Comparación de modelos de clasificación múltiple AutoML / Non-Auto-ML

Bienvenido, les saluda Miguel y aquí les traigo otro artículo.

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=';')

Crear subconjuntos de tren / prueba

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:

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

Paso 1: conéctese a su instancia a través del sdk

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)

Paso 2: registrar los subconjuntos de tren / prueba como conjuntos de datos de previsión

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)

Paso 3: configuración de entrenamiento y conjunto de datos

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)

Paso 4: lanzar un caso de uso de clasificación múltiple

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:

1- Bosque aleatorio con la configuración predeterminada de scikit learn

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

2- Bosque aleatorio con hiperparámetros del mejor modelo de previsión

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.

3- Mejor modelo de Prevision.io

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.

Gracias por leer este artículo.