9.3 Guardar y Cargar Modelos en PyTorch

Uno de los aspectos más importantes del entrenamiento de modelos de aprendizaje profundo es la capacidad de guardar los modelos entrenados para su uso posterior. Esto es crucial porque entrenar modelos puede llevar una cantidad significativa de tiempo, especialmente cuando se trata de conjuntos de datos masivos. Guardar un modelo no solo nos permite reutilizar el modelo en el futuro, sino que también nos ayuda a evitar la necesidad de entrenar el modelo desde cero.

Los modelos guardados se pueden utilizar para varios propósitos, como hacer predicciones, continuar el proceso de entrenamiento, ajustar los modelos o incluso comenzar un nuevo proceso de entrenamiento. Al reutilizar un modelo entrenado, también podemos ahorrar recursos computacionales y tiempo que se requerirían para entrenar un nuevo modelo desde cero.

Además, los modelos que se guardan se pueden compartir con otros, lo que puede ser beneficioso para proyectos colaborativos o al trabajar en problemas similares. La capacidad de guardar y compartir modelos es particularmente útil en el contexto del aprendizaje profundo, donde los modelos pueden tener millones o incluso miles de millones de parámetros, lo que hace que sea poco práctico entrenarlos en computadoras personales.

La capacidad de guardar y reutilizar modelos entrenados es una característica crucial en el aprendizaje profundo y es una parte esencial del proceso de desarrollo de cualquier aplicación de aprendizaje profundo.

9.3.1 Guardar Modelos

En PyTorch, podemos guardar el modelo completo utilizando la función torch.save(). Esta función guarda los parámetros y la arquitectura del modelo.

Podemos especificar la extensión del archivo para guardar el diccionario de estado del modelo como un archivo .pt o .pth. Esto es útil cuando solo queremos guardar el diccionario de estado del modelo, que contiene información sobre los pesos y sesgos de las capas del modelo.

Además, también podemos cargar un modelo guardado utilizando la función torch.load(). Esta función carga el diccionario de estado guardado y lo devuelve como un diccionario de Python. Luego podemos usar este diccionario para establecer los parámetros de un modelo de PyTorch. Es importante tener en cuenta que la arquitectura del modelo debe ser la misma que la utilizada para guardar el diccionario de estado para que los parámetros se carguen correctamente.

En resumen, PyTorch nos proporciona funciones convenientes para guardar y cargar modelos, lo que nos permite reutilizar y compartir fácilmente modelos entrenados con otros.

Así es como puedes hacerlo:

# Assume model is an instance of a PyTorch neural network
torch.save(model, 'model.pth')

En este código, model es el modelo que queremos guardar y 'model.pth' es el nombre del archivo en el que queremos guardarlo. La extensión .pth se utiliza comúnmente para modelos de PyTorch, pero puedes usar cualquier extensión que desees.

9.3.2 Cargar Modelos

Para cargar un modelo que hemos guardado previamente utilizando PyTorch, podemos utilizar la función torch.load(). Esta función nos permite cargar un objeto serializado, que puede ser un punto de control del modelo, un diccionario de parámetros u cualquier otro objeto serializado de PyTorch.

Una vez que hemos cargado el modelo, podemos usarlo para inferencia o entrenamiento adicional. Por ejemplo, podríamos ajustar el modelo en un nuevo conjunto de datos o usarlo para generar predicciones en un conjunto de pruebas. Además, podríamos utilizar el modelo como punto de partida para un nuevo modelo, inicializando algunas de las capas con los pesos preentrenados.

En general, torch.load() es una función esencial para trabajar con modelos preentrenados en PyTorch, lo que nos permite cargar y manipular fácilmente objetos serializados.

Así es cómo se hace:

# Load the model
model = torch.load('model.pth')

En este código, 'model.pth' es el nombre del archivo desde el cual queremos cargar el modelo. El modelo cargado tendrá la misma arquitectura y parámetros que el modelo cuando se guardó.

9.3.3 Guardar y Cargar Solo los Parámetros del Modelo

A veces, es posible que solo deseemos guardar los parámetros del modelo (los pesos y sesgos), no todo el modelo en sí. Esto puede ser útil cuando queremos cargar los parámetros en una arquitectura de modelo diferente. De hecho, esta es una práctica común en el aprendizaje profundo, donde los modelos preentrenados con parámetros guardados a menudo se utilizan como bloques de construcción para nuevos modelos.

Al guardar solo los parámetros, podemos reducir significativamente el espacio de almacenamiento necesario para guardar el modelo. Nos permite separar la arquitectura del modelo de los parámetros aprendidos, lo que facilita experimentar con diferentes arquitecturas sin tener que volver a entrenar todo el modelo desde cero.

Esto puede ahorrar mucho tiempo y recursos computacionales. Además, nos permite compartir los parámetros aprendidos con otros, lo que facilita la colaboración y la reproducibilidad de los resultados. En general, guardar solo los parámetros del modelo proporciona muchos beneficios y es una técnica importante en el aprendizaje profundo.

Para guardar solo los parámetros, podemos utilizar la función state_dict():

# Save only the model parameters
torch.save(model.state_dict(), 'params.pth')

Y para cargar los parámetros en un modelo, primero debemos crear una instancia de la arquitectura del modelo y luego utilizar la función load_state_dict():

# Assume model is an instance of the same architecture as the saved parameters
model.load_state_dict(torch.load('params.pth'))

Recuerda que al cargar los parámetros, la arquitectura del modelo debe ser la misma que la arquitectura del modelo cuando se guardaron los parámetros.

9.3.4 Guardar y Cargar Modelos Durante el Entrenamiento

Cuando se entrenan modelos de aprendizaje profundo, especialmente en conjuntos de datos grandes, el proceso de entrenamiento puede llevar mucho tiempo, a veces incluso días o semanas. En tales casos, es una buena práctica guardar el modelo periódicamente durante el entrenamiento. De esta manera, si ocurre algo inesperado (como un corte de energía o un fallo del sistema), no perderás todo tu progreso. Simplemente puedes cargar el último modelo guardado y continuar el entrenamiento desde ese punto.

Guardar el modelo a intervalos regulares te permite hacer un seguimiento del rendimiento del modelo con el tiempo. Puedes comparar el rendimiento del modelo en diferentes etapas de entrenamiento y hacer ajustes a los hiperparámetros en consecuencia. Además, guardar el modelo te permite reutilizar el modelo entrenado para otras tareas, sin tener que comenzar el proceso de entrenamiento desde cero.

En resumen, guardar el modelo periódicamente durante el entrenamiento no solo te ayuda a evitar la pérdida de progreso en caso de fallos del sistema, sino que también te permite analizar el rendimiento del modelo con el tiempo, realizar ajustes en los hiperparámetros y reutilizar el modelo entrenado para otras tareas.

Así es cómo puedes guardar el modelo cada n épocas durante el entrenamiento:

n = 10  # Save the model every 10 epochs
for epoch in range(num_epochs):
    # Training code here...

    # Save the model every n epochs
    if epoch % n == 0:
        torch.save(model, f'model_{epoch}.pth')

En este código, num_epochs es el número total de épocas para el entrenamiento, y epoch es la época actual. El modelo se guarda cada n épocas, y el número de época se incluye en el nombre del archivo.

Salida:

La salida del código será una serie de archivos .pth, cada uno conteniendo los pesos del modelo después de n épocas. Lo siguiente es un ejemplo de la salida del código:

model_0.pth
model_10.pth
model_20.pth
...
model_90.pth

Los archivos .pth se pueden cargar en PyTorch para continuar entrenando el modelo o para usar el modelo para inferencia.

Aquí tienes una explicación más detallada del código:

n = 10 define el número de épocas entre cada guardado.
for epoch in range(num_epochs) hace un bucle sobre el número de épocas.
# Código de entrenamiento aquí... contiene el código de entrenamiento.
if epoch % n == 0: verifica si la época actual es divisible por n.
torch.save(model, f'model_{epoch}.pth') guarda los pesos del modelo en un archivo con el nombre model_epoch.pth.

Cuando quieras continuar entrenando desde un modelo guardado, puedes cargar el modelo y continuar el bucle de entrenamiento desde la próxima época:

# Load the model
model = torch.load('model_10.pth')

# Continue training from epoch 11
for epoch in range(11, num_epochs):
    # Training code here...

Salida:

La salida del código será que el modelo continuará entrenando desde la época 11. Lo siguiente es un ejemplo de la salida del código:

Epoch [11/10], Step [100/60000], Loss: 2.123456
Epoch [11/10], Step [200/60000], Loss: 2.012345
...
Epoch [20/10], Step [60000/60000], Loss: 0.000012

El modelo continuará entrenando desde la época 11 porque la variable model se carga con los pesos del archivo model_10.pth. El bloque # Código de entrenamiento aquí... entrenará el modelo durante las épocas restantes num_epochs - 10.

Aquí tienes una explicación más detallada del código:

model = torch.load('model_10.pth') carga los pesos del modelo desde el archivo model_10.pth.
for epoch in range(11, num_epochs): hace un bucle sobre las épocas restantes.
# Código de entrenamiento aquí... contiene el código de entrenamiento.

Recuerda que guardar y cargar modelos durante el entrenamiento es una buena práctica que puede ahorrarte mucho tiempo y problemas. ¡Sigue haciendo un trabajo fantástico! Estás explorando de manera excelente el mundo del aprendizaje profundo con PyTorch.

9.3.5 Mejores Prácticas para Guardar y Cargar Modelos

Cuando trabajas con PyTorch y otros frameworks de aprendizaje profundo, hay algunas mejores prácticas que debes seguir al guardar y cargar modelos:

Guarda el state_dict del modelo, no el modelo completo: Aunque puedes guardar el modelo completo en PyTorch, generalmente se recomienda guardar solo el state_dict del modelo. Esto se debe a que el state_dict solo incluye los parámetros del modelo, que son la parte más esencial del modelo. Guardar el modelo completo también guarda la arquitectura, pero esto puede causar problemas si la arquitectura cambia o si se necesita cargar el modelo en un entorno diferente.
Utiliza la extensión .pth o .pt para los archivos de modelos de PyTorch: Aunque puedes usar cualquier extensión de archivo que desees, es común utilizar la extensión .pth o .pt para los archivos de modelos de PyTorch. Esto hace claro que el archivo es un modelo de PyTorch.
Guarda y carga en el mismo dispositivo: Cuando guardas y cargas modelos, asegúrate de hacerlo en el mismo dispositivo (CPU o GPU). Si necesitas cargar un modelo en un dispositivo diferente, puedes utilizar el argumento map_location en la función torch.load().
Guarda periódicamente durante el entrenamiento: Como se mencionó anteriormente, es una buena práctica guardar tu modelo periódicamente durante el entrenamiento. De esta manera, si algo sale mal, puedes reanudar el entrenamiento desde el último modelo guardado en lugar de empezar desde cero.
Lleva un registro de la información del entrenamiento: Cuando guardas tu modelo, puede ser útil guardar también información sobre el proceso de entrenamiento, como el número de épocas, la tasa de aprendizaje actual y el rendimiento en el conjunto de validación. Esto puede ayudarte a llevar un registro del proceso de entrenamiento y facilitar la reanudación del entrenamiento más adelante.

Aquí tienes un ejemplo de cómo puedes guardar el state_dict de un modelo junto con alguna información de entrenamiento:

# Assume model is an instance of a PyTorch neural network
# Assume optimizer is an instance of a PyTorch optimizer
# Assume epoch is the current epoch number
# Assume loss is the loss on the validation set

torch.save({
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': loss,
}, 'checkpoint.pth')

Y aquí tienes cómo puedes cargar el state_dict y la información de entrenamiento:

# Load the checkpoint
checkpoint = torch.load('checkpoint.pth')

# Load the model and optimizer state_dict
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])

# Load the other training information
epoch = checkpoint['epoch']
loss = checkpoint['loss']

En esta sección, hemos profundizado en el proceso de guardar y cargar modelos en PyTorch. Esta es una habilidad crucial para cualquier profesional del aprendizaje automático, ya que nos permite preservar nuestros modelos para su uso futuro, compartirlos con otros y retomar donde lo dejamos en caso de interrupciones durante el entrenamiento.

Hemos aprendido cómo guardar y cargar el modelo completo, así como solo el state_dict, que contiene los parámetros aprendidos del modelo. También hemos discutido la importancia de guardar modelos periódicamente durante el entrenamiento y las mejores prácticas para hacerlo. Además, hemos visto cómo guardar y cargar modelos en el mismo dispositivo y las extensiones de archivo comunes utilizadas para modelos de PyTorch.

Recuerda que la clave para dominar estas habilidades es la práctica. Así que no dudes en experimentar con guardar y cargar modelos mientras continúas tu viaje en el aprendizaje profundo con PyTorch. ¡Sigue con el trabajo fantástico y feliz aprendizaje!