¿Qué hay de nuevo en Tensorflow 2.0?

En este artículo, profundizaremos en los principales cambios realizados en un salto de Tensorflow 1.x a 2.0, desde ampliar la variedad de soporte del sistema y nuevos servicios hasta modelos personalizados y ciclos de capacitación.

Introducción

Si es un ingeniero de aprendizaje automático, un científico de datos o un aficionado que desarrolla modelos de aprendizaje automático de vez en cuando solo por diversión, es muy probable que esté familiarizado con Tensorflow.

Tensorflow es un marco de código abierto y gratuito desarrollado por Google Brain Team escrito en Python, C++ y CUDA. Se utiliza para desarrollar, probar e implementar modelos de Machine Learning.

Inicialmente, Tensoflow no tenía soporte completo para múltiples plataformas y lenguajes de programación, y no era muy rápido y eficiente para entrenar modelos de aprendizaje automático, pero con el tiempo y después de algunas actualizaciones, Tensorflow ahora se considera un marco de referencia para desarrollar , entrenar e implementar modelos de aprendizaje automático.

Tensorflow 1.x

Tensorflow 1.x también fue un gran salto para este marco. Introdujo muchas características nuevas, rendimiento mejorado y contribuciones de código abierto. Introdujo una API de alto nivel para TensorFlow, lo que facilitó mucho la creación de prototipos en muy poco tiempo.

Se hizo compatible con Keras. Pero lo más importante que irritó a los desarrolladores fue que no tenían ganas de aprovechar la simplicidad de Python al usar TensorFlow.

En TensorFlow, cada modelo se representa como un gráfico y los nodos representan los cálculos en el gráfico. Es un ejemplo de "Programación simbólica" y mientras que Python es una ["Programación imperativa"](https://en.wikipedia. org/wiki/Imperative_programming#:~:text=In%20computer%20science,%20imperative%20programming,for%20the%20computer%20to%20perform) Language.

No voy a entrar en muchos detalles ya que esto está más allá del alcance de este artículo. Pero el punto aquí es que con el lanzamiento de PyTorch (que está muy orientado hacia la programación imperativa y aprovecha el comportamiento dinámico de Python), los novatos y los científicos investigadores encontraron que PyTorch era más fácil de entender y aprender que Tensorflow y PyTorch comenzó en muy poco tiempo. para ganar popularidad.

Todos los desarrolladores de Tensorflow exigían lo mismo de Tensorflow y Google Brain Team. Además, TensorFlow 1.x pasó por mucho desarrollo que resultó en muchas API, es decir, tf.layers, tf.contrib.layers, tf.keras y los desarrolladores tenían muchas opciones para elegir, lo que resultó en conflictos.

Anuncio de Tensorflow 2.0

Era bastante obvio que el equipo de Tensorflow tenía que abordar estos problemas, por lo que anunciaron Tensorflow 2.0.

Este fue un gran paso porque para abordar todos los problemas tuvieron que hacer grandes cambios. Muchas personas se enfrentaron a otra experiencia de aprendizaje, pero las mejoras hicieron que valiera la pena volver a aprender.

En la fase de entrenamiento, nos presentan tf.data y Datasets, que nos permiten importar y procesar datos con facilidad. Luego, se nos presenta el entrenamiento distribuido en varias CPU, GPU y TPU. Para la serialización, podemos usar SavedModel para implementar en TensorFlow Hub o servicios como TensorFlow Serving, TensorFlow Lite o TensorFlow.JS:

tensorflow 2.0 architecture

[Crédito: blog.tensorflow.org]{.pequeño}

Novedades de Tensorflow 2.0

Aquí hay una breve descripción de las actualizaciones más importantes que vinieron con Tensorflow 2.

1. Implementación de modelos en múltiples plataformas {#1implementación de modelos en múltiples plataformas}

Tensorflow siempre fue muy adecuado para la producción, pero Tensorflow 2 mejoró la compatibilidad y la paridad en múltiples plataformas.

Introdujo el soporte de la nueva plataforma para el formato SavedModel que nos permite guardar modelos de Tensorflow. La novedad aquí es que puede implementar su modelo guardado en cualquier plataforma, es decir, en dispositivos móviles o IoT usando [Tensorflow Lite] (https://www.tensorflow.org/lite) o Node.js con [Tensorflow.js] (https://www.tensorflow.org/js). Alternativamente, puede usar en entornos de producción con [Servicio Tensorflow] (https://www.tensorflow.org/tfx/guide/serving).

Echemos un vistazo a cómo puede guardar un modelo compilado:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import os
import tensorflow as tf
# Building the Model
model = tf.keras.Sequential([
        tf.keras.layers.Dense(5,actiavtion='relu',input_shape=(16,)),
        tf.keras.layers.Dense(1,activation='sigmoid')])
# Compiling the Model
model.compile(loss='binary_crossentropy',optimizer='adam')

# Saving the Model
save_path = path + "/version_number/"
save_path = os.path.join
tf.saved_model.save(model, save_path)

Y ahí tienes Ahora puede implementarlo usando cualquiera de los servicios antes mencionados.

2. Ejecución ansiosa {#2ejecución ansiosa}

Antes de Tensorflow 2, tenía que crear una sesión para ejecutar su modelo. De hecho, si deseaba imprimir el valor de una variable solo para la depuración, primero tenía que crear una sesión y luego escribir una declaración de impresión dentro de esa sesión.

Tenía que crear marcadores de posición lentos e inútiles para alimentar los datos de entrada al modelo. Básicamente, en Tensorflow 1.x, primero construiría el gráfico completo y luego lo ejecutaría, en lugar de construirlo mientras se ejecuta.

Esto se sentía estático y torpe, especialmente en comparación con PyTorch, que permitía a los usuarios crear gráficos dinámicos durante la ejecución.

Afortunadamente, esto se renovó en Tensorflow 2.0, lo que nos introdujo a la ejecución ansiosa. Echemos un vistazo a cómo habríamos construido un gráfico en Tensorflow 1.x frente a 2.0:

1
2
3
4
5
6
7
8
import tensorflow as tf

"""Creating the Graph"""
# Tensorflow 1.x
# Defining two Tensorflow variables
a = tf.Variable(4)
b = tf.Variable(5)
result = tf.multiply(a,b)

Ahora, para acceder a la variable resultado, tendremos que ejecutar la gráfica en una sesión:

1
2
3
4
5
# Creating a session
with tf.Session() as sess:
    # Initializing all the Variables
    sess.run(tf.global_variables_initializer())
    print(sess.run(result))

Ahora, en lugar de eso, podemos acceder directamente a ellos:

1
2
3
4
5
6
7
import tensorflow as tf

# Tensorflow 2.0
a = tf.Variable(4)
b = tf.Variable(5)
# No need to create a session
print(float(a*b))

3. Integración de Keras con Tensorflow

Keras es una API de red neuronal y aprendizaje profundo construida sobre Tensorflow.

La mayoría de las personas comienzan con Keras antes de pasar a Tensorflow o PyTorch. Fue diseñado para la experimentación rápida con redes neuronales profundas y, por lo tanto, es más simple.

Antes de Tensorflow 2.0, la biblioteca lo admitía, pero no estaba integrado. Ahora, es oficialmente una API de alto nivel. No es necesario instalarlo explícitamente, viene con Tensorflow y ahora se puede acceder a través de tf.keras.

En consecuencia, esto da como resultado una limpieza de la API y la eliminación de tf.contrib.layers tf.layers, etc. tf.keras es la API de acceso ahora. Tanto tf.contrib.layers como tf.layers estaban haciendo lo mismo. Y con tf.keras, habría triple redundancia ya que contiene el módulo tf.keras.layers.

El equipo también proporcionó una guía para actualizar su código de Tensorflow 1.x a Tensorflow 2.0, ya que muchos de los paquetes más antiguos ahora están obsoletos.

4. tf.function Decorador

Esta es también una de las características más emocionantes de Tensorflow 2. El decorador @tf.función permite que sus funciones de Python se conviertan automáticamente en Tensorflow Graphs .

Todavía puede tener todas las ventajas de la ejecución basada en gráficos y deshacerse de la pesada programación basada en sesiones. Aplicando el decorador @tf.function a una función como:

1
2
3
4
5
@tf.function
def multiply(a, b):
  return a * b

multiply(tf.ones([2, 2]), tf.ones([2, 2]))

En caso de que te lo estés preguntando, esto se complementa automáticamente con Autograph. Genera un gráfico que tiene exactamente los mismos efectos que la función que hemos decorado.

5. Capacitación usando computación distribuida

Tensorflow 2.0 viene con un rendimiento mejorado para entrenar con GPU. Según el equipo, esta versión es 3 veces más rápida que Tensorflow 1.x.

Y a partir de ahora, Tensorflow también puede funcionar con TPU. De hecho, puede trabajar con múltiples TPU y GPU en un enfoque de computación distribuida.

Puedes leer más sobre esto en la guía oficial.

6. tf.data y conjuntos de datos

Con tf.datos, ahora es muy fácil crear canalizaciones de datos personalizadas. No es necesario usar feed_dict. tf.data tiene soporte para muchos tipos de formatos de entrada, es decir, texto, imágenes, video, series de tiempo y mucho más.

Proporciona tuberías de entrada muy limpias y eficientes. Por ejemplo, digamos que queremos importar un archivo de texto con algunas palabras que serán preprocesadas y utilizadas en un modelo. Hagamos un preprocesamiento clásico para la mayoría de los problemas de PNL.

Primero leamos el archivo, pongamos todas las palabras en minúsculas y dividámoslas en una lista:

1
2
3
4
5
6
7
8
import numpy as np

text_file = "file.txt"

text = open(text_file,'r').read()

text = text.lower()
text = text.split()

Luego, querremos eliminar todas las palabras duplicadas. Esto se hace fácilmente empaquetándolos en un ‘Conjunto’, convirtiéndolo en una ‘Lista’ y clasificándolo:

1
words = sorted(list(set(text)))

Ahora que hemos clasificado las palabras únicas, haremos un vocabulario con ellas. Cada palabra tendrá asignado un identificador de dígito único:

1
2
vocab_to_int = {word:index for index, word in enumerate(words)}
int_to_vocab = np.array(words)

Ahora, para convertir nuestra matriz de números enteros que representan palabras en un conjunto de datos de Tensorflow, usaremos la función from_tensor_slices() proporcionada por tf.data.Dataset:

1
words_dataset = tf.data.Dataset.from_tensor_slices(words_as_int)

Ahora, podemos realizar operaciones en este conjunto de datos, como agruparlos en secuencias más pequeñas:

1
2
seq_len = 50
sequences = words_dataset.batch(seq_len+1,drop_remainder=True)

Ahora, cuando entrenamos, podemos obtener fácilmente lotes del objeto Dataset:

1
for (batch_n,inp) in enumerate(dataset):

Alternativamente, puede cargar directamente conjuntos de datos ya existentes en objetos Conjunto de datos:

1
2
3
4
import tensorflow_datasets as tfds

mnist_data = tfds.load("mnist")
mnist_train, mnist_test = mnist_data["train"], mnist_data["test"]

7. tf.keras.modelo

Una novedad querida es la definición de sus propios modelos personalizados mediante la creación de subclases de la clase keras.Model.

Tomando una pista de PyTorch, que permite a los desarrolladores crear modelos usando clases personalizadas (personalizando las clases que forman una “Capa” y, por lo tanto, alterando la estructura del modelo), Tensorflow 2.0, a través de Keras, también nos permite definir modelos personalizados. .

Vamos a crear un modelo ‘secuencial’, como si usaras Tensorflow 1:

1
2
3
4
5
6
7
8
# Creating a Model
model = tf.keras.Sequential([
tf.keras.layers.Dense(512,activation='relu',input_shape=(784,)),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(512,activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10,activation='softmax')
])

Ahora, en lugar de usar el modelo Sequential, creemos nuestro propio modelo subclasificando la clase keras.Model:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
# Creating a Model
class mnist_model(tf.keras.Model):
    def __init__(self):
        super(mnist_model,self).__init__()
        self.dense1 = tf.keras.layers.Dense(512)
        self.drop1 = tf.keras.layers.Dropout(0.2)
        self.dense2 = tf.keras.layers.Dense(512)
        self.drop2 = tf.keras.layers.Dropout(0.2)
        self.dense3 = tf.keras.layers.Dense(10)

    def call(self,x):
        x = tf.nn.relu(self.dense1(x))
        x = self.drop1(x)
        x = tf.nn.relu(self.dense2(x))
        x = self.drop2(x)
        x = tf.nn.softmax(self.dense3(x))
        return x

Hemos creado efectivamente el mismo modelo aquí, aunque este enfoque nos permite personalizar completamente y crear modelos según nuestras necesidades.

8. tf.GradientTape

tf.GradientTape le permite calcular gradientes automáticamente. Esto es útil cuando se usan bucles de entrenamiento personalizados.

Puede entrenar su modelo usando bucles de entrenamiento personalizados en lugar de llamar a model.fit. Le da más control sobre el proceso de entrenamiento si desea modificarlo.

Emparejar bucles de entrenamiento personalizados disponibles por tf.GradientTape con modelos personalizados disponibles por keras.Model le da control sobre modelos y entrenamiento que nunca antes había tenido.

Estos rápidamente se convirtieron en características muy queridas en la comunidad. Así es como puede crear un modelo personalizado con funciones decoradas y un ciclo de entrenamiento personalizado:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
"""Note: We'll be using the model created in the previous section."""
# Creating the model
model = mnist_model()
# Defining the optimizer and the loss
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
loss_object = tf.keras.losses.CategoricalCrossentropy(from_logits=False)

@tf.function
def  step(model,x,y):
    """
    model: in this case the mnist_model
    x: input data in batches
    y: True labels """
    # Use GradientTape to monitor trainable variables
    with tf.GradientTape() as tape:
        # Computing predictions
        predictions = model(x)
        # Calculating Loss
        loss = loss_object(y,predictions)
    # Extracting all the trainable variables
    trainable_variables = model.trainable_variables()

    # Computing derivative of loss w.r.t variables/weights
    gradients = tape.gradient(loss,trainable_variables)
    # Updating the weights
    optimizer.apply_gradients(zip(gradients,trainable_variables))

    return loss

Ahora puede simplemente llamar a la función step() pasando el modelo y los datos de entrenamiento en lotes usando un bucle.

Conclusión

Con la llegada de Tensorflow 2.0, se han revisado muchos contratiempos. Desde ampliar la variedad de soporte del sistema y nuevos servicios hasta modelos personalizados y ciclos de capacitación, Tensorflow 2.0 también ha introducido una nueva experiencia de aprendizaje para profesionales veteranos. ranos.