Machine Learning Academy · Lección

Guardado y carga de un pipeline con joblib

Serializará un Pipeline ajustado en disco con joblib.dump y lo volverá a cargar en una sesión nueva de Python para hacer predicciones sin volver a entrenarlo.

Lección 4 de 413 pasos

Guardado y carga de un pipeline con joblib es una lección gratuita de Machine Learning Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Machine Learning Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Machine Learning Academy incluye 4 lecciones en total.

¿Por qué conservar un Pipeline entrenado?

Entrenar un pipeline de aprendizaje automático puede llevar minutos u horas. Una vez ajustado, querrá guardarlo en el disco para poder recargarlo más adelante y realizar predicciones sin volver a entrenarlo. La persistencia también es esencial para la implementación: el entrenamiento se realiza en una máquina de desarrollo y las predicciones se sirven en un servidor de producción. El archivo guardado debe incluir tanto los pasos de preprocesamiento como los pesos del modelo.

Dos opciones de serialización: pickle y joblib

El módulo integrado pickle de Python puede serializar cualquier objeto de Python, incluidos los pipelines de sklearn. joblib es una biblioteca de terceros (incluida con scikit-learn) que generalmente se prefiere para objetos de ML porque es más eficiente con matrices grandes de NumPy —usa mapeo de memoria en lugar de copiar— y puede comprimir automáticamente el archivo de salida.

import pickle
import joblib

# Both approaches work; joblib is recommended for sklearn objects
print('pickle version:', pickle.HIGHEST_PROTOCOL)
import sklearn
print('sklearn version:', sklearn.__version__)

Guardado con joblib.dump

joblib.dump(obj, filename) serializa el pipeline en un archivo. Opcionalmente, puede establecer compress=3 para usar compresión zlib (niveles del 1 al 9; 3 ofrece un equilibrio entre velocidad y tamaño). La función devuelve una lista de los archivos creados. Para la mayoría de los pipelines, se crea un único archivo .pkl o .joblib.

import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', LogisticRegression(C=1.0, max_iter=200))
])
pipe.fit(X, y)

# Save
joblib.dump(pipe, '/tmp/iris_pipeline.joblib')
print('Pipeline saved!')

Carga con joblib.load

joblib.load(filename) deserializa el pipeline y lo convierte de nuevo en un objeto de Python. El pipeline cargado es idéntico al original: tiene los mismos parámetros del escalador ajustado (media y varianza) y los mismos pesos del modelo. Puede llamar inmediatamente a predict, predict_proba o score sin volver a ajustarlo.

import joblib
from sklearn.datasets import load_iris
import numpy as np

X, y = load_iris(return_X_y=True)

# Load the saved pipeline
loaded_pipe = joblib.load('/tmp/iris_pipeline.joblib')

# Predict and verify
predictions = loaded_pipe.predict(X[:5])
print('Predictions:', predictions)
print('Test accuracy:', loaded_pipe.score(X, y).round(4))

Verificación de la fidelidad del recorrido completo

Después de cargarlo, confirme que el pipeline cargado produce predicciones idénticas a las del original. Cualquier diferencia indica un error de serialización o una incompatibilidad de versiones. Una comprobación sencilla consiste en comparar las predicciones elemento por elemento mediante np.array_equal.

import joblib
import numpy as np
from sklearn.datasets import load_iris

X, _ = load_iris(return_X_y=True)

# Reload and compare
loaded = joblib.load('/tmp/iris_pipeline.joblib')

# Reload the original reference predictions
# (in practice, save original predictions before reload)
original_preds = loaded.predict(X)  # use loaded as reference
loaded2 = joblib.load('/tmp/iris_pipeline.joblib')
reloaded_preds = loaded2.predict(X)

print('Predictions match:', np.array_equal(original_preds, reloaded_preds))

Opciones de compresión en joblib

Los pipelines grandes (por ejemplo, uno con un RandomForest de 1000 árboles) pueden ocupar cientos de MB. Use joblib.dump(pipe, path, compress=3) para comprimirlos sobre la marcha. Como alternativa, especifique explícitamente el compresor: compress=('zlib', 3) o compress=('lz4', 1) para obtener la máxima velocidad. LZ4 es el más rápido; zlib genera archivos más pequeños, pero es más lento.

import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
import os

X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())]).fit(X, y)

# Uncompressed
joblib.dump(pipe, '/tmp/pipe_raw.joblib')
# Compressed
joblib.dump(pipe, '/tmp/pipe_compressed.joblib', compress=3)

print('Raw size:', os.path.getsize('/tmp/pipe_raw.joblib'), 'bytes')
print('Compressed size:', os.path.getsize('/tmp/pipe_compressed.joblib'), 'bytes')

Uso de pickle como alternativa

Si joblib no está disponible, pickle funciona con pipelines de sklearn. Use el modo binario ('rb'/'wb') al abrir el archivo. Para modelos pequeños o herramientas puntuales ejecutadas mediante scripts, pickle es perfectamente adecuado; para sistemas de producción que manejan matrices grandes de NumPy, se recomienda encarecidamente joblib.

import pickle
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())]).fit(X, y)

# Save with pickle
with open('/tmp/model.pkl', 'wb') as f:
    pickle.dump(pipe, f)

# Load with pickle
with open('/tmp/model.pkl', 'rb') as f:
    loaded = pickle.load(f)

print('Loaded score:', loaded.score(X, y).round(4))

Advertencias sobre la compatibilidad de versiones

Una cuestión crítica en producción: un pipeline serializado con scikit-learn 1.2 podría no cargarse correctamente con scikit-learn 1.5. Registre siempre las versiones de las bibliotecas utilizadas durante el entrenamiento en un archivo de metadatos junto al modelo guardado. Use pip freeze > requirements.txt o registre las versiones mediante programación y almacénelas junto al archivo del modelo.

import sklearn
import numpy as np
import json
import os

metadata = {
    'sklearn_version': sklearn.__version__,
    'numpy_version': np.__version__,
    'model_file': 'iris_pipeline.joblib'
}

with open('/tmp/model_metadata.json', 'w') as f:
    json.dump(metadata, f, indent=2)

print(json.dumps(metadata, indent=2))

Carga de un pipeline en un script de producción

En un servicio de producción, el flujo de trabajo es el siguiente: cargue el pipeline una vez al iniciar el servicio (no en cada solicitud), reciba las características de entrada, aplique el preprocesamiento mediante las transformaciones integradas del pipeline y devuelva las predicciones. Como el pipeline incluye todo el preprocesamiento, el código del servicio no necesita conocer los detalles del escalado, la codificación ni el PCA: todo está encapsulado en el objeto guardado.

import joblib
import numpy as np

# At startup (once)
model = joblib.load('/tmp/iris_pipeline.joblib')

def predict(sepal_length, sepal_width, petal_length, petal_width):
    features = np.array([[sepal_length, sepal_width, petal_length, petal_width]])
    label = model.predict(features)[0]
    proba = model.predict_proba(features)[0]
    return {'label': int(label), 'confidence': round(float(proba.max()), 4)}

result = predict(5.1, 3.5, 1.4, 0.2)
print('Prediction result:', result)

Consideraciones de seguridad sobre los modelos serializados con pickle

No cargue nunca un archivo pickle de una fuente que no sea de confianza. Los archivos pickle pueden ejecutar código arbitrario al cargarse; esta es una limitación de seguridad fundamental de Python. Para compartir modelos externamente, considere alternativas más seguras y específicas del formato: ONNX para la serialización entre distintos frameworks, o archivos joblib compartidos únicamente dentro de una infraestructura de confianza. Verifique siempre la suma de comprobación del archivo antes de cargarlo.

import hashlib

def file_sha256(path):
    h = hashlib.sha256()
    with open(path, 'rb') as f:
        for chunk in iter(lambda: f.read(65536), b''):
            h.update(chunk)
    return h.hexdigest()

checksum = file_sha256('/tmp/iris_pipeline.joblib')
print('Model SHA-256:', checksum)

# In production: compare this checksum with the one stored in your model registry

Prueba rápida de coherencia de carga y predicción

Otra práctica recomendada final: incluya un script breve de prueba de coherencia en el paquete del modelo que cargue el pipeline, ejecute una entrada conocida y compruebe que la salida coincide con la esperada. Ejecute esta prueba en su pipeline de CI/CD cada vez que el modelo pase a producción, para confirmar que el archivo no está dañado y que el entorno es compatible.

import joblib
import numpy as np

# Sanity test
model = joblib.load('/tmp/iris_pipeline.joblib')

# Known input (setosa): sepal_length=5.1, sepal_width=3.5, petal_length=1.4, petal_width=0.2
X_test = np.array([[5.1, 3.5, 1.4, 0.2]])
pred = model.predict(X_test)[0]

# Iris class 0 = setosa
assert pred == 0, f'Expected setosa (0) but got {pred}'
print('Sanity test PASSED — model predicts setosa correctly.')

Comprobación rápida

Compruebe su comprensión del guardado y la carga de pipelines explicados en esta lección.

Responde en la lección interactiva

Resumen de la lección

En esta lección ha aprendido que joblib.dump y joblib.load guardan y restauran un pipeline ajustado completo, incluidos todos los parámetros de preprocesamiento; que debe registrar siempre las versiones de las bibliotecas junto al modelo guardado para garantizar una carga reproducible; y que nunca debe cargar archivos pickle de fuentes que no sean de confianza, ya que pueden ejecutar código arbitrario. A continuación abordaremos los conjuntos de datos desbalanceados: detectaremos el desbalance de clases y entenderemos por qué la exactitud es una métrica engañosa en ese contexto.

Gratis para empezar

Aprende Python con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 30
Lecciones: 120

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Guardado y carga de un pipeline con joblib» es gratis?

Sí — el texto completo de «Guardado y carga de un pipeline con joblib» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Machine Learning Academy, actualiza a CoddyKit PRO. El curso de Machine Learning Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Guardado y carga de un pipeline con joblib»?

Serializará un Pipeline ajustado en disco con joblib.dump y lo volverá a cargar en una sesión nueva de Python para hacer predicciones sin volver a entrenarlo. Practicas Machine Learning Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Machine Learning Academy?

No se requiere experiencia previa. Machine Learning Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Guardado y carga de un pipeline con joblib»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Machine Learning Academy?

Sí. Cada lección de Machine Learning Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Creación de su primer pipeline: escalador más clasificador
ColumnTransformer dentro de un pipeline
Validación cruzada y búsqueda en cuadrícula de un pipeline completo
Guardado y carga de un pipeline con joblib

← Volver a Machine Learning Academy