Gráfico de limite de decisão para um perceptron

11

Estou tentando traçar o limite de decisão de um algoritmo perceptron e estou realmente confuso sobre algumas coisas. Minhas instâncias de entrada estão no formato , basicamente uma instância de entrada 2D ( x 1 e x 2 ) e um valor alvo de classe binária ( y ) [1 ou 0].[(x1 1,x2),y]x1 1x2y

Meu vetor de peso, portanto, está na forma: .[W1 1,W2]

Agora eu tenho que incorporar um parâmetro de viés adicional e, portanto, meu vetor de peso se torna um vetor 3 × 1 ? é vetor 1 × 3 ? Eu acho que deveria ser 1 × 3, pois um vetor tem apenas 1 linha e n colunas.W0 03×1 11 1×31 1×3

Agora, digamos que eu instancie a valores aleatórios, como eu traçaria o limite de decisão para isso? Significado o que w 0 significa aqui? É w 0 / n o r m ( w ) a distância da região de decisão da origem? Se sim, como capturar isso e plotá-lo em Python usando matplotlib.pyplot ou seu equivalente Matlab?[W0 0,W1 1,W2]W0 0W0 0/norm(W)

Eu realmente gostaria de receber uma pequena ajuda sobre esse assunto.

user2502020
fonte

Respostas:

16

A maneira como o perceptron prevê a saída em cada iteração é seguindo a equação:

yj=f[WTx]=f[Wx]=f[W0 0+W1 1x1 1+W2x2+...+Wnxn]

WW0 01 1

n×1 11 1×nn×1 1

Lembre-se, isso é feito para cada entrada que você tem no conjunto de treinamento. Depois disso, atualize o vetor de ponderação para corrigir o erro entre a saída prevista e a saída real.

Quanto ao limite de decisão, aqui está uma modificação do código de aprendizado do scikit que encontrei aqui :

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

que produz o seguinte gráfico:

insira a descrição da imagem aqui

Basicamente, a idéia é prever um valor para cada ponto em uma malha que cubra todos os pontos e plotar cada previsão com uma cor apropriada contourf.

Robert Smith
fonte
0

W0 0,W1 1,W2 . E, com base em outra solução, escrevi o código python matplotlib para desenhar uma linha de fronteira que classifica duas classes.

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

perceptron simples classifica duas classes diferentes

Rubanraj Ravichandran
fonte