tensorflow Tutoriel
Démarrer avec tensorflow

Remarques

Installation ou configuration

Depuis la version 1.0 de Tensorflow, l'installation est beaucoup plus facile à réaliser. Au minimum, pour installer TensorFlow, il faut installer pip sur leur machine avec une version python d'au moins 2.7 ou 3.3+.

pip install --upgrade tensorflow      # for Python 2.7
pip3 install --upgrade tensorflow     # for Python 3.n

Pour tensorflow sur une machine GPU (à partir de 1.0 nécessite CUDA 8.0 et cudnn 5.1, le GPU AMD n'est pas supporté)

pip install --upgrade tensorflow-gpu  # for Python 2.7 and GPU
pip3 install --upgrade tensorflow-gpu # for Python 3.n and GPU

Pour tester si cela a fonctionné, ouvrez la version correcte de python 2 ou 3 et lancez

import tensorflow

Si cela a réussi sans erreur, vous avez installé tensorflow sur votre machine.

* Soyez conscient que cela fait référence à la branche principale, on peut changer cela sur le lien ci-dessus pour référencer la version stable actuelle.)

Exemple de base

Tensorflow est plus qu'un simple cadre d'apprentissage approfondi. C'est un cadre de calcul général permettant d'effectuer des opérations mathématiques générales de manière parallèle et distribuée. Un exemple de ceci est décrit ci-dessous.

Régression linéaire

Un exemple statistique de base couramment utilisé et plutôt simple à calculer consiste à adapter une ligne à un ensemble de données. La méthode pour le faire dans tensorflow est décrite ci-dessous dans le code et les commentaires.

Les principales étapes du script (TensorFlow) sont les suivantes:

1. Déclarez les espaces réservés ( x_ph , y_ph ) et les variables ( W , b )
2. Définir l'opérateur d'initialisation ( init )
3. Déclarez les opérations sur les espaces réservés et les variables ( y_pred , loss , train_op )
4. Créer une session ( sess )
5. Exécutez l'opérateur d'initialisation ( sess.run(init) )
6. Exécuter des opérations de graphique (par exemple, sess.run([train_op, loss], feed_dict={x_ph: x, y_ph: y}) )

La construction du graphe est réalisée à l'aide de l'API Python TensorFlow (peut également être réalisée à l'aide de l'API T ++ CensorFlow). L'exécution du graphique appelle des routines C ++ de bas niveau.

'''
function: create a linear model which try to fit the line 
          y = x + 2 using SGD optimizer to minimize 
          root-mean-square(RMS) loss function

'''
import tensorflow as tf
import numpy as np

# number of epoch
num_epoch = 100

# training data x and label y
x = np.array([0., 1., 2., 3.], dtype=np.float32)
y = np.array([2., 3., 4., 5.], dtype=np.float32)

# convert x and y to 4x1 matrix
x = np.reshape(x, [4, 1])
y = np.reshape(y, [4, 1])

# test set(using a little trick)
x_test = x + 0.5
y_test = y + 0.5

# This part of the script builds the TensorFlow graph using the Python API

# First declare placeholders for input x and label y
# Placeholders are TensorFlow variables requiring to be explicitly fed by some 
# input data
x_ph = tf.placeholder(tf.float32, shape=[None, 1])
y_ph = tf.placeholder(tf.float32, shape=[None, 1])

# Variables (if not specified) will be learnt as the GradientDescentOptimizer
# is run
# Declare weight variable initialized using a truncated_normal law
W = tf.Variable(tf.truncated_normal([1, 1], stddev=0.1))
# Declare bias variable initialized to a constant 0.1
b = tf.Variable(tf.constant(0.1, shape=[1]))

# Initialize variables just declared 
init = tf.initialize_all_variables()

# In this part of the script, we build operators storing operations
# on the previous variables and placeholders.
# model: y = w * x + b
y_pred = x_ph * W + b

# loss function
loss = tf.mul(tf.reduce_mean(tf.square(tf.sub(y_pred, y_ph))), 1. / 2)
# create training graph
train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

# This part of the script runs the TensorFlow graph (variables and operations
# operators) just built.
with tf.Session() as sess:
    # initialize all the variables by running the initializer operator
    sess.run(init)
    for epoch in xrange(num_epoch):
        # Run sequentially the train_op and loss operators with
        # x_ph and y_ph placeholders fed by variables x and y
        _, loss_val = sess.run([train_op, loss], feed_dict={x_ph: x, y_ph: y})
        print('epoch %d: loss is %.4f' % (epoch, loss_val))

    # see what model do in the test set
    # by evaluating the y_pred operator using the x_test data
    test_val = sess.run(y_pred, feed_dict={x_ph: x_test})
    print('ground truth y is: %s' % y_test.flatten())
    print('predict y is     : %s' % test_val.flatten())

Bases du flux de tension

Tensorflow fonctionne sur le principe des graphes de flux de données. Pour effectuer un calcul, il y a deux étapes:

1. Représente le calcul sous forme de graphique.
2. Exécutez le graphique.

Représentation: Comme tout graphe orienté, un graphe Tensorflow est constitué de nœuds et d'arêtes directionnelles.

Node: Un nœud est également appelé Op (signifie opération). Un nœud peut avoir plusieurs arêtes entrantes mais un seul front sortant.

Bord: Indique les données entrantes ou sortantes d'un nœud. Dans ce cas, les entrées et sorties de certains nœuds (Op).

Chaque fois que nous disons des données, nous entendons un vecteur à n dimensions appelé Tensor. Un tensionneur a trois propriétés: rang, forme et type

• Rang signifie le nombre de dimensions du Tenseur (un cube ou une case a le rang 3).
• Forme signifie les valeurs de ces dimensions (la boîte peut avoir la forme 1x1x1 ou 2x5x7).
• Type signifie type de données dans chaque coordonnée de Tensor.

Execution: Même si un graphe est construit, c'est toujours une entité abstraite. Aucun calcul ne se produit réellement jusqu'à ce que nous l'exécutions. Pour exécuter un graphique, nous devons allouer des ressources CPU à Ops dans le graphique. Ceci est fait en utilisant des sessions Tensorflow. Les étapes sont les suivantes:

1. Créez une nouvelle session.
2. Exécuter une Op dans le graphique. Habituellement, nous exécutons la dernière Op où nous attendons la sortie de notre calcul.

Un front entrant sur une Op est comme une dépendance pour les données sur une autre Op. Ainsi, lorsque nous exécutons une Op, tous les bords entrants sont tracés et les opérations de l'autre côté sont également exécutées.

Remarque: Des nœuds spéciaux appelés rôle de lecture de la source de données ou du récepteur sont également possibles. Par exemple, vous pouvez avoir une Op qui donne une valeur constante donc pas d'arêtes entrantes (référez-vous à la valeur 'matrix1' dans l'exemple ci-dessous) et Op sans les arêtes sortantes où les résultats sont collectés

Exemple:

import tensorflow as tf

# Create a Constant op that produces a 1x2 matrix.  The op is
# added as a node to the default graph.
#
# The value returned by the constructor represents the output
# of the Constant op.
matrix1 = tf.constant([[3., 3.]])

# Create another Constant that produces a 2x1 matrix.
matrix2 = tf.constant([[2.],[2.]])

# Create a Matmul op that takes 'matrix1' and 'matrix2' as inputs.
# The returned value, 'product', represents the result of the matrix
# multiplication.
product = tf.matmul(matrix1, matrix2)

# Launch the default graph.
sess = tf.Session()

# To run the matmul op we call the session 'run()' method, passing 'product'
# which represents the output of the matmul op.  This indicates to the call
# that we want to get the output of the matmul op back.
#
# All inputs needed by the op are run automatically by the session.  They
# typically are run in parallel.
#
# The call 'run(product)' thus causes the execution of three ops in the
# graph: the two constants and matmul.
#
# The output of the op is returned in 'result' as a numpy `ndarray` object.
result = sess.run(product)
print(result)
# ==> [[ 12.]]

# Close the Session when we're done.
sess.close()

Compter jusqu'à 10

Dans cet exemple, nous utilisons Tensorflow pour compter jusqu'à 10. Oui , il s'agit d'une surcharge totale, mais c'est un bon exemple pour montrer une configuration minimale absolue requise pour utiliser Tensorflow.

import tensorflow as tf

# create a variable, refer to it as 'state' and set it to 0
state = tf.Variable(0)

# set one to a constant set to 1
one = tf.constant(1)

# update phase adds state and one and then assigns to state
addition = tf.add(state, one)
update = tf.assign(state, addition )

# create a session
with tf.Session() as sess:
  # initialize session variables
  sess.run( tf.global_variables_initializer() )

  print "The starting state is",sess.run(state)

  print "Run the update 10 times..."
  for count in range(10):
    # execute the update
    sess.run(update)

  print "The end state is",sess.run(state)

La chose importante à réaliser ici est que l’ état, l’un, l’addition et la mise à jour ne contiennent pas de valeurs. Au lieu de cela, ils sont des références à des objets Tensorflow. Le résultat final n'est pas un état , mais est récupéré à l'aide d'un flux Tensor pour l'évaluer à l'aide de sess.run (state)

Cet exemple provient de https://github.com/panchishin/learn-to-tensorflow . Il y a plusieurs autres exemples là-bas et un beau plan d'apprentissage progressif pour se familiariser avec la manipulation du graphe Tensorflow en python.