Lernen von ANN in Matlab (Mehrschicht-Backpropagation)

Question

Ich schreibe diesen Code für den Lernprozess von ANN (Mehrschicht-Backpropagation), aber das Ergebnis des Lernens ist sehr schlecht, es ist zu keiner Zeit nahe 1 Ich weiß, dass wir keine Garantie geben können, um erfolgreich zu lernen, aber ich möchte wissen, ob ich etwas Fehler in diesem Code mache oder ob ich diese Schritte mit mehr Leistung machen kann.

Schritte:

1- Mein-Datensatz

2- 170 Zeilen aus 225 für das Lernen wählen, und der Rest 50 Zeilen für das Testen (zufällig)

3- schaffen Gewichte für Eingänge und versteckt Schichten zufällig zwischen 0 und 1

4- Bias für versteckte und Ausgang zwischen -1 und 1

5- finden die zufällig Schichten erstellen Ausgabe für jede für jeden Ausgang

6- Fehlersuche Zeile dann für jede versteckte Schicht

7- Aktualisierungs Gewichte und Bias-Arrays bei jeder Iteration

8- die Summation von quadratischen Fehler (MSE), berechnet auf jede Iteration.

Das Ergebnis für jeden Ausgang immer zwischen .2 und .5 auch nicht für die gewünschte Ausgabe. Was ist der mögliche Fehler bei meiner Logik oder bei meinem Code hier !!

Anmerkungen: 1- (Ich verwende Datensatz mit 225 Zeilen mit 108 Spalten und 25 Ergebnisse als Klassen) 170 Zeilen für das Lernen 55 Zeilen für das Testen

2- 50.000 Iterationen

3- Lernrate 0,3

4- Impulses = 0,7

5- verborgene Schicht ne. no = 90

Code:

%Initialize the weight matrices with random weights 

V = rand(inlayer,hlayer); % Weight matrix from Input to Hidden between [0,1] 

W = rand(hlayer,olayer); % Weight matrix from Hidden to Output between [0,1] 

%Initialize the theta matrices for hidden and output layers 
Thetahidden = randi(1,hlayer); 
Thetaoutput = randi(1,olayer); 

for i=1:iteration 


for j=1:170 % depends on training data set 
    %This for output between input-hidden 
    for h=1:hlayer % depends on neuron number at hidden layer 
     sum = 0; 
     for k=1:108 % depends on column number 
      sum = sum + (V(k,h)* trainingdata(j,k)); 
     end 
     H(h) = sum + Thetahidden(h); 
     Oh(h) = 1/(1+exp(-H(h))); 
    end 
    %This for output between hidden-output 
    for o=1:olayer % depends on number of output layer 
     sumO = 0; 
     for hh=1:hlayer 
      sumO = sumO+W(hh,o)*Oh(hh); 
     end 
     O(o)=sumO + Thetaoutput(o); 
     OO(o) = 1/(1+exp(-O(o))); 

     finaloutputforeachrow(j,o)= OO(o); 

    end 

    % Store real value of real output 
    for r=1:170 
     for o=1:olayer 
      i=outputtrainingdata(r); 
     if i == o 
      RO(r,o)=1; 
     else 
      RO(r,o)=0; 
     end 
     end 
    end 


    sumerror =0; 


    % Compute Error (output layer) 
    for errorout=1:olayer 

     lamdaout(errorout) = OO(errorout)*(1-OO(errorout))*(RO(j,errorout)-OO(errorout)); 
     errorrate = RO(j,errorout)-OO(errorout); 
     sumerror = sumerror+(errorrate^2); 
     FinalError(j,errorout) = errorrate; 
    % Compute Error (hidden layer) 
    ersum=0; 
    for errorh=1:hlayer 
     ersum= lamdaout(errorout)*W(errorh,errorout); 
     lamdahidden(errorh)= Oh(errorh)*(1-Oh(errorh))*ersum; 
    end 
    FinalSumError(j) = (1/2)*sumerror; 
    end 

    %update weights between input and hidden layer 
    for h=1:hlayer 
     for k=1:108 
      deltaw(k,h) = learningrate*lamdahidden(h)*trainingdata(j,k); 
      V(k,h) = (m*V(k,h)) + deltaw(k,h); 
     end 
    end 

    %update weights/Theta between hidden and output layer 
    for h=1:hlayer 
     for outl=1:olayer 
      %weight 
      deltaw2(h,outl) = learningrate * lamdaout(outl)*Oh(h); 
      W(h,outl)= (m*W(h,outl))+deltaw2(h,outl); 

     end 
    end 

    for h=1:hlayer 
      %Theta-Hidden 
      deltaHiddenTh(h) = learningrate * lamdahidden(h); 
      Thetahidden(h) = (m*Thetahidden(h)) + deltaHiddenTh(h); 
    end 

    for outl=1:olayer 

      %Theta-Output 
      deltaOutputTh(outl) = learningrate * lamdaout(outl); 
      Thetaoutput(outl) = (m*Thetaoutput(outl)) + deltaOutputTh(outl); 
    end 





end 


end 

Answer 1

Es gibt viele Dinge, die die Leistung (und letztendlich die Konvergenz) von neuronalen Netzen beeinflussen. Neben der Nähe Blick auf Ihren Code mit und stellen Sie sicher, dass der Prozess richtig codiert ist, können Sie einige Ideen spielen, um und denken:

• Der Bereich der Initialisierung der Gewichte auf die in Beziehung gesetzt werden sollte Eingaben, die das Netz verarbeiten soll have a look here. Gibt es einen Grund, warum im Bereich [0,1], wenn die Eingänge im Bereich [-1,1] liegen?

• Der Impulswert kann einen großen Einfluss auf die Konvergenz haben. Probieren Sie verschiedene Werte aus.

• Eine nette Übung, um ein Gefühl für einen schönen Lernprozess zu haben, ist die learning curve, d. H. Der Fehler (MSE in Ihrem Fall) gegen die Trainingsepoche zu plotten. Es gibt gesunde Muster, die Ihnen einen Hinweis geben können, was passiert.

• Die Tatsache, dass die Anfangsgewichte zufällig gesetzt sind, kann (abhängig von der Komplexität des Problems) zu unterschiedlichen Konvergenzpunkten führen. Es ist hilfreich, eine Vorstellung davon zu haben, wie groß dieser Unterschied sein kann: Trainiere einfach das Netz, trainiere es mehrmals und zeichne die Unterschiede auf.

Es gibt immer noch die Anzahl der versteckten Neuronen und alle Art von Schrauben müssen Sie anpassen, bevor es funktioniert, aber auf den ersten Blick scheint es, wie Sie ein sehr komplexes Problem (108 Spalten und 25 Ergebnisse haben als Klassen) mit einem zu kleinen Datensatz zu trainieren (225). Wenn das der Fall ist, brauchen Sie vielleicht mehr Daten ... Oder versuchen Sie eine andere Art von Modell anstelle von neuronalen Netzen.

Hoffe es hilft, viel Spaß!