Training mit Datenmengen

Beispielhaft wird hier ein KNN mit der Datenmenge trainiert, die sich aus den Zuständen der Ampelschaltung ergeben:

Es werden sechs Zustände dargestellt:

Aus, Grün, Gelb, Rot, Rot-Gelb, Gelb blinkend (Störung)

Das KNN wird also 3 Eingabeknoten und einen Ausgabeknoten benötigen. Es wird mit drei "Features" trainiert:

KNN mit 3 Eingabe- und einem Ausgabeknoten

Training mit nur einem Datensatz

Zunächst wird das KNN mit nur einem Datensatz trainiert. Dabei wird zunächst ein interessanter Sonderfall betrachtet: beim ersten Datensatz ist der Input aller Eingabepunkte = 0:

Stoppen des Gradientenabstiegs durch Input = 0

 1    
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import numpy as np
weights = np.array([0.5,0.48,-0.7])
alpha = 0.1

streetlights = np.array( [ [ 0, 0, 0 ],
                           [ 0, 0, 1 ],
                           [ 0, 1, 0 ],
                           [ 0, 1, 1 ],
                           [ 1, 0, 0 ],
                           [ 1, 1, 1 ] ] )

walk_vs_stop = np.array( [ 1, 0, 0, 0, 1, 1 ] )

input = streetlights[0] # [0,0,0]
goal_prediction = walk_vs_stop[0] # equals 1... i.e. "go"

for iteration in range(20):
    prediction = input.dot(weights)
    error = (goal_prediction - prediction) ** 2
    delta = prediction - goal_prediction
    weights = weights - (alpha * (input * delta))	

    print("Error:" + str(error) + " Prediction:" + str(prediction))

Listing 1: Stoppen des Lernvorgangs

Ausgabe:

Error:1.0 Prediction:0.0
Error:1.0 Prediction:0.0
Error:1.0 Prediction:0.0
Error:1.0 Prediction:0.0
...

Das KNN wird durch die Eingabe von [0, 0, 0] gestoppt. Egal welche Gewichte eingestellt sind, die Vorhersage ist immer 0. Weder Forward noch Backpropagation funktionieren. Die Neuronen "feuern nicht".

Wird z.B. mit dem Datensatz für "Grün", dem Datensatz [1, 0, 0] trainiert, konvergiert das KNN:

14    
15

input = streetlights[4] # [1,0,0] grün
goal_prediction = walk_vs_stop[4] # equals 1... i.e. "go"

Listing 2: Training mit einem Datensatz

Ausgabe:

Error:0.25 Prediction:0.5
Error:0.20249999999999996 Prediction:0.55
Error:0.16402499999999992 Prediction:0.5950000000000001
Error:0.13286024999999996 Prediction:0.6355000000000001
...
Error:0.006953209736092335 Prediction:0.9166140915016672
Error:0.005632099886234798 Prediction:0.9249526823515004
Error:0.0045620009078501805 Prediction:0.9324574141163504

Erlernen der gesamten Datenmenge

Natürlich muss das KNN, um eine genügend sichere Voraussage machen zu können, ob eine gefahrlose Fahrt möglich ist, weitere Ampelkombinationen lernen (dabei muss der Datensatz, bei dem jeder Input=0 ist vorher entfernt werden):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import numpy as np
weights = np.array([0.5,0.48,-0.7])
alpha = 0.1

streetlights = np.array( [ [ 0, 0, 1 ],
                           [ 0, 1, 0 ],
                           [ 0, 1, 1 ],
                           [ 1, 0, 0 ],
                           [ 1, 1, 1 ] ] )

walk_vs_stop = np.array( [ 0, 0, 0, 1, 1 ] )

for iteration in range(40):
    error_for_all_lights = 0
    for row_index in range(len(walk_vs_stop)):
        input = streetlights[row_index]
        goal_prediction = walk_vs_stop[row_index]
        
        prediction = input.dot(weights)
        
        error = (goal_prediction - prediction) ** 2
        error_for_all_lights += error
        
        delta = prediction - goal_prediction
        weights = weights - (alpha * (input * delta))	
        print("Prediction:" + str(prediction))
    print("Error:" + str(error_for_all_lights) + "\n")
print(weights)

Listing 3: Erlernen der gesamten Datemenge (ausgenommen [0, 0, 0])

Ausgabe:

Prediction:-0.7
Prediction:0.48  
Prediction:-0.198
Prediction:0.5   
Prediction:0.39160000000000006
Error:1.3797545599999999

Prediction:-0.54936
Prediction:0.51264
Prediction:-0.033047999999999966
Prediction:0.61084
Prediction:0.6233176
Error:0.8590234855737601

...

Prediction:-0.010430604497233771
Prediction:0.011102039787819075
Prediction:0.0006042917615267738
Prediction:0.998954630378456
Prediction:0.9995426007498317
Error:0.0002337199778807819

Prediction:-0.009402233298646243
Prediction:0.009977146557901322
Prediction:0.0005174219333295704
Prediction:0.9991049072656273
Prediction:0.9996083540857283
Error:0.00018916774742239737

Weights:[ 0.99923358  0.00896685 -0.00847459]

Korrelation

Mit der gesamten Datenmenge trainiertes KNN

Das KNN hat gelernt, dass die Farbe Grün sehr stark mit "Go" korreliert, denn Korrelation ist vorhanden, wenn Gewichte hohe Werte aufweisen. Dagegen sind die Gewichte der beiden anderen Features sehr niedrig. Der Einfluss von Gelb und Rot auf Go ist gering. Es wurde für Gelb und Rot Zufälligkeit festgestellt.

Zusammenfassung

Die beiden Schichten des KNN haben eine Korrelation zwischen 2 Datenmengen festgestellt:

Trainingsdaten

streetlights = [ [ 0, 0, 1 ],           walk_vs_stop = [ 0,
                 [ 0, 1, 0 ],                            0,
                 [ 0, 1, 1 ],      ->                    0,
                 [ 1, 0, 0 ],                            1,
                 [ 1, 1, 1 ] ] )                         1 ]

                   0  0  -           0
                   0  -  0           0
                   0  -  -     ->    0
                   +  0  0           1
                   +  -  -           1
                   

Die Daten der ersten Spalte (Grün) erhöhten durch einen positiven Druck das entsprechende Gewicht (Korrelation). Die Daten der beiden anderen Spalten (Gelb und Rot) verminderten die entsprechenden Gewichte durch einen negativen Druck (keine Korrelation).

Quellen:

Trask, Andrew W. (2020): Neuronale Netze und Deep Learning kapieren. Der einfache Praxiseinstieg mit Beispielen in Python. (1. Aufl.). mitp-Verlag, S. 121ff.

https://github.com/iamtrask/Grokking-Deep-Learning/blob/master/Chapter6%20-%20Intro%20to%20Backpropagation%20-%20Building%20Your%20First%20DEEP%20Neural%20Network.ipynb