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

Data Scientists und KI-Entwickler verwenden das Azure Machine Learning SDK v1 für Python, um Machine Learning-Workflows mit dem Azure Machine Learning-Dienstzu erstellen und auszuführen. Sie können mit dem Dienst in jeder Python-Umgebung interagieren, einschließlich Jupyter-Notizbüchern, Visual Studio Codeoder Ihrer bevorzugten Python-IDE.

Zu den wichtigsten Bereichen des SDK gehören:

• Erkunden, vorbereiten und verwalten Sie den Lebenszyklus Ihrer Datasets, die in Machine Learning-Experimenten verwendet werden.
• Verwalten Sie Cloudressourcen zum Überwachen, Protokollieren und Organisieren Von Machine Learning-Experimenten.
• Trainieren Sie Modelle entweder lokal oder mithilfe von Cloudressourcen, einschließlich gpubeschleunigte Modellschulungen.
• Verwenden Sie automatisiertes maschinelles Lernen, das Konfigurationsparameter und Schulungsdaten akzeptiert. Es durchläuft automatisch Algorithmen und Hyperparametereinstellungen, um das beste Modell für die Ausführung von Vorhersagen zu finden.
• Stellen Sie Webdienste bereit, um Ihre trainierten Modelle in RESTful-Dienste zu konvertieren, die in einer beliebigen Anwendung genutzt werden können.

Eine schrittweise exemplarische Vorgehensweise für die ersten Schritte finden Sie im Lernprogramm.

Die folgenden Abschnitte sind Übersichten über einige der wichtigsten Klassen im SDK und allgemeine Entwurfsmuster für die Verwendung. Informationen zum Abrufen des SDK finden Sie im Installationshandbuch.

Stabil im Vergleich zu experimentell

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

Experimentelle Features werden in der SDK-Referenz durch einen Notizabschnitt gekennzeichnet und durch Text gekennzeichnet, z. B. (Vorschau) in Azure Machine Learning-Dokumentation.

Arbeitsbereich

Namespace-: azureml.core.workspace.Workspace

Die Workspace Klasse ist eine grundlegende Ressource in der Cloud, die Sie zum Experimentieren, Trainieren und Bereitstellen von Machine Learning-Modellen verwenden. Es verknüpft Ihr Azure-Abonnement und Ihre Ressourcengruppe mit einem leicht genutzten Objekt.

Zeigen Sie alle Parameter der Create Workspace-Methode, um vorhandene Instanzen wiederzuverwenden (Speicher, Key Vault, App-Insights und Azure Container Registry-ACR) sowie zusätzliche Einstellungen wie private Endpunktkonfiguration und Computeziel zu ändern.

Importieren Sie die Klasse, und erstellen Sie einen neuen Arbeitsbereich mithilfe des folgenden Codes. Legen Sie create_resource_group auf False fest, wenn Sie über eine zuvor vorhandene Azure-Ressourcengruppe verfügen, die Sie für den Arbeitsbereich verwenden möchten. Einige Funktionen werden möglicherweise zur Eingabe von Azure-Authentifizierungsanmeldeinformationen aufgefordert.

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

Verwenden Sie denselben Arbeitsbereich in mehreren Umgebungen, indem Sie ihn zuerst in eine JSON-Konfigurationsdatei schreiben. Dadurch werden Ihre Abonnement-, Ressourcen- und Arbeitsbereichsnamendaten gespeichert.

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

Laden Sie Ihren 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 die statische get()-Methode verwenden, um einen vorhandenen Arbeitsbereich zu 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 ein Workspace -Objekt in den folgenden Codebeispielen dar.

Experiment

Namespace-: azureml.core.experiment.Experiment

Die Experiment Klasse ist eine weitere grundlegende Cloudressource, die eine Sammlung von Testversionen darstellt (einzelne Modellausführungen). Der folgende Code ruft ein Experiment-Objekt aus Workspace nach Namen ab, oder es 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 in Workspaceenthaltenen Experiment Objekte abzurufen.

list_experiments = Experiment.list(ws)

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

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

Es gibt zwei Möglichkeiten, eine Experimenttestphase auszuführen. Wenn Sie interaktiv in einem Jupyter-Notizbuch experimentieren, verwenden Sie die start_logging-Funktion. Wenn Sie ein Experiment aus einer Standard-Python-Umgebung übermitteln, verwenden Sie die submit-Funktion. Beide Funktionen geben ein Run-Objekt zurück. Die experiment Variable stellt ein Experiment -Objekt in den folgenden Codebeispielen dar.

Laufen

Namespace-: azureml.core.run.Run

Eine Ausführung stellt eine einzelne Testversion eines Experiments dar. Run ist das Objekt, das Sie verwenden, um die asynchrone Ausführung einer Testversion zu überwachen, die Ausgabe der Testversion zu speichern, Ergebnisse zu analysieren und auf generierte Artefakte zuzugreifen. Sie verwenden Run in Ihrem Experimentiercode, um Metriken und Artefakte beim Run History-Dienst zu protokollieren. Die Funktionalität umfasst:

• Speichern und Abrufen von Metriken und Daten.
• Verwenden von Tags und der untergeordneten Hierarchie für einfache Nachschlagevorgänge früherer Ausführungen.
• Registrieren gespeicherter Modelldateien für die Bereitstellung.
• Speichern, Ändern und Abrufen von Eigenschaften einer Ausführung.

Erstellen Sie ein Run-Objekt, indem Sie ein Experiment-Objekt mit einem Ausführen der Konfiguration-Objekts übermitteln. Verwenden Sie den parameter tags, um benutzerdefinierte Kategorien und Beschriftungen an Ihre Ausführung anzufügen. Sie können sie später problemlos von Experimentfinden 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 aus Experimentabzurufen. Geben Sie den tags Parameter an, der nach dem zuvor erstellten Tag gefiltert werden soll.

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

Verwenden Sie die get_details-Funktion, um die detaillierte Ausgabe für die Ausführung abzurufen.

run_details = run.get_details()

Die Ausgabe für diese Funktion ist ein Wörterbuch, das Folgendes umfasst:

• Run-ID
• Status
• Start- und Endzeit
• Computeziel (lokal im Vergleich zur Cloud)
• Abhängigkeiten und Versionen, die in der Ausführung verwendet werden
• Schulungsspezifische Daten (je nach Modelltyp)

Weitere Beispiele zum Konfigurieren und Überwachen von Ausführungen finden Sie in den Vorgehensweisen.

Modell

Namespace-: azureml.core.model.Model

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

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

Das folgende Beispiel zeigt, wie Sie ein einfaches lokales Klassifizierungsmodell mit scikit-learnerstellen, das Modell in Workspaceregistrieren und das Modell aus der Cloud herunterladen.

Erstellen Sie einen einfachen Klassifizierer, clf, um Kundenabwanderungen basierend auf ihrem Alter vorherzusagen. Speichern Sie dann das Modell in einer .pkl Datei im selben Verzeichnis.

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, um das Modell in Ihrem Arbeitsbereich zu registrieren. 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, ist es einfach, Ihre Modelle zu verwalten, herunterzuladen und zu organisieren. Um ein Modellobjekt (z. B. in einer anderen Umgebung) aus Workspaceabzurufen, verwenden Sie den Klassenkonstruktor, und geben Sie den Modellnamen und alle optionalen Parameter an. Verwenden Sie dann die download-Funktion, um das Modell einschließlich der Cloudordnerstruktur herunterzuladen.

from azureml.core.model import Model
import os

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

Verwenden Sie die delete-Funktion, um das Modell aus Workspacezu entfernen.

model.delete()

Nachdem Sie ein registriertes Modell erstellt haben, ist die Bereitstellung als Webdienst ein einfacher Prozess. Zuerst Sie ein Bilderstellen und registrieren. In diesem Schritt werden die Python-Umgebung und ihre Abhängigkeiten sowie ein Skript zum Definieren der Webdienstanforderungs- und Antwortformate konfiguriert. Nachdem Sie ein Image erstellt haben, Sie eine Bereitstellungskonfiguration erstellen, die die CPU-Kerne und Speicherparameter für das Computeziel festlegt. Anschließend fügen Sie Ihr Bild 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, in denen Sie Ihre Machine Learning-Modelle trainieren können. Ein Computeziel kann entweder ein lokaler Computer oder eine Cloudressource sein, z. B. Azure Machine Learning Compute, Azure HDInsight oder ein virtueller Remotecomputer.

Verwenden Sie Computeziele, um leistungsstarke virtuelle Computer für Modellschulungen zu nutzen und entweder dauerhafte Computeziele oder temporäre laufzeitaufgerufene Ziele einzurichten. Eine umfassende Anleitung zum Einrichten und Verwalten von Computezielen finden Sie in den Vorgehensweisen.

Der folgende Code zeigt ein einfaches Beispiel für das Einrichten eines AmlCompute (untergeordnete Klasse von ComputeTarget) Ziel. Dieses Ziel erstellt eine Laufzeit-Remote computeressource in Ihrem Workspace-Objekt. Die Ressource wird automatisch skaliert, wenn ein Auftrag übermittelt wird. Sie wird automatisch gelöscht, wenn die Ausführung abgeschlossen ist.

Verwenden Sie das einfache scikit-learn Änderungsmodell wieder, und erstellen Sie es in eine eigene Datei, train.py, im aktuellen Verzeichnis. Erstellen Sie am Ende der Datei ein neues Verzeichnis namens outputs. In diesem Schritt wird ein Verzeichnis in der Cloud (Ihrem Arbeitsbereich) erstellt, um Ihr trainiertes Modell zu speichern, das serialisiert joblib.dump().

# 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 kleinste Ressourcengröße (1 CPU-Kern, 3,5 GB Arbeitsspeicher) verwendet. Die list_vms Variable enthält eine Liste der unterstützten virtuellen Computer und deren 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 Remote computeressource mithilfe der CondaDependencies-Klasse. Die train.py Datei verwendet scikit-learn und numpy, 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_configfestzulegen.

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 können Sie das Experiment übermitteln. Verwenden Sie die ScriptRunConfig Klasse, um die Computezielkonfiguration anzufügen, und geben Sie den Pfad/die Datei an das Schulungsskript train.pyan. Übermitteln Sie das Experiment, indem Sie den config Parameter der submit()-Funktion angeben. Rufen Sie wait_for_completion für die resultierende Ausführung auf, um die asynchrone Ausführungsausgabe anzuzeigen, während die Umgebung initialisiert wird 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 trainierte Modelldatei churn-model.pkl in Ihrem Arbeitsbereich verfügbar.

Umwelt

Namespace-: azureml.core.environment

Azure Machine Learning-Umgebungen geben die Python-Pakete, Umgebungsvariablen und Softwareeinstellungen für Ihre Schulungs- und Bewertungsskripts an. Zusätzlich zu Python können Sie auch PySpark, Docker und R für Umgebungen konfigurieren. Intern führen Umgebungen zu Docker-Images, die zum Ausführen der Schulungs- und Bewertungsprozesse für das Computeziel verwendet werden. Die Umgebungen sind verwaltete und versionsgesteuerte Entitäten innerhalb Ihres Machine Learning-Arbeitsbereichs, die reproduzierbare, überprüfbare und tragbare Machine Learning-Workflows über eine Vielzahl von Computezielen und Computetypen hinweg ermöglichen.

Sie können ein Environment-Objekt verwenden, um:

• Entwickeln Sie Ihr Schulungsskript.
• Verwenden Sie dieselbe Umgebung auf Azure Machine Learning Compute für Modellschulungen im großen Maßstab.
• Stellen Sie Ihr Modell mit derselben Umgebung bereit, ohne an einen bestimmten Computetyp gebunden zu sein.

Der folgende Code importiert die Environment-Klasse aus dem SDK und instanziiert ein Umgebungsobjekt.

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

Fügen Sie einer Umgebung Pakete hinzu, indem Sie Conda-, Pip- oder private Raddateien verwenden. Geben Sie jede Paketabhängigkeit mithilfe der CondaDependency Klasse an, um sie der PythonSectionUmgebung hinzuzufügen.

Im folgenden Beispiel wird der Umgebung hinzugefügt. Es fügt Version 1.17.0 von numpyhinzu. Außerdem wird das pillow-Paket der Umgebung myenvhinzugefügt. Im Beispiel werden 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

Um eine Schulungsausführung zu übermitteln, müssen Sie Ihre Umgebung, Computezielund Ihr Schulungs-Python-Skript in einer Ausführungskonfiguration kombinieren. Diese Konfiguration ist ein Wrapperobjekt, das zum Übermitteln von Ausführungen verwendet wird.

Wenn Sie einen Schulungslauf einreichen, kann das Erstellen einer neuen Umgebung mehrere Minuten dauern. Die Dauer hängt von der Größe der erforderlichen Abhängigkeiten ab. Die Umgebungen werden vom Dienst zwischengespeichert. Solange die Umgebungsdefinition unverändert bleibt, erfolgt die vollständige Einrichtungszeit nur einmal.

Das folgende Beispiel zeigt, wo Sie ScriptRunConfig als Wrapperobjekt 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 vor dem Übermitteln der Ausführung keine Umgebung in Ihrer Ausführungskonfiguration angeben, wird für Sie eine Standardumgebung erstellt.

Informationen zum Bereitstellen eines Webdiensts finden Sie im Abschnitt Model deploy section to use environments to deploy a web service.

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 Machine Learning-Aufgabe. Teilvorgänge werden als eine Reihe von Schritten innerhalb der Pipeline gekapselt. Eine Azure Machine Learning-Pipeline kann so einfach wie ein Schritt sein, der ein Python-Skript aufruft. Pipelines umfassen Funktionen für:

• Datenvorbereitung, einschließlich Import, Überprüfung und Reinigung, Mung und Transformation, Normalisierung und Staging
• Schulungskonfiguration, einschließlich Parametrisierung von Argumenten, Dateipfaden und Protokollierungs-/Berichtskonfigurationen
• Schulung und Überprüfung effizient und wiederholbar, was die Angabe bestimmter Datenuntermengen, verschiedene Hardware-Computeressourcen, verteilte Verarbeitung und Fortschrittsüberwachung umfassen kann
• Bereitstellung, einschließlich Versionsverwaltung, Skalierung, Bereitstellung und Zugriffssteuerung
• Veröffentlichen einer Pipeline an einem REST-Endpunkt zum erneuten Ausführen aus einer beliebigen HTTP-Bibliothek

Ein PythonScriptStep ist ein einfacher, integrierter Schritt zum Ausführen eines Python-Skripts auf einem Computeziel. Es verwendet einen Skriptnamen und andere optionale Parameter wie Argumente für das Skript, Computeziel, Eingaben und Ausgaben. Der folgende Code ist ein einfaches Beispiel für eine PythonScriptStep. Ein Beispiel für ein train.py-Skript finden Sie im Lernprogramm Unterabschnitt.

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 als einfache automatisierte Pipeline miteinander verknüpft und veröffentlicht werden.

from azureml.pipeline.core import Pipeline

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

Ein umfassendes Beispiel zum Erstellen eines Pipelineworkflows finden Sie im erweiterten Lernprogramm.

Muster zum Erstellen und Verwenden von Pipelines

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

Ein gängiges Muster für Pipelineschritte ist:

1. Angeben des Arbeitsbereichs, der Berechnung und des Speichers
2. Konfigurieren der Eingabe- und Ausgabedaten mithilfe von
   1. Dataset-, das einen vorhandenen Azure-Datenspeicher zur Verfügung stellt
   2. PipelineDataset-, das typierte tabellarische Daten kapselt
   3. PipelineData-, die für Zwischendatei- oder Verzeichnisdaten verwendet wird, die von einem Schritt geschrieben wurden und von einem anderen genutzt werden sollen
3. Definieren einer oder mehrerer Pipelineschritte
4. Instanziieren einer Pipeline mithilfe Ihres Arbeitsbereichs und ihrer Schritte
5. Erstellen eines Experiments, an das Sie die Pipeline übermitteln
6. Überwachen der Experimentergebnisse

Dieses Notizbuch ist ein gutes Beispiel für dieses Muster. Arbeit

Weitere Informationen zu Azure Machine Learning-Pipelines und insbesondere zur Unterscheidung von anderen Pipelinetypen finden Sie in diesem Artikel.

AutoMLConfig

Namespace-: azureml.train.automl.automlconfig.AutoMLConfig

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

• Vorgangstyp (Klassifizierung, Regression, Prognose)
• Anzahl der Algorithmusiterationen und maximale Zeit pro Iteration
• Genauigkeitsmetrik zur Optimierung
• Algorithmen für Blockliste/Zulassungsliste
• Anzahl der überprüfungsübergreifenden Überprüfungen
• Berechnen von Zielen
• Schulungsdaten

Ausführliche Anleitungen und Beispiele für das Einrichten automatisierter Machine Learning-Experimente finden Sie im Lernprogramm und Anleitungen zum.

Der folgende Code veranschaulicht das Erstellen eines automatisierten Machine Learning-Konfigurationsobjekts 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 nach Abschluss an. Nach Abschluss der Ausführung wird ein AutoMLRun-Objekt (das die Run Klasse erweitert) zurückgegeben. Rufen Sie das am besten geeignete Modell ab, indem Sie die get_output()-Funktion verwenden, 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 ist für Konfigurationseinstellungen vorgesehen, die die Umgebung beschreiben, die zum Hosten des Modells und Webdiensts erforderlich ist.

Webservice ist die abstrakte übergeordnete Klasse zum Erstellen und Bereitstellen von Webdiensten für Ihre Modelle. Eine ausführliche Anleitung zum Vorbereiten der Modellbereitstellung und bereitstellung von Webdiensten finden Sie in diesem Vorgehensweisen.

Sie können Umgebungen verwenden, wenn Sie Ihr Modell als Webdienst bereitstellen. Umgebungen ermöglichen einen reproduzierbaren, verbundenen Workflow, in dem Sie Ihr Modell mithilfe der gleichen Bibliotheken sowohl in Ihrer Schulungsberechnung als auch in Ihrer Ableitung bereitstellen können. Intern werden Umgebungen als Docker-Images implementiert. Sie können entweder von Microsoft bereitgestellte Images verwenden oder eigene benutzerdefinierte Docker-Images verwenden. Wenn Sie zuvor die ContainerImage-Klasse für Ihre Bereitstellung verwendet haben, lesen Sie die DockerSection Klasse zum Ausführen eines ähnlichen Workflows mit Umgebungen.

Um einen Webdienst bereitzustellen, kombinieren Sie die Umgebung, die Berechnung, das Bewertungsskript und das registrierte Modell in Ihrem Bereitstellungsobjekt, deploy().

Im folgenden Beispiel wird davon ausgegangen, dass Sie bereits eine Schulungsausführung mit Umgebung, myenvabgeschlossen haben und dieses Modell in Azure-Containerinstanzen 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 am besten für kleine Tests und schnelle Bereitstellungen geeignet ist. Verwenden Sie Azure Kubernetes Service (AKS), um Ihr Modell als Produktionswebdienst bereitzustellen. Weitere Informationen finden Sie unter 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 untersuchen und das Dataset in Ihrem AML-Arbeitsbereich speichern, um Versionsverwaltungs- und Reproduzierbarkeitsfunktionen zu erhalten. Datasets werden während der Schulung problemlos von Modellen genutzt. Ausführliche Verwendungsbeispiele finden Sie in der Anleitung.

• TabularDataset stellt Daten in einem tabellarischen Format dar, das durch analysieren einer Datei oder Liste von Dateien erstellt wird.
• FileDataset verweisen auf einzelne oder mehrere Dateien in Datenspeichern oder aus öffentlichen URLs.

Das folgende Beispiel zeigt, wie Sie ein TabularDataset erstellen, das auf einen einzelnen Pfad in einem Datenspeicher zeigt.

from azureml.core import Dataset

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

Das folgende Beispiel zeigt, wie Sie eine FileDataset erstellen, die 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 die folgenden Schritte aus, um zu erfahren, wie Sie das Azure Machine Learning SDK für Python verwenden:

• Folgen Sie dem Lernprogramm, um zu erfahren, wie Sie ein Modell in Python erstellen, trainieren und bereitstellen.

• Suchen Sie Klassen und Module in der Referenzdokumentation auf dieser Website mithilfe des Inhaltsverzeichnisses auf der linken Seite nach.