Tracé des limites de décision pour un perceptron

J'essaie de tracer la frontière de décision d'un algorithme perceptron et je suis vraiment confus à propos de quelques choses. Mes instances d'entrée sont sous la forme , essentiellement une instance d'entrée 2D ( et ) et une valeur cible de classe binaire ( ) [1 ou 0].$[(x_{1},x_{2}), y]$$x_{1}$$x_{2}$$y$

Mon vecteur de poids se présente donc sous la forme: .$[w_{1}, w_{2}]$

Maintenant, je dois incorporer un paramètre de biais supplémentaire et donc mon vecteur de poids devient un vecteur ? est-ce vecteur? Je pense que cela devrait être car un vecteur n'a que 1 ligne et n colonnes.$w_{0}$$3 \times 1$$1 \times 3$$1 \times 3$

Supposons maintenant que j'instancie en valeurs aléatoires, comment pourrais-je tracer la frontière de décision pour cela? signifie ici? Est la distance de la région de décision de l'origine? Si oui, comment puis-je capturer cela et le tracer en Python en utilisant matplotlib.pyplot ou son équivalent Matlab?$[w_{0}, w_{1}, w_{2}]$$w_{0}$$w_{0}/norm(w)$

J'apprécierais vraiment même un peu d'aide à ce sujet.

La façon dont le perceptron prédit la sortie à chaque itération est en suivant l'équation:

$$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}]$$

Comme vous l'avez dit, votre poids contient un terme de biais . Par conséquent, vous devez inclure un dans l'entrée pour conserver les dimensions dans le produit scalaire.$\vec{w}$$w_{0}$$1$

Vous commencez généralement par un vecteur de colonne pour les poids, c'est-à-dire un vecteur . Par définition, le produit scalaire nécessite que vous transposiez ce vecteur pour obtenir un vecteur de poids et pour compléter ce produit scalaire, vous avez besoin d'un vecteur d'entrée . C'est pourquoi a souligné le changement entre la notation matricielle et la notation vectorielle dans l'équation ci-dessus, afin que vous puissiez voir comment la notation vous suggère les bonnes dimensions.$n \times 1$$1 \times n$$n \times 1$

N'oubliez pas que cela se fait pour chaque entrée que vous avez dans l'ensemble de formation. Ensuite, mettez à jour le vecteur de poids pour corriger l'erreur entre la sortie prévue et la sortie réelle.

En ce qui concerne la limite de décision, voici une modification du code d'apprentissage scikit que j'ai trouvé ici :

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')

qui produit le tracé suivant:

Fondamentalement, l'idée est de prédire une valeur pour chaque point dans un maillage qui couvre chaque point et de tracer chaque prédiction avec une couleur appropriée en utilisant contourf.

Récemment, j'essayais d'implémenter la même chose, mais je ne savais pas trop comment dessiner le tracé de la limite de décision avec trois poids . Et sur la base d'une autre solution, j'ai écrit du code python matplotlib pour dessiner une ligne de délimitation qui classe deux classes.$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')