Datadriftsättning i automatiserad maskininlärning

  • Artikel

GÄLLER FÖR:Python SDK azureml v1

Lär dig mer om inställningarna för dataprestationer i Azure Machine Learning och hur du anpassar dessa funktioner för automatiserade maskininlärningsexperiment.

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 ytterligare (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 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 automatiserade ML-experiment.

Förutsättningar

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

Viktigt!

Python-kommandona i den här artikeln kräver den senaste azureml-train-automl paketversionen.

Information om konfiguration finns i följande artiklar:

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.

Kommentar

Steg för automatiserad maskininlärning (till exempel funktionsnormalisering, hantering av saknade data eller konvertering av text till numerisk) blir en del av den underliggande modellen. När du använder modellen för förutsägelser tillämpas samma funktionaliseringssteg som tillämpas under träningen på dina indata automatiskt.

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:

Konfiguration av funktionalisering beskrivning
"featurization": 'auto' Anger att dataskyddsmekanismer och funktionaliseringssteg ska utföras automatiskt som en del av förbearbetningen. Den här inställningen är standard.
"featurization": 'off' Anger att funktionaliseringssteg inte ska utföras automatiskt.
"featurization": 'FeaturizationConfig' Anger att anpassade funktionaliseringssteg ska användas. Lär dig hur du anpassar funktionalisering.

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 .

Kommentar

Om du planerar att exportera dina AutoML-skapade modeller till en ONNX-modell stöds endast de funktionaliseringsalternativ som anges med en asterisk ("*") i ONNX-format. Läs mer om att konvertera modeller till ONNX.

Funktionaliseringssteg beskrivning
Släpp hög kardinalitet eller inga variansfunktioner* Ta bort de här funktionerna från tränings- och valideringsuppsättningar. Gäller för funktioner där alla värden saknas, med samma värde över alla rader eller med hög kardinalitet (till exempel hashvärden, ID:n eller GUID).)
Impute saknade värden* För numeriska funktioner kan du imputera med medelvärdet av värden i kolumnen.

För kategoriska funktioner kan du imputera med det vanligaste värdet.
Generera fler funktioner* För DateTime-funktioner: År, Månad, Dag, Veckodag, Dag på året, Kvartal, Vecka på året, Timme, Minut, Sekund.

För prognostiseringsaktiviteter skapas dessa ytterligare DateTime-funktioner: ISO-år, Halv-halvår, Kalendermånad som sträng, Vecka, Veckodag som sträng, Dag i kvartalet, Dag på året, AM/PM (0 om timmen är före 12:00), 1 annars), AM/PM som sträng, Timme på dagen (12-timmarsbasis)

För textfunktioner: Termfrekvens baserad på unigram, bigrams och trigram. Läs mer om hur det går till med BERT.
Transformera och koda* Omvandla numeriska funktioner som har få unika värden till kategoriska funktioner.

One-hot-kodning används för kategoriska funktioner med låg kardinalitet. One-hot-hash-kodning används för kategoriska funktioner med hög kardinalitet.
Word-inbäddningar En textbedriftatör konverterar vektorer av texttoken till meningsvektorer med hjälp av en förtränad modell. Varje ords inbäddningsvektor i ett dokument aggregeras med resten för att skapa en dokumentfunktionsvektor.
Klusteravstånd Tränar en k-means-klustringsmodell på alla numeriska kolumner. Genererar k nya funktioner (en ny numerisk funktion per kluster) som innehåller avståndet för varje exempel till centroiden för varje kluster.

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.

Skalning och bearbetning beskrivning
StandardScaleWrapper Standardisera funktioner genom att ta bort medelvärdet och skalningen till enhetsavvikelse
MinMaxScalar Transformerar funktioner genom att skala varje funktion efter kolumnens lägsta och högsta
MaxAbsScaler Skala varje funktion efter dess högsta absoluta värde
RobustScalar Skalar funktioner efter deras kvantilintervall
PCA Linjär dimensionsminskning med hjälp av singularvärdesfördelning av data för att projicera dem till ett lägre dimensionellt utrymme
TrunkeradeSVDWrapper Den här transformatorn utför linjär dimensionsreduktion med hjälp av trunkerad singulär värde nedbrytning (SVD). I motsats till PCA centreras inte denna skattningsfaktor data innan den beräknar singularvärdets nedbrytning, vilket innebär att den kan arbeta med scipy.sparse-matriser effektivt
SparseNormalizer Varje exempel (dvs. varje rad i datamatrisen) med minst en icke-nollkomponent skalas om oberoende av andra exempel så att dess norm (l1 eller l2) är lika med en

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:

Stat/län beskrivning
Passerade Inga dataproblem har identifierats och ingen åtgärd krävs av dig.
Gjort Ändringar har tillämpats på dina data. Vi rekommenderar att du granskar de korrigerande åtgärder som AutoML vidtog för att säkerställa att ändringarna överensstämmer med de förväntade resultaten.
Larmade Ett dataproblem upptäcktes men kunde inte åtgärdas. Vi rekommenderar att du ändrar och åtgärdar problemet.

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:

Skyddsräcke Status Villkor för utlösare
Imputering av saknade funktionsvärden Passerade


Klart		 Inga saknade funktionsvärden identifierades i dina träningsdata. Läs mer om imputation av saknade värden.

Saknade funktionsvärden identifierades i dina träningsdata och imputerades.
Funktionsidentifiering med hög kardinalitet Passerade


Klart		 Dina indata har analyserats och inga funktioner med hög kardinalitet har identifierats.

Funktioner med hög kardinalitet identifierades i dina indata och hanterades.
Hantering av valideringsdelning Klart Valideringskonfigurationen har angetts till 'auto' och träningsdata innehöll färre än 20 000 rader.
Varje iteration av den tränade modellen verifierades med hjälp av korsvalidering. Läs mer om valideringsdata.

Valideringskonfigurationen har angetts till 'auto', och träningsdata innehöll mer än 20 000 rader.
Indata har delats upp i en träningsdatauppsättning och en valideringsdatauppsättning för validering av modellen.
Identifiering av klassutjämning Passerade



Larmade


Klart		 Dina indata har analyserats och alla klasser balanseras i dina träningsdata. En datamängd anses vara balanserad om varje klass har en bra representation i datamängden, mätt i antal och förhållande mellan prover.

Obalanserade klasser identifierades i dina indata. Åtgärda utjämningsproblemet för att åtgärda modellfördomar. Läs mer om obalanserade data.

Obalanserade klasser identifierades i dina indata och den svepande logiken har bestämt sig för att tillämpa balansering.
Identifiering av minnesproblem Passerade



Klart
De valda värdena (horisont, fördröjning, rullande fönster) analyserades och inga potentiella problem med out-of-memory identifierades. Läs mer om konfigurationer för tidsserieprognoser.


De valda värdena (horisont, fördröjning, rullande fönster) analyserades och kan leda till att ditt experiment får slut på minne. Konfigurationerna för fördröjning eller rullande fönster har inaktiverats.
Frekvensidentifiering Passerade



Klart
Tidsserierna analyserades och alla datapunkter är justerade med den identifierade frekvensen.

Tidsserierna analyserades och datapunkter som inte överensstämmer med den identifierade frekvensen identifierades. Dessa datapunkter har tagits bort från datauppsättningen.
Korsvalidering Klart För att korrekt utvärdera de modeller som tränats av AutoML använder vi en datauppsättning som modellen inte tränas på. Om användaren inte tillhandahåller en explicit valideringsdatauppsättning används därför en del av träningsdatauppsättningen för att uppnå detta. För mindre datamängder (färre än 20 000 exempel) används korsvalidering, annars delas en enda undantagsuppsättning upp från träningsdata för att fungera som valideringsdatauppsättning. För dina indata använder vi därför korsvalidering med 10 gånger, om antalet träningsexempel är färre än 1 000 och 3 gånger i alla andra fall.
Train-Test data split Klart För att korrekt utvärdera de modeller som tränats av AutoML använder vi en datauppsättning som modellen inte tränas på. Om användaren inte tillhandahåller en explicit valideringsdatauppsättning används därför en del av träningsdatauppsättningen för att uppnå detta. För mindre datamängder (färre än 20 000 exempel) används korsvalidering, annars delas en enda undantagsuppsättning upp från träningsdata för att fungera som valideringsdatauppsättning. Därför har dina indata delats upp i en träningsdatauppsättning och en holdout-valideringsdatauppsättning.
Identifiering av tidsserie-ID Passerade



Åtgärdat
Datauppsättningen analyserades och inget duplicerat tidsindex identifierades.

Flera tidsserier hittades i datauppsättningen och tidsserieidentifierarna skapades automatiskt för datauppsättningen.
Aggregering av tidsserier Passerade



Åtgärdat
Datamängdsfrekvensen är justerad med användarens angivna frekvens. Ingen aggregering utfördes.

Data aggregerades för att uppfylla användarens angivna frekvens.
Kort seriehantering Passerade



Åtgärdat
Automatiserad ML identifierade tillräckligt många datapunkter för varje serie i indata för att fortsätta med träningen.

Automatiserad ML upptäckte att vissa serier inte innehöll tillräckligt med datapunkter för att träna en modell. För att fortsätta med träningen har dessa korta serier tappats eller vadderats.

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 Machine Learning-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:

Anpassning Definition
Uppdatering av kolumnsyfte Åsidosätt den automatiskt identifierade funktionstypen för den angivna kolumnen.
Uppdatering av transformeringsparameter Uppdatera parametrarna för den angivna transformatorn. Stöder för närvarande Imputer (medelvärde, vanligast och median) och HashOneHotEncoder.
Ta bort kolumner Anger kolumner som ska tas bort från funktionalisering.
Blockera transformatorer Anger blocktransformatorer som ska användas i funktionaliseringsprocessen.

Kommentar

Funktionen för släppkolumner är inaktuell från och med SDK version 1.19. Släpp kolumner från datauppsättningen som en del av datarensningen innan du använder den i ditt automatiserade ML-experiment.

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.

Kommentar

Använd "timeseriestransformer" för task='forecasting', annars använder du "datatransformer" för "regression" eller "klassificeringsaktivitet".

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','DateTime','DateTime','DateTime']}]
Output Definition
RawFeatureName Indatafunktions-/kolumnnamn från den angivna datamängden.
TypeDetected Datatypen för indatafunktionen har identifierats.
Tappade Anger om indatafunktionen har tagits bort eller använts.
EngineeringFeatureCount Antal funktioner som genereras via automatiserade funktionstekniska transformeringar.
Transformeringar Lista över transformeringar som tillämpas på indatafunktioner för att generera konstruerade funktioner.

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 har hämtat den bästa körnings- och anpassade modellen med samma anrop ovanifrån 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 undantag för modellen. 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 NLP-experiment (natural language processing) som även använder BERT med automatiserad ML.

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. Till exempel kan "StringCast"-transformatorn hittas 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
}

Nästa steg