4.5 Vertrauensfragen — 5 gerade sein lassen
Wir haben bereits in 4.1 dargestellt, dass das Machine Learning der Gerade/Ungerade-Unterscheidung robust ist gegen Fehler in den Trainingsdaten: Innerhalb einer gewissen Fehlerrate lernt das System die Klassifikation korrekt.
Weiter haben wir gesehen, dass die verwendeten Modelle allein durch andere Trainingsdaten auf z.B. Vielfache von 5 trainiert werden können.
Wir wollen sehen, was passiert, wenn wir die Trainingsdaten systematisch verfälschen, d.h. Vielfache von 5 im Datensatz ebenfalls per Label 0 als “gerade” klassifizieren. Führt das nur zu einer “Störung” des Systems, oder erkennt das trainierte Modell in den Testdaten auch Vielfache von 5 als “gerade” an? Kann man ein sauber trainiertes Modell auch nachträglich zu Fehlentscheidungen bringen, durch Nachtraining mit “gezinkten” Daten?
4.5.1 Das Gerade/Ungerade-NN-Modell aus 4.3
Wir wiederholen das NN-Modell mit Embedding aus 4.3 als Grundlage für die Untersuchung dieser Fragen.
Die Größe des Vokabulars ist wieder auf 10 (Anzahl Ziffern), die einheitliche Länge der “Sätze” in Anzahl Wörtern auf 4 gesetzt. Als Encoding verwenden wir wieder die Ziffern selbst, das Padding auf 4 Stellen erfolgt mittels der Funktion v_pad.
Wir umgehen damit die Kodierung von Wörtern in Zahlen (embedded_docs) und das Padding und verwenden das Trainingsdaten-Array npX direkt.
Die embedding Dimension setzen wir hierbei auf 6 (s. 4.3).
Die Spezifikation des Modells aus 4.3 erfolgt hier über die keras API-Variante, bei der die einzelnen Layer explizit spezifiziert und die Input- und Output-Tensoren referenziert werden können. Wir geben den Layern außerdem explizit feste Namen. Insgesamt ist leicht zu sehen, dass diese Formulierung zur gleichen Modell-Architektur führt wie mittels der add-Methode.
# Same model as in 4.3 but using keras API
vocab_size = 10 # Umfang des Vokabulars
max_length = 4
embedding_dim = 6 # Dimension des Embedding-Raums
from keras.models import Model
from keras.layers import Input,Embedding,Flatten,Dense
from keras import initializers
# Set the model structure - chaining output-input tensors
inp = Input(shape=(max_length,),name='input') # Input layer
x = Embedding(vocab_size,embedding_dim,name='embed')(inp)
# Embedding layer, inp as input, x as output
x = Flatten(name='flatten')(x) # Flatten has no paramters
out = Dense(1, activation='sigmoid',
kernel_initializer=initializers.Constant(0.5),
bias_initializer='zeros',name='out_dense')(x)
# Output through one Dense layer
# Define Model
model = Model(inputs=inp,outputs=out)
# Compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])
# Model Overview
print(model.summary())_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input (InputLayer) (None, 4) 0
_________________________________________________________________
embed (Embedding) (None, 4, 6) 60
_________________________________________________________________
flatten (Flatten) (None, 24) 0
_________________________________________________________________
out_dense (Dense) (None, 1) 25
=================================================================
Total params: 85
Trainable params: 85
Non-trainable params: 0
_________________________________________________________________
None
Wir trainieren model mit Trainingsdaten wie zuvor auf Klassifikation von Gerade/Ungerade und evaluieren mit dem Testset. (Die Bereitstellung der Trainings- und Testdaten erfolgt wie in 4.3., daher wiederholen wir diesen Code-Teil hier nicht.)
# Problem-Parameter und Daten für Even/Odd Klassifikation wie in 4.3
# Imports wie in 4,3Das Training zeigt die guten Konvergenzeigenschaften bzgl. loss und accuracy wie in 4.3.
training_epochs = 200
bs = 50
hist1 = model.fit(npX, y, epochs=training_epochs, batch_size=bs, verbose=0)Die Evaluation mit dem nicht zum Training verwendeten Testdatenset zeigt keine Abweichungen von der Test-Klassifikation in gerade (Label 0) und ungerdae (Label 1), d.h. 100% Accuracy:
Abweichungen gegen Klassifikation der Testdaten:
Test : Value pred trueAccuracy: 100.000
Die Gewichte im trainierten Zustand des Modells (Code-Snippet wie in 4.3, hier nicht wiederholt) zeigen das klare, gut interpretierbare Bild wie in 4.3:
4.5.2 Training mit systematisch verfälschten Daten
Wir wollen sehen, was passiert, wenn wir die Trainingsdaten systematisch so ändern, dass Vielfache von 5 ebenfalls das Label 0 bekommen, sie quasi als “gerade” klassifiziert werden.
Es ist klar, dass sich dabei nur die Label der ungeraden Vielfachen von 5 ändern, da die geraden Vielfachen schon unter den ursprünglichen Trainingsdaten das Label 0 (“gerade”) haben.
Die Bezeichnung “gerade” ist in diesem Fall natürlich nur eine übernommene Bedeutung, die für das Label 0 zutrifft, wenn das Modell auf Gerade/Ungerade-Erkennung trainiert ist. Aber woher wissen wir, dass ein Modell als Blackbox auf Gerade/Ungerade trainiert ist und nicht Fehler oder systematische Abweichungen produziert. Wir kommen darauf weiter unten noch einmal zurück.
Bereitstellung “verfälschter” Trainingsdaten: Das Code-Snippet zeigt nur den entsprechend geänderten Teil. Das Testdaten-Set bleibt unverändert bzw. wird aus 4.5.1 oben weiter verwendet (gleiche Testbedingungen).
# Generation of "tinkered" data set for training, adapted from 4.3nmin,nmax = 0,10000
n_cases = 500
Z = np.random.randint(nmin,nmax,size=(n_cases))
y = Z[:] % 5
y = np.where(y > 0,Z % 2,y)
# Padding auf vier Stellen und Encoding in array npX von Ziffern wie in 4.3 ...
(500,) (500,)
Trainingset - Auszug:
[['8315', 0], ['8628', 0], ['8751', 1], ['6543', 1], ['4209', 1], ['3827', 1], ['2514', 0], ['8253', 1], ['8181', 1], ['9536', 0], ['1998', 0], ['7215', 0], ['7306', 0], ['6429', 1], ['9756', 0], ['9932', 0], ['4924', 0], ['9503', 1], ['7170', 0], ['0515', 0]]
(37,)
Von den 500 zufällig generierten Trainingszahlen sind 37 ungerade Vielfache von 5 (drei Beispiele im Auszug).
Training des Modells von 4.5.1 mit den neuen Trainingsdaten: Es werden die gleichen Code-Teile für Modell-Definition, Training und Evaluation durchlaufen wie oben. (Diese werden hier nicht wiederholt, sondern nur die neuen Ausgaben der Code-Teile.)
Das Training mit den gleichen Parametern wie oben zeigt nur geringfügig schlechtere Konvergenz gegenüber 4.5.1. Das Modell ist nach ca. 40 Epochen austrainiert.
Die Evaluation mit dem gleichen Testset wie oben zeigt genau diejenigen Abweichungen, die den ungeraden Vielfachen von 5 entsprechen.
# Evaluation durch Predicts über das Testset
yy = model.predict(npX_test) # padded_test
y_pred = np.round(yy)
acc = 0
print('Abweichungen gegen Klassifikation der Testdaten:')
print('Test : Value pred true')
for i in range(len(yy)):
if(int(y_pred[i][0]) != y_test[i]):
print(npX_test[i],': %6.3f %d %d' %(yy[i][0],int(y_pred[i][0]),y_test[i]))
if int(y_pred[i][0]) == y_test[i]:
acc += 1
loss, accuracy = model.evaluate(npX_test, y_test, verbose=0)
print('Accuracy: %6.3f' % (accuracy*100))Abweichungen gegen Klassifikation der Testdaten:
Test : Value pred true
[8 4 0 5] : 0.004 0 1
[5 2 0 5] : 0.004 0 1
[4 0 7 5] : 0.004 0 1
[2 7 5 5] : 0.005 0 1
Accuracy: 92.000
Das so trainierte ML Modell als Black-Box würde also diese Zahlen aus dem Test-Set ebenfalls als “gerade” erkennen. Insofern wird hier, allein durch systematische Änderung an den Trainingsdaten, das Modell z.T. fehlerhafte Aussagen machen. Und es liegt erst einmal nur an der (intellektuellen) Schlichtheit der Aufgabe, dass wir (als Mensch) die “Fehler” direkt erkennen können.
Ein andere Frage ist, ob wir das Ergebnis des ML Modells, Vielfache von 5 im Test auch als “gerade” auszuweisen, verstehen können. Dazu sehen wir uns die Gewichte an.
Die Gewichte im trainierten Zustand zeigen ein deutlich verändertes Bild gegenüber dem Trainingszustand von 4.5.1:
Verständnis für das veränderte Verhalten des Modells kann man hier tatsächlich exemplarisch durch Vergleich der Gewichte-Plots gewinnen. Wir erkennen leicht, dass die Gewichtung (rot) der Stellen in einer Zahl in beiden Fällen gleich ist: die Gruppe der Gewichte für die “Einer-Stelle” bewegt sich auf einem hohen Wert, die anderen liegen bei Null. Hier kann also das unterschiedliche Vorhersage-Verhalten nicht verursacht sein. Anders bei den blauen Gewichten, die, in Gruppen, die verschiedenen Ziffern gewichten. Die sechste Gruppe liegt nun “unten” statt “oben”. D.h. die Gruppe der Gewichte für die Ziffer 5 liegt im gleichen Wertebereich wie die für 0, 2, 4, 6 und 8. Das Modell kommt also zu der Einschätzung, dass Vielfache von 5 ebenfalls gerade Zahlen sind, weil die Gewichte sich durch das Training mit den “gezinkten” Daten auf die Ebene der geraden Ziffern bewegt haben.
Dies ist gleichzeitig ein “toy example” für eine große Sorge, die die KI-Szene allgemein umtreibt: Wie kann man die Entscheidungen eines KI Systems verstehen, bzw. nachvollziehen, durch die es zu einem bestimmten Ergebnis kommt. Und kann man das System dazu bringen, die Erklärung selbst zu liefern?
Es gibt eigentlich drei Faktoren, die den trainierten Zustand eines NN bestimmen und evtl. zur Erklärung eines Vorhersage-Ergebnisses herangezogen werden können: die Architektur des NN (also der NN-Algorithmus), die Trainingsdaten und die Anfangswerte der internen Paramter (Kernel-Gewichte, Bias).
In unserem Fall ist der Algorithmus unverändert geblieben, und in den folgenden Abschnitten zu “Nachtraining” haben im vor-trainierten Zustand die Anfangswerte bereits ihre Wirkung getan.
Eine Verfälschung, beabsichtigt oder unbeabsichtigt, in den Trainingsdaten könnte das ML System zu Fehlern oder Tendenzen hin manipulieren. Dies kann auch noch im Nachhinein geschehen, durch Nachtraining eines bereits trainierten Modells, wie wir im Folgenden zeigen.
Anm.: Eine unbeabsichtigten “Fälschung” der Trainingsdaten ist mir selbst unterlaufen. Dabei wurden bei den Testdaten Vielfache von 5 als gerade und gerade Zahlen mit einer 6 als Einerstelle als ungerade klassifiziert. Entsprechend waren die Gewichte-Gruppen im Plot “vertauscht”. Ursache war ein einfacher Programmierfehler bei der Erstellung der Trainingsdaten: y = Z[:] % 5 gefolgt von y = np.where(y > 1,Z % 2,y).
4.5.3 Nachtraining eines bereits trainierten Systems
Wir legen dem auf Gerade/Ungerade-Erkennung trainierten NN-Model (4.5.1) ein kleines Set von zusätzlichen Trainingsdaten vor, in denen Vielfache von 5 mit Label 0 versehen sind.
Hierbei sind verschiedene Varianten des Nachtrainings denkbar:
- Das Nachtrainings-Set enthält nur ungerade Vielfache von 5 mit Klassifikation 0
- Das Nachtrainings-Set besteht aus beliebigen Zahlen, wobei neben den geraden Zahlen auch Vielfache von 5 mit 0 klassifiziert sind — also ähnlich wie die in 4.5.2 verwendeten Trainingsdaten
- Die Anzahl der Nachtrainingsdaten variiert
- Es erfolgt eine ganze Abfolge von Nachtrainings hintereinander, jeweils mit einzelnen oder wenigen Zahlen.
Wir werden hier nur einige der möglichen Varianten als Beispiele durchführen.
Naheliegend ist zunächst die Variante 1, bei der das Modell mit den puren Umklassifikationsdaten quasi “geimpft” wird.
Vorgehen für die weiteren Nachtraining-Tests
- Das NN-Modell wird wie in 4.5.1 mit sauberen Trainingsdaten auf korrekte Gerade/Ungerade-Klassifikation vortrainiert.
- Der trainierte Zustand, d.h. die Werte der trainierten Gewichte, wird gespeichert (mit
model.get_weights()), so dass damit ein nachtrainiertes Modell wieder in den vortrainierten Zustand zurück gesetzt werden kann (model.set_weights(...)). - Mit
model.fitund den Daten aus einem Nachtrainings-Set wird das Modell trainiert und anschließend evaluiert. Als Testdaten verwenden wir das Original-Testset aus dem Vortraining (4.5.1).
Sichern des trainierten Modell-Zustands
Wir führen die Schritte aus 4.5.1 aus und sichern für die weiteren Tests die Gewichte des Modells im trainierten Zustand. Sie werden zu Beginn eines Nachtraining-Tests verwendet, um das Modell in den sauberen Gerade/Ungerade-Trainingszustand zurück zu setzen — statt jedes Mal diesen Zustand erneut durch Training herzustellen.
# Save trained state of model
w_trained = model.get_weights()# print(w_trained) # gibt den vortrainierten Zustand aus
4.5.4 Nachtraining Variante 1 — Mit nur ungeraden Vielfachen von 5, die wir wie folgt erzeugen:
# Vorrat an "Gezinkten" Nach-Trainingsdaten: ein paar reine Vielfache von 5nmin,nmax = 0,10000
n_cases = 500Z = np.random.randint(nmin,nmax,size=(n_cases))
y_5 = Z[:] % 10
y_5 = np.where(y_5 == 5,0,1) # Label 0 für ungerade Vielf. von 5sel = y_5 == 0 # Zum Nachtraining Selektion der
Z = Z[sel] # (ungeraden) Vielfache von 5
y = y_5[sel]print('Größe Nachtraining-Set:',Z.shape[0])
for i in range(10):
print(Z[i],y[i])
print('...')
n_cases = Z.shape[0]Größe Nachtraining-Set: 48
2065 0
4935 0
6455 0
1335 0
1535 0
855 0
7845 0
6065 0
7425 0
4535 0
...
Nachtraining. Zu Beginn wird das Modell stets mit den gesicherten Gewichten w_trained wieder in den Gerade/Ungerade-trainierten Zustand zurück versetzt.
Die Wahl der Hyperparameter (batch_size, epochs) und die Größe des Trainingssets beeinflussen Konvergenz und Ergebnis. Wir verzichten hier auf eine systematische Abdeckung aller Möglichkeiten.
# Always start with the Even/Odd-trained model state using saved weightsmodel.set_weights(w_trained)
# print(model.get_weights()) # Check weights resettraining_epochs = 200
bs = 10
hist1 = model.fit(npX[:], y[:],epochs=training_epochs,
batch_size=bs, verbose=0)
print([hist1.history['acc'][i] for i in range(0,200,10)])
# Plot mse, accuracy und die Entwicklung der Gewichte
...[0.0, 0.0, 0.0, 0.3541666744276881, 0.7291666666666666, 0.8125000049670538, 0.9583333283662796, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
Wir verzichten auf die Darstellung der Konvergenz durch loss- und accuracy-Plots. Das Training zeigt langsame Konvergenz, die Accuracy erreicht 1.0 nach etwa 70 Epochen.
Überprüfung mit den Gerade/Ungerade-Testdaten aus 4.5.1 ergibt (Code-Snippet s. in 4.5.2)
Abweichungen gegen Klassifikation der Testdaten:
Test : Value pred true
[5 5 5 6] : 0.831 1 0
[9 3 1 7] : 0.492 0 1
[9 1 7 7] : 0.497 0 1
[4 1 9 5] : 0.005 0 1
[0 4 1 5] : 0.017 0 1
[8 4 4 5] : 0.079 0 1
Accuracy: 88.000Die Accuracy bezieht sich auf die ursprüngliche Kategorisierung der Testdaten, also 0 für gerade, 1 für ungerade. So bedeutet z.B. 88%, dass wir 12% Fehlklassifikationen gegenüber Gerade/Ungerade haben, verursacht durch das Nachtraining (u.a. durch ungerade Vielfache von 5).
Es fällt auf, dass neben den Vielfachen von 5 auch einige Zahlen mit anderen Endziffern fehlklassifiziert werden — die gerade Zahl 5556 wird als ungerade klassifiziert, die beiden folgenden ungeraden als gerade. Bei den Vielfachen von 5 ist die Fehlklassifikation “gewollt”.
Offensichtlich ist das Modell etwas “durcheinander geraten”.
Darstellung der Gewichte: Wir versuchen wie oben über die Plots der Gewichte zu verstehen, wie dieser Effekt zustande kommt.
Während die roten Gewichte sich noch grob so darstellen, wie im vortrainierten Zustand, sind die blauen Gewichte heftig durcheinander geraten. Sie verteilen sich quasi erratisch, so dass man kaum die Gruppen trennen kann. Einzig die Gruppe für die Ziffer 5 liegt erkennbar eng zusammen auf Höhe Null, was erklärt, dass bei den Testdatenauswertungen ungerade Vielfache von 5 als “gerade” (Label 0) klassifiziert werden.
Nachtraining Variante 1 — Mit etwa halbem Training Set: Wir wählen beliebig den Teil [10:35] des Nachtrainings-Sets aus und wiederholen das Experiment in gleicher Weise.
# Always start with the Even/Odd-trained model state using saved weightsmodel.set_weights(w_trained)training_epochs = 400
# bs = ... Default
hist1 = model.fit(npX[10:35], y[10:35], epochs=training_epochs,
verbose=0)
print([hist1.history['acc'][i] for i in range(0,200,10)])
Das Ergebnis der Evaluation mit den Gerade/Ungerade-Testdaten zeigt folgendes Bild:
Abweichungen gegen Klassifikation der Testdaten:
Test : Value pred true
[9 3 1 7] : 0.437 0 1
[3 1 4 7] : 0.374 0 1
[9 1 7 7] : 0.412 0 1
[4 1 9 5] : 0.162 0 1
[0 4 1 5] : 0.113 0 1
[7 7 1 7] : 0.466 0 1
[9 3 8 7] : 0.278 0 1
[8 4 4 5] : 0.083 0 1
Accuracy: 84.000Auch hier gibt es zusätzliche (unsystematische) Fehlklassifikationen.
Die Gewichte zeigen jetzt folgendes Bild:
Bei diesem Versuch haben wir keine batch_size vorgegeben und über mehr Epochen iteriert (epochs = 400). Konvergenz beginnt bei etwa 200 Epochen. Das Evaluationsergebnis ist ähnlich dem zuvor. Die trainierten Gewichte zeigen eine etwas deutlichere Struktur: Die Gruppe für die Ziffer 5 liegt eng beieinander auf Höhe Null. Die anderen "Gruppen" scheinen eine unklare, alternierende Verteilung anzudeuten.
4.5.5 Nachtraining Variante 2 — Vermischtes Trainingsset, das wir wie in 4.5.2 erzeugen.
# Trainingsdatennmin,nmax = 0,10000
n_cases = 200Z = np.random.randint(nmin,nmax,size=(n_cases))y = Z[:] % 5
y = np.where(y > 0,Z % 2,y)# Padding auf vier Stellen und Encoding als array npX von Ziffern wie in 4.3
Nachtraining. Zu Beginn wird das Modell stets mit den gesicherten Gewichten w_trained wieder in den Gerade/Ungerade-trainierten Zustand zurück versetzt, anschließend erfolgt das Training sowie die Evaluation mit den bekannte Testdaten.
# Always start with the Even/Odd-trained model state using saved weights
model.set_weights(w_trainedtraining_epochs = 400
bs = 5
hist1 = model.fit(npX[:], y[:], epochs=training_epochs,batch_size=bs, verbose=0) #batch_size=bs,
Die Evaluation mit dem Testset zeigt nur die erwarteten Abweichungen bei den ungeraden Vielfachen von 5:
Abweichungen gegen Klassifikation der Testdaten:
Test : Value pred true
[4 1 9 5] : 0.000 0 1
[0 4 1 5] : 0.000 0 1
[8 4 4 5] : 0.000 0 1
Accuracy: 94.000Die Gewichte-Verteilung zeigt jetzt folgendes Bild:
Das Ergebnis sieht deutlich klarer aus. Für das Nachtraining wurd eine Datensatz von 200 klassifizierten Zahlen erzeugt, in dem 20 Fälle von ungeraden Vielfachen von 5 vorkommen. Das Training (model.fit) ging hier exemplarisch über 400 Epochen mit einer batch_size von 5 und konvergierte rasch nach ca. 20 Epochen.
Die Evaluation mit dem Testset zeigt nur die erwarteten Abweichungen bei den ungeraden Vielfachen von 5.
Die Gewichte (blau, in 6er-Gruppen) sind deutlicher strukturiert und alternieren als Ganzes zwischen positiven und negativen Wertebereichen. Das Cluster für die Ziffer 5 liegt auf gleicher Höhe wie das für die 4 und die 6.
Weitere Tests deuten darauf hin, dass die Gewichte-Gruppen tendenziell dem Muster aus 4.5.2 (Verfälschte Trainingsdaten) näher kommen, je größer die Nachtrainingsmenge ist — was durchaus verständlich ist, da ein Nachtraining mit gemischten Daten einem “normalen” Training mit anderen Startwerten für die Gewichte entspricht.
4.5.6 Einige Erkenntnisse — Zusammenfassung
- Durch systematische Falschklassifikation für Vielfache von 5 in den Trainingsdaten kann das NN-Modell für Gerade/Ungerade-Klassifikation gezielt darauf trainiert werden, falsche Vorhersagen (Klassifikationen) für neue Daten zu machen.
- Das entspricht einem “Bias-Effekt” z.B. bei großen NN-Systemen zur Bildinterpretation.
- Der “Bias-Effekt” kann durch unbeabsichtigte oder beabsichtigte Veränderung der Trainingsdaten bzw. durch Nachtraining unbemerkt erzeugt werden.
- Durch Inspektion und Vergleich der Gewichte im trainierten Zustand lassen sich — in gewissem Rahmen — Vorhersagen des Systems verstehen. Dabei kann man sich ggf. durchaus auf spezielle Layer eines mehrschichtigen NNs fokussieren.
- Es liegt nahe, zu überlegen die Interpretation der Gewichte-Muster ebenfalls maschinell zu unterstützen — etwa um die Ähnlichkeit zwischen den Gewichtsmustern aus 4.5.1–5 zu evaluieren und ggf. mit den Vorhersageergebnissen zu korrelieren. (Bei unseren “toy examples” ist das natürlich übertrieben.)
- Beim Nachtraining zeigen sich zudem überraschende Effekte:
- Das vortrainierte Modell wird durch Nachtraining offenbar erheblich “verwirrt”. Es lernt zwar ganz gut, Vielfache von 5 zu erkennen, wird aber bzgl. Gerade/Ungerade “unsicher” in der Vorhersage. Der Effekt ist unabhängig von Konvergenz-Paramtern (
batch_size, epochs). - Ein Nachtraining mit “reinen Umlern-Daten”, d.h. nur mit Vielfachen von 5, ist offenbar weniger effektiv und erzeugt mehr “Verwirrung” als ein Nachtraining mit einem allgemeinen Datensatz, in dem die Umlern-Daten eingestreut sind.
- Die Ergebnisse regen zu eine ganzen Reihen weiterer “Experimente” an, auf die wir hier aber nicht eingehen wollen.
Weiter lesen: 5 Komplexere NNs für komplexere Aufgaben
bernhard.thomas@becketal.com
www.becketal.com
