Carga de modelo de PyTorch con torch.load()

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.

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

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`: ```python 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: ```python 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 ```python 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: ```python 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()` ```python 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.