tensorflow Tutorial
Empezando con tensorflow

Observaciones

Instalación o configuración

A partir de la versión 1.0 de Tensorflow, la instalación se ha vuelto mucho más fácil de realizar. Como mínimo para instalar TensorFlow, es necesario instalar un pip en su máquina con una versión de python de al menos 2.7 o 3.3+.

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

Para tensorflow en una máquina GPU (a partir de 1.0 requiere CUDA 8.0 y cudnn 5.1, no se admite la GPU AMD)

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

Para probar si funcionó, abra la versión correcta de python 2 o 3 y ejecute

import tensorflow

Si eso tuvo éxito sin error, entonces tiene tensorflow instalado en su máquina.

* Tenga en cuenta que esta referencia a la rama maestra puede cambiar esto en el enlace anterior para hacer referencia a la versión estable actual.)

Ejemplo básico

Tensorflow es más que un marco de aprendizaje profundo. Es un marco de cálculo general para realizar operaciones matemáticas generales de manera paralela y distribuida. Un ejemplo de esto se describe a continuación.

Regresión lineal

Un ejemplo estadístico básico que se utiliza comúnmente y es bastante simple de calcular es ajustar una línea a un conjunto de datos. El método para hacerlo en tensorflow se describe a continuación en el código y los comentarios.

Los pasos principales del script (TensorFlow) son:

1. Declare marcadores de posición ( x_ph , y_ph ) y variables ( W , b )
2. Definir el operador de inicialización ( init ).
3. Declarar operaciones sobre los marcadores de posición y las variables ( y_pred , loss , train_op )
4. Crear una sesión ( sess )
5. Ejecute el operador de inicialización ( sess.run(init) )
6. Ejecute algunas operaciones gráficas (por ejemplo, sess.run([train_op, loss], feed_dict={x_ph: x, y_ph: y}) )

La construcción del gráfico se realiza utilizando la API de Python TensorFlow (también se podría hacer utilizando la API de C ++ TensorFlow). Ejecutar el gráfico llamará rutinas de C ++ de bajo nivel.

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

Fundamentos de Tensorflow

Tensorflow funciona en principio de gráficos de flujo de datos. Para realizar algún cálculo hay dos pasos:

1. Representa el cálculo como una gráfica.
2. Ejecuta la gráfica.

Representación: como cualquier gráfico dirigido, un gráfico Tensorflow consta de nodos y bordes direccionales.

Nodo: Un nodo también se denomina Op (significa operación). Un nodo puede tener varios bordes entrantes pero un solo borde saliente.

Borde: indica los datos entrantes o salientes de un nodo. En este caso, entrada (s) y salida de algunos Nodos (Op).

Cuando decimos datos nos referimos a un vector n-dimensional conocido como Tensor. Un tensor tiene tres propiedades: rango, forma y tipo

• Rango significa el número de dimensiones del Tensor (un cubo o caja tiene rango 3).
• Forma significa valores de esas dimensiones (el cuadro puede tener forma 1x1x1 o 2x5x7).
• Tipo significa tipo de datos en cada coordenada de Tensor.

Ejecución: a pesar de que se construye un gráfico, sigue siendo una entidad abstracta. Ningún cálculo realmente ocurre hasta que lo ejecutamos. Para ejecutar un gráfico, necesitamos asignar recursos de CPU a Operaciones dentro del gráfico. Esto se hace utilizando sesiones de Tensorflow. Los pasos son:

1. Crear una nueva sesión.
2. Ejecuta cualquier Op dentro del Gráfico. Por lo general, ejecutamos la Op. Final donde esperamos el resultado de nuestro cálculo.

Una ventaja entrante en una Op es como una dependencia de datos en otra Op. Por lo tanto, cuando ejecutamos cualquier Op, todos los bordes entrantes se trazan y las operaciones en el otro lado también se ejecutan.

Nota: También son posibles los nodos especiales llamados rol de juego de origen de datos o sumidero. Por ejemplo, puede tener una Op que da un valor constante, por lo tanto no hay bordes entrantes (consulte el valor 'matrix1' en el ejemplo a continuación) y de manera similar, Op sin bordes salientes donde se recopilan los resultados (consulte el 'producto' en el ejemplo a continuación).

Ejemplo:

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

Contando hasta 10

En este ejemplo, usamos Tensorflow para contar hasta 10. Sí, esto es una exageración total, pero es un buen ejemplo para mostrar una configuración mínima absoluta necesaria para usar 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)

Lo importante a tener en cuenta aquí es que el estado, la adición y la actualización no contienen valores. En su lugar, son referencias a objetos Tensorflow. El resultado final no es el estado , sino que se recupera utilizando un Tensorflow para evaluarlo utilizando sess.run (estado)

Este ejemplo es de https://github.com/panchishin/learn-to-tensorflow . Hay varios otros ejemplos allí y un buen plan de aprendizaje graduado para familiarizarse con la manipulación del gráfico Tensorflow en python.