Guardado y carga de modelos Sklearn
En el aprendizaje automático, el proceso de entrenamiento de modelos suele llevar mucho tiempo. Para evitar volver a entrenar el modelo cada vez, podemos guardar el modelo entrenado para poder cargarlo y hacer predicciones más adelante.
scikit-learnSe ofrecen dos formas comunes para guardar y cargar modelos:joblibypickle。
1. UsojoblibGuardado y carga de modelos
joblibes una herramienta eficiente de serialización de Python, especialmente adecuada para guardar objetos que contienen una gran cantidad de arreglos numéricos (como arreglos de numpy, modelos de scikit-learn, etc.). En comparación conpickle，joblibes más eficiente al procesar datos a gran escala.
joblib es una biblioteca externa de Python que se puede instalar con el siguiente comando:
pip install joblib
Guardar modelo
joblib proporciona una API sencilla para guardar y cargar objetos.
Podemos usar el método joblib.dump() para guardar el modelo en un archivo.
Ejemplo
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
# Cargar datos
data = load_iris()
X, y = data.data, data.target
# Dividir el conjunto de entrenamiento y el de pruebas
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Crear y entrenar el modelo
model = SVC(kernel='linear')
model.fit(X_train, y_train)
# Guardar el modelo en un archivo
joblib.dump(model, 'svm_model.joblib')
Cargar modelo
Usa el método joblib.load() para cargar el objeto de modelo guardado.
Ejemplo
loaded_model = joblib.load('svm_model.joblib')
# Usar el modelo cargado para hacer predicciones
y_pred = loaded_model.predict(X_test)
# Imprimir los resultados de la predicción
print("Predictions:", y_pred)
Con los pasos anteriores, hemos guardado correctamente el modelo entrenado en un archivo y podemos cargar el modelo y realizar predicciones en cualquier momento posterior.
2. Uso de pickle para guardar y cargar modelos
pickle es un módulo integrado de Python que permite serializar y deserializar objetos de Python.
Aunque joblib es más adecuado para manejar grandes cantidades de datos, pickle también es una herramienta comúnmente utilizada para guardar y cargar modelos, adecuada para situaciones generales.
Guardar modelo
Al igual que joblib, pickle también tiene una API sencilla para guardar y cargar objetos.
El código para guardar el modelo es el siguiente:
Ejemplo
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
# Cargar datos
data = load_iris()
X, y = data.data, data.target
# Dividir el conjunto de entrenamiento y el de pruebas
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Crear y entrenar el modelo
model = SVC(kernel='linear')
model.fit(X_train, y_train)
# Guardar el modelo usando pickle
with open('svm_model.pkl', 'wb') as f:
pickle.dump(model, f)
Cargar modelo
Usa pickle.load() para cargar el modelo:
Ejemplo
with open('svm_model.pkl', 'rb') as f:
loaded_model = pickle.load(f)
# Usar el modelo cargado para hacer predicciones
y_pred = loaded_model.predict(X_test)
# Imprimir los resultados de la predicción
print("Predictions:", y_pred)
3、joblib vs pickle
joblib y pickle son dos métodos comunes para guardar y cargar modelos.
joblib es más adecuado para guardar objetos de datos grandes, mientras que pickle es la herramienta estándar de serialización de Python, adecuada para situaciones generales.
joblib: normalmente adecuado para guardar objetos que contienen grandes cantidades de datos numéricos (como arreglos de numpy).joblibAl procesar datos a gran escala,picklees más eficiente.pickle: adecuado para guardar objetos más pequeños u objetos de Python comunes. Es una biblioteca integrada de Python, por lo que no requiere instalación adicional.
Si el modelo contiene una gran cantidad de arreglos o matrices numéricas (como máquinas de vectores de soporte, bosques aleatorios, etc.), se recomienda usar joblib, que es más eficiente que pickle. Para modelos más pequeños o que no contienen grandes cantidades de datos numéricos, pickle es suficiente.
4. Guardar y cargar el Pipeline
En aplicaciones reales, el modelo no es solo un modelo único; a veces combina múltiples pasos de procesamiento (como preprocesamiento de datos, selección de características, entrenamiento del modelo, etc.). Estos pasos se pueden realizar con el Pipeline de scikit-learn. Pipeline también se puede guardar y cargar con joblib o pickle.
Guardar el Pipeline:
Ejemplo
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
import joblib
# Crear un Pipeline
pipeline = Pipeline([
('scaler', StandardScaler()),
('svc', SVC(kernel='linear'))
])
# Entrenar el Pipeline
pipeline.fit(X_train, y_train)
# Guardar el Pipeline en un archivo
joblib.dump(pipeline, 'pipeline_model.joblib')
Cargar el Pipeline:
Ejemplo
loaded_pipeline = joblib.load('pipeline_model.joblib')
# Usar el Pipeline cargado para hacer predicciones
y_pred = loaded_pipeline.predict(X_test)
# Imprimir los resultados de la predicción
print("Predictions:", y_pred)
El proceso de guardar y cargar el Pipeline es el mismo que para un modelo único; solo asegúrate de guardar y cargar todo el objeto Pipeline.
5. Gestión de versiones de modelos
En aplicaciones reales de aprendizaje automático, la actualización y la gestión de versiones de modelos son cruciales. Cada vez que se entrena y guarda un modelo, es recomendable agregar una marca de tiempo o un número de versión al nombre del archivo del modelo para distinguir las diferentes versiones. Por ejemplo:
Ejemplo
# Crear una marca de tiempo
timestamp = time.strftime("%Y%m%d-%H%M%S")
# Guardar el modelo con marca de tiempo
joblib.dump(model, f'svm_model_{timestamp}.joblib')
De esta manera, podemos gestionar las diferentes versiones del modelo según la marca de tiempo, lo que facilita el seguimiento y la actualización del modelo.
6. Persistencia con el modelo
Una vez que el modelo está entrenado y guardado, podemos cargarlo en aplicaciones prácticas posteriores para hacer predicciones sin tener que volver a entrenarlo.
Por ejemplo, podemos integrar el modelo guardado con servicios web, trabajos por lotes u otras aplicaciones, de modo que el modelo pueda ser reutilizado sin necesidad de volver a entrenarlo.
Uso del modelo cargado en servicios web
Por ejemplo, supongamos que estamos usando Flask para crear un servicio web simple que proporcione un servicio de predicción de modelos a través de una API. En este caso, podemos cargar el modelo guardado para hacer predicciones en tiempo real.
Ejemplo
import joblib
import numpy as np
app = Flask(__name__)
# Cargar el modelo
model = joblib.load('svm_model.joblib')
@app.route('/predict', methods=['POST'])
def predict():
data = request.get_json() # Obtener los datos de entrada
features = np.array(data['features']).reshape(1, -1) # Convertir a un formato adecuado para la predicción
prediction = model.predict(features) # Usar el modelo cargado para hacer predicciones
return jsonify({'prediction': prediction.tolist()}) # Devolver el resultado de la predicción
if __name__ == '__main__':
app.run(debug=True)