Uso Básico

Para usar TensorFlow es necesario entender como TensorFlow:

  • Representa cálculos en forma de grafos.
  • Ejecuta grafos en el contexto de sesiones.
  • Representa los datos en forma de tensors.
  • Mantiene el estado con Variables.
  • Usa operaciones de alimentación y recuperación para obtener datos dentro y fuera de operaciones arbitrarias.

Resumen

Tensor Flow es un sistema de programación, en el cuál puedes representar cálculos computacionales como grafos. Los Nodos en el grafo son llamados ops (cortos para operaciones)- Un op toma cero o mas Tensors, desempeña cierta operación computacional y produce cero o más Tensors. Un Tensor es un arreglo multidimensional tipificado. Por ejemplo, tu puedes representar una mini-batch de imágenes como un arreglo 4-D de puntos flotantes con dimensiones [dimensiones, altura, anchura, canales].

El cómputo basado en grafos

Los programas de TensorFlow son usualmente estructurados dentro de una fase de construcción, y una fase de ejecución que utiliza una sesión para ejecutar ops en el grafo.

Por ejemplo, es común crear un grafo para representar y entrenar una red neuronal en la fase de construcción, y entonces ejecutar repetidamente un conjunto de ops entrenadas en la fase de ejecución.

TensorFlow puede ser utilizado en programas como: C, C++ y Python. Esto representa una manera mucho más sencilla de utilizar las librerias de Python para unir grafos, como tambien se prevee de un gran conjunto de funciones útiles que no estan disponibles en C y C++.

Las librerías de sesión tienen funcionalidades equivalente paralos tres lenguajes.

Construyendo el grafo

Para construir un grafo comienza con los ops que no necesitan ninguna entrada (ops fuente), como una constante, y pasa su salida a otro ops para realizar el cálculo cómputacional.

El constructor de ops en la librería de Python regresa objetos que se mantienen para la salida de las ops construidas. Usted puede pasarles a otras ops construidas para usarlas como entradas.

La librería de Python para TensorFlow tiene un grafo por default el cual agrega nodos a los ops constructores. El grafo por defecto es suficiente para muchas aplicaciones. Vea la documentación de la clase Graph para como manejar explícitamente múltiples grafos.

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)

El grafo por defecto ahora tiene tres nodos: dos constant() ops y uno matmul() op. Para multiplicar las matrices, y obtener el resultado de la multiplicación, usted debe lanzar el grafo firmado en su sesión personal.```

Lanzando el Grafo en una sesión

El lanzamiento requiere la siguiente construcción. Para lanzar el Grafo, cree un objeto Session. Sin argumentos, el constructor de la sesión lanza el grafo por default.

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

La sesión debe cerrarse para liberar recursos. Tambien puede ingresar a la sesión con un bloque "with". La sessión es cerrada automáticamente al final del bloque "with".

with tf.Session() as sess:
  result = sess.run([product])
  print(result)

La implementación de TensorFlow traduce la definición de un grafo en operaciones distribuidas ejecutables a lo largo de recursos de cómputo disponibles, como CPU o una de las tarjetas GPU en su computadora. En general no necesita especificar los CPUs o GPUs explícitamente. TensorFlow utiliza el primer GPU, si usted cuenta con uno, para la mayoría de las operaciones como sea posible.

Si usted cuenta con más de un GPU dispinible en su computadora, para usar un GPU más allá del primero usted debe asignarle ops explícitamente. Use la instrucción with...Device para específicar cual CPU o GPU usar para la operación:

with tf.Session() as sess:
  with tf.device("/gpu:1"):
    matrix1 = tf.constant([[3., 3.]])
    matrix2 = tf.constant([[2.],[2.]])
    product = tf.matmul(matrix1, matrix2)
    ...

Los dispositivos con especificados como strings. Los dispositivos actualmente soportados son:

  • "/cpu:0": The CPU of your machine.
  • "/gpu:0": The GPU of your machine, if you have one.
  • "/gpu:1": The second GPU of your machine, etc.

Vea Usando_GPUs para más información sobre GPUs y TensorFlow

Lanzando el Grafo en una sesión distribuida

Para crear un cluster de TensorFlow, lance un server de TensorFlow en cada una de las máquinas en el clúster. Cuando usted inicia una sesión en su cliente, usted debe enviar la localización en la red de una de las máquinas en el clúster:

with tf.Session("grpc://example.org:2222") as sess:
  # Calls to sess.run(...) will be executed on the cluster.
  ...

Esta máquina se convierte en el maestro de la sesión. El maestro distribuye el Grafo a través de otras máquinas en el cluster(workesrs), parecido en la manera en la que la implementación local distribuye el Grafo através de recursos de cómputo dentro de una máquina.

Usted puede usar "with tf.device():" para especificar directamente los workers para partes espcíficas del Grafo:

with tf.device("/job:ps/task:0"):
  weights = tf.Variable(...)
  biases = tf.Variable(...)

Vea TensorFlow_Distribuido_HowTo para más información sobre sesiones distribuidoas y clusters

Uso interactivo

Los ejemplos de Python en la documentación lanzan el Grafo con una Session y usa Session.run()

Para facilitar el uso de ambientes interactivos de Python, como IPython usted puede utilizar la clase InteractiveSession, y el Tensor.eval() y los métodos Operation.run(). Esto permitirá mantener una variable para la sesión:

# Enter an interactive TensorFlow Session.
import tensorflow as tf
sess = tf.InteractiveSession()

x = tf.Variable([1.0, 2.0])
a = tf.constant([3.0, 3.0])

# Initialize 'x' using the run() method of its initializer op.
x.initializer.run()

# Add an op to subtract 'a' from 'x'.  Run it and print the result
sub = tf.sub(x, a)
print(sub.eval())
# ==> [-2. -1.]

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

Tensors

Los programas de TensorFlow usan una estructura de datos tensor para representar todos los datos -- sólo los tensors pasan por las operaciones del Grafo computacional. Usted puede pensar en un tensor TensorFlow como un arreglo de n-dimensiones o una lista. Un tensor tiene un tipos estático, un rango y una forma. Para aprender más sobre como soporta TensorFlow este concepto, vea Rango,Forma y Tipo.

Variables

Las variables mantienen su estado durante la ejecución del Grafo. Los siguientes ejemplos muestran una variable sirviendo como un simple contador. Vea Variables para más detalles.

# Create a Variable, that will be initialized to the scalar value 0.
state = tf.Variable(0, name="counter")

# Create an Op to add one to `state`.

one = tf.constant(1)
new_value = tf.add(state, one)
update = tf.assign(state, new_value)

# Variables must be initialized by running an `init` Op after having
# launched the graph.  We first have to add the `init` Op to the graph.
init_op = tf.initialize_all_variables()

# Launch the graph and run the ops.
with tf.Session() as sess:
  # Run the 'init' op
  sess.run(init_op)
  # Print the initial value of 'state'
  print(sess.run(state))
  # Run the op that updates 'state' and print 'state'.
  for _ in range(3):
    sess.run(update)
    print(sess.run(state))

# output:

# 0
# 1
# 2
# 3

La operación assing() en este código es una parte de la expresión del Grafo como la operación add(), pero esto no realiza la asignación hasta que se ejecuta la expresión run()

Típicamente usted puede representar los parámetros de un modelo estadístico como un conjunto de Variables. Por ejemplo, usted quisiera almacenar los pesos de una red nueronal como un tensor en una variable. Duante el entrenamiento usted actualiza este tensor corriendo un Grafo de entrenamiento repetidamente.

Fetches

Para extraer las salidas de las operaciones, ejecute el Grafo con una llamda run() sobre el objeto Session y pasar en el tensor para recuperarlo. En el ejemplo anterior, nosotros extrajimos el nodo sencillo state, pero también podemos extraer múltiples tensors:

input1 = tf.constant([3.0])
input2 = tf.constant([2.0])
input3 = tf.constant([5.0])
intermed = tf.add(input2, input3)
mul = tf.mul(input1, intermed)

with tf.Session() as sess:
  result = sess.run([mul, intermed])
  print(result)

# output:
# [array([ 21.], dtype=float32), array([ 7.], dtype=float32)]

Todas las ops necesarios para producir los valores de los tensores requeridos son corridos una vez (no una vez para cada ocasión que son requeridos).

Feeds

Los ejemplos anteriores introduce a los tensors en un Grafo computacional almacenándole en Constantes y Variables. TensorFlow tambien provee un mecanismo de alimentación para ajustar un tensor directamente en una operación en el Grafo.

Un feed temporalmente reemplaza una salida de una operación con un valor del tensor. Usted aliemnta los datos del feed como un argumento de la llamada a run(). El feed es solamente utilizado para ejecutar call en el que es enviado. El caso más común envuelve operaciones especialmente diseñadas para ser operaciones "feed" usando: tf.placeholder() para crearlos:

input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
output = tf.mul(input1, input2)

with tf.Session() as sess:
  print(sess.run([output], feed_dict={input1:[7.], input2:[2.]}))

# output:
# [array([ 14.], dtype=float32)]

La operación placeholer() genera un error si usted no puede soportar un feed para esto. Vea MNIST fully-connected feed tutorial (source code) para código más complejos de Feeds.

results matching ""

    No results matching ""