PureBoard

Verfasst: **11.04.2007 10:30**

schauste hier

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

Verfasst: **03.05.2010 19:27**

remi_meier hat geschrieben: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

Verfasst: **03.05.2010 23:08**

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.

Verfasst: **04.05.2010 06:20**

Super. Herzlichen Dank!!

Gruß, Little John

Verfasst: **31.10.2010 13:41**

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 °°°

Verfasst: **02.11.2010 00:16**

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

Verfasst: **02.11.2010 12:29**

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 °°°

Verfasst: **02.11.2010 19:34**

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 °°

PureBoard

Neuronales Netzwerk

Re:

Re: Neuronales Netzwerk

Re: Neuronales Netzwerk

Re: Neuronales Netzwerk

Re: Neuronales Netzwerk

Re: Neuronales Netzwerk

Re: Neuronales Netzwerk