Antes de entrenar un modelo de clasificación de texto en PyTorch necesitas tres piezas que muchas veces se pasan por alto: los hiperparámetros, el optimizador con su función de pérdida y una división correcta del dataset en entrenamiento, validación y prueba. Sin esto, tu red neuronal no tiene cómo aprender ni cómo medirse.

Aquí te muestro cómo configurarlas paso a paso usando DBpedia, CrossEntropyLoss y Stochastic Gradient Descent, con código pensado para ejecutarse en Colab con GPU.

Qué hiperparámetros necesitas antes de entrenar

Los hiperparámetros son valores que tú defines y que afectan cómo aprende tu modelo. No los aprende la red, los eliges tú y los ajustas con experimentación.

En esta configuración trabajamos con tres [00:32]:

• Épocas: 3. Es un número conservador porque el GPU de Colab es pequeño y los datos mejoran rápido. Si quitas o agregas una época puedes ver cómo cambia el accuracy y la pérdida.
• Tasa de aprendizaje: 0.2. Un valor agresivo que ha funcionado bien en otros modelos. Puedes probar 0.1 (tradicional) o 0.3 (más agresivo) y comparar resultados.
• Tamaño del batch: 64. Antes usamos 8 como ejemplo, pero con GPU disponible podemos aprovechar lotes más grandes. Cuanto más grande el batch, más memoria GPU necesitas.

¿Qué es un hiperparámetro en deep learning? Es un valor que defines manualmente antes de entrenar, como la tasa de aprendizaje o el número de épocas. No se ajusta durante el entrenamiento, lo ajustas tú mediante experimentación.

Cómo defines el criterio y el optimizador en PyTorch

El criterio es la función de pérdida y el optimizador es el algoritmo que ajusta los pesos del modelo. Por convención en Python, a la función de pérdida se le llama criterion y al optimizador optimizer [02:15].

Para clasificación multiclase usamos CrossEntropyLoss, que vive en torch.nn. Si quieres experimentar con otras como L1Loss o MSELoss, todas están listadas en la documentación oficial de PyTorch.

python criterion = torch.nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=tasa_aprendizaje)

El optimizador Stochastic Gradient Descent (SGD) es el más usado y suele ser una buena elección por defecto. Recibe los parámetros del modelo (model.parameters()) y la tasa de aprendizaje. Si tus datos responden mejor a otro algoritmo, puedes probar Adam, RMSprop u otros disponibles en torch.optim.

¿Por qué se usa CrossEntropyLoss para clasificación? Porque mide la diferencia entre la distribución de probabilidad predicha y la real, lo que la hace ideal cuando tu modelo debe elegir entre varias clases.

Cómo divides un dataset en entrenamiento, validación y prueba

DBpedia te entrega dos datasets: train y test. Pero un flujo robusto necesita tres conjuntos. La validación te permite ajustar hiperparámetros sin contaminar el set de prueba final [03:50].

Qué hace ToMapStyleDataset y por qué lo necesitas

Los datasets que entrega DBpedia son iteradores. Para que el DataLoader de PyTorch los pueda mezclar y dividir en batches, necesitas convertirlos a formato map-style. Eso lo hace to_map_style_dataset de torchtext.

python from torch.utils.data.dataset import random_split from torchtext.data.functional import to_map_style_dataset

train_iter, test_iter = DBpedia() train_dataset = to_map_style_dataset(train_iter) test_dataset = to_map_style_dataset(test_iter)

Cómo aplicar random_split para crear el set de validación

De los datos de entrenamiento, separas el 95% para entrenar y el 5% para validar. Primero calculas cuántos ejemplos representa ese 95% y luego usas random_split para dividir aleatoriamente.

python num_train = int(len(train_dataset) * 0.95) split_train, split_valid = random_split( train_dataset, [num_train, len(train_dataset) - num_train] )

La resta len(train_dataset) - num_train te garantiza que los dos pedazos sumen exactamente el total, sin errores de redondeo.

Cómo creas los DataLoaders para entrenar, validar y probar

Un DataLoader es la estructura que alimenta tu modelo durante el entrenamiento. Mezcla los datos, los divide en lotes y los entrega listos para procesar.

Necesitas tres, uno por cada split [06:40]:

python train_dataloader = DataLoader( split_train, batch_size=batch_tamano, shuffle=True, collate_fn=collate_batch ) valid_dataloader = DataLoader( split_valid, batch_size=batch_tamano, shuffle=True, collate_fn=collate_batch ) test_dataloader = DataLoader( test_dataset, batch_size=batch_tamano, shuffle=True, collate_fn=collate_batch )

Fíjate en tres detalles importantes:

• shuffle=True mezcla los datos aleatoriamente en cada época, lo que evita que el modelo aprenda patrones del orden.
• collate_fn=collate_batch aplica la función de preprocesamiento que ya habíamos definido para tokenizar y armar tensores.
• El test_dataloader usa test_dataset directamente, no un split, porque DBpedia ya lo entrega separado.

¿Para qué sirve el set de validación? Para ajustar hiperparámetros y monitorear si el modelo está sobreajustando, sin tocar el set de prueba que reservas para la evaluación final.

Con el criterio definido, el optimizador listo y los tres DataLoaders preparados, ya tienes toda la infraestructura para entrenar tu red neuronal. ¿Qué tasa de aprendizaje vas a probar primero, 0.1, 0.2 o 0.3? Cuéntame en los comentarios qué resultados obtienes.