Contenido del curso
Entrenamiento de Modelos de Clasificación con DBpedia Dataset
¿Cómo diseñar una función de entrenamiento para un modelo de Machine Learning?
Diseñar una función de entrenamiento efectiva es crucial para mejorar el rendimiento de un modelo de clasificación. En esta clase, hemos creado una función llamada Entrena que se utiliza para fomentar el aprendizaje de un modelo en base a un conjunto de datos. A continuación, desglosamos los elementos clave y pasos seguidos para lograrlo.
¿Qué pasos iniciales se deben considerar?
Definir el modo del modelo: Al comienzo de la función, se coloca el modelo en modo de entrenamiento (train). Esto permite que el modelo se ajuste y modifique sus parámetros.
Inicializar variables: Se establece un seguimiento de métricas esenciales, como la precisión de la época (Epoch Accuracy o ACK) y la pérdida (Epoch Loss). Además, se cuenta con Total Count, el total de ejemplos en el lote o batch.
¿Cómo se iteran los datos con un Data Loader?
Utilizamos un bucle sobre el data loader para extraer la información necesaria:
Una vez extraídos, los gradientes deben restablecerse a cero para evitar acumulación de errores de iteraciones anteriores.
¿Cuál es la importancia de la predicción y la pérdida?
Predicción: Utilizamos el modelo para obtener predicciones basadas en el texto y los offsets.
Cálculo de pérdida: Esta se determina comparando las predicciones con las etiquetas reales. Se utiliza un criterio específico para medir y evaluar qué tanto mejora o empeora el modelo.
prediccion = modelo(texto, offsets) perdida = criterio(prediccion, etiqueta)
¿Cómo se manejan los gradientes y la actualización de pesos?
Propagación hacia atrás: A través de backward, se calculan los gradientes de pérdida con respecto a los pesos del modelo.
Normalización de gradientes: Para evitar que se eleve y desestabilice, se utiliza clip-rat-norm, limitando la norma a un valor máximo de 0.1.
Actualización de pesos: Con step, los pesos se ajustan en función de los gradientes calculados, mejorando así el modelo.
¿Cómo se reporta el progreso del entrenamiento?
Es fundamental reportar métricas para monitorear el avance:
if idx > 0 and idx % 500 == 0: print(f"Época {nro_epoca}, Procesados {idx}/{len(data_loader)} ejemplos, Pérdida: {epoch_loss/total_count}, Precisión: {epoch_accuracy/total_count}")
¿Cuál es el valor de separar funciones de entrenamiento?
Separar las funciones en secciones (como entrenamiento y validación) permite un código más limpio, fácil de mantener y depurar. Esto facilita identificar y corregir errores, promoviendo un enfoque más sistemático en el aprendizaje automático.
Este proceso de diseño de funciones es una habilidad fundamental en el desarrollo de modelos de Machine Learning. ¡Sigue adelante con tu práctica y mejora continua!
Sebastián Franco
Estudiante
Mario Alexander Vargas Celis
Estudiante
Octavio De Paula
Estudiante
Eduard Giraldo Martínez
Estudiante¿Qué es el clip_grad_norm
El clipping es una estrategia que se usa en entrenamiento para acortar parámetros que vayan creciendo y, en caso de no ser detenidos, crear un problema denominado "exploding gradients" que no es más que una red que nunca convergerá porque sus parámetros son demasiado grandes.
Tipos de clipping
Popularmente hay 2 tipos de clipping: por norm y por parameter, donde el primero calcula la norma L2 del parámetro, y si esta supera un threshold será reducido mediante una pequeña operación, el segundo caso es igual, donde no se realiza el cálculo de la media sino que se compara directamente el valor de cada parámetro.
La importancia de cuándo se llama
Es importante llamar este clipper en el momento que se han calculado los gradientes pero ANTES de actualizarlos con el optimizador, de esta manera aseguraremos que el modelo no sea propenso a sufrir de una explosión de gradientes.
¿Esto mejora el performance?
Directamente, no. Lo que si hace es mejorar la estabilidad del modelo para que los parámetros serán homogéneos, que al final se traducirá en mejor performance a la hora de entrenar el modelo.
Aquí tienes una función de ejemplo para entrenar un modelo de clasificación de texto usando PyTorch. Esta función realiza el ciclo típico de entrenamiento para varias épocas y calcula la pérdida y precisión:
### Función de Entrenamiento
import torch import torch.nn as nn import torch.optim as optim def train\_model(model, train\_loader, valid\_loader, optimizer, criterion, num\_epochs, device):   model.to(device)       \# Bucle de entrenamiento   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)   \# Reiniciar gradientes   optimizer.zero\_grad()   \# Forward pass   outputs = model(inputs)   loss = criterion(outputs, labels)       \# Backward pass y optimización   loss.backward()   optimizer.step()   \# Acumular la pérdida y calcular predicciones correctas   running\_loss += loss.item() \* inputs.size(0)   \_, predicted = torch.max(outputs, 1)   correct\_predictions += (predicted == labels).sum().item()   total\_samples += labels.size(0)       epoch\_loss = running\_loss / total\_samples   epoch\_acc = correct\_predictions / total\_samples   print(f"Epoch {epoch+1}/{num\_epochs} - Loss: {epoch\_loss:.4f}, Accuracy: {epoch\_acc:.4f}")   \# Validación al final de cada época   model.eval() # Poner el modelo en modo de evaluación   val\_loss = 0.0   val\_correct\_predictions = 0   val\_total\_samples = 0   with torch.no\_grad():   for val\_inputs, val\_labels in valid\_loader:   val\_inputs, val\_labels = val\_inputs.to(device), val\_labels.to(device)   val\_outputs = model(val\_inputs)   loss = criterion(val\_outputs, val\_labels)   val\_loss += loss.item() \* val\_inputs.size(0)   \_, val\_predicted = torch.max(val\_outputs, 1)   val\_correct\_predictions += (val\_predicted == val\_labels).sum().item()   val\_total\_samples += val\_labels.size(0)   val\_loss /= val\_total\_samples   val\_acc = val\_correct\_predictions / val\_total\_samples   print(f"Validation Loss: {val\_loss:.4f}, Validation Accuracy: {val\_acc:.4f}")
### Descripción de los componentes:
1. **model.train()**: Pone el modelo en modo de entrenamiento.
2. **optimizer.zero\_grad()**: Reinicia los gradientes en cada paso.
3. **criterion**: Función de pérdida (por ejemplo, nn.CrossEntropyLoss).
4. **loss.backward()**: Realiza la retropropagación para actualizar los pesos.
5. **model.eval()**: Pone el modelo en modo de evaluación para la validación.
### Ejemplo de uso:
\# Inicializar el modelo, optimizador, y función de pérdida model = MyTextClassifierModel() # Reemplaza con tu modelo optimizer = optim.Adam(model.parameters(), lr=0.001) criterion = nn.CrossEntropyLoss() \# Llamar a la función de entrenamiento train\_model(model, train\_loader, valid\_loader, optimizer, criterion, num\_epochs=10, device="cuda")
Esta función recorre el conjunto de datos de entrenamiento y validación durante varias épocas, mostrando la pérdida y la precisión en cada una de ellas. ¡Es un buen punto de partida para entrenar un modelo de clasificación de texto!
Si se tienen conocimientos bases se disfruta mucho, aunque sin dudas haga falta un poco mas explicacion profunda en los conceptos nuevos.
Hola Octavio
👀Pensaba lo mismo hasta hace poco, me puse a leer el código desde arriba, tratando de explicarlo con mis propias palabras cómo funciona.
🧠Pude notar que así se entiende más el código y el PORQUÉ de las cosas.
🗒️Te invito a hacerlo, y si no sabes para qué es cierta función, lee la documentación o pídele a Papá ChatGPT que te explique de una manera sencilla.
💚Para mí, el profesor explica fantástico, porque para llegar hasta aquí debemos tener ciertas bases sólidas. Claramente, hay conceptos que no entiendo, pero lo importante es que te quedes con la lógica detrás de todo esto
Un fuerte abrazo Octavio, no te frustres, disfruta el proceso, que cuándo llegues a entender todo bien y a la primera, sentirás mucha satisfacción personal ✨
