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.

¿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.

The post Cómo ejecutar 40 modelos de regresión con unas pocas líneas de código first appeared on Planeta Chatbot.

Esto es lo que acaba de suceder: PyCaret lidió con los datos categóricos, dividió el conjunto de datos en train y conjuntos de prueba, registró el experimento, verificó los valores atípicos, solucionó el desequilibrio de clases y ejecutó modelos desde Regresión logística a XGBoost en menos de 30 segundos. También obtuvo una precisión de 0.8154 con 2 líneas de código. Ahora, entendamos más sobre cómo funciona PyCaret y cómo puedes usarlo.

¿Cómo llevar a cabo este proyecto de Data Science?

¿Qué es PyCaret?

Esto es lo que dice su sitio web:

PyCaret es una biblioteca de aprendizaje automático de low-code y de código abierto en Python que te permite pasar de preparar tus datos a implementar tu modelo en cuestión de minutos en el entorno de notebook que elijas.

Parece que PyCaret hace lo que promete. Va desde la preparación de tus datos hasta la implementación de modelos supervisados ​​y no supervisados ​​con 2 o 3 líneas de código. Lo probé en algunos proyectos diferentes, incluidos algunos antiguos en los que funcionó en el pasado, y los resultados fueron muy similares a los que obtuve después de una semana de trabajo. Para mostrarte cómo funciona, creemos un proyecto de clasificación juntos. Puedes encontrar el cuaderno que utilicé para este artículo aquí. Pronto también publicaré un proyecto de regresión. Tendrás que estar muy atent@!

Instalación

Hay algunas formas de instalar a PyCaret a través de tu terminal. . Se recomienda encarecidamente utilizar un entorno virtual para evitar conflictos con otras bibliotecas. El primero es escribir pip install pycaret en tu terminal, que es una versión más ligera de PyCaret y sus dependencias estrictas. Para instalar la versión completa, puedes escribir pip install pycaret[full], que es la que recomiendo.

Iniciar un nuevo proyecto

PyCaret está tan seguro de lo que ofrece, que su equipo nos brinda 55 conjuntos de datos que puedes probar la librería por tu cuenta. Estos son los problemas incluidos: detección de anomalías, minería de reglas de asociación, clasificación binaria y multiclase, agrupamiento, PNL y regresión.

Una vez que hayas instalado PyCaret, puedes escribir lo siguiente en un Jupyter notebook para obtener la lista de conjuntos de datos que ponen a disposición.

# Get data
from pycaret.datasets import get_data
from pycaret.classification import *
index = get_data('index')

La lista de conjuntos de datos es larga y no los agregaré todos aquí, pero estos son los conjuntos de datos de clasificación entre los que puedes elegir:

Para este proyecto, iré con el proyecto predeterminado de la tarjeta de crédito. Es algo desafiante y está muy cerca de un problema de la vida real. Para elegir un conjunto de datos, simplemente escribe data = get_data(‘name_of_the_dataset’). Dado que probaremos el conjunto de datos predeterminado de la tarjeta de crédito, debemos escribir data = get_data(‘credit’ )y ejecutar la celda.

Ahora, estamos listos para la preparación de datos. Tomará una línea de código. PyCaret devolverá una tabla con la información del conjunto de datos y podremos tomar decisiones sobre cómo queremos proceder. Para hacerlo, configuraremos el conjunto de datos, la etiqueta de destino, el nombre del experimento, etc. Aquí está la parte más importante del código:

clf1 = setup(data, target = ‘default’, session_id=123, log_experiment=True, experiment_name=’default1')

Una vez que el código indicado anteriormente está corriendo, tenemos que hacer las siguientes preguntas: Los siguientes tipos de datos se han deducido automáticamente. Si son correctos, presione Intro para continuar o escribe «Salir» de lo contrario. Escribe enter para continuar.

Lo que hizo este código anterior fue pasar por la limpieza de datos, dividir la prueba del train, probar la transformación de registros, polinomios, convertir datos categóricos, resolver el desequilibrio de clases y cualquier otra preparación de datos que puedas imaginar. Puedes ver que escribí log_transformation = True como ejemplo, pero hay docenas de opciones de preparación de datos. Te recomiendo encarecidamente que escribas shift + taby compruebes todo lo que puedes hacer con la preparación de datos. Podría escribir un artículo completo al respecto (y podría hacerlo), pero por ahora, sigamos con lo básico.

Ejecución de modelos

Ahora es el momento de ejecutar modelos de referencia. Hasta ahora, después de cargar el conjunto de datos, he escrito una línea de código. Ahora ejecutaremos 16 modelos de aprendizaje automático con otra línea de código. Usaré 5 pliegues para las validaciones cruzadas.

La ejecución de todos los modelos tomó 1:36 min, incluidos algunos modelos de conjuntos complejos. Comprobemos los resultados:

Varias cosas que hay que destacar en este punto. Primero, XGBoost falló. Está bien. Tenemos otros 15 modelos para analizar. PyCaret nos brinda múltiples métricas y destaca los mejores resultados para cada métrica. Para este proyecto, debemos considerar la métrica de recuperación, que se utiliza cuando el costo de los falsos negativos es alto y obtuvimos una puntuación de recuperación de 0.90. También puedes crear modelos individuales simplemente escribiendo, por ejemplo qda = create_model(‘qda’).

Qda significa el modelo de análisis discriminante cuadrático. De forma predeterminada, PyCaret divide el conjunto de prueba en 10 pliegues. Puedes editarlo escribiendo qda = create_model(‘Ada’, fold = 5). Para comprobar la lista completa de modelos que puedes ejecutar, la biblioteca que están usando y la abreviatura, escribe models().

Y puedes escribir tune_models(lr)para ajustar los hiperparámetros. Lo que en este caso mejoró algunas métricas, pero en realidad disminuyó la puntuación de recuperación.

Y hay muchas otras cosas para las que puedes usar PyCaret, por ejemplo analizar e interpretar modelos, probar modelos con conjuntos reservados, guardar e implementar modelos.

Te animo a que visites su sitio web y consultes su documentación, proyectos y más tutoriales. Hay mucho contenido que cubrir, aunque eso lo analizaré en otro artículo

Conclusiones finales

PyCaret parece asombroso y cumple lo prometido. Sin embargo, como siempre me gusta recordar a los lectores, la ciencia de datos es un rol complejo y no se puede sustituir a un profesional con unas pocas líneas de códigos. Si deseas utilizarlo PyCaret como un paso adicional para su próximo proyecto y comprende el potencial de tu conjunto de datos, hágalo. Lo probé con múltiples conjuntos de datos y los resultados fueron muy cercanos a los que pude obtener cuando trabajé una semana completa en un proyecto. Sin embargo, no recomiendo usarlo para tus resultados finales o como un atajo. Puedes agregarlo como parte del proceso y obtener información rápida sin tener que escribir docenas de líneas de código. Diviértete probándolo y cuéntame cómo te va.

Pronto publicaré un proyecto de regresión usando PyCaret, así que sígueme aquí en para estar al día. Si te ha gustado este artículo, no olvides dejar tus aplausos. Me motiva a seguir escribiendo.

The post Cómo crear un proyecto de data science con 2 líneas de código first appeared on Planeta Chatbot.

Eso es lo que lazy predict intenta (con éxito) lograr. Ejecuta 30 modelos de aprendizaje automático en solo unos segundos y nos da una idea de cómo funcionarán los modelos con nuestro conjunto de datos. Para comprender mejor cómo podemos usar lazy predict, creé un proyecto de predicción de supervivientes del Titanic para que puedas codificarlo. Puedes encontrar el cuaderno completo aquí y así llevar a cabo este proyecto conmigo. La experiencia básica con Python, Pandas y scikit-learn te ayudará a comprender mejor lo que está sucediendo.

Importación y limpieza de datos

Primero, importemos pyforest. PyForest importa las 40 bibliotecas de Python más populares con una línea de código. Escribí un artículo al respecto y lo puedes encontrar aquí. Apagaré algunos mensajes de advertencia desagradables usando la biblioteca de advertencias. También importaré algunas bibliotecas de métricas. Lo necesitaremos más adelante.

import pyforest
import warnings
warnings.filterwarnings("ignore")
from sklearn import metrics
from sklearn.metrics import accuracy_score

Ahora, importemos el conjunto de datos que usaremos de Kaggle. Puedes encontrar el conjunto de datos en este enlace. Ten en cuenta que no importé Pandas. Eso es porque viene incluido con pyforest.

# importing .csv files using Pandas
train = pd.read_csv(‘train.csv’)
test = pd.read_csv(‘test.csv’)

Saltaré algunos análisis de datos exploratorios en este artículo porque nuestro enfoque principal es comenzar a usar lazy predict. Sin embargo, en mi EDA inicial que puedes encontrar en mi GitHub, noté que necesitamos convertir la columna Sex en numérica. Podemos hacer eso fácilmente con un lambda function.

train['Sex'] = train['Sex'].apply(lambda x: 1 if x == 'male' else 2)

También podemos eliminar algunas columnas categóricas que no se utilizarán para este micro proyecto. Como tarea, te recomiendo que intentes jugar con estas funciones cuando termines este artículo.

train.drop(columns=[‘Name’,’Ticket’,’Cabin’, ‘PassengerId’, ‘Parch’, ‘Embarked’], inplace=True)

Train Test Split

Dividamos ahora nuestro train set en las variables “x” e “y”. Dirigiré todas las características a “X”, excepto “Survived”, es decir, superviviente (survived) que es nuestra etiqueta de destino.

X = train.drop([‘Survived’], axis=1)
y = train.Survived

Y ahora, dividamos la variable en conjuntos de train y test. Iré con el 0,25 predeterminado para el tamaño de la prueba. Puedes agregar fácilmente otros valores usando:

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

Modelando con LazyPredict

Ahora es el momento de divertirse. Si es la primera vez que usas lazypredict, tendrás que instalarlo. Para hacerlo, puedes escribir pip install lazypredict en en tu terminal. Si ya lo tienes instalado, importémoslo a tu proyecto. Dado que este es un proyecto de clasificación, importamos LazyClassifier también.

import lazypredict
from lazypredict.Supervised import LazyClassifier

Finalmente, ejecutamos los modelos y comprobamos si funciona:

clf = LazyClassifier(verbose=0,ignore_warnings=True)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
models

Voilá. Acabas de iterar más de 30 modelos en menos de 2 segundos. Eso es increíblemente rápido y sin esfuerzo. Sin embargo, ¿cómo podemos asegurarnos de que estos resultados sean precisos? Bueno, ahora podemos verificar los resultados ejecutando algunos modelos y comparándolos. Para este proyecto, probaré el conjunto de datos con un modelo de regresión logística y bosque aleatorio. Veamos si podemos acercarnos a los resultados que acabamos de ver. Comencemos con Random Forest.

rf = RandomForestClassifier()
rf.fit(X_train, y_train)
y_pred = rf.predict(X_test)

Como puedes comprobar, el nivel de accuracy y el F1-Score reflejan unos resultados similares. Probemos ahora con la variable Logistic Regression.

rf = LogisticRegression()
rf.fit(X_train, y_train)
y_pred_lr = rf.predict(X_test)

De nuevo tenemos un resultado similar. En consecuencia, los resultados obtenidos son válidos y confiables. Así de simple.

Conclusión

Lazypredict es una biblioteca fácil y rápida que ofrece una buena predicción de cómo se comportarán nuestros modelos si tu conjunto de datos. Ten en cuenta que los resultados obtenidos con lazy predict NO DEBEN considerarse modelos finales. Las estadísticas son un componente importante de la ciencia de datos y, dado que los diferentes modelos tienen diferentes enfoques, debes saber cómo funciona cada uno de los modelos antes de elegir el modelo final. Más importante aún, la ciencia de datos es un campo complejo y no existen soluciones mágicas sin pros y contras. Úsalo como tu primera iteración para confirmar tu enfoque planificado y verifica siempre los resultados con herramientas como scikit-learn.

¡Diviértete y avísame si te funcionó!

The post Cómo ejecutar 30 modelos de aprendizaje automático con unas pocas líneas de código first appeared on Planeta Chatbot.