notebook.community

Edit and run 





In [0]:



    


# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Conceptos de programación de TensorFlow

Objetivos de aprendizaje:

  • Obtén información sobre los conceptos básicos del modelo de programación de TensorFlow, enfocado en los siguientes conceptos:
    • tensores
    • operaciones
    • gráficos
    • sesiones
  • Crea un programa simple de TensorFlow que genere un gráfico predeterminado y una sesión que ejecute el gráfico.

Nota: Lee atentamente este instructivo. El modelo de programación de TensorFlow probablemente sea diferente a otros que conozcas y, por lo tanto, tal vez no sea lo suficientemente intuitivo.

Resumen de conceptos

El nombre de TensorFlow proviene de tensores, que son matrices de dimensionalidad arbitraria. Con TensorFlow, puedes manipular tensores con una gran cantidad de dimensiones. No obstante, mayormente trabajarás con uno o más de los siguientes tensores de baja dimensionalidad:

  • Un escalar es una matriz de 0-d (un tensor en el orden 0). Por ejemplo, "Howdy" o 5
  • Un vector es una matriz de 1-d (un tensor en el orden 1). Por ejemplo, [2, 3, 5, 7, 11] o [5]
  • Un arreglo es una matriz de 2-d (un tensor en el orden 2). Por ejemplo, [[3.1, 8.2, 5.9][4.3, -2.7, 6.5]]

Las operaciones de TensorFlow crean, destruyen y manipulan tensores. La mayoría de las líneas de código en un programa típico de TensorFlow son operaciones.

Un gráfico de TensorFlow (también conocido como gráfico computacional o gráfico de flujo de datos) es, de hecho, una estructura de datos de gráfico. Muchos programas de TensorFlow consisten en un solo gráfico, pero es posible que los programas de TensorFlow alternativamente creen gráficos múltiples. Los nodos de un gráfico son operaciones; los bordes de un gráfico son tensores. Los tensores fluyen en el gráfico, manipulado en cada nodo mediante una operación. El tensor de resultado de una operación por lo general se convierte en el tensor de entrada de una operación subsiguiente. TensorFlow implementa un modelo de ejecución relajado, lo que significa que los nodos solo se calculan cuando es necesario, en función de los nodos asociados.

Los tensores pueden almacenarse en el gráfico como constantes o variables. Como podrás imaginar, las constantes tienen tensores cuyos valores no pueden cambiar, mientras que las variables tienen tensores cuyos valores sí pueden cambiar. Sin embargo, lo que posiblemente no imagines es que las constantes y las variables son solo más operaciones en el gráfico. Una constante es una operación que siempre arroja el mismo valor de tensor. Una variable es una operación que arrojará el tensor que tuviera asignado.

Para definir una constante, usa el operador tf.constant y envía su valor. Por ejemplo:

  x = tf.constant([5.2])

De manera similar, puedes crear una variable como la siguiente:

  y = tf.Variable([5])

O bien puedes crear primero la variable y, luego, asignar un valor como el siguiente (ten en cuenta que siempre debes especificar un valor predeterminado):

  y = tf.Variable([0])
  y = y.assign([5])

Una vez que hayas definido algunas constantes o variables, podrás combinarlas con otras operaciones, como tf.add. Cuando evalúas la operación tf.add, esta invocará a tus operaciones tf.constant o tf.Variable para obtener sus valores y, luego, obtener un tensor nuevo con la suma de esos valores.

Los gráficos deben ejecutarse dentro de una sesión de TensorFlow, que incluye el estado de los gráficos que ejecuta:

with tf.Session() as sess:
  initialization = tf.global_variables_initializer()
  print(y.eval())

Cuando trabajas con variables tf.Variable, debes inicializarlas de forma explícita. Para hacerlo, debes invocar a tf.global_variables_initializer al inicio de la sesión, como se muestra arriba.

Nota: Una sesión puede distribuir la ejecución del gráfico en varias máquinas (si asumimos que el programa se ejecuta en un marco de trabajo de cálculo distribuido). Para obtener más información, consulta TensorFlow distribuido.

Resumen

La programación de TensorFlow básicamente es un proceso de dos pasos:

  1. Crea constantes, variables y operaciones en un gráfico.
  2. Evalúa esas constantes, variables y operaciones en una sesión.

Creación de un programa simple de TensorFlow

Veamos cómo codificar un programa simple de TensorFlow que agrega dos constantes.

Establecimiento de sentencias de importación

Al igual que con casi todos los programas de Python, empezarás especificando algunas sentencias de import. El conjunto de sentencias de import necesario para ejecutar un programa de TensorFlow depende, por supuesto, de las funciones que accede tu programa. Como mínimo, debes proporcionar la sentencia import tensorflow en todos los programas de TensorFlow:





In [0]:



    


import tensorflow as tf

No te olvides de ejecutar el bloque de código previo (las sentencias de import).

Otras sentencias de importación habituales incluyen lo siguiente:

  import matplotlib.pyplot as plt # Visualización del conjunto de datos
  import numpy as np              # Biblioteca de Python numérica de bajo nivel
  import pandas as pd             # Biblioteca de Python numérica de alto nivel

TensorFlow proporciona un gráfico predeterminado. Sin embargo, recomendamos de forma explícita crear tu propio Graph en lugar de proporcionar el estado de seguimiento (p. ej., es posible que quieras trabajar con un Graph diferente en cada celda).





In [0]:



    


from __future__ import print_function

import tensorflow as tf

# Create a graph.
g = tf.Graph()

# Establish the graph as the "default" graph.
with g.as_default():
  # Assemble a graph consisting of the following three operations:
  #   * Two tf.constant operations to create the operands.
  #   * One tf.add operation to add the two operands.
  x = tf.constant(8, name="x_const")
  y = tf.constant(5, name="y_const")
  sum = tf.add(x, y, name="x_y_sum")


  # Now create a session.
  # The session will run the default graph.
  with tf.Session() as sess:
    print(sum.eval())

Ejercicio: Introduce un tercer operando

Revisa la lista de códigos de arriba para agregar tres números enteros, en lugar de dos:

  1. Define una tercera constante escalar de números enteros, z, y asígnala a un valor de 4.

  2. Agrega z a sum para generar una nueva suma.

    Sugerencia: Consulta los documentos de la API para tf.add() para obtener más información sobre su firma de función.

  3. Vuelve a ejecutar el bloque de código modificado. ¿El programa generó la suma total correcta?

Solución

Haz clic a continuación para conocer la solución.





In [0]:



    


# Create a graph.
g = tf.Graph()

# Establish our graph as the "default" graph.
with g.as_default():
  # Assemble a graph consisting of three operations. 
  # (Creating a tensor is an operation.)
  x = tf.constant(8, name="x_const")
  y = tf.constant(5, name="y_const")
  sum = tf.add(x, y, name="x_y_sum")
  
  # Task 1: Define a third scalar integer constant z.
  z = tf.constant(4, name="z_const")
  # Task 2: Add z to `sum` to yield a new sum.
  new_sum = tf.add(sum, z, name="x_y_z_sum")

  # Now create a session.
  # The session will run the default graph.
  with tf.Session() as sess:
    # Task 3: Ensure the program yields the correct grand total.
    print(new_sum.eval())

Más información

Para explorar más los gráficos básicos de TensorFlow, prueba con el siguiente instructivo:

Content source: google/eng-edu

Similar notebooks:

notebook.community | gallery | about