Neuronales Netzwerk

[Xaby]

schauste hier

http://fbim.fh-regensburg.de/~saj39122/ ... 20102.html

[Little John]

OK:
http://mypage.bluewin.ch/remimeier/Tutorial/Tut3.pdf

Der Link funktioniert leider nicht mehr.

remi_meier, bist Du noch da?
Das Thema interessiert mich, wie kann ich an Dein Tutorial kommen?

Gruß, Little John

[remi_meier]

Jo, bin teilweise noch hier
Ich machs mir mal einfach und linke mal hier hin:
http://web.archive.org/web/*/http://myp ... l/Tut3.pdf

Fand es gerade selber amüsant, das wieder mal zu lesen.

[Little John]

Super. Herzlichen Dank!!

Gruß, Little John

[°°°]

Hi

Erstmal super beispiel. Ich habe schon länger nach einem beispiel für ein neuronales netzt gesucht.

Bei mir hakt es bloß gerade bei einer Sache.

Bei der Berechnung der fehler was genau macht das ( "* Outputs(z) * (1.0 - Outputs(z))" oder das "* VNeurons(z1) * (1.0 - VNeurons(z1))" )

Code: Alles auswählen

OFehler(z) = (SollOutputs(z) - Outputs(z)) * Outputs(z) * (1.0 - Outputs(z)) 
VFehler(z1) =  Fehler1 * VNeurons(z1) * (1.0 - VNeurons(z1))

Ich habe mal ein bisschen rumprobiert und wenn ich das "* Outputs(z) * (1.0 - Outputs(z))" auskommentiere brauche ich weniger lerndurchläufe für bessere ergebnisse.
Wenn ich allerdings "* VNeurons(z1) * (1.0 - VNeurons(z1))" auskommentiere erhöht sich die fehlerquote drastisch.

Woran das liegt keine ahnung. Hoffe du kannst mir helfen.

mfg °°°

[remi_meier]

Da liest doch tatsächlich jemand meine alten Codes .

Ich mach's mal kurz: Ich denke, mein alter Code oben
ist falsch und hier ist die richtige Version:

Code: Alles auswählen

Procedure.f Berechne_Fehler()  ;Rückwärts 1, gibt den MaximalFehler zurück
  Protected MaxFehler.f    ;um zu erkennen, wann der maximale Fehler innerhalb der Toleranz #Toleranz liegt
  
  For z = 1 To #a   ;Fehler für 2. Gewichtsschicht
    OFehler(z) = (SollOutputs(z) - Outputs(z))     ;fülle Fehler-Array der Outputschicht
    
    ; If Abs(OFehler(z)) > Abs(MaxFehler)   ;Maximaler Fehler herausfinden
      ; MaxFehler = OFehler(z)
    ; EndIf
  Next
  
  For z1 = 1 To #v    ;für jedes Neuron der verb. Schicht
    Fehler1.f = 0     ;mit 0 initialisieren
    For z2 = 1 To #a  ;Fehler 1 berechnen
      Fehler1 = Fehler1 + OFehler(z2) * VNeurons(z1) * Gewichte2(z1, z2)  ;Fehler aufsummieren
    Next
    VFehler(z1) =  Fehler1    ;fülle Fehlerarray der verb. Schicht
  Next
  
  ProcedureReturn MaxFehler
EndProcedure

Man beachte nebst deinen oben genannten Entfernungen der
komischen Terme das Einfügen des Faktors "VNeurons(z1)"
in der verschachtelten For-Schleife. Das ist die vorgezogene
Delta-Regel der "Gewichte_anpassen()"-Prozedur. Damit habe
ich weitaus bessere Resultate.

Disclaimer: Ich weiss nicht, was ich mir damals gedacht habe
und woher ich die Informationen bezogen habe. Deshalb ist
diese Korrektur mit Vorsicht zu geniessen, da sie aus reiner
Intuition folgt. Wobei ich hoffe, dass meine Intuition mit den
Jahren besser wurde

Ich hoffe, das hilft dir ein wenig.

greetz
remi

[°°°]

Ja,
jetzt ergibt das ganze mehr sinn. Kann es zwar im Momment nicht testen,
aber sobald ich nach Hause komme mache ich das.

Ich lesen deinen Code weil er das einzige beispiel für ein funktionierendes KNN ist. Ansonsten findet man ja nur Theorie, aber nie ein vernüftiges beispiel.
Deshalb noch mal danke du hast mir damit weitergeholfen.

mfg °°°

[°°°]

Hi

habe mal ein bisschen getestet. Und das hier ist die version mit dem besten ergebnis. Auf 10k Lerndurchläufen 100% trefferquote.
Das heißt nur bei der Fehlerberechnung des Outputs die Multiplikation rausnehmen.

Code: Alles auswählen

Procedure.f Berechne_Fehler()  ;Rückwärts 1, gibt den MaximalFehler zurück
  Protected MaxFehler.f    ;um zu erkennen, wann der maximale Fehler innerhalb der Toleranz #Toleranz liegt
 
  For z = 1 To #a   ;Fehler für 2. Gewichtsschicht
    OFehler(z) = (SollOutputs(z) - Outputs(z))     ;fülle Fehler-Array der Outputschicht
   
    ; If Abs(OFehler(z)) > Abs(MaxFehler)   ;Maximaler Fehler herausfinden
      ; MaxFehler = OFehler(z)
    ; EndIf
  Next
 
  For z1 = 1 To #v    ;für jedes Neuron der verb. Schicht
    Fehler1.f = 0     ;mit 0 initialisieren
    For z2 = 1 To #a  ;Fehler 1 berechnen
      Fehler1 = Fehler1 + OFehler(z2)  * Gewichte2(z1, z2)  ;Fehler aufsummieren
    Next
    VFehler(z1) =  Fehler1 * VNeurons(z1) * (1.0 - VNeurons(z1))   ;fülle Fehlerarray der verb. Schicht
  Next
 
  ProcedureReturn MaxFehler
EndProcedure

Mich würde jetzt nur interressieren wie man auf " * VNeurons(z1) * (1.0 - VNeurons(z1)) " kommt. Aber da ich nicht verlagen kann das du dich noch daran errinnerst werde ich es wohl als gegeben hinnehmen müssen.
Wenn aber irgendjemand weiß woher das kommt bitte sagen.

mfg °°