Estás leyendo la publicación: Ejecute todos los algoritmos de sklearn con una línea de código: hacia la IA
Publicado originalmente en Hacia la IA, la empresa líder mundial en noticias y medios de IA y tecnología. Si está creando un producto o servicio relacionado con la IA, lo invitamos a considerar convertirse en patrocinador de la IA. En Hacia la IA, ayudamos a escalar las empresas emergentes de IA y tecnología. Permítanos ayudarlo a dar rienda suelta a su tecnología a las masas.
Lazypredict: ejecute todos los algoritmos de Sklearn con una línea de código
Cómo (y por qué no deberías) usarlo
Aquí hay dos puntos débiles de los científicos de datos:
Punto de dolor 1: tiempo limitado en el ciclo de vida de la ciencia de datos
Los científicos de datos tienen que priorizar. Esto puede significar dedicar más tiempo a comprender el problema comercial e identificar el enfoque más apropiado en lugar de centrarse únicamente en desarrollar algoritmos de aprendizaje automático.
Punto problemático 2: el modelado de aprendizaje automático puede llevar mucho tiempo
El ajuste fino de un algoritmo de aprendizaje automático implica encontrar los valores óptimos para estos hiperparámetros, lo que puede ser un proceso de prueba y error. Esto lleva mucho tiempo.
AutoML salva el día
AutoML puede solucionarlos. Una biblioteca naciente es lazypredict. En esta publicación, analizo lo siguiente:
- que es lazypredict
- Instalando lazypredict
- Cómo usarlo para ajustar automáticamente los algoritmos de regresión de scikit-learn
- Cómo usarlo para algoritmos de clasificación de ajuste automático
- Por qué no deberías usarlo (y qué más puedes usar)
¿Qué es Lazypredict?
Lazypredict es un paquete de Python que tiene como objetivo automatizar el proceso de modelado de aprendizaje automático. Funciona tanto en tareas de regresión como de clasificación.
Su característica clave es su capacidad para automatizar el entrenamiento y la evaluación de modelos de aprendizaje automático. Proporciona una interfaz simple para definir un rango de hiperparámetros y luego entrena y evalúa un modelo utilizando una variedad de combinaciones diferentes de estos hiperparámetros.
Instalación de Lazypredict
En su terminal, ejecute lo siguiente
pip instalar lazypredict
Sin embargo, es posible que deba instalar manualmente algunas dependencias de lazypredict. Si se encuentra con problemas que indican que necesita instalar scikit-learn, xgboost o lightgbm, puede ejecutar pip install para instalar las bibliotecas necesarias.
Personalmente, conseguí que funcionara en python 3.9.13 al tener los siguientes requisitos.txt
pandas==1.4.4
numpy==1.21.5
scikit-aprender==1.0.2
lazypredict==0.2.12
Instalé las siguientes bibliotecas ejecutando este comando en la terminal: pip install -r requirements.txt.
Es incluso mejor usar un entorno virtual en este caso.
Uso de Lazypredict para regresión
Repasemos el código. (Si solo desea el código completo, busque “Código completo” en este artículo).
Primero importaremos las bibliotecas necesarias.
de lazypredict.Importación supervisada LazyRegressor
de conjuntos de datos de importación de sklearn
de sklearn.utils importación aleatoria
importar numpy como np
Primero, importaremos el conjunto de datos de Diabetes.
Se obtuvieron diez variables iniciales, edad, sexo, índice de masa corporal, presión arterial promedio y seis mediciones de suero sanguíneo para cada uno de n = 442 pacientes con diabetes, así como la respuesta de interés, una medida cuantitativa de la progresión de la enfermedad un año después de la línea base. .
# Importar el conjunto de datos de diabetes
diabetes = conjuntos de datos.load_diabetes()
A continuación, mezclamos el conjunto de datos para poder dividirlos en conjuntos de prueba de entrenamiento.
# Mezclar el conjunto de datos
X, y = barajar (diabetes.datos, diabetes.objetivo, estado_aleatorio=13)
# Convierta los valores numéricos en un flotante numpy.
X = X.astype(np.float32)
# Divida el conjunto de datos en 90% y 10%.
desplazamiento = int(forma X[0] * 0.9)
# Dividirse en entrenar y probar
X_tren, y_tren = X[:offset]y[:offset]
Prueba_X, prueba_y = X[offset:]y[offset:]
A continuación, inicializamos el objeto LazyRegressor.
# Ejecutar la biblioteca Lazypredict y ajustar múltiples bibliotecas de regresión
# para el mismo conjunto de datos
reg = LazyRegressor(detallado=0,
ignore_warnings=Falso,
custom_metric=Ninguno,
predicciones = falso,
estado_aleatorio = 13)
# Parámetros
# ———-
# detallado: int, opcional (predeterminado=0)
# Para los solucionadores liblinear y lbfgs establezca verbose en cualquier positivo
# número de verbosidad.
# ignore_warnings : bool, opcional (predeterminado=Verdadero)
# Cuando se establece en Verdadero, la advertencia relacionada con algoritmos que no pueden
# para ejecutar se ignoran.
# custom_metric: función, opcional (predeterminado=Ninguno)
# Cuando se proporciona la función, los modelos se evalúan en función de la costumbre
# métrica de evaluación proporcionada.
# predicción: booleano, opcional (predeterminado=Falso)
# Cuando se establece en Verdadero, las predicciones de todos los modelos son
# devuelto como marco de datos.
# regresores: lista, opcional (predeterminado=”todos”)
# Cuando se proporciona la función, entrena los regresores elegidos.
Ahora, ajustaremos múltiples algoritmos de regresión con la biblioteca lazypredict. Este paso tomó 3 segundos en total.
Debajo del capó, el método de ajuste hace lo siguiente:
- Divida todas las características en tres categorías: numéricas (características que son números) o categóricas (características que son texto)
- Divida aún más las características categóricas en dos: características categóricas ‘altas’ (y características categóricas ‘bajas’ (
- Luego, cada función se preprocesa de esta manera:
- Funciones numéricas: impute los valores faltantes con la media y luego estandarice la función
- Características categóricas ‘altas’: impute los valores faltantes con el valor ‘faltante’, luego realice una codificación one-hot.
- Características categóricas ‘bajas’: impute los valores faltantes con el valor ‘faltante’, luego realice la codificación ordinal (en el ejemplo de una columna Género, ‘Masculino’ se codifica como 0 y ‘Femenino’ como 1).
- Ajuste el conjunto de datos de entrenamiento en cada algoritmo.
- Pruebe cada algoritmo en el conjunto de prueba. De forma predeterminada, las métricas se ajustan R-cuadrado, R-cuadrado, error cuadrático medio y el tiempo necesario.
modelos, predicciones = reg.fit(X_train, X_test, y_train, y_test)
model_dictionary = reg.provide_models(X_tren, X_prueba, y_tren, y_prueba)
modelos
Aquí está el resultado.
| Modelo | R-cuadrado ajustado | R-cuadrado | RMSE | Tiempo tomado |
|:——————————|—————– —-:|————:|——-:|————-:|
| ExtraTreesRegresor | 0.38 | 0.52 | 54.22 | 0.17 |
| OrthogonalMatchingPursuitCV | 0.37 | 0.52 | 54.39 | 0.01 |
| Lazo | 0.37 | 0.52 | 54.46 | 0.01 |
| LassoLars | 0.37 | 0.52 | 54.46 | 0.01 |
| LarsCV | 0.37 | 0.51 | 54.54 | 0.02 |
| LassoCV | 0.37 | 0.51 | 54.59 | 0.07 |
| PasivoAgresivoRegresor | 0.37 | 0.51 | 54.74 | 0.01 |
| LassolarsIC | 0.36 | 0.51 | 54.83 | 0.01 |
| Regresor SGD | 0.36 | 0.51 | 54,85 | 0.01 |
| RidgeCV | 0.36 | 0.51 | 54.91 | 0.01 |
| Cresta | 0.36 | 0.51 | 54.91 | 0.01 |
| Cresta bayesiana | 0.36 | 0.51 | 54,94 | 0.01 |
| LassoLarsCV | 0.36 | 0.51 | 54,96 | 0.02 |
| Regresión lineal | 0.36 | 0.51 | 54,96 | 0.01 |
| TransformedTargetRegressor | 0.36 | 0.51 | 54,96 | 0.01 |
| Lars | 0.36 | 0.50 | 55.09 | 0.01 |
| ElasticNetCV | 0.36 | 0.50 | 55,20 | 0.06 |
| HuberRegresor | 0.36 | 0.50 | 55.24 | 0.02 |
| Regresor de bosque aleatorio | 0,35 | 0.50 | 55.48 | 0,25 |
| AdaBoostRegresor | 0.34 | 0.49 | 55.88 | 0.08 |
| Regresor LGBM | 0.34 | 0.49 | 55,93 | 0.05 |
| HistGradientBoostingRegressor | 0.34 | 0.49 | 56.08 | 0.20 |
| Regresor de Poisson | 0.32 | 0.48 | 56.61 | 0.01 |
| red elástica | 0.30 | 0,46 | 57.49 | 0.01 |
| KNeighborsRegresor | 0.30 | 0,46 | 57.57 | 0.01 |
| Persecución de coincidencia ortogonal | 0.29 | 0,45 | 57.87 | 0.01 |
| Regresor de embolsado | 0.29 | 0,45 | 57,92 | 0.04 |
| Regresor XGB | 0.28 | 0,45 | 58.18 | 0.11 |
| GradientBoostingRegressor | 0.25 | 0,42 | 59,70 | 0.12 |
| Regresor de Tweedie | 0.24 | 0,42 | 59.81 | 0.01 |
| Regresor gamma | 0.22 | 0,40 | 60.61 | 0.01 |
| RANSACRegresor | 0.20 | 0.38 | 61,40 | 0.12 |
| SVR lineal | 0.12 | 0.32 | 64.66 | 0.01 |
| ExtraTreeRegresor | 0.00 | 0.23 | 68.73 | 0.01 |
| NuSVR | -0.07 | 0.18 | 71.06 | 0.01 |
| RVS | -0.10 | 0.15 | 72.04 | 0.02 |
| Regresor ficticio | -0.30 | -0.00 | 78.37 | 0.01 |
| CuantilRegresor | -0.35 | -0.04 | 79.84 | 1.42 |
| Árbol de decisión Regresor | -0.47 | -0.14 | 83.42 | 0.01 |
| Regresor de proceso gaussiano | -0.77 | -0.37 | 91.51 | 0.02 |
| MLPRegresor | -1.87 | -1.22 | 116.51 | 0.21 |
| Kernel Ridge | -5.04 | -3.67 | 169.06 | 0.01 |
Aquí está el código completo para la regresión en un conjunto de datos de diabetes.
de lazypredict.Importación supervisada LazyRegressor
de conjuntos de datos de importación de sklearn
de sklearn.utils importación aleatoria
importar numpy como np
# Importar el conjunto de datos de diabetes
diabetes = conjuntos de datos.load_diabetes()
# Mezclar el conjunto de datos
X, y = barajar (diabetes.datos, diabetes.objetivo, estado_aleatorio=13)
# Emitir los valores numéricos
X = X.astype(np.float32)
desplazamiento = int(forma X[0] * 0.9)
# Dividirse en entrenar y probar
X_tren, y_tren = X[:offset]y[:offset]
Prueba_X, prueba_y = X[offset:]y[offset:]
# Ejecutar la biblioteca Lazypredict y ajustar múltiples bibliotecas de regresión
# para el mismo conjunto de datos
reg = LazyRegressor(verbose=0, ignore_warnings=False, custom_metric=Ninguno)
modelos, predicciones = reg.fit(X_train, X_test, y_train, y_test)
model_dictionary = reg.provide_models(X_tren, X_prueba, y_tren, y_prueba)
modelos
Uso de Lazypredict para la clasificación
Usemos Lazypredict para la clasificación. (Si solo desea el código completo, busque “código completo” en este artículo.
Primero, importe las bibliotecas necesarias.
de lazypredict.Importación supervisada LazyClassifier
desde sklearn.datasets importar load_iris
de sklearn.model_selection import train_test_split
A continuación, cargamos los datos, el conjunto de datos de Iris, y los dividimos en conjuntos de entrenamiento y prueba. Esto es lo que contiene.
El conjunto de datos consta de 50 muestras de cada una de las tres especies de (, y ). cuatro características se midieron de cada muestra: la longitud y el ancho de la sépalos y pétalosen centímetros.
datos = cargar_iris()
X = datos.datos
y= datos.objetivo
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=.5,random_state =123)
A continuación, inicializamos el objeto LazyClassifier.
# Ejecutar la biblioteca Lazypredict y ajustar múltiples bibliotecas de regresión
# para el mismo conjunto de datos
clf = LazyClassifier(verbose=0,ignore_warnings=True, custom_metric=Ninguno)
“””
Parámetros
———-
detallado: int, opcional (predeterminado = 0)
Para los solucionadores liblinear y lbfgs establezca verbose en cualquier positivo
número de verbosidad.
ignore_warnings : bool, opcional (predeterminado=Verdadero)
Cuando se establece en True, se ignoran las advertencias relacionadas con los algoritmos que no pueden ejecutarse.
custom_metric : función, opcional (predeterminado=Ninguno)
Cuando se proporciona la función, los modelos se evalúan en función de la métrica de evaluación personalizada proporcionada.
predicción: booleano, opcional (predeterminado=Falso)
Cuando se establece en True, las predicciones de todos los modelos se devuelven como marco de datos.
clasificadores: lista, opcional (predeterminado=”todos”)
Cuando se proporciona la función, entrena los clasificadores elegidos.
“””
Luego, llamamos al método de ajuste del regresor perezoso, que ajusta múltiples algoritmos de clasificación con la biblioteca de predicción perezosa. Este paso tomó 1 segundo en total para este pequeño conjunto de datos.
(Busque la palabra clave “” para saltar a la sección donde explico lo que hace el ajuste).
modelos,predicciones = clf.fit(X_tren, X_prueba, y_tren, y_prueba)
Por último, podemos ver cómo funciona cada modelo usando provide_models. Esto informa la precisión, la precisión equilibrada, ROC AUC y la puntuación F1 en el conjunto de prueba.
# Calcule el rendimiento de todos los modelos en el conjunto de datos de prueba
model_dictionary = clf.provide_models(X_tren,X_prueba,y_tren,y_prueba)
modelos
Aquí está el resultado completo.
| Modelo | Precisión | Precisión equilibrada | ABC de la República de China | Puntuación F1 | Tiempo tomado |
|:——————————|—————–:|—- —————-:|:———-|—————–:|——- ——:|
| Análisis Discriminante Lineal | 0.99 | 0.99 | | 0.99 | 0.01 |
| Clasificador AdaBoost | 0.97 | 0,98 | | 0,97 | 0.13 |
| Clasificador pasivo agresivo | 0.97 | 0,98 | | 0,97 | 0.01 |
| Regresión Logística | 0.97 | 0.98 | | 0,97 | 0.01 |
| Nota gaussiana | 0.97 | 0,98 | | 0.97 | 0.01 |
| Clasificador SGD | 0,96 | 0,96 | | 0,96 | 0.01 |
| Clasificador de bosque aleatorio | 0,96 | 0,96 | | 0,96 | 0.19 |
| Análisis Discriminante Cuadrático | 0,96 | 0,96 | | 0,96 | 0.01 |
| Perceptrón | 0,96 | 0,96 | | 0,96 | 0.01 |
| Clasificador LGBM | 0,96 | 0,96 | | 0,96 | 0.30 |
| ExtraTreeClassifier | 0,96 | 0,96 | | 0,96 | 0.01 |
| Clasificador de embolsado | 0,95 | 0,95 | | 0,95 | 0.03 |
| ExtraTreesClassifier | 0,95 | 0,95 | | 0,95 | 0.13 |
| Clasificador XGB | 0,95 | 0,95 | | 0,95 | 0.19 |
| Clasificador de árboles de decisión | 0,95 | 0,95 | | 0,95 | 0.01 |
| SVC lineal | 0,95 | 0,95 | | 0,95 | 0.01 |
| CalibratedClassifierCV | 0,95 | 0,95 | | 0,95 | 0.04 |
| KNeighborsClassifier | 0,93 | 0,94 | | 0,93 | 0.01 |
| NuSVC | 0,93 | 0,94 | | 0,93 | 0.01 |
| CVS | 0,93 | 0,94 | | 0,93 | 0.01 |
| RidgeClassifierCV | 0.91 | 0.91 | | 0.91 | 0.01 |
| Centroide más cercano | 0,89 | 0,90 | | 0,89 | 0.01 |
| Propagación de etiquetas | 0,89 | 0,90 | | 0,90 | 0.01 |
| Extensión de etiquetas | 0,89 | 0,90 | | 0,90 | 0.01 |
| RidgeClassifier | 0.88 | 0,89 | | 0.88 | 0.01 |
| BernoulliNB | 0,79 | 0,75 | | 0.77 | 0.01 |
| Clasificador ficticio | 0.27 | 0.33 | | 0.11 | 0.01 |
Aquí está el código completo para la clasificación.
de lazypredict.Importación supervisada LazyClassifier
de sklearn.datasets importar load_breast_cancer
de sklearn.model_selection import train_test_split
# Cargar conjunto de datos
datos = cargar_cáncer_de_mama()
X = datos.datos
y= datos.objetivo
# Dividir datos en entrenar y probar con una proporción de 90:10
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=.1,random_state =123)
# Inicializar la biblioteca Lazypredict
clf = LazyClassifier(verbose=0,ignore_warnings=True, custom_metric=Ninguno)
# Ajuste todos los algoritmos de clasificación en el conjunto de datos de entrenamiento
modelos,predicciones = clf.fit(X_tren, X_prueba, y_tren, y_prueba)
# Calcule el rendimiento de todos los modelos en el conjunto de datos de prueba
model_dictionary = clf.provide_models(X_tren,X_prueba,y_tren,y_prueba)
modelos
¿Recomiendo lazypredict?
Si llegas a instalarlo, lazypredict es muy simple de usar. Su sintaxis es muy parecida a la de scikit-learn, lo que hace que la curva de aprendizaje sea muy suave.
Pero tiene algunas debilidades críticas.
- Instalación difícil: muchos informaron dificultades para instalar las bibliotecas porque los desarrolladores no agregaron los requisitos.txt que documentan las dependencias requeridas.
- Documentación limitada: Tuve que peinar a través de la código fuente para averiguar cómo se ejecuta el preprocesamiento. Esto no es ideal. Tampoco conozco los hiperparámetros utilizados para realizar cada una de las tareas de clasificación y regresión.
- Personalización limitada: todavía tengo que encontrar formas de personalizar los pasos de preprocesamiento.
- No está claro cómo usar el modelo después de lazypredict: una vez que haya terminado con la biblioteca lazypredict, idealmente querrá seleccionar el mejor algoritmo. Lazypredict no lo hace fácil ya que no tiene una manera fácil de exportar el mejor algoritmo.
comida para llevar principal
Las debilidades críticas de Lazypredict limitan su utilidad. Es agradable, pero todavía está subdesarrollado.
Le recomiendo encarecidamente que compruebe que son superiores en términos de documentación y personalización.
Aquí hay algunas alternativas.
- TPOT (Vea cómo usar TPOT aquí)
- Aprendizaje automático
- ViML automático
- H2O AutoML
- Auto-Keras
- MLBox
- Hiperopción Sklearn
- AutoGluon
Soy Travis Tang, científico de datos en Tech. Comparto cómo puedes usar bibliotecas de código abierto en Medium. También comparto análisis de datos y consejos científicos sobre LinkedIn a diario. Sígueme si te gusta este contenido.
Lazypredict: Ejecute todos los algoritmos de sklearn con una línea de código se publicó originalmente en Hacia la IA en Medium, donde las personas continúan la conversación resaltando y respondiendo a esta historia.
Publicado a través de Hacia la IA
