Gráfico de límites de decisión para un perceptrón

Estoy tratando de trazar el límite de decisión de un algoritmo de perceptrón y estoy realmente confundido acerca de algunas cosas. Mis instancias de entrada tienen la forma , básicamente una instancia de entrada 2D ( y ) y un valor objetivo de clase binaria ( ) [1 o 0].x 1 x 2$[(x_{1},x_{2}), y]$$x_{1}$$x_{2}$$y$

Por lo tanto, mi vector de peso tiene la forma: .$[w_{1}, w_{2}]$

¿Ahora tengo que incorporar un parámetro de sesgo adicional y, por lo tanto, mi vector de peso se convierte en un vector ? ¿Es vectores? Creo que debería ser ya que un vector tiene solo 1 fila yn columnas. 3 × 1 1 × 3 1 × $w_{0}$$3 \times 1$$1 \times 3$$1 \times 3$

Ahora supongamos que instancia a valores aleatorios, ¿cómo el límite de decisión para esto? ¿Qué significa aquí? ¿Es la distancia de la región de decisión desde el origen? Si es así, ¿cómo capturo esto y lo trazo en Python usando matplotlib.pyplot o su equivalente en Matlab?w 0 w 0 / n o r m ( w $[w_{0}, w_{1}, w_{2}]$$w_{0}$$w_{0}/norm(w)$

Realmente agradecería incluso un poco de ayuda con respecto a este asunto.

La forma en que el perceptrón predice la salida en cada iteración es siguiendo la ecuación:

$$y_{j} = f[{\bf{w}}^{T} {\bf{x}}] = f[\vec{w}\cdot \vec{x}] = f[w_{0} + w_{1}x_{1} + w_{2}x_{2} + ... + w_{n}x_{n}]$$

Como dijiste, tu peso contiene un término de sesgo . Por lo tanto, debe incluir un en la entrada para preservar las dimensiones en el producto escalar. w0$\vec{w}$$w_{0}$$1$

Por lo general, comienza con un vector de columna para los pesos, es decir, un vector . Por definición, el producto de puntos requiere que transponga este vector para obtener un vector de peso y para complementar ese producto de puntos necesita un vector de entrada . Es por eso que enfatizó el cambio entre la notación matricial y la notación vectorial en la ecuación anterior, para que pueda ver cómo la notación le sugiere las dimensiones correctas.1 × n n × $n \times 1$$1 \times n$$n \times 1$

Recuerde, esto se hace para cada entrada que tenga en el conjunto de entrenamiento. Después de esto, actualice el vector de peso para corregir el error entre la salida predicha y la salida real.

En cuanto al límite de decisión, aquí hay una modificación del código de aprendizaje de scikit que encontré aquí :

import numpy as np
from sklearn.linear_model import Perceptron
import matplotlib.pyplot as plt

X = np.array([[2,1],[3,4],[4,2],[3,1]])
Y = np.array([0,0,1,1])
h = .02  # step size in the mesh


# we create an instance of SVM and fit our data. We do not scale our
# data since we want to plot the support vectors

clf = Perceptron(n_iter=100).fit(X, Y)

# create a mesh to plot in
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))

# Plot the decision boundary. For that, we will assign a color to each
# point in the mesh [x_min, m_max]x[y_min, y_max].
fig, ax = plt.subplots()
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])

# Put the result into a color plot
Z = Z.reshape(xx.shape)
ax.contourf(xx, yy, Z, cmap=plt.cm.Paired)
ax.axis('off')

# Plot also the training points
ax.scatter(X[:, 0], X[:, 1], c=Y, cmap=plt.cm.Paired)

ax.set_title('Perceptron')

que produce la siguiente trama:

Básicamente, la idea es predecir un valor para cada punto en una malla que cubra cada punto, y trazar cada predicción con un color apropiado usando contourf.

Recientemente estaba tratando de implementar lo mismo, pero estaba demasiado confundido sobre cómo dibujar el diagrama de límites de decisión con tres pesos . Y en base a otra solución, he escrito código python matplotlib para dibujar una línea límite que clasifica dos clases.$w_0,w_1,w_2$

def plot_data(self,inputs,targets,weights):
    # fig config
    plt.figure(figsize=(10,6))
    plt.grid(True)

    #plot input samples(2D data points) and i have two classes. 
    #one is +1 and second one is -1, so it red color for +1 and blue color for -1
    for input,target in zip(inputs,targets):
        plt.plot(input[0],input[1],'ro' if (target == 1.0) else 'bo')

    # Here i am calculating slope and intercept with given three weights
    for i in np.linspace(np.amin(inputs[:,:1]),np.amax(inputs[:,:1])):
        slope = -(weights[0]/weights[2])/(weights[0]/weights[1])  
        intercept = -weights[0]/weights[2]

        #y =mx+c, m is slope and c is intercept
        y = (slope*i) + intercept
        plt.plot(i, y,'ko')