Theano - Triviales Trainingsbeispiel

Theano ist sehr nützlich beim Training neuronaler Netze, bei denen wir wiederholt Kosten und Gradienten berechnen müssen, um ein Optimum zu erreichen. Bei großen Datenmengen wird dies rechenintensiv. Theano macht dies aufgrund seiner internen Optimierungen des Rechengraphen, die wir zuvor gesehen haben, effizient.

Problemstellung

Wir werden nun lernen, wie man mit der Theano-Bibliothek ein Netzwerk trainiert. Wir nehmen einen einfachen Fall, in dem wir mit einem Datensatz mit vier Merkmalen beginnen. Wir berechnen die Summe dieser Merkmale, nachdem wir jedem Merkmal ein bestimmtes Gewicht (Wichtigkeit) zugewiesen haben.

Ziel des Trainings ist es, die jedem Merkmal zugewiesenen Gewichte so zu ändern, dass die Summe einen Zielwert von 100 erreicht.

sum = f1 * w1 + f2 * w2 + f3 * w3 + f4 * w4

Wo f1, f2, ... sind die Merkmalswerte und w1, w2, ... sind die Gewichte.

Lassen Sie mich das Beispiel quantifizieren, um die Problemstellung besser zu verstehen. Wir nehmen für jedes Merkmal einen Anfangswert von 1,0 an und nehmen w1 gleich0.1, w2 gleich 0.25, w3 gleich 0.15, und w4 gleich 0.3. Es gibt keine bestimmte Logik bei der Zuweisung der Gewichtswerte, es ist nur unsere Intuition. Somit ist die Anfangssumme wie folgt:

sum = 1.0 * 0.1 + 1.0 * 0.25 + 1.0 * 0.15 + 1.0 * 0.3

Welche Summen zu 0.8. Jetzt werden wir die Gewichtszuweisung so ändern, dass sich diese Summe 100 nähert. Der aktuelle resultierende Wert von0.8 ist weit entfernt von unserem gewünschten Zielwert von 100. In Bezug auf maschinelles Lernen definieren wir costals Differenz zwischen dem Zielwert minus dem aktuellen Ausgabewert, typischerweise quadriert, um den Fehler zu vergrößern. Wir reduzieren diese Kosten in jeder Iteration, indem wir die Gradienten berechnen und unseren Gewichtsvektor aktualisieren.

Lassen Sie uns sehen, wie diese gesamte Logik in Theano implementiert wird.

Variablen deklarieren

Wir deklarieren zuerst unseren Eingabevektor x wie folgt:

x = tensor.fvector('x')

Wo x ist ein eindimensionales Array von Gleitkommawerten.

Wir definieren einen Skalar target Variable wie unten angegeben -

target = tensor.fscalar('target')

Als nächstes erstellen wir einen Gewichtstensor W mit den oben diskutierten Anfangswerten -

W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')

Theano-Ausdruck definieren

Wir berechnen nun die Ausgabe mit dem folgenden Ausdruck:

y = (x * W).sum()

Beachten Sie dies in der obigen Erklärung x und Wsind die Vektoren und keine einfachen skalaren Variablen. Wir berechnen nun den Fehler (die Kosten) mit dem folgenden Ausdruck:

cost = tensor.sqr(target - y)

Die Kosten sind die Differenz zwischen dem Zielwert und der aktuellen Ausgabe im Quadrat.

Um den Gradienten zu berechnen, der uns sagt, wie weit wir vom Ziel entfernt sind, verwenden wir die integrierte Funktion grad Methode wie folgt -

gradients = tensor.grad(cost, [W])

Wir aktualisieren jetzt die weights Vektor durch eine Lernrate von 0.1 wie folgt -

W_updated = W - (0.1 * gradients[0])

Als nächstes müssen wir unseren Gewichtsvektor unter Verwendung der obigen Werte aktualisieren. Wir machen das in der folgenden Aussage -

updates = [(W, W_updated)]

Definieren / Aufrufen der Theano-Funktion

Zuletzt definieren wir a function in Theano, um die Summe zu berechnen.

f = function([x, target], y, updates=updates)

Um die obige Funktion eine bestimmte Anzahl von Malen aufzurufen, erstellen wir eine for Schleife wie folgt -

for i in range(10):
output = f([1.0, 1.0, 1.0, 1.0], 100.0)

Wie bereits erwähnt, ist die Eingabe für die Funktion ein Vektor, der die Anfangswerte für die vier Merkmale enthält - wir weisen den Wert von zu 1.0zu jedem Merkmal ohne besonderen Grund. Sie können verschiedene Werte Ihrer Wahl zuweisen und prüfen, ob die Funktion letztendlich konvergiert. Wir werden die Werte des Gewichtsvektors und der entsprechenden Ausgabe in jeder Iteration drucken. Es wird im folgenden Code gezeigt -

print ("iteration: ", i)
print ("Modified Weights: ", W.get_value())
print ("Output: ", output)

Vollständige Programmliste

Die vollständige Programmliste finden Sie hier als Kurzreferenz -

from theano import *
import numpy

x = tensor.fvector('x')
target = tensor.fscalar('target')

W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')
print ("Weights: ", W.get_value())

y = (x * W).sum()
cost = tensor.sqr(target - y)
gradients = tensor.grad(cost, [W])
W_updated = W - (0.1 * gradients[0])
updates = [(W, W_updated)]

f = function([x, target], y, updates=updates)
for i in range(10):
   output = f([1.0, 1.0, 1.0, 1.0], 100.0)
   print ("iteration: ", i)
   print ("Modified Weights: ", W.get_value())
   print ("Output: ", output)

Wenn Sie das Programm ausführen, sehen Sie die folgende Ausgabe:

Weights: [0.1 0.25 0.15 0.3 ]
iteration: 0
Modified Weights: [19.94 20.09 19.99 20.14]
Output: 0.8
iteration: 1
Modified Weights: [23.908 24.058 23.958 24.108]
Output: 80.16000000000001
iteration: 2
Modified Weights: [24.7016 24.8516 24.7516 24.9016]
Output: 96.03200000000001
iteration: 3
Modified Weights: [24.86032 25.01032 24.91032 25.06032]
Output: 99.2064
iteration: 4
Modified Weights: [24.892064 25.042064 24.942064 25.092064]
Output: 99.84128
iteration: 5
Modified Weights: [24.8984128 25.0484128 24.9484128 25.0984128]
Output: 99.968256
iteration: 6
Modified Weights: [24.89968256 25.04968256 24.94968256 25.09968256]
Output: 99.9936512
iteration: 7
Modified Weights: [24.89993651 25.04993651 24.94993651 25.09993651]
Output: 99.99873024
iteration: 8
Modified Weights: [24.8999873 25.0499873 24.9499873 25.0999873]
Output: 99.99974604799999
iteration: 9
Modified Weights: [24.89999746 25.04999746 24.94999746 25.09999746]
Output: 99.99994920960002

Beachten Sie, dass nach vier Iterationen die Ausgabe erfolgt 99.96 und nach fünf Iterationen ist es 99.99, was nahe an unserem gewünschten Ziel von liegt 100.0.

Abhängig von der gewünschten Genauigkeit können Sie sicher schließen, dass das Netzwerk in 4 bis 5 Iterationen trainiert wird. Suchen Sie nach Abschluss des Trainings nach dem Gewichtsvektor, der nach 5 Iterationen die folgenden Werte annimmt:

iteration: 5
Modified Weights: [24.8984128 25.0484128 24.9484128 25.0984128]

Sie können diese Werte jetzt in Ihrem Netzwerk zum Bereitstellen des Modells verwenden.