Datenfeaturisierung mit automatisiertem maschinellem Lernen

GILT FÜR: Python SDK azureml v1

In diesem Artikel wird erläutert, wie Sie die Einstellungen für die Datenfeaturisierung in Azure Machine Learning für Ihre Experimente mit automatisiertem maschinellem Lernen (automatisiertem ML) anpassen können.

Feature Engineering und Featurisierung

Die Trainingsdaten bestehen aus Zeilen und Spalten. Jede Zeile ist eine Beobachtung oder ein Datensatz, und die Spalten jeder Zeile sind die Features, mit denen die einzelnen Datensätze beschrieben werden. In der Regel werden zum Erstellen von Vorhersagemodellen die Features ausgewählt, die die Muster in den Daten am besten beschreiben.

Obwohl viele der Rohdatenfelder direkt zum Trainieren eines Modells verwendet werden können, ist es häufig erforderlich, zusätzliche (entwickelte) Features zu erstellen, die Informationen bereitstellen, mit denen die Muster in den Daten besser unterschieden werden können. Dieser Prozess wird Feature Engineering genannt. Dabei werden Kenntnisse zum Themenbereich der Daten genutzt, um Features zu erstellen, die ML-Algorithmen beim Lernen unterstützen.

In Azure Machine Learning wird das Feature Engineering mithilfe von Datenskalierungs- und Normalisierungstechniken vereinfacht. Zusammen werden diese Techniken und das Feature Engineering in Experimenten mit automatisiertem maschinellem Lernen (ML) als Featurisierung bezeichnet.

Voraussetzungen

In diesem Artikel wird davon ausgegangen, dass Sie bereits mit der Konfiguration eines Experiments für automatisiertes maschinelles Lernen vertraut sind.

Weitere Informationen zur Konfiguration finden Sie in den folgenden Artikeln:

• Für ein Code First-Konzept: Einrichten von AutoML-Training mit Python
• Für ein No-Code-Konzept: Einrichten des Trainings für automatisiertes maschinelles Lernen für Tabellendaten ohne Code über die Studio-Benutzeroberfläche

Konfigurieren der Featurisierung

Standardmäßig werden in jedem Experiment mit automatisiertem maschinellem Lernen automatische Skalierungs- und Normalisierungstechniken auf Ihre Daten angewandt. Bei diesen Techniken handelt es sich um Formen der Featurisierung, die für bestimmte Algorithmen hilfreich sind, die auf Features unterschiedlichen Größenordnungen reagieren. Sie können zusätzliche Featurisierungen wie die Zuschreibung fehlender Werte, Codierung und Transformationen aktivieren.

Bei Experimenten, die mit dem Python SDK konfiguriert werden, können Sie die Featurisierungseinstellung aktivieren oder deaktivieren und die Featurisierungsschritte für Ihr Experiment angeben. Wenn Sie Azure Machine Learning Studio verwenden, finden Sie unter Anpassen der Featurisierung weitere Informationen.

In der folgenden Tabelle sind die akzeptierten Einstellungen für featurization in der AutoMLConfig-Klasse aufgeführt:

Automatische Featurebereitstellung

In der folgenden Tabelle sind die Verfahren zusammengefasst, die automatisch auf die Daten angewendet werden. Diese Verfahren werden für Experimente angewendet, die mit dem SDK oder der Studio-Benutzeroberfläche konfiguriert werden. Um dieses Verhalten zu deaktivieren, legen Sie "featurization": 'off' in Ihrem AutoMLConfig-Objekt fest.

In jedem automatisierten Machine Learning-Experiment werden Ihre Daten automatisch skaliert oder normalisiert, damit die Algorithmen gut funktionieren. Während des Modelltrainings wird eine der folgenden Skalierungs- oder Normalisierungstechniken auf jedes Modell angewendet.

Schutzmaßnahmen für Daten

Der Datenintegritätsschutz hilft Ihnen dabei, potenzielle Probleme mit Ihren Daten zu identifizieren (z. B. fehlende Werte oder ein Klassenungleichgewicht). Sie helfen Ihnen auch, Korrekturmaßnahmen für verbesserte Ergebnisse zu ergreifen.

Der Datenintegritätsschutz wird für Folgendes angewendet:

• Bei SDK-Experimenten: Wenn in Ihrem AutoMLConfig-Objekt der Parameter "featurization": 'auto' oder validation=auto angegeben ist
• Bei Studio-Experimenten: Wenn die automatische Featurisierung aktiviert ist

Sie können den Datenintegritätsschutz für Ihr Experiment folgendermaßen überprüfen:

• Durch Festlegen von show_output=True, wenn Sie ein Experiment mit dem SDK übermitteln
• In Studio auf der Registerkarte Data guardrails (Datenintegritätsschutz) Ihrer Ausführung des automatisierten maschinellen Lernens

Zustände des Datenintegritätsschutzes

Der Datenintegritätsschutz zeigt einen von drei Zuständen an:

Unterstützter Datenintegritätsschutz

In der folgenden Tabelle werden der derzeit unterstützte Datenintegritätsschutz und die zugehörigen Statuswerte beschrieben, die Ihnen beim Übermitteln Ihres Experiments unter Umständen angezeigt werden:

Anpassen der Featurisierung

Sie können die Featurisierungseinstellungen anpassen, um sicherzustellen, dass die Daten und Features zum Trainieren Ihres ML-Modells zu relevanten Vorhersagen führen.

Um die Featurisierung anzupassen, geben Sie "featurization": FeaturizationConfig in Ihrem AutoMLConfig-Objekt an. Wenn Sie Azure Machine Learning Studio für Ihr Experiment verwenden, finden Sie weitere Informationen in dieser Anleitung. Informationen zum Anpassen der Featurisierung für Vorhersagetasktypen finden Sie unter Vorhersagen.

Unterstützte Anpassungen umfassen:

Erstellen Sie das FeaturizationConfig-Objekt mithilfe von API-Aufrufen:

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

Transparenz der Featurisierung

Auf jedes AutoML-Modell wird automatisch eine Featurisierung angewendet. Die Featurisierung umfasst automatisiertes Feature Engineering (wenn "featurization": 'auto') sowie Skalierung und Normalisierung, was sich dann auf den ausgewählten Algorithmus und seine Hyperparameterwerte auswirkt. AutoML unterstützt verschiedene Methoden, um sicherzustellen, dass Sie einen Überblick darüber haben, was auf Ihr Modell angewendet wurde.

Betrachten Sie dieses Vorhersagebeispiel:

• Es gibt vier Eingabemerkmale: A (numerisch), B (numerisch), C (numerisch), D (DateTime).
• Das numerische Feature C wird weggelassen, da es sich um eine ID-Spalte mit ausschließlich eindeutigen Werten handelt.
• Die Werte der numerischen Features A und B fehlen und werden daher als Mittelwerte zugerechnet.
• DateTime-Feature D wird in 11 verschiedenen entwickelten Features bereitgestellt.

Verwenden Sie die fitted_model-Ausgabe Ihrer automatisierten ML-Experimentausführung, um diese Informationen zu erhalten.

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

Automatisierte Featureentwicklung

get_engineered_feature_names() gibt eine Liste von Namen entwickelter Features zurück.

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

Diese Liste enthält alle Namen entwickelter Features.

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

get_featurization_summary() erhält eine Zusammenfassung der Featurisierung aller Eingabefeatures.

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

Skalierung und Normalisierung

Verwenden Sie fitted_model.steps, um die Skalierung/Normalisierung und den ausgewählten Algorithmus mit seinen Hyperparameterwerten zu verstehen.

Das folgende Beispiel zeigt die Ausgabe der Ausführung von fitted_model.steps für eine ausgewählte Ausführung:

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

Verwenden Sie diese Hilfsfunktion, um weitere Details zu erhalten:

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

Diese Hilfsfunktion gibt die folgende Ausgabe für eine bestimmte Ausführung zurück, wobei LogisticRegression with RobustScalar als spezifischer Algorithmus verwendet wird.

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}

Vorhersage der Klassenwahrscheinlichkeit

Mithilfe von automatisiertem ML erzeugte Modelle verfügen sämtlich über Wrapper-Objekte, die die Funktionalität ihrer Open-Source-Ursprungsklasse widerspiegeln. Die meisten Wrapper-Objekte von Klassifizierungsmodellen, die von automatisiertem ML zurückgegeben werden, implementieren die predict_proba()-Funktion, die eine Datenstichprobe Ihrer Features (X-Werte) in einer Array-ähnlichen oder Sparsematrixform akzeptiert und ein n-dimensionales Array jeder Stichprobe und ihrer jeweiligen Klassenwahrscheinlichkeit zurückgibt.

Wenn Sie mithilfe derselben Aufrufe die beste Ausführung und das angepasste Modell abgerufen haben, können Sie predict_proba() direkt aus dem angepassten Modell aufrufen, wobei Sie ein X_test-Beispiel im für den Modelltyp passenden Format bereitstellen.

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

Wenn das zugrunde liegende Modell die predict_proba()-Funktion nicht unterstützt oder das Format falsch ist, wird eine für die Modellklasse spezifische Ausnahme ausgelöst. Beispiele zur Implementierung dieser Funktion für verschiedene Modelltypen finden Sie in den Referenzdokumenten zu RandomForestClassifier und XGBoost.

BERT-Integration im automatisierten maschinellen Lernen

BERT wird auf der Featurisierungsebene des automatisierten maschinellen Lernens verwendet. Wenn in dieser Ebene eine Spalte freien Text oder andere Datentypen wie Zeitstempel oder einfache Zahlen enthält, dann wird die Featurisierung entsprechend angewendet.

Für BERT wird das Modell unter Verwendung der von den Anbietern zur Verfügung gestellten Bezeichnungen optimiert und trainiert. Von hier aus werden die Dokumenteinbettungen als Features neben anderen ausgegeben, z. B. zeitstempelbasierte Features, Wochentag.

Weitere Informationen finden Sie unter Einrichten von automatisiertem ML zum Trainieren eines Modells zur Verarbeitung natürlicher Sprache mit Python.

Schritte zum Aufrufen von BERT

Um BERT aufzurufen, legen Sie enable_dnn: True in Ihren „automl_settings“ fest und verwenden eine GPU-Computeressource (vm_size = "STANDARD_NC6" oder eine höhere GPU). Wenn eine CPU-Computeressource verwendet wird, aktiviert AutoML anstatt BERT den BiLSTM DNN-Featurizer.

Automatisiertes maschinelles Lernen führt die folgenden Schritte für BERT aus.

1. Vorverarbeitung und Tokenisierung aller Textspalten. Beispielsweise ist der StringCast-Transformator in der Featurisierungszusammenfassung für das endgültige Modell zu finden. Ein Beispiel dafür, wie die Zusammenfassung der Featurisierung des Modells zu erstellen ist, findet sich in diesem Notebook.

2. Verketten Sie alle Textspalten zu einer einzelnen Textspalte, daher das StringConcatTransformer im endgültigen Modell.

   Bei unserer Implementierung von BERT ist die Gesamttextlänge eines Trainingsbeispiels auf 128 Token eingeschränkt. Das bedeutet, dass bei der Verkettung alle Textspalten idealerweise höchstens 128 Token aufweisen sollten. Wenn mehrere Spalten vorhanden sind, sollte jede Spalte gekürzt werden, sodass diese Bedingung erfüllt ist. Bei verketteten Spalten mit einer Länge von mehr als >128 Token kürzt die Tokenizerebene von BERT diese Eingabe andernfalls auf 128 Token.

3. Im Rahmen des Featuresweepings wird BERT von AutoML mit der Baseline (Sammlung von Wortfeatures) für eine Stichprobe der Daten verglichen. Dieser Vergleich bestimmt, ob BERT die Genauigkeit erhöhen würde. Wenn BERT besser abschneidet als die Baseline, verwendet AutoML dann BERT zur Textfeatureisierung für die gesamten Daten. In diesem Fall wird im endgültigen Modell PretrainedTextDNNTransformer angezeigt.

Die Ausführung von BERT dauert im Allgemeinen länger als bei den anderen Featurizern. Für eine bessere Leistung wird aufgrund der jeweiligen RDMA-Funktionen die Verwendung von STANDARD_NC24r oder STANDARD_NC24rs_V3 empfohlen.

Beim automatisierten maschinellen Lernen wird das BERT-Training auf mehrere Knoten verteilt, wenn diese verfügbar sind (bis zu maximal acht Knoten). Dies kann in Ihrem AutoMLConfig-Objekt erfolgen, indem Sie den max_concurrent_iterations-Parameter auf einen höheren Wert als 1 festlegen.

Unterstützte Sprachen für BERT in AutoML

AutoML unterstützt derzeit ungefähr 100 Sprachen und wählt abhängig von der Sprache des Datasets das entsprechende BERT-Modell aus. Für Daten in deutscher Sprache wird das deutsche BERT-Modell verwendet. Für englische Daten wird das englische BERT-Modell verwendet. Für alle anderen Sprachen nutzen wir das mehrsprachige BERT-Modell.

Im folgenden Code wird das deutsche BERT-Modell ausgelöst, da deu als Datasetsprache angegeben ist, was gemäß ISO-Klassifizierung dem dreibuchstabigen Ländercode für Deutschland entspricht.

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
}

Zugehöriger Inhalt

• Bereitstellen von Machine Learning-Modellen für Azure
• Trainieren eines Regressionsmodells mit automatisiertem ML und Python