Optimizador y splits de datos en PyTorch
Contenido del curso
Sebastián Franco
Mario Alexander Vargas Celis
Ciro Villafraz
Carlos Alberto Bustamante Gaytan
Hablemos de los estilos de datasets
Hoy tuve la pregunta de por qué debemos hacer switch de estilo de dataset desde iter hacia map, y eso me llevó a estudiar qué es cada estilo y por qué se usa.
map-style dataset
Este es el estilo de dataset más conocido, donde tenemos un dataset X con 10.000 ejemplos y podemos acceder arbitrariamente (o también llamado aleatoriamente) a cualquiera con la sintaxis X[n].
Este estilo de dataset demanda en la clase base implementar los métodos getitem y len para funcionar. Una limitante es que se debe conocer el tamaño del dataset, pero a cambio podemos acceder a los ejemplos a voluntad.
iter-style dataset
Este tipo de dataset está pensado para grandes volúmenes de datos y es el que encontramos en este proyecto.
Este estilo de dataset implica la implementación del método iter que será un generador de elementos.
La gran ventaja es que este estilo es agnóstico del tamaño, por lo que virtualmente podríamos usar datos de tamaño infinito y no tendríamos problemas en la carga de memoria, sin embargo, no podremos acceder a los ejemplos a voluntad como en el primer caso.
¿Por qué cambiamos de estilo?
Aquí me voy a remitir a la clase 13, donde hemos cargado los vocabularios y tokens. Para acortar, la función build_vocab espera un ITERADOR, y este es el formato natural de nuestro dataset, por lo que podemos alimentarlo sin mayor problema, sin embargo, cuando vamos a implementar los DataLoader en esta clase debemos cambiarlo.
La razón del cambio es que el objeto DataLoader espera por defecto un dataset del tipo map y no iter, si bien puede aceptarlo, es cierto que podrían encontrarse problemas de compabilidad, por lo que requerimos cambiar el estilo.
En resumen
En resumen, el dataset tipo iterador nos ha servido para crear nuestros tokens y vocabularios, pero debemos cambiarlo a un dataset tipo map para poder cargar los datos "nativamente" y posteriormente splitearlos.
Aquí tienes una explicación detallada sobre cómo realizar el **split de datos**, configurar la **función de pérdida**, y definir un **optimizador** en PyTorch para el entrenamiento de un modelo de clasificación de texto.
### 1. **Split de datos**
El **split de datos** es importante para separar el conjunto de datos en entrenamiento y validación (o prueba). Esto permite entrenar el modelo en una porción de los datos y evaluar su rendimiento en otra.
Puedes usar torch.utils.data.random\_split para dividir tus datos.
#### Ejemplo:
from torch.utils.data import random\_split \# Supongamos que tienes un dataset llamado `dataset` train\_size = int(0.8 \* len(dataset)) # 80% para entrenamiento val\_size = len(dataset) - train\_size # 20% para validación \# Dividir el dataset train\_dataset, val\_dataset = random\_split(dataset, \[train\_size, val\_size])
### 2. **DataLoader**
El DataLoader se usa para cargar los datos en mini-lotes durante el entrenamiento y la evaluación.
#### Ejemplo:
from torch.utils.data import DataLoader \# Crear DataLoaders para entrenamiento y validación train\_loader = DataLoader(train\_dataset, batch\_size=32, shuffle=True) val\_loader = DataLoader(val\_dataset, batch\_size=32, shuffle=False)
### 3. **Función de Pérdida (Loss Function)**
La función de pérdida mide cuán bien o mal está haciendo el modelo en las predicciones. Para clasificación de texto, una de las funciones de pérdida más comunes es CrossEntropyLoss, que se usa para tareas de clasificación multiclase.
#### Ejemplo:
import torch.nn as nn \# Definir la función de pérdida criterion = nn.CrossEntropyLoss()
### 4. **Optimizador**
El optimizador ajusta los pesos del modelo en función del gradiente de la función de pérdida. Uno de los optimizadores más utilizados es Adam, que es una versión mejorada del descenso de gradiente estocástico.
#### Ejemplo:
import torch.optim as optim \# Inicializar el optimizador optimizer = optim.Adam(model.parameters(), lr=0.001)
### 5. **Entrenamiento del Modelo**
Ahora que tenemos los datos, la pérdida y el optimizador configurados, podemos entrenar el modelo. El siguiente bloque de código muestra cómo entrenar un modelo durante varios **epochs**.
#### Ejemplo:
def train\_model(model, train\_loader, val\_loader, criterion, optimizer, num\_epochs, device):   model = model.to(device)   for epoch in range(num\_epochs):   model.train() # Poner el modelo en modo de entrenamiento   running\_loss = 0.0   correct\_predictions = 0   total\_samples = 0   for inputs, labels in train\_loader:   inputs, labels = inputs.to(device), labels.to(device)   \# Forward pass   outputs = model(inputs)   loss = criterion(outputs, labels)   \# Backward pass y optimización   optimizer.zero\_grad()   loss.backward()   optimizer.step()   running\_loss += loss.item() \* inputs.size(0)   \_, predicted = torch.max(outputs, 1)   correct\_predictions += (predicted == labels).sum().item()   total\_samples += labels.size(0)   avg\_train\_loss = running\_loss / total\_samples   train\_accuracy = correct\_predictions / total\_samples   print(f"Epoch {epoch+1}/{num\_epochs}, Loss: {avg\_train\_loss:.4f}, Accuracy: {train\_accuracy:.4f}")   \# Validación después de cada epoch   validate\_model(model, val\_loader, criterion, device) def validate\_model(model, val\_loader, criterion, device):   model.eval() # Poner el modelo en modo evaluación   running\_loss = 0.0   correct\_predictions = 0   total\_samples = 0   with torch.no\_grad(): # No calcular gradientes en validación   for inputs, labels in val\_loader:   inputs, labels = inputs.to(device), labels.to(device)   outputs = model(inputs)   loss = criterion(outputs, labels)   running\_loss += loss.item() \* inputs.size(0)   \_, predicted = torch.max(outputs, 1)   correct\_predictions += (predicted == labels).sum().item()   total\_samples += labels.size(0)   avg\_val\_loss = running\_loss / total\_samples   val\_accuracy = correct\_predictions / total\_samples   print(f"Validation Loss: {avg\_val\_loss:.4f}, Validation Accuracy: {val\_accuracy:.4f}")
### 6. **Resumen**
1. **Split de datos**: Usa random\_split para dividir tus datos en entrenamiento y validación.
2. **Función de pérdida**: Usa CrossEntropyLoss para tareas de clasificación.
3. **Optimizador**: Usa Adam para actualizar los parámetros del modelo.
4. **Entrenamiento**: Implementa un ciclo de entrenamiento con el optimizador y la función de pérdida.
5. **Validación**: Evalúa el rendimiento del modelo en el conjunto de validación después de cada epoch.
Este flujo cubre los aspectos básicos de la preparación y entrenamiento de un modelo de clasificación de texto en PyTorch.
En una clase anterior se había dicho que no era necesario poner shuffle=True por el dataset de DBpedia. Sin embargo, aquí si ponemos shuffle=True 🤔.
En general el DataLoader tiene el shuffle=False de forma predeterminada, por lo que si quieres que se haga un shuffle es necesario ponerlo como True. Ahora, si te refieres a la razón de hacer shuffle es porque se necesita hacer para el entrenamiento, porque la red puede aprender que el orden de los datos es un factor, cosa que no es.
De forma general yo te diría que para datos de entrenamiento siempre hagas un shuffle a los datos y para validación o prueba no es necesario del todo y en ocasiones para el análisis de error es mejor no hacerlo.
