Freigeben über

Einrichten von AutoML-Training mit Python

  • Artikel

GILT FÜR: Python SDK azureml v1

Hier erfahren Sie, wie Sie eine AutoML-Trainingsausführung (automatisiertes maschinelles Lernen) mit dem Python-SDK für Azure Machine Learning mithilfe von automatisiertem ML von Azure Machine Learning einrichten. Das automatisierte ML wählt einen Algorithmus und Hyperparameter für Sie aus und generiert ein Modell, das Sie anschließend bereitstellen können. Dieser Leitfaden enthält Details zu den verschiedenen Optionen, die Sie zum Konfigurieren von automatisierten ML-Experimenten verwenden können.

Ein vollständiges Beispiel finden Sie unter Tutorial: Trainieren eines Regressionsmodells mit AutoML.

Wenn Sie lieber ohne Code arbeiten, finden Sie hier Informationen zum Einrichten von AutoML-Training in Azure Machine Learning Studio ohne Code.

Voraussetzungen

Für diesen Artikel ist Folgendes erforderlich:

Auswählen der Experimentart

Legen Sie vor Experimentbeginn fest, welche Art von Problem des maschinellen Lernens Sie lösen möchten. Das automatisierte maschinelle Lernen unterstützt die Aufgabentypen classification, regression und forecasting. Weitere Informationen zu Aufgabentypen

Hinweis

Unterstützung für Aufgaben zur Verarbeitung natürlicher Sprache (Natural Language Processing, NLP): Bildklassifizierung (mit mehreren Klassen und mehreren Bezeichnungen) und Erkennung benannter Entitäten ist in der öffentlichen Vorschau verfügbar. Erfahren Sie mehr über NLP-Aufgaben in automatisiertem ML.

Diese Vorschaufunktionen werden ohne Vereinbarung zum Servicelevel bereitgestellt. Einige Funktionen werden möglicherweise nicht unterstützt, oder sie sind nur eingeschränkt verwendbar. Weitere Informationen finden Sie unter Zusätzliche Nutzungsbestimmungen für Microsoft Azure-Vorschauen.

Der folgende Code nutzt den Parameter task im Konstruktor AutoMLConfig, um den Experimenttyp classification anzugeben.

from azureml.train.automl import AutoMLConfig

# task can be one of classification, regression, forecasting
automl_config = AutoMLConfig(task = "classification")

Datenquelle und Datenformat

Das automatisierte Machine Learning unterstützt Daten, die sich auf dem lokalen Desktop oder in der Cloud (z. B. in Azure Blob Storage) befinden. Die Daten können in einen Pandas DataFrame oder ein Azure Machine Learning-TabularDataset eingelesen werden. Erfahren Sie mehr über Datasets.

Anforderungen für das Trainieren von Daten beim maschinellen Lernen:

  • Die Daten müssen in Tabellenform vorliegen.
  • Der Wert, der vorhergesagt werden soll (Zielspalte), muss in den Daten vorhanden sein.

Wichtig

Automatisierte ML-Experimente unterstützen kein Training mit Datasets, die identitätsbasierten Datenzugriff verwenden.

Für Remoteexperimente müssen Trainingsdaten über die Remotecomputeressource zugänglich sein. Automatisiertes ML akzeptiert nur TabularDatasets von Azure Machine Learning, wenn Sie auf einer Remotecomputeressource arbeiten.

Azure Machine Learning-Datasets stellen Funktionen für folgende Zwecke bereit:

  • Einfacher Datentransfer von statischen Dateien oder URL-Quellen in Ihren Arbeitsbereich
  • Bereitstellen Ihrer Daten für Trainingsskripts bei Ausführung auf Cloudcomputeressourcen (Ein Beispiel für die Verwendung der Dataset-Klasse zum Einbinden von Daten in Ihr Remotecomputeziel finden Sie unter Trainieren mit Datasets.)

Mit dem folgenden Code wird ein TabularDataset-Element aus einer Web-URL erstellt. Codebeispiele zum Erstellen von Datasets aus anderen Quellen wie lokalen Dateien und Datenspeichern finden Sie unter Erstellen eines TabularDataset-Elements.

from azureml.core.dataset import Dataset
data = "https://automlsamplenotebookdata.blob.core.windows.net/automl-sample-notebook-data/creditcard.csv"
dataset = Dataset.Tabular.from_delimited_files(data)

Für lokale Computeexperimente werden DataFrames-Objekte von Pandas für schnellere Verarbeitungszeiten empfohlen.

import pandas as pd
from sklearn.model_selection import train_test_split

df = pd.read_csv("your-local-file.csv")
train_data, test_data = train_test_split(df, test_size=0.1, random_state=42)
label = "label-col-name"

Trainieren, Überprüfen und Testen von Daten

Sie können separate Trainingsdaten und Datasets für die Überprüfung direkt im AutoMLConfig-Konstruktor angeben. Erfahren Sie mehr über das Konfigurieren von Training, Validierung, Kreuzvalidierung und Testdaten für Ihre AutoML-Experimente.

Wenn Sie keinen validation_data- oder n_cross_validation-Parameter explizit angeben, wendet das automatisierte maschinelle Lernen Standardverfahren an, um zu bestimmen, wie die Überprüfung durchgeführt wird. Diese Bestimmung hängt von der Anzahl der Zeilen im Dataset ab, das Ihrem training_data-Parameter zugewiesen wird.

Umfang der Trainingsdaten Validierungsverfahren
Mehr als 20.000 Zeilen Es wird eine Aufteilung in Trainings- und Validierungsdaten vorgenommen. Standardmäßig werden 10 % des ursprünglichen Trainingsdatasets als Validierungsset verwendet. Dieses Validierungsset wird seinerseits für die Metrikberechnung verwendet.
Weniger als 20.000 Zeilen Der Kreuzvalidierungsansatz wird angewendet. Die Standardanzahl der Faltungen (Folds) hängt von der Zeilenanzahl ab.
Wenn das Dataset weniger als 1.000 Zeilen aufweist, werden 10 Faltungen verwendet.
Wenn die Anzahl der Zeilen zwischen 1.000 und 20.000 liegt, werden drei Faltungen verwendet.

Tipp

Sie können Testdaten (Vorschau) hochladen, um Modelle zu bewerten, die durch automatisiertes maschinelles Lernen für Sie generiert wurden. Diese Features sind experimentelle Previewfunktionen und können jederzeit geändert werden. In diesem Artikel werden folgende Themen erläutert:

Wenn Sie eine Vorgehensweise ohne Code bevorzugen, fahren Sie mit Schritt 12 unter „Einrichten des automatisierten maschinellen Lernens mit der Studio-Benutzeroberfläche“ fort.

Große Datenmengen

Automatisiertes ML unterstützt eine begrenzte Anzahl von Algorithmen für das Training mit großen Datenmengen, die erfolgreich Modelle für große Daten auf kleinen virtuellen Computern erstellen können. Heuristiken für automatisiertes ML hängen von Eigenschaften wie der Datengröße, der Arbeitsspeichergröße des virtuellen Computers, dem Timeout für Experimente und den Featurisierungseinstellungen ab, um festzustellen, ob diese Algorithmen für große Datenmengen angewendet werden sollten. Erfahren Sie mehr darüber, welche Modelle beim automatisierten maschinellen Lernen unterstützt werden.

Wenn Sie diese Heuristiken außer Kraft setzen möchten, wenden Sie die folgenden Einstellungen an:

Aufgabe Einstellung Notizen
Blockieren von Datenstreamingalgorithmen blocked_models in Ihrem AutoMLConfig-Objekt und Auflisten der Modelle, die Sie nicht verwenden möchten. Führt entweder zu einem Ausführungsfehler oder zu einer langen Laufzeit.
Verwenden von Datenstreamingalgorithmen allowed_models in Ihrem AutoMLConfig-Objekt und Auflisten der Modelle, die Sie verwenden möchten.
Verwenden von Datenstreamingalgorithmen
(Experimente mit der Studio-Benutzeroberfläche)		 Blockieren Sie alle Modelle außer den Big Data-Algorithmen, die Sie verwenden möchten.

Computeziel zum Ausführen des Experiments

Legen Sie als Nächstes die Instanz fest, auf der das Modell trainiert werden soll. Ein Trainingsexperiment mit automatisiertem ML kann auf den folgenden Computeoptionen ausgeführt werden.

  • Wählen Sie ein lokales Computeziel aus: Wenn Ihr Szenario anfängliche Untersuchungen oder Demos mithilfe weniger Daten und kurzen Trainingsprozessen (d. h. Sekunden oder wenige Minuten pro untergeordnete Ausführung) umfasst, kann sich das Training auf Ihrem lokalen Computer als besser erweisen. Es gibt keine Einrichtungszeit, die Infrastrukturressourcen (Ihr Computer oder Ihre VM) sind sofort verfügbar. Ein Beispiel mit einem lokalen Computeziel finden Sie in diesem Notebook.

  • Wählen Sie ein Remote-ML-Computecluster aus: Wenn Sie wie beim Erstellen von Modellen für Produktionstraining Training mit größeren Datasets durchführen, die längere Trainingszeiträume erfordern, bietet ein Remotecomputeziel eine bessere Gesamtdauer, da AutoML Trainingsprozesse über Clusterknoten hinweg parallelisiert. Auf einem Remotecomputeziel werden etwa 1,5 Minuten pro untergeordnete Ausführung durch die Startzeit für die interne Infrastruktur hinzugefügt. Außerdem werden weitere Minuten für die Clusterinfrastruktur addiert, wenn die VMs noch nicht ausgeführt werden. Azure Machine Learning Managed Compute ist ein verwalteter Dienst, der es ermöglicht, Machine Learning-Modelle auf Clustern aus virtuellen Azure-Computern zu trainieren. Compute-Instanzen werden auch als Computeziel unterstützt.

  • Ein Azure Databricks-Cluster im Azure-Abonnement. Weitere Informationen finden Sie unter Einrichten eines Azure Databricks-Clusters für automatisiertes maschinelles Lernen. Beispielnotebooks mit Azure Databricks finden Sie auf der GitHub-Website.

Berücksichtigen Sie die folgenden Faktoren bei der Auswahl Ihres Computeziels:

Vorteile Nachteile
Lokales Computeziel
  • Keine Startzeit für die Umgebung
    		•
  • Teilmenge der Features
  • Keine Parallelisierung der Ausführungen
  • Schlechter für große Datenmengen
  • Kein Datenstreaming während des Trainings
  • Keine DNN-basierte Featurisierung
  • Nur Python SDK
    		•
    Remote-ML-Computecluster
  • Alle Features
  • Parallelisierung untergeordneter Ausführungen
  • Unterstützung großer Datasets
  • DNN-basierte Featurisierung
  • Dynamische Skalierbarkeit von Computeclustern nach Bedarf
  • Webbenutzeroberfläche zur Verwendung ohne Programmiererfahrung
    		•
  • Startzeit für Clusterknoten
  • Startzeit für jede untergeordnete Ausführung
    		•

    Konfigurieren der Experimenteinstellungen

    Es gibt mehrere Optionen zum Konfigurieren von Experimenten mit automatisiertem ML. Diese Parameter werden beim Instanziieren eines AutoMLConfig-Objekts festgelegt. Unter AutoMLConfig-Klasse finden Sie eine vollständige Liste der Parameter.

    Das folgende Beispiel gilt für eine Klassifizierungsaufgabe. Im Experiment wird die AUC gewichtet als primäre Metrik verwendet. Für das Experiment sind ein Timeoutwert von 30 Minuten und zwei Faltungen für die Kreuzvalidierung festgelegt.

        automl_classifier=AutoMLConfig(task='classification',
                                   primary_metric='AUC_weighted',
                                   experiment_timeout_minutes=30,
                                   blocked_models=['XGBoostClassifier'],
                                   training_data=train_data,
                                   label_column_name=label,
                                   n_cross_validations=2)

    Sie können auch Vorhersageaufgaben konfigurieren, was eine zusätzliche Einrichtung erfordert. Weitere Informationen finden Sie im Artikel Einrichten von AutoML zum Trainieren eines Zeitreihenvorhersagemodells mit Python.

        time_series_settings = {
                            'time_column_name': time_column_name,
                            'time_series_id_column_names': time_series_id_column_names,
                            'forecast_horizon': n_test_periods
                           }
    
    automl_config = AutoMLConfig(
                                 task = 'forecasting',
                                 debug_log='automl_oj_sales_errors.log',
                                 primary_metric='normalized_root_mean_squared_error',
                                 experiment_timeout_minutes=20,
                                 training_data=train_data,
                                 label_column_name=label,
                                 n_cross_validations=5,
                                 path=project_folder,
                                 verbosity=logging.INFO,
                                 **time_series_settings
                                )

    Unterstützte Modelle

    Beim automatisierten maschinellen Lernen werden während des Automatisierungs- und Optimierungsprozesses verschiedene Modelle und Algorithmen getestet. Als Benutzer müssen Sie den Algorithmus nicht angeben.

    Die drei verschiedenen Werte des Parameters task bestimmen die Liste der anzuwendenden Algorithmen oder Modelle. Verwenden Sie die Parameter allowed_models oder blocked_models, um Iterationen mit den verfügbaren Modellen, die eingeschlossen oder ausgeschlossen werden sollen, weiter zu ändern. In der folgenden Tabelle werden die unterstützten Modelle anhand des Tasktyps zusammengefasst.

    Hinweis

    Wenn Sie vorhaben, Ihre mit automatisiertem ML erstellten Modelle in ein ONNX-Modell zu exportieren, beachten Sie, dass nur mit einem Sternchen (*) angegebene Algorithmen in das ONNX-Format konvertiert werden können. Erfahren Sie mehr über das Konvertieren von Modellen zu ONNX.

    Beachten Sie auch, dass ONNX zurzeit nur Klassifizierungs- und Regressionsaufgaben unterstützt.

    Klassifizierung Regression Zeitreihe und Vorhersage
    Logistische Regression* Elastisches Netz* AutoARIMA
    Light GBM* Light GBM* Prophet
    Gradient Boosting* Gradient Boosting* Elastisches Netz
    Entscheidungsstruktur* Entscheidungsstruktur* Light GBM
    K nächste Nachbarn* K nächste Nachbarn* Gradient Boosting
    Lineare SVC* LARS-Lasso* Entscheidungsstruktur
    Support Vector Classification (SVC)* Stochastisches Gradientenabstiegsverfahren (SGD)* Arimax
    Zufällige Gesamtstruktur* Random Forest LARS Lasso
    Extremely Randomized Trees* Extremely Randomized Trees* Stochastisches Gradientenabstiegsverfahren (SGD)
    XGBoost* XGBoost* Random Forest
    Averaged Perceptron Classifier Online Gradient Descent Regressor Xgboost
    Naive Bayes* Schneller linearer Regressor ForecastTCN
    Stochastisches Gradientenabstiegsverfahren (SGD)* Naiv
    Linearer SVM-Klassifizierer* SeasonalNaive
    Average
    SeasonalAverage
    ExponentialSmoothing

    Primary metric (Primäre Metrik)

    Der Parameter primary_metric bestimmt die Metrik, die während des Modelltrainings für die Optimierung verwendet werden soll. Die verfügbaren Metriken, die Sie auswählen können, richten sich nach der Art der ausgewählten Aufgabe.

    Bei der Auswahl einer primären Metrik für optimiertes automatisiertes ML muss eine Vielzahl von Faktoren berücksichtigt werden. Der wichtigste Aspekt sollte sein, welche Metrik Ihre Geschäftsanforderungen am besten widerspiegelt. Anschließend sollten Sie überprüfen, ob die Metrik für Ihr Datasetprofil (Datengröße, Datenbereich, Klassenverteilung usw.) geeignet ist. In den folgenden Abschnitten werden die empfohlenen primären Metriken basierend auf dem Aufgabentyp und Geschäftsszenario zusammengefasst.

    Informationen zu den speziellen Definitionen dieser Metriken finden Sie unter Grundlagen von Ergebnissen des automatisierten maschinellen Lernens.

    Metriken für Klassifizierungsszenarien

    Schwellenwertabhängige Metriken wie accuracy, recall_score_weighted, norm_macro_recall und precision_score_weighted sind möglicherweise nicht optimal für kleine Datensätze, die eine sehr große Klassenschiefe (Klassenungleichgewicht) aufweisen, oder wenn der erwartete Metrikwert sehr nahe bei 0,0 oder 1,0 liegt. In diesen Fällen eignet sich AUC_weighted möglicherweise besser als primäre Metrik. Nach Abschluss des automatisierten ML können Sie das stärkste Modell basierend auf der Metrik auswählen, die sich am besten für Ihre Geschäftsanforderungen eignet.

    Metrik Beispiel eines Anwendungsfalls
    accuracy Bildklassifizierung, Stimmungsanalyse, Vorhersage der Kundenabwanderung
    AUC_weighted Betrugserkennung, Bildklassifizierung, Anomalie-/Spamerkennung
    average_precision_score_weighted Stimmungsanalyse
    norm_macro_recall Vorhersage der Kundenabwanderung
    precision_score_weighted

    Metriken für Regressionsszenarien

    r2_score, normalized_mean_absolute_error und normalized_root_mean_squared_error versuchen alle, die Vorhersagefehler zu minimieren. r2_score und normalized_root_mean_squared_error minimieren beide die durchschnittlichen quadratischen Fehler, während normalized_mean_absolute_error den durchschnittlichen absoluten Wert der Fehler minimiert. Der absolute Wert behandelt Fehler aller Größenordnungen gleich, und quadrierte Fehler haben einen viel größeren Nachteil für Fehler mit größeren absoluten Werten. Je nachdem, ob größere Fehler stärker bestraft werden sollen oder nicht, kann man wählen, ob man den quadratischen Fehler oder den absoluten Fehler optimiert.

    Der Hauptunterschied zwischen r2_score und normalized_root_mean_squared_error ist die Art und Weise, wie sie normalisiert werden, und ihre Bedeutung. normalized_root_mean_squared_error ist der mittlere quadratische Fehler, normiert auf den Bereich und kann als durchschnittliche Fehlergröße für die Vorhersage interpretiert werden. r2_score ist der mittlere quadratische Fehler, normalisiert durch eine Schätzung der Varianz der Daten. Es ist der Anteil der Variation, der durch das Modell erfasst werden kann.

    Hinweis

    r2_score und normalized_root_mean_squared_error verhalten sich auch als primäre Metriken ähnlich. Wenn ein fester Validierungssatz verwendet wird, optimieren diese beiden Metriken dasselbe Ziel, nämlich den mittleren quadratischen Fehler, und werden von demselben Modell optimiert. Wenn nur ein Trainingsset zur Verfügung steht und Kreuzvalidierung angewendet wird, würden sie sich leicht unterscheiden, da der Normalisierer für normalized_root_mean_squared_error als Bereich des Trainingssets festgelegt ist, aber der Normalisierer für r2_score würde für jede Falte variieren, da er die Varianz für jede Falte darstellt.

    Wenn der Rang und nicht der genaue Wert von Interesse ist, kann spearman_correlation die bessere Wahl sein, da er die Rangkorrelation zwischen realen Werten und Vorhersagen misst.

    Derzeit gibt es jedoch keine primäre Regressionsmetrik, die sich mit relativen Unterschieden befasst. Alle r2_score, normalized_mean_absolute_error und normalized_root_mean_squared_error behandeln einen Vorhersagefehler von $20k für einen Arbeitnehmer mit einem Gehalt von $30k genauso wie für einen Arbeitnehmer, der $20M verdient, wenn diese beiden Datenpunkte zum selben Datensatz für die Regression oder zur selben Zeitreihe gehören, die durch den Zeitreihenbezeichner angegeben wird. Tatsächlich ist ein Vorhersagefehler bzw. eine Abweichung von 20.000 USD bei einem Jahresgehalt von 20 Millionen USD jedoch sehr nah am eigentlichen Wert (eine geringe relative Differenz von 0,1 %), wohingegen ein Vorhersagefehler bzw. eine Abweichung von 20.000 USD bei einem Gehalt von 30.000 USD eine erhebliche Abweichung darstellt (eine große relative Differenz von 67 %). Um das Problem der relativen Unterschiede zu lösen, kann man ein Modell mit den verfügbaren primären Metriken trainieren und dann das Modell mit den besten mean_absolute_percentage_error oder root_mean_squared_log_error auswählen.

    Metrik Beispiel eines Anwendungsfalls
    spearman_correlation
    normalized_root_mean_squared_error Preisvorhersage (Haus/Produkt/Trinkgeld), Vorhersage eines Bewertungsergebnisses
    r2_score Verspätungen bei Fluggesellschaften, Gehaltsschätzung, erforderlicher Zeitaufwand bis zur Problemlösung
    normalized_mean_absolute_error

    Metriken für Szenarien zur Zeitreihenvorhersage

    Die Empfehlungen ähneln den Empfehlungen für Regressionsszenarien.

    Metrik Beispiel eines Anwendungsfalls
    normalized_root_mean_squared_error Preisvorhersage, Bestandoptimierung, Bedarfsvorhersage
    r2_score Preisvorhersage, Bestandoptimierung, Bedarfsvorhersage
    normalized_mean_absolute_error

    Merkmalerstellung für Daten

    In jedem Experiment mit automatisiertem ML werden Ihre Daten automatisch skaliert und normalisiert, um bestimmte Algorithmen zu unterstützen, die auf Features mit unterschiedlichen Skalierungen sensibel reagieren. Diese Skalierung und Normalisierung wird als Featurisierung bezeichnet. Weitere Informationen und Codebeispiele finden Sie unter Featurisierung in AutoML.

    Hinweis

    Die Schritte zur Featurebereitstellung bei automatisiertem maschinellen Lernen (Featurenormalisierung, Behandlung fehlender Daten, Umwandlung von Text in numerische Daten usw.) werden Teil des zugrunde liegenden Modells. Bei Verwendung des Modells für Vorhersagen werden die während des Trainings angewendeten Schritte zur Featurebereitstellung automatisch auf Ihre Eingabedaten angewendet.

    Beim Konfigurieren Ihrer Experimente im Objekt AutoMLConfig können Sie die Einstellung featurization aktivieren/deaktivieren. In der folgenden Tabelle werden die akzeptierten Einstellungen für die Featurisierung im AutoMLConfig-Objekt aufgeführt.

    Konfiguration der Featurebereitstellung BESCHREIBUNG
    "featurization": 'auto' Gibt an, dass im Rahmen der Vorverarbeitung die folgenden Schritte für Datenschutzmaßnahmen und Featurebereitstellung automatisch durchgeführt werden. Standardeinstellung.
    "featurization": 'off' Gibt an, dass der Featurisierungsschritt nicht automatisch durchgeführt werden soll
    "featurization": 'FeaturizationConfig' Gibt an, dass ein angepasster Featurebereitstellungsschritt verwendet werden soll. Erfahren Sie, wie Sie die Featurebereitstellung anpassen.

    Ensemble-Konfiguration

    Ensemble-Modelle sind standardmäßig aktiviert und treten als abschließende Ausführungsiterationen in einer AutoML-Ausführung auf. Derzeit werden VotingEnsemble und StackEnsemble unterstützt.

    Mit VotingEnsemble wird Soft-Voting implementiert, wobei gewichtete Durchschnittswerte verwendet werden. Bei der StackEnsemble-Implementierung wird eine Implementierung auf zwei Ebenen verwendet, bei der die erste Ebene dieselben Modelle wie VotingEnsemble besitzt, und das Modell der zweiten Ebene verwendet wird, um die optimale Kombination der Modelle aus der ersten Ebene zu ermitteln.

    Wenn Sie ONNX-Modelle verwenden oder die Modellerklärung aktiviert haben, wird StackEnsemble deaktiviert und nur VotingEnsemble wird verwendet.

    Das Ensemble-Training kann mithilfe der booleschen Parameter enable_voting_ensemble und enable_stack_ensembledeaktiviert werden.

    automl_classifier = AutoMLConfig(
                                 task='classification',
                                 primary_metric='AUC_weighted',
                                 experiment_timeout_minutes=30,
                                 training_data=data_train,
                                 label_column_name=label,
                                 n_cross_validations=5,
                                 enable_voting_ensemble=False,
                                 enable_stack_ensemble=False
                                )

    Es gibt mehrere Standardargumente, die als kwargs in einem AutoMLConfig-Objekt bereitgestellt werden können, um das Ensemble-Standardverhalten zu verändern.

    Wichtig

    Die folgenden Parameter sind keine expliziten Parameter der AutoMLConfig-Klasse.

    • ensemble_download_models_timeout_sec: Während der VotingEnsemble- und StackEnsemble-Modellgenerierung werden mehrere angepasste Modelle aus den vorherigen Ausführungen untergeordneter Elemente heruntergeladen. Wenn der folgende Fehler angezeigt wird, müssen Sie möglicherweise mehr Zeit für das Herunterladen der Modelle einplanen: AutoMLEnsembleException: Could not find any models for running ensembling. Der Standardwert beträgt 300 Sekunden für das parallele Herunterladen dieser Modelle, und es gibt kein maximales Timeoutlimit. Konfigurieren Sie diesen Parameter mit einem höheren Wert als 300 Sekunden, wenn mehr Zeit erforderlich ist.

      Hinweis

      Wenn das Zeitlimit erreicht ist und Modelle heruntergeladen wurden, wird das Ensembling mit so vielen Modellen fortgesetzt, wie es heruntergeladen hat. Es ist nicht erforderlich, dass alle Modelle heruntergeladen werden müssen, um innerhalb dieses Zeitlimits fertig zu werden. Die folgenden Parameter gelten nur für StackEnsemble-Modelle:

    • stack_meta_learner_type: Der meta-learner ist ein mit der Ausgabe der einzelnen heterogenen Modelle trainiertes Modell. Standard-meta-learner sind LogisticRegression für Klassifizierungsaufgaben (oder LogisticRegressionCV, wenn die Kreuzvalidierung aktiviert ist) und ElasticNet für Regressions-/Vorhersage-Aufgaben (oder ElasticNetCV, wenn die Kreuzvalidierung aktiviert ist). Dieser Parameter kann ein der folgenden Zeichenfolgen sein: LogisticRegression, LogisticRegressionCV, LightGBMClassifier, ElasticNet, ElasticNetCV, LightGBMRegressor oder LinearRegression.

    • stack_meta_learner_train_percentage: gibt den Teil des Trainingssatzes an (bei Auswahl des Trainings- und Validierungstyps des Trainings), der für das Training des meta-learners reserviert werden soll. Der Standardwert ist 0.2.

    • stack_meta_learner_kwargs: optionale Parameter, die an den Initialisierer des meta-learners übergeben werden sollen. Diese Parameter und Parametertypen spiegeln die Parameter und Parametertypen des entsprechenden Modellkonstruktors wider und werden an den Modellkonstruktor weitergeleitet.

    Der folgende Code zeigt ein Beispiel für das Angeben des benutzerdefinierten Ensemble-Verhaltens in einem AutoMLConfig-Objekt.

    ensemble_settings = {
                     "ensemble_download_models_timeout_sec": 600
                     "stack_meta_learner_type": "LogisticRegressionCV",
                     "stack_meta_learner_train_percentage": 0.3,
                     "stack_meta_learner_kwargs": {
                                                    "refit": True,
                                                    "fit_intercept": False,
                                                    "class_weight": "balanced",
                                                    "multi_class": "auto",
                                                    "n_jobs": -1
                                                  }
                    }
automl_classifier = AutoMLConfig(
                                 task='classification',
                                 primary_metric='AUC_weighted',
                                 experiment_timeout_minutes=30,
                                 training_data=train_data,
                                 label_column_name=label,
                                 n_cross_validations=5,
                                 **ensemble_settings
                                )

    Exit Criteria (Beendigungskriterien)

    Es gibt einige Optionen, die Sie in Ihrer AutoMLConfig definieren können, um Ihr Experiment zu beenden.

    Kriterien description
    Keine Kriterien Wenn Sie keine Beendigungsparameter definieren, wird das Experiment fortgesetzt, bis kein weiterer Fortschritt bei Ihrer primären Metrik erzielt wird.
    Nach einer Zeitspanne Verwenden Sie experiment_timeout_minutes in Ihren Einstellungen, um zu definieren, wie lange Ihr Experiment in Minuten weiterhin ausgeführt werden soll.

    Es liegt ein Mindestwert von 15 Minuten vor (oder 60 Minuten, wenn die Zeile nach Spaltengröße 10 Millionen überschreitet), um Fehler aufgrund von Zeitüberschreitungen beim Experiment zu vermeiden.
    Eine Bewertung wurde erreicht Wenn Sie experiment_exit_score verwenden, wird das Experiment abgeschlossen, nachdem der angegebene primäre metrischer Bewertungswert erreicht wurde.

    Ausführen des Experiments

    Warnung

    Wenn Sie ein Experiment mit denselben Konfigurationseinstellungen und derselben primären Metrik mehrmals durchführen, werden Sie wahrscheinlich bei jedem Experiment eine Abweichung in der abschließenden metrischen Bewertung und in den generierten Modellen sehen. Die Algorithmen, die beim automatisierten maschinellen Lernen eingesetzt werden, weisen eine inhärente Zufälligkeit auf, die zu geringfügigen Abweichungen bei den im Experiment ausgegebenen Modellen und der abschließenden metrischen Bewertung eines empfohlenen Modells führen kann, z. B. bei der Genauigkeit. Sie werden wahrscheinlich auch Ergebnisse mit demselben Modellnamen, aber unterschiedlichen verwendeten Hyperparametern erhalten.

    Für automatisierte ML-Experimente erstellen Sie ein Experiment-Objekt, wobei es sich um ein benanntes Objekt in einem Workspace handelt, das zur Ausführung von Experimenten verwendet wird.

    from azureml.core.experiment import Experiment

ws = Workspace.from_config()

# Choose a name for the experiment and specify the project folder.
experiment_name = 'Tutorial-automl'
project_folder = './sample_projects/automl-classification'

experiment = Experiment(ws, experiment_name)

    Übermitteln Sie das auszuführende Experiment, um ein Modell zu generieren. Übergeben Sie die Methode AutoMLConfig an die submit-Methode, um das Modell zu generieren.

    run = experiment.submit(automl_config, show_output=True)

    Hinweis

    Abhängigkeiten werden zunächst auf einem neuen Computer installiert. Es dauert bis zu 10 Minuten, bevor die Ausgabe angezeigt wird. Wenn Sie show_output auf True festlegen, wird die Ausgabe auf der Konsole angezeigt.

    Mehrere untergeordnete Ausführungen auf Clustern

    Untergeordnete Ausführungen von automatisierten ML-Experimenten können auf einem Cluster durchgeführt werden, auf dem bereits ein anderes Experiment ausgeführt wird. Das Timing hängt jedoch davon ab, über wie viele Knoten der Cluster verfügt und ob diese Knoten zur Ausführung eines anderen Experiments zur Verfügung stehen.

    Jeder Knoten im Cluster fungiert als einzelner virtueller Computer (VM), der eine einzelne Trainingsausführung durchführen kann. Für automatisiertes ML bedeutet dies eine untergeordnete Ausführung. Wenn alle Knoten ausgelastet sind, wird das neue Experiment in die Warteschlange gestellt. Wenn es jedoch freie Knoten gibt, führt das neue Experiment untergeordnete Ausführungen von automatisiertem ML parallel auf den verfügbaren Knoten/VMs aus.

    Um die Verwaltung von untergeordneten Ausführungen und deren Zeitpunkt der Durchführung zu erleichtern, empfehlen wir Ihnen, einen dedizierten Cluster pro Experiment zu erstellen und die Anzahl von max_concurrent_iterations Ihres Experiments an die Anzahl der Knoten im Cluster anzupassen. Auf diese Weise verwenden Sie alle Clusterknoten gleichzeitig mit der von Ihnen gewünschten Anzahl von gleichzeitigen untergeordneten Ausführungen/Iterationen.

    Konfigurieren Sie max_concurrent_iterations in Ihrem AutoMLConfig-Objekt. Wenn es nicht konfiguriert ist, ist standardmäßig nur eine gleichzeitige untergeordnete Ausführung/Iteration pro Experiment zulässig. Im Fall einer Compute-Instanz kann max_concurrent_iterations auf die gleiche Anzahl von Kernen wie auf dem virtuellen Computer der Compute-Instanz festgelegt werden.

    Untersuchen von Modellen und Metriken

    Automatisiertes ML bietet Ihnen Möglichkeiten zur Überwachung und Auswertung Ihrer Trainingsergebnisse.

    Sie können die Hyperparameter, die Skalierungs- und Normalisierungstechniken und den Algorithmus, der auf einen bestimmten automatisierten ML-Lauf angewendet wurde, mit der benutzerdefinierten Codelösung, print_model() anzeigen.

    Tipp

    Mit automatisiertem ML können Sie auch den generierten Code für das Training der von Auto ML trainierten Modelle anzeigen. Diese Funktion befindet sich in der öffentlichen Vorschauversion und kann jederzeit geändert werden.

    Überwachen von Ausführungen des automatisierten maschinellen Lernens

    Damit Sie bei Ausführungen mit automatisiertem ML auf die Diagramme aus einer vorherigen Ausführung zugreifen können, ersetzen Sie <<experiment_name>> durch den Namen des entsprechenden Experiments:

    from azureml.widgets import RunDetails
from azureml.core.run import Run

experiment = Experiment (workspace, <<experiment_name>>)
run_id = 'autoML_my_runID' #replace with run_ID
run = Run(experiment, run_id)
RunDetails(run).show()

    Jupyter Notebook-Widget für automatisiertes Machine Learning

    Testmodelle (Vorschau)

    Wichtig

    Das Testen Ihrer Modelle mit einem Testdataset zum Bewerten der durch automatisiertes maschinelles Lernen generierten Modelle ist eine Previewfunktion. Diese Funktion ist eine experimentelle Previewfunktion, die jederzeit geändert werden kann.

    Warnung

    Dieses Feature ist nicht für die folgenden Szenarien mit automatisiertem ML verfügbar:

    Das Übergeben der Parameter test_data oder test_size an AutoMLConfig löst automatisch einen Remotetestlauf aus, der die bereitgestellten Testdaten verwendet, um das beste Modell zu bewerten, das durch automatisiertes maschinelles Lernen nach Abschluss des Experiments empfohlen wird. Dieser Remotetestlauf erfolgt am Ende des Experiments, nachdem das beste Modell ermittelt wurde. Erfahren Sie, wie Sie Testdaten an Ihre AutoMLConfig übergeben.

    Abrufen von Testauftragsergebnissen

    Sie können die Vorhersagen und Metriken aus dem Remotetestauftrag in Azure Machine Learning Studio oder mit dem folgenden Code abrufen.

    best_run, fitted_model = remote_run.get_output()
test_run = next(best_run.get_children(type='automl.model_test'))
test_run.wait_for_completion(show_output=False, wait_post_processing=True)

# Get test metrics
test_run_metrics = test_run.get_metrics()
for name, value in test_run_metrics.items():
    print(f"{name}: {value}")

# Get test predictions as a Dataset
test_run_details = test_run.get_details()
dataset_id = test_run_details['outputDatasets'][0]['identifier']['savedId']
test_run_predictions = Dataset.get_by_id(workspace, dataset_id)
predictions_df = test_run_predictions.to_pandas_dataframe()

# Alternatively, the test predictions can be retrieved via the run outputs.
test_run.download_file("predictions/predictions.csv")
predictions_df = pd.read_csv("predictions.csv")

    Beim Modelltestauftrag wird die Datei „predictions.csv“ generiert, die in dem mit dem Arbeitsbereich erstellten Standarddatenspeicher gespeichert ist. Dieser Datenspeicher ist für alle Benutzer mit demselben Abonnement sichtbar. Testaufträge werden nicht für Szenarien empfohlen, in denen die für den Testauftrag verwendeten oder erstellten Informationen privat bleiben müssen.

    Testen eines vorhandenen Modells für automatisiertes maschinelles Lernen

    Führen Sie zum Testen anderer vorhandener Modelle für automatisiertes maschinelles Lernen (bester oder untergeordneter Auftrag) ModelProxy() aus, um ein Modell zu testen, nachdem die Hauptausführung des automatisierten maschinellen Lernens abgeschlossen wurde. ModelProxy() gibt bereits die Vorhersagen und Metriken zurück und erfordert keine weitere Verarbeitung zum Abrufen der Ausgaben.

    Hinweis

    ModelProxy ist eine experimentelle Vorschauklasse und kann jederzeit geändert werden.

    Der folgende Code veranschaulicht das Testen eines Modells aus einer beliebigen Ausführung mithilfe der ModelProxy.test()-Methode. Sie können in der test()-Methode mithilfe des Parameters include_predictions_only angeben, dass nur die Vorhersagen des Testlaufs angezeigt werden sollen.

    from azureml.train.automl.model_proxy import ModelProxy

model_proxy = ModelProxy(child_run=my_run, compute_target=cpu_cluster)
predictions, metrics = model_proxy.test(test_data, include_predictions_only= True
)

    Registrieren und Bereitstellen von Modellen

    Nachdem Sie ein Modell getestet und bestätigt haben, dass Sie es in der Produktion verwendet möchten, können Sie es für die spätere Verwendung registrieren und

    Zum Registrieren eines Modells aus einer Ausführung für das automatisierte maschinelle Lernen verwenden Sie die register_model()-Methode.

    
best_run = run.get_best_child()
print(fitted_model.steps)

model_name = best_run.properties['model_name']
description = 'AutoML forecast example'
tags = None

model = run.register_model(model_name = model_name, 
                                  description = description, 
                                  tags = tags)

    Details zum Erstellen einer Bereitstellungskonfiguration und Bereitstellen eines registrierten Modells in einem Webdienst finden Sie unter Wie und wo Modelle bereitgestellt werden.

    Tipp

    Für registrierte Modelle steht in Azure Machine Learning Studio die Bereitstellung mit nur einem Klick zur Verfügung. Weitere Informationen finden Sie unter Bereitstellen registrierter Modelle aus Studio.

    Interpretierbarkeit von Modellen

    Die Interpretierbarkeit von Modellen ermöglicht es Ihnen, zu verstehen, warum Ihre Modelle Vorhersagen erstellt haben, und die zugrunde liegenden Featurewichtigkeitswerte zu verstehen. Das SDK enthält verschiedene Pakete zum Aktivieren von Modellinterpretierbarkeitsfeatures, sowohl für die Trainings- als auch die Rückschlusszeit, für lokale und bereitgestellte Modelle.

    Weitere Informationen zum Aktivieren von Interpretierbarkeitsfeatures insbesondere in Experimenten mit automatisiertem ML finden Sie unter Interpretierbarkeit: Modellerklärungen beim automatisierten maschinellen Lernen (Vorschau).

    Allgemeine Informationen dazu, wie Modellerklärungen und Featurewichtigkeit in anderen Bereichen des SDK außerhalb des automatisierten maschinellen Lernens aktiviert werden können, finden Sie im Artikel Modellinterpretierbarkeit in Azure Machine Learning (Vorschauversion).

    Hinweis

    Das ForecastTCN-Modell wird aktuell vom Erklärungsclient nicht unterstützt. Dieses Modell gibt kein Erklärungsdashboard zurück, wenn es als bestes Modell zurückgegeben wird, und es unterstützt keine Erklärungsläufe auf Anforderung.

    Nächste Schritte