Open Source im professionellen Einsatz
Linux-Magazin 07/2017
893

KI-Fütterung

Tensorflow erwartet die mathematischen Gleichungen zum Betreiben eines Modells als so genannte »Nodes« in einem Graphen, den es in »Sessions« mit Parametern füllt und wieder und wieder ausführt, entweder auf einem einzigen PC oder auch gerne parallel auf ganzen Clustern von Maschinen im Rechenzentrum. Listing 1 definiert die Geradengleichung für das lineare Modell in Zeile 22 als »Y=X*W+b« .

Listing 1

linreg.py

01 #!/usr/bin/python3
02 import pandas as pd
03 import tensorflow as tf
04 import numpy
05 import os
06
07 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
08
09 rnd             = numpy.random
10 learning_rate   = .01
11 training_epochs = 2000
12 chkpoint        = 250
13
14 train_df = pd.read_csv("odometer.csv")
15
16 X = tf.placeholder("float")
17 Y = tf.placeholder("float")
18
19 W = tf.Variable(rnd.randn(), name="weight")
20 b = tf.Variable(rnd.randn(), name="bias")
21
22   # model: Y = X*W + b
23 pred = tf.add(tf.multiply(X, W), b)
24
25   # mean squared error
26 total = len(train_df.index)
27 cost  = tf.reduce_sum(
28     tf.pow(pred-Y, 2))/(2*total)
29
30   # normalize training set
31 nn_offset=int(train_df[['date']].min())
32 nn_div=int(train_df[['date']].max() -
33        train_df[['date']].min())
34 print("norm_off=", nn_offset)
35 print("norm_mult=", nn_div)
36 train_df['date'] -= nn_offset
37 train_df['date'] /= nn_div
38
39 opt = tf.train.GradientDescentOptimizer(
40     learning_rate).minimize(cost)
41
42 init = tf.global_variables_initializer()
43
44   # tensorflow session
45 with tf.Session() as sess:
46     sess.run(init)
47     for epoch in range(training_epochs):
48         for ix, row in train_df.iterrows():
49             sess.run(opt, feed_dict={
50                 X: row['date'],
51                 Y: row['miles']})
52         if epoch % chkpoint == 0:
53             c=sess.run(cost, feed_dict={
54                 X: train_df['date'],
55                 Y: train_df['miles']})
56             print("W=", sess.run(W),
57                   "b=", sess.run(b),
58                   "cost=", c)

Die Variable »X« ist hier der Eingabewert für die Simulation, sie gibt also den Zeitwert vor, zu dem das Verfahren den Kilometerstand »Y« als Ausgabe errechnet. Die Parameter »W« (Weight) und »b« (Bias) zum Multiplizieren von X beziehungsweise zum Addieren eines Offsets soll das Modell im Training bestimmen, und zwar so, dass Y dann möglichst genau dem Kilometerstand im Training zum Zeitpunkt X entspricht.

Hierzu definieren die Zeilen 16 bis 17 die Variablen »X« und »Y« als »placeholder« und die Zeilen 19 bis 20 die Parameter »W« und »b« als »Variable« und initialisieren sie mit zufälligen Werten aus der Random-Bibliothek des »numpy« -Moduls. Zeile 14 liest in einem Rutsch die in zwei Spalten »date« und »miles« vorliegenden Daten der CSV-Datei in einen Pandas-Dataframe ein, einer Art Tabelle mit zwei Spalten.

Das eigentliche Training übernimmt der Optimizer in Zeile 39, der nach dem Gradient-Descent-Verfahren versucht die Geradengleichung durch Modifizieren der Parameter »W« und »b« so lange an die Einzelpunkte aus den Trainingsdaten anzupassen, bis die ab Zeile 27 definierte Kosten- (oder Fehler-)Kalkulation »cost« auf einen minimalen Wert fällt. Sie definiert dazu, wieder in Tensorflow-Semantik, die mittlere quadratische Abweichung aller Trainingspunkte von der durch »W« und »b« bestimmten Geraden.

In der ab Zeile 45 laufenden Tensorflow-Session iteriert die For-Schleife ab Zeile 47 über alle in Zeile 11 festgesetzten 2000 Trainingseinheiten und berechnet für je 250 Durchgänge den Wert für die Kostenfunktion, um den User bei Laune zu halten. Fürs Training muss Tensorflow aber letztlich nur in Zeile 49 mit »run« die Session mit den aktuellen X- und Y-Werten aufrufen, die dann über den Optimizer im Hintergrund die Formel in Zeile 23 aufruft, das Ergebnis ausrechnet und ihrerseits über die Kostenfunktion die Parameter weiter anpasst. Nach 2000 Durchgängen zeigt sich das Bild in Abbildung 3, der Wert für »W« pendelt sich auf 6491 ein, der für »b« auf 32838.

Abbildung 3: Der Lern-Algorithmus minimiert schrittweise die als Kosten bezeichneten Abweichungen.

Normal bleiben

Allerdings klappt die Regression nur, falls die Trainingsdaten vorher auf einen begrenzten Wertebereich normalisiert wurden. Füttert das Skript etwa den Optimizer mit den unmodifizierten Unix-Sekunden, schaukelt sich dieser auf und produziert immer unsinnigere Werte, bis er schließlich die Grenzen der Fließkommazahlen sprengt und alle Parameter auf »nan« (Not a Number) setzt.

Deshalb normalisieren die Zeilen 31 bis 37 in Listing 1 die Trainingsdaten vorab nach der Min-Max-Methode, finden mit den Pandas-Methoden »min()« und »max()« den minimalen und den maximalen Zeitstempelwert, ziehen ersteren als Offset von allen Trainingswerten ab und dividieren sie anschließend durch die Min-Max-Differenz.

Heraus kommen dann normalerweise Trainingswerte zwischen 0 und 1 (aber Achtung falls min=max!), die der Optimizer besser verarbeitet.

Mit den gelernten Parametern lassen sich nun im Rahmen des Modells historische Werte reproduzieren oder auch die Zukunft voraussagen. Welchen Kilometerstand wird das Auto am 2. Juni 2019 aufweisen? Das Datum hat einen Epoch-Wert von 1559516400, den das Modell genau wie im Trainingsfall erst normalisieren muss. Der in Abbildung 3 gefundene Offset »norm_off« von 1486972800 wird abgezogen und das Eingabedatum auch noch durch den Skalierungsfaktor »norm_mult« von 7686000 geteilt.

Es ergibt sich ein X-Wert von 9.43, der in die Formel »Y=X*W+b« eingesetzt einen Kilometerstand von 94.115 voraussagt. Alles unter der Annahme natürlich, dass das Modell stimmt, also ein linearer Anstieg vorliegt, und dass die drei Monate Trainingsdaten für die genaue Ermittlung des Anstiegs ausreichen.

Diesen Artikel als PDF kaufen

Express-Kauf als PDF

Umfang: 4 Heftseiten

Preis € 0,99
(inkl. 19% MwSt.)

Linux-Magazin kaufen

Einzelne Ausgabe
 
Abonnements
 
TABLET & SMARTPHONE APPS
Bald erhältlich
Get it on Google Play

Deutschland

Ähnliche Artikel

  • Machine Learning

    Der Arbeitgeber von Autor Chris Hinze litt wie vermutlich alle Homepage-Baukasten-Anbieter unter Spammern und illegalen Inhalten. Ein Praxisbericht, der auf der Theorie des Deep Learning beruht.

  • Snapshot

    2, 5, 7, 10, 12 – und welche Zahl kommt als nächste? Michael Schilli testet, ob sich von Psychologen erdachte Intelligenztests mit modernen KI-Automaten knacken lassen.

  • Tensorflow erreicht Version 1.0

    Tensorflow 1.0 verspricht Stabilität für sein Python API und beschleunigt die aktuelle und zukünftige Arbeit mit der Einführung des domain-spezifischen XLA Compilers.

  • Screencast zum Snapshot 07/2017

    Anhand von Trainingsdaten in Form von täglich im Auto erfassten Kilometerständen versucht Michael Schillis ein KI-Programm, Muster im Fahrverhalten zu erlernen und Prognosen für die Zukunft abzugeben.

  • Verständnisfrage

    Als Prüfer Programmcode oder Multiple-Choice-Fragen elektronisch auszuwerten ist nicht allzu schwer. Doch das Korrektursystem zur Linux-Vorlesung an der Hochschule Heidelberg versteht nicht nur vorformulierte Textbausteine, sondern auch Freitextantworten.

comments powered by Disqus

Ausgabe 10/2017

Digitale Ausgabe: Preis € 6,40
(inkl. 19% MwSt.)

Artikelserien und interessante Workshops aus dem Magazin können Sie hier als Bundle erwerben.