Trama del limite decisionale per un percettrone

11

Sto cercando di tracciare il confine decisionale di un algoritmo perceptron e sono davvero confuso su alcune cose. Le mie istanze di input sono nella forma , sostanzialmente un'istanza di input 2D ( e ) e un valore target della classe binaria ( ) [1 o 0]. $[(x_{1},x_{2}), y]$ $x_{1}$ $x_{2}$ $y$

Il mio vettore di peso è quindi nella forma: . $[w_{1}, w_{2}]$

Ora devo incorporare un ulteriore parametro di polarizzazione e quindi il mio vettore di peso diventa un vettore ? è vettoriale? Penso che dovrebbe essere poiché un vettore ha solo 1 riga e n colonne. $w_{0}$ $3 \times 1$ $1 \times 3$ $1 \times 3$

Ora diciamo che ho un'istanza di su valori casuali, come potrei tracciare il confine decisionale per questo? Che cosa significa qui ? È la distanza della regione decisione dall'origine? In tal caso, come posso catturarlo e tracciarlo in Python usando matplotlib.pyplot o il suo equivalente Matlab? $[w_{0}, w_{1}, w_{2}]$ $w_{0}$ $w_{0}/norm(w)$

Gradirei davvero anche un piccolo aiuto per quanto riguarda questa questione.

— user2502020
fonte

16

Il modo in cui il percettrone prevede l'output in ciascuna iterazione è seguendo l'equazione:

y_{j} = f [w^{T} X] = f [\vec{w} \cdot \vec{X}] = f [w_{0} + w_{1} X_{1} + w_{2} X_{2} + . . . + w_{n} X_{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}]$

Come hai detto, il tuo peso contiene un termine di errore . Pertanto, è necessario includere un nell'input per preservare le dimensioni nel prodotto punto. $\vec{w}$ $w_{0}$ $1$

Di solito si inizia con un vettore di colonna per i pesi, ovvero un vettore . Per definizione, il prodotto punto richiede di trasporre questo vettore per ottenere un vettore peso e per integrare quel prodotto punto è necessario un vettore input . Ecco perché ha enfatizzato il cambiamento tra notazione matriciale e notazione vettoriale nell'equazione sopra, in modo da poter vedere come la notazione suggerisce le giuste dimensioni. $n \times 1$ $1 \times n$ $n \times 1$

Ricorda, questo viene fatto per ogni input che hai nel set di allenamento. Successivamente, aggiorna il vettore di peso per correggere l'errore tra l'uscita prevista e l'uscita reale.

Per quanto riguarda il limite di decisione, ecco una modifica del codice di apprendimento di Scikit che ho trovato qui :

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

che produce il seguente diagramma:

inserisci qui la descrizione dell'immagine

Fondamentalmente, l'idea è di predire un valore per ogni punto in una mesh che copre ogni punto e tracciare ogni previsione con un colore appropriato usando contourf.

— Robert Smith
fonte

0

Recentemente stavo cercando di implementare la stessa cosa, ma sono troppo confuso su come disegnare la trama del confine decisionale con tre pesi $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')

— Rubanraj Ravichandran
fonte