PureBoard

Code: Alles auswählen

; Neuronale Netze - 1. Perceptron
;
; Original von chutullu 
; https://www.freebasic-portal.de/tutorials/neuronale-netze-perceptron-34.html
;
; 1.1.0. Grundlagen
; 
; Künstliche Intelligenz ist ein Sammelbegriff für verschiedenste Techniken, mit denen menschliches Denken
; nachgeahmt werden soll. Dabei kristallisiert sich eine Gemeinsamkeit heraus, die Fähigkeit einer "Maschine"
; zu lernen.
; 
; Unter Neuronalen Netzen versteht man die Nachahmung lebender Gehirnstrukturen, diese werden als elektrisch
; verarbeitende Elemente angesehen und mittels Hard- bzw. Software nachgebildet. Somit ist unser Gehirn nichts
; anderes als ein massiv parallel arbeitendes Neuronales Netzwerk.
; 
; Die Fähigkeit sich die Muster zu merken, wird in der Natur durch die verschiedenen Verbindungen (Synapsen)
; zwischen den einzelnen Gehirnzellen (Neuronen), welche man sich als eine Art elektrischen Wiederstand
; vorstellen kann, realisiert, der Biologe möge mir die vielleicht etwas "schwammige" Formulierung verzeihen.
; 
; 1.1.1. Einteilung der Netzparadigmen
; 
; Neuronale Netze können nach verschiedenen Gesichtspunkten unterschieden werden :
; 
; Lernart (supervised / unsupervised)
; Netzarchitektur ( Feedforward Netze / Feedback Netze / einschichtig / mehrschichtig)
; Eingabe / Ausgabe Verhältnis (Mustererkennung / Assoziierung)
; Erkennen der Muster ( bekannte und gelernte Muster erkennen / selbstorganisierende Auffindung von Musterklassen)
; Wertebereich der Ein-/Ausgangssignale (diskrete Werte / kontinuierliche Werte)
; Art der Berechnung
; 1.2. Perceptron
; 
; Zum Einstieg eignet sich besonders das Perceptron, dieses stellt das älteste Neuronale Netz dar.
; Unter einem Perceptron ist ein Sensor mit verschiedenen Eingängen zu verstehen, der fähig ist
; die Eingangswerte in zwei verschiedene Klassen zu unterscheiden. Dies wird durch eine Hard Limiterfunktion
; am Ausgang ermöglicht.
;
; Beispile Code:
; Perceptron - Grundlage
;
;  Allgemeine Beschreibung
;
;    Das Perceptron setzt sich wie fogt zusammen :
;
;      Eingang        : x(1) .. x(n)
;      Gewichte       : w(1) .. w(n)
;      Summenfunktion : sum = x(1)*w(1)+w(0) + x(2)*w(2)+w(0) + ... + x(n)*w(n)+w(0)
;      Hart Limiter   : y = 1 wenn sum >= 0 oder y = 0 wenn sum < = 0
;
;    Die Variable w(0) nimmt eine Sonderfunktion ein, sie wird "Bias" genannt und
;    hat den Wert 1. Weiterhin sind die Eingangs-/Ausgangswerte so genannte diskrete
;    Werte, d. h. sie können nur den Wert 0 bzw. 1 annehmen.
;
;  Lernvorgang
;
;    Supervised, d.h. es werden Eingangsmuster und Ausgangsmuster vorgegeben.
;    Dabei wird die so genannte Delta Regel verwendet :
;
;    Gewicht (k) = Gewicht (k - 1) + Lernfk. * (Sollausgang - Istausgang (k - 1)) * Eingangswert
;           i (neu)        i (alt) 
;
;
; Eine Zusammenfassung des Themengebietes gibt folgender kleiner Quellcode, 
; welcher ein Perceptron - Element darstellt und dessen Einsatz als AND Funktion zeigt.
; Es empfiehlt sich mit dem Lernfaktor zu experimentieren, weiterhin ist es für das Verständnis ratsam,
; während der einzelnen Lernschritte einmal alle Gewichtungen auszugeben.
;
; Viel Spaß beim Experimentieren.

EnableExplicit

DeclareModule PNN

  Interface PERCEPTRON
    Percepron(Index.i,Input.a)
    Solution.i(Input.a)
    Output.i()
    Learn.i()
    Release.i()
  EndInterface
  
  Declare.i Create(Perceprons.i)
  
EndDeclareModule

Module PNN
  
  EnableExplicit
  
  Structure PERCEPTRON_STRUCT
    *vtable
    inputs.i
    Array node.a(0)
    Array weight.d(0)
    factor.d
    bias.a
    solution.a
  EndStructure
  
  Procedure.i Percepron(*vtable.PERCEPTRON_STRUCT,Index.i,Input.a)
    With *vtable
      If Index < \inputs
        \node(Index) = Input
        ProcedureReturn #True
      Else
        ProcedureReturn #False
      EndIf 
    EndWith
  EndProcedure
  
  Procedure.i Solution(*vtable.PERCEPTRON_STRUCT,Input.a)
    With *vtable
      \solution = Input 
    EndWith
    ProcedureReturn #Null
  EndProcedure
  
  Procedure.i Output(*vtable.PERCEPTRON_STRUCT)
    Protected index.i
    Protected sum.d
    With *vtable
      For index = 0 To \inputs - 1
        sum + \weight(index) + \node(index) + \bias
      Next
      If sum < 0
        ProcedureReturn 0
      Else
        ProcedureReturn 1
      EndIf
    EndWith
  EndProcedure
  
  Procedure.i Learn(*vtable.PERCEPTRON_STRUCT)
    Protected index.i
    With *vtable
      For index = 0 To \inputs - 1
        \weight(index) = \weight(index) + \factor * (\solution - Output(*vtable)) * \node(index)
      Next
    EndWith
    ProcedureReturn #Null
  EndProcedure
  
  Procedure.i Create(Perceprons.i)
    Protected *pnn.PERCEPTRON_STRUCT
    *pnn = AllocateStructure(PERCEPTRON_STRUCT)
    If *pnn
      With *pnn
        \vtable = ?vtable_PERCEPTRON
        \bias = 1
        \inputs = Perceprons
        \factor = 0.1
        ReDim \node(\inputs)
        ReDim \weight(\inputs)
        If ArraySize(\node()) = \inputs And ArraySize(\weight()) = \inputs
          ProcedureReturn *pnn
        EndIf 
        FreeArray(\node())
        FreeArray(\weight())
      EndWith
      FreeStructure(*pnn)
    EndIf 
    ProcedureReturn #Null
  EndProcedure
  
  Procedure.i Release(*pnn.PERCEPTRON_STRUCT)
    With *pnn
      FreeArray(\node())
      FreeArray(\weight())
    EndWith
    FreeStructure(*pnn)
    ProcedureReturn #Null
  EndProcedure
  
  DataSection
    vtable_PERCEPTRON:
    Data.i @Percepron()
    Data.i @Solution()
    Data.i @Output()
    Data.i @Learn()
    Data.i @Release()
  EndDataSection
  
EndModule

Global *pnn.PNN::PERCEPTRON
Global Dim result.a(4)
Global index.i

*pnn = PNN::Create(2)
If *pnn
  
  ;Untrainiertes Netzwerk
  
  ;Vorgabe:
  ;p1 -> 0 0 1 1 
  ;p2 -> 0 1 0 1
  *pnn\Percepron(0,0):*pnn\Percepron(1,0):result(0) = *pnn\Output()
  *pnn\Percepron(0,0):*pnn\Percepron(1,1):result(1) = *pnn\Output()
  *pnn\Percepron(0,1):*pnn\Percepron(1,0):result(2) = *pnn\Output()
  *pnn\Percepron(0,1):*pnn\Percepron(1,1):result(3) = *pnn\Output()
  
  ;Ergenis
  Debug result(0)
  Debug result(1)
  Debug result(2)
  Debug result(3)
  Debug "--------"
  
  ;Lernvorgang
  For index = 0 To 50
    *pnn\Percepron(0,0):*pnn\Percepron(1,0):*pnn\Solution(0):*pnn\Learn()
    *pnn\Percepron(0,1):*pnn\Percepron(1,0):*pnn\Solution(0):*pnn\Learn()
    *pnn\Percepron(0,0):*pnn\Percepron(1,1):*pnn\Solution(0):*pnn\Learn()
    *pnn\Percepron(0,1):*pnn\Percepron(1,1):*pnn\Solution(1):*pnn\Learn()
  Next
  
  ;Vorgabe Test
  ;p1 -> 0 0 1 1 
  ;p2 -> 0 1 0 1
  *pnn\Percepron(0,0):*pnn\Percepron(1,0):result(0) = *pnn\Output()
  *pnn\Percepron(0,0):*pnn\Percepron(1,1):result(1) = *pnn\Output()
  *pnn\Percepron(0,1):*pnn\Percepron(1,0):result(2) = *pnn\Output()
  *pnn\Percepron(0,1):*pnn\Percepron(1,1):result(3) = *pnn\Output()
  
  ;Ergebnis (ist)
  Debug result(0)
  Debug result(1)
  Debug result(2)
  Debug result(3)
  Debug "--------"
  
  ;Ergenis (soll)
  Debug (0 & 0)
  Debug (1 & 0)
  Debug (0 & 1)
  Debug (1 & 1)
  
  *pnn\Release()
EndIf

End