Funktionalisering av data i automatiserad maskininlärning (AutoML)

GÄLLER FÖR:Azure Machine Learning SDK v1 för Python

Den här artikeln beskriver hur du anpassar inställningarna för datadriftsättning i Azure Machine Learning för dina autoML-experiment (automatiserad maskininlärning).

Funktionsutveckling och funktionalisering

Träningsdata består av rader och kolumner. Varje rad är en observation eller post, och kolumnerna i varje rad är de funktioner som beskriver varje post. Vanligtvis väljs de funktioner som bäst kännetecknar mönstren i data för att skapa förutsägelsemodeller.

Även om många av rådatafälten kan användas direkt för att träna en modell, är det ofta nödvändigt att skapa andra (konstruerade) funktioner som ger information för att bättre särskilja mönster i data. Den här processen kallas funktionsteknik, där användningen av domänkunskaper om data används för att skapa funktioner som i sin tur hjälper maskininlärningsalgoritmer att lära sig bättre.

I Azure Machine Learning används dataskalnings- och normaliseringstekniker för att göra funktionsframställning enklare. Tillsammans kallas dessa tekniker och den här funktionstekniken för funktionalisering i AutoML-experiment.

Förutsättningar

Den här artikeln förutsätter att du redan vet hur du konfigurerar ett AutoML-experiment.

Information om konfiguration finns i följande artiklar:

• För en programmeringsfokuserad upplevelse: Konfigurera AutoML-träning med Python
• För en no-code-upplevelse: Konfigurera autoML-träning utan kod för tabelldata med studiogränssnittet

Konfigurera funktionalisering

I varje AutoML-experiment tillämpas automatiska skalnings- och normaliseringstekniker på dina data som standard. Dessa tekniker är typer av funktionalisering som hjälper vissa algoritmer som är känsliga för funktioner i olika skalor. Du kan aktivera mer funktionalisering, till exempel imputation av saknade värden, kodning och transformeringar.

För experiment som du konfigurerar med Python SDK kan du aktivera eller inaktivera funktionaliseringsinställningen och ytterligare ange de funktionaliseringssteg som ska användas för experimentet. Om du använder Azure Machine Learning-studio kan du läsa stegen för att aktivera funktionalisering.

I följande tabell visas de godkända inställningarna för featurization i klassen AutoMLConfig:

Automatisk funktionalisering

I följande tabell sammanfattas tekniker som tillämpas automatiskt på dina data. De här teknikerna används för experiment som konfigureras med hjälp av SDK:t eller studiogränssnittet. Om du vill inaktivera det här beteendet anger du "featurization": 'off' i objektet AutoMLConfig .

I varje AutoML-experiment skalas eller normaliseras dina data automatiskt för att hjälpa algoritmer att prestera bra. Under modellträningen tillämpas någon av följande skalnings- eller normaliseringstekniker på varje modell.

Dataskyddsmekanismer

Dataskyddsmekanismer hjälper dig att identifiera potentiella problem med dina data, till exempel saknade värden eller obalanserade data. De hjälper dig också att vidta korrigerande åtgärder för bättre resultat.

Dataskyddsmekanismer tillämpas:

• För SDK-experiment: När parametrarna "featurization": 'auto' eller validation=auto anges i objektet AutoMLConfig .
• För studioexperiment: När automatisk funktionalisering är aktiverad.

Du kan granska dataskyddsmekanismerna för experimentet:

• Genom att ange show_output=True när du skickar ett experiment med hjälp av SDK: et.
• I studion går du till fliken Data guardrails i AutoML-körningen.

Dataskyddstillstånd

Dataskyddsmekanismer visar ett av tre tillstånd:

Dataskyddsmekanismer som stöds

I följande tabell beskrivs de dataskyddsmekanismer som stöds för närvarande och de associerade statusar som du kan se när du skickar experimentet:

Anpassa funktionalisering

Du kan anpassa dina funktionaliseringsinställningar för att säkerställa att de data och funktioner som används för att träna maskininlärningsmodellen resulterar i relevanta förutsägelser.

Om du vill anpassa funktionaliseringar anger du "featurization": FeaturizationConfig i objektet AutoMLConfig . Om du använder Azure Machine Learning Studio för experimentet kan du läsa konfigurera inställningar för funktionalisering. För att anpassa funktionaliseringen för prognosuppgifter, hänvisa till Anpassa funktionalisering.

Anpassningar som stöds är:

Du kan skapa FeaturizationConfig objektet med hjälp av API-anrop:

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})

Funktionaliseringstransparens

Varje AutoML-modell har funktionalisering automatiskt tillämpad. Funktionalisering omfattar automatiserad funktionsutveckling (när "featurization": 'auto') och skalning och normalisering, vilket sedan påverkar den valda algoritmen och dess hyperparametervärden. AutoML har stöd för olika metoder för att säkerställa att du har insyn i vad som tillämpades på din modell.

Tänk på det här prognosexemplet:

• Det finns fyra indatafunktioner: A (numeriskt), B (numeriskt), C (numeriskt), D (DateTime).
• Numerisk funktion C tas bort eftersom det är en ID-kolumn med alla unika värden.
• Numeriska funktioner A och B saknar värden och imputeras därför av medelvärdet.
• DateTime-funktion D omvandlas till 11 olika härledda funktioner.

Om du vill hämta denna fitted_model information, använd utdatan från din AutoML-experimentkörning.

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

Automatiserad funktionsutveckling

Funktionen get_engineered_feature_names() returnerar en lista över utformade funktionsnamn.

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

Den här listan innehåller alla skapade funktionsnamn.

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

get_featurization_summary() får en översikt över alla inmatningsfunktioner.

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

Utdata

[{'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']}]

Skalning och normalisering

Om du vill förstå skalning/normalisering och den valda algoritmen med dess hyperparametervärden använder du fitted_model.steps.

Följande exempelutdata kommer från att köra fitted_model.steps för en vald körning:

[('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))]

Om du vill ha mer information använder du den här hjälpfunktionen:

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()   

Den här hjälpfunktionen returnerar följande utdata för en viss körning med den specifika algoritmen LogisticRegression with RobustScalar.

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}

Förutsäga klassannolikheten

Modeller som skapas med AutoML har alla omslutningsobjekt som speglar funktioner från ursprungsklassen med öppen källkod. De flesta klassificeringsmodellomslutningsobjekt som returneras av AutoML implementerar predict_proba() funktionen, som accepterar ett matrisliknande eller gles matrisdataexempel på dina funktioner (X-värden) och returnerar en n-dimensionell matris för varje exempel och dess respektive klasss sannolikhet.

Förutsatt att du hämtade den bästa körningsmodellen och den anpassade modellen med samma anrop kan du anropa predict_proba() direkt från den anpassade modellen och tillhandahålla ett X_test exempel i lämpligt format beroende på modelltyp.

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

Om den underliggande modellen inte stöder predict_proba() funktionen eller om formatet är felaktigt genereras ett klassspecifikt modellfel. I referensdokumenten för RandomForestClassifier och XGBoost finns exempel på hur den här funktionen implementeras för olika modelltyper.

BERT-integrering i AutoML

Bidirectional Encoder Representations from Transformers (BERT) används i autoML-funktionaliseringsskiktet. Om en kolumn i det här lagret innehåller fritext eller andra typer av data, till exempel tidsstämplar eller enkla tal, tillämpas funktionalisering därefter.

För BERT är modellen finjusterad och tränad genom att använda de etiketter som tillhandahålls av användaren. Härifrån matas dokumentinbäddningar ut som funktioner tillsammans med andra, till exempel tidsstämpelbaserade funktioner eller veckodagar.

Lär dig hur du konfigurerar AutoML för att träna en bearbetningsmodell för naturligt språk med Python.

Steg för att anropa BERT

För att anropa BERT anger du enable_dnn: True i din automl_settings och använder en GPU-beräkning (vm_size = "STANDARD_NC6" eller högre GPU). Om en CPU-beräkning används aktiverar AutoML biLSTM DNN-funktionaliseraren i stället för BERT.

AutoML utför följande steg för BERT.

1. Förbearbetar och tokeniserar alla textkolumner. Transformatorn finns till exempel StringCast i den slutliga modellens funktionaliseringssammanfattning. Ett exempel på hur du skapar modellens funktionaliseringssammanfattning finns i den här Jupyter-anteckningsboken.

2. Sammanfogar alla textkolumner till en enda textkolumn, därav i StringConcatTransformer den slutliga modellen.

   Vår implementering av BERT begränsar den totala textlängden för ett träningsexempel till 128 tokens. Det innebär att alla textkolumner när de sammanfogas bör helst vara högst 128 token långa. Om det finns flera kolumner bör varje kolumn beskäras så att det här villkoret är uppfyllt. I annat fall trunkerar BERT:s tokenizerlager för sammanfogade kolumner med längd >128 token dessa indata till 128 token.

3. Som en del av funktionssanering jämför AutoML BERT med baslinjen (påse med ordfunktioner) på ett exempel på data. Den här jämförelsen avgör om BERT skulle ge förbättringar av noggrannheten. Om BERT presterar bättre än baslinjen använder AutoML sedan BERT för textfunktionalisering för hela data. I så fall visas PretrainedTextDNNTransformer i den slutliga modellen.

BERT körs vanligtvis längre än andra funktionaliserare. För bättre prestanda rekommenderar vi att du använder STANDARD_NC24r eller STANDARD_NC24rs_V3 för deras RDMA-funktioner.

AutoML distribuerar BERT-träning över flera noder om de är tillgängliga (upp till högst åtta noder). Detta kan göras i objektet AutoMLConfig genom att ange parametern max_concurrent_iterations till högre än 1.

Språk som stöds för BERT

AutoML stöder för närvarande cirka 100 språk. Beroende på datauppsättningens språk väljer AutoML lämplig BERT-modell. För tyska data använder vi den tyska BERT-modellen. För engelska använder vi den engelska BERT-modellen. För alla andra språk använder vi den flerspråkiga BERT-modellen.

I följande kod utlöses den tyska BERT-modellen eftersom datamängdsspråket anges till deu, språkkoden med tre bokstäver för tyska enligt ISO-klassificering:

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
}

Relaterat innehåll

• Distribuera maskininlärningsmodeller till Azure
• Träna en regressionsmodell med AutoML och Python