Entrenamiento y Evaluación de Modelos en PyTorch
Contenido del curso
Miguel Sánchez Guerrero
Rafael Rivera
Andres Camacho
Luis Camilo Jimenez Alvarez
Nydia Mejía Zavala
Mario Alexander Vargas Celis
Juan Acevedo
Juan Arevalo
Luis Ángel Mazabuel Garcia
Eduard Giraldo Martínez
David Alejandro Quiñonez
Fernando Alcalá
Carlos Perilla
Hiperparámetros
EPOCHS = 6
TASA_APRENDIZAJE = 0.15
BATCH_TAMANO = 86
Optimizador
optimizer = torch.optim.Adam(modelo.parameters(), lr= TASA_APRENDIZAJE)
Gracias por compartir, muy buen resultado con los cambios que hiciste.
tengo una pregunta, se crea y se inicializa una variable major\_loss\_validation pero en ningun momento veo que el valor de esa variable se modifique, pero aun asi siempre se compara contra el valor de esa variable para guardar el mejor modelo:
if validacion_loss < major_loss_validation:
la pregunta es, no se deberia guardar el valor del mejor modelo en esa variable major\_loss\_validation?
yo creo lo mismo
Para guardar el valor del mejor modelo en la variable major_loss_validation, debes inicializarla con un valor positivo infinito al inicio del entrenamiento. Luego, durante cada época, compara la validation_loss actual con el valor almacenado en major_loss_validation. Si la validation_loss es menor, actualiza major_loss_validation con este nuevo valor y guarda el modelo actual utilizando torch.save().
El proceso se desglosa así:
Esto asegura que siempre tengas el mejor modelo con la menor pérdida de validación.
if validation_loss < major_loss_validation: major_loss_validation = validation_loss torch.save(model.state_dict(), 'mejores_pesos.pt')
Aquí tienes un ejemplo completo de cómo puedes realizar el **entrenamiento** y la **evaluación** de un modelo de clasificación de texto utilizando PyTorch y TorchText, asumiendo que ya tienes los datos preparados y tokenizados.
### Paso 1: Preparación de los datos
Para este ejemplo, asumiremos que ya has cargado el dataset (como **DBpedia**) y creado tu vocabulario. También vamos a usar un DataLoader para manejar los datos en mini-lotes.
### Paso 2: Definir el modelo
El modelo que vamos a usar es una simple red neuronal con una capa de embeddings, una capa recurrente (GRU), y una capa completamente conectada para la clasificación.
import torch import torch.nn as nn import torch.optim as optim class TextClassificationModel(nn.Module):   def \_\_init\_\_(self, vocab\_size, embed\_dim, num\_class):   super(TextClassificationModel, self).\_\_init\_\_()   self.embedding = nn.EmbeddingBag(vocab\_size, embed\_dim, sparse=True)   self.fc = nn.Linear(embed\_dim, num\_class)   self.init\_weights()   def init\_weights(self):   initrange = 0.5   self.embedding.weight.data.uniform\_(-initrange, initrange)   self.fc.weight.data.uniform\_(-initrange, initrange)   self.fc.bias.data.zero\_()   def forward(self, text, offsets):   embedded = self.embedding(text, offsets)   return self.fc(embedded)
### Paso 3: Entrenamiento del modelo
#### Función de entrenamiento
def train(dataloader, model, criterion, optimizer):   model.train()   total\_acc, total\_count = 0, 0   log\_interval = 500   for idx, (label, text, offsets) in enumerate(dataloader):   optimizer.zero\_grad()   predicted\_label = model(text, offsets)   loss = criterion(predicted\_label, label)   loss.backward()   torch.nn.utils.clip\_grad\_norm\_(model.parameters(), 0.1) # Evitar gradientes explosivos   optimizer.step()   total\_acc += (predicted\_label.argmax(1) == label).sum().item()   total\_count += label.size(0)   if idx % log\_interval == 0 and idx > 0:   print(f'Batch {idx}: Accuracy: {total\_acc/total\_count:.4f}')   total\_acc, total\_count = 0, 0
### Paso 4: Evaluación del modelo
#### Función de evaluación
Para evaluar el modelo, no aplicamos gradientes, y calculamos la precisión en el conjunto de prueba.
def evaluate(dataloader, model, criterion):   model.eval()   total\_acc, total\_count = 0, 0   with torch.no\_grad():   for label, text, offsets in dataloader:   predicted\_label = model(text, offsets)   loss = criterion(predicted\_label, label)   total\_acc += (predicted\_label.argmax(1) == label).sum().item()   total\_count += label.size(0)   return total\_acc/total\_count
### Paso 5: Entrenar y evaluar
VOCAB\_SIZE = len(vocab) # Tamaño del vocabulario EMBED\_DIM = 64 # Dimensión de los embeddings NUM\_CLASS = len(set(\[label for (label, text) in train\_iter])) # Número de clases model = TextClassificationModel(VOCAB\_SIZE, EMBED\_DIM, NUM\_CLASS).to(device) optimizer = optim.SGD(model.parameters(), lr=0.001) criterion = nn.CrossEntropyLoss() \# Entrenamiento for epoch in range(10):   train(train\_dataloader, model, criterion, optimizer)   acc = evaluate(test\_dataloader, model, criterion)   print(f'Epoch {epoch+1}: Test Accuracy: {acc:.4f}')
### Paso 6: Preparar los datos para DataLoader
Antes de entrenar el modelo, es necesario definir un DataLoader que maneje cómo se cargarán los datos en mini-lotes. Aquí te dejo un ejemplo de cómo preparar los datos:
from torch.utils.data import DataLoader from torchtext.datasets import DBpedia from torchtext.data.utils import get\_tokenizer tokenizer = get\_tokenizer('basic\_english') def yield\_tokens(data\_iter):   for \_, text in data\_iter:   yield tokenizer(text) vocab = build\_vocab\_from\_iterator(yield\_tokens(train\_iter), specials=\["\<unk>"]) vocab.set\_default\_index(vocab\["\<unk>"]) def collate\_batch(batch):   label\_list, text\_list, offsets = \[], \[], \[0]   for (\_label, \_text) in batch:   label\_list.append(int(\_label) - 1)   processed\_text = torch.tensor(vocab(tokenizer(\_text)), dtype=torch.int64)   text\_list.append(processed\_text)   offsets.append(processed\_text.size(0))   label\_list = torch.tensor(label\_list, dtype=torch.int64)   text\_list = torch.cat(text\_list)   offsets = torch.tensor(offsets\[:-1]).cumsum(dim=0)   return label\_list, text\_list, offsets train\_iter = DBpedia(split='train') test\_iter = DBpedia(split='test') train\_dataloader = DataLoader(train\_iter, batch\_size=8, shuffle=True, collate\_fn=collate\_batch) test\_dataloader = DataLoader(test\_iter, batch\_size=8, shuffle=True, collate\_fn=collate\_batch)
### Conclusión
Este es un flujo básico de cómo entrenar y evaluar un modelo de clasificación de texto con PyTorch. El modelo usa embeddings simples y una capa de clasificación, pero puedes mejorarlo añadiendo capas más complejas como LSTM o CNN. También puedes probar diferentes optimizadores, tasas de aprendizaje y técnicas de regularización para obtener mejores resultados.
Hay un detalle que se me hizo raro en el código presentado
y es que creo que el mejor modelo no se guarda como tal , ya que major_loss_validation no se está actualizando y el sentido del condicional ahí equivale a revisar que la perdida promedio de validación en ese epoch sea menor a la antigua pero la antigua se guarda en una variable diferente a la que se usa para mirar la condición por ende realmente no se guarda la mejor sino se guarda la siguiente y la siguiente ya que esa condición siempre da TRUE
Codigo propuesto:
#Crear variable que devuelve la perdida de validacióon mas pequeña major_loss_validation = float('inf') #Entrenar for epoch in range(1, EPOCHS + 1 ): #Entrenar el modelo accuracy_mean_trian, mean_loss_train = training(model_t, dataloader_train) #Validación accuracy_mean_eval, mean_loss_eval = training(model_t, dataloader_val) #Guardar el modelo con mejores resultados if mean_loss_eval < major_loss_validation: major_loss_validation = mean_loss_eval torch.save(model_t.state_dict(), "mejor_model.pt")
Si mi lógica está mal déjenmelo saber 🫰
¿Cuanto tiempo les tardo en entrenarse su modelo hasta llegar a las 4 Epochs? Mi entrenamiento está tardando demasiado. ¿Saben qué podría ser?
Aproximadamente 8 minutos en Kaggle con una "GPU T4 x2", 4 épocas con tamaño del lote de 128. Asegúrate de tener la GPU, sino esto puede tardar varias horas. También fíjate en la cantidad de épocas (entre más, más demorará) y en el tamaño del lote (entre más, más rápido, pero requiere más GPU).
Hola Juan
Aproximadamente 8min.
Lo estoy haciendo en local, creo que está configurado para 4 de RAM y usar CUDA de la targeta gráfica, pero no está a su máxima potencia.
Cambiando el optimizador a Adam solamente tuve un resultado prometedor
Durante la ejecución del Entrenamiento y la validación me apareció el siguiente mensaje de error:
La solución fue eliminar el sparse=True en:
self.embedding = nn.EmbeddingBag(vocab_size, embed_dim, sparse=True)
Luego de eso, me salió el siguiente error en la evaluación:
El cual ocurre porque en el video, en el código de la clase, para la función de entrenamiento se utilizó:
total_count += label.size(0)
Pero en la función de validación no se le pasó ningún parámetro, ergo: la solución es ponerle el 0.
Comparto el modelo usando LSTM:from torch import nnimport torch.nn.functional as F class ModeloClasificacionTexto(nn.Module): def __init__(self, vocab_size, embed_dim, hidden_size, num_class): super(ModeloClasificacionTexto, self).__init__() # Capa de incrustación (embedding) self.embedding = nn.EmbeddingBag(vocab_size, embed_dim) # Capa LSTM self.lstm = nn.LSTM(embed_dim, hidden_size) # Capa de transformación self.transformation = nn.Sequential( nn.Linear(hidden_size, hidden_size), nn.ReLU(), nn.Linear(hidden_size, hidden_size) ) # Capa de normalización por lotes (batch normalization) self.bn1 = nn.BatchNorm1d(embed_dim) # Capa completamente conectada (fully connected) self.fc = nn.Linear(embed_dim, num_class) def forward(self, text, offsets): # Incrustar el texto (embed the text) embedded = self.embedding(text, offsets) # Pasar el texto incrustado a través de la capa LSTM (pass the embedded text through the LSTM layer) lstm_out, _ = self.lstm(embedded) # Aplicar la transformación (apply the transformation) # transformed_out = self.transformation(lstm_out[:, -1, :]) transformed_out = self.transformation(lstm_out[-1, :]) # Aplicar la normalización por lotes (apply batch normalization) embedded_norm = self.bn1(embedded) # Aplicar la función de activación ReLU (apply the ReLU activation function) embedded_activated = F.relu(embedded_norm) # Devolver las probabilidades de clase (output the class probabilities) return self.fc(embedded_activated)
from torch import nn import torch.nn.functional as F class ModeloClasificacionTexto(nn.Module): def __init__(self, vocab_size, embed_dim, hidden_size, num_class): super(ModeloClasificacionTexto, self).__init__() # Capa de incrustación (embedding) self.embedding = nn.EmbeddingBag(vocab_size, embed_dim) # Capa LSTM self.lstm = nn.LSTM(embed_dim, hidden_size) # Capa de transformación self.transformation = nn.Sequential( nn.Linear(hidden_size, hidden_size), nn.ReLU(), nn.Linear(hidden_size, hidden_size) ) # Capa de normalización por lotes (batch normalization) self.bn1 = nn.BatchNorm1d(embed_dim) # Capa completamente conectada (fully connected) self.fc = nn.Linear(embed_dim, num_class) def forward(self, text, offsets): # Incrustar el texto (embed the text) embedded = self.embedding(text, offsets) # Pasar el texto incrustado a través de la capa LSTM (pass the embedded text through the LSTM layer) lstm_out, _ = self.lstm(embedded) # Aplicar la transformación (apply the transformation) # transformed_out = self.transformation(lstm_out[:, -1, :]) transformed_out = self.transformation(lstm_out[-1, :]) # Aplicar la normalización por lotes (apply batch normalization) embedded_norm = self.bn1(embedded) # Aplicar la función de activación ReLU (apply the ReLU activation function) embedded_activated = F.relu(embedded_norm) # Devolver las probabilidades de clase (output the class probabilities) return self.fc(embedded_activated)
