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))

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

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

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])

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 para solventar el problema al que nos enfrentemos.

Si te ha gustado este post, no dudes en echar un vistazo a otros que hemos escrito recientemente.