Bienvenido, les saluda Miguel y aquí les traigo otro artículo.
Índice
Introducción
En esta publicación, mostraremos cómo usar Prevision.io sdk
para crear un caso de uso de clasificación múltiple utilizando datos de calidad de vino blanco del Repositorio de aprendizaje automático de UCI .
El objetivo del aprendizaje automático es predecir la calidad del vino blanco a partir de sus características químicas como (acidez, ph, densidad, sulfatos …)
Además, compararemos el rendimiento de la previsión con otros algoritmos de codificación hechos por nosotros mismos y mostraremos cómo podemos comparar ambos enfoques dentro exactamente del mismo alcance (la misma validación cruzada / evaluación de prueba) a pesar de la característica de caja negra de la solución de auto-ml
que ofrece la plataforma de previsión.
Enfoque automático ML
Consigamos el conjunto de datos:
import pandas as pd df = pd.read_csv('winequality-white.csv', sep=';')
Creemos una submuestra (aproximadamente el 20%
del conjunto de datos general) que usaremos como un conjunto de datos de reserva, para evaluar el error de generalización de nuestros modelos. esta submuestra se dejará de lado y no se utilizará para capacitación.
Por lo tanto, descubriremos qué tan bien funcionarán nuestros modelos con datos nuevos (no vistos durante la fase de entrenamiento).
Existen muchas formas de crear la muestra, la más sencilla es utilizar train_test_split()
de scikit learn
.
from sklearn.model_selection import train_test_split train_set, test_set = train_test_split(df, test_size=0.2, random_state=42)
Durante el paso de ingeniería de características, puede construir dos tipos de características:
- Características derivadas del negocio: ejemplo aquí, si tenemos algún conocimiento en química en química, podemos extraer una nueva característica de una combinación de acidez fija, acidez volátil y ácido cítrico para crear una nueva característica explicativa.
- Funciones basadas en transformación: estas características se derivan de operaciones ML como escalado, codificación, normalización, componentes ACP… para crear nuevas características más valiosas para los modelos.
El segundo tipo de ingeniería de características es compatible con la plataforma: una vez que inicie el caso de uso en su conjunto de datos, puede seleccionar las transformaciones que desea aplicar en su conjunto de datos.
Se calcularán y agregarán automáticamente como características independientes para obtener más información sobre la transformación de características soportada por la plataforma consulte este enlace.
Lanzar canalización automática de ml dentro de 10 líneas de código
import previsionio as pio import pandas as pd URL = 'https://XXXX.prevision.io' TOKEN = '''YOUR_MASTER_TOKEN''' # initialize client workspace pio.prevision_client.client.init_client(URL, TOKEN)
Para lanzar un nuevo caso de uso, debe almacenarlos en su espacio de trabajo:
pio_train = pio.Dataset.new(name=’white-wine-train’, dataframe=train_set) pio_test = pio.Dataset.new(name=’white-wine-test’, dataframe=test_set)
Para lanzar un nuevo caso de uso, debe definir algunos parámetros de configuración y luego simplemente usar el SDK BaseUsecase
métodos derivados para que la plataforma se encargue automáticamente de iniciar todo por usted.
Ejemplo aquí necesitamos decirle a la plataforma que la columna de destino es quality
.
col_config = pio.ColumnConfig(target_column=’quality’)
Ahora también especificaremos algunos parámetros de entrenamiento, como qué modelos se utilizan, qué transformaciones se aplican y cómo se optimizan los modelos.
uc_config = pio.TrainingConfig(models=[pio.Model.LinReg, pio.Model.LightGBM, pio.Model.RandomForest], simple_models=[], features=pio.Feature.Full.drop(pio.Feature.PCA, pio.Feature.KMeans, pio.Feature.PolynomialFeatures), profile=pio.Profile.Quick)
Ahora usaremos el método `fit ()`
de la clase `previsionio.MultiClassification`
: seleccionamos la pérdida de registro como una métrica de rendimiento.
# now we will launch # launch Multiclassif auto ml use case uc = pio.MultiClassification.fit('wine_quality_from_sdk', dataset=pio_train, metric=pio.metrics.MultiClassification.log_loss, holdout_dataset=pio_test, column_config=col_config, training_config=uc_config, with_blend=False)
Puedes visitar esta publicación para obtener más información sobre las opciones de `fit ()`
.
Análisis de resultados
Para un caso de uso de clasificación múltiple, Prevision admite la estrategia OvA (uno contra todos). La plataforma generaría probabilidad para cada modalidad de la columna objetivo y la seleccionada es la argmax
.
descubramos las mejores actuaciones encontradas por la plataforma:
print(" models were trained on this usecase:n".format(len(uc))) for model in uc.models: print(model.name,' === ' ,'%.3f'%model.score, 'log_loss') print("n##################################################") print('The best model found in this use case is a', best.algorithm) print("the best cross validation performance is of log_loss".format('%.3f'%best.score)) print("n##################################################") print('The best model performance in the holdout-dataset is ', '%.3f'%uc._status['holdoutScore'])
=> El mejor modelo es un bosque aleatorio y su puntaje de val cruzado es 0.93
.
Ahora entrenaremos a un bosque aleatorio con scikit learn API
.
Enfoque basado en Scikit-learn
import numpy as np # Definir características X para subconjuntos de entrenamiento y prueba X_train = np.asarray (train_set.drop ('calidad', eje = 1)) X_test = np.asarray (test_set.drop ('calidad', eje = 1) )# Defina el objetivo y para subconjuntos de tren y prueba y_train = np.asarray (train_set ['calidad']) y_test = np.asarray (test_set ['calidad'])
Para asegurarnos de que tenemos los mismos pliegues de validación cruzada, construiremos un iterador personalizado para el parámetro cv del método cross_val_predict()
scikit learn
, consulte esta publicación para obtener más información.
Los pliegues de validación cruzada están disponibles a través de la propiedad cross_validation
del mejor modelo (de la clase prevision io.model.ClassificationModel
). Este tutorial proporciona más detalles sobre los atributos de los modelos de previsión.
best_cv = best.cross_validation folds = best_cv ['__ fold__']# crear un iterador cv personalizado: def custom_pio_folds (X, pio_cv = folds): for i in sorted (pio_cv.unique ()): idx_test = np.where (pio_cv == i) [0] idx_train = np.where (pio_cv ! = i) [0] rendimiento idx_train, idx_test
Ahora construiremos un modelo de bosque aleatorio con Scikit
, aprenderemos los hiperparámetros predeterminados y evaluaremos sus predicciones de validación cruzada dentro de los mismos pliegues que Previsión con la métrica log_loss
.
from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import cross_val_predict from sklearn.metrics import log_lossforest_clf = RandomForestClassifier(random_state=42) custom_cv = custom_pio_folds(X_train) y_pred_forest = cross_val_predict(forest_clf, X_train, y_train, cv=custom_cv, method='predict_proba')sk_score = log_loss(y_train, y_pred_forest) print('sckit learn default random forest log loss CV is {}'.format('%.3f' % sk_score))
Devuelve => 1.08
Ahora verifiquemos manualmente el mejor rendimiento del modelo encontrado por la plataforma:
predictions = best.cross_validation.drop(['ID', 'quality', 'pred_quality', '__fold__'], axis=1) predictions = predictions.loc[:, ['pred_quality_'+str(i) for i in sorted(best.cross_validation['quality'].unique())]] predictions = predictions.values true_values = best.cross_validation['quality'].valuespio_score = log_loss(true_values, predictions) print('%.3f' % pio_score)
Devuelve => 0.938
que es el mismo valor que el devuelto por el sdk
.
Usar hiperparámetros de Previsión
Cambiemos los hiperparámetros del clasificador de bosque aleatorio con el hiperparámetro del mejor modelo encontrado por la plataforma:
forest_clf = RandomForestClassifier(**best.hyperparameters) custom_cv = custom_pio_folds(X_train) y_pred_forest = cross_val_predict(forest_clf, X_train, y_train, cv=custom_cv, method='predict_proba')hyper_sk_score = log_loss(y_train, y_pred_forest) print('%.3f' % pio_score)
=> ¡Había devuelto 0.967
! que es bastante mejor que el anterior 1.087
.
Es incluso más simple que la búsqueda en cuadrícula o las técnicas hiperópticas de búsqueda aleatoria, ¡La plataforma ya lo había calculado para usted! (Es un truco muy inteligente para usar en desafíos de kaggle;)
).
Actuaciones de Holdout
Habíamos evaluado el rendimiento de la validación cruzada. Ahora verifiquemos el error de generalización usando el subconjunto de prueba:
forest_clf = RandomForestClassifier (random_state = 42)
forest_clf.fit (X_train, y_train)
preds = forest_clf.predict_proba (X_test)
log_loss (y_test, preds, labels = forest_clf.classes_)
=> Devolvió 0,95
forest_clf = RandomForestClassifier (** best.hyperparameters)
forest_clf.fit (X_train, y_train)
preds = forest_clf.predict_proba (X_test)
log_loss (y_test, preds, labels = forest_clf.classes_)
=> Devolvió 0.86 mucho mejor que el predeterminado.
uc._status ['holdoutScore']
=> ¡El resultado es 0,83 el mejor!
Esta pequeña brecha entre el rendimiento del modelo de previsión y el bosque aleatorio personalizado se debe a la transformación de características construida y agregada por la plataforma antes de entrenar los modelos.
Con el segundo, mantuvimos los parámetros predeterminados y obtuvimos un resultado pobre ( 1.08 )
, pero al usar los mejores hiperparámetros del modelo encontrados por la plataforma auto-ml
, la pérdida disminuyó a 0.967
, pero aún así el mejor rendimiento de val cruzado fue 0.938
de el mejor modelo.
Una vez más, quiero mostrar a través de esta publicación cómo las herramientas de Auto-ML
pueden facilitar nuestro trabajo. Para este caso de uso, solo tomó unos minutos crear, entrenar y evaluar una docena de modelos y encontrar el mejor.
Si desea probarlo por su cuenta, simplemente inicie sesión en la instancia en la nube de Prevision y obtendrá un acceso de prueba gratuito.
Realmente creo que las herramientas de auto-ml son el futuro de la IA, por lo tanto, tenemos que poner la mayor parte del esfuerzo en pensar en cómo integrar los modelos en nuestros sistemas en lugar de dedicar tiempo a crearlos y optimizarlos con el enfoque tradicional.
Gracias por leer este artículo.
Añadir comentario