En este post te traigo una librería que quizá no conozcas, pero te aseguro que te va a encantar y la vas a usar bastante. Se trata de LazyPredict. Este paquete de Python nos ayudará a saber qué modelos son los mejores para los datos con los que estamos trabajando, sin tener que comerte la cabeza con el análisis exploratorio. Porque recordad, la clave es trabajar de manera inteligente, no mucho.
“Elijo a una persona vaga para hacer un trabajo duro. Porque una persona vaga encontrará una manera fácil de hacerlo.”
Bill Gates
El problema que resuelve LazyPredict
Cuando nos enfrentamos a un proyecto de Machine Learning, tenemos que hacer un análisis de datos e intentar escoger el modelo/modelos que mejor se ajusten a nuestro dataset. Que como ya sabemos, no todos los modelos son óptimos para todo tipo de datos. Por poneros unos ejemplos:
- Para datos con una relación lineal funcionan bien los modelos lineales como la reglog, regresión lineal etc.
- Para datos con la mayoría de variables continuas son buenos los modelos como Gaussian Naive Bayes, regresiones lineales, SVM…
- Para datos un poco más ‘caóticos’ podemos intentar algoritmos por árboles como Random Forest, algoritmos por boosting como GBM o el xGBoost etc.
Aquí es donde entra en juego esta librería. LazyPredict nos permite, con una línea, lanzar una barbaridad de modelos de scikit-Learn con los parámetros por defecto para ver el rendimiento de cada uno de ellos. Esto nos da la ventaja de ver el rendimiento de cada uno de ellos para nuestros datos y poder enfocar en optimizar aquellos que mejor funcionan para nuestros datos.
Cómo usar LazyPredict
Instalación y cómo importarlo
Por suerte, esta librería que os traigo está incluida en pypi.org, así que para instalarla no vamos a tener que indagar para descargarnos un repositorio de Github ni nada. Simplemente chutamos el comando de pip y lo tendremos:
pip install lazypredict
A la hora de importar, también es una sola línea sencilla. Para aprovechar los imports, voy a importar también funciones y datos de sklearn con los que os voy a mostrar el potencial de esta librería.
from lazypredict.Supervised import LazyClassifier, LazyRegressor from sklearn.model_selection import train_test_split from sklearn import datasets import pandas as pd
Ejemplo de regresión
Para este ejemplo vamos a tirar de los datos inmobiliarios de Boston que proporciona scikit.
data = datasets.load_boston() X = pd.DataFrame(data.data, columns=data.feature_names) print(X.shape) print(X.sample(5)) y = data.target print('Min target:', min(y), 'Max target:', max(y))
CRIM | ZN | INDUS | CHAS | NOX | RM | AGE | DIS | RAD | TAX | PTRATIO | B | LSTAT |
0.62356 | 0 | 6.2 | 1 | 0.507 | 6.879 | 77.7 | 3.2721 | 8 | 307 | 17.4 | 390.39 | 9.93 |
15.8603 | 0 | 18.1 | 0 | 0.679 | 5.896 | 95.4 | 1.9096 | 24 | 666 | 20.2 | 7.68 | 24.39 |
0.31827 | 0 | 9.9 | 0 | 0.544 | 5.914 | 83.2 | 3.9986 | 4 | 304 | 18.4 | 390.7 | 18.33 |
12.0482 | 0 | 18.1 | 0 | 0.614 | 5.648 | 87.6 | 1.9512 | 24 | 666 | 20.2 | 291.55 | 14.1 |
3.67367 | 0 | 18.1 | 0 | 0.583 | 6.312 | 51.9 | 3.9917 | 24 | 666 | 20.2 | 388.62 | 10.58 |
Como vemos se trata de un dataset de 506 filas por 13 columnas y un target continuo que va desde 5 a 50. Ahora es cuando entra en juego la magia de LazyPredict. Creamos los datos de entrenamiento y de test con sklearn, y después, con una sola línea de código lanzamos 38 modelos de regresión y podemos observar los resultados:
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.2, random_state=42) models, predictions = LazyRegressor().fit(X_train, X_test, y_train, y_test) print(models[:10])
LazyRegressor nos devuelve 2 variables, los modelos con los datos de entrenamiento y las predicciones de los modelos para los datos de Test. En la tabla a continuación se muestran los 10 primeros modelos para los datos de train. Tened en cuenta de que con LazyRegressor lanzamos 38 modelos. Como métricas para regresión están el R cuadrado y el RMSE por defecto, pero podemos elegir la métrica que queramos con el atributo custom_metric
Model | R-Squared | RMSE | Time Taken |
GradientBoostingRegressor | 0.92 | 2.49 | 0.17 |
XGBRegressor | 0.90 | 2.70 | 0.05 |
LGBMRegressor | 0.89 | 2.83 | 0.06 |
RandomForestRegressor | 0.89 | 2.85 | 0.33 |
BaggingRegressor | 0.88 | 2.98 | 0.04 |
ExtraTreesRegressor | 0.87 | 3.14 | 0.19 |
HistGradientBoostingRegressor | 0.86 | 3.18 | 0.23 |
AdaBoostRegressor | 0.84 | 3.45 | 0.11 |
DecisionTreeRegressor | 0.77 | 4.06 | 0.01 |
KNeighborsRegressor | 0.72 | 4.54 | 0.01 |
Para tener una mejor visualización, vamos tirar de seaborn y representar la métrica que seleccionemos para cada modelo. Además, lo representaremos horizontalmente para que sea más fácil leer los ejes y comparar barras.
import matplotlib.pyplot as plt import seaborn as sns predictions["R-Squared"] = [0 if i < 0 else i for i in predictions.iloc[:,0] ] plt.figure(figsize=(5, 10)) sns.set_theme(style="whitegrid") ax = sns.barplot(y=predictions.index, x="R-Squared", data=predictions) ax.set(xlim=(0, 1))
Ejemplo de clasificación
Una vez visto el ejemplo de regresión, vamos a por el ejemplo de clasificación. Para ello vamos a utilizar el dataset de cáncer de mama que proporciona skLearn:
data = datasets.load_breast_cancer() X = pd.DataFrame(data.data, columns=data.feature_names) print(X.shape) print(X.sample(5)) y = data.target
mean radius | mean texture | mean perimeter | … | worst symmetry | worst fractal dimension |
13.9 | 19.24 | 88.73 | … | 0.2356 | 0.07603 |
11.2 | 29.37 | 70.67 | … | 0.1566 | 0.05905 |
13.24 | 20.13 | 86.87 | … | 0.2845 | 0.1249 |
14.92 | 14.93 | 96.45 | … | 0.2688 | 0.08273 |
23.29 | 26.67 | 158.9 | … | 0.3198 | 0.08762 |
Como vemos se trata de un dataset de 569 filas por 30 columnas y un target binario. Como en el caso de la regresión, ahora tiramos de LazyPredict para entrenar modelos de clasificación con una sola línea y observar los resultados:
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.2, random_state=42) models, predictions = LazyClassifier().fit(X_train, X_test, y_train, y_test) print(models[:10])
Model | Accuracy | Balanced Accuracy | ROC AUC | F1 Score | Time Taken |
BernoulliNB | 0.98 | 0.98 | 0.98 | 0.98 | 0.01 |
PassiveAggressiveClassifier | 0.98 | 0.98 | 0.98 | 0.98 | 0.01 |
SVC | 0.98 | 0.98 | 0.98 | 0.98 | 0.02 |
Perceptron | 0.97 | 0.97 | 0.97 | 0.97 | 0.01 |
AdaBoostClassifier | 0.97 | 0.97 | 0.97 | 0.97 | 0.16 |
LogisticRegression | 0.97 | 0.97 | 0.97 | 0.97 | 0.05 |
SGDClassifier | 0.96 | 0.97 | 0.97 | 0.97 | 0.01 |
ExtraTreeClassifier | 0.96 | 0.97 | 0.97 | 0.97 | 0.01 |
CalibratedClassifierCV | 0.97 | 0.97 | 0.97 | 0.97 | 0.04 |
XGBClassifier | 0.96 | 0.96 | 0.96 | 0.96 | 0.13 |
De nuevo, tirando de seaborn, podemos observar el performance de todos los modelos entrenados con LazyPredict:
plt.figure(figsize=(5, 10)) sns.set_theme(style="whitegrid") ax = sns.barplot(y=predictions.index, x="Accuracy", data=predictions)
Conclusión
Como veis, se trata de una librería muy útil, que nos va a librar de mucho tiempo de diseño de nuestros modelos y que seguro nos facilita escoger el mejor approach
Si te ha gustado este post, no dudes en echar un vistazo a otros que hemos escrito recientemente.
Hola, lazypredict se considera low-code? Gracias!
cordial saludo
muy buen aporte
gracias