html
Guía Integral para Construir y Desplegar Modelos de Aprendizaje Automático con Python y XGBoost
En el campo en rápida evolución de la ciencia de datos, la habilidad de construir, evaluar y desplegar modelos de aprendizaje automático es una habilidad crítica. Ya sea que estés prediciendo patrones climáticos, analizando el comportamiento de los clientes o automatizando procesos de toma de decisiones, dominar estos pasos puede mejorar significativamente la efectividad y escalabilidad de tus proyectos. Esta guía proporciona un enfoque integral y paso a paso para construir y desplegar un modelo de aprendizaje automático usando Python, con un enfoque en el potente algoritmo XGBoost. Nos adentraremos en el preprocesamiento de datos, la selección de características, el entrenamiento del modelo, la evaluación y el despliegue, apoyados por ejemplos prácticos de código de los Jupyter Notebooks.
Tabla de Contenidos
- Introducción al Despliegue de Modelos de Aprendizaje Automático
- Preparación y Preprocesamiento de Datos
- Importación de Bibliotecas y Datos
- Manejo de Valores Faltantes
- Codificación de Características Categóricas
- Selección de Características
- Entrenamiento y Evaluación del Modelo
- K-Nearest Neighbors (KNN)
- Regresión Logística
- Gaussian Naive Bayes
- Máquina de Vectores de Soporte (SVM)
- Árbol de Decisión
- Random Forest
- AdaBoost
- XGBoost
- Guardar y Cargar Modelos con Pickle
- Realizar Predicciones con el Modelo Desplegado
- Desplegar el Modelo en una Aplicación Web
- Conclusión
1. Introducción al Despliegue de Modelos de Aprendizaje Automático
Desplegar un modelo de aprendizaje automático implica varios pasos críticos más allá de simplemente construir y entrenar el modelo. Incluye preparar los datos, seleccionar las características adecuadas, entrenar múltiples modelos, evaluar su rendimiento y, finalmente, desplegar el modelo con mejor rendimiento en un entorno de producción donde pueda proporcionar predicciones en tiempo real. Esta guía te lleva a través de cada una de estas etapas usando Python y XGBoost, una biblioteca de alto rendimiento optimizada para velocidad y precisión.
2. Preparación y Preprocesamiento de Datos
Importación de Bibliotecas y Datos
El primer paso en cualquier proyecto de aprendizaje automático es la preparación de datos. Esto implica importar las bibliotecas necesarias y cargar el conjunto de datos.
|
|
import pandas as pd import seaborn as sns # Load the dataset data = pd.read_csv('weatherAUS - tiny.csv') data.tail() |
Salida:
|
|
Date Location MinTemp MaxTemp Rainfall Evaporation Sunshine WindGustDir WindGustSpeed WindDir9am ... RainToday RISK_MM RainTomorrow 9994 04/01/2012 CoffsHarbour 19.6 28.6 0.0 7.4 10.0 NE 56.0 NNW ... No 0.6 No 9995 05/01/2012 CoffsHarbour 21.3 26.5 0.6 7.6 6.4 NNE 31.0 S ... No 0.0 No 9996 06/01/2012 CoffsHarbour 18.4 27.6 0.0 5.0 10.6 SSW 56.0 N ... No 0.0 No 9997 07/01/2012 CoffsHarbour 18.3 26.1 0.0 7.6 9.0 SW 28.0 SW ... No 0.0 No 9998 08/01/2012 CoffsHarbour 21.4 29.2 0.0 5.8 12.8 NNE 61.0 N ... No 2.0 Yes |
Manejo de Valores Faltantes
Manejar datos faltantes es crucial para construir modelos confiables. Aquí, usamos SimpleImputer de Scikit-learn para manejar valores faltantes tanto en columnas numéricas como categóricas.
|
|
import numpy as np from sklearn.impute import SimpleImputer # Handling missing numeric data imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean') numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0]) imp_mean.fit(X.iloc[:, numerical_cols]) X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols]) # Handling missing categorical data string_cols = list(np.where((X.dtypes == np.object))[0]) imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent') imp_mode.fit(X.iloc[:, string_cols]) X.iloc[:, string_cols] = imp_mode.transform(X.iloc[:, string_cols]) |
Codificación de Características Categóricas
Los algoritmos de aprendizaje automático requieren entradas numéricas. Por lo tanto, codificamos las características categóricas utilizando métodos de codificación de etiquetas y codificación one-hot.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
from sklearn import preprocessing from sklearn.compose import ColumnTransformer from sklearn.preprocessing import OneHotEncoder # Label Encoding function def LabelEncoderMethod(series): le = preprocessing.LabelEncoder() le.fit(series) print('Encoding values', le.transform(pd.unique(series))) return le.transform(series) # One Hot Encoding function def OneHotEncoderMethod(indices, data): columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices)], remainder='passthrough') return columnTransformer.fit_transform(data) # Encoding selection function def EncodingSelection(X, threshold=10): string_cols = list(np.where((X.dtypes == np.object))[0]) one_hot_encoding_indices = [] for col in string_cols: length = len(pd.unique(X[X.columns[col]])) if length == 2 or length > threshold: X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]]) else: one_hot_encoding_indices.append(col) X = OneHotEncoderMethod(one_hot_encoding_indices, X) return X # Apply encoding X = EncodingSelection(X) print(X.shape) # Output: (9999, 25) |
3. Selección de Características
Seleccionar las características adecuadas mejora el rendimiento del modelo y reduce los costos computacionales. Usamos SelectKBest con la prueba estadística Chi-Cuadrado (chi2) para seleccionar las 5 mejores características.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
from sklearn.feature_selection import SelectKBest, chi2 from sklearn import preprocessing # Initialize SelectKBest and MinMaxScaler kbest = SelectKBest(score_func=chi2, k=10) MMS = preprocessing.MinMaxScaler() K_features = 5 # Fit and transform the features x_temp = MMS.fit_transform(X) x_temp = kbest.fit(x_temp, y) # Select top features best_features = np.argsort(x_temp.scores_)[-K_features:] features_to_delete = np.argsort(x_temp.scores_)[:-K_features] X = np.delete(X, features_to_delete, axis=1) print(X.shape) # Output: (9999, 5) |
4. Entrenamiento y Evaluación del Modelo
Con los datos preparados, los dividimos en conjuntos de entrenamiento y prueba y construimos múltiples modelos de clasificación para determinar cuál tiene el mejor rendimiento.
División de Entrenamiento y Prueba
|
|
from sklearn.model_selection import train_test_split # Split the data X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1) print(X_train.shape) # Output: (7999, 5) |
Escalado de Características
Escalar las características es esencial para algoritmos como KNN y SVM, que son sensibles a la escala de los datos de entrada.
|
|
from sklearn import preprocessing # Initialize and fit the scaler sc = preprocessing.StandardScaler(with_mean=False) sc.fit(X_train) # Transform the data X_train = sc.transform(X_train) X_test = sc.transform(X_test) print(X_train.shape) # Output: (7999, 5) print(X_test.shape) # Output: (2000, 5) |
Construcción de Modelos de Clasificación
K-Nearest Neighbors (KNN)
|
|
from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score # Initialize and train KNN knnClassifier = KNeighborsClassifier(n_neighbors=3) knnClassifier.fit(X_train, y_train) # Make predictions y_pred = knnClassifier.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.8455 |
Regresión Logística
|
|
from sklearn.linear_model import LogisticRegression # Initialize and train Logistic Regression LRM = LogisticRegression(random_state=0, max_iter=200) LRM.fit(X_train, y_train) # Make predictions y_pred = LRM.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.869 |
Gaussian Naive Bayes
|
|
from sklearn.naive_bayes import GaussianNB # Initialize and train GaussianNB model_GNB = GaussianNB() model_GNB.fit(X_train, y_train) # Make predictions y_pred = model_GNB.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.822 |
Máquina de Vectores de Soporte (SVM)
|
|
from sklearn.svm import SVC # Initialize and train SVC model_SVC = SVC() model_SVC.fit(X_train, y_train) # Make predictions y_pred = model_SVC.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.87 |
Árbol de Decisión
|
|
from sklearn.tree import DecisionTreeClassifier # Initialize and train Decision Tree model_DTC = DecisionTreeClassifier() model_DTC.fit(X_train, y_train) # Make predictions y_pred = model_DTC.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.8335 |
Random Forest
|
|
from sklearn.ensemble import RandomForestClassifier # Initialize and train Random Forest model_RFC = RandomForestClassifier(n_estimators=500, max_depth=5) model_RFC.fit(X_train, y_train) # Make predictions y_pred = model_RFC.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.873 |
AdaBoost
|
|
from sklearn.ensemble import AdaBoostClassifier # Initialize and train AdaBoost model_ABC = AdaBoostClassifier() model_ABC.fit(X_train, y_train) # Make predictions y_pred = model_ABC.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.8715 |
XGBoost
XGBoost es reconocido por su eficiencia y rendimiento, especialmente en el manejo de conjuntos de datos grandes.
|
|
import xgboost as xgb # Initialize and train XGBoost model_xgb = xgb.XGBClassifier(use_label_encoder=False) model_xgb.fit(X_train, y_train) # Make predictions y_pred = model_xgb.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.865 |
Nota: Durante el entrenamiento, podrías recibir una advertencia respecto a la métrica de evaluación predeterminada en XGBoost. Puedes establecer el parámetro eval_metric explícitamente para suprimir esta advertencia.
|
|
model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss') |
5. Guardar y Cargar Modelos con Pickle
Una vez que has identificado el modelo con mejor rendimiento, guardarlo para uso futuro es esencial. La biblioteca pickle de Python permite una fácil serialización y deserialización de modelos.
Guardar el Modelo
|
|
import pickle # Save the XGBoost model file_name = 'model_xgb.pkl' pickle.dump(model_xgb, open(file_name, 'wb')) |
Cargar el Modelo
|
|
# Load the saved model saved_model = pickle.load(open('model_xgb.pkl', 'rb')) # Verify the loaded model y_pred = saved_model.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.865 |
6. Realizar Predicciones con el Modelo Desplegado
Con el modelo guardado, ahora puedes hacer predicciones sobre nuevos datos. A continuación, se muestra cómo cargar el modelo y utilizarlo para predecir nuevas instancias.
|
|
import pickle import numpy as np # Load the model saved_model = pickle.load(open('model_xgb.pkl', 'rb')) # New data instance new_data = np.array([[0.02283472, 3.93934668, 1.95100361, 2.12694147, 0 ]]) # Make prediction prediction = saved_model.predict(new_data) print(prediction) # Output: [1] |
7. Desplegar el Modelo en una Aplicación Web
Desplegar tu modelo de aprendizaje automático permite que otros interactúen con él a través de una interfaz web. Supongamos que creas una aplicación web con un formulario donde los usuarios pueden ingresar valores de características. El backend puede cargar el archivo model_xgb.pkl guardado, procesar la entrada y devolver la predicción.
Flujo de Trabajo de Ejemplo:
- Frontend: El usuario ingresa los valores de las características en un formulario.
- Backend:
- Recibir los datos de entrada.
- Preprocesar los datos (por ejemplo, escalado, codificación).
- Cargar el
model_xgb.pkl usando pickle.
- Realizar una predicción.
- Respuesta: Mostrar el resultado de la predicción al usuario.
Código de Ejemplo en Python Flask:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
from flask import Flask, request, jsonify import pickle import numpy as np app = Flask(__name__) # Load the trained model model = pickle.load(open('model_xgb.pkl', 'rb')) @app.route('/predict', methods=['POST']) def predict(): data = request.get_json(force=True) # Extract features from the request features = [data['feature1'], data['feature2'], data['feature3'], data['feature4'], data['feature5']] # Convert to numpy array final_features = np.array([features]) # Make prediction prediction = model.predict(final_features) # Return the result return jsonify({'prediction': int(prediction[0])}) if __name__ == '__main__': app.run(debug=True) |
Esta aplicación Flask crea un endpoint de API /predict que acepta solicitudes POST con datos JSON. Procesa la entrada, hace una predicción usando el modelo XGBoost cargado y devuelve el resultado en formato JSON.
8. Conclusión
Construir y desplegar modelos de aprendizaje automático implica una serie de pasos metódicos, desde el preprocesamiento de datos y la selección de características hasta el entrenamiento del modelo, la evaluación y el despliegue. Utilizar bibliotecas potentes como XGBoost y herramientas como Jupyter Notebooks y Flask puede agilizar este proceso, haciéndolo eficiente y escalable. Siguiendo esta guía integral, puedes desarrollar modelos de aprendizaje automático robustos y desplegarlos efectivamente para satisfacer tus necesidades específicas.
Recursos Adicionales
Al integrar estas prácticas y aprovechar los fragmentos de código proporcionados, puedes mejorar la precisión de tus proyectos de aprendizaje automático y desplegar modelos sin problemas en entornos de producción.
