Cómo cargar pesos desde Hugging Face en PyTorch

Cursos Empresas Blog Live Conf Precios

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

Cómo cargar pesos desde Hugging Face en PyTorch

Resumen

Recuperar un modelo entrenado desde el hub de Hugging Face te permite continuar un entrenamiento o ejecutar inferencia sin volver a entrenar desde cero. Aquí verás cómo cargar pesos en PyTorch usando un checkpoint, inicializar un modelo nuevo y validar la predicción con un ejemplo real.

¿Cómo descargo un checkpoint desde Hugging Face Hub?

El flujo empieza con la función load de PyTorch, que lee el archivo .pth guardado en tu carpeta local de weights. Ese archivo contiene un diccionario con el estado de los pesos previamente entrenados.

python checkpoint = torch.load('weights/model-checkpoint.pth')

Una vez cargado, tienes acceso a varias llaves dentro del diccionario: el estado del modelo, el estado del optimizador, la época y la pérdida. Cada una se usará para reconstruir el entorno tal como estaba al momento de guardar.

¿Qué es un checkpoint en PyTorch? Es un diccionario que guarda los pesos del modelo, los parámetros del optimizador y métricas como la época y la loss, para poder reanudar el entrenamiento o hacer inferencia.

¿Cómo inicializo un modelo nuevo con los mismos parámetros?

Necesitas crear una instancia con la misma estructura original: número de clases, tamaño del vocabulario y tamaño del embedding. A esa nueva instancia la llamamos modelo2, y al optimizador optimizer2, ambos espejo de los originales.

Inicializa modelo2 con los hiperparámetros originales del clasificador de texto.
Inicializa optimizer2 con torch.optim.SGD y una tasa de aprendizaje de 0.2.
Mantén la arquitectura idéntica; los pesos llegarán después con load_state_dict.

Después de instanciar, los pesos siguen siendo aleatorios. La transferencia real ocurre con load_state_dict, que copia los tensores entrenados al nuevo modelo.

python modelo2.load_state_dict(checkpoint['model_state_dict']) optimizer2.load_state_dict(checkpoint['optimizer_state_dict'])

Si todo cuadra, PyTorch responde con all keys matched successfully, confirmando que los parámetros entrenables se transfirieron correctamente.

¿Por qué aparece el error "SGD object is not subscriptable"?

Este error ocurre cuando guardaste el optimizador completo en lugar de su state_dict. Es un detalle pequeño pero crítico: PyTorch necesita el diccionario, no el objeto del optimizador.

¿Cómo soluciono el error "object is not subscriptable" al cargar un optimizador? Asegúrate de guardar optimizer.state_dict() dentro del checkpoint, no el optimizador completo. Solo el diccionario es subscriptable y permite la transferencia de parámetros.

La corrección consiste en regresar al código donde construyes el checkpoint, reemplazar el objeto por su state_dict(), volver a guardar el archivo y subirlo de nuevo al hub de Hugging Face usando upload_file con la API.

¿Qué pasos sigo para reemplazar el checkpoint en el hub?

Corrige el guardado del optimizador con optimizer.state_dict().
Sube el nuevo model-checkpoint.pth con upload_file de la API.
Elimina el archivo erróneo local con remove weights/model-checkpoint.pth.
Descarga la versión corregida desde el hub al directorio weights.

Un detalle importante: si no borras el archivo viejo, tu entorno local seguirá leyendo la versión errónea. Hugging Face conserva el historial de commits, así que puedes revisar cuándo se subió cada versión.

¿Cómo recupero la época y la pérdida del entrenamiento previo?

El checkpoint también guarda metadatos del entrenamiento. Esto te sirve si quieres reanudar exactamente desde donde te quedaste, sin perder el contador de épocas ni la última loss registrada.

python epoch2 = checkpoint['epoch'] loss2 = checkpoint['loss']

Con estas variables puedes reanudar el bucle de entrenamiento moviendo modelo2 al device CUDA, o quedarte en CPU si solo harás inferencia. Para inferencia no necesitas GPU, así que mover el modelo a CPU es suficiente y ahorra recursos.

¿Cómo pruebo el modelo cargado con un ejemplo de inferencia?

Para validar que los pesos son los correctos, basta con un texto de prueba. En el ejercicio se usó una descripción del ajolote como entrada al clasificador de texto, pasándola por el text_pipeline que convierte palabras al vocabulario del modelo.

La predicción se mapea con el diccionario divipedia_label, que traduce el número de clase a una etiqueta legible en inglés. El resultado para el texto del ajolote fue la categoría animal, lo que confirma que los pesos descargados funcionan como se esperaba.

Mueve el modelo a CPU con modelo2.cpu() antes de inferir.
Aplica text_pipeline al ejemplo para tokenizarlo según el vocabulario.
Mapea la predicción numérica a texto usando divipedia_label.

Este ciclo completo, guardar, subir, descargar, cargar y predecir, te da un flujo reproducible para versionar modelos en Hugging Face. ¿En qué otros proyectos aplicarías este patrón de checkpointing? Cuéntanos en los comentarios qué casos te gustaría explorar.

Comentarios

Miguel Rodríguez

Estudiante

Para poder hacer inferencia con el nuevo modelo faltaron algunos detalles: | Es necesario guardar el archivo de vocabulario para usarlo en el nuevo entorno.

# guardar vocabulario creado con el dataset
torch.save(vocab, 'vocab.pt')

#carga del vocabulario:
vocab = torch.load('vocab.pt')

E importar el tokenizador con el que fue creado para definir el text_pipeline

from torchtext.data.utils import get_tokenizer

tokenizer = get_tokenizer("TU_TOKENIZADOR")

# Definir text pipeline
text_pipeline = lambda x: vocab(tokenizer(x))

Y después de agregar esto podemos hacer inferencia con el modelo.

Carlos Alejandro Sanchez Aceves

Estudiante

Al final no se está haciendo la predicción con el model_cpu, ya que la función predict() utiliza el modelo entrenado desde el principio, creo que una buena forma que podríamos solucionar esto, es hacer que a las funciones como predic(), train(), eval(), etc. reciban como parámetro el modelo que se quiere utilizar.

Miguel Rodríguez

Estudiante

Descubrí como solucionar el problema, te dejo el enlace

Luis Camilo Jimenez Alvarez

Estudiante

no sólo eso, predict lo debes modificar, ya que como default está en model.train() por lo cual hay que incluir model.eval() en predict, para que no genere error.

def predict(model, text, text_pipeline):
  model.eval()
  with torch.no_grad():
    text = torch.tensor(text_pipeline(text))
    opt_mod = torch.compile(model, mode='reduce-overhead')
    output = opt_mod(text, torch.tensor([0]))
    return output.argmax(1).item() + 1

Miguel Rodríguez

Estudiante

Escribí un tutorial con un enlace a un colab en el que muestro la manera de cargar el modelo ya entrenado y hacer predicciones con éste.

Tutorial

JOSE LUIS ALCOCER CACERES

Estudiante

No sé a quién más le suceda, pero el ejemplo 2 no me dice que es categoría animal, jaja. Por cierto la manera correcta de hacer el predict es:

model = modelo2.to("cpu")

ejemplo = "Axolotls are animals and animals and tigers and lions animals animals ."

def inference(text, texto_pipeline, model):
  with torch.no_grad():
    model.eval()
    text = torch.tensor(texto_pipeline(text))
    opt_mod = torch.compile(model, mode = 'reduce-overhead') 
    output = opt_mod(text, torch.tensor([0])) 
    return output.argmax(1).item() + 1 

print(f"El ejemplo es de la categoria {DBpedia_label[inference(ejemplo, texto_pipeline, model)]}")

Mario Alexander Vargas Celis

Estudiante

La función torch.load() se utiliza en PyTorch para cargar un modelo previamente guardado. Esta función puede cargar tanto el estado de los parámetros del modelo (usando state\_dict()) como el modelo completo, dependiendo de cómo se haya guardado el archivo.

Aquí te explico las dos formas más comunes de cargar un modelo en PyTorch:

### 1. Cargar solo el state\_dict()

Cuando guardas solo los pesos y parámetros del modelo (usando torch.save(model.state\_dict())), puedes cargarlo y reinstanciar el modelo de la siguiente manera:

#### Guardar el state\_dict() del modelo

Supongamos que tienes un modelo llamado TextClassificationModel:


import torch



\# Definir el modelo (debe coincidir con la arquitectura original)

model = TextClassificationModel(VOCAB\_SIZE, EMBED\_DIM, NUM\_CLASS)



\# Guardar solo los pesos (state\_dict)

torch.save(model.state\_dict(), "mi\_modelo.pth")

#### Cargar el state\_dict()

Para cargar los pesos guardados y asignarlos a una nueva instancia del modelo:


import torch



\# Reinstanciar el modelo (debe tener la misma arquitectura)

model\_cargado = TextClassificationModel(VOCAB\_SIZE, EMBED\_DIM, NUM\_CLASS)



\# Cargar el state\_dict en el modelo

model\_cargado.load\_state\_dict(torch.load("mi\_modelo.pth"))



\# Poner el modelo en modo de evaluación (opcional pero recomendado para inferencias)

model\_cargado.eval()

Es importante que la estructura del modelo que definas al cargar el state\_dict() sea idéntica a la del modelo que usaste al guardar los pesos.

### 2. Cargar el modelo completo

También puedes guardar el modelo completo, incluyendo tanto la arquitectura como los pesos. Para hacerlo, necesitas guardar la instancia completa del modelo:

#### Guardar el modelo completo


import torch



\# Guardar el modelo completo

torch.save(model, "mi\_modelo\_completo.pth")

#### Cargar el modelo completo

Para cargar el modelo completo en otro script o entorno:


import torch



\# Cargar el modelo completo (incluyendo la arquitectura y los pesos)

model\_cargado = torch.load("mi\_modelo\_completo.pth")



\# Poner en modo de evaluación

model\_cargado.eval()

### Diferencias entre ambos métodos

- **Cargar el state\_dict()**: Este método es más flexible y es el más recomendado en la mayoría de los casos, ya que te permite cargar solo los pesos en un modelo predefinido. Esto puede ser útil si cambias algunos aspectos de tu código o realizas ajustes en la arquitectura.

- **Cargar el modelo completo**: Este método guarda tanto la arquitectura del modelo como los pesos. Es útil si necesitas cargar todo sin tener que definir la arquitectura del modelo nuevamente, pero es menos flexible si tu código cambia.

### Consideraciones al usar torch.load()

- **Dispositivos**: Si los modelos fueron entrenados en GPU y deseas cargarlos en CPU, o viceversa, asegúrate de especificar el dispositivo al cargar:

- Para cargar en CPU:

```python

model = torch.load("mi_modelo_completo.pth", map_location=torch.device('cpu'))

```

- Para cargar en GPU (si tienes disponible):

```python

model = torch.load("mi_modelo_completo.pth", map_location=torch.device('cuda'))

```

### Ejemplo completo de carga de un modelo con torch.load()


import torch



\# Definir el modelo (en caso de usar state\_dict)

model\_cargado = TextClassificationModel(VOCAB\_SIZE, EMBED\_DIM, NUM\_CLASS)



\# Cargar los pesos guardados

model\_cargado.load\_state\_dict(torch.load("mi\_modelo.pth", map\_location=torch.device('cpu')))



\# Poner el modelo en modo de evaluación para inferencias

model\_cargado.eval()



\# Realizar una inferencia (ejemplo con datos de entrada)

texto = \["Ejemplo de texto para clasificar"]

tokens = tokenizador(texto\[0])  # Suponiendo que tienes un tokenizador

ids = torch.tensor(\[vocab\[token] for token in tokens])  # Convertir a IDs



\# Hacer la predicción

output = model\_cargado(ids.unsqueeze(0))  # Añadir dimensión de batch

prediccion = output.argmax(1).item()  # Obtener la clase predicha



print("Clase predicha:", prediccion)

Con estos pasos, puedes cargar un modelo previamente entrenado y usarlo para realizar inferencias o continuar con el entrenamiento.

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