Entrenamiento de Modelos de Clasificación con DBpedia Dataset

Contenido del curso

Fundamentos de PyTorch

Estructura de modelo de deep learning en PyTorch

Redes neuronales con PyTorch

Cierre del curso

24
Qué aprendiste en el curso de PyTorch
01:13 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:50

Entrenamiento de Modelos de Clasificación con DBpedia Dataset

Curso de Redes Neuronales con PyTorch

Clase 16 de 24

Clase 16 / 24

Comentarios (3)3 comentarios

Sebastián Franco

Hace 3 años

¿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.

Mario Alexander Vargas Celis

Hace 2 años

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):

&#x20;   model.to(device)

&#x20;  &#x20;

&#x20;   \# Bucle de entrenamiento

&#x20;   for epoch in range(num\_epochs):

&#x20;       model.train()  # Poner el modelo en modo de entrenamiento

&#x20;       running\_loss = 0.0

&#x20;       correct\_predictions = 0

&#x20;       total\_samples = 0



&#x20;       for inputs, labels in train\_loader:

&#x20;           inputs, labels = inputs.to(device), labels.to(device)



&#x20;           \# Reiniciar gradientes

&#x20;           optimizer.zero\_grad()



&#x20;           \# Forward pass

&#x20;           outputs = model(inputs)

&#x20;           loss = criterion(outputs, labels)

&#x20;          &#x20;

&#x20;           \# Backward pass y optimización

&#x20;           loss.backward()

&#x20;           optimizer.step()



&#x20;           \# Acumular la pérdida y calcular predicciones correctas

&#x20;           running\_loss += loss.item() \* inputs.size(0)

&#x20;           \_, predicted = torch.max(outputs, 1)

&#x20;           correct\_predictions += (predicted == labels).sum().item()

&#x20;           total\_samples += labels.size(0)

&#x20;      &#x20;

&#x20;       epoch\_loss = running\_loss / total\_samples

&#x20;       epoch\_acc = correct\_predictions / total\_samples



&#x20;       print(f"Epoch {epoch+1}/{num\_epochs} - Loss: {epoch\_loss:.4f}, Accuracy: {epoch\_acc:.4f}")



&#x20;       \# Validación al final de cada época

&#x20;       model.eval()  # Poner el modelo en modo de evaluación

&#x20;       val\_loss = 0.0

&#x20;       val\_correct\_predictions = 0

&#x20;       val\_total\_samples = 0



&#x20;       with torch.no\_grad():

&#x20;           for val\_inputs, val\_labels in valid\_loader:

&#x20;               val\_inputs, val\_labels = val\_inputs.to(device), val\_labels.to(device)



&#x20;               val\_outputs = model(val\_inputs)

&#x20;               loss = criterion(val\_outputs, val\_labels)

&#x20;               val\_loss += loss.item() \* val\_inputs.size(0)



&#x20;               \_, val\_predicted = torch.max(val\_outputs, 1)

&#x20;               val\_correct\_predictions += (val\_predicted == val\_labels).sum().item()

&#x20;               val\_total\_samples += val\_labels.size(0)



&#x20;       val\_loss /= val\_total\_samples

&#x20;       val\_acc = val\_correct\_predictions / val\_total\_samples



&#x20;       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!

Octavio De Paula

Hace 2 años

Si se tienen conocimientos bases se disfruta mucho, aunque sin dudas haga falta un poco mas explicacion profunda en los conceptos nuevos.

Eduard Giraldo Martínez

Hace 2 años

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 ✨

Recursos

¿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:

Índice del ejemplo: Relevante para el seguimiento del progreso.
Datos de cada lote: Incluyen etiqueta, texto y offsets definidos en la función de agrupación (Colate Function).

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:

Imprimir informe: Si el índice es múltiplo de 500 (y mayor a cero), se imprimen detalles del progreso, como el número de época, ejemplos procesados, pérdida promedio y precisión.

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!

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):

&#x20;   model.to(device)

&#x20;  &#x20;

&#x20;   \# Bucle de entrenamiento

&#x20;   for epoch in range(num\_epochs):

&#x20;       model.train()  # Poner el modelo en modo de entrenamiento

&#x20;       running\_loss = 0.0

&#x20;       correct\_predictions = 0

&#x20;       total\_samples = 0

&#x20;       for inputs, labels in train\_loader:

&#x20;           inputs, labels = inputs.to(device), labels.to(device)

&#x20;           \# Reiniciar gradientes

&#x20;           optimizer.zero\_grad()

&#x20;           \# Forward pass

&#x20;           outputs = model(inputs)

&#x20;           loss = criterion(outputs, labels)

&#x20;          &#x20;

&#x20;           \# Backward pass y optimización

&#x20;           loss.backward()

&#x20;           optimizer.step()

&#x20;           \# Acumular la pérdida y calcular predicciones correctas

&#x20;           running\_loss += loss.item() \* inputs.size(0)

&#x20;           \_, predicted = torch.max(outputs, 1)

&#x20;           correct\_predictions += (predicted == labels).sum().item()

&#x20;           total\_samples += labels.size(0)

&#x20;      &#x20;

&#x20;       epoch\_loss = running\_loss / total\_samples

&#x20;       epoch\_acc = correct\_predictions / total\_samples

&#x20;       print(f"Epoch {epoch+1}/{num\_epochs} - Loss: {epoch\_loss:.4f}, Accuracy: {epoch\_acc:.4f}")

&#x20;       \# Validación al final de cada época

&#x20;       model.eval()  # Poner el modelo en modo de evaluación

&#x20;       val\_loss = 0.0

&#x20;       val\_correct\_predictions = 0

&#x20;       val\_total\_samples = 0

&#x20;       with torch.no\_grad():

&#x20;           for val\_inputs, val\_labels in valid\_loader:

&#x20;               val\_inputs, val\_labels = val\_inputs.to(device), val\_labels.to(device)

&#x20;               val\_outputs = model(val\_inputs)

&#x20;               loss = criterion(val\_outputs, val\_labels)

&#x20;               val\_loss += loss.item() \* val\_inputs.size(0)

&#x20;               \_, val\_predicted = torch.max(val\_outputs, 1)

&#x20;               val\_correct\_predictions += (val\_predicted == val\_labels).sum().item()

&#x20;               val\_total\_samples += val\_labels.size(0)

&#x20;       val\_loss /= val\_total\_samples

&#x20;       val\_acc = val\_correct\_predictions / val\_total\_samples

&#x20;       print(f"Validation Loss: {val\_loss:.4f}, Validation Accuracy: {val\_acc:.4f}")

\# 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")

Resumen

¿Cómo diseñar una función de entrenamiento para un modelo de Machine Learning?

¿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:

Índice del ejemplo: Relevante para el seguimiento del progreso.
Datos de cada lote: Incluyen etiqueta, texto y offsets definidos en la función de agrupación (Colate Function).

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:

Imprimir informe: Si el índice es múltiplo de 500 (y mayor a cero), se imprimen detalles del progreso, como el número de época, ejemplos procesados, pérdida promedio y precisión.

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?

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!

Fundamentos de PyTorch

Clasificación de Texto con PyTorch y TorchText en Google Colab

Introducción a PyTorch: Ventajas y Comparación con Otros Frameworks

Clasificador de texto con nn.Module en PyTorch

Tensores en PyTorch desde cero

Debuguea tensores en PyTorch sin errores

Operaciones con tensores y conversión NumPy-PyTorch

Estructura de modelo de deep learning en PyTorch

Regresión Lineal con PyTorch: Creación y Partición de Datos Artificiales

Regresión lineal desde cero en PyTorch

Bucle de entrenamiento con SGD en PyTorch

Entrenamiento y Visualización de Modelos de Regresión Lineal en PyTorch

Inferencia y predicciones con PyTorch

Redes neuronales con PyTorch

Clasificación de texto con TorchText y DBpedia

Tokenización y Vocabulario en TorchText para DBpedia

DataLoader y collate function en PyTorch

Arquitectura de clasificación de texto en PyTorch

Entrenamiento de Modelos de Clasificación con DBpedia Dataset

Evaluación de Modelos de Aprendizaje Automático en PyTorch

Optimizador y splits de datos en PyTorch

Entrenamiento y Evaluación de Modelos en PyTorch

Inferencia con torch.compile en PyTorch 2.0

Guardado y carga de modelos en PyTorch con checkpoints

Subir modelos al Hub de Hugging Face

Cómo cargar pesos desde Hugging Face en PyTorch

Cierre del curso

Qué aprendiste en el curso de PyTorch

Entrenamiento de Modelos de Clasificación con DBpedia Dataset

Progreso del curso

Fundamentos de PyTorch

Estructura de modelo de deep learning en PyTorch

Redes neuronales con PyTorch

Cierre del curso

Recursos

Recursos