Autoencoders

🔬 ¿Qué es un Autoencoder?

Un autoencoder es una red neuronal que aprende a copiar su entrada en su salida — pero pasando por un cuello de botella que la obliga a aprender una representación comprimida de los datos. Parece trivial, pero ese cuello de botella es lo que lo hace poderoso.

El autoencoder fue introducido por Rumelhart, Hinton y Williams en 1986 como parte de su trabajo seminal sobre backpropagation. La idea original era utilizar una red con un cuello de botella para aprender representaciones internas útiles de los datos de forma no supervisada — sin necesitar etiquetas. Aunque puede parecer una tarea trivial («copiar la entrada»), el bottleneck obliga a la red a descubrir la estructura latente de los datos: patrones, correlaciones y factores de variación que definen la distribución subyacente.

Esta idea resultó ser extraordinariamente influyente. Hoy, los autoencoders y sus variantes son la base conceptual de modelos como Stable Diffusion (que opera en el espacio latente de un autoencoder), DALL-E (que usa VQ-VAE para tokenizar imágenes), y numerosas aplicaciones en detección de anomalías, compresión aprendida y drug discovery.

📉 Función de Pérdida: Reconstrucción

El autoencoder se entrena minimizando la pérdida de reconstrucción: la diferencia entre la entrada \( x \) y la salida \( \hat{x} \). Las dos opciones más comunes:

📐 Undercomplete vs Overcomplete

La relación entre la dimensión de entrada \( n \) y la dimensión latente \( d \) define el tipo de autoencoder:

🔗 Conexión con PCA

Si usamos un autoencoder lineal (sin funciones de activación) con loss MSE, la solución óptima es exactamente PCA (Principal Component Analysis):

🌌 El Espacio Latente: el corazón del autoencoder

El espacio latente es la representación de baja dimensión que el autoencoder aprende internamente. Es el punto donde la red ha destilado la información esencial, descartando redundancia y ruido.

⏳ El Bottleneck y la Hipótesis del Manifold

La hipótesis del manifold dice que los datos reales de alta dimensión viven en un subespacio (manifold) de dimensión mucho menor. El autoencoder aprende este manifold:

La hipótesis del manifold es uno de los supuestos más importantes en deep learning. Proporciona la justificación teórica de por qué las redes neuronales profundas pueden funcionar tan bien con datos de alta dimensión: si los datos realmente viven en un manifold de dimensión mucho menor, la tarea de la red no es «entender» todas las \( 2^{784} \) posibles configuraciones de píxeles, sino solo el pequeño subconjunto que corresponde a imágenes válidas.

🗺️ Visualización del Espacio Latente

Cuando \( d = 2 \), podemos visualizar directamente el espacio latente como un scatter plot. Para \( d > 2 \), usamos técnicas como t-SNE o UMAP para proyectar a 2D.

🔄 Interpolación en el Espacio Latente

Una propiedad fascinante: si tomamos dos puntos \( z_A \) y \( z_B \) en el espacio latente y generamos puntos intermedios, el decoder produce transiciones suaves entre las imágenes correspondientes:

Esta interpolación es clave: demuestra que el espacio latente es continuo y tiene estructura semántica. Es el fundamento de la generación de contenido nuevo.

🧪 Explorador interactivo: Espacio Latente 2D

Experimenta con un espacio latente bidimensional simulado. Mueve el punto en el espacio latente y observa cómo cambia la «reconstrucción»:

🗂️ Tipos de Autoencoders

El autoencoder «vanilla» es solo el punto de partida. Existen variantes que añaden regularización o estructura para mejorar las representaciones aprendidas. Aquí están las más importantes:

🧹 Denoising Autoencoder (DAE)

Idea: Corrompe la entrada con ruido y entrena al autoencoder a reconstruir la versión limpia. Esto fuerza a la red a aprender la estructura real de los datos, no artefactos del ruido.

✨ Sparse Autoencoder

Idea: Permite un espacio latente overcomplete (\( d \geq n \)), pero añade una penalización de sparsity para que solo unas pocas neuronas estén activas a la vez. Cada entrada activa un subconjunto diferente de neuronas.

Donde \( \hat{\rho}_j \) es la activación media de la neurona \( j \) y \( \rho \) es el nivel de sparsity objetivo (típicamente \( \rho = 0.05 \), es decir, solo el 5% de las neuronas activas).

📏 Contractive Autoencoder (CAE)

Idea: Añade una penalización sobre el jacobiano del encoder, forzando a que la representación latente sea insensible a pequeñas perturbaciones en la entrada:

La norma de Frobenius del jacobiano mide cuánto cambia \( z \) cuando \( x \) cambia un poco. Minimizarla hace que el encoder sea «suave» — resistente a variaciones irrelevantes.

🔲 Autoencoder Convolucional

Para imágenes, usar capas densas es ineficiente. Los autoencoders convolucionales usan Conv2D en el encoder y ConvTranspose2D (o upsampling) en el decoder:

import torch
import torch.nn as nn

class ConvAutoencoder(nn.Module):
    def __init__(self, latent_dim=32):
        super().__init__()
        # Encoder: 1x28x28 → 32x7x7 → latent
        self.encoder = nn.Sequential(
            nn.Conv2d(1, 16, 3, stride=2, padding=1),  # 16x14x14
            nn.BatchNorm2d(16), nn.ReLU(),
            nn.Conv2d(16, 32, 3, stride=2, padding=1), # 32x7x7
            nn.BatchNorm2d(32), nn.ReLU(),
            nn.Flatten(),
            nn.Linear(32*7*7, latent_dim)
        )
        # Decoder: latent → 32x7x7 → 1x28x28
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 32*7*7),
            nn.Unflatten(1, (32, 7, 7)),
            nn.ConvTranspose2d(32, 16, 3, stride=2, padding=1, output_padding=1),
            nn.BatchNorm2d(16), nn.ReLU(),
            nn.ConvTranspose2d(16, 1, 3, stride=2, padding=1, output_padding=1),
            nn.Sigmoid()
        )

    def forward(self, x):
        z = self.encoder(x)
        return self.decoder(z), z

model = ConvAutoencoder(latent_dim=16)
print(f"Parámetros: {sum(p.numel() for p in model.parameters()):,}")
# Loss: nn.MSELoss() o nn.BCELoss()

import tensorflow as tf
from tensorflow.keras import layers, Model

def build_conv_autoencoder(latent_dim=32):
    # Encoder
    encoder_input = layers.Input(shape=(28, 28, 1))
    x = layers.Conv2D(16, 3, strides=2, padding='same', activation='relu')(encoder_input)
    x = layers.BatchNormalization()(x)
    x = layers.Conv2D(32, 3, strides=2, padding='same', activation='relu')(x)
    x = layers.BatchNormalization()(x)
    x = layers.Flatten()(x)
    z = layers.Dense(latent_dim, name='latent')(x)
    encoder = Model(encoder_input, z, name='encoder')

    # Decoder
    decoder_input = layers.Input(shape=(latent_dim,))
    x = layers.Dense(7 * 7 * 32, activation='relu')(decoder_input)
    x = layers.Reshape((7, 7, 32))(x)
    x = layers.Conv2DTranspose(16, 3, strides=2, padding='same', activation='relu')(x)
    x = layers.BatchNormalization()(x)
    x = layers.Conv2DTranspose(1, 3, strides=2, padding='same', activation='sigmoid')(x)
    decoder = Model(decoder_input, x, name='decoder')

    # Full autoencoder
    ae_output = decoder(encoder(encoder_input))
    autoencoder = Model(encoder_input, ae_output, name='autoencoder')
    autoencoder.compile(optimizer='adam', loss='mse')
    return autoencoder, encoder, decoder

ae, enc, dec = build_conv_autoencoder(latent_dim=16)
ae.summary()

📋 Resumen comparativo

🌟 VAE: de reconstruir a generar

El autoencoder estándar aprende a reconstruir, pero no a generar. ¿Por qué? Porque su espacio latente no tiene estructura probabilística: los puntos se distribuyen de forma irregular, con «huecos» donde el decoder no sabe qué producir.

La diferencia visual es clara: el espacio latente del AE estándar tiene «agujeros» — regiones donde ningún dato del entrenamiento fue codificado, y por lo tanto el decoder no tiene información sobre qué producir. El VAE, al forzar que todo el espacio latente se parezca a una gaussiana estándar, garantiza que cualquier punto muestreado producirá una salida coherente. Este es el salto conceptual que convierte a un autoencoder en un modelo generativo.

📐 Formulación Probabilística del VAE

El VAE (Kingma & Welling, 2013) reformula el autoencoder como un modelo generativo probabilístico. En lugar de aprender una función determinista encoder-decoder, el VAE aprende una distribución sobre el espacio latente. Esta reformulación, que se apoya en la inferencia variacional — una de las técnicas más potentes del ML bayesiano — es lo que permite al VAE generar muestras nuevas de forma principled.

El marco conceptual tiene cuatro elementos:

📊 ELBO: la función objetivo del VAE

El objetivo del VAE es maximizar la Evidence Lower BOund (ELBO), que es una cota inferior de la log-verosimilitud de los datos:

En la práctica, la loss del VAE es:

🔧 Reparameterization Trick

El problema: En el forward pass, necesitamos muestrear \( z \sim q_\phi(z|x) = \mathcal{N}(\mu, \sigma^2) \). Pero el muestreo es una operación no diferenciable — no podemos hacer backpropagation a través de él.

La solución: Reparametrizar el muestreo separando la parte estocástica:

🎨 Generación con VAE

Una vez entrenado, generar nuevas muestras es trivial:

🧪 Explorador interactivo: VAE

Experimenta con los parámetros de un VAE y observa el trade-off entre reconstrucción y regularización:

🎛️ β-VAE: Representaciones Disentangled

Higgins et al. (2017) propusieron una modificación simple pero poderosa: multiplicar el término KL por un factor \( \beta \). Aunque parezca un cambio trivial, tiene implicaciones profundas sobre la estructura del espacio latente y la calidad de las representaciones aprendidas.

🏷️ Conditional VAE (CVAE)

El CVAE (Sohn et al., 2015) condiciona tanto el encoder como el decoder en una etiqueta \( y \) (clase, atributo, texto...). Esta extensión es fundamental: permite pasar de generar al azar a generar con control, una capacidad esencial en aplicaciones reales.

Esto permite generar con control: «genera un dígito 7» o «genera una cara con gafas».

🧊 VQ-VAE: Cuantización Vectorial

Van den Oord et al. (2017) propusieron el VQ-VAE, que usa un espacio latente discreto en lugar de continuo. Esta idea rompe con la tradición de los VAE gaussianos y abre la puerta a combinar autoencoders con modelos autoregresivos como Transformers. El codebook de embeddings actúa como un diccionario aprendido de «palabras visuales».

Donde \( \text{sg}[\cdot] \) es «stop gradient». Los tres términos son: reconstrucción, commitment loss (acercar encoder a embeddings), y codebook loss (acercar embeddings a encoder).

💻 Implementación completa: VAE

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

class VAE(nn.Module):
    def __init__(self, input_dim=784, hidden_dim=400, latent_dim=20):
        super().__init__()
        # Encoder
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.fc_mu = nn.Linear(hidden_dim, latent_dim)
        self.fc_logvar = nn.Linear(hidden_dim, latent_dim)
        # Decoder
        self.fc3 = nn.Linear(latent_dim, hidden_dim)
        self.fc4 = nn.Linear(hidden_dim, input_dim)

    def encode(self, x):
        h = F.relu(self.fc1(x))
        return self.fc_mu(h), self.fc_logvar(h)

    def reparameterize(self, mu, logvar):
        """El famoso reparameterization trick"""
        std = torch.exp(0.5 * logvar)  # σ = exp(logσ²/2)
        eps = torch.randn_like(std)     # ε ~ N(0, I)
        return mu + std * eps           # z = μ + σ·ε

    def decode(self, z):
        h = F.relu(self.fc3(z))
        return torch.sigmoid(self.fc4(h))

    def forward(self, x):
        mu, logvar = self.encode(x.view(-1, 784))
        z = self.reparameterize(mu, logvar)
        return self.decode(z), mu, logvar

def vae_loss(x_recon, x, mu, logvar):
    """ELBO loss = reconstrucción + KL"""
    # Reconstrucción (BCE porque sigmoid en decoder)
    recon = F.binary_cross_entropy(x_recon, x.view(-1, 784), reduction='sum')
    # KL divergence con N(0,I) — fórmula cerrada
    kl = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
    return recon + kl

# Entrenamiento
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = VAE(latent_dim=20).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

train_loader = DataLoader(
    datasets.MNIST('./data', train=True, download=True,
                   transform=transforms.ToTensor()),
    batch_size=128, shuffle=True
)

for epoch in range(10):
    model.train()
    total_loss = 0
    for x, _ in train_loader:
        x = x.to(device)
        x_recon, mu, logvar = model(x)
        loss = vae_loss(x_recon, x, mu, logvar)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch {epoch+1}, Loss: {total_loss/len(train_loader.dataset):.2f}")

# Generar nuevas muestras
model.eval()
with torch.no_grad():
    z = torch.randn(16, 20).to(device)  # Muestrear de N(0,I)
    samples = model.decode(z)            # Decodificar
    # samples tiene forma (16, 784) → reshape a (16, 1, 28, 28)

import tensorflow as tf
from tensorflow.keras import layers, Model
import numpy as np

class Sampling(layers.Layer):
    """Reparameterization trick como capa de Keras"""
    def call(self, inputs):
        mu, log_var = inputs
        eps = tf.random.normal(shape=tf.shape(mu))
        return mu + tf.exp(0.5 * log_var) * eps

class VAE(Model):
    def __init__(self, latent_dim=20, **kwargs):
        super().__init__(**kwargs)
        self.latent_dim = latent_dim

        # Encoder
        self.encoder_dense = layers.Dense(400, activation='relu')
        self.mu_layer = layers.Dense(latent_dim)
        self.logvar_layer = layers.Dense(latent_dim)
        self.sampling = Sampling()

        # Decoder
        self.decoder_dense1 = layers.Dense(400, activation='relu')
        self.decoder_out = layers.Dense(784, activation='sigmoid')

    def encode(self, x):
        h = self.encoder_dense(x)
        return self.mu_layer(h), self.logvar_layer(h)

    def decode(self, z):
        h = self.decoder_dense1(z)
        return self.decoder_out(h)

    def call(self, x):
        x_flat = tf.reshape(x, [-1, 784])
        mu, logvar = self.encode(x_flat)
        z = self.sampling([mu, logvar])
        x_recon = self.decode(z)

        # Añadir KL loss
        kl_loss = -0.5 * tf.reduce_sum(
            1 + logvar - tf.square(mu) - tf.exp(logvar), axis=1
        )
        self.add_loss(tf.reduce_mean(kl_loss))
        return x_recon

# Entrenamiento
(x_train, _), _ = tf.keras.datasets.mnist.load_data()
x_train = x_train.astype('float32') / 255.0

vae = VAE(latent_dim=20)
vae.compile(optimizer='adam', loss='binary_crossentropy')
vae.fit(x_train.reshape(-1, 784), x_train.reshape(-1, 784),
        epochs=10, batch_size=128, validation_split=0.1)

# Generar
z_sample = np.random.normal(size=(16, 20)).astype('float32')
generated = vae.decode(z_sample).numpy().reshape(-1, 28, 28)

🌍 Aplicaciones de los Autoencoders

🧪 Widget: Detector de anomalías con AE

Simula cómo un autoencoder detecta anomalías basándose en el error de reconstrucción:

🌐 Los Autoencoders en el Ecosistema Generativo

Los autoencoders no son un modelo aislado — son el fundamento conceptual de gran parte de la IA generativa moderna:

🏛️ El Legado de los Autoencoders