Theano - Kurzanleitung

Haben Sie Modelle für maschinelles Lernen in Python entwickelt? Dann kennen Sie natürlich die Feinheiten bei der Entwicklung dieser Modelle. Die Entwicklung ist in der Regel ein langsamer Prozess, der Stunden und Tage Rechenleistung in Anspruch nimmt.

Die Modellentwicklung für maschinelles Lernen erfordert viele mathematische Berechnungen. Diese erfordern im Allgemeinen arithmetische Berechnungen, insbesondere große Matrizen mit mehreren Dimensionen. Heutzutage verwenden wir neuronale Netze anstelle der traditionellen statistischen Techniken zur Entwicklung von Anwendungen für maschinelles Lernen. Die neuronalen Netze müssen über eine große Datenmenge trainiert werden. Das Training wird in Datenstapeln von angemessener Größe durchgeführt. Somit ist der Lernprozess iterativ. Wenn die Berechnungen nicht effizient durchgeführt werden, kann das Training des Netzwerks mehrere Stunden oder sogar Tage dauern. Daher ist die Optimierung des ausführbaren Codes sehr erwünscht. Und genau das bietet Theano.

Theano ist eine Python-Bibliothek, mit der Sie mathematische Ausdrücke definieren können, die beim maschinellen Lernen verwendet werden, diese Ausdrücke optimieren und diese sehr effizient bewerten können, indem Sie GPUs in kritischen Bereichen entscheidend einsetzen. In den meisten Fällen kann es mit typischen vollständigen C-Implementierungen mithalten.

Theano wurde im LISA-Labor mit der Absicht geschrieben, effiziente Algorithmen für maschinelles Lernen schnell zu entwickeln. Es wird unter einer BSD-Lizenz veröffentlicht.

In diesem Tutorial lernen Sie die Verwendung der Theano-Bibliothek.

Theano kann unter Windows, MacOS und Linux installiert werden. Die Installation ist in allen Fällen trivial. Bevor Sie Theano installieren, müssen Sie seine Abhängigkeiten installieren. Das Folgende ist die Liste der Abhängigkeiten -

• Python
• NumPy - Erforderlich
• SciPy - Nur für Sparse Matrix und Sonderfunktionen erforderlich
• BLAS - Bietet Standardbausteine ​​für die Ausführung grundlegender Vektor- und Matrixoperationen

Die optionalen Pakete, die Sie je nach Ihren Anforderungen installieren können, sind:

• Nase: Um Theanos Testsuite auszuführen
• Sphinx - Zur Gebäudedokumentation
• Graphiz und Pydot - Zum Umgang mit Grafiken und Bildern
• NVIDIA CUDA-Treiber - Erforderlich für die Generierung / Ausführung von GPU-Code
• libgpuarray - Erforderlich für die GPU / CPU-Codegenerierung auf CUDA- und OpenCL-Geräten

Wir werden die Schritte zur Installation von Theano unter MacOS besprechen.

MacOS-Installation

Um Theano und seine Abhängigkeiten zu installieren, verwenden Sie pipvon der Kommandozeile wie folgt. Dies sind die minimalen Abhängigkeiten, die wir in diesem Tutorial benötigen.

$ pip install Theano
$ pip install numpy
$ pip install scipy
$ pip install pydot

Sie müssen das OSx-Befehlszeilenentwickler-Tool auch mit dem folgenden Befehl installieren:

$ xcode-select --install

Sie sehen den folgenden Bildschirm. Klick auf dasInstall Schaltfläche zum Installieren des Tools.

Nach erfolgreicher Installation wird die Erfolgsmeldung auf der Konsole angezeigt.

Installation testen

Öffnen Sie nach erfolgreicher Installation ein neues Notizbuch im Anaconda Jupyter. Geben Sie in die Codezelle das folgende Python-Skript ein:

Beispiel

import theano
from theano import tensor
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a,b], c)
d = f(1.5, 2.5)
print (d)

Ausgabe

Führen Sie das Skript aus und Sie sollten die folgende Ausgabe sehen -

4.0

Der Screenshot der Ausführung dient unten als Kurzreferenz -

Wenn Sie die obige Ausgabe erhalten, ist Ihre Theano-Installation erfolgreich. Wenn nicht, befolgen Sie die Debug-Anweisungen auf der Theano-Download-Seite, um die Probleme zu beheben.

Was ist Theano?

Nachdem Sie Theano erfolgreich installiert haben, versuchen wir zunächst zu verstehen, was Theano ist. Theano ist eine Python-Bibliothek. Sie können damit mathematische Ausdrücke definieren, optimieren und auswerten, insbesondere diejenigen, die bei der Entwicklung von Modellen für maschinelles Lernen verwendet werden. Theano selbst enthält keine vordefinierten ML-Modelle. es erleichtert nur seine Entwicklung. Dies ist besonders nützlich, wenn Sie sich mit mehrdimensionalen Arrays befassen. Es lässt sich nahtlos in NumPy integrieren, ein grundlegendes und weit verbreitetes Paket für wissenschaftliche Berechnungen in Python.

Theano erleichtert die Definition mathematischer Ausdrücke, die in der ML-Entwicklung verwendet werden. Solche Ausdrücke umfassen im Allgemeinen Matrixarithmetik, Differenzierung, Gradientenberechnung und so weiter.

Theano erstellt zunächst den gesamten Computational Graph für Ihr Modell. Anschließend wird es in hocheffizienten Code kompiliert, indem verschiedene Optimierungstechniken auf das Diagramm angewendet werden. Der kompilierte Code wird durch eine spezielle Operation namens in die Theano-Laufzeit eingefügtfunctionerhältlich in Theano. Wir führen dies ausfunctionwiederholt, um ein neuronales Netzwerk zu trainieren. Die Trainingszeit ist im Vergleich zur Verwendung von reiner Python-Codierung oder sogar einer vollständigen C-Implementierung erheblich reduziert.

Wir werden jetzt den Prozess der Theano-Entwicklung verstehen. Beginnen wir mit der Definition eines mathematischen Ausdrucks in Theano.

Beginnen wir unsere Reise von Theano mit der Definition und Bewertung eines trivialen Ausdrucks in Theano. Betrachten Sie den folgenden trivialen Ausdruck, der zwei Skalare hinzufügt:

c = a + b

Wo a, b sind Variablen und cist die Ausdrucksausgabe. In Theano ist es schwierig, selbst diesen trivialen Ausdruck zu definieren und zu bewerten.

Lassen Sie uns die Schritte zur Bewertung des obigen Ausdrucks verstehen.

Theano importieren

Zuerst müssen wir die Theano-Bibliothek in unser Programm importieren, was wir mit der folgenden Anweisung tun:

from theano import *

Anstatt die einzelnen Pakete zu importieren, haben wir in der obigen Anweisung * verwendet, um alle Pakete aus der Theano-Bibliothek einzuschließen.

Variablen deklarieren

Als nächstes deklarieren wir eine Variable namens a mit der folgenden Anweisung -

a = tensor.dscalar()

Das dscalarMethode deklariert eine dezimale skalare Variable. Die Ausführung der obigen Anweisung erstellt eine Variable namensain Ihrem Programmcode. Ebenso werden wir eine Variable erstellenb mit der folgenden Anweisung -

b = tensor.dscalar()

Ausdruck definieren

Als nächstes definieren wir unseren Ausdruck, der mit diesen beiden Variablen arbeitet a und b.

c = a + b

In Theano führt die Ausführung der obigen Anweisung nicht die skalare Addition der beiden Variablen durch a und b.

Theano-Funktion definieren

Um den obigen Ausdruck zu bewerten, müssen wir eine Funktion in Theano wie folgt definieren:

f = theano.function([a,b], c)

Die Funktion functionnimmt zwei Argumente, das erste Argument ist eine Eingabe für die Funktion und das zweite ist ihre Ausgabe. Die obige Deklaration besagt, dass das erste Argument vom Typ Array ist, das aus zwei Elementen bestehta und b. Die Ausgabe ist eine skalare Einheit namensc. Diese Funktion wird mit dem Variablennamen referenziertf in unserem weiteren Code.

Theano-Funktion aufrufen

Der Aufruf der Funktion f erfolgt mit folgender Anweisung:

d = f(3.5, 5.5)

Die Eingabe für die Funktion ist ein Array, das aus zwei Skalaren besteht: 3.5 und 5.5. Die Ausgabe der Ausführung wird der skalaren Variablen zugewiesend. So drucken Sie den Inhalt vondwerden wir die verwenden print Aussage -

print (d)

Die Ausführung würde den Wert von verursachen d auf der Konsole gedruckt werden, die in diesem Fall 9.0 ist.

Vollständige Programmliste

Die vollständige Programmliste finden Sie hier als Kurzreferenz -

from theano import *
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a,b], c)
d = f(3.5, 5.5)
print (d)

Führen Sie den obigen Code aus und Sie sehen die Ausgabe als 9.0. Der Screenshot wird hier gezeigt -

Lassen Sie uns nun ein etwas komplexeres Beispiel diskutieren, das die Multiplikation zweier Matrizen berechnet.

Wir werden ein Punktprodukt aus zwei Matrizen berechnen. Die erste Matrix hat die Dimension 2 x 3 und die zweite die Dimension 3 x 2. Die Matrizen, die wir als Eingabe verwendet haben, und ihr Produkt werden hier ausgedrückt -

$$ \ begin {bmatrix} 0 & -1 & 2 \\ 4 & 11 & 2 \ end {bmatrix} \: \ begin {bmatrix} 3 & -1 \\ 1 & 2 \\ 35 & 20 \ end {bmatrix} = \ begin {bmatrix} 11 & 0 \\ 35 & 20 \ end {bmatrix} $$

Variablen deklarieren

Um einen Theano-Ausdruck für das Obige zu schreiben, deklarieren wir zuerst zwei Variablen, um unsere Matrizen wie folgt darzustellen:

a = tensor.dmatrix()
b = tensor.dmatrix()

Die Matrix ist die Art der Matrizen für Doppel. Beachten Sie, dass wir die Matrixgröße nirgendwo angeben. Somit können diese Variablen Matrizen jeder Dimension darstellen.

Ausdruck definieren

Zur Berechnung des Punktprodukts haben wir die integrierte Funktion aufgerufen dot wie folgt -

c = tensor.dot(a,b)

Die Ausgabe der Multiplikation wird einer Matrixvariablen namens aufgerufen c.

Theano-Funktion definieren

Als nächstes definieren wir eine Funktion wie im vorherigen Beispiel, um den Ausdruck auszuwerten.

f = theano.function([a,b], c)

Beachten Sie, dass die Eingabe für die Funktion zwei Variablen a und b sind, die vom Matrixtyp sind. Der Funktionsausgang ist der Variablen zugeordnetc das wäre automatisch vom Matrixtyp.

Theano-Funktion aufrufen

Wir rufen die Funktion nun mit der folgenden Anweisung auf:

d = f([[0, -1, 2], [4, 11, 2]], [[3, -1],[1,2], [6,1]])

Die beiden Variablen in der obigen Anweisung sind NumPy-Arrays. Sie können NumPy-Arrays explizit wie hier gezeigt definieren -

f(numpy.array([[0, -1, 2], [4, 11, 2]]),
numpy.array([[3, -1],[1,2], [6,1]]))

Nach d berechnet werden wir drucken seinen Wert -

print (d)

Sie sehen die folgende Ausgabe auf der Ausgabe -

[[11. 0.]
[25. 20.]]

Vollständige Programmliste

The complete program listing is given here:
from theano import *
a = tensor.dmatrix()
b = tensor.dmatrix()
c = tensor.dot(a,b)
f = theano.function([a,b], c)
d = f([[0, -1, 2],[4, 11, 2]], [[3, -1],[1,2],[6,1]])
print (d)

Der Screenshot der Programmausführung wird hier gezeigt -

Anhand der beiden obigen Beispiele haben Sie möglicherweise bemerkt, dass wir in Theano einen Ausdruck erstellen, der schließlich mit Theano ausgewertet wird function. Theano verwendet erweiterte Optimierungstechniken, um die Ausführung eines Ausdrucks zu optimieren. Zur Visualisierung des Berechnungsdiagramms bietet Theano aprinting Paket in seiner Bibliothek.

Symbolisches Diagramm für die Skalaraddition

Verwenden Sie die Druckbibliothek wie folgt, um das Berechnungsdiagramm für unser Skalaradditionsprogramm anzuzeigen:

theano.printing.pydotprint(f, outfile="scalar_addition.png", var_with_name_simple=True)

Wenn Sie diese Anweisung ausführen, wird eine Datei aufgerufen scalar_addition.pngwird auf Ihrem Computer erstellt. Das gespeicherte Berechnungsdiagramm wird hier als Kurzreferenz angezeigt -

Die vollständige Programmliste zum Generieren des obigen Bildes finden Sie unten -

from theano import *
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a,b], c)
theano.printing.pydotprint(f, outfile="scalar_addition.png", var_with_name_simple=True)

Symbolisches Diagramm für den Matrixmultiplikator

Versuchen Sie nun, das Berechnungsdiagramm für unseren Matrixmultiplikator zu erstellen. Die vollständige Liste zum Generieren dieses Diagramms finden Sie unten -

from theano import *
a = tensor.dmatrix()
b = tensor.dmatrix()
c = tensor.dot(a,b)
f = theano.function([a,b], c)
theano.printing.pydotprint(f, outfile="matrix_dot_product.png", var_with_name_simple=True)

Das generierte Diagramm wird hier angezeigt -

Komplexe Graphen

In größeren Ausdrücken können die Berechnungsgraphen sehr komplex sein. Ein solches Diagramm aus der Theano-Dokumentation wird hier gezeigt -

Um die Arbeitsweise von Theano zu verstehen, ist es wichtig, zunächst die Bedeutung dieser Rechengraphen zu kennen. Mit diesem Verständnis werden wir die Bedeutung von Theano kennen.

Warum Theano?

Wenn Sie sich die Komplexität der Berechnungsgraphen ansehen, können Sie jetzt den Zweck der Entwicklung von Theano verstehen. Ein typischer Compiler würde lokale Optimierungen im Programm bereitstellen, da er niemals die gesamte Berechnung als eine Einheit betrachtet.

Theano implementiert sehr fortschrittliche Optimierungstechniken, um den vollständigen Rechengraphen zu optimieren. Es kombiniert die Aspekte der Algebra mit Aspekten eines optimierenden Compilers. Ein Teil des Diagramms kann in C-Code kompiliert werden. Für wiederholte Berechnungen ist die Auswertungsgeschwindigkeit kritisch und Theano erfüllt diesen Zweck, indem es einen sehr effizienten Code generiert.

Nachdem Sie die Grundlagen von Theano verstanden haben, beginnen wir mit den verschiedenen Datentypen, die Ihnen zum Erstellen Ihrer Ausdrücke zur Verfügung stehen. Die folgende Tabelle enthält eine unvollständige Liste der in Theano definierten Datentypen.

Datentyp	Theano Typ
Byte	bscalar, bvector, bmatrix, brow, bcol, btensor3, btensor4, btensor5, btensor6, btensor7
16-Bit-Ganzzahlen	wscalar, wvector, wmatrix, wrow, wcol, wtensor3, wtensor4, wtensor5, wtensor6, wtensor7
32-Bit-Ganzzahlen	iscalar, ivector, imatrix, irow, icol, itensor3, itensor4, itensor5, itensor6, itensor7
64-Bit-Ganzzahlen	lscalar, lvector, lmatrix, lrow, lcol, ltensor3, ltensor4, ltensor5, ltensor6, ltensor7
schweben	fscalar, fvector, fmatrix, frow, fcol, ftensor3, ftensor4, ftensor5, ftensor6, ftensor7
doppelt	dscalar, dvector, dmatrix, drow, dcol, dtensor3, dtensor4, dtensor5, dtensor6, dtensor7
Komplex	cscalar, cvector, cmatrix, krähe, ccol, ctensor3, ctensor4, ctensor5, ctensor6, ctensor7

Die obige Liste ist nicht vollständig und der Leser wird für eine vollständige Liste auf das Tensor-Erstellungsdokument verwiesen.

Ich werde Ihnen nun einige Beispiele geben, wie Sie Variablen verschiedener Arten von Daten in Theano erstellen.

Skalar

Um eine skalare Variable zu erstellen, verwenden Sie die Syntax -

Syntax

x = theano.tensor.scalar ('x')
x = 5.0
print (x)

Ausgabe

5.0

Eindimensionales Array

Verwenden Sie die folgende Deklaration, um ein eindimensionales Array zu erstellen:

Beispiel

f = theano.tensor.vector
f = (2.0, 5.0, 3.0)
print (f)f = theano.tensor.vector
f = (2.0, 5.0, 3.0)
print (f)
print (f[0])
print (f[2])

Ausgabe

(2.0, 5.0, 3.0)
2.0
3.0

Wenn Sie tun f[3] es würde einen Indexfehler außerhalb des Bereichs erzeugen, wie hier gezeigt -

print f([3])

Ausgabe

IndexError                          Traceback (most recent call last)
<ipython-input-13-2a9c2a643c3a> in <module>
   4 print (f[0])
   5 print (f[2])
----> 6 print (f[3])
IndexError: tuple index out of range

Zweidimensionales Array

Um ein zweidimensionales Array zu deklarieren, verwenden Sie das folgende Codefragment:

Beispiel

m = theano.tensor.matrix
m = ([2,3], [4,5], [2,4])
print (m[0])
print (m[1][0])

Ausgabe

[2, 3]
4

5-dimensionales Array

Verwenden Sie die folgende Syntax, um ein 5-dimensionales Array zu deklarieren:

Beispiel

m5 = theano.tensor.tensor5
m5 = ([0,1,2,3,4], [5,6,7,8,9], [10,11,12,13,14])
print (m5[1])
print (m5[2][3])

Ausgabe

[5, 6, 7, 8, 9]
13

Sie können ein dreidimensionales Array mithilfe des Datentyps deklarieren tensor3 anstelle von tensor5ein 4-dimensionales Array unter Verwendung des Datentyps tensor4und so weiter bis tensor7.

Mehrere Konstruktoren

Manchmal möchten Sie möglicherweise Variablen desselben Typs in einer einzelnen Deklaration erstellen. Sie können dies mit der folgenden Syntax tun:

Syntax

from theano.tensor import * x, y, z = dmatrices('x', 'y', 'z') 
x = ([1,2],[3,4],[5,6]) 
y = ([7,8],[9,10],[11,12]) 
z = ([13,14],[15,16],[17,18]) 
print (x[2]) 
print (y[1]) 
print (z[0])

Ausgabe

[5, 6] 
[9, 10] 
[13, 14]

Im vorherigen Kapitel haben wir bei der Erörterung der Datentypen Theano-Variablen erstellt und verwendet. Um es noch einmal zu wiederholen, würden wir die folgende Syntax verwenden, um eine Variable in Theano zu erstellen -

x = theano.tensor.fvector('x')

In dieser Anweisung haben wir eine Variable erstellt xvom Typ Vektor, der 32-Bit-Floats enthält. Wir nennen es auch alsx. Die Namen sind im Allgemeinen zum Debuggen nützlich.

Um einen Vektor mit 32-Bit-Ganzzahlen zu deklarieren, verwenden Sie die folgende Syntax:

i32 = theano.tensor.ivector

Hier geben wir keinen Namen für die Variable an.

Um einen dreidimensionalen Vektor zu deklarieren, der aus 64-Bit-Floats besteht, verwenden Sie die folgende Deklaration:

f64 = theano.tensor.dtensor3

Die verschiedenen Konstruktortypen sowie ihre Datentypen sind in der folgenden Tabelle aufgeführt:

Konstrukteur	Datentyp	Maße
fvector	float32	1
ivector	int32	1
fscalar	float32	0
fmatrix	float32	2
ftensor3	float32	3
dtensor3	float64	3

Sie können einen generischen Vektorkonstruktor verwenden und den Datentyp explizit wie folgt angeben:

x = theano.tensor.vector ('x', dtype=int32)

Im nächsten Kapitel erfahren Sie, wie Sie gemeinsam genutzte Variablen erstellen.

Oft müssten Sie Variablen erstellen, die von verschiedenen Funktionen und auch von mehreren Aufrufen derselben Funktion gemeinsam genutzt werden. Um ein Beispiel zu nennen: Während Sie ein neuronales Netzwerk trainieren, erstellen Sie einen Gewichtsvektor, um jedem betrachteten Merkmal ein Gewicht zuzuweisen. Dieser Vektor wird bei jeder Iteration während des Netzwerktrainings geändert. Daher muss es über mehrere Aufrufe derselben Funktion hinweg global zugänglich sein. Zu diesem Zweck erstellen wir eine gemeinsame Variable. In der Regel verschiebt Theano solche gemeinsam genutzten Variablen auf die GPU, sofern eine verfügbar ist. Dies beschleunigt die Berechnung.

Syntax

Sie erstellen eine gemeinsam genutzte Variable und verwenden die folgende Syntax:

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

Beispiel

Hier wird das aus vier Gleitkommazahlen bestehende NumPy-Array erstellt. Um das zu setzen / zu bekommenW Wert würden Sie das folgende Code-Snippet verwenden -

import numpy
W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')
print ("Original: ", W.get_value())
print ("Setting new values (0.5, 0.2, 0.4, 0.2)")
W.set_value([0.5, 0.2, 0.4, 0.2])
print ("After modifications:", W.get_value())

Ausgabe

Original: [0.1 0.25 0.15 0.3 ]
Setting new values (0.5, 0.2, 0.4, 0.2)
After modifications: [0.5 0.2 0.4 0.2]

Theano functionwirkt wie ein Haken für die Interaktion mit dem symbolischen Graphen. Ein symbolischer Graph wird zu einem hocheffizienten Ausführungscode kompiliert. Dies wird erreicht, indem mathematische Gleichungen umstrukturiert werden, um sie schneller zu machen. Es kompiliert einige Teile des Ausdrucks in C-Sprachcode. Es verschiebt einige Tensoren zur GPU und so weiter.

Der effizient kompilierte Code wird jetzt als Eingabe für den Theano angegeben function. Wenn Sie den Theano ausführenfunction, ordnet das Berechnungsergebnis den von uns angegebenen Variablen zu. Die Art der Optimierung kann als FAST_COMPILE oder FAST_RUN angegeben werden. Dies wird in der Umgebungsvariablen THEANO_FLAGS angegeben.

Ein Theano function wird mit der folgenden Syntax deklariert:

f = theano.function ([x], y)

Der erste Parameter [x] ist die Liste der Eingangsvariablen und der zweite Parameter y ist die Liste der Ausgabevariablen.

Nachdem wir nun die Grundlagen von Theano verstanden haben, beginnen wir die Theano-Codierung mit einem trivialen Beispiel.

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.

Die Modellbildung für maschinelles Lernen umfasst intensive und sich wiederholende Berechnungen mit Tensoren. Diese erfordern intensive Rechenressourcen. Da ein regulärer Compiler die Optimierungen auf lokaler Ebene bereitstellen würde, erzeugt er im Allgemeinen keinen schnellen Ausführungscode.

Theano erstellt zunächst einen Berechnungsgraphen für die gesamte Berechnung. Da das gesamte Bild der Berechnung während der Kompilierung als einzelnes Bild verfügbar ist, können während der Vorkompilierung verschiedene Optimierungstechniken angewendet werden, und genau das tut Theano. Es strukturiert den Rechengraphen neu, konvertiert ihn teilweise in C, verschiebt gemeinsam genutzte Variablen in die GPU usw., um einen sehr schnell ausführbaren Code zu generieren. Der kompilierte Code wird dann von einem Theano ausgeführtfunctionDies dient lediglich als Hook zum Einfügen des kompilierten Codes in die Laufzeit. Theano hat sich bewährt und ist sowohl in der Wissenschaft als auch in der Industrie weit verbreitet.