Benutzer:ThePacker/ MachineLearning/ CrossEntropySoftmax

Aus Wikibooks
Zur Navigation springen Zur Suche springen
  • Die Daten für das folgende MachineLearningProjekt können Sie hier herunterladen: http://yann.lecun.com/exdb/mnist/
    • Sie werden folgende Dateien benötigen.
      • train-images-idx3-ubyte.gz: training set images (9912422 bytes)
      • train-labels-idx1-ubyte.gz: training set labels (28881 bytes)
      • t10k-images-idx3-ubyte.gz: test set images (1648877 bytes)
      • t10k-labels-idx1-ubyte.gz: test set labels (4542 bytes)
  • Die Ziele dieser Üung sind:
    • ein 1 Layer Neuronal Netzwerk zu implementieren
    • es zu trainieren
    • den Fehler zu bestimmen, wenn wir das trainierte Netz auf Daten anwenden, die das trainierte Netz nicht zur Verfügung hatte
  • Struktur:
    • Datenverarbeitung
    • Layer-Variablen
    • Model
    • Lossfunction / Optimizer
    • INIT Tensorflow - Variableninitialisierung
    • Start einer Tensorflow-session
    • Training und Evaluation

Daten(vor)verarbeitung[Bearbeiten]

Um mit den MNIST-Daten auf abstrakter Ebene zu arbeiten, bringt Tensorflow eine fertige Bibliothek mit, so dass das Einlesen und Verarbeiten der MNIST-Daten nicht immer wieder aufs Neue implementiert werden muss.

import tensorflow as tf

from tensorflow.examples.tutorials.mnist import input_data as mnist_data

mnist = mnist_data.read_data_sets("data/MNIST/", one_hot=True,reshape=False,validation_size=0)

Auf diese Daten können wir anschließend mittels

  • mnist.train
  • mnist.test
    • mnist.test.images bzw. mnist,test.labels

zugreifen, ohne uns darüber Gedanken machen zu müssen,

  • wie wir die Daten interpretieren müssen,
  • sie in Python einlesen müssen
  • wie wir die Daten aufbereiten müssen

und dergleichen. Das erlaubt es uns, uns ausschließlich mit dem Teil auseinanderzusetzen, der für das Training der neuronalen Netze relevant ist.

Training des neuronalen Netzes[Bearbeiten]

Das Training erfolgt, indem wir über eine Schleife hinweg einen Stapel (batch) Bilder und korrekte Labels besorgen und das Training für diesen Stapel vornehmen und für den den folgenden Stapel wiederholen. Je nach Komplexität und Beschaffenheit des neuronalem Netzes müssen diese Eingaben (in unserem Fall Pixel von Bildern) mehrfach trainiert werden. Wenn wir das neuronale Netz einmal mit allen Bildern trainiert haben, entspricht das exakt einer Epoche.

Für das Training füllen wir die beiden Platzhalter X und Y_ mit unseren zu trainierenden Daten und übergeben diese Daten an TensorFlow myTFSession.run(train_step, feed_dict=train_data)

for i in range(1000):
    # print current batch number
    print(i)

    # load batch of one hundred training images and one hundred training labels
    batchOfImages, batchOfLabels = mnist.train.next_batch(100)
    train_data={X: batchOfImages, Y_:batchOfLabels}

    # training
    myTFSession.run(train_step, feed_dict=train_data)

Das Prinzip für das Training ist immer wieder gleich. Diese Art der Trainingsschleife findet sich immer und immer wieder. Die Platzhalter für die Trainingsdaten werden befüllt und anschließend führt man genau einen Trainingsschritt aus. Je nach weiterer Parametrierung des Netzes / Graphen müssen noch zusätzliche Daten für die Platzhalter in "train_data" eingetragen werden. train_step beinhaltet den kompletten Graphen, der auch den zentralen Optimierungsschritt enthält.

Gesamter Sourcecode - MNIST - CrossEntropy Softmax[Bearbeiten]

import tensorflow as tf

from tensorflow.examples.tutorials.mnist import input_data as mnist_data

Tensorflow - Erläuterungen zum Berechnungsmodell[Bearbeiten]

Tensorflow ist eine Bibliothek, die sich andere Python-Bibliotheken wie unter Anderem "numpy" zu Nutze macht. Wir werden im Prinzip von den mathematischen Details verschont. Wenn man die GPU-Variante von Tensorflow installiert hat, so werden die ganzen mathematischen Operationen auf die Grafikkarte ausgelagert. Dazu müssen die Daten vom Arbeitsspeicher der CPU in den Arbeitsspeicher der Grafikkarte kopiert werden auch diese Aufgabe übernimmt Tensorflow für uns.

Da die GPU der Grafikkarte im Vergleich zur CPU sehr viele Daten und diese auch parallel verarbeiten kann und sich zwischen der GPU und den Daten ein Python-Interpreter befindet, wäre es nicht hilfreich, wenn die GPU für jede einzelne Operation (bspw. Matrixmultiplikation) ständig Daten vom Pythoninterpreter anfordern muss. Statt dessen wird von Tensorflow ein entsprechender Computational Graph aufgebaut, der evaluiert wird. Dieser Graph wird intern in einzelne Matrizen-Operationen übersetzt und anschließend für wechselnde Datensätze parametriert und auf der Grafikkarte ausgeführt. Anschließend werden die Ergebnisse der Berechnung wieder an das Python-Programm übergeben.

Unsere Aufgabe besteht darin, einen oder mehrere Computational Graphen aufzubauen, die wir kontinuierlich evaluieren, einerseits, um das Netzwerk anzulernen (Forward + Backward Path) oder um die Ergebnisse des angelernten Netzwerks auf die Test-Daten anzuwenden (Forward Path).

Tensorflow - Session / Initialisierung[Bearbeiten]

Wir initialisieren Tensorflow für gewöhnlich, indem wir die globalen Variablen initialisieren, bevor wir diese aktive für Berechnungen benutzen. Dazu müssen zur Laufzeit alle diese Variablen, die wir im Rahmen unserer Berecnung nutzen wollen vorher deklariert (bekannt gemacht) worden sein.

Das Ergebnis von tf.global_variables_initializer() ist ein Graph, der wenn wir ihn evaluieren, alle unsere zuvor definierten Variablen und Platzhalter initialisiert.

Dazu erstellen wir uns eine Tensorflow-Session via tf.Session() und evaluieren den initGraph via myTFSession.run(initGraph).

Hier der vollständige Code, um eine Session zu initialisieren.

import tensorflow as tf

initGraph = tf.global_variables_initializer()

myTFSession = tf.Session()
myTFSession.run(initGraph)

Die Deklaration von Variablen und Platzhaltern kann vor dem Aufruf tf.global_variables_initializer() oder nach dem Aufruf von tf.global_variables_initializer() erfolgen, aber vor dem Erstellen der Session mit tf.Session().

TensorFlow - Konstanten, Variablen und Platzhalter[Bearbeiten]

TensorFlow kennt drei wichtige Arten von Daten

  • Konstanten - tf.Constant( ... )
    • Sind Werte in einem Graph, die sich zur Laufzeit nicht ändern.
  • Variablen - tf.Variable( ... )
    • Sind Werte in einem Graph, die sich zur Laufzeit ändern können. Bleiben wertetechnisch über mehrere Graphen-Evaluation (myTFSession.run( ... )) hinweg erhalten.
  • Platzhalter - tf.placeholder( ... )
    • Sind Werte, die als Eingabeplatzhalter dienen, die erst zum Zeitpunkt der Graphen-Evaluation (myTFSession.run( ... )) bereitgestellt werden (meist einmalig). Die Position des Platzhalters verändert sich im Computational Graph nicht, sondern lediglich seine Werte oder Teile seiner Dimensionen können sich verändern.

Die konkreten Werte sind für gewöhnlich mehrdimensionale Matrizen. In TensorFlow werden diese Matrizen als Tensor behandelt und alle Rechnenoperationen auf diesen mehrdimensionalen Werten erfolgen unter Anwendung der Tensorrechnung.