Cómo ejecutar 40 modelos de regresión con unas pocas líneas de código

Aprende a ejecutar más de 40 modelos de aprendizaje automático con Lazy Predict para proyectos de regresión

- ,

Supongamos que necesitas trabajar en un proyecto de aprendizaje automático de regresión. Analiza tus datos, realiza una limpieza de datos, crea algunas variables ficticias y ahora es el momento de ejecutar un modelo de regresión de aprendizaje automático. ¿Cuáles son los diez mejores modelos que te vienen a la mente? La mayoría de vosotros probablemente ni siquiera sepáis que existen diez modelos de regresión. No te preocupes si no lo sabes porque, al final de este artículo, podrás ejecutar no solo diez modelos de regresión de aprendizaje automático, ¡sino más de 40!

Hace unas semanas, escribí el blog Cómo ejecutar 30 modelos de aprendizaje automático con unas pocas líneas de código, y la recepción fue muy positiva. De hecho, es mi blog más popular hasta ahora. En ese blog, creé un proyecto de clasificación para probar Lazy Predict. Hoy, probaré el Lazy Predict en un proyecto de regresión. Para hacerlo, utilizaré el conjunto de datos clásico de Seattle House Price. Puedes encontrarlo en Kaggle.

Desarrollo de ChatBots para empresas

Creamos chatbots en WhatsApp, Facebook Messenger, Telegram...

Contáctanos en nuestra web

¿Qué es Lazy Predict?

Lazy Predict ayuda a construir docenas de modelos sin mucho código y ayuda a comprender qué modelos funcionan mejor sin ningún ajuste de parámetros. La mejor manera de mostrar cómo funciona es con un proyecto corto, así que comencemos.

Proyecto de regresión con Lazy Predict

En primer lugar, para instalar Lazy Predict, puedes copiar y pegar «pip install lazypredict» en tu terminal. Es así de simple. Ahora, importamos algunas bibliotecas que usaremos en este proyecto. Puedes encontrar el cuaderno completo aquí.

# Importing important libraries
import pyforest
from lazypredict.Supervised import LazyRegressor
from pandas.plotting import scatter_matrix
# Scikit-learn packages
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import ExtraTreesRegressor
from sklearn import metrics
from sklearn.metrics import mean_squared_error
# Hide warnings
import warnings
warnings.filterwarnings(“ignore”)
# Setting up max columns displayed to 100
pd.options.display.max_columns = 100

Puedes ver que importé «pyforest» en lugar de Pandas y Numpy. PyForest importa todas las bibliotecas importantes al portátil muy rápidamente. Escribí un blog al respecto y lo puedes encontrar aquí. Ahora, importamos el conjunto de datos.

# Import dataset
df = pd.read_csv('../data/kc_house_data_train.csv', index_col=0)

Ahora veamos como queda este conjunto de datos:

Bien, ahora revisemos los tipos de datos.

# Checking datatimes and null values
df.info()

Ahora, algunas cosas que me llamaron la atención. El primero es que las columnas de id no tienen ninguna relevancia para este breve proyecto. Sin embargo, si deseas profundizar en el proyecto, debes verificar si hay duplicados. Además, las columnas de date son un tipo de objeto. Deberíamos cambiarlo al tipo DateTime. Las columnas zipcode, lat, y long probablemente tienen poca o ninguna correlación con el precio actual. Sin embargo, dado que el objetivo de este proyecto es demostrar lazy predict(predicción perezosa), los conservaré.

Veamos ahora algunas estadísticas y veamos si podemos encontrar algo que debamos cambiar antes de ejecutar nuestros primeros modelos.

Está bien. Puedo ver algunas cosas interesantes. Primero, hay una casa con 33 habitaciones. Eso no puede ser correcto. Por lo tanto, verifiqué en línea y resultó que encontré la casa en línea usando su identificación, y en realidad tiene tres dormitorios. Puedes encontrar la casa aquí. Además, parece que hay casas con 0 baños. Incluiré al menos un baño, y deberíamos terminar con la limpieza de datos.

># Fixing house with 33 bedrooms
df[df['bedrooms'] == 33] = df[df['bedrooms'] == 3]
# This will add 1 bathroom to houses without any bathroom
df['bathrooms'] = df.bedrooms.apply(lambda x: 1 if x < 1 else x)

Train Test Split

Ahora estamos listos para la división de prueba de tren, pero antes, asegurémonos de no tener nan or infinite con este código:

# Removing nan and infinite values
df.replace([np.inf, -np.inf], np.nan, inplace=True)
df.dropna(inplace=True)

Dividimos el conjunto de datos en variables X e Y. Asignaré el 75% del conjunto de datos al conjunto de trenes y el 25% a un conjunto de prueba.

# Creating train test split
X = df.drop(columns=['price])
y = df.price
# Call train_test_split on the data and capture the results
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=3,test_size=0.25)

¡Es hora de divertirse! El siguiente código se ejecutará en más de 40 modelos y mostrará el R-Squared y RMSE para cada modelo. En sus marcas, listos, fuera…

reg = LazyRegressor(ignore_warnings=False, custom_metric=None)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)
print(models)

¡Guau! Estos resultados son excelentes para la cantidad de trabajo invertido en ellos. Esos son excelentes R-Squared y RMSE para modelos vainilla. Como podemos ver, ejecutamos 41 modelos básicos, obtuvimos las métricas que necesitábamos y puede ver el tiempo dedicado a cada modelo. No está mal. Ahora bien, ¿cómo puedes estar seguro de que estos resultados son correctos? Podemos ejecutar un modelo y verificar los resultados para ver si están cerca de lo que obtuvimos. ¿Probamos el árbol de regresión de aumento de gradiente basado en histogramas? Si nunca has oído hablar de este algoritmo, no te preocupes porque yo tampoco he oído hablar de él. Puedes encontrar un artículo al respecto aquí.

Resultados de doble verificación

Primero, importemos este modelo usando scikit-learn.

# Explicitly require this experimental feature
from sklearn.experimental import enable_hist_gradient_boosting
# Now you can import normally from ensemble
from sklearn.ensemble import HistGradientBoostingRegressor

Además, creemos una función para verificar las métricas del modelo.

# Evaluation Functions
def rmse(model, y_test, y_pred, X_train, y_train):
r_squared = model.score(X_test, y_test)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
print(‘R-squared: ‘ + str(r_squared))
print(‘Mean Squared Error: ‘+ str(rmse))
# Create model line scatter plot
def scatter_plot(y_test, y_pred, model_name):
plt.figure(figsize=(10,6))
sns.residplot(y_test, y_pred, lowess=True, color='#4682b4',
line_kws={'lw': 2, 'color': 'r'})
plt.title(str('Price vs Residuals for '+ model_name))
plt.xlabel('Price',fontsize=16)
plt.xticks(fontsize=13)
plt.yticks(fontsize=13)
plt.show()

Finalmente, ejecutamos el modelo y verificamos los resultados.

# Histogram-based Gradient Boosting Regression Tree
hist = HistGradientBoostingRegressor()
hist.fit(X_train, y_train)
y_pred = hist.predict(X_test)

¡Voilá! Los resultados fueron muy parecidos a los que obtuvimos con Lazy Predict. Parece que realmente funciona.

Comentarios finales

Lazy Predict es una biblioteca fantástica, fácil de usar y rápida que ejecuta modelos básicos con muy pocas líneas de código. En lugar de configurar manualmente varios modelos básicos, puedes hacerlo manualmente con 2 o 3 líneas de código. Ten en cuenta que no debes considerar los resultados como modelos finales, y siempre debes verificar los resultados para asegurarte de que la biblioteca esté funcionando correctamente. Como mencioné en otros blogs, la ciencia de datos es un campo complejo y Lazy Predict no puede sustituir la experiencia de un profesional que optimizará los modelos. Hazme saber cómo te ha funcionado y si te quedan más preguntas.

Entradas del mismo autor

Deja un comentario