Einrichten von AutoML-Training mit Python

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:

• Ein Azure Machine Learning-Arbeitsbereich. Informationen zum Erstellen des Arbeitsbereichs finden Sie unter Schnellstart: So erstellen Sie Arbeitsbereichsressourcen, die Sie für die ersten Schritte mit Azure Machine Learning benötigen.

• Installation des Azure Machine Learning Python SDK, zum Installieren des SDK können Sie wie folgt vorgehen:

  • Erstellen Sie eine Compute-Instanz, wodurch das SDK automatisch installiert und für ML-Workflows vorkonfiguriert wird. Weitere Informationen hierzu finden Sie unter Erstellen und Verwalten einer Azure Machine Learning-Computeinstanz.

  • Installieren Sie das Paket automl selbst. Es enthält die Standardinstallation des SDK.

  Wichtig

  Für die Python-Befehle in diesem Artikel ist die neueste azureml-train-automl-Paketversion erforderlich.

  • Installieren Sie das neueste azureml-train-automl-Paket in Ihrer lokalen Umgebung.
  • Einzelheiten zum neuesten azureml-train-automl-Paket finden Sie in den Versionshinweisen.

  Warnung

  Python 3.8 ist nicht kompatibel mit automl.

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

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.

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.

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.

• Für die Regression sind dies Online Gradient Descent Regressor und Fast Linear Regressor (Schneller linearer Regressor).

• Für die Klassifizierung sind dies Averaged Perceptron Classifier und Linear SVM Classifier. Dabei verfügt der „Linear SVM Classifier“ sowohl über Versionen für große Datenmengen als auch kleine Datenmengen.

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

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:

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.

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.

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.

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.

Metriken für Szenarien zur Zeitreihenvorhersage

Die Empfehlungen ähneln den Empfehlungen für Regressionsszenarien.

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.

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.

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.

• 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.

Ausführen des Experiments

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)

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 Ihre Trainingsergebnisse in einem Widget oder in der Inlineansicht anzeigen, wenn Sie ein Notebook verwenden. Weitere Informationen finden Sie unter Überwachen automatisierter Machine Learning-Ausführungen.

• Definitionen und Beispiele für die Leistungsdiagramme und Metriken, die für jede Ausführung bereitgestellt werden, finden Sie unter Auswerten der Ergebnisse von Experimenten des automatisierten maschinellen Lernens.

• Eine Zusammenfassung der Featurisierung und Informationen zu den Features, die zu einem bestimmten Modell hinzugefügt wurden, finden Sie unter Transparenz der Featurisierung.

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.

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

Testmodelle (Vorschau)

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.

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.

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

Nächste Schritte

• Lernen Sie, wie und wo Sie Modelle bereitstellen können.

• Weitere Informationen finden Sie unter Trainieren eines Regressionsmodells mit automatisiertem Machine Learning.

• Behandeln Sie Probleme bei automatisierten ML-Experimenten.