Arquitectura de clasificación de texto en PyTorch
Contenido del curso
Sebastián Franco
Edgar A. Gonzalez Ambriz
Diego Ferrua Huivin
Federico Arias
Bryan Castano
Mario Alexander Vargas Celis
Hablemos 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.
