Cómo cargar pesos desde Hugging Face en PyTorch
Contenido del curso
Miguel Rodríguez
Carlos Alejandro Sanchez Aceves
Miguel Rodríguez
Luis Camilo Jimenez Alvarez
Miguel Rodríguez
JOSE LUIS ALCOCER CACERES
Mario Alexander Vargas Celis
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.
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.
Descubrí como solucionar el problema, te dejo el enlace
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
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.
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)]}")
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.
