Entscheidungsgrenzdiagramm für ein Perzeptron

Ich versuche, die Entscheidungsgrenze eines Perzeptron-Algorithmus zu zeichnen, und bin über einige Dinge wirklich verwirrt. Meine Eingabeinstanzen haben die Form , im Grunde eine 2D-Eingabeinstanz ( x 1 und x 2 ) und einen Binärklassenzielwert ( y ) [1 oder 0].$[(x_{1},x_{2}), y]$$x_{1}$$x_{2}$$y$

Mein Gewichtsvektor hat daher die Form: .$[w_{1}, w_{2}]$

Jetzt muss ich einen zusätzlichen Bias-Parameter einbauen und daher wird mein Gewichtsvektor ein 3 × 1- Vektor? ist es 1 × 3 Vektor? Ich denke, es sollte 1 × 3 sein, da ein Vektor nur 1 Zeile und n Spalten hat.$w_{0}$$3 \times 1$$1 \times 3$$1 \times 3$

Nehmen wir nun an, ich instanziiere auf zufällige Werte. Wie würde ich die Entscheidungsgrenze dafür darstellen? Was bedeutet w 0 hier? Ist w 0 / n o r m ( w ) der Abstand des Entscheidungsbereichs vom Ursprung? Wenn ja, wie kann ich dies erfassen und in Python mit matplotlib.pyplot oder seinem Matlab-Äquivalent zeichnen?$[w_{0}, w_{1}, w_{2}]$$w_{0}$$w_{0}/norm(w)$

Ich würde mich sehr über eine kleine Hilfe in dieser Angelegenheit freuen.

Die Art und Weise, wie das Perzeptron die Ausgabe in jeder Iteration vorhersagt, folgt der folgenden Gleichung:

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

$\vec{w}$$w_{0}$$1$

$n \times 1$$1 \times n$$n \times 1$

Denken Sie daran, dass dies für jede Eingabe im Trainingssatz erfolgt. Aktualisieren Sie anschließend den Gewichtsvektor, um den Fehler zwischen der vorhergesagten Ausgabe und der tatsächlichen Ausgabe zu korrigieren.

In Bezug auf die Entscheidungsgrenze gibt es hier eine Modifikation des Scikit-Lerncodes, den ich hier gefunden habe :

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

welches das folgende Diagramm erzeugt:

Grundsätzlich besteht die Idee darin, einen Wert für jeden Punkt in einem Netz vorherzusagen, der jeden Punkt abdeckt, und jede Vorhersage mit einer geeigneten Farbe zu zeichnen contourf.

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