Comment les œuvres dans tensorflow

Question

Comment dois-je "dis" tf qu'une certaine fonction de coût provient d'une NN?

(court) Réponse

Cela se fait simplement en configurant votre optimizer afin de minimiser (ou maximiser) un tenseur. Par exemple, si j'ai une perte de fonction de la façon

loss = tf.reduce_sum( tf.square( y0 - y_out ) )

où y0 est la la vérité terrain (ou de sortie désirée) et y_out est le résultat calculé, puis j'ai pu minimiser la perte, par la définition de ma formation en fonction de la façon

train = tf.train.GradientDescentOptimizer(1.0).minimize(loss)

Cela dit Tensorflow que lorsque train est calculé, c'est d'appliquer la descente de gradient sur la perte de la minimiser, et la perte est calculée à l'aide de y0 et y_out, et ainsi de descente de gradient va aussi affecter les personnes (si elles sont éducables variables), et ainsi de suite.

La variable y0, y_out, perte, et train ne sont pas standard de python variables, mais plutôt la description d'un graphe. Tensorflow utilise les informations à propos du graphe de la dérouler lors de l'application de la descente de gradient.

Spécifiquement sur la façon dont il le fait est au-delà de la portée de cette réponse. Ici et ici sont deux bons points de départ pour plus d'informations sur plus de détails.

Exemple De Code

Examinons un exemple de code. D'abord le code.

### imports
import tensorflow as tf
### constant data
x  = [[0.,0.],[1.,1.],[1.,0.],[0.,1.]]
y_ = [[0.],[0.],[1.],[1.]]
### induction
# 1x2 input -> 2x3 hidden sigmoid -> 3x1 sigmoid output
# Layer 0 = the x2 inputs
x0 = tf.constant( x  , dtype=tf.float32 )
y0 = tf.constant( y_ , dtype=tf.float32 )
# Layer 1 = the 2x3 hidden sigmoid
m1 = tf.Variable( tf.random_uniform( [2,3] , minval=0.1 , maxval=0.9 , dtype=tf.float32  ))
b1 = tf.Variable( tf.random_uniform( [3]   , minval=0.1 , maxval=0.9 , dtype=tf.float32  ))
h1 = tf.sigmoid( tf.matmul( x0,m1 ) + b1 )
# Layer 2 = the 3x1 sigmoid output
m2 = tf.Variable( tf.random_uniform( [3,1] , minval=0.1 , maxval=0.9 , dtype=tf.float32  ))
b2 = tf.Variable( tf.random_uniform( [1]   , minval=0.1 , maxval=0.9 , dtype=tf.float32  ))
y_out = tf.sigmoid( tf.matmul( h1,m2 ) + b2 )
### loss
# loss : sum of the squares of y0 - y_out
loss = tf.reduce_sum( tf.square( y0 - y_out ) )
# training step : gradient decent (1.0) to minimize loss
train = tf.train.GradientDescentOptimizer(1.0).minimize(loss)
### training
# run 500 times using all the X and Y
# print out the loss and any other interesting info
with tf.Session() as sess:
sess.run( tf.global_variables_initializer() )
for step in range(500) :
sess.run(train)
results = sess.run([m1,b1,m2,b2,y_out,loss])
labels  = "m1,b1,m2,b2,y_out,loss".split(",")
for label,result in zip(*(labels,results)) :
print ""
print label
print result
print ""

Nous allons aller à travers elle, mais dans l'ordre inverse, en commençant par

sess.run(train)

Cela dit tensorflow de regarder le graphique noeud défini par train et de le calculer. Train est défini comme

train = tf.train.GradientDescentOptimizer(1.0).minimize(loss)

Pour calculer cette tensorflow doit calculer la la différentiation automatique pour perte, ce qui signifie marcher le graphique. perte est défini comme

loss = tf.reduce_sum( tf.square( y0 - y_out ) )

Qui est vraiment tensorflow l'application de la différentiation automatique dérouler de première tf.reduce_sum, puis tf.carré, puis y0 - y_out, ce qui conduit à avoir à marcher sur le graphique pour les deux y0 et y_out.

y0 = tf.constant( y_ , dtype=tf.float32 )

y0 est une constante, et ne sera pas mis à jour.

y_out = tf.sigmoid( tf.matmul( h1,m2 ) + b2 )

y_out sera traitée semblable à la perte, d'abord tf.sigmoïde seront traitées, etc...

Dans l'ensemble, chaque opération ( telle que la tf.sigmoïde, tf.carré ) ne définit pas seulement l'opération ( appliquer sigmoïde ou carrée), mais aussi les informations nécessaires pour la différentiation automatique. Ceci est différent du standard de python mathématiques comme

x = 7 + 9

L'équation ci-dessus code pour rien, sauf la façon de mettre à jour x, où que

z = y0 - y_out

code pour le graphique de la soustraction y_out de y0 et stocke l'opération et assez à faire la différentiation automatique dans z