Cuando terminamos de entrenar un modelo y estamos conformes con su rendimiento, no queremos repetir todo el proceso cada vez que necesitemos hacer una predicción.
En un proyecto real, lo habitual es:
Eso ahorra tiempo y permite llevar el modelo a otros scripts, servidores o aplicaciones.
Guardar un modelo significa serializar el objeto entrenado para poder recuperarlo más adelante exactamente como quedó después del aprendizaje.
Si además usamos un Pipeline, al guardar el pipeline se conservan también los pasos de preprocesamiento.
En Python suelen usarse dos herramientas muy conocidas:
pickle;joblib.En el ecosistema de Scikit-learn, joblib es una opción muy común y recomendable para guardar modelos.
En general conviene guardar el flujo completo que realmente se usará en producción:
Así te aseguras de que los nuevos datos reciban exactamente el mismo tratamiento que durante el entrenamiento.
En este ejemplo entrenaremos un pipeline con escalado y regresión logística, lo guardaremos con joblib, lo volveremos a cargar y haremos una predicción.
import pandas as pd
import joblib
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
clientes = pd.DataFrame({
"paginas_vistas": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 5, 8],
"minutos_sitio": [1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 3, 4],
"compra": [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1]
})
X = clientes[["paginas_vistas", "minutos_sitio"]]
y = clientes["compra"]
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.25, random_state=42, stratify=y
)
modelo = Pipeline([
("escalador", StandardScaler()),
("clasificador", LogisticRegression())
])
modelo.fit(X_train, y_train)
y_pred = modelo.predict(X_test)
print("Exactitud antes de guardar:", accuracy_score(y_test, y_pred))
joblib.dump(modelo, "modelo_clientes.joblib")
modelo_cargado = joblib.load("modelo_clientes.joblib")
nuevo_cliente = pd.DataFrame({
"paginas_vistas": [7],
"minutos_sitio": [4]
})
prediccion = modelo_cargado.predict(nuevo_cliente)[0]
probabilidad = modelo_cargado.predict_proba(nuevo_cliente)[0, 1]
print("Predicción con el modelo cargado:", prediccion)
print(f"Probabilidad de compra: {probabilidad:.3f}")Salida resumida esperada:
Exactitud antes de guardar: ...
Predicción con el modelo cargado: ...
Probabilidad de compra: ...
Primero entrenamos el pipeline como en cualquier problema supervisado. Después lo guardamos en un archivo con joblib.dump. Luego lo recuperamos con joblib.load y verificamos que sigue sirviendo para predecir.
Eso muestra una idea central: el modelo entrenado puede separarse del proceso de entrenamiento y reutilizarse en otro momento.
Si solo guardáramos la regresión logística, tendríamos que recordar aplicar el mismo escalado manualmente cada vez que llegue un nuevo caso.
En cambio, al guardar el pipeline completo:
joblib.dump(modelo, "modelo_clientes.joblib"): guarda el objeto entrenado en disco.joblib.load("modelo_clientes.joblib"): recupera el objeto guardado.modelo_cargado.predict(...): demuestra que el objeto cargado sigue funcionando como antes.Pipeline([...]): permite conservar preprocesamiento y modelo en un solo archivo.En el simulador del curso no trabajamos con archivos persistentes reales entre sesiones. Por eso, el ejemplo online mostrará la misma idea usando serialización en memoria con joblib, para que se entienda el concepto sin depender del sistema de archivos del navegador.
joblib es una herramienta muy usada para eso en Scikit-learn.