Definizione delle funzionalità dei dati in Machine Learning automatizzato (AutoML)

SI APPLICA A:Azure Machine Learning SDK v1 per Python

Questo articolo illustra come personalizzare le impostazioni di definizione delle funzionalità dei dati in Azure Machine Learning per esperimenti di Machine Learning automatizzato (AutoML).

Ingegneria e definizione delle funzionalità

I dati di training sono costituiti da righe e colonne. Ciascuna riga è un'osservazione o un record, mentre le colonne di ogni riga corrispondono alle funzionalità che descrivono ciascun record. In genere, le funzionalità che meglio caratterizzano i modelli nei dati vengono selezionate per creare modelli predittivi.

Anche se molti dei campi dati non elaborati possono essere usati direttamente per eseguire il training di un modello, spesso è necessario creare altre funzionalità (ingegneriate) che forniscono informazioni per differenziare meglio i modelli nei dati. Questo processo è denominato ingegneria delle funzionalità, in cui l'uso della conoscenza del dominio dei dati viene usato per creare funzionalità che a loro volta contribuiscono a un migliore apprendimento degli algoritmi di apprendimento automatico.

In Azure Machine Learning, vengono applicate tecniche di ridimensionamento dei dati e normalizzazione per semplificare l'ingegneria delle funzionalità. Collettivamente, queste tecniche e questa progettazione di funzionalità sono denominate funzionalità negli esperimenti AutoML.

Prerequisiti

Questo articolo presuppone che si sappia già come configurare un esperimento AutoML.

Per informazioni sulla configurazione, vedere gli articoli seguenti:

• Per un'esperienza code-first: configurare il training AutoML con Python
• Per un'esperienza senza codice: configurare il training AutoML senza codice per i dati tabulari con l'interfaccia utente di studio

Configurare la definizione delle funzionalità

In ogni esperimento autoML, le tecniche di ridimensionamento automatico e normalizzazione vengono applicate ai dati per impostazione predefinita. Queste tecniche sono tipi di definizione delle funzionalità che aiutano determinati algoritmi sensibili alle funzionalità su diverse scale. È possibile abilitare più definizioni delle funzionalità, ad esempio imputazione di valori mancanti, codifica e trasformazioni.

Per gli esperimenti configurati con Python SDK, è possibile abilitare o disabilitare l'impostazione di definizione delle funzionalità e specificare ulteriormente i passaggi di definizione delle funzionalità da usare per l'esperimento. Se si usa lo studio di Azure Machine Learning, vedere la procedura per abilitare la definizione delle funzionalità.

La tabella seguente illustra le impostazioni accettate per featurization nella classe AutoMLConfig:

Definizione automatica delle funzionalità

La tabella seguente riepiloga le tecniche applicate automaticamente ai dati. Queste tecniche vengono applicate per gli esperimenti configurati usando l'SDK o l'interfaccia utente dello studio. Per disabilitare questo comportamento, impostare "featurization": 'off' nell'oggetto AutoMLConfig.

In ogni esperimento AutoML, i dati vengono ridimensionati o normalizzati automaticamente per consentire alle prestazioni degli algoritmi. Durante il training del modello, viene applicata una delle tecniche di ridimensionamento o normalizzazione seguenti a ogni modello.

Protezioni dei dati

Le protezioni dei dati consentono di identificare potenziali problemi con i dati, ad esempio valori mancanti o dati sbilanciati. Consentono inoltre di eseguire azioni correttive per migliorare i risultati.

Le protezioni dei dati vengono applicate:

• Per gli esperimenti dell'SDK: quando i "featurization": 'auto' parametri o validation=auto sono specificati nell'oggetto AutoMLConfig .
• Per esperimenti di studio: quando è abilitata la descrizione della funzionalità automatica.

È possibile esaminare le protezioni dati per l'esperimento:

• Impostando show_output=True quando si invia un esperimento usando l'SDK.
• Nello studio, nella scheda Protezioni dei dati dell'esecuzione di AutoML.

Stati di protezione dati

Le protezioni dei dati visualizzano uno dei tre stati seguenti:

Protezioni dei dati supportate

Nella tabella seguente sono descritte le protezioni dei dati attualmente supportate e gli stati associati che potrebbero essere riscontrati durante l'invio dell'esperimento:

Personalizzare la definizione delle funzionalità

È possibile personalizzare le impostazioni di definizione delle funzionalità per assicurarsi che i dati e le funzionalità usati per eseguire il training del modello di Machine Learning comportino stime pertinenti.

Per personalizzare la definizione delle funzionalità, specificare "featurization": FeaturizationConfig nell'oggetto AutoMLConfig. Se si usa Azure Machine Learning Studio per l'esperimento, vedere Configurare le impostazioni di definizione delle funzionalità. Per personalizzare le caratteristiche per i tipi di attività di previsione, vedere Personalizzare le caratteristiche.

Personalizzazioni supportate:

È possibile creare l'oggetto FeaturizationConfig usando chiamate API:

featurization_config = FeaturizationConfig()
featurization_config.blocked_transformers = ['LabelEncoder']
featurization_config.drop_columns = ['aspiration', 'stroke']
featurization_config.add_column_purpose('engine-size', 'Numeric')
featurization_config.add_column_purpose('body-style', 'CategoricalHash')
#default strategy mean, add transformer param for 3 columns
featurization_config.add_transformer_params('Imputer', ['engine-size'], {"strategy": "median"})
featurization_config.add_transformer_params('Imputer', ['city-mpg'], {"strategy": "median"})
featurization_config.add_transformer_params('Imputer', ['bore'], {"strategy": "most_frequent"})
featurization_config.add_transformer_params('HashOneHotEncoder', [], {"number_of_bits": 3})

Trasparenza della definizione delle funzionalità

Ogni modello AutoML ha una definizione delle funzionalità applicata automaticamente. La definizione delle funzionalità include la progettazione automatizzata delle funzionalità (in caso di "featurization": 'auto') e scalabilità e normalizzazione, influendo quindi sull'algoritmo selezionato e sui relativi valori degli iperparametri. AutoML supporta metodi diversi per assicurarsi di avere visibilità su ciò che è stato applicato al modello.

Si consideri questo esempio di previsione:

• Sono disponibili quattro funzionalità di input: A (numerica), B (numerica), C (numerica), D (DateTime).
• La funzionalità numerica C viene eliminata poiché è una colonna ID con tutti i valori univoci.
• Le funzionalità numeriche A e B presentano valori mancanti e vengono quindi imputate in base alla media.
• La funzionalità DateTime D viene trasformata in 11 diverse funzionalità ingegnerizzate.

Per ottenere queste informazioni, utilizzare l'output fitted_model dell'esecuzione dell'esperimento AutoML.

automl_config = AutoMLConfig(…)
automl_run = experiment.submit(automl_config …)
best_run, fitted_model = automl_run.get_output()

Ingegneria delle funzionalità automatizzata

get_engineered_feature_names() restituisce un elenco dei nomi di funzionalità ingegnerizzate.

fitted_model.named_steps['timeseriestransformer']. get_engineered_feature_names ()

Questo elenco include tutti i nomi delle funzionalità ingegnerizzate.

['A', 'B', 'A_WASNULL', 'B_WASNULL', 'year', 'half', 'quarter', 'month', 'day', 'hour', 'am_pm', 'hour12', 'wday', 'qday', 'week']

get_featurization_summary() ottiene un riepilogo della definizione delle funzionalità di tutte le funzionalità di input.

fitted_model.named_steps['timeseriestransformer'].get_featurization_summary()

Risultato

[{'RawFeatureName': 'A',
  'TypeDetected': 'Numeric',
  'Dropped': 'No',
  'EngineeredFeatureCount': 2,
  'Tranformations': ['MeanImputer', 'ImputationMarker']},
 {'RawFeatureName': 'B',
  'TypeDetected': 'Numeric',
  'Dropped': 'No',
  'EngineeredFeatureCount': 2,
  'Tranformations': ['MeanImputer', 'ImputationMarker']},
 {'RawFeatureName': 'C',
  'TypeDetected': 'Numeric',
  'Dropped': 'Yes',
  'EngineeredFeatureCount': 0,
  'Tranformations': []},
 {'RawFeatureName': 'D',
  'TypeDetected': 'DateTime',
  'Dropped': 'No',
  'EngineeredFeatureCount': 11,
  'Tranformations': ['DateTime','DateTime','DateTime','DateTime','DateTime','DateTime','DateTime','DateTime',ateTime','DateTime','DateTime']}]

Ridimensionamento e normalizzazione

Per comprendere la scalabilità/normalizzazione e l'algoritmo selezionato con i valori degli iperparametri, usare fitted_model.steps.

L'output di esempio seguente deriva dall'esecuzione di fitted_model.steps per un'esecuzione scelta:

[('RobustScaler', 
  RobustScaler(copy=True, 
  quantile_range=[10, 90], 
  with_centering=True, 
  with_scaling=True)), 

  ('LogisticRegression', 
  LogisticRegression(C=0.18420699693267145, class_weight='balanced', 
  dual=False, 
  fit_intercept=True, 
  intercept_scaling=1, 
  max_iter=100, 
  multi_class='multinomial', 
  n_jobs=1, penalty='l2', 
  random_state=None, 
  solver='newton-cg', 
  tol=0.0001, 
  verbose=0, 
  warm_start=False))]

Per ottenere altri dettagli, usare questa funzione helper:

from pprint import pprint

def print_model(model, prefix=""):
    for step in model.steps:
        print(prefix + step[0])
        if hasattr(step[1], 'estimators') and hasattr(step[1], 'weights'):
            pprint({'estimators': list(e[0] for e in step[1].estimators), 'weights': step[1].weights})
            print()
            for estimator in step[1].estimators:
                print_model(estimator[1], estimator[0]+ ' - ')
        elif hasattr(step[1], '_base_learners') and hasattr(step[1], '_meta_learner'):
            print("\nMeta Learner")
            pprint(step[1]._meta_learner)
            print()
            for estimator in step[1]._base_learners:
                print_model(estimator[1], estimator[0]+ ' - ')
        else:
            pprint(step[1].get_params())
            print()   

Questa funzione helper restituisce l'output seguente per una particolare esecuzione usando LogisticRegression with RobustScalar come algoritmo specifico.

RobustScaler
{'copy': True,
'quantile_range': [10, 90],
'with_centering': True,
'with_scaling': True}

LogisticRegression
{'C': 0.18420699693267145,
'class_weight': 'balanced',
'dual': False,
'fit_intercept': True,
'intercept_scaling': 1,
'max_iter': 100,
'multi_class': 'multinomial',
'n_jobs': 1,
'penalty': 'l2',
'random_state': None,
'solver': 'newton-cg',
'tol': 0.0001,
'verbose': 0,
'warm_start': False}

Prevedere la probabilità della classe

I modelli prodotti con AutoML includono oggetti wrapper che rispecchiano la funzionalità della loro classe di origine open source. La maggior parte degli oggetti wrapper per modelli di classificazione restituiti da AutoML implementa la funzione predict_proba(), che accetta un campione di dati sotto forma di matrice o matrice sparsa delle caratteristiche (valori X) e restituisce una matrice n-dimensionale di ogni campione e la rispettiva probabilità di classe.

Supponendo di avere recuperato l'esecuzione migliore e adattato il modello usando le stesse chiamate, è possibile chiamare predict_proba() direttamente dal modello adattato, specificando un X_test di esempio nel formato appropriato, a seconda del tipo di modello.

best_run, fitted_model = automl_run.get_output()
class_prob = fitted_model.predict_proba(X_test)

Se il modello sottostante non supporta la funzione predict_proba() o il formato non è corretto, viene generata un'eccezione specifica della classe del modello. Per alcuni esempi su come viene implementata questa funzione per diversi tipi di modello, vedere la documentazione di riferimento di RandomForestClassifier e XGBoost.

Integrazione BERT in AutoML

Le rappresentazioni del codificatore bidirezionale da Transformers (BERT) vengono usate nel livello di definizione delle caratteristiche di AutoML. In questo livello, se una colonna contiene testo libero o altri tipi di dati, ad esempio timestamp o numeri semplici, la funzionalità viene applicata adeguatamente.

Nel caso di BERT, il modello è ottimizzato e addestrato utilizzando le etichette fornite dall'utente. Da qui, gli incorporamenti di documenti vengono restituiti come funzionalità insieme ad altre, ad esempio funzionalità basate su timestamp o giorno della settimana.

Informazioni sulla Configurazione di AutoML per eseguire il training di un modello di elaborazione del linguaggio naturale con Python.

Passaggi per richiamare BERT

Per richiamare BERT, impostare enable_dnn: True in automl_settings e usare calcolo GPU (vm_size = "STANDARD_NC6" o GPU di livello superiore). Se viene usato un calcolo CPU, invece di BERT AutoML abilita le funzionalità DNN BiLSTM.

AutoML esegue i passaggi seguenti per BERT.

1. Pre-elabora e tokenzza tutte le colonne di testo. Ad esempio, il trasformatore StringCast è disponibile nel riepilogo della definizione delle funzionalità del modello finale. Un esempio di come produrre il riepilogo delle caratteristiche del modello è disponibile in questo notebook jupyter.

2. Concatena tutte le colonne di testo in una singola colonna di testo, di conseguenza nel StringConcatTransformer modello finale.

   L'implementazione di BERT limita la lunghezza totale del testo di un campione di training a 128 token. Ciò significa che tutte le colonne di testo, quando vengono concatenate, dovrebbero avere una lunghezza massima di 128 token. Se sono presenti più colonne, è necessario eliminare ogni colonna in modo che questa condizione venga soddisfatta. In caso contrario, per le colonne concatenate di lunghezza di >128 token, il livello tokenizer di BERT tronca questo input a 128 token.

3. Nell'ambito dello sweep delle funzionalità, AutoML confronta BERT con la baseline (funzionalità contenitore di parole) su un campione di dati. Questo confronto determina se BERT offrirà miglioramenti dell'accuratezza. Se BERT offre prestazioni migliori rispetto alla baseline, AutoML usa BERT per la definizione delle funzionalità di testo per tutti i dati. In tal caso, viene visualizzato PretrainedTextDNNTransformer nel modello finale.

BERT viene in genere eseguito più a lungo rispetto ad altri featurizer. Per ottenere prestazioni migliori, è consigliabile usare STANDARD_NC24r o STANDARD_NC24rs_V3 per le relative funzionalità RDMA.

AutoML distribuisce il training BERT tra più nodi, se disponibili (fino a un massimo di otto nodi). Questa operazione può essere eseguita nell'oggetto AutoMLConfig impostando il parametro max_concurrent_iterations su maggiore di 1.

Lingue supportate per BERT

AutoML supporta attualmente circa 100 lingue. A seconda del linguaggio del set di dati, AutoML sceglie il modello BERT appropriato. Per i dati tedeschi si usa il modello BERT tedesco. Per l'inglese si usa il modello BERT inglese. Per tutte le altre lingue, si usa il modello BERT multilingue.

Nel codice seguente viene attivato il modello BERT tedesco perché la lingua del set di dati è specificata in deu, il codice linguistico di tre lettere per il tedesco in base alla classificazione ISO:

from azureml.automl.core.featurization import FeaturizationConfig

featurization_config = FeaturizationConfig(dataset_language='deu')

automl_settings = {
    "experiment_timeout_minutes": 120,
    "primary_metric": 'accuracy',
# All other settings you want to use
    "featurization": featurization_config,
    
    "enable_dnn": True, # This enables BERT DNN featurizer
    "enable_voting_ensemble": False,
    "enable_stack_ensemble": False
}

Contenuto correlato

• Distribuire modelli di apprendimento automatico in Azure
• Eseguire il training di un modello di regressione con AutoML e Python