Neuronales Netzwerk

[remi_meier]

Wie schon beim Testen gesagt:
Jetzt musst du nur noch n nettes Spielchen dazu erfinden und es wird sicher !

[Kaeru Gaman]

ähh......

wiese hat das hier eigentlich bis auf remi, der es schon vorab zugeschickt bekam
absolut keinen kommentar bekommen???????

[remi_meier]

Naja gut, du könntest es vielleicht unter Feedback posten. Vielleicht schreckt der Titel des Threads ab

[Kaeru Gaman]

hast wohl recht...
muss es halt vorher nochma überarbeiten.
vielleicht sollte ich die AI auch nicht fred nennen....
hab ich aber gemacht, bevor ich ins forum kam...

unter 'anwendungen' oder 'spiele' was denkst du?

[Scarabol]

@Kaeru
Denke eher unter Code Tips und Tricks

@remi
Du hast die Funktion super beschrieben, aber kein Wort darüber verloren was der Code konkret macht. Bitte ergänzen...

Gruß
Scarabol

PS
Hier mal der überarbeitete Code, da das kopieren aus der pdf ein Krampf war und der Code auch nicht PB4 konform war.

Code: Alles auswählen

;/ 3-schichtiges Neuronales Netzwerk 
; Eingabeschicht - Verborgene Schicht - Ausgabeschicht 
; - Jedes Neuron der Eingabeschicht ist mit jedem Neuron der verborgenen 
;   Schicht verbunden 
; - Jedes Neuron der verborgenen Schicht ist mit jedem Neuron der 
;   Ausgabeschicht verbunden 
; - Jedes Neuron der verb.- und der Ausgabeschicht hat ein 
;   Verschiebungsgewicht (Gewicht wo immer Input = 1) 
; - Weniger fehleranfällig, für nichtlineare Probleme der Form: y = f(x), 
;   braucht mehr Training 
; als Aktivierungsfunktion habe ich diesmal die nichtlineare sigmoide 
; Funktion gewählt: 
; 1 / (1 + e^(-Aktivierung)) 
; sie bleibt zwischen 0 und 1, wird aber 0 und 1 nie erreichen! 
; Zu #LD: für einen Fehler von 10% müsste die Anzahl Lerndurchläufe 10 mal 
; grösser sein, als die Anzahl an Gewichten!!! (Anz.Gewichte = #v * (#n * #n + #a) 
; #Toleranz = 0.01 ;Zum herausfinden, wann genug gelernt wurde (habs auskommentiert) 
#LD = 30000 ;Anz. Lerndurchläufe 
#TD = 400 ;Anz. Testdurchläufe 
#LK = 0.1 ;Lernkonstante 
#n = 16 ;Wurzelvon(Anz. Inputs), Seitenlänge des Bildes 
#v = 30 ;Anz. verb. Neuronen 
#a = 1 ;Anz. Outputs, Achtung, wenn verändert, dann muss auch Generiere_Input() angepasst werden 
;Gewichte 
Global Dim Gewichte1.f(#n * #n, #v) ;Gewichte von Inputs nach verb. Schicht 
Global Dim Gewichte2.f(#v, #a) ;Gewichte von verb. Schicht nach Outputs 
;Outputs der Neuronen 
Global Dim Inputs.f(#n * #n) ;Inputneuronen 
Global Dim VNeurons.f(#v) ;Verb. Neuronen 
Global Dim VFehler.f(#v) ;Um die Fehler zu speichern (Fehler = Abweichung vom berechneten Solloutput) 
Global Dim Outputs.f(#a) ;Outputneuronen 
Global Dim OFehler.f(#a) ;Um die Fehler zu speichern (Fehler = Abweichung vom Solloutput) 
Global Dim SollOutputs.f(#a) ;Array mit den Bildern (1011110000011101) 
;- Initialisierung 
Procedure Init_Gewichte() ;Zufällig initialisieren, von -0.3 bis +0.3 
  For z1 = 0 To #n * #n ;von 0, da Verschiebungsgewicht auch initialisiert werden muss 
    For z2 = 0 To #v 
      Gewichte1(z1, z2) = Random(600) / 1000.0 - 0.3 
    Next 
  Next 
  For z1 = 0 To #v 
    For z2 = 0 To #a 
      Gewichte2(z1, z2) = Random(600) / 1000.0 - 0.3 
    Next 
  Next 
  VNeurons(0) = 1 
  Inputs(0) = 1 
EndProcedure 


Global Image.l 
Image = CreateImage(#PB_Any, #n, #n) 
Procedure Generiere_Input() 
StartDrawing(ImageOutput(Image)) 
  DrawingMode(0) 
  Box(0, 0, #n, #n, 0) ;Image löschen 
  DrawingMode(4) 
  zufall = Random(1) 
  If zufall = 0 ;Ellipse 
    Ellipse(Random(4) + 6, Random(4) + 6, Random(4) + 3, Random(4) + 3, $FFFFFF) 
    SollOutputs(1) = 1.0 ;Outputneuron = 1 
  ElseIf zufall = 1 ;Box 
    Box(Random(6), Random(6), Random(5) + 5, Random(5) + 5, $FFFFFF) 
    SollOutputs(1) = 0.0 ;Outputneuron = 0 
  EndIf 
  For z = 1 To #n * #n ;Inputs()-Array füllen 
    x = (z % #n) + 1 
    y = z / #n 
    farbe = Point(x, y) 
    If farbe > 0 
      Inputs(z) = 1.0 
    Else 
      Inputs(z) = 0.0 
    EndIf 
  Next 
StopDrawing() 
EndProcedure 


;- Berechnen/Lernen/Anpassen 
Procedure Berechne_Outputs() ;Vorwärts 
  For z1 = 1 To #v ;für jedes Neuron der verb. Schicht 
    VNeurons(z1) = 0 ;mit 0 initialisieren 
  For z2 = 1 To #n * #n ;für jedes Neuron der Inputsschicht 
    VNeurons(z1) = VNeurons(z1) + Inputs(z2) * Gewichte1(z2, z1) 
    ;Aktivierung aufsummieren 
  Next 
  For z3 = 1 To #v ;und noch die Verschiebungsgewichte 
    VNeurons(z1) = VNeurons(z1) + Gewichte1(0, z3) 
  Next 
    VNeurons(z1) = 1.0 / (1.0 + Pow(2.718, -VNeurons(z1))) 
    ;Aktivierungsfunktion (sigmoide Funktion) => Output 
  Next 
  For z1 = 1 To #a ;für jedes Neuron der Ausgabeschicht 
    Outputs(z1) = 0 ;mit 0 initialisieren 
    For z2 = 1 To #v ;für jedes Neuron der verb. Schicht 
      Outputs(z1) = Outputs(z1) + VNeurons(z2) * Gewichte2(z2, z1) 
      ;Aktivierung aufsummieren 
    Next 
    For z3 = 1 To #a ;und noch die Verschiebungsgewichte 
      Outputs(z1) = Outputs(z1) + Gewichte2(0, z3) 
    Next 
    Outputs(z1) = 1.0 / (1.0 + Pow(2.718, -Outputs(z1))) 
    ;Aktivierungsfunktion (sigmoide Funktion) => Output 
  Next 
EndProcedure 


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)) * Outputs(z) * (1.0 - Outputs(z)) ;fülle Fehler-Array der Outputschicht 
 ; 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) = VNeurons(z1) * (1.0 - VNeurons(z1)) * Fehler1 ;fülle Fehlerarray der verb. Schicht 
  Next 
  ProcedureReturn MaxFehler 
EndProcedure 


Procedure Gewichte_anpassen() ;Rückwärts 2
  ;2. Gewichteschicht anpassen
  For z1 = 0 To #a ;für jedes Neuron der Ausgabeschicht
    For z2 = 0 To #v ;für jedes Neuron der verb. Schicht
      Gewichte2(z2, z1) = Gewichte2(z2,z1) + (#LK * OFehler(z1)) * VNeurons(z2) ;die altbekannte Delta-Regel
    Next
  Next
  ;1. Gewichteschicht anpassen
  For z1 = 0 To #v ;für jedes Neuron der verb. Schicht
    For z2 = 0 To #n * #n ;für jedes Neuron der Eingabeschicht
      Gewichte1(z2, z1) = Gewichte1(z2, z1) + (#LK * VFehler(z1)) * Inputs(z2) ;die altbekannte Delta-Regel
    Next
  Next
EndProcedure

;- LERNE 
Init_Gewichte() ;Gewichte auf Zufallswerte (nahe beieinander (-0.3 bis +0.3)) 
; anzInToleranz = 0 
For z = 1 To #LD 
  Generiere_Input() ;Inputs()-Array füllen und Solloutput generieren 
  Berechne_Outputs() ;die Outputs der verschiedenen Schichten (verb.- und Ausgabe-) errechnen 
  Berechne_Fehler() ;die Fehler in die Fehlerarrays füllen 
  ; bereich.f = Berechne_Fehler() 
  ; If Abs(bereich) <= #Toleranz 
  ; anzInToleranz + 1 
  ; EndIf 
  ; If anzInToleranz >= 300 
  ; Break 
  ; EndIf 
  Gewichte_anpassen() ;Aus Fehlern lernen! 
Next 
OpenConsole() 
PrintN("Training beendet!") 
PrintN("") 
;- TESTE 
richtige = 0 
OpenWindow(0,200,200,200,200,"",#PB_Window_SystemMenu)
For z = 1 To #TD
  Generiere_Input() 
  ; If Abs(OFehler(z)) > Abs(MaxFehler) ;Maximaler Fehler herausfinden 
  ; MaxFehler = OFehler(z) 
  StartDrawing(WindowOutput(0)) 
  DrawImage(ImageID(Image),0,0,32,32) 
  StopDrawing()
  
   Berechne_Outputs()
  If (SollOutputs(1) > 0.8 And Outputs(1) > 0.8) Or (SollOutputs(1) < 0.2 And Outputs(1) < 0.2) ;hat ers auf 0.2 genau herausgefunden? 
    richtige + 1
  EndIf 
Next 
PrintN("Test:") 
PrintN("Richtige von " + Str(#TD) + ": " + Str(richtige)) 
PrintN("In Prozent: " + StrF(richtige / #TD * 100.0)) 
Input()

[Kaeru Gaman]

unter 'anwendungen' oder 'spiele' was denkst du?

@Kaeru
Denke eher unter Code Tips und Tricks

Gratuliere!


...aber vielen dank für fürs aktualisieren von remis code.

[Xaby]

Habt ihr euch schon mal mit der Videoanalyse oder dem Parser beschäftigt. ...
Ihr wisst schon, das nervige Thema von mir

[Kekskiller]

Also ich weiß nicht. Wahrscheinlich gehe ich mit einem ganz anderen Ziel an so eine Aufgabe heran, aber ich würde dabei eher an das assoziative Suchen von Information innerhalb eines Knoten-Gewirrs (Neuronen?) denken und bastel schon seit Ewigkeiten an Konzepten rum, wie man diese z.b. in Spielen einsetzen kann. Ich gehe da kaum mathematisch ran, eher alghorythmisch, mit Gewichtungen und dem Zerfall bestimmter Zellen, alles benötigte eine Denkzeit (Anzahl der Knoten, die pro Frame durchsucht werden können) und picke mir am Ende die nach Wertigkeit (Zahl, die bestimmt in welcher Situation was am passendsten wäre) sortierten Ergebnisse raus, die dann ausgeführt/umgesetzt werden.

Um ehrlich zu sein, habe ich auch nie verstanden, warum genau immer mit diesem seltsamen Schichten-System und sonst irgendwelchen Funktionen gearbeitet wird. Ich meine, ich suche doch eigentlich auch nur nach Möglichkeiten wenn ich nachdenke und vergleiche sie bei Fund mit der aktuellen Situation, oder? Fallen mir nicht auch spontan Sachen ein, wenn ich an irgendetwas denke, was damit garnicht zu tun hat - ist das nicht assoziatives Denken, das was man eigentlich simulieren sollte?

Oder gehts hierbei eher um das Erlernen der Fähigkeit, Lösungen zu generieren? Hm... ev. gehe ich wohl doch eher von einer begrenzten, programmbedingten Technik aus, hm...

[Kaeru Gaman]

@Kekskiller

dazu hab ich hier noch nen teil einer dissertation rumliegen, die ich vor jahren mal im net gefunden hab.
nennt sich "pathfinding-network" und hat nichts mit dem pathfinding in games zu tun, sondern mit einem pathfinding inerhalb des NN.
die zellen sind also nicht von anfang an verknüpft, sondern suchen sich ihre verknüpfungen mit der zeit.
ob es dafür softwarelösungen gibt, weiß ich nicht, der autor hatte damals nen programmierer gesucht.....

der autor heißt Manfred Hotthalmseder aus Linz, die dissertation ist von 2002.
....vielleicht findest du ja noch was...

[Kekskiller]

Klingt so als würde das ungefähr in meine Variante eines solchen Netzes gehen. Nungut, dann muss ich mir wohl das für später aufsparen...
... und lizensiere das als Engine für teuer Geld, werde berühmt und gehe in die Geschichte ein, HA !