Introducción a Tensor con Tensorflow

TensorFlow es una biblioteca de software de código abierto para la programación de flujo de datos en una variedad de tareas. Es una biblioteca matemática simbólica y también se utiliza para aplicaciones de aprendizaje automático, como redes neuronales. TensorFlow de código abierto de Google en noviembre de 2015. Desde entonces, TensorFlow se ha convertido en el repositorio de aprendizaje automático con más estrellas en Github. (https://github.com/tensorflow/tensorflow)

¿Por qué TensorFlow? La popularidad de TensorFlow se debe a muchas cosas, pero principalmente al concepto de gráficos computacionales, la diferenciación automática y la adaptabilidad de la estructura de la API de Python de Tensorflow. Esto hace que la resolución de problemas reales con TensorFlow sea accesible para la mayoría de los programadores.

El motor Tensorflow de Google tiene una forma única de resolver problemas. Esta forma única permite resolver problemas de aprendizaje automático de manera muy eficiente. Cubriremos los pasos básicos para comprender cómo funciona Tensorflow.

¿Qué es Tensor en Tensorflow?

TensorFlow, como su nombre lo indica, es un marco para definir y ejecutar cálculos que involucran tensores. Un tensor es una generalización de vectores y arrays a dimensiones potencialmente más altas. Internamente, TensorFlow representa los tensores como arrays n-dimensionales de tipos de datos base. Cada elemento del tensor tiene el mismo tipo de datos y el tipo de datos siempre se conoce. La forma (es decir, el número de dimensiones que tiene y el tamaño de cada dimensión) podría conocerse solo parcialmente. La mayoría de las operaciones producen tensores de formas completamente conocidas si las formas de sus entradas también son completamente conocidas, pero en algunos casos solo es posible encontrar la forma de un tensor en el momento de la ejecución del gráfico.

Esquemas generales del algoritmo TensorFlow

Aquí presentaremos el flujo general de los algoritmos Tensorflow.

1. Importar o generar datos

   Todos nuestros algoritmos de aprendizaje automático dependerán de los datos. En la práctica, generaremos datos o utilizaremos una fuente externa de datos. A veces es mejor confiar en los datos generados porque querremos saber el resultado esperado. Y también tensorflow viene precargado con conjuntos de datos famosos como MNIST, CIFAR-10, etc.

2. Transformar y normalizar datos

   Por lo general, los datos no tienen la dimensión o el tipo correctos que esperan nuestros algoritmos de Tensorflow. Tendremos que transformar nuestros datos antes de poder usarlos. La mayoría de los algoritmos también esperan datos normalizados. Tensorflow tiene funciones integradas que pueden normalizar los datos por ti.

   data = tf.nn.batch_norm_with_global_normalization(...)

3. Establecer parámetros de algoritmo

   Nuestros algoritmos suelen tener un conjunto de parámetros que mantenemos constantes durante todo el procedimiento. Por ejemplo, puede ser el número de iteraciones, la tasa de aprendizaje u otros parámetros fijos de nuestra elección. Se considera una buena forma inicializarlos juntos para que el lector o usuario pueda encontrarlos fácilmente.

   learning_rate = 0.001  iterations = 1000

4. Inicializar variables y marcadores de posición

   Tensorflow depende de que le digamos qué puede y qué no puede modificar. Tensorflow modificará las variables durante la optimización para minimizar una función de pérdida. Para lograr esto, ingresamos datos a través de marcadores de posición. Necesitamos inicializar ambos, variables y marcadores de posición con tamaño y tipo, para que Tensorflow sepa qué esperar.

   a_var = tf.constant(42)  x_input = tf.placeholder(tf.float32, [None, input_size])  y_input = tf.placeholder(tf.fload32, [None, num_classes])

5. Definir la estructura del modelo

   Después de tener los datos e inicializar nuestras variables y marcadores de posición, tenemos que definir el modelo. Esto se hace mediante la construcción de un gráfico computacional. Le decimos a Tensorflow qué operaciones se deben realizar en las variables y marcadores de posición para llegar a las predicciones de nuestro modelo.

   y_pred = tf.add(tf.mul(x_input, weight_matrix), b_matrix)

6. Declarar las funciones de pérdida

   Después de definir el modelo, debemos poder evaluar la salida. Aquí es donde declaramos la función de pérdida. La función de pérdida es muy importante ya que nos dice qué tan lejos están nuestras predicciones de los valores reales.

   loss = tf.reduce_mean(tf.square(y_actual – y_pred))

7. Inicializar y entrenar el modelo.

   Ahora que tenemos todo en su lugar, creamos una instancia o nuestro gráfico e ingresamos los datos a través de los marcadores de posición y dejamos que Tensorflow cambie las variables para predecir mejor nuestros datos de entrenamiento. Aquí hay una forma de inicializar el gráfico computacional.

   with tf.Session(graph=graph) as session:
    ...
    session.run(...)
    ...

   Tenga en cuenta que también podemos iniciar nuestro gráfico con

   session = tf.Session(graph=graph)  session.run(…)

8. Evaluar el modelo (Opcional)

   Una vez que hemos construido y entrenado el modelo, debemos evaluar el modelo observando qué tan bien funciona con nuevos datos a través de algunos criterios específicos.

9. Predecir nuevos resultados (Opcional)

   También es importante saber cómo hacer predicciones sobre datos nuevos e invisibles. Podemos hacer esto con todos nuestros modelos, una vez que los hayamos entrenado.

Resumen

En Tensorflow, tenemos que configurar los datos, las variables, los marcadores de posición y el modelo antes de decirle al programa que entrene y cambie las variables para mejorar las predicciones. Tensorflow logra esto a través del gráfico computacional. Le decimos que minimice una función de pérdida y Tensorflow lo hace modificando las variables en el modelo. Tensorflow sabe cómo modificar las variables porque realiza un seguimiento de los cálculos en el modelo y calcula automáticamente los gradientes para cada variable. Debido a esto, podemos ver lo fácil que puede ser hacer cambios y probar diferentes fuentes de datos.

En general, los algoritmos están diseñados para ser cíclicos en TensorFlow. Configuramos este ciclo como un gráfico computacional y (1) ingresamos datos a través de los marcadores de posición, (2) calculamos la salida del gráfico computacional, (3) comparamos la salida con la salida deseada con una función de pérdida, (4) modificamos las variables del modelo de acuerdo con la retropropagación automática, y finalmente (5) repetir el proceso hasta que se cumpla un criterio de parada.

Now starts the practical session with tensorflow and implementing tensors using it.

Primero, necesitamos importar las bibliotecas requeridas.

import tensorflow as tf
from tensorflow.python.framework import ops
ops.reset_default_graph()

Luego para iniciar la sesión de gráficos

sess = tf.Session()

Ahora viene la parte principal, es decir, crear tensores.

TensorFlow tiene una función integrada para crear tensores para usar en variables. Por ejemplo, podemos crear un tensor lleno de ceros de forma predefinida usando la función tf.zeros() de la siguiente manera.

my_tensor = tf.zeros([1,20])

Podemos evaluar tensores llamando a un método run() en nuestra sesión.

sess.run(my_tensor)

Los algoritmos de TensorFlow necesitan saber qué objetos son variables y cuáles son constantes. Así que creamos una variable usando la función TensorFlow tf.Variable(). Tenga en cuenta que no puede ejecutar sess.run(my_var), esto daría como resultado un error. Debido a que TensorFlow opera con gráficos computacionales, debemos crear una operación de inicialización de variables para evaluar las variables. Para este script, podemos inicializar una variable a la vez llamando al método de variable my_var.initializer.

my_var = tf.Variable(tf.zeros([1,20]))
sess.run(my_var.initializer)
sess.run(my_var)

Producción:

array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  
              0.,  0.,  0.,  0.,  0.,  0.,  0.,  
              0.,  0.,  0.,  0.,  0.,  0.]], dtype=float32)

Ahora vamos a crear nuestra variable para manejar las dimensiones de tener una forma específica y luego inicializar las variables con todo ‘1’ o ‘0’

row_dim = 2
col_dim = 3
zero_var = tf.Variable(tf.zeros([row_dim, col_dim]))
ones_var = tf.Variable(tf.ones([row_dim, col_dim]))

Ahora evalúe los valores de ellos, podemos ejecutar métodos de inicialización en nuestras variables nuevamente.

sess.run(zero_var.initializer)
sess.run(ones_var.initializer)
print(sess.run(zero_var))
print(sess.run(ones_var))

Producción:

[[ 0.  0.  0.]
 [ 0.  0.  0.]]
[[ 1.  1.  1.]
 [ 1.  1.  1.]]

Y esta lista continuará. El resto será para que estudies, sigue este jupyter notebook por mí para obtener más información sobre los tensores desde aquí .

Visualización de la creación de variables en TensorBoard

Para visualizar la creación de variables en Tensorboard, restableceremos el gráfico computacional y crearemos una operación de inicialización global.

# Reset graph
ops.reset_default_graph()
  
# Start a graph session
sess = tf.Session()
  
# Create variable
my_var = tf.Variable(tf.zeros([1,20]))
  
# Add summaries to tensorboard
merged = tf.summary.merge_all()
  
# Initialize graph writer:
writer = tf.summary.FileWriter("/tmp/variable_logs", graph=sess.graph)
  
# Initialize operation
initialize_op = tf.global_variables_initializer()
  
# Run initialization of variable
sess.run(initialize_op)

Ahora ejecute el siguiente comando en cmd.

tensorboard --logdir=/tmp

Y nos dirá la URL en la que podemos navegar nuestro navegador para ver Tensorboard, para lograr sus gráficos de pérdidas.

Código para crear todo tipo de tensores y evaluarlos.

import tensorflow as tf
from tensorflow.python.framework import ops
ops.reset_default_graph()
  
# Introduce tensors in tf
  
# Get graph handle
sess = tf.Session()
  
my_tensor = tf.zeros([1,20])
  
# Declare a variable
my_var = tf.Variable(tf.zeros([1,20]))
  
# Different kinds of variables
row_dim = 2
col_dim = 3 
  
# Zero initialized variable
zero_var = tf.Variable(tf.zeros([row_dim, col_dim]))
  
# One initialized variable
ones_var = tf.Variable(tf.ones([row_dim, col_dim]))
  
# shaped like other variable
sess.run(zero_var.initializer)
sess.run(ones_var.initializer)
zero_similar = tf.Variable(tf.zeros_like(zero_var))
ones_similar = tf.Variable(tf.ones_like(ones_var))
  
sess.run(ones_similar.initializer)
sess.run(zero_similar.initializer)
  
# Fill shape with a constant
fill_var = tf.Variable(tf.fill([row_dim, col_dim], -1))
  
# Create a variable from a constant
const_var = tf.Variable(tf.constant([8, 6, 7, 5, 3, 0, 9]))
# This can also be used to fill an array:
const_fill_var = tf.Variable(tf.constant(-1, shape=[row_dim, col_dim]))
  
# Sequence generation
linear_var = tf.Variable(tf.linspace(start=0.0, stop=1.0, num=3)) # Generates [0.0, 0.5, 1.0] includes the end
  
sequence_var = tf.Variable(tf.range(start=6, limit=15, delta=3)) # Generates [6, 9, 12] doesn't include the end
  
# Random Numbers
  
# Random Normal
rnorm_var = tf.random_normal([row_dim, col_dim], mean=0.0, stddev=1.0)
  
# Add summaries to tensorboard
merged = tf.summary.merge_all()
  
# Initialize graph writer:
  
writer = tf.summary.FileWriter("/tmp/variable_logs", graph=sess.graph)
  
# Initialize operation
initialize_op = tf.global_variables_initializer()
  
# Run initialization of variable
sess.run(initialize_op)

Producción:

Link de referencia:

1) Documentación de Tensorflow