Datadriftsättning i automatiserad maskininlärning

GÄLLER FÖR: Python SDK azureml v1

Den här artikeln beskriver hur du anpassar inställningarna för datadriftsättning i Azure Mašinsko učenje 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 som bättre skiljer 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 Mašinsko učenje 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 ml-experiment (automatiserad maskininlärning).

Förutsättningar

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

Information om konfiguration finns i följande artiklar:

• För en kod-första 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 automatiserat maskininlärningsexperiment 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 Mašinsko učenje 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 automatiserat maskininlärningsexperiment 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 obalans i klassen). 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 din automatiserade ML-körning.

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 ML-modellen resulterar i relevanta förutsägelser.

Om du vill anpassa funktionaliseringar anger du "featurization": FeaturizationConfig i objektet AutoMLConfig . Om du använder Azure Mašinsko učenje Studio för experimentet kan du läsa artikeln instruktioner. Om du vill anpassa funktionalisering för aktivitetstyper för prognostiseringar läser du anvisningar för prognostisering.

Anpassningar som stöds är:

Skapa objektet FeaturizationConfig 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-funktionen D är funktionsanpassad till 11 olika konstruerade funktioner.

Om du vill hämta den här informationen använder du fitted_model utdata från din automatiserade ML-experimentkörning.

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

Automatiserad funktionsutveckling

Returnerar get_engineered_feature_names() en lista över skapade 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']

Hämtar get_featurization_summary() en funktionaliseringssammanfattning av alla indatafunktioner.

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

Output

[{'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öras 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 LogisticRegression with RobustScalar specifika algoritmen.

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 klasssannolikheten

Modeller som produceras med automatiserad ML har alla omslutningsobjekt som speglar funktioner från ursprungsklassen med öppen källkod. De flesta omslutningsobjekt för klassificeringsmodeller som returneras av automatiserad ML implementerar predict_proba() funktionen, som accepterar ett matrisliknande eller gles matrisdataexempel för 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 automatiserad ML

BERT används i funktionaliseringsskiktet för automatiserad ML. 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 finjusteras och tränas modellen med hjälp av de av användare tillhandahållna etiketterna. 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 en högre GPU). Om en CPU-beräkning används aktiverar AutoML biLSTM DNN-funktionaliseraren i stället för BERT.

Automatiserad ML vidtar följande steg för BERT.

1. Förbearbetning och tokenisering av 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 notebook-filen.

2. Sammanfoga 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 i AutoML

AutoML stöder för närvarande cirka 100 språk och 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