Was ist das Azure Machine Learning SDK für Python?

Das Azure Machine Learning-SDK für Python wird von Data Scientists und KI-Entwicklern zum Erstellen und Ausführen von Machine Learning-Workflows mit Azure Machine Learning Service verwendet. Sie können mit dem Dienst in jeder Python-Umgebung interagieren, einschließlich Jupyter Notebooks, Visual Studio Code und Ihrer bevorzugten Python-IDE.

Zu den Hauptbereichen des SDK gehören:

• Erkunden, Vorbereiten und Verwalten des Lebenszyklus Ihrer in Experimenten mit maschinellem Lernen verwendeten Datasets
• Verwalten von Cloudressourcen zum Überwachen, Protokollieren und Organisieren von Experimenten mit maschinellem Lernen
• Trainieren von Modellen – lokal oder mithilfe von Cloudressourcen –, einschließlich GPU-beschleunigten Modelltrainings
• Verwenden des automatisierten maschinellen Lernens, das Konfigurationsparameter und Trainingsdaten akzeptiert. Es durchläuft automatisch Algorithmen und Hyperparametereinstellungen, um das beste Modell zum Ausführen von Vorhersagen zu finden.
• Bereitstellen von Webdiensten, um die trainierten Modelle in RESTful-Dienste zu konvertieren, die in jeder Anwendung verwendet werden können

Eine ausführliche exemplarische Vorgehensweise für die ersten Schritte finden Sie im Tutorial .

Die folgenden Abschnitte enthalten Übersichten über einige der wichtigsten Klassen im SDK sowie allgemeine Entwurfsmuster für ihre Verwendung. Informationen zum Erhalt des SDK finden Sie im Installationshandbuch.

Stabile und experimentelle Version

Das Azure Machine Learning SDK für Python bietet sowohl stabile als auch experimentelle Features.

Experimentelle Features sind in der SDK-Referenz mit einem entsprechenden Hinweisabschnitt versehen und in der gesamten Azure Machine Learning-Dokumentation durch Text wie (Vorschauversion) gekennzeichnet.

Arbeitsbereich

Namespace:azureml.core.workspace.Workspace

Die Workspace-Klasse ist eine grundlegende Cloudressource zum Experimentieren, Trainieren und Bereitstellen von Machine Learning-Modellen. Sie verknüpft Ihr Azure-Abonnement und Ihre Ressourcengruppe mit einem einfach verwendbaren Objekt.

Sehen Sie sich unter Workspace-Klasse die Parameter der create-Methode an, um vorhandene Instanzen (Storage, Key Vault, App Insights und Azure Container Registry (ACR)) wiederzuverwenden und zusätzliche Einstellungen wie die Konfiguration des privaten Endpunkts und das Computeziel zu ändern.

Mit dem folgenden Code importieren Sie die Klasse und erstellen einen neuen Arbeitsbereich. Legen Sie create_resource_group auf False fest, wenn Sie bereits über eine vorhandene Azure-Ressourcengruppe verfügen, die Sie für den Arbeitsbereich verwenden möchten. Einige Funktionen fordern möglicherweise zur Eingabe von Anmeldeinformationen für die Azure-Authentifizierung auf.

from azureml.core import Workspace
ws = Workspace.create(name='myworkspace',
                      subscription_id='<azure-subscription-id>',
                      resource_group='myresourcegroup',
                      create_resource_group=True,
                      location='eastus2'
                     )

Sie können denselben Arbeitsbereich in mehreren Umgebungen verwenden, indem Sie ihn zunächst in eine JSON-Konfigurationsdatei aufnehmen. Dadurch werden Ihre Daten zu Abonnement-, Ressourcen- und Arbeitsbereichsnamen gespeichert.

ws.write_config(path="./file-path", file_name="ws_config.json")

Sie laden den Arbeitsbereich, indem Sie die Konfigurationsdatei lesen.

from azureml.core import Workspace
ws_other_environment = Workspace.from_config(path="./file-path/ws_config.json")

Alternativ können Sie mit der statischen get()-Methode einen vorhandenen Arbeitsbereich laden, ohne Konfigurationsdateien zu verwenden.

from azureml.core import Workspace
ws = Workspace.get(name="myworkspace", subscription_id='<azure-subscription-id>', resource_group='myresourcegroup')

Die Variable ws stellt in den folgenden Codebeispielen ein Workspace-Objekt dar.

Experiment

Namespace:azureml.core.experiment.Experiment

Die Experiment-Klasse ist eine weitere grundlegende Cloudressource, die eine Sammlung von Tests (einzelne Modellausführungen) darstellt. Der folgende Code ruft ein Experiment-Objekt in Workspace anhand des Namens ab oder erstellt ein neues Experiment-Objekt, wenn der Name nicht vorhanden ist.

from azureml.core.experiment import Experiment
experiment = Experiment(workspace=ws, name='test-experiment')

Führen Sie den folgenden Code aus, um eine Liste aller Experiment-Objekte in Workspace abzurufen.

list_experiments = Experiment.list(ws)

Verwenden Sie die get_runs-Funktion, um eine Liste von Run-Objekten (Testversionen) von Experiment abzurufen. Der folgende Code ruft die Ausführungen ab und druckt jede Ausführungs-ID.

list_runs = experiment.get_runs()
for run in list_runs:
    print(run.id)

Experimenttests können auf zwei Arten ausgeführt werden. Wenn Sie in einem Jupyter Notebook interaktiv experimentieren, verwenden Sie die start_logging-Funktion. Wenn Sie ein Experiment aus einer Python-Standardumgebung übermitteln, verwenden Sie die submit-Funktion. Beide Funktionen geben ein Run-Objekt zurück. Die Variable experiment stellt in den folgenden Codebeispielen ein Experiment-Objekt dar.

Ausführen

Namespace:azureml.core.run.Run

Eine Ausführung stellt einen einzelnen Test eines Experiments dar. Run ist das Objekt, mit dem Sie die asynchrone Ausführung eines Tests überwachen, die Ausgabe des Tests speichern, Ergebnisse analysieren und auf generierte Artefakte zugreifen. Sie verwenden Run in Ihrem Experimentiercode, um Metriken und Artefakte im Ausführungsverlaufsdienst zu protokollieren. Zu den Funktionen gehören:

• Speichern und Abrufen von Metriken und Daten
• Einfaches Suchen nach früheren Ausführungen mithilfe von Tags und der untergeordneten Hierarchie
• Registrieren von gespeicherten Modelldateien für die Bereitstellung
• Speichern, Ändern und Abrufen von Eigenschaften einer Testausführung

Erstellen Sie ein Run-Objekt, indem Sie ein Experiment-Objekt mit einem run configuration -Objekt übermitteln. Verwenden Sie den Parameter tags, um benutzerdefinierte Kategorien und Bezeichnungen an Ihre Ausführungen anzufügen. Sie können sie später ganz einfach über Experiment suchen und abrufen.

tags = {"prod": "phase-1-model-tests"}
run = experiment.submit(config=your_config_object, tags=tags)

Verwenden Sie die statische list-Funktion, um eine Liste aller Run-Objekte von Experiment abzurufen. Geben Sie den Parameter tags an, um nach dem zuvor erstellten Tag zu filtern.

from azureml.core.run import Run
filtered_list_runs = Run.list(experiment, tags=tags)

Verwenden Sie die get_details-Funktion, um die ausführliche Ausgabe der Ausführung abzurufen.

run_details = run.get_details()

Die Ausgabe für diese Funktion ist ein Wörterbuch mit folgendem Inhalt:

• Run ID
• Status
• Start- und Endzeiten
• Computeziel (lokal oder Cloud)
• In der Ausführung verwendete Abhängigkeiten und Versionen
• Trainingsspezifische Daten (abhängig vom Modelltyp)

Weitere Beispiele zum Konfigurieren und Überwachen von Ausführungen finden Sie in der Schrittanleitung.

Modell

Namespace:azureml.core.model.Model

Die Model-Klasse dient für die Arbeit mit Clouddarstellungen von Machine Learning-Modellen. Methoden helfen Ihnen beim Übertragen von Modellen zwischen lokalen Entwicklungsumgebungen und dem Workspace-Objekt in der Cloud.

Mit der Modellregistrierung können Sie Ihre Modelle in der Azure-Cloud in Ihrem Arbeitsbereich speichern und versionieren. Registrierte Modelle werden anhand des Namens und der Version identifiziert. Jedes Mal, wenn Sie ein Modell mit dem gleichen Namen wie ein bereits vorhandenes Modell registrieren, erhöht die Registrierung die Versionsnummer. Azure Machine Learning unterstützt jedes Modell, das über Python 3 geladen werden kann, nicht nur Azure Machine Learning-Modelle.

Im folgenden Beispiel wird gezeigt, wie ein einfaches lokales Klassifizierungsmodell mit scikit-learn erstellt, in Workspace registriert und aus der Cloud heruntergeladen wird.

Erstellen Sie den einfachen Klassifizierer clf, um die Kundenabwanderung basierend auf dem Alter vorherzusagen. Geben Sie das Modell dann in einer .pkl-Datei im selben Verzeichnis aus.

from sklearn import svm
import joblib
import numpy as np

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

joblib.dump(value=clf, filename="churn-model.pkl")

Verwenden Sie die register-Funktion zum Registrieren des Modells in Ihrem Arbeitsbereich. Geben Sie den lokalen Modellpfad und den Modellnamen an. Wenn Sie denselben Namen mehrmals registrieren, wird eine neue Version erstellt.

from azureml.core.model import Model

model = Model.register(workspace=ws, model_path="churn-model.pkl", model_name="churn-model-test")

Nachdem das Modell nun in Ihrem Arbeitsbereich registriert ist, können Ihre Modelle einfach verwaltet, heruntergeladen und organisiert werden. Verwenden Sie zum Abrufen eines Modellobjekts (z. B. in einer anderen Umgebung) aus Workspace den Klassenkonstruktor, und geben Sie den Modellnamen sowie etwaige optionale Parameter an. Verwenden Sie dann die download-Funktion, um das Modell herunterzuladen, einschließlich der Cloudordnerstruktur.

from azureml.core.model import Model
import os

model = Model(workspace=ws, name="churn-model-test")
model.download(target_dir=os.getcwd())

Entfernen Sie das Modell mit der delete-Funktion aus Workspace.

model.delete()

Nachdem Sie über ein registriertes Modell verfügen, ist die Bereitstellung als Webdienst ein einfacher Prozess. Zuerst erstellen und registrieren Sie ein Image. In diesem Schritt wird die Python-Umgebung mit ihren Abhängigkeiten zusammen mit einem Skript zum Definieren der Formate für Webdienstanforderung und -antwort konfiguriert. Nachdem Sie ein Image erstellt haben, erstellen Sie eine Bereitstellungskonfiguration, mit der die Parameter für CPU-Kerne und Arbeitsspeicher für das Computeziel festgelegt werden. Anschließend fügen Sie das Image an.

ComputeTarget, RunConfiguration und ScriptRunConfig

Namespace:azureml.core.compute.ComputeTarget
Namespace:azureml.core.runconfig.RunConfiguration
Namespace:azureml.core.script_run_config.ScriptRunConfig

Die ComputeTarget-Klasse ist die abstrakte übergeordnete Klasse zum Erstellen und Verwalten von Computezielen. Ein Computeziel stellt eine Vielzahl von Ressourcen dar, mit denen Sie Ihre Machine Learning-Modelle trainieren können. Ein Computeziel kann ein lokaler Computer oder eine Cloudressource sein, beispielsweise Azure Machine Learning Compute, Azure HDInsight oder ein virtueller Remotecomputer.

Verwenden Sie Computeziele, um leistungsstarke virtuelle Computer für das Modelltraining zu nutzen, und richten Sie persistente Computeziele oder temporäre, zur Laufzeit aufgerufene Ziele ein. Eine umfassende Anleitung zum Einrichten und Verwalten von Computezielen finden Sie in der Schrittanleitung.

Der folgende Code zeigt ein einfaches Beispiel für das Einrichten eines AmlCompute-Ziels (untergeordnete Klasse von ComputeTarget). Dieses Ziel erstellt eine Runtime-Remotecomputeressource in Ihrem Workspace-Objekt. Die Ressource wird beim Übermitteln eines Auftrags automatisch skaliert. Sie wird automatisch gelöscht, wenn die Ausführung abgeschlossen ist.

Verwenden Sie das einfache scikit-learn-Abwanderungsmodell, und erstellen Sie es in einer eigenen Datei (train.py) im aktuellen Verzeichnis. Erstellen Sie am Ende der Datei ein neues Verzeichnis mit dem Namen outputs. In diesem Schritt wird ein Verzeichnis in der Cloud (Ihrem Arbeitsbereich) erstellt, in dem Ihr durch joblib.dump() serialisiertes trainiertes Modell gespeichert werden soll.

# train.py

from sklearn import svm
import numpy as np
import joblib
import os

# customer ages
X_train = np.array([50, 17, 35, 23, 28, 40, 31, 29, 19, 62])
X_train = X_train.reshape(-1, 1)
# churn y/n
y_train = ["yes", "no", "no", "no", "yes", "yes", "yes", "no", "no", "yes"]

clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(X_train, y_train)

os.makedirs("outputs", exist_ok=True)
joblib.dump(value=clf, filename="outputs/churn-model.pkl")

Als Nächstes erstellen Sie das Computeziel, indem Sie ein RunConfiguration-Objekt instanziieren und den Typ und die Größe festlegen. In diesem Beispiel wird die geringste Ressourcengröße (1 CPU-Kern, 3,5 GB Arbeitsspeicher) verwendet. Die Variable list_vms enthält eine Liste der unterstützten virtuellen Computer und ihrer Größen.

from azureml.core.runconfig import RunConfiguration
from azureml.core.compute import AmlCompute
list_vms = AmlCompute.supported_vmsizes(workspace=ws)

compute_config = RunConfiguration()
compute_config.target = "amlcompute"
compute_config.amlcompute.vm_size = "STANDARD_D1_V2"

Erstellen Sie Abhängigkeiten für die Python-Umgebung der Remotecomputeressource mithilfe der CondaDependencies-Klasse. In der Datei train.py werden scikit-learn und numpy verwendet, die in der Umgebung installiert werden müssen. Sie können auch Versionen von Abhängigkeiten angeben. Verwenden Sie das dependencies-Objekt, um die Umgebung in compute_config festzulegen.

from azureml.core.conda_dependencies import CondaDependencies

dependencies = CondaDependencies()
dependencies.add_pip_package("scikit-learn")
dependencies.add_pip_package("numpy==1.15.4")
compute_config.environment.python.conda_dependencies = dependencies

Jetzt sind Sie bereit, das Experiment zu übermitteln. Verwenden Sie die ScriptRunConfig-Klasse, um die Computezielkonfiguration anzufügen und den Pfad bzw. die Datei für das Trainingsskript train.py anzugeben. Übermitteln Sie das Experiment, indem Sie den Parameter config der submit()-Funktion angeben. Rufen Sie wait_for_completion für die resultierende Ausführung auf, um die Ausgabe der asynchronen Ausführung anzuzeigen, während die Umgebung initialisiert und das Modell trainiert wird.

from azureml.core.experiment import Experiment
from azureml.core import ScriptRunConfig

script_run_config = ScriptRunConfig(source_directory=os.getcwd(), script="train.py", run_config=compute_config)
experiment = Experiment(workspace=ws, name="compute_target_test")
run = experiment.submit(config=script_run_config)
run.wait_for_completion(show_output=True)

Nach Abschluss der Ausführung ist die Datei churn-model.pkl des trainierten Modells in Ihrem Arbeitsbereich verfügbar.

Environment

Namespace:azureml.core.environment

Azure Machine Learning-Umgebungen geben die Python-Pakete, Umgebungsvariablen und Softwareeinstellungen bezüglich Ihrer Trainings- und Bewertungsskripts an. Neben Python können Sie auch PySpark, Docker und R für Umgebungen konfigurieren. Intern werden Umgebungen zu Docker-Images, die zum Ausführen der Trainings- und Bewertungsprozesse auf dem Computeziel verwendet werden. Die Umgebungen sind verwaltete und versionsverwaltete Entitäten innerhalb Ihres Machine Learning-Arbeitsbereichs, die reproduzierbare, überprüfbare und portierbare Machine Learning-Workflows über verschiedene Computeziele und-typen hinweg ermöglichen.

Sie können ein Environment-Objekt für folgende Zwecke verwenden:

• Entwickeln Sie Ihr Trainingsskript.
• Verwenden Sie dieselbe Umgebung in Azure Machine Learning Compute für das skalierte Modelltraining wieder.
• Stellen Sie Ihr Modell mit derselben Umgebung bereit, ohne an einen bestimmten Computetyp gebunden zu sein.

Mit dem folgenden Code wird die Environment-Klasse aus dem SDK importiert und ein Umgebungsobjekt instanziiert.

from azureml.core.environment import Environment
Environment(name="myenv")

Sie fügen einer Umgebung Pakete mithilfe von Conda-, pip- oder Private Wheels-Dateien hinzu. Geben Sie mithilfe der CondaDependency-Klasse jede Paketabhängigkeit an, um sie zum PythonSection-Objekt der Umgebung hinzuzufügen.

Das folgende Beispiel zeigt eine Hinzufügung zur Umgebung. Sie fügt Version 1.17.0 von numpy hinzu. Darüber hinaus wird das pillow-Paket der Umgebung myenv hinzugefügt. Im Beispiel wird die add_conda_package()-Methode bzw. die add_pip_package()-Methode verwendet.

from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies

myenv = Environment(name="myenv")
conda_dep = CondaDependencies()

# Installs numpy version 1.17.0 conda package
conda_dep.add_conda_package("numpy==1.17.0")

# Installs pillow package
conda_dep.add_pip_package("pillow")

# Adds dependencies to PythonSection of myenv
myenv.python.conda_dependencies=conda_dep

Zum Übermitteln eines Trainingslaufs müssen Sie Ihre Umgebung, das Computeziel und das Python-Trainingsskript zu einer Ausführungskonfiguration kombinieren. Diese Konfiguration ist ein Wrapper-Objekt, das zum Übermitteln von Läufen verwendet wird.

Wenn Sie einen Trainingslauf übermitteln, kann das Erstellen einer neuen Umgebung einige Minuten dauern. Die Dauer hängt von der Größe der erforderlichen Abhängigkeiten ab. Die Umgebungen werden vom Dienst zwischengespeichert. Sofern die Umgebungsdefinition unverändert bleibt, wird die gesamte Setupzeit nur einmal in Anspruch genommen.

Das folgende Beispiel zeigt, wo Sie ScriptRunConfig als Wrapper-Objekt verwenden würden.

from azureml.core import ScriptRunConfig, Experiment
from azureml.core.environment import Environment

exp = Experiment(name="myexp", workspace = ws)
# Instantiate environment
myenv = Environment(name="myenv")

# Add training script to run config
runconfig = ScriptRunConfig(source_directory=".", script="train.py")

# Attach compute target to run config
runconfig.run_config.target = "local"

# Attach environment to run config
runconfig.run_config.environment = myenv

# Submit run 
run = exp.submit(runconfig)

Wenn Sie in Ihrer Ausführungskonfiguration keine Umgebung angeben, bevor Sie den Lauf übermitteln, wird eine Standardumgebung für Sie erstellt.

Weitere Informationen zum Bereitstellen eines Webdiensts mithilfe von Umgebungen finden Sie im Abschnitt Modellbereitstellung.

Pipeline, PythonScriptStep

Namespace:azureml.pipeline.core.pipeline.Pipeline
Namespace:azureml.pipeline.steps.python_script_step.PythonScriptStep

Eine Azure Machine Learning-Pipeline ist ein automatisierter Workflow einer vollständigen Aufgabe zum maschinellen Lernen. Teilaufgaben werden als eine Reihe von Schritten in der Pipeline gekapselt. Eine Azure Machine Learning-Pipeline kann ganz einfach sein und nur einen Schritt umfassen, in dem ein Python-Skript aufgerufen wird. Pipelines enthalten Funktionen für:

• Datenvorbereitung einschließlich Import, Validierung und Bereinigung, Verfremdung und Transformation, Normalisierung und Staging
• Trainingskonfiguration einschließlich Parametrisierungsargumenten, Dateipfaden und Protokollierungs-/Berichtskonfigurationen
• Effizientes und wiederholtes Trainieren und Validieren von Daten, einschließlich der Angabe spezifischer Datenteilmengen, verschiedener Hardware-Computeressourcen, verteilter Verarbeitung und Fortschrittsüberwachung
• Bereitstellung, einschließlich Versionierung, Skalierung, Bereitstellung und Zugriffssteuerung
• Veröffentlichung einer Pipeline an einem REST-Endpunkt zum erneuten Ausführen aus einer beliebigen HTTP-Bibliothek

Ein PythonScriptStep ist ein grundlegender integrierter Schritt zum Ausführen eines Python-Skripts auf einem Computeziel. Er nimmt einen Skriptnamen und andere optionale Parameter wie Argumente für das Skript, das Computeziel, Eingaben und Ausgaben entgegen. Im Folgenden sehen Sie ein einfaches Beispiel für einen PythonScriptStep. Ein Beispiel für ein train.py-Skript finden Sie im Abschnitt Tutorial.

from azureml.pipeline.steps import PythonScriptStep

train_step = PythonScriptStep(
    script_name="train.py",
    arguments=["--input", blob_input_data, "--output", output_data1],
    inputs=[blob_input_data],
    outputs=[output_data1],
    compute_target=compute_target,
    source_directory=project_folder
)

Nachdem mindestens ein Schritt erstellt wurde, können die Schritte miteinander verknüpft und als einfache automatisierte Pipeline veröffentlicht werden.

from azureml.pipeline.core import Pipeline

pipeline = Pipeline(workspace=ws, steps=[train_step])
pipeline_run = experiment.submit(pipeline)

Ein umfassendes Beispiel für das Aufbauen eines Pipelineworkflows finden Sie im fortgeschrittenen Tutorial.

Muster für das Erstellen und Verwenden von Pipelines

Eine Azure Machine Learning-Pipeline ist einem Azure Machine Learning-Arbeitsbereich zugeordnet, und ein Pipelineschritt ist einem verfügbaren Computeziel in diesem Arbeitsbereich zugeordnet. Weitere Informationen finden Sie in diesem Artikel zu Arbeitsbereichen oder dieser Erläuterung von Computezielen.

Ein gängiges Muster für Pipelineschritte ist:

1. Angeben von Arbeitsbereich, Compute und Speicher
2. Konfigurieren der Eingabe- und Ausgabedaten mithilfe von:
   1. Dataset zum Verfügbarmachen eines vorhandenen Azure-Datenspeichers
   2. PipelineDataset zum Kapseln von typisierten tabellarischen Daten
   3. PipelineData für Zwischenstufen von Datei- oder Verzeichnisdaten, die in einem Schritt geschrieben wurden und in einem anderen verwendet werden sollen
3. Definieren mindestens eines Pipelineschritts
4. Instanziieren einer Pipeline mithilfe Ihres Arbeitsbereichs und der Schritte
5. Erstellen eines Experiments, an das die Pipeline übermittelt werden soll
6. Überwachen der Experimentergebnisse

Dieses Notebook ist ein gutes Beispiel für dieses Muster. Auftrag

Weitere Informationen zu Azure Machine Learning-Pipelines und insbesondere zu den Unterschieden zu anderen Arten von Pipelines finden Sie in diesem Artikel.

AutoMLConfig

Namespace:azureml.train.automl.automlconfig.AutoMLConfig

Verwenden Sie die AutoMLConfig-Klasse, um Parameter für das Training für automatisiertes maschinelles Lernen zu konfigurieren. Automatisiertes maschinelles Lernen durchläuft viele Kombinationen von Algorithmen für maschinelles Lernen und Hyperparametereinstellungen. Anschließend wird das am besten geeignete Modell anhand der ausgewählten Genauigkeitsmetrik gesucht. Die Konfiguration ermöglicht das Angeben von:

• Aufgabentyp (Klassifizierung, Regression, Vorhersage)
• Anzahl von Algorithmusiterationen und maximale Zeit pro Iteration
• Genauigkeitsmetrik zur Optimierung
• Algorithmen für die Sperrliste oder Positivliste
• Anzahl von Kreuzvalidierungen
• Computeziele
• Trainingsdaten

Ausführliche Anleitungen und Beispiele zum Einrichten von Experimenten mit automatisiertem maschinellem Lernen finden Sie im Tutorial und in der Schrittanleitung.

Der folgende Code veranschaulicht das Erstellen eines Konfigurationsobjekts für automatisiertes maschinelles Lernen für ein Klassifizierungsmodell und dessen Verwendung beim Übermitteln eines Experiments.

from azureml.train.automl import AutoMLConfig

automl_config = AutoMLConfig(task="classification",
                             X=your_training_features,
                             y=your_training_labels,
                             iterations=30,
                             iteration_timeout_minutes=5,
                             primary_metric="AUC_weighted",
                             n_cross_validations=5
                            )

Verwenden Sie das automl_config-Objekt, um ein Experiment zu übermitteln.

from azureml.core.experiment import Experiment

experiment = Experiment(ws, "automl_test_experiment")
run = experiment.submit(config=automl_config, show_output=True)

Nachdem Sie das Experiment übermittelt haben, zeigt die Ausgabe die Trainingsgenauigkeit für jede Iteration an, sobald sie abgeschlossen ist. Nach Abschluss der Ausführung wird ein AutoMLRun-Objekt (das die Run-Klasse erweitert) zurückgegeben. Verwenden Sie die get_output()-Funktion, um ein Model-Objekt zurückzugeben.

best_model = run.get_output()
y_predict = best_model.predict(X_test)

Modellbereitstellung

Namespace:azureml.core.model.InferenceConfig
Namespace:azureml.core.webservice.webservice.Webservice

Die InferenceConfig-Klasse wird für Konfigurationseinstellungen verwendet, in denen die zum Hosten des Modells und des Webdiensts erforderliche Umgebung beschrieben wird.

Webservice ist die abstrakte übergeordnete Klasse zum Erstellen und Bereitstellen von Webdiensten für Ihre Modelle. Eine ausführliche Anleitung zum Vorbereiten der Modellimplementierung und zum Bereitstellen von Webdiensten finden Sie in dieser Schrittanleitung.

Sie können Umgebungen verwenden, wenn Sie Ihr Modell als Webdienst bereitstellen. Umgebungen ermöglichen einen reproduzierbaren, verbundenen Workflow, in dem Sie Ihr Modell bereitstellen können, indem Sie dieselben Bibliotheken sowohl in ihren Trainings- als auch in Rückschlusscomputeressourcen verwenden. Intern werden Umgebungen als Docker-Images implementiert. Sie können entweder von Microsoft bereitgestellte Images oder eigene benutzerdefinierte Docker-Images verwenden. Wenn Sie zuvor die ContainerImage-Klasse für die Bereitstellung verwendet haben, sehen Sie sich die DockerSection-Klasse an, um einen ähnlichen Workflow mit Umgebungen zu erzielen.

Zum Bereitstellen eines Webdiensts kombinieren Sie die Umgebung, das Rückschlusscompute, das Bewertungsskript und das registrierte Modell in Ihrem Bereitstellungsobjekt deploy().

Im folgenden Beispiel wird davon ausgegangen, dass Sie bereits einen Trainingslauf mithilfe der Umgebung myenv abgeschlossen haben und dieses Modell in Azure Container Instances bereitstellen möchten.

from azureml.core.model import InferenceConfig, Model
from azureml.core.webservice import AciWebservice, Webservice

# Register the model to deploy
model = run.register_model(model_name = "mymodel", model_path = "outputs/model.pkl")

# Combine scoring script & environment in Inference configuration
inference_config = InferenceConfig(entry_script="score.py",
                                   environment=myenv)

# Set deployment configuration
deployment_config = AciWebservice.deploy_configuration(cpu_cores = 1,
                                                       memory_gb = 1)

# Define the model, inference, & deployment configuration and web service name and location to deploy
service = Model.deploy(workspace = ws,
                       name = "my_web_service",
                       models = [model],
                       inference_config = inference_config,
                       deployment_config = deployment_config)

In diesem Beispiel wird ein Azure Container Instances-Webdienst erstellt, der sich am besten für kleine Tests und schnelle Bereitstellungen eignet. Um Ihr Modell als Webdienst in Produktionsqualität bereitzustellen, verwenden Sie Azure Kubernetes Service (AKS). Weitere Informationen finden Sie unter der AksCompute-Klasse.

Dataset

Namespace:azureml.core.dataset.Dataset
Namespace:azureml.data.file_dataset.FileDataset
Namespace:azureml.data.tabular_dataset.TabularDataset

Die Dataset-Klasse ist eine grundlegende Ressource zum Untersuchen und Verwalten von Daten in Azure Machine Learning. Sie können Ihre Daten mit Zusammenfassungsstatistiken durchsuchen und das Dataset in Ihrem AML-Arbeitsbereich speichern, um Versions- und Reproduzierbarkeitsfunktionen umsetzen zu können. Datasets werden während des Trainings problemlos von Modellen genutzt. Ausführliche Verwendungsbeispiele finden Sie in der Schrittanleitung.

• TabularDataset stellt Daten in einem tabellarischen Format bereit, das durch Analysieren einer Datei oder Liste von Dateien erstellt wird.
• FileDataset verweist auf Dateien in Datenspeichern oder unter öffentlichen URLs.

Im folgenden Beispiel wird gezeigt, wie ein TabularDataset erstellt wird, das auf einen einzelnen Pfad in einem Datenspeicher verweist.

from azureml.core import Dataset

dataset = Dataset.Tabular.from_delimited_files(path = [(datastore, 'train-dataset/tabular/iris.csv')])
dataset.take(3).to_pandas_dataframe()

Im folgenden Beispiel wird gezeigt, wie Sie ein FileDataset erstellen, das auf mehrere Datei-URLs verweist.

from azureml.core.dataset import Dataset

url_paths = [
            'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz'
            ]
dataset = Dataset.File.from_files(path=url_paths)

Nächste Schritte

Probieren Sie diese nächsten Schritte aus, um zu erfahren, wie Sie das Azure Machine Learning SDK für Python verwenden können:

• Befolgen Sie das Tutorial , um zu erfahren, wie Sie ein Modell in Python erstellen, trainieren und bereitstellen.

• Suchen Sie über das Inhaltsverzeichnis auf der linken Seite in der Referenzdokumentation auf dieser Website nach Klassen und Modulen.