Hola Habr! Les presento la traducción del artículo "Tutorial de TensorFlow: 10 minutos Lección práctica de TensorFlow para estudiantes rápidos" por Ankit Sachan.
Este tutorial de TensorFlow es para cualquier persona que tenga una comprensión básica del aprendizaje automático y esté intentando comenzar con TensorFlow.
En primer lugar, debe tener instalado TensorFlow. Puedes instalarlo en esta guía. Esta lección se divide en dos partes: en la primera parte explicamos los conceptos básicos con un ejemplo de trabajo, en la segunda parte construimos un modelo de regresión lineal.
Parte 1. Conceptos básicos de TensorFlow
TensorFlow es una biblioteca numérica en la que los datos pasan a través de un gráfico. Los datos en TensorFlow están representados por matrices n-dimensionales - tensores. El gráfico está compuesto de datos (tensores) y operaciones matemáticas.
En los nodos del gráfico hay operaciones matemáticas.
Los bordes del gráfico representan tensores que "fluyen" entre operaciones.
Hay otro aspecto en el que TensorFlow es muy diferente de cualquier otro lenguaje de programación. En TensorFlow, primero debe crear un proyecto de lo que desea crear. Inicialmente, al crear un gráfico, las variables no tienen significado. Más tarde, cuando creó un gráfico completo, lo ejecutó en una sesión y solo entonces las variables tomarán cualquier valor.
Comencemos aprendiendo haciendo. Ejecute Python e importe TensorFlow:
~$ python Python 2.7.6 (default, Oct 26 2016, 20:30:19) [GCC 4.8.4] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> >>>import tensorflow as tf
Se utiliza un gráfico para definir operaciones, y todas las operaciones se realizan en una sesión. Los gráficos y las sesiones se crean independientemente uno del otro. Trate el gráfico como un proyecto de construcción y la sesión como un sitio de construcción.
1.1. Gráficos en TensorFlow
Un gráfico es la base de TensorFlow, todos los cálculos (operaciones), las variables están en el gráfico. Todo lo que sucede en el código está en el gráfico predeterminado proporcionado por TensorFlow. Puede acceder a este gráfico de la siguiente manera:
graph = tf.get_default_graph()
Y así puede obtener una lista de todas las operaciones en esta columna:
graph.get_operations()
Su gráfico ahora está vacío. Si necesita imprimir el nombre de cada operación, ejecute el siguiente código:
for op in graph.get_operations(): print(op.name)
La salida volverá a estar vacía. En el futuro, después de agregar operaciones al gráfico, utilizaremos este código para mostrar sus nombres.
1.2. Sesiones en TensorFlow
El gráfico solo define los cálculos (crea el proyecto), pero no tiene ninguna variable, ni valores, a menos que ejecutemos el gráfico o parte del gráfico en la sesión.
Puede crear una sesión como esta:
sess=tf.Session() ... your code ... ... your code ... sess.close()
No olvides que para iniciar una sesión debes finalizarla o usar el bloque with ... as , por ejemplo así:
with tf.Session() as sess: sess.run(f)
La ventaja de utilizar este enfoque es que la sesión se cerrará automáticamente al final del bloque with
1.3. Tensores en TensorFlow
TensorFlow almacena datos en tensores: matrices multidimensionales muy similares a las matrices numPy.
a) Las constantes son valores que no se pueden cambiar. Se definen de la siguiente manera:
a=tf.constant(1.0)
sin embargo, cuando intenta generar resultados, obtiene lo siguiente:
print(a) <tf.Tensor'Const:0' shape=() dtype=float32> print(a) Tensor("Const:0", shape=(), dtype=float32)
Como puede ver, esto es diferente de otros lenguajes de programación, como python. No puede imprimir o acceder a la constante hasta que comience la sesión. Hagamos esto:
with tf.Session() as sess: print(sess.run(a))
Este código generará 1.0
b) Las variables también son tensores que son como variables en otros lenguajes de programación:
>>>b = tf.Variable(2.0,name="test_var") >>>b <tensorflow.python.ops.variables.Variable object at 0x7f37ebda1990>
A diferencia de las constantes, las variables pueden cambiar su contenido. Sin embargo, las variables en TensorFlow deben inicializarse en una operación de inicialización separada. Inicializar todas las variables puede llevar mucho tiempo, pero TensorFlow proporciona un mecanismo para inicializar todas las variables a la vez:
init_op = tf.global_variables_initializer()
Ahora debe comenzar la operación de inicialización antes de intentar acceder a la variable:
with tf.Session() as sess: sess.run(init_op) print(sess.run(b))
Este código generará 2.0
Si ahora intenta imprimir operaciones en el gráfico
graph = tf.get_default_graph() for op in graph.get_operations(): print(op.name)
obtendrá el siguiente resultado:
Const test_var/initial_value test_var test_var/Assign test_var/read init
Como puede ver, declaramos "a" como Const y se agregó al gráfico. De manera similar, para la variable b, se agregaron muchos estados test_var al gráfico TensorFlow, como test_var / initial_value, test_var / read, etc. Puede visualizar toda la red utilizando TensorBoard, que es una herramienta para visualizar el gráfico TensorFlow y el proceso de aprendizaje. .
c) Los marcadores de posición son tensores que esperan ser inicializados con datos. Se utilizan para datos que se proporcionarán solo cuando el código se ejecute realmente en la sesión. Lo que se transfiere al marcador de posición es un diccionario que contiene los nombres de los marcadores de posición y sus significados:
a = tf.placeholder("float") b = tf.placeholder("float") y = tf.multiply(a, b) fd = {a: 2, b: 3} with tf.Session() as sess: print(sess.run(y, fd))
Este código generará 6.0
1.4. Dispositivos en TensorFlow
TensorFlow tiene características integradas muy potentes para ejecutar su código en GPU, CPU o clústeres. Le da la oportunidad de elegir el dispositivo en el que desea ejecutar su código. Sin embargo, esto no es algo en lo que pensar cuando recién está comenzando con TF.
Así que aquí hay una imagen completa de cómo funcionan los cálculos en TensorFlow:
Parte 2. Tutorial de TensorFlow con un ejemplo simple
En esta parte, veremos el código para ejecutar la regresión lineal. Antes de eso, veamos algunas de las funciones básicas de TensorFlow que usaremos en el código.
Crear una distribución normal aleatoria:
Use random_normal para crear valores aleatorios a partir de la distribución normal. En este ejemplo, w es una variable de dimensión 784 * 10 con valores aleatorios con una desviación estándar de 0.01.
w=tf.Variable(tf.random_normal([784, 10], stddev=0.01))
Reduce_mean : calcula el valor promedio de una matriz
b = tf.Variable([10,20,30,40,50,60],name='t') with tf.Session() as sess: sess.run(tf.initialize_all_variables()) sess.run(tf.reduce_mean(b))
Este código generará 35
argmax : muy similar a argmax en Python. Obtiene el valor máximo del tensor a lo largo del eje especificado.
a=[ [0.1, 0.2, 0.3 ], [20, 2, 3 ] ] b = tf.Variable(a,name='b') with tf.Session() as sess: sess.run(tf.initialize_all_variables()) sess.run(tf.argmax(b,1))
Imprima una matriz ([2, 0]) que muestra el índice del valor máximo en cada una de las líneas a.
Problema de regresión lineal
Planteamiento del problema: hay una gran cantidad de puntos de datos, tratando de hacer coincidir una línea recta con ellos. Para este ejemplo, crearemos 100 puntos de datos e intentaremos hacer coincidir la línea con ellos.
2.1. Crear un conjunto de datos de entrenamiento
trainX contiene valores entre -1 y 1, y trainY contiene 3 veces el valor de trainX más alguna variable aleatoria:
import tensorflow as tf import numpy as np trainX = np.linspace(-1, 1, 101) trainY = 3 * trainX + np.random.randn(*trainX.shape) * 0.33
2.2. Marcadores de posición
X = tf.placeholder("float") Y = tf.placeholder("float")
2.3. Modelado
El modelo de regresión lineal tiene la forma
- debemos calcular el valor de w. Inicialicemos w a cero y creemos un modelo para resolver este problema. Definimos la función de costo como
(Modelo Y-y__) ^ 2
TensorFlow viene con muchos optimizadores que calculan y actualizan los gradientes después de cada iteración, tratando de minimizar la función de costo especificada. Vamos a definir una operación de aprendizaje usando GradientDescentOptimizer para minimizar nuestra función de costo a una velocidad de aprendizaje de 0.01. Luego ejecutamos esta operación de aprendizaje en un bucle.
w = tf.Variable(0.0, name="weights") y_model = tf.multiply(X, w) cost = (tf.pow(Y-y_model, 2)) train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cost)
2.4. Entrenamiento
Hasta este punto, solo hemos definido un gráfico. No se han producido cálculos, ninguna de las variables TensorFlow importa. Para ejecutar este gráfico, necesitamos crear una sesión y ejecutarla. Antes de eso, necesitamos crear una operación de inicialización para todas las variables:
init = tf.initialize_all_variables() with tf.Session() as sess: sess.run(init) for i in range(100): for (x, y) in zip(trainX, trainY): sess.run(train_op, feed_dict={X: x, Y: y}) print(sess.run(w))
Tenga en cuenta que lo primero que se hizo fue inicializar las variables llamando a init dentro de session.run () . Más tarde ejecutamos train_op , alimentando su feed_dict . Finalmente, imprimimos el valor de w (nuevamente dentro de sess.run ()), que debería ser alrededor de 3.
Ejercicio:
Si crea una nueva sesión después de este código e intenta imprimir w, ¿qué se generará?
with tf.Session() as sess: sess.run(init) print(sess.run(w))
Sí, entendiste correctamente, se mostrará 0.0. Tan pronto como dejamos la sesión creada anteriormente, todas las operaciones dejan de existir.
Espero que este tutorial le brinde un comienzo rápido con TensorFlow. No dude en hacer sus preguntas en los comentarios. El código completo se puede descargar aquí .