Cómo guardar y cargar un modelo de Machine Learning en Python

Después de entrenar un modelo de Machine Learning, volver a entrenarlo cada vez que necesitas una predicción es una pérdida de tiempo y de recursos. La solución es guardar el modelo en un archivo y cargarlo cuando haga falta — en un script, una API o un servicio en producción. Vas a aprender a guardar y cargar un modelo con joblib, la forma más común de hacerlo en el ecosistema scikit-learn, con un ejemplo listo para ejecutar.

Requisitos previos

• Python 3.9 o superior instalado.
• scikit-learn instalado con pip install scikit-learn. joblib ya viene incluido como dependencia.
• Nociones básicas de cómo entrenar un modelo (usamos un ejemplo simple y reproducible).

Paso 1: Entrenar un modelo de ejemplo

Para que el resultado sea reproducible, entrenamos un clasificador sobre el dataset Iris, que ya viene con scikit-learn. Puedes cambiarlo por cualquier modelo tuyo — el proceso de guardado es el mismo.

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)
print("Accuracy:", model.score(X_test, y_test))

Paso 2: Guardar el modelo con joblib.dump

Con el modelo entrenado, guardarlo en disco es una sola línea. La función joblib.dump recibe el objeto del modelo y el nombre del archivo; por convención usamos la extensión .joblib.

import joblib

joblib.dump(model, "iris_model.joblib")

Esto crea el archivo iris_model.joblib en la carpeta actual, con todo lo que el modelo aprendió. scikit-learn recomienda joblib en lugar del pickle estándar porque es más eficiente al guardar objetos con grandes arrays NumPy, como los que hay dentro de bosques o redes neuronales.

Paso 3: Cargar el modelo y hacer una predicción

En otro script — o en otro día — cargas el modelo con joblib.load y lo usas como si acabaras de entrenarlo. Fíjate en que no hace falta llamar a fit de nuevo.

import joblib

loaded_model = joblib.load("iris_model.joblib")

# Predict a new sample (4 measurements of one flower)
new_sample = [[5.1, 3.5, 1.4, 0.2]]
print("Predicted class:", loaded_model.predict(new_sample))

El modelo cargado tiene exactamente el mismo estado que el original, por lo que devuelve las mismas predicciones.

Paso 4: Guardar todo el Pipeline (evita un error común)

Un error muy frecuente es guardar solo el modelo y olvidar el preprocesamiento — por ejemplo, el StandardScaler que normalizó los datos. Si el entrenamiento usó datos transformados, la predicción debe aplicar exactamente la misma transformación. La forma segura es reunir todo en un Pipeline y guardar el pipeline completo en un solo archivo.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("clf", LogisticRegression(max_iter=1000)),
])
pipeline.fit(X_train, y_train)

joblib.dump(pipeline, "iris_pipeline.joblib")

Ahora el archivo guarda la normalización y el modelo. Al cargar el pipeline, el preprocesamiento se aplica automáticamente antes de cada predicción, y dejas de arriesgarte a olvidar un paso.

Verificar el resultado

Para confirmar que el guardado funcionó, compara las predicciones del modelo original con las del modelo cargado — deben ser idénticas:

import numpy as np

original = model.predict(X_test)
loaded = joblib.load("iris_model.joblib").predict(X_test)
print("Identical?", np.array_equal(original, loaded))  # True

Comprueba también que el archivo iris_model.joblib existe en la carpeta. Si aparece un aviso de versión al cargar, asegúrate de usar la misma versión de scikit-learn con la que guardaste, porque versiones distintas pueden causar incompatibilidades.

Seguridad: carga solo archivos .joblib de fuentes en las que confíes. Al igual que pickle, joblib puede ejecutar código al cargar un archivo, así que nunca abras modelos de origen desconocido.

Conclusión

Ya puedes guardar y cargar un modelo con joblib y, más importante, guardar el Pipeline completo para que el preprocesamiento viaje siempre con el modelo. El siguiente paso natural es versionar tus archivos (por ejemplo, iris_model_v1.joblib) y servir las predicciones a través de una API. ¿Qué nombre le vas a poner a tu primer modelo en producción?