Theano - Guide rapide

Avez-vous développé des modèles d'apprentissage automatique en Python? Ensuite, vous connaissez évidemment les subtilités du développement de ces modèles. Le développement est généralement un processus lent prenant des heures et des jours de puissance de calcul.

Le développement du modèle Machine Learning nécessite beaucoup de calculs mathématiques. Ceux-ci nécessitent généralement des calculs arithmétiques, en particulier de grandes matrices de dimensions multiples. De nos jours, nous utilisons les réseaux de neurones plutôt que les techniques statistiques traditionnelles pour développer des applications d'apprentissage automatique. Les réseaux de neurones doivent être formés sur une énorme quantité de données. La formation se fait par lots de données de taille raisonnable. Ainsi, le processus d'apprentissage est itératif. Ainsi, si les calculs ne sont pas effectués efficacement, la formation du réseau peut prendre plusieurs heures voire plusieurs jours. Ainsi, l'optimisation du code exécutable est fortement souhaitée. Et c'est exactement ce que propose Theano.

Theano est une bibliothèque Python qui vous permet de définir des expressions mathématiques utilisées dans le Machine Learning, d'optimiser ces expressions et de les évaluer très efficacement en utilisant de manière décisive les GPU dans les zones critiques. Il peut rivaliser avec les implémentations C complètes typiques dans la plupart des cas.

Theano a été écrit au laboratoire LISA avec l'intention de fournir un développement rapide d'algorithmes d'apprentissage automatique efficaces. Il est publié sous une licence BSD.

Dans ce didacticiel, vous apprendrez à utiliser la bibliothèque Theano.

Theano peut être installé sur Windows, MacOS et Linux. L'installation dans tous les cas est triviale. Avant d'installer Theano, vous devez installer ses dépendances. Voici la liste des dépendances -

  • Python
  • NumPy - Obligatoire
  • SciPy - Requis uniquement pour Sparse Matrix et fonctions spéciales
  • BLAS - Fournit des blocs de construction standard pour effectuer des opérations vectorielles et matricielles de base

Les packages optionnels que vous pouvez choisir d'installer en fonction de vos besoins sont:

  • nez: pour exécuter la suite de tests de Theano
  • Sphinx - Pour la documentation de construction
  • Graphiz et pydot - Pour gérer les graphiques et les images
  • Pilotes NVIDIA CUDA - Requis pour la génération / exécution de code GPU
  • libgpuarray - Requis pour la génération de code GPU / CPU sur les périphériques CUDA et OpenCL

Nous discuterons des étapes pour installer Theano sous MacOS.

Installation MacOS

Pour installer Theano et ses dépendances, vous utilisez pipà partir de la ligne de commande comme suit. Ce sont les dépendances minimales dont nous aurons besoin dans ce didacticiel.

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

Vous devez également installer l'outil de développement de ligne de commande OSx à l'aide de la commande suivante -

$ xcode-select --install

Vous verrez l'écran suivant. Clique sur leInstall bouton pour installer l'outil.

Une fois l'installation réussie, vous verrez le message de réussite sur la console.

Test de l'installation

Une fois l'installation terminée, ouvrez un nouveau bloc-notes dans Anaconda Jupyter. Dans la cellule de code, entrez le script Python suivant -

Exemple

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)

Production

Exécutez le script et vous devriez voir la sortie suivante -

4.0

La capture d'écran de l'exécution est présentée ci-dessous pour votre référence rapide -

Si vous obtenez le résultat ci-dessus, votre installation Theano est réussie. Sinon, suivez les instructions de débogage sur la page de téléchargement de Theano pour résoudre les problèmes.

Qu'est-ce que Theano?

Maintenant que vous avez installé Theano avec succès, essayons d'abord de comprendre ce qu'est Theano? Theano est une bibliothèque Python. Il vous permet de définir, d'optimiser et d'évaluer des expressions mathématiques, en particulier celles qui sont utilisées dans le développement de modèles d'apprentissage automatique. Theano lui-même ne contient aucun modèle de ML prédéfini; cela facilite simplement son développement. Il est particulièrement utile lorsqu'il s'agit de tableaux multidimensionnels. Il s'intègre parfaitement à NumPy, qui est un package fondamental et largement utilisé pour les calculs scientifiques en Python.

Theano facilite la définition des expressions mathématiques utilisées dans le développement ML. De telles expressions impliquent généralement l'arithmétique matricielle, la différenciation, le calcul de gradient, etc.

Theano crée d'abord le graphe de calcul complet pour votre modèle. Il le compile ensuite en code hautement efficace en appliquant plusieurs techniques d'optimisation sur le graphe. Le code compilé est injecté dans le runtime Theano par une opération spéciale appeléefunctiondisponible dans Theano. Nous exécutons celafunctionrépétitivement pour former un réseau neuronal. Le temps de formation est considérablement réduit par rapport à l'utilisation d'un codage Python pur ou même d'une implémentation C complète.

Nous allons maintenant comprendre le processus de développement de Theano. Commençons par comment définir une expression mathématique dans Theano.

Commençons notre voyage de Theano en définissant et en évaluant une expression triviale dans Theano. Considérez l'expression triviale suivante qui ajoute deux scalaires -

c = a + b

a, b sont des variables et cest la sortie de l'expression. Dans Theano, définir et évaluer même cette expression triviale est délicat.

Comprenons les étapes pour évaluer l'expression ci-dessus.

Importer Theano

Tout d'abord, nous devons importer la bibliothèque Theano dans notre programme, ce que nous faisons en utilisant l'instruction suivante -

from theano import *

Plutôt que d'importer les packages individuels, nous avons utilisé * dans l'instruction ci-dessus pour inclure tous les packages de la bibliothèque Theano.

Déclaration de variables

Ensuite, nous déclarerons une variable appelée a en utilisant l'instruction suivante -

a = tensor.dscalar()

le dscalardéclare une variable scalaire décimale. L'exécution de l'instruction ci-dessus crée une variable appeléeadans votre code de programme. De même, nous allons créer une variableb en utilisant l'instruction suivante -

b = tensor.dscalar()

Définition de l'expression

Ensuite, nous définirons notre expression qui opère sur ces deux variables a et b.

c = a + b

Dans Theano, l'exécution de l'instruction ci-dessus n'effectue pas l'ajout scalaire des deux variables a et b.

Définition de la fonction Theano

Pour évaluer l'expression ci-dessus, nous devons définir une fonction dans Theano comme suit -

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

La fonction functionprend deux arguments, le premier argument est une entrée de la fonction et le second est sa sortie. La déclaration ci-dessus indique que le premier argument est de type tableau composé de deux élémentsa et b. La sortie est une unité scalaire appeléec. Cette fonction sera référencée avec le nom de la variablef dans notre autre code.

Appel de la fonction Theano

L'appel à la fonction f est effectué à l'aide de l'instruction suivante -

d = f(3.5, 5.5)

L'entrée de la fonction est un tableau composé de deux scalaires: 3.5 et 5.5. La sortie d'exécution est affectée à la variable scalaired. Pour imprimer le contenu ded, nous utiliserons le print déclaration -

print (d)

L'exécution entraînerait la valeur de d à imprimer sur la console, qui est 9.0 dans ce cas.

Liste complète du programme

La liste complète du programme est donnée ici pour votre référence rapide -

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)

Exécutez le code ci-dessus et vous verrez la sortie comme 9.0. La capture d'écran est affichée ici -

Voyons maintenant un exemple légèrement plus complexe qui calcule la multiplication de deux matrices.

Nous allons calculer un produit scalaire de deux matrices. La première matrice est de dimension 2 x 3 et la seconde est de dimension 3 x 2. Les matrices que nous avons utilisées comme entrée et leur produit sont exprimées ici -

$$ \ 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} $$

Déclaration de variables

Pour écrire une expression Theano pour ce qui précède, nous déclarons d'abord deux variables pour représenter nos matrices comme suit -

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

La matrice est le type de matrices pour les doubles. Notez que nous ne spécifions nulle part la taille de la matrice. Ainsi, ces variables peuvent représenter des matrices de n'importe quelle dimension.

Définition de l'expression

Pour calculer le produit scalaire, nous avons utilisé la fonction intégrée appelée dot comme suit -

c = tensor.dot(a,b)

La sortie de multiplication est affectée à une variable de matrice appelée c.

Définition de la fonction Theano

Ensuite, nous définissons une fonction comme dans l'exemple précédent pour évaluer l'expression.

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

Notez que les entrées de la fonction sont deux variables a et b qui sont de type matrice. La sortie de fonction est affectée à la variablec qui serait automatiquement de type matriciel.

Appel de la fonction Theano

Nous appelons maintenant la fonction en utilisant l'instruction suivante -

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

Les deux variables de l'instruction ci-dessus sont des tableaux NumPy. Vous pouvez définir explicitement les tableaux NumPy comme indiqué ici -

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

Après d est calculé on imprime sa valeur -

print (d)

Vous verrez la sortie suivante sur la sortie -

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

Liste complète du programme

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)

La capture d'écran de l'exécution du programme est affichée ici -

À partir des deux exemples ci-dessus, vous avez peut-être remarqué que dans Theano, nous créons une expression qui est finalement évaluée à l'aide du Theano function. Theano utilise des techniques d'optimisation avancées pour optimiser l'exécution d'une expression. Pour visualiser le graphe de calcul, Theano fournit unprinting package dans sa bibliothèque.

Graphique symbolique pour l'addition scalaire

Pour voir le graphe de calcul de notre programme d'addition scalaire, utilisez la bibliothèque d'impression comme suit -

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

Lorsque vous exécutez cette instruction, un fichier appelé scalar_addition.pngsera créé sur votre machine. Le graphique de calcul enregistré est affiché ici pour votre référence rapide -

La liste complète des programmes pour générer l'image ci-dessus est donnée ci-dessous -

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)

Graphique symbolique pour multiplicateur matriciel

Maintenant, essayez de créer le graphe de calcul pour notre multiplicateur matriciel. La liste complète pour générer ce graphique est donnée ci-dessous -

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)

Le graphique généré est affiché ici -

Graphiques complexes

Dans les expressions plus grandes, les graphes de calcul peuvent être très complexes. Un tel graphe tiré de la documentation Theano est montré ici -

Pour comprendre le fonctionnement de Theano, il est important de connaître d'abord la signification de ces graphes de calcul. Avec cette compréhension, nous connaîtrons l'importance de Theano.

Pourquoi Theano?

En regardant la complexité des graphes de calcul, vous serez maintenant en mesure de comprendre le but du développement de Theano. Un compilateur typique fournirait des optimisations locales dans le programme car il ne considère jamais l'ensemble du calcul comme une seule unité.

Theano met en œuvre des techniques d'optimisation très avancées pour optimiser le graphe de calcul complet. Il combine les aspects de l'algèbre avec les aspects d'un compilateur d'optimisation. Une partie du graphique peut être compilée en code en langage C. Pour les calculs répétés, la vitesse d'évaluation est critique et Theano répond à cet objectif en générant un code très efficace.

Maintenant que vous avez compris les bases de Theano, commençons par les différents types de données dont vous disposez pour créer vos expressions. Le tableau suivant vous donne une liste partielle des types de données définis dans Theano.

Type de données Type de Theano
Octet

bscalar, bvector, bmatrix, front, bcol, btensor3, btensor4, btensor5, btensor6, btensor7

Entiers 16 bits

wscalar, wvector, wmatrix, wrow, wcol, wtensor3, wtensor4, wtensor5, wtensor6, wtensor7

Entiers 32 bits

iscalaire, ivector, imatrix, irow, icol, itensor3, itensor4, itensor5, itensor6, itensor7

Entiers 64 bits

lscalaire, lvector, lmatrix, lrow, lcol, ltensor3, ltensor4, ltensor5, ltensor6, ltensor7

flotte

fscalar, fvector, fmatrix, frow, fcol, ftensor3, ftensor4, ftensor5, ftensor6, ftensor7

double

dscalar, dvector, dmatrix, drow, dcol, dtensor3, dtensor4, dtensor5, dtensor6, dtensor7

complexe

cscalar, cvector, cmatrix, corbeau, ccol, ctensor3, ctensor4, ctensor5, ctensor6, ctensor7

La liste ci-dessus n'est pas exhaustive et le lecteur est renvoyé au document de création de tenseur pour une liste complète.

Je vais maintenant vous donner quelques exemples sur la façon de créer des variables de différents types de données dans Theano.

Scalaire

Pour construire une variable scalaire, vous utiliseriez la syntaxe -

Syntaxe

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

Production

5.0

Réseau unidimensionnel

Pour créer un tableau unidimensionnel, utilisez la déclaration suivante -

Exemple

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])

Production

(2.0, 5.0, 3.0)
2.0
3.0

Si tu fais f[3] cela générerait une erreur d'index hors plage comme indiqué ici -

print f([3])

Production

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

Réseau bidimensionnel

Pour déclarer un tableau à deux dimensions, vous utiliserez l'extrait de code suivant -

Exemple

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

Production

[2, 3]
4

Réseau à 5 dimensions

Pour déclarer un tableau à 5 dimensions, utilisez la syntaxe suivante -

Exemple

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])

Production

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

Vous pouvez déclarer un tableau à 3 dimensions en utilisant le type de données tensor3 au lieu de tensor5, un tableau à 4 dimensions utilisant le type de données tensor4, et ainsi de suite jusqu'à tensor7.

Constructeurs pluriels

Parfois, vous souhaiterez peut-être créer des variables du même type dans une seule déclaration. Vous pouvez le faire en utilisant la syntaxe suivante -

Syntaxe

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])

Production

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

Dans le chapitre précédent, tout en discutant des types de données, nous avons créé et utilisé des variables Theano. Pour réitérer, nous utiliserions la syntaxe suivante pour créer une variable dans Theano -

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

Dans cette déclaration, nous avons créé une variable xde type vecteur contenant des flottants 32 bits. Nous l'appelons également commex. Les noms sont généralement utiles pour le débogage.

Pour déclarer un vecteur d'entiers 32 bits, vous utiliserez la syntaxe suivante -

i32 = theano.tensor.ivector

Ici, nous ne spécifions pas de nom pour la variable.

Pour déclarer un vecteur tridimensionnel composé de flottants 64 bits, vous utiliseriez la déclaration suivante -

f64 = theano.tensor.dtensor3

Les différents types de constructeurs ainsi que leurs types de données sont répertoriés dans le tableau ci-dessous -

Constructeur Type de données Dimensions
vecteur float32 1
ivecteur int32 1
fscalaire float32 0
fmatrix float32 2
ftensor3 float32 3
dtensor3 float64 3

Vous pouvez utiliser un constructeur vectoriel générique et spécifier explicitement le type de données comme suit -

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

Dans le prochain chapitre, nous apprendrons comment créer des variables partagées.

Plusieurs fois, vous devrez créer des variables qui sont partagées entre différentes fonctions et également entre plusieurs appels à la même fonction. Pour citer un exemple, lors de la formation d'un réseau de neurones, vous créez un vecteur de poids pour attribuer un poids à chaque caractéristique considérée. Ce vecteur est modifié à chaque itération pendant la formation du réseau. Ainsi, il doit être globalement accessible à travers les multiples appels à la même fonction. Nous créons donc une variable partagée à cet effet. En règle générale, Theano déplace ces variables partagées vers le GPU, à condition qu'il en existe une. Cela accélère le calcul.

Syntaxe

Vous créez une variable partagée vous utilisez la syntaxe suivante -

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

Exemple

Ici, le tableau NumPy composé de quatre nombres à virgule flottante est créé. Pour définir / obtenir leW valeur que vous utiliseriez l'extrait de code suivant -

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())

Production

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 functionagit comme un crochet pour interagir avec le graphe symbolique. Un graphe symbolique est compilé dans un code d'exécution très efficace. Il y parvient en restructurant les équations mathématiques pour les rendre plus rapides. Il compile certaines parties de l'expression en code de langage C. Il déplace certains tenseurs vers le GPU, et ainsi de suite.

Le code compilé efficace est maintenant donné comme entrée du Theano function. Lorsque vous exécutez le Theanofunction, il affecte le résultat du calcul aux variables que nous spécifions. Le type d'optimisation peut être spécifié comme FAST_COMPILE ou FAST_RUN. Ceci est spécifié dans la variable d'environnement THEANO_FLAGS.

Un Theano function est déclaré en utilisant la syntaxe suivante -

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

Le premier paramètre [x] est la liste des variables d'entrée et le deuxième paramètre y est la liste des variables de sortie.

Ayant maintenant compris les bases de Theano, commençons le codage Theano avec un exemple trivial.

Theano est très utile dans la formation de réseaux de neurones où nous devons calculer à plusieurs reprises le coût et les gradients pour atteindre un optimum. Sur les grands ensembles de données, cela devient intensif en calcul. Theano le fait efficacement grâce à ses optimisations internes du graphe de calcul que nous avons vu précédemment.

Énoncé du problème

Nous allons maintenant apprendre à utiliser la bibliothèque Theano pour former un réseau. Nous allons prendre un cas simple où nous commençons avec un jeu de données à quatre entités. Nous calculons la somme de ces caractéristiques après avoir appliqué un certain poids (importance) à chaque caractéristique.

Le but de la formation est de modifier les pondérations attribuées à chaque fonctionnalité afin que la somme atteigne une valeur cible de 100.

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

f1, f2, ... sont les valeurs des caractéristiques et w1, w2, ... sont les poids.

Permettez-moi de quantifier l'exemple pour une meilleure compréhension de l'énoncé du problème. Nous supposerons une valeur initiale de 1,0 pour chaque fonctionnalité et nous prendrons w1 égal0.1, w2 équivaut à 0.25, w3 équivaut à 0.15, et w4 équivaut à 0.3. Il n'y a pas de logique définie dans l'attribution des valeurs de poids, c'est juste notre intuition. Ainsi, la somme initiale est la suivante -

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

Qui somme à 0.8. Maintenant, nous allons continuer à modifier l'affectation de poids pour que cette somme approche 100. La valeur résultante actuelle de0.8 est loin de la valeur cible souhaitée de 100. En termes d'apprentissage automatique, nous définissons costcomme la différence entre la valeur cible moins la valeur de sortie actuelle, généralement au carré pour faire exploser l'erreur. Nous réduisons ce coût à chaque itération en calculant les gradients et en mettant à jour notre vecteur de poids.

Voyons comment toute cette logique est implémentée dans Theano.

Déclaration de variables

Nous déclarons d'abord notre vecteur d'entrée x comme suit -

x = tensor.fvector('x')

x est un tableau unidimensionnel de valeurs flottantes.

Nous définissons un scalaire target variable comme indiqué ci-dessous -

target = tensor.fscalar('target')

Ensuite, nous créons un tenseur de poids W avec les valeurs initiales décrites ci-dessus -

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

Définition de l'expression Theano

Nous calculons maintenant la sortie en utilisant l'expression suivante -

y = (x * W).sum()

Notez que dans la déclaration ci-dessus x et Wsont les vecteurs et non de simples variables scalaires. Nous calculons maintenant l'erreur (coût) avec l'expression suivante -

cost = tensor.sqr(target - y)

Le coût est la différence entre la valeur cible et la sortie de courant, au carré.

Pour calculer le gradient qui nous indique à quelle distance nous sommes de la cible, nous utilisons la fonction intégrée grad méthode comme suit -

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

Nous mettons maintenant à jour le weights vecteur en prenant un taux d'apprentissage de 0.1 comme suit -

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

Ensuite, nous devons mettre à jour notre vecteur de poids en utilisant les valeurs ci-dessus. Nous faisons cela dans la déclaration suivante -

updates = [(W, W_updated)]

Définition / appel de la fonction Theano

Enfin, nous définissons un function dans Theano pour calculer la somme.

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

Pour invoquer la fonction ci-dessus un certain nombre de fois, nous créons un for boucle comme suit -

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

Comme indiqué précédemment, l'entrée de la fonction est un vecteur contenant les valeurs initiales des quatre caractéristiques - nous attribuons la valeur de 1.0à chaque fonctionnalité sans aucune raison spécifique. Vous pouvez attribuer différentes valeurs de votre choix et vérifier si la fonction converge finalement. Nous imprimerons les valeurs du vecteur de poids et la sortie correspondante à chaque itération. Il est indiqué dans le code ci-dessous -

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

Liste complète du programme

La liste complète du programme est reproduite ici pour votre référence rapide -

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)

Lorsque vous exécutez le programme, vous verrez la sortie suivante -

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

Observez qu'après quatre itérations, la sortie est 99.96 et après cinq itérations, c'est 99.99, qui est proche de notre objectif souhaité de 100.0.

En fonction de la précision souhaitée, vous pouvez conclure en toute sécurité que le réseau est formé en 4 à 5 itérations. Une fois la formation terminée, recherchez le vecteur de poids, qui, après 5 itérations, prend les valeurs suivantes -

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

Vous pouvez maintenant utiliser ces valeurs dans votre réseau pour déployer le modèle.

La construction de modèles d'apprentissage automatique implique des calculs intensifs et répétitifs impliquant des tenseurs. Celles-ci nécessitent des ressources informatiques intensives. Comme un compilateur régulier fournirait les optimisations au niveau local, il ne produit généralement pas un code d'exécution rapide.

Theano crée d'abord un graphe de calcul pour l'ensemble du calcul. Comme toute l'image du calcul est disponible sous la forme d'une seule image lors de la compilation, plusieurs techniques d'optimisation peuvent être appliquées lors de la pré-compilation et c'est exactement ce que fait Theano. Il restructure le graphe de calcul, le convertit partiellement en C, déplace les variables partagées vers le GPU, et ainsi de suite pour générer un code exécutable très rapide. Le code compilé est ensuite exécuté par un Theanofunctionqui agit simplement comme un crochet pour injecter le code compilé dans le runtime. Theano a prouvé ses références et est largement accepté dans les universitaires et dans l'industrie.