Creazione di un percetron del treno in matlab per la clasifficazione di genere

Question

Sto codificando un percetron per imparare a classificare il genere nelle immagini dei volti. Sono molto nuovo in Matlab, quindi ho bisogno di molto aiuto. Ho alcune domande:

1. Sto cercando di programmare per una funzione:

   function [y] = testset(x,w)  
   %y = sign(sigma(x*w-threshold))
   

   Dove Y è i risultati previsti, X è il set di allenamento/test inserito come matrice molto grande e W è peso sull'equazione. La parte dopo il % è quello che sto cercando di scrivere, ma non so come scrivere questo con il codice Matlab. Qualche idea là fuori?

2. Sto cercando di codificare una seconda funzione:

   function [err] = testerror(x,w,y)  
   %err = sigma(max(0,-w*x*y))
   

   W, X e Y hanno gli stessi valori sopra indicati, ed ERR è la mia funzione di errore, che sto cercando di minimizzare attraverso i passaggi del perceptron.

3. Sto cercando di creare un passo nel mio percetrone per ridurre la percentuale di errore usando la discesa gradiente sulla mia equazione originale. Qualcuno sa come posso incrementare W usando la discesa gradiente per ridurre al minimo la funzione di errore utilizzando un'istruzione If Then?

Posso mettere il codice che ho fino ad ora se questo ti aiuterebbe a rispondere a queste domande.

Grazie!

modificare--------------------------

Ok, quindi sto ancora lavorando al codice per questo e vorrei metterlo quando ho qualcosa di più completo. La mia più grande domanda in questo momento è:

Ho la seguente funzione:

function [y] = testset(x,w)  
y = sign(sum(x*w-threshold))

Ora so che dovrei mettere una soglia, ma non riesco a capire cosa dovrei mettere come soglia! Qualche idea là fuori?

modificare----------------------------
Questo è quello che ho finora. Le modifiche devono ancora essere apportate ad esso, ma apprezzerei l'input, specialmente per quanto riguarda la struttura e consigli per apportare le modifiche che devono essere apportate!

function [y] = Perceptron_Aviva(X,w)
y = sign(sum(X*w-1));
end

function [err] = testerror(X,w,y)
    err = sum(max(0,-w*X*y));
end

%function [w] = perceptron(X,Y,w_init)
%w = w_init;
%end

%------------------------------

% input samples
X = X_train;

% output class [-1,+1];
Y = y_train;

% init weigth vector
w_init = zeros(size(X,1));
w = w_init;


%---------------------------------------------
loopcounter = 0

while abs(err) > 0.1 && loopcounter < 100

    for j=1:size(X,1)

        approx_y(j) = Perceptron_Aviva(X(j),w(j))

        err = testerror(X(j),w(j),approx_y(j))

        if err > 0 %wrong (structure is correct, test is wrong)
            w(j) = w(j) - 0.1 %wrong
        elseif err < 0 %wrong
            w(j) = w(j) + 0.1 %wrong
        end

       % -----------
       % if sign(w'*X(:,j)) ~= Y(j) %wrong decision?
       %      w = w + X(:,j) * Y(j);   %then add (or subtract) this point to w
    end

Answer 1

puoi leggere questo domanda L'ho fatto qualche tempo fa.

Uso un codice matlab e una funzione perceptron

function [w] = perceptron(X,Y,w_init)

w = w_init;
for iteration = 1 : 100  %<- in practice, use some stopping criterion!
  for ii = 1 : size(X,2)         %cycle through training set
    if sign(w'*X(:,ii)) ~= Y(ii) %wrong decision?
      w = w + X(:,ii) * Y(ii);   %then add (or subtract) this point to w
    end
  end
  sum(sign(w'*X)~=Y)/size(X,2)   %show misclassification rate
end

ed è chiamato dal codice (@Itamar Katz) come (dati casuali):

% input samples
X1=[rand(1,100);rand(1,100);ones(1,100)];   % class '+1'
X2=[rand(1,100);1+rand(1,100);ones(1,100)]; % class '-1'
X=[X1,X2];

% output class [-1,+1];
Y=[-ones(1,100),ones(1,100)];

% init weigth vector
w=[.5 .5 .5]';

% call perceptron
wtag=perceptron(X,Y,w);
% predict
ytag=wtag'*X;


% plot prediction over origianl data
figure;hold on
plot(X1(1,:),X1(2,:),'b.')
plot(X2(1,:),X2(2,:),'r.')

plot(X(1,ytag<0),X(2,ytag<0),'bo')
plot(X(1,ytag>0),X(2,ytag>0),'ro')
legend('class -1','class +1','pred -1','pred +1')

Immagino che questo possa darti un'idea di fare le funzioni che hai descritto. All'errore confronta il risultato atteso con il risultato reale (classe)

Answer 2

Supponiamo che il set di dati sia X, i datapoin e y, le etichette delle classi.

f=newp(X,Y)

Crea un percetron.

Se vuoi creare un MLP, allora:

f=newff(X,Y,NN)

Dove NN è l'architettura di rete, cioè un array che designa il numero di neuroni in ogni livello nascosto. Per esempio

NN=[5 3 2]

corrisponderà a una rete con 5 neuroni ai primi strati, 3 al secondo e 2 a il terzo livello nascosto.

Answer 3

Bene, ciò che chiami soglia è la distorsione nella nomenclatura dell'apprendimento automatico. Questo dovrebbe essere lasciato come input per l'utente perché viene utilizzato durante l'allenamento.

Inoltre, mi chiedo perché non stai usando le funzioni Matlab incorporate. cioè Newp o Newff. per esempio

ff=newp(X,Y)

Quindi è possibile impostare le proprietà dell'oggetto FF per svolgere il tuo lavoro per selezionare la discesa gradiente e così via.