Autoencoders

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()

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)