Künstliche Intelligenz (KI) als Hobby / Artificial Intelligence (AI) as a Hobby

Facebook Gruppe: Künstliche Intelligenz (KI) als Hobby

Delta-Lernregel in PHP

Basierend auf dem Tutorial: Neuronale Netze [010] - Delta Lernregel

Einleitung

Die Deltalernregel für neuronale Netze ist eine relativ einfach nachvollziehbare Methode, um die Gewichtungen zwischen Input und Outputneuronen eines neuronalen Netzes zu berechnen.

Nach dem im Video beschriebenen Prinzip können theoretisch beliebig viele Inputneuronen mit beliebig vielen Outputneuronen verbunden werden und deren Gewichtungen anhand einer beliebig großen Anzahl von Lerndaten berechnet werden.

Da es sich hierbei um das sogenannte überwachte Lernen handelt, müssen in dem zur Verfügung stehenden Datensatz alle Inputvariablen und auch die Outputvariablen mitgegeben werden. Nehmen wir eine Exceltabelle bzw. CSV Datei als Datenbasis, so können die ersten drei Spalten zum Beispiel die Input Werte beinhalten und die vierte Spalte zum Beispiel einen Outputwert. Praktischerweise wird man den Datensatz aufteilen, sodass sich eine Vielzahl von Zeilen zum Training benutzen lassen, aber eine bestimmte Anzahl von Zeilen nicht zum Training genutzt wird, sondern später zur Kontrolle.

Beginnen wir nun entsprechend dem Beispiel im Video damit, ein Array einzurichten in dem alle Neuronen sitzen. Wir erzeugen ein 2-dimensionales Array, bei dem die erste Stufe die Nummer des Trainingsdatensatzes darstellt, und die zweite Stufe die Nummer des Neuron. In unserem Beispiel verwenden wir, genau wie im Video, nur einen einzigen Trainingsdatensatz, sodass es nur eine erste Stufe gibt und in der zweiten Stufe die Nrn. 1-4. Die Nrn. 1-3 stellen Inputs dar und Nummer 4 unser gewünschtes Output.

20180119_Delta_Lernregel_Skizze.jpg

Array für die Neurons

Array
(
    [1] => 10
    [2] => -5
    [3] => 7
    [4] => 2
)

Als nächstes erstellen wir ein zweites Array, in dem die Gewichtungen zwischen den Neuronen gespeichert werden. Zu Beginn, also vor dem ersten Durchlauf, wird für jede Verbindung der Neuronen ein zufälliges Gewicht gewählt, was sich dann erst mit den Durchgängen des Lernprozesses verbessert. In diesem Beispiel gibt es drei Gewichte, die sich zwischen den Input Neuronen und dem einen Output Neuron ergeben. Um die Gewichte darzustellen, wird ein neues Array angelegt, bei dem die zweite Stufe das Inputneuron und die erste Stufe das Output Neuron darstellt.

Array für die Gewichte

Array
(
    [4] => Array
        (
            [1] => 0.6
            [2] => 0.3
            [3] => -0.2
        )

)

Als nächstes müssen wir nun eine Berechnung durchführen, die unsere drei Inputneuronen mit dem aktuellen Gewicht multipliziert, und einen berechneten Wert für das Output Neuron herauskommt.

1. Berechnung des Output

Output 4 Input 1 mit Wert = 10 Gewicht = 0.6
Output 4 Input 2 mit Wert = -5 Gewicht = 0.3
Output 4 Input 3 mit Wert = 7 Gewicht = -0.2
Output berechnet = 3.1
Output Soll = 2

Nach dem ersten Durchgang der Berechnung des neuronalen Netzes im aktuellen Zustand, können wir sehen das die Werte der Inputneuronen multipliziert mit den jeweiligen Gewichtungen einen anderen Wert (3.1) für das Output Neuron ergeben, als der Datensatz vorgegeben hat (2). Im nächsten Schritt wenden wir deshalb die Deltalernregel an, mit der die Gewichte angepasst werden, auf Basis der Abweichung zwischen Soll und ist Wert des Output Neurons. Wie im Video Beispiel wählen wir den konstanten Faktor mit 0,01 und berechnen als weiteren Faktor die Differenz zwischen Output Neuron soll und Output Neuron berechnet.

1. Berechnung der Differenz

Lernfaktor = 0.01
Output berechnet = 3.1
Output Soll = 2
Differenz = -1.1

Jetzt haben wir die beiden Konstanten zur Anwendung der Delta Lernregel zur Verfügung und müssen nun das Array der Gewichte durch rechnen, sodass sich jedes aktuelle Gewicht entsprechend der Formel mit diesen beiden Konstanten zu einem neuen Gewicht anpassen kann. Wir können dies mit einer einfachen Schleife machen.

Delta-Lern-Durchlauf 1

Output 4 Input 1 mit GewichtDelta = -0.11 also neues Gewicht = 0.6 + -0.11
Output 4 Input 2 mit GewichtDelta = 0.055 also neues Gewicht = 0.3 + 0.055
Output 4 Input 3 mit GewichtDelta = -0.077 also neues Gewicht = -0.2 + -0.077
Array
(
    [4] => Array
        (
            [1] => 0.49
            [2] => 0.355
            [3] => -0.277
        )

)

Jetzt haben wir den ersten Lernprozess durchlaufen und können direkt sehen, wie sich die drei Gewichte dadurch angepasst haben. Wie in dem Video Beispiel können wir unser Netz jetzt mit dem selben Datensatz immer wieder trainieren, sodass sich der berechnete Wert für das Outputneuron immer näher an den Sollwert für das Output Neuron annähert. In diesem Beispiel kommen wir naturgemäß sehr nahe an das soll Ergebnis heran, da das neuronale Netz ja immer wieder mit dem gleichen Datensatz trainiert wird. In der Realität wäre so eine exakte Annäherung äußerst unwahrscheinlich, aber dieses Beispiel zeigt das Prinzip des überwachten Lernens trotzdem sehr gut. Nachfolgend lassen wir diesen Lernmechanismus noch ein paar Mal durchlaufen und geben jeweils das neue Array der Gewichte aus.

Output berechnet = 1.186
Output Soll = 2

Delta-Lern-Durchlauf 2

Output 4 Input 1 mit GewichtDelta = 0.0814 also neues Gewicht = 0.49 + 0.0814
Output 4 Input 2 mit GewichtDelta = -0.0407 also neues Gewicht = 0.355 + -0.0407
Output 4 Input 3 mit GewichtDelta = 0.05698 also neues Gewicht = -0.277 + 0.05698
Array
(
    [4] => Array
        (
            [1] => 0.5714
            [2] => 0.3143
            [3] => -0.22002
        )

)
Output berechnet = 2.60236
Output Soll = 2

Delta-Lern-Durchlauf 3

Output 4 Input 1 mit GewichtDelta = -0.060236 also neues Gewicht = 0.5714 + -0.060236
Output 4 Input 2 mit GewichtDelta = 0.030118 also neues Gewicht = 0.3143 + 0.030118
Output 4 Input 3 mit GewichtDelta = -0.0421652 also neues Gewicht = -0.22002 + -0.0421652
Array
(
    [4] => Array
        (
            [1] => 0.511164
            [2] => 0.344418
            [3] => -0.2621852
        )

)
Output berechnet = 1.5542536
Output Soll = 2

Delta-Lern-Durchlauf 4

Output 4 Input 1 mit GewichtDelta = 0.04457464 also neues Gewicht = 0.511164 + 0.04457464
Output 4 Input 2 mit GewichtDelta = -0.02228732 also neues Gewicht = 0.344418 + -0.02228732
Output 4 Input 3 mit GewichtDelta = 0.031202248 also neues Gewicht = -0.2621852 + 0.031202248
Array
(
    [4] => Array
        (
            [1] => 0.55573864
            [2] => 0.32213068
            [3] => -0.230982952
        )

)
Output berechnet = 2.329852336
Output Soll = 2

Delta-Lern-Durchlauf 5

Output 4 Input 1 mit GewichtDelta = -0.0329852336 also neues Gewicht = 0.55573864 + -0.0329852336
Output 4 Input 2 mit GewichtDelta = 0.0164926168 also neues Gewicht = 0.32213068 + 0.0164926168
Output 4 Input 3 mit GewichtDelta = -0.02308966352 also neues Gewicht = -0.230982952 + -0.02308966352
Array
(
    [4] => Array
        (
            [1] => 0.5227534064
            [2] => 0.3386232968
            [3] => -0.25407261552
        )

)
Output berechnet = 1.75590927136
Output Soll = 2

Delta-Lern-Durchlauf 6

Output 4 Input 1 mit GewichtDelta = 0.024409072864 also neues Gewicht = 0.5227534064 + 0.024409072864
Output 4 Input 2 mit GewichtDelta = -0.012204536432 also neues Gewicht = 0.3386232968 + -0.012204536432
Output 4 Input 3 mit GewichtDelta = 0.0170863510048 also neues Gewicht = -0.25407261552 + 0.0170863510048
Array
(
    [4] => Array
        (
            [1] => 0.547162479264
            [2] => 0.326418760368
            [3] => -0.2369862645152
        )

)
Output berechnet = 2.1806271391936
Output Soll = 2

Delta-Lern-Durchlauf 7

Output 4 Input 1 mit GewichtDelta = -0.01806271391936 also neues Gewicht = 0.547162479264 + -0.01806271391936
Output 4 Input 2 mit GewichtDelta = 0.00903135695968 also neues Gewicht = 0.326418760368 + 0.00903135695968
Output 4 Input 3 mit GewichtDelta = -0.012643899743552 also neues Gewicht = -0.2369862645152 + -0.012643899743552
Array
(
    [4] => Array
        (
            [1] => 0.52909976534464
            [2] => 0.33545011732768
            [3] => -0.24963016425875
        )

)
Output berechnet = 1.8663359169967
Output Soll = 2

Delta-Lern-Durchlauf 8

Output 4 Input 1 mit GewichtDelta = 0.013366408300326 also neues Gewicht = 0.52909976534464 + 0.013366408300326
Output 4 Input 2 mit GewichtDelta = -0.0066832041501632 also neues Gewicht = 0.33545011732768 + -0.0066832041501632
Output 4 Input 3 mit GewichtDelta = 0.0093564858102285 also neues Gewicht = -0.24963016425875 + 0.0093564858102285
Array
(
    [4] => Array
        (
            [1] => 0.54246617364497
            [2] => 0.32876691317752
            [3] => -0.24027367844852
        )

)
Output berechnet = 2.0989114214224
Output Soll = 2

Delta-Lern-Durchlauf 9

Output 4 Input 1 mit GewichtDelta = -0.0098911421422415 also neues Gewicht = 0.54246617364497 + -0.0098911421422415
Output 4 Input 2 mit GewichtDelta = 0.0049455710711208 also neues Gewicht = 0.32876691317752 + 0.0049455710711208
Output 4 Input 3 mit GewichtDelta = -0.0069237994995691 also neues Gewicht = -0.24027367844852 + -0.0069237994995691
Array
(
    [4] => Array
        (
            [1] => 0.53257503150272
            [2] => 0.33371248424864
            [3] => -0.24719747794809
        )

)
Output berechnet = 1.9268055481474
Output Soll = 2

Delta-Lern-Durchlauf 10

Output 4 Input 1 mit GewichtDelta = 0.0073194451852587 also neues Gewicht = 0.53257503150272 + 0.0073194451852587
Output 4 Input 2 mit GewichtDelta = -0.0036597225926294 also neues Gewicht = 0.33371248424864 + -0.0036597225926294
Output 4 Input 3 mit GewichtDelta = 0.0051236116296811 also neues Gewicht = -0.24719747794809 + 0.0051236116296811
Array
(
    [4] => Array
        (
            [1] => 0.53989447668798
            [2] => 0.33005276165601
            [3] => -0.24207386631841
        )

)
Output berechnet = 2.0541638943709
Output Soll = 2

Delta-Lern-Durchlauf 11

Output 4 Input 1 mit GewichtDelta = -0.0054163894370915 also neues Gewicht = 0.53989447668798 + -0.0054163894370915
Output 4 Input 2 mit GewichtDelta = 0.0027081947185457 also neues Gewicht = 0.33005276165601 + 0.0027081947185457
Output 4 Input 3 mit GewichtDelta = -0.003791472605964 also neues Gewicht = -0.24207386631841 + -0.003791472605964
Array
(
    [4] => Array
        (
            [1] => 0.53447808725089
            [2] => 0.33276095637455
            [3] => -0.24586533892438
        )

)
Output berechnet = 1.9599187181655
Output Soll = 2

Delta-Lern-Durchlauf 12

Output 4 Input 1 mit GewichtDelta = 0.0040081281834476 also neues Gewicht = 0.53447808725089 + 0.0040081281834476
Output 4 Input 2 mit GewichtDelta = -0.0020040640917238 also neues Gewicht = 0.33276095637455 + -0.0020040640917238
Output 4 Input 3 mit GewichtDelta = 0.0028056897284134 also neues Gewicht = -0.24586533892438 + 0.0028056897284134
Array
(
    [4] => Array
        (
            [1] => 0.53848621543434
            [2] => 0.33075689228283
            [3] => -0.24305964919596
        )

)
Output berechnet = 2.0296601485575
Output Soll = 2

Delta-Lern-Durchlauf 13

Output 4 Input 1 mit GewichtDelta = -0.0029660148557513 also neues Gewicht = 0.53848621543434 + -0.0029660148557513
Output 4 Input 2 mit GewichtDelta = 0.0014830074278756 also neues Gewicht = 0.33075689228283 + 0.0014830074278756
Output 4 Input 3 mit GewichtDelta = -0.0020762103990259 also neues Gewicht = -0.24305964919596 + -0.0020762103990259
Array
(
    [4] => Array
        (
            [1] => 0.53552020057859
            [2] => 0.33223989971071
            [3] => -0.24513585959499
        )

)
Output berechnet = 1.9780514900674
Output Soll = 2

Delta-Lern-Durchlauf 14

Output 4 Input 1 mit GewichtDelta = 0.002194850993256 also neues Gewicht = 0.53552020057859 + 0.002194850993256
Output 4 Input 2 mit GewichtDelta = -0.001097425496628 also neues Gewicht = 0.33223989971071 + -0.001097425496628
Output 4 Input 3 mit GewichtDelta = 0.0015363956952792 also neues Gewicht = -0.24513585959499 + 0.0015363956952792
Array
(
    [4] => Array
        (
            [1] => 0.53771505157184
            [2] => 0.33114247421408
            [3] => -0.24359946389971
        )

)
Output berechnet = 2.0162418973501
Output Soll = 2

Delta-Lern-Durchlauf 15

Output 4 Input 1 mit GewichtDelta = -0.0016241897350095 also neues Gewicht = 0.53771505157184 + -0.0016241897350095
Output 4 Input 2 mit GewichtDelta = 0.00081209486750473 also neues Gewicht = 0.33114247421408 + 0.00081209486750473
Output 4 Input 3 mit GewichtDelta = -0.0011369328145066 also neues Gewicht = -0.24359946389971 + -0.0011369328145066
Array
(
    [4] => Array
        (
            [1] => 0.53609086183684
            [2] => 0.33195456908158
            [3] => -0.24473639671422
        )

)
Output berechnet = 1.9879809959609
Output Soll = 2

Delta-Lern-Durchlauf 16

Output 4 Input 1 mit GewichtDelta = 0.001201900403907 also neues Gewicht = 0.53609086183684 + 0.001201900403907
Output 4 Input 2 mit GewichtDelta = -0.0006009502019535 also neues Gewicht = 0.33195456908158 + -0.0006009502019535
Output 4 Input 3 mit GewichtDelta = 0.0008413302827349 also neues Gewicht = -0.24473639671422 + 0.0008413302827349
Array
(
    [4] => Array
        (
            [1] => 0.53729276224074
            [2] => 0.33135361887963
            [3] => -0.24389506643148
        )

)
Output berechnet = 2.0088940629889
Output Soll = 2

Delta-Lern-Durchlauf 17

Output 4 Input 1 mit GewichtDelta = -0.00088940629889112 also neues Gewicht = 0.53729276224074 + -0.00088940629889112
Output 4 Input 2 mit GewichtDelta = 0.00044470314944556 also neues Gewicht = 0.33135361887963 + 0.00044470314944556
Output 4 Input 3 mit GewichtDelta = -0.00062258440922378 also neues Gewicht = -0.24389506643148 + -0.00062258440922378
Array
(
    [4] => Array
        (
            [1] => 0.53640335594185
            [2] => 0.33179832202907
            [3] => -0.2445176508407
        )

)
Output berechnet = 1.9934183933882
Output Soll = 2

Delta-Lern-Durchlauf 18

Output 4 Input 1 mit GewichtDelta = 0.00065816066117939 also neues Gewicht = 0.53640335594185 + 0.00065816066117939
Output 4 Input 2 mit GewichtDelta = -0.00032908033058969 also neues Gewicht = 0.33179832202907 + -0.00032908033058969
Output 4 Input 3 mit GewichtDelta = 0.00046071246282557 also neues Gewicht = -0.2445176508407 + 0.00046071246282557
Array
(
    [4] => Array
        (
            [1] => 0.53706151660303
            [2] => 0.33146924169848
            [3] => -0.24405693837788
        )

)
Output berechnet = 2.0048703888927
Output Soll = 2

Delta-Lern-Durchlauf 19

Output 4 Input 1 mit GewichtDelta = -0.00048703888927273 also neues Gewicht = 0.53706151660303 + -0.00048703888927273
Output 4 Input 2 mit GewichtDelta = 0.00024351944463636 also neues Gewicht = 0.33146924169848 + 0.00024351944463636
Output 4 Input 3 mit GewichtDelta = -0.00034092722249091 also neues Gewicht = -0.24405693837788 + -0.00034092722249091
Array
(
    [4] => Array
        (
            [1] => 0.53657447771376
            [2] => 0.33171276114312
            [3] => -0.24439786560037
        )

)

PHP Code zu diesem Projekt

//While Schleife pro Lerndurchlauf
$i = 2;
while($i < 20)
{

//Unter-Schleife zum Durchlaufen des Arrays zur Berechnung des aktuellen Outputneurons
$Output = 0;
foreach($Gewichte as $key => $value){
foreach($value as $key2 => $value2){

$Output = $Output + ($Neuronen[$key2] * $value2);

}
}

//2 Faktoren der Delta-Lern-Formel festlegen
$Lernfaktor = 0.01;
$Differenz = ($Neuronen[4] - $Output);


//Unter-Schleife zur Berechnung der Gewicht-Deltas und der Anpassung des Gewichte-Arrays
foreach($Gewichte as $key => $value){
foreach($value as $key2 => $value2){

$GewichtDelta = ($Lernfaktor * $Differenz * $Neuronen[$key2]);

$Gewichte [$key][$key2] = $value2 + $GewichtDelta;

}
}

Kommentiere diese Seite