Dans le prolongement de Blog post, je voudrais résumer un peu plus les détails de Theano que je n'ai pas pu écrire sur la diapositive.
Tout d'abord, Theano commentary est une expression concise des fonctionnalités de Theano, je vous recommande donc de le lire.
Tel qu'il est écrit ici, la fonction de Theano est
Etc.
http://deeplearning.net/software/theano/tutorial/index.html#tutorial Un résumé approximatif de.
import numpy
import theano
import theano.tensor as T
Ces trois sont des promesses.
Si vous avez une compréhension générale des éléments suivants, vous devriez être capable de lire et de comprendre l'implémentation du Deep Learning et d'apporter des modifications.
Les variables manipulées par Theano sont gérées par le concept de "tenseur". Les types et les opérations autour du tenseur sont approximativement définis sous le tenseur (comme T).
Je ne comprends pas vraiment Tensol, mais pour le moment "** T. * Voici les types de variables et les principales fonctions mathématiques générales (exp, log, sin, etc.) **" à propos de ça.
Ici, "** type de variable **" est
il y a. Ceux-ci sont combinés pour représenter le type de variable (type tenseur).
En tant que nom,
Et
Et ainsi de suite (il y en a d'autres).
En combinant ces derniers,
Etc. Par exemple:
x = T.lscalar("x")
m = T.dmatrix()
Ces x et m sont des "symboles" et n'ont pas de valeurs réelles. C'est un peu différent des variables Python ordinaires.
Voir ci-dessous pour plus d'informations sur la génération de variables. http://deeplearning.net/software/theano/library/tensor/basic.html#libdoc-basic-tensor
Par exemple
x = T.lscalar("x")
y = x*2
z = T.exp(x)
Et exécutez. Puisque x est un symbole sans valeur, y n'a pas non plus de valeur, et y est également un symbole qui signifie «x * 2». z est également un symbole pour exp (x). (En fait, objet Python)
Les calculs qui composent le réseau de neurones sont également traités comme une masse d'opérations (en bref, une expression) entre ces symboles jusqu'à ce qu'une valeur soit effectivement donnée. Puisqu'il est traité comme une expression, il est facile à comprendre pour les humains, et je pense qu'il sera possible d'effectuer une différenciation automatique, qui sera décrite plus loin, et de l'optimiser à l'exécution.
Afin d'effectuer effectivement le calcul, il est nécessaire de définir une "fonction".
Par exemple, si vous souhaitez créer "** f (x) = x * 2 **"
f = theano.function([x], x*2)
Et
y = x*2
f = theano.function([x], y)
Etc. f devient une fonction, et lorsqu'elle est appelée
>>> f(3)
array(6)
Ce sera.
la fonction est
Est spécifié. Il semble que la fonction soit compilée à ce stade, et même les fonctions compliquées sont exécutées à grande vitesse.
function a le mot-clé ** donne **. Comme son nom l'indique, givens a pour fonction de "remplacer un symbole dans une expression par un autre symbole ou une autre valeur".
Par exemple
>>> x = T.dscalar()
>>> y = T.dscalar()
>>> c = T.dscalar()
>>> ff = theano.function([c], x*2+y, givens=[(x, c*10), (y,5)])
>>> ff(2)
array(45)
Tu peux dire ça. A l'origine, la valeur à calculer est "x * 2 + y", mais l'argument de la fonction elle-même est supposé prendre le symbole "c". En fait, il ne peut être calculé que si x et y sont donnés, mais il peut également être calculé en donnant les valeurs de x et y dans cette partie donnée. Cela sera utilisé dans les prochains tutoriels pour utiliser partiellement les données dans l'apprentissage automatique.
L'une des principales caractéristiques de Theano est cette fonction de différenciation. Vous pouvez "analyser la formule pour trouver la formule différenciée" appelée différenciation automatique.
Par exemple
x, y = T.dscalars ("x", "y") # * Comment déclarer collectivement z = (x+2*y)**2
Si vous différenciez la formule par rapport à x, vous obtenez dz / dx = 2 (x + 2 * y).
gx = T.grad(z, x)
Vous pouvez convertir l'expression avec.
Pour la différenciation par rapport à y, dz / dy = 4 (x + 2 * y), mais
gy = T.grad(z, y)
Vous pouvez convertir l'expression avec.
Lors de la recherche effective de la valeur, elle doit encore être fonctionnalisée.
fgy = theano.function([x,y], gy)
>>> fgy(1,2)
array(20.0)
Etc.
Variable = theano.shared (objet)
Vous pouvez déclarer des données partagées qui peuvent être référencées dans la ** fonction ** ci-dessus sous la forme de. Par exemple
>>> x = T.dscalar("x")
>>> b = theano.shared(numpy.array([1,2,3,4,5]))
>>> f = theano.function([x], b * x)
>>> f(2)
array([ 2., 4., 6., 8., 10.])
Vous pouvez l'utiliser avec. Pour référencer ou définir la valeur d'une variable partagée
>>> b.get_value()
array([1,2,3,4,5])
>>> b.set_value([10,11,12])
Etc. Cela se reflète immédiatement dans la fonction définie précédemment, et lorsque vous exécutez à nouveau ** f (2) **, vous pouvez voir que le résultat a changé.
>>> f(2)
array([ 20., 22., 24.])
La fonction a un argument de mot-clé ** updates **, qui vous permet de mettre à jour les variables partagées.
Par exemple, pour définir c comme variable partagée et l'incrémenter de 1 chaque fois que la fonction f est exécutée, écrivez comme suit.
c = theano.shared(0)
f = theano.function([], c, updates= {c: c+1})
La partie ** updated = {c: c + 1} ** représente la mise à jour de la valeur familière dans le langage de programmation ** c = c + 1 **. Lorsque vous faites cela, vous obtenez:
>>> f()
array(0)
>>> f()
array(1)
>>> f()
array(2)
Ceux-ci peuvent être utilisés pour implémenter la méthode du gradient. Par exemple, pour les données ** x = [1,2,3,4,5] **, recherchez ** c ** qui minimise ** y = somme ((xc) ^ 2) **. Je veux. Le code est le suivant, par exemple.
x = T.dvector("x") # input
c = theano.shared(0.) #Je vais mettre à jour cela. La valeur initiale est 0 pour le moment.
y = T.sum((x-c)**2) # y=Valeur que vous souhaitez minimiser
gc = T.grad(y, c) #Différenciation partielle de y par rapport à c
d2 = theano.function([x], y, updates={c: c - 0.05*gc}) #Met à jour c chaque fois qu'il s'exécute et renvoie le y courant
Si vous donnez ** [1,2,3,4,5] ** à ** d2 () ** plusieurs fois,
>>> d2([1,2,3,4,5])
array(55.0)
>>> c.get_value()
1.5
>>> d2([1,2,3,4,5])
array(21.25)
>>> c.get_value()
2.25
>>> d2([1,2,3,4,5])
array(12.8125)
>>> c.get_value()
2.625
Ce sera. Vous pouvez voir que y diminue progressivement et c s'approche progressivement de "3".
Si vous pouvez comprendre ce domaine, vous comprendrez comment fonctionne la régression logistique dans le didacticiel suivant.
http://deeplearning.net/software/theano/tutorial/examples.html#a-real-example-logistic-regression
(Eh bien, tu le sais depuis le début? ^^;)
Recommended Posts