Tarea 6: Autoencoder para extraer características

Información de la Tarea

• Estudiante: Andrés Cruz Chipol
• Curso: Aprendizaje Profundo
• Fecha de entrega: Martes 11 de Agosto, 2026

Descripción de la Tarea

• Autoencoder para extraer características para un clasificador.
• Reproducir en PyTorch los resultados del artículo “Autoencoder Feature Extraction for Classification”.
• Evaluar y comparar la exactitud usando Regresión Logística con los datos originales y con las características comprimidas.

Conjunto de Datos

Muestra: 1,000 ejemplos y 100 características de entrada.

El Reto: Se generó un conjunto de datos para clasificación binaria mediante la función make_classification. La dificultad de este conjunto de datos radica en que de las 100 características de entrada, solo 10 son informativas y las otras 90 son puro ruido o redundancia.

Los datos fueron divididos (67% entrenamiento, 33% prueba) y escalados al rango [0, 1] usando MinMaxScaler. El objetivo es que el Autoencoder actúe como un filtro que limpie esta alta redundancia.

Autoencoder

import torch
import torch.nn as nn

class AutoEncoder(nn.Module):
    def __init__(self, n_inputs):
        super().__init__()
        # Quitamos la division cuando entrenamos con las 100 en lugar de las 50
        n_bottleneck = round(float(n_inputs) / 2.0)

        self.encoder = nn.Sequential(
            # Encoder Nivel 1
            nn.Linear(n_inputs, n_inputs * 2),
            nn.BatchNorm1d(n_inputs * 2),
            nn.LeakyReLU(),
            # Encoder Nivel 2
            nn.Linear(n_inputs * 2, n_inputs),
            nn.BatchNorm1d(n_inputs),
            nn.LeakyReLU(),

            # Bottleneck: 50 características
            nn.Linear(n_inputs, n_bottleneck)
        )

        self.decoder = nn.Sequential(
            # Decoder Nivel 1
            nn.Linear(n_bottleneck, n_inputs),
            nn.BatchNorm1d(n_inputs),
            nn.LeakyReLU(),
            # Decoder Nivel 2
            nn.Linear(n_inputs, n_inputs * 2),
            nn.BatchNorm1d(n_inputs * 2),
            nn.LeakyReLU(),

            # Capa de Salida
            nn.Linear(n_inputs * 2, n_inputs)
        )

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

Proceso de Entrenamiento PyTorch

Configuración e Hiperparámetros:

• Épocas: 200
• Batch Size: 16
• Función de Pérdida: MSELoss (Error Cuadrático Medio)
• Optimizador: Adam ($lr=0.001$)

Resultados de Entrenamiento:

Para validar la arquitectura, ejecutamos dos experimentos: uno sin compresión (dejando 100 neuronas en el cuello de botella) para garantizar la correcta topología, y otro comprimiendo al 50%.

Sin Compresión (100 neuronas):

Con Compresión (50 neuronas):

Ambas redes convergen a una pérdida (MSE) cercana a 0.001. El encoder final se guardó en autoenc0.pth.

Resultados

1. Línea Base: El modelo MLP sin el encoder.
2. Encoder (100 dimensiones)
3. Encoder Comprimido (50 dimensiones)

Diagnóstico: La Regresión Logística es sensible al ruido. Usar el Autoencoder como preprocesamiento mejoró la línea base (89.4%):

• A ~93.9% usando la representación latente (100 neuronas), logrando mapear patrones limpios.
• A 91.00% logrando una compresión estricta del 50% de los datos.

El Autoencoder parece una excelente herramienta para eliminar ruido y extraer características.