Aprender a construir un modelo de PyTorch con nn.Module es el primer paso para entender cómo funcionan por dentro las arquitecturas de inteligencia artificial modernas. Aquí vas a ver cómo armar un clasificador de texto desde cero, pieza por pieza, como si fuera un castillo de Legos.

La idea es simple: defines bloques, decides su tamaño y luego los conectas. Eso es, en esencia, lo que hacen modelos como BERT o GPT, solo que con muchas más piezas.

Qué es nn.Module y por qué es la base de PyTorch

La clase nn.Module es el cimiento sobre el que se construye prácticamente cualquier modelo en PyTorch. Cuando creas una subclase de nn.Module, heredas toda la maquinaria que PyTorch necesita para entrenar, propagar gradientes y guardar parámetros.

Piensa en nn.Module como la base del castillo. Tú, como arquitecto, decides qué bloques poner encima y cómo conectarlos [01:05].

¿Qué es nn.Module en PyTorch? Es la clase base que provee PyTorch para definir modelos de redes neuronales. Al heredar de ella, tu modelo gana la capacidad de registrar capas, manejar parámetros entrenables y ejecutar la propagación hacia adelante.

Por qué usar Google Colab para entrenar modelos

Colab te da acceso gratuito a una GPU, suficiente para experimentar con modelos como este TextClassifier. Además, autocompleta el código y te avisa en rojo si hay errores de sintaxis [00:34].

Cómo construir una subclase TextClassifier en PyTorch

El primer paso es importar torch y el módulo nn, que viene de neural network. Después defines tu clase heredando de nn.Module y declaras los argumentos que tu arquitectura necesita.

En este caso, el modelo recibe cuatro argumentos clave que funcionan como hiperparámetros: el tamaño del vocabulario, las dimensiones del embedding, las dimensiones ocultas y la dimensión de salida [02:10].

python import torch from torch import nn

class TextClassifier(nn.Module): def init(self, vocab_size, embedding_dim, hidden_dim, output_dim): super().init() self.embedding = nn.Embedding(vocab_size, embedding_dim) self.rnn = nn.LSTM(embedding_dim, hidden_dim, num_layers=2, batch_first=True) self.fc = nn.Linear(hidden_dim, output_dim)

Cada línea define un bloque de Lego con su tamaño específico. El embedding convierte palabras en vectores, la capa LSTM procesa secuencias y la capa linear da el resultado final.

Qué hace cada bloque dentro del modelo

• Embedding: transforma cada palabra del vocabulario en un vector denso de tamaño embedding_dim. Es la entrada del modelo.
• LSTM: una red neuronal recurrente que procesa el texto en secuencia. El argumento batch_first=True indica que los lotes van primero en la dimensión del tensor [03:50].
• Linear (FC): la fully connected final que mapea las dimensiones ocultas a las clases de salida.

¿Para qué sirve batch_first en una capa LSTM? Le indica a PyTorch que la primera dimensión del tensor de entrada corresponde al tamaño del lote. Esto facilita procesar varios ejemplos en paralelo sin reordenar tensores manualmente.

Cómo conectar las capas con la función forward

La función forward es donde defines el flujo de datos. PyTorch reconoce este nombre automáticamente, así que no puedes cambiarlo [05:00].

python def forward(self, text): embeddings = self.embedding(text) outputs, (hidden, cell) = self.rnn(embeddings) final_hidden = hidden[-1] return self.fc(final_hidden)

Primero, el texto entra al embedding. El vector resultante pasa a la LSTM, que devuelve tres cosas: las salidas en cada paso, el estado oculto final y la celda. Tomas el último estado oculto, le ajustas las dimensiones y lo pasas por la capa linear.

Por qué se manipulan las dimensiones del tensor oculto

La LSTM devuelve un tensor con una dimensión extra que corresponde al número de capas. Como tu capa linear espera un tensor más simple, necesitas reducir esa dimensión antes de conectar los bloques [06:20]. Si los tamaños no calzan, el modelo no corre.

Cómo inicializar el modelo TextClassifier con hiperparámetros reales

Una vez definida la clase, toca darle valores concretos a los argumentos. Estos números son hiperparámetros: puedes moverlos según tu hardware y tu problema.

python vocab_size = 10000 embedding_dim = 100 hidden_dim = 256 output_dim = 2

model = TextClassifier(vocab_size, embedding_dim, hidden_dim, output_dim)

Algunas referencias prácticas que se mencionaron:

• Un modelo BERT usa un vocabulario cercano a 30.000 tokens, pero puede llegar a 60.000 o 100.000 [09:10].
• Las dimensiones de embedding en transformers modernos rondan los 768.
• Las hidden_dim controlan la profundidad: más grande significa más capacidad y más cómputo.
• output_dim = 2 se usa para clasificación binaria; súbelo si tienes más clases.

¿Qué son hidden_dim y embedding_dim? Son las dimensiones que controlan el tamaño interno del modelo. embedding_dim define qué tan rico es el vector que representa cada palabra, y hidden_dim define la profundidad de la red neuronal recurrente.

Cómo se ve el modelo final inicializado

Al imprimir model, ves los tres bloques con sus tamaños: un Embedding de 10.000 por 100, una LSTM de 100 por 256 y una Linear de 256 por 2. Todo encaja porque las dimensiones de salida de un bloque coinciden con las de entrada del siguiente [11:30].

Ese encaje es lo que hace que el castillo se sostenga. Si rompes una dimensión, el modelo deja de funcionar.

Ahora que tienes tu primer modelo en PyTorch, cuéntame en los comentarios qué arquitectura te gustaría construir. ¿Un clasificador de sentimientos? ¿Un detector de spam? ¿Algo más ambicioso? Tu castillo, tus reglas.