ML | Codificador automático con TensorFlow 2.0

Este tutorial demuestra cómo generar imágenes de dígitos escritos a mano mediante la ejecución en modo gráfico en TensorFlow 2.0 entrenando un codificador automático. 
Un AutoEncoder es un algoritmo de compresión y descompresión de datos implementado con Redes Neuronales y/o Redes Neuronales Convolucionales . los datos se comprimen en un cuello de botella que es de una dimensión más baja que la entrada inicial. La descompresión utiliza la representación intermedia para generar de nuevo la misma imagen de entrada. Codifiquemos un buen AutoEncoder utilizando TensorFlow 2.0, que por defecto está ansioso por comprender el mecanismo de este algoritmo. Los codificadores automáticos se consideran un buen requisito previo para modelos generativos más avanzados, como GAN y CVAE. 
En primer lugar, descargue TensorFlow 2.0 según el hardware disponible. Si está utilizando Google Colab, siga este IPython Notebook o esta demostración de colab . Asegúrese de que las versiones adecuadas de CUDA y CUDNN estén disponibles para instalaciones de GPU. Visite las instrucciones de descarga oficiales en la página de TensorFlow aquí . 
Código: Importación de bibliotecas 
 

# Install TensorFlow 2.0 by using the following command
# For CPU installation
# pip install -q tensorflow == 2.0
# For GPU installation (CUDA and CuDNN must be available)
# pip install -q tensorflow-gpu == 2.0
 
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
 
 
import tensorflow as tf
print(tf.__version__)

Después de confirmar la descarga de TF adecuada, importe las otras dependencias para el aumento de datos y defina funciones personalizadas como se muestra a continuación. El escalador estándar escala los datos transformando las columnas. La función get_random_block_from_data es útil cuando se usa tf.GradientTape para realizar AutoDiff (Diferenciación automática) para obtener los gradientes.
 

import numpy as np
import sklearn.preprocessing as prep
import tensorflow.keras.layers as layers
 
def standard_scale(X_train, X_test):
    preprocessor = prep.StandardScaler().fit(X_train)
    X_train = preprocessor.transform(X_train)
    X_test = preprocessor.transform(X_test)
    return X_train, X_test
 
def get_random_block_from_data(data, batch_size):
    start_index = np.random.randint(0, len(data) - batch_size)
    return data[start_index:(start_index + batch_size)]

Los codificadores automáticos pueden tener una representación intermedia con pérdida, también conocida como representación comprimida. Esta reducción de la dimensionalidad es útil en una multitud de casos de uso en los que existe una compresión de datos de imágenes sin pérdidas. Por lo tanto, podemos decir que la parte del codificador del AutoEncoder codifica una representación densa de los datos. Aquí usaremos la API de subclases de TensorFlow para definir capas personalizadas para el codificador y el decodificador.
 

class Encoder(tf.keras.layers.Layer):
    '''Encodes a digit from the MNIST dataset'''
     
    def __init__(self,
                n_dims,
                name ='encoder',
                **kwargs):
        super(Encoder, self).__init__(name = name, **kwargs)
        self.n_dims = n_dims
        self.n_layers = 1
        self.encode_layer = layers.Dense(n_dims, activation ='relu')
         
    @tf.function       
    def call(self, inputs):
        return self.encode_layer(inputs)
 
class Decoder(tf.keras.layers.Layer):
    '''Decodes a digit from the MNIST dataset'''
 
    def __init__(self,
                n_dims,
                name ='decoder',
                **kwargs):
        super(Decoder, self).__init__(name = name, **kwargs)
        self.n_dims = n_dims
        self.n_layers = len(n_dims)
        self.decode_middle = layers.Dense(n_dims[0], activation ='relu')
        self.recon_layer = layers.Dense(n_dims[1], activation ='sigmoid')
         
    @tf.function       
    def call(self, inputs):
        x = self.decode_middle(inputs)
        return self.recon_layer(x)

Luego extendemos tf.keras.Model para definir un modelo personalizado que utiliza nuestras capas personalizadas previamente definidas para formar el modelo AutoEncoder. La función de llamada se anula, que es el pase hacia adelante cuando los datos están disponibles para el objeto modelo. Observe el decorador de función @tf.function . Asegura que la ejecución de la función ocurra en un gráfico lo que acelera nuestra ejecución.
 

class Autoencoder(tf.keras.Model):
    '''Vanilla Autoencoder for MNIST digits'''
     
    def __init__(self,
                 n_dims =[200, 392, 784],
                 name ='autoencoder',
                 **kwargs):
        super(Autoencoder, self).__init__(name = name, **kwargs)
        self.n_dims = n_dims
        self.encoder = Encoder(n_dims[0])
        self.decoder = Decoder([n_dims[1], n_dims[2]])
         
    @tf.function       
    def call(self, inputs):
        x = self.encoder(inputs)
        return self.decoder(x)

El siguiente bloque de código prepara el conjunto de datos y los prepara para introducirlos en la canalización de funciones de preprocesamiento antes de entrenar el AutoEncoder.
 

mnist = tf.keras.datasets.mnist
 
(X_train, _), (X_test, _) = mnist.load_data()
X_train = tf.cast(np.reshape(
        X_train, (X_train.shape[0],
                  X_train.shape[1] * X_train.shape[2])), tf.float64)
X_test = tf.cast(
        np.reshape(X_test,
                   (X_test.shape[0],
                    X_test.shape[1] * X_test.shape[2])), tf.float64)
 
X_train, X_test = standard_scale(X_train, X_test)

Es una buena práctica de TensorFlow usar tf.data.Dataset para obtener rápidamente cortes de tensor con un lote barajado del conjunto de datos para el entrenamiento. El siguiente bloque de código demuestra el uso de tf.data y también define los hiperparámetros para entrenar el modelo AutoEncoder.
 

train_data = tf.data.Dataset.from_tensor_slices(
        X_train).batch(128).shuffle(buffer_size = 1024)
test_data = tf.data.Dataset.from_tensor_slices(
        X_test).batch(128).shuffle(buffer_size = 512)
 
n_samples = int(len(X_train) + len(X_test))
training_epochs = 20
batch_size = 128
display_step = 1
 
optimizer = tf.optimizers.Adam(learning_rate = 0.01)
mse_loss = tf.keras.losses.MeanSquaredError()
loss_metric = tf.keras.metrics.Mean()

¡Hemos completado todos los requisitos previos para entrenar nuestro modelo AutoEncoder! Todo lo que nos queda por hacer es definir un objeto AutoEncoder y compilar el modelo con el optimizador y la pérdida antes de llamar a model.train para los hiperparámetros definidos anteriormente. ¡Voila! ¡Puede ver la reducción de pérdidas y el AutoEncoder mejorando su rendimiento!
 

ae = Autoencoder([200, 392, 784])
ae.compile(optimizer = tf.optimizers.Adam(0.01),
           loss ='categorical_crossentropy')
ae.fit(X_train, X_train, batch_size = 64, epochs = 5)

Puede consultar el IPython Notebook aquí y una demostración de colaboración que envié a TensorFlow aquí . Sígueme en GitHub .