El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Guardar y Cargar Modelos

Siguiente ►
►

En este tema, aprenderemos cómo guardar y cargar modelos en PyTorch. Esta es una habilidad crucial para cualquier proyecto de aprendizaje profundo, ya que permite guardar el estado de un modelo entrenado y reutilizarlo más tarde sin tener que volver a entrenarlo desde cero.

Conceptos Clave

  1. Estado del Modelo (state_dict): En PyTorch, el estado del modelo se guarda en un diccionario llamado state_dict. Este diccionario contiene todos los parámetros del modelo (pesos y sesgos).
  2. Guardar el Modelo: Utilizamos la función torch.save para guardar el state_dict del modelo en un archivo.
  3. Cargar el Modelo: Utilizamos la función torch.load para cargar el state_dict desde un archivo y la función load_state_dict para actualizar el modelo con los parámetros cargados.

Guardar el Modelo

Para guardar un modelo en PyTorch, seguimos estos pasos:

  1. Entrenar el Modelo: Entrena tu modelo como lo harías normalmente.
  2. Guardar el state_dict: Utiliza torch.save para guardar el state_dict del modelo.

Ejemplo Práctico

import torch
import torch.nn as nn
import torch.optim as optim

# Definimos una red neuronal simple
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.fc2 = nn.Linear(50, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Inicializamos el modelo, el optimizador y la función de pérdida
model = SimpleNN()
optimizer = optim.SGD(model.parameters(), lr=0.01)
criterion = nn.MSELoss()

# Simulamos un entrenamiento
for epoch in range(100):
    # Aquí iría el código de entrenamiento
    pass

# Guardamos el estado del modelo
torch.save(model.state_dict(), 'model.pth')
print("Modelo guardado en 'model.pth'")

Cargar el Modelo

Para cargar un modelo en PyTorch, seguimos estos pasos:

  1. Crear una Instancia del Modelo: Crea una instancia del modelo que tenga la misma arquitectura que el modelo guardado.
  2. Cargar el state_dict: Utiliza torch.load para cargar el state_dict desde el archivo y load_state_dict para actualizar el modelo.

Ejemplo Práctico

# Creamos una nueva instancia del modelo
model = SimpleNN()

# Cargamos el estado del modelo
model.load_state_dict(torch.load('model.pth'))
print("Modelo cargado desde 'model.pth'")

# Ahora el modelo está listo para ser usado
model.eval()  # Ponemos el modelo en modo de evaluación

Ejercicio Práctico

Ejercicio 1: Guardar y Cargar un Modelo

  1. Entrena un modelo simple: Usa cualquier conjunto de datos pequeño para entrenar un modelo simple.
  2. Guarda el modelo: Guarda el state_dict del modelo en un archivo.
  3. Cargar el modelo: Carga el state_dict desde el archivo y verifica que el modelo cargado produce las mismas predicciones que el modelo original.

Solución

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Generamos datos de ejemplo
X, y = make_regression(n_samples=1000, n_features=10, noise=0.1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Normalizamos los datos
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Convertimos los datos a tensores
X_train = torch.tensor(X_train, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.float32).view(-1, 1)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_test = torch.tensor(y_test, dtype=torch.float32).view(-1, 1)

# Definimos una red neuronal simple
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.fc2 = nn.Linear(50, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Inicializamos el modelo, el optimizador y la función de pérdida
model = SimpleNN()
optimizer = optim.SGD(model.parameters(), lr=0.01)
criterion = nn.MSELoss()

# Entrenamos el modelo
for epoch in range(100):
    model.train()
    optimizer.zero_grad()
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    loss.backward()
    optimizer.step()

# Guardamos el estado del modelo
torch.save(model.state_dict(), 'model.pth')

# Creamos una nueva instancia del modelo
model_loaded = SimpleNN()

# Cargamos el estado del modelo
model_loaded.load_state_dict(torch.load('model.pth'))

# Verificamos que el modelo cargado produce las mismas predicciones
model_loaded.eval()
with torch.no_grad():
    original_outputs = model(X_test)
    loaded_outputs = model_loaded(X_test)
    print("Diferencia entre las predicciones del modelo original y el cargado:", torch.sum(original_outputs - loaded_outputs).item())

Conclusión

En esta sección, hemos aprendido cómo guardar y cargar modelos en PyTorch utilizando el state_dict. Esta habilidad es esencial para cualquier proyecto de aprendizaje profundo, ya que permite guardar el progreso del entrenamiento y reutilizar modelos entrenados sin tener que volver a entrenarlos desde cero. En el siguiente módulo, profundizaremos en las Redes Neuronales Convolucionales (CNNs), una arquitectura clave para el procesamiento de imágenes.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados