Wykres graniczny decyzji dla perceptronu

11

Próbuję wykreślić granicę decyzyjną algorytmu perceptronowego i jestem naprawdę zdezorientowany co do kilku rzeczy. Moje instancje wejściowe mają postać , w zasadzie instancję wejściową 2D ( i x_ {2} ) oraz wartość docelową klasy binarnej ( y ) [1 lub 0].[(x1,x2)),y]x1x2)y

Mój wektor ciężaru ma zatem postać: [w1,w2)] .

Teraz muszę wprowadzić dodatkowy parametr odchylenia w0 a zatem mój wektor wagi staje się wektorem 3)×1 ? czy to jest wektor 1×3) ? Myślę, że powinno to być 1×3) ponieważ wektor ma tylko 1 wiersz i n kolumn.

Powiedzmy teraz, że tworzę instancję [w0,w1,w2)] na losowe wartości, jak wykreślić granicę decyzji? Co oznacza w0 tutaj? Czy w0/norm(w) odległość regionu decyzyjnego od źródła? Jeśli tak, to jak to uchwycić i wydrukować w Pythonie za pomocą matplotlib.pyplot lub jego odpowiednika Matlab?

Byłbym bardzo wdzięczny nawet za niewielką pomoc w tej sprawie.

użytkownik2502020
źródło

Odpowiedzi:

17

Sposób, w jaki perceptron przewiduje wynik w każdej iteracji, jest następujący:

yjot=fa[wT.x]=fa[wx]=fa[w0+w1x1+w2)x2)+...+wnxn]

Jak już powiedziałeś, twoja waga zawiera termin odchylenia w 0 . Dlatego musisz wprowadzić 1 na wejściu, aby zachować wymiary w produkcie kropkowym.ww01

Zwykle zaczynasz od wektora kolumny dla wag, czyli wektora . Z definicji iloczyn skalarny wymaga transponowania tego wektora, aby uzyskać wektor wagi 1 × n, a do uzupełnienia tego iloczynu potrzebny jest wektor wejściowy n × 1 . Dlatego podkreślono zmianę między notacją macierzową a notacją wektorową w powyższym równaniu, abyś mógł zobaczyć, jak notacja sugeruje odpowiednie wymiary.n×11×nn×1

Pamiętaj, że odbywa się to dla każdego wkładu, który masz w zestawie treningowym. Następnie zaktualizuj wektor ciężaru, aby poprawić błąd między przewidywaną mocą wyjściową a rzeczywistą mocą wyjściową.

Jeśli chodzi o granicę decyzji, oto modyfikacja kodu do nauki scikit, który znalazłem tutaj :

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

który produkuje następujący wykres:

wprowadź opis zdjęcia tutaj

Zasadniczo chodzi o to, aby przewidzieć wartość dla każdego punktu w siatce pokrywającej każdy punkt i narysować każdą prognozę za pomocą odpowiedniego koloru contourf.

Robert Smith
źródło
0

w0,w1,w2)

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

prosty perceptron klasyfikuje dwie różne klasy

Rubanraj Ravichandran
źródło