Contenido del curso
Arquitectura de clasificación de texto en PyTorch
Construir un modelo de clasificación de texto en PyTorch implica ensamblar capas como bloques de Lego: un embedding, una normalización por lotes y una capa lineal final. Aprenderás a definir esta arquitectura paso a paso, entender por qué cada componente importa y cómo inicializar el modelo con los hiperparámetros correctos. Es ideal si ya diste tus primeros pasos con PyTorch y quieres construir un modelo real, pequeño pero eficiente.
Qué librerías necesitas para crear el modelo de clasificación
Antes de escribir la clase, necesitas tres importaciones clave en tu notebook de Google Colab [00:25].
nn. Por convención se importa con el alias F.La diferencia es importante. La clase Linear, por ejemplo, se construye internamente con funciones de functional. En este modelo usarás F específicamente para aplicar la función de activación ReLU sobre los tensores normalizados.
¿Qué es torch.nn.functional? Es un módulo de PyTorch con funciones fundamentales (como ReLU, softmax o convoluciones) que las clases de
nnusan por debajo. Te da control fino cuando quieres aplicar una operación sin instanciar una capa completa.
Cómo se define la arquitectura del modelo paso a paso
La clase ModeloClasificacionTexto hereda de nn.Module, igual que en clases anteriores, pero esta vez ensambla un modelo real [01:10].
En el __init__ pides al usuario cuatro datos al inicializar: el tamaño del vocabulario (vocab_size), las dimensiones del embedding (embed_dim) y el número de clases (num_class). Con esos parámetros defines tres bloques.
Qué hace cada bloque de la red neuronal
nn.EmbeddingBag(vocab_size, embed_dim): convierte tokens en vectores densos [02:30].nn.BatchNorm1d(embed_dim): normaliza los vectores del embedding [03:00].nn.Linear(embed_dim, num_class): proyecta las dimensiones del embedding al número final de clases [04:20].La capa lineal es la que hace la magia de la clasificación. Si tu embedding tiene 100 dimensiones y tienes 14 clases, esta capa proyecta de 100 a 14, donde cada dimensión final representa una clase posible.
Por qué usar batch normalization en tu modelo
Normalizar significa tomar un grupo de datos, calcular su media y varianza, y transformarlos a media cero y varianza uno. Esto compacta valores muy grandes o muy pequeños y trae tres beneficios concretos.
Por eso encontrarás batch normalization en prácticamente todos los modelos modernos.
¿Qué es normalizar en deep learning? Es transformar un grupo de tensores para que tengan media cero y varianza uno. Compacta los datos, acelera el entrenamiento y reduce el riesgo de sobreajuste.
Cómo conectar las capas en el método forward
El método forward define el flujo real de los datos a través de los bloques [05:40]. Recibe dos argumentos del usuario: text y offsets, este último indica dónde inicia cada nuevo texto dentro del tensor.
El flujo es así:
embedded = self.embedding(text, offsets) aplica el embedding.embedded_norm = self.bn1(embedded) normaliza por lotes.embedded_activated = F.relu(embedded_norm) aplica la no linealidad ReLU.return self.fc(embedded_activated) proyecta a las clases finales.La función ReLU introduce no linealidad y permite que la red aprenda patrones más complejos que una simple combinación lineal.
Cómo inicializar el modelo con los hiperparámetros correctos
Para instanciar el modelo necesitas calcular tres valores a partir del dataset DBpedia [07:50].
len(set([label for label, text in train_iter])). Itera todo el split de entrenamiento, extrae cada etiqueta, las mete en un set para eliminar duplicados y mide su longitud. Para DBpedia el resultado son 14 clases.len(vocab), donde vocab se definió antes. En este caso da 802 mil elementos, que incluyen palabras y símbolos [09:30].Con esos tres valores ya puedes ejecutar modelo = ModeloClasificacionTexto(vocab_size, embedding_size, num_class).to(device) para enviarlo a GPU si está disponible o a CPU.
Cómo contar los parámetros entrenables del modelo
Una función reutilizable que vale la pena tener en todos tus proyectos cuenta los parámetros entrenables [11:20]. La lógica es simple: itera sobre model.parameters(), filtra solo los que tienen requires_grad=True y suma p.numel() de cada uno.
Tener gradiente es sinónimo de ser entrenable. Si un parámetro no requiere gradiente, no se actualiza durante el entrenamiento.
Al imprimir el resultado con un formato limpio (separando miles con coma), descubres que el modelo tiene 80 millones de parámetros entrenables. Es un modelo grande, aunque dentro del mundo del deep learning moderno todavía se considera relativamente pequeño y muy eficiente para lo que ofrece.
¿Qué significa que un parámetro sea entrenable? Que tiene
requires_grad=Truey, por lo tanto, se actualiza durante el backpropagation. Solo esos parámetros cuentan para medir el tamaño real de aprendizaje del modelo.
¿Cómo se compara este modelo con la regresión lineal o el Hello PyTorch que construiste antes? ¿Qué capas extra le agregarías: más normalización, una LSTM, dropout? Déjalo en los comentarios.
Sebastián Franco
Estudiante
Edgar A. Gonzalez Ambriz
Estudiante
Diego Ferrua Huivin
Estudiante
Federico Arias
Estudiante
Bryan Castano
Estudiante
Mario Alexander Vargas Celis
EstudianteHablemos de los embeddings
Los embeddings, en palabras simples, son una matriz que nos permite representar cualquier palabra de un text corpus (o dataset de texto) en un array de N dimensiones, donde cada dimensión será una similaridad abstracta entre varias palabras, su nacimiento original se da para comprimir la cantidad de dimensiones que resultan de hacer One Hot Encoding a los tokens, pero ha resultado ser una herramienta excelente para calcular distancias vectoriales entre palabras (o sencillamente, su correlación).
Cómo funciona un embedding
Un embedding es simplemente una capa simétrica de 1 entrada y 1 salida, donde procesaremos cada posible token y se predecirá cuál es el token que le acompañará, al hacer esto, tendremos una matriz de pesos de dimensión tamaño_vocabulario x dimensiones_embedding.
En nuestro modelo hemos usado la capa EmbeddingBag, que nos evita computar la capa de entrada y salida y directamente calcula y usa el tensor de pesos para el resto de la red (además de aplicar promedio a cada dimensión).
Tamaño del modelo
Es increíble ver que el modelo tenga más de 80 millones de parámetros, pero es natural, dado que más del 90% de estos son la capa de embedding, donde para cada token existente en el corpus debemos crear una correlación con respecto a N dimensiones, en este caso nuestro caso tenemos un vocab_size de 802.998 y una dimensión de embedding de 100, por lo tanto los parámetros entrenables de esta capa será su multiplicación.
Finalidad del modelo
Esta capa nos permitirá ver la similitud entre palabras, por lo que, al ser posteriormente normalizada y activada, la pasaremos por una capa fully connect de 14 salidas para hacer la clasificación, de esta manera haremos que el modelo abstraiga qué palabras son más frecuentes de aparecer que otras con respecto a una categoría.
Estimado profesor, usted sabe bastante, pero hace falta que explique un poco mas detallado los conceptos. Muchas gracias
Hay cursos previos a este que se tiene que llevar, recomiendo usar chat GPT para terminar de consolidar conceptos complejos. Saludos
no entiendo como se normaliza un vector de textos, osea el vocabulario son numeros que representan palabras, pero que significaria restar la media y dividir por la varianza a un vector de numeros que representan palabras? estariamos calculando la distancia entre palabras?
Segun GPT: Normalizar un vector de palabras en el contexto de NLP (Procesamiento de Lenguaje Natural) no se refiere a la normalización estadística (restar la media y dividir por la desviación estándar) como se haría con vectores numéricos. En NLP, la normalización de texto se refiere a la preparación del texto para su procesamiento, lo cual puede incluir varias técnicas como:
1. **Tokenización:**
Separar el texto en unidades más pequeñas, como palabras o subpalabras. Esto se puede hacer utilizando técnicas como dividir por espacios en blanco, tokenización basada en reglas o tokenización basada en modelos de lenguaje como BERT.
2. **Limpieza de texto:**
Eliminar caracteres especiales, puntuación, números, espacios adicionales, y convertir el texto a minúsculas para estandarizarlo. También se pueden eliminar palabras comunes que no aportan significado (stopwords).
3. **Stemming y lematización:**
Reducir las palabras a su forma base. El stemming reduce las palabras eliminando sufijos, mientras que la lematización reduce las palabras a su forma canónica (lema).
4. **Vectorización:**
Convertir las palabras en vectores numéricos para que puedan ser procesadas por algoritmos de aprendizaje automático. Esto se puede hacer utilizando técnicas como Bag of Words (BoW), TF-IDF (Term Frequency-Inverse Document Frequency), word embeddings (como Word2Vec, GloVe, FastText), entre otros.
5. **Padding y truncado:**
Alinear las secuencias de palabras para que tengan la misma longitud, utilizando padding para añadir tokens especiales al final o truncado para eliminar palabras en secuencias más largas.
6. **Normalización lingüística:**
Aplicar reglas lingüísticas específicas del idioma, como corrección ortográfica, corrección gramatical, expansión de abreviaturas, entre otros.
Estas son algunas de las técnicas comunes de normalización de texto en NLP. El enfoque exacto dependerá del problema específico que estés abordando y de las características del texto que estés procesando.
Hola Chicos , este es un Modelo xon dos capas LSTM al modelo para capturar dependencias secuenciales. He modificado la arquitectura del ejemplo de la clase, para usar Embedding normal en lugar de EmbeddingBag, ya que LSTM necesita procesar secuencias:
from torch import nn import torch.nn.functional as F class TextClassifierLSTM(nn.Module): def __init__(self, vocab_size, embed_dim, hidden_dim, class_num, num_layers=2, dropout=0.3): super(TextClassifierLSTM, self).__init__() # Capa de incrustación (embedding) self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0) # Dos capas LSTM bidireccionales para capturar dependencias complejas self.lstm = nn.LSTM( input_size=embed_dim, hidden_size=hidden_dim, num_layers=num_layers, batch_first=True, dropout=dropout if num_layers > 1 else 0, bidirectional=True ) # Capa de normalización por lotes self.bn1 = nn.BatchNorm1d(hidden_dim * 2) # *2 porque es bidireccional # Dropout para regularización self.dropout = nn.Dropout(dropout) # Capa completamente conectada self.fc = nn.Linear(hidden_dim * 2, class_num) def forward(self, text): # text shape: (batch_size, seq_length) # Incrustar el texto embedded = self.embedding(text) # (batch_size, seq_length, embed_dim) # Pasar por LSTM lstm_out, (hidden, cell) = self.lstm(embedded) # lstm_out: (batch_size, seq_length, hidden_dim * 2) # Tomar el último estado oculto (concatenar forward y backward) # hidden shape: (num_layers * 2, batch_size, hidden_dim) hidden_forward = hidden[-2, :, :] # Última capa forward hidden_backward = hidden[-1, :, :] # Última capa backward hidden_concat = torch.cat([hidden_forward, hidden_backward], dim=1) # hidden_concat shape: (batch_size, hidden_dim * 2) # Normalización por lotes normalized = self.bn1(hidden_concat) # Activación ReLU activated = F.relu(normalized) # Dropout dropped = self.dropout(activated) # Capa de salida output = self.fc(dropped) return output
Para un Ejemplo de caso:
import torch # Parámetros del modelo vocab_size = 10000 embed_dim = 128 hidden_dim = 256 class_num = 4 # Para AG_NEWS num_layers = 2 # Crear modelo model = TextClassifierLSTM( vocab_size=vocab_size, embed_dim=embed_dim, hidden_dim=hidden_dim, class_num=class_num, num_layers=num_layers, dropout=0.3 ) # Ejemplo de entrada (batch_size=4, seq_length=50) text = torch.randint(0, vocab_size, (4, 50)) # Forward pass output = model(text) print(f"Output shape: {output.shape}") # (4, 4) print(f"Total parámetros: {sum(p.numel() for p in model.parameters()):,}")
Caracteristicas::
PD: Ahora el forward solo recibe text (sin offsets), ya que LSTM procesa secuencias completas. Por tanto y Habra que Ajustar pipeline de datos para pasar tensores de secuencias en lugar de usar EmbeddingBag.
Para crear un modelo de clasificación de texto utilizando PyTorch, puedes seguir un enfoque basado en redes neuronales. Aquí te mostraré cómo construir un modelo simple de clasificación de texto utilizando una red neuronal totalmente conectada (fully connected neural network) con torch.nn. Este ejemplo utilizará el conjunto de datos AG News, pero puedes adaptarlo a cualquier conjunto de datos que estés utilizando.
### Paso 1: Importar las librerías necesarias
import torch import torch.nn as nn import torch.optim as optim from torchtext.datasets import AG\_NEWS from torchtext.data.utils import get\_tokenizer from torchtext.vocab import build\_vocab\_from\_iterator from torch.utils.data import DataLoader
### Paso 2: Cargar y preparar el conjunto de datos
\# Cargar el conjunto de datos AG News train\_iter = AG\_NEWS(split='train') \# Crear un tokenizador tokenizador = get\_tokenizer('basic\_english') \# Función para generar tokens def yield\_tokens(data\_iter):   for \_, texto in data\_iter:   yield tokenizador(texto) \# Construir el vocabulario vocab = build\_vocab\_from\_iterator(yield\_tokens(train\_iter), specials=\["\<unk>"]) vocab.set\_default\_index(vocab\["\<unk>"]) \# Función para convertir texto en índices de vocabulario def process\_text(text):   return torch.tensor(\[vocab\[token] for token in tokenizador(text)], dtype=torch.int64) \# Cargar de nuevo el conjunto de datos train\_iter = AG\_NEWS(split='train') \# Crear una lista de tuplas (texto procesado, etiqueta) data = \[(process\_text(text), label) for label, text in train\_iter] \# Crear un DataLoader batch\_size = 16 # Puedes ajustar el tamaño del batch data\_loader = DataLoader(data, batch\_size=batch\_size, shuffle=True)
### Paso 3: Definir el modelo
Aquí definimos un modelo simple de red neuronal:
class TextClassifier(nn.Module):   def \_\_init\_\_(self, vocab\_size, embed\_dim, num\_classes):   super(TextClassifier, self).\_\_init\_\_()   self.embedding = nn.Embedding(vocab\_size, embed\_dim)   self.fc1 = nn.Linear(embed\_dim, 128)   self.fc2 = nn.Linear(128, num\_classes)   self.relu = nn.ReLU()   self.softmax = nn.LogSoftmax(dim=1)   def forward(self, x):   \# x: tensor de índices   x = self.embedding(x) # Obtiene las representaciones de las palabras   x = x.mean(dim=1) # Promedia los embeddings (puedes usar otras técnicas de agregación)   x = self.fc1(x)   x = self.relu(x)   x = self.fc2(x)   return self.softmax(x)
### Paso 4: Inicializar el modelo, la función de pérdida y el optimizador
\# Parámetros vocab\_size = len(vocab) embed\_dim = 64 # Dimensión de los embeddings num\_classes = 4 # Número de clases en AG News \# Inicializar el modelo model = TextClassifier(vocab\_size, embed\_dim, num\_classes) \# Definir la función de pérdida y el optimizador criterion = nn.NLLLoss() # Pérdida negativa logarítmica optimizer = optim.Adam(model.parameters(), lr=0.001)
### Paso 5: Entrenamiento del modelo
\# Definir el número de épocas num\_epochs = 5 for epoch in range(num\_epochs):   total\_loss = 0   for texts, labels in data\_loader:   \# Zero gradients   optimizer.zero\_grad()   \# Forward pass   outputs = model(texts)   \# Compute loss   loss = criterion(outputs, labels)   \# Backward pass and optimization   loss.backward()   optimizer.step()   total\_loss += loss.item()   print(f"Epoch \[{epoch + 1}/{num\_epochs}], Loss: {total\_loss / len(data\_loader):.4f}")
### Paso 6: Evaluación del modelo
Para evaluar el modelo, puedes usar un conjunto de validación o prueba. A continuación se muestra un ejemplo básico:
def evaluate\_model(model, data\_loader):   model.eval() # Cambiar a modo evaluación   correct = 0   total = 0   with torch.no\_grad():   for texts, labels in data\_loader:   outputs = model(texts)   \_, predicted = torch.max(outputs.data, 1)   total += labels.size(0)   correct += (predicted == labels).sum().item()   print(f'Accuracy: {100 \* correct / total:.2f}%') \# Puedes evaluar usando el mismo DataLoader de entrenamiento o uno diferente evaluate\_model(model, data\_loader)
### Resumen
1. **Importar librerías y cargar el conjunto de datos.**
2. **Definir el modelo de clasificación.**
3. **Inicializar el modelo, la función de pérdida y el optimizador.**
4. **Entrenar el modelo.**
5. **Evaluar el modelo.**
Esto te dará una buena base para crear un modelo de clasificación de texto en PyTorch.