Plot batas keputusan untuk perceptron

Saya mencoba untuk merencanakan batas keputusan algoritma perceptron dan saya benar-benar bingung tentang beberapa hal. Contoh input saya adalah dalam bentuk , pada dasarnya contoh input 2D ( x 1 dan x 2 ) dan nilai target kelas biner ( y ) [1 atau 0].$[(x_{1},x_{2}), y]$$x_{1}$$x_{2}$$y$

Vektor berat badan saya maka dalam bentuk: .$[w_{1}, w_{2}]$

Sekarang saya harus memasukkan parameter bias tambahan dan karenanya vektor bobot saya menjadi vektor 3 × 1 ? apakah 1 × 3 vektor? Saya pikir itu harus 1 × 3 karena vektor hanya memiliki 1 baris dan kolom n.$w_{0}$$3 \times 1$$1 \times 3$$1 \times 3$

Sekarang katakanlah saya instantiate ke nilai acak, bagaimana saya merencanakan batas keputusan untuk ini? Berarti apa yang ditandai dengan 0 di sini? Apakah w 0 / n o r m ( w ) jarak wilayah keputusan dari asal? Jika demikian, bagaimana saya menangkap ini dan memplotnya dengan Python menggunakan matplotlib.pyplot atau yang setara dengan Matlab?$[w_{0}, w_{1}, w_{2}]$$w_{0}$$w_{0}/norm(w)$

Saya akan sangat menghargai bahkan sedikit bantuan mengenai masalah ini.

Cara perceptron memprediksi output di setiap iterasi adalah dengan mengikuti persamaan:

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

Ingat, ini dilakukan untuk setiap input yang Anda miliki di set pelatihan. Setelah ini, perbarui vektor bobot untuk memperbaiki kesalahan antara output yang diprediksi dan output nyata.

Adapun batas keputusan, berikut adalah modifikasi dari kode belajar scikit yang saya temukan di sini :

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

yang menghasilkan plot berikut:

Pada dasarnya, idenya adalah untuk memprediksi nilai untuk setiap titik dalam mesh yang mencakup setiap titik, dan plot setiap prediksi dengan menggunakan warna yang sesuai 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')