Sesiones iterativas y grafos en TensorFlow son ciertas funciones de esta biblioteca de código abierto que resulta necesario estudiar cuando quieres convertirte en un experto en el manejo de los macrodatos. Por ello, en este post, te exponemos cómo funcionan las sesiones iterativas y grafos en TensorFlow.

Sesiones iterativas y grafos en TensorFlow

Para conocer las sesiones iterativas y grafos en TensorFlow, primero se definen las operaciones a realizar y luego se ejecutan. Para ello, se usa un grafo.

Un ejemplo sencillo de una suma de a + b:

Un ejemplo un poco más complicado de sesiones iterativas y grafos en TensorFlow:

Es un ejemplo de un grafo que representa la clasificación de una imagen de un número en su correspondiente clase. TensorFlow funciona así: primero defines las operaciones que quieres que se realicen, junto a las variables necesarias (creas el grafo), y luego lo ejecutas (con una sesión).

# Lo primero que necesitamos hacer es asegurarnos de que vamos a ejecutar la 
# versión 1.x de TensorFlow. Hace aproximadamente un año salió la versión
# 2.0, que establece por defecto el "EagerMode" para hacer más sencilla la 
# implementación y depuración de código. 

# No obstante, al igual que pasó en su día con Python 2 y Python 3, con tensorflow
# ha pasado algo similar: la versión 1.x se sigue utilizando mucho. Algunas de 
# las razones son la retro-compatibilidad y la rapidez de ejecución. En este 
# curso veremos ejemplos de ambos casos.

# Vamos a ver qué versión es la que tenemos:
import tensorflow as tf
print(tf.__version__)

# Desde el 27 de marzo de 2020, Google Colab tiene activada por defecto la versión
# 2.x. Para poder usar la 1.x debemos utilizar el siguiente comando mágico: 

%tensorflow_version 1.x

# Al haber cargado tensorflow ya, lo más probable es que os pida reiniciar el 
# runtime para poder cambiar la versión, si es así, lo reiniciáis y volvéis a 
# ejecutar el comando. Este es el mensaje que suele aparecer cuando esto sucede:
# "TensorFlow is already loaded. Please restart the runtime to change versions."

# Si todo va bien, esto es lo que deberíais ver:
# "TensorFlow 1.x selected."

# Vamos a comprobar qué versión tenemos ahora:
import tensorflow as tf
print(tf.__version__)

# Como podéis ver, ya tenemos la versión 1.x

# Lo primero que debemos hacer es importar el paquete de Tensorflow
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt # importamos también pyplot para gráficas
%matplotlib inline

# Es muy importante que conozcamos 3 conceptos básicos de TF:
# tf.Graph: representa un conjunto de tf.Operations
# tf.Operation: son las operaciones indicadas por las ecuaciones que escribimos
# tf.Tensor: los resultados de las tf.Operations

# En un principio, el tf.Graph es transparente a nosotros, ya que por defecto
# existe uno donde se van añadiendo todas las operaciones que definimos:
# tf.get_default_graph()

# Vamos a empezar con algo muy sencillo, una simple multiplicación en TensorFlow

# Primero definimos los valores que queremos utilizar
x = tf.constant(6)  # tf.Constant porque no va a cambiar durante la ejecución
y = tf.constant(8)

# Ahora definimos la operación a realizar: la multiplicación
result = ## Code ##
print(result)

# Como podéis ver, no nos ha devuelto el resultado. Lo que ha hecho hasta ahora
# ha sido crear el grafo. Por poner un ejemplo, es como montar un coche. Ahora 
# lo tenemos montado, pero aún no hace aquello para lo que fue diseñado, 
# desplazarse. Para ello, deberíamos encenderlo. Pues con esto es igual,
# tenemos que encenderlo:

sess = ##Code##  # abrimos nuestro "coche" y lo encendemos
output = ##Code##   # nos ponemos en movimiento
print(output)

# Para poder visualizar el grafo ERA necesario definir un par de funciones que 
# lo permitan. Para que veáis a que nivel TF puede llegar a ser un incordio,
# las he dejado aquí.

from IPython.display import clear_output, Image, display, HTML

def strip_consts(graph_def, max_const_size=32):
    """Strip large constant values from graph_def."""
    strip_def = tf.GraphDef()
    for n0 in graph_def.node:
        n = strip_def.node.add() 
        n.MergeFrom(n0)
        if n.op == 'Const':
            tensor = n.attr['value'].tensor
            size = len(tensor.tensor_content)
            if size > max_const_size:
                tensor.tensor_content = "<stripped %d bytes>"%size
    return strip_def

def show_graph(graph_def, max_const_size=32):
    """Visualize TensorFlow graph."""
    if hasattr(graph_def, 'as_graph_def'):
        graph_def = graph_def.as_graph_def()
    strip_def = strip_consts(graph_def, max_const_size=max_const_size)
    code = """
        <script>
          function load() {{
            document.getElementById("{id}").pbtxt = {data};
          }}
        </script>
        <link rel="import" href="https://tensorboard.appspot.com/tf-graph-basic.build.html" onload=load()>
        <div style="height:600px">
          <tf-graph-basic id="{id}"></tf-graph-basic>
</div>
    """.format(data=repr(str(strip_def)), id='graph'+str(np.random.rand()))

    iframe = """
        <iframe seamless style="width:1200px;height:620px;border:0" srcdoc="{}"></iframe>
    """.format(code.replace('"', '&quot;'))
    display(HTML(iframe))

# Ahora, desde TF 1.13, podemos hacer uso del comando mágico: %tensorboard
# Pero primero, tenemos que guardar el grafo:
writer = tf.summary.FileWriter("output", tf.get_default_graph())
writer.close()

# ahora sí, visualizamos el grafo recien construido:
%load_ext tensorboard
%tensorboard --logdir output

En este post, te hemos expuesto cómo funcionan las sesiones iterativas y grafos en TensorFlow. No obstante, el universo del manejo del Big Data es muy amplio y, por ello, si planeas seguir aprendiendo al respecto, no dudes en investigar el Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning, con el que podrás desarrollar una serie de destrezas para llevar a cabo el manejo de macrodatos. ¡Apúntate ya!