Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
GILT FÜR: 
Python SDK azure-ai-ml v2 (aktuell)
Hinweis
Ein Lernprogramm, das SDK v1 zum Erstellen einer Pipeline verwendet, finden Sie im Lernprogramm: Erstellen einer Azure Machine Learning-Pipeline für die Imageklassifizierung.
Eine Machine Learning-Pipeline teilt eine vollständige Machine Learning-Aufgabe in einen mehrstufigen Workflow auf. Jeder Schritt ist eine verwaltbare Komponente, die Sie einzeln entwickeln, optimieren, konfigurieren und automatisieren können. Klar definierte Schnittstellen verbinden Schritte. Der Azure Machine Learning-Pipelinedienst koordiniert alle Abhängigkeiten zwischen Pipelineschritten.
Die Vorteile der Verwendung einer Pipeline sind standardisierte MLOps-Praxis, skalierbare Teamzusammenarbeit, Schulungseffizienz und Kostenreduzierung. Weitere Informationen zu den Nutzen von Pipelines finden Sie unter Was sind Azure Machine Learning-Pipelines.
In diesem Lernprogramm verwenden Sie Azure Machine Learning, um ein produktionsfähiges Machine Learning-Projekt mit Azure Machine Learning Python SDK v2 zu erstellen. Nach diesem Lernprogramm können Sie das Azure Machine Learning Python SDK verwenden, um:
- Abrufen eines Handles für Ihren Azure Machine Learning-Arbeitsbereich
- Erstellen von Azure Machine Learning-Datenressourcen
- Erstellen wiederverwendbarer Azure Machine Learning-Komponenten
- Erstellen, Überprüfen und Ausführen von Azure Machine Learning-Pipelines
Während diesem Tutorial erstellen Sie eine Azure Machine Learning-Pipeline, um ein Modell für die Kreditausfallvorhersage zu trainieren. Die Pipeline besteht aus zwei Schritten:
- Datenaufbereitung
- Trainieren und Registrieren des trainierten Modells
Die nächste Abbildung zeigt eine einfache Pipeline, wie sie im Azure Studio angezeigt wird, nachdem Sie sie übermittelt haben.
Die beiden Schritte sind Datenvorbereitung und Schulung.
Dieses Video zeigt Ihnen, wie Sie mit Azure Machine Learning Studio loslegen, um den Schritten des Tutorials folgen zu können. Das Video zeigt, wie Sie ein Notebook erstellen, eine Computeinstanz erstellen und das Notebook klonen. In den folgenden Abschnitten werden auch diese Schritte beschrieben.
Voraussetzungen
-
Für die Verwendung von Azure Machine Learning benötigen Sie einen Arbeitsbereich. Wenn Sie noch keinen haben, schließen Sie Erstellen von Ressourcen, die Sie für die ersten Schritte benötigen ab, um einen Arbeitsbereich zu erstellen, und mehr über dessen Verwendung zu erfahren.
Wichtig
Wenn Ihr Azure Machine Learning-Arbeitsbereich mit einem verwalteten virtuellen Netzwerk konfiguriert ist, müssen Sie möglicherweise Ausgangsregeln hinzufügen, um den Zugriff auf die öffentlichen Python-Paketrepositorys zu ermöglichen. Weitere Informationen finden Sie unter Szenario: Zugreifen auf öffentliche Machine Learning-Pakete.
-
Melden Sie sich bei Studio an, und wählen Sie Ihren Arbeitsbereich aus, falls dieser noch nicht geöffnet ist.
Schließen Sie das Tutorial Hochladen, Abrufen und Untersuchen Ihrer Daten ab, um das Datenobjekt zu erstellen, das Sie in diesem Tutorial benötigen. Stellen Sie sicher, dass Sie den gesamten Code ausführen, um das anfängliche Datenobjekt zu erstellen. Sie können die Daten untersuchen und bei Bedarf überarbeiten, aber sie benötigen nur die anfänglichen Daten für dieses Lernprogramm.
-
Öffnen oder erstellen Sie ein neues Notebook in Ihrem Arbeitsbereich:
- Wenn Sie Code kopieren und in Zellen einfügen möchten, erstellen Sie ein neues Notebook.
- Alternativ öffnen Sie die Datei tutorials/get-started-notebooks/quickstart.ipynb im Abschnitt Beispiele des Studios. Wählen Sie dann Klonen aus, um das Notebook zu Ihren Dateien hinzuzufügen. Informationen zum Suchen nach Beispielnotebooks finden Sie unter Lernen anhand von Beispiel-Notebooks.
Festlegen des Kernels und Öffnen in Visual Studio Code (VS Code)
Erstellen Sie auf der oberen Leiste über Ihrem geöffneten Notebook eine Compute-Instanz, falls Sie noch keine besitzen.
Wenn die Compute-Instanz beendet wurde, wählen Sie Compute starten aus, und warten Sie, bis sie ausgeführt wird.
Warten Sie, bis die Compute-Instanz ausgeführt wird. Vergewissern Sie sich dann, dass sich rechts oben der Kernel
Python 3.10 - SDK v2befindet. Falls nicht, verwenden Sie die Dropdownliste, um diesen Kernel auszuwählen.
Falls dieser Kernel nicht angezeigt wird, überprüfen Sie, ob Ihre Compute-Instanz ausgeführt wird. Falls ja, wählen Sie rechts oben im Notebook die Schaltfläche Aktualisieren aus.
Wenn Sie ein Banner mit dem Hinweis sehen, dass Sie authentifiziert werden müssen, wählen Sie Authentifizieren aus.
Sie können das Notebook hier ausführen oder es in VS Code öffnen, um eine vollständig integrierte Entwicklungsumgebung (Integrated Development Environment, IDE) mit der Leistungsfähigkeit von Azure Machine Learning-Ressourcen nutzen zu können. Wählen Sie In VS Code öffnen und dann unter „In VS Code bearbeiten“ entweder die Option „Web“ oder „Desktop“ aus. Wenn Sie den VS Code-Editor auf diese Weise starten, wird er an Ihre Compute-Instanz, den Kernel und das Dateisystem des Arbeitsbereichs angefügt.
Wichtig
Der Rest dieses Tutorials enthält Zellen des Tutorial-Notebooks. Kopieren Sie diese, und fügen Sie sie in Ihr neues Notebook ein, oder wechseln Sie jetzt zum Notebook, wenn Sie es geklont haben.
Einrichten der Pipelineressourcen
Sie können das Azure Machine Learning-Framework über die Azure CLI-, Python-SDK- oder Studioschnittstelle verwenden. In diesem Beispiel verwenden Sie das Azure Machine Learning Python-SDK v2 zum Erstellen einer Pipeline.
Bevor Sie die Pipeline erstellen, benötigen Sie diese Ressourcen:
- Die Datenressource für das Training
- Die Softwareumgebung zum Ausführen der Pipeline
- Eine Computerressource, auf der der Auftrag ausgeführt wird
Erstellen eines Handles für den Arbeitsbereich
Bevor Sie den Code verwenden, benötigen Sie eine Möglichkeit, auf Ihren Arbeitsbereich zu verweisen. Erstellen Sie ml_client als Handle für den Arbeitsbereich. Sie verwenden dann ml_client zur Verwaltung von Ressourcen und Aufträgen.
Geben Sie in der nächsten Zelle Ihre Abonnement-ID, den Namen der Ressourcengruppe und den Arbeitsbereichsnamen ein. So finden Sie diese Werte:
- Wählen Sie auf der oben rechts angezeigten Azure Machine Learning Studio-Symbolleiste den Namen Ihres Arbeitsbereichs aus.
- Kopieren Sie den Wert für Arbeitsbereich, Ressourcengruppe und Abonnement-ID in den Code. Sie müssen einen Wert kopieren, den Bereich schließen, diesen Wert einfügen und dann zum nächsten Wert zurückkehren.
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
# authenticate
credential = DefaultAzureCredential()
SUBSCRIPTION = "<SUBSCRIPTION_ID>"
RESOURCE_GROUP = "<RESOURCE_GROUP>"
WS_NAME = "<AML_WORKSPACE_NAME>"
# Get a handle to the workspace
ml_client = MLClient(
credential=credential,
subscription_id=SUBSCRIPTION,
resource_group_name=RESOURCE_GROUP,
workspace_name=WS_NAME,
)
SDK-Referenz:
Hinweis
Das Erstellen von MLClient stellt keine Verbindung mit dem Arbeitsbereich her. Die Clientinitialisierung erfolgt verzögert. Sie wartet auf die erste Anforderung, die sie stellen muss. Initialisierung erfolgt in der nächsten Codezelle.
Überprüfen Sie die Verbindung durch einen Anruf bei ml_client. Da dieser Anruf das erste Mal ist, dass Sie einen Anruf an den Arbeitsbereich tätigen, werden Sie möglicherweise aufgefordert, sich zu authentifizieren.
# Verify that the handle works correctly.
# If you get an error here, modify your SUBSCRIPTION, RESOURCE_GROUP, and WS_NAME in the previous cell.
ws = ml_client.workspaces.get(WS_NAME)
print(ws.location, ":", ws.resource_group)
SDK-Referenz:
Zugreifen auf das registrierte Datenobjekt
Beginnen Sie mit dem Abrufen der Daten, die Sie zuvor im Lernprogramm registriert haben: Hochladen, Zugreifen und Untersuchen Ihrer Daten in Azure Machine Learning.
Hinweis
Azure Machine Learning verwendet ein Data Objekt, um eine wiederverwendbare Definition von Daten zu registrieren und Daten in einer Pipeline zu nutzen.
# get a handle of the data asset and print the URI
credit_data = ml_client.data.get(name="credit-card", version="initial")
print(f"Data asset URI: {credit_data.path}")
SDK-Referenz:
Erstellen einer Auftragsumgebung für Pipelineschritte
Bisher haben Sie eine Entwicklungsumgebung auf der Computeinstanz, Ihrem Entwicklungscomputer, erstellt. Sie benötigen außerdem eine Umgebung, die Sie für Schritt in der Pipeline verwenden können. Jeder Schritt kann über eine eigene Umgebung verfügen, oder Sie können einige gemeinsame Umgebungen für mehrere Schritte verwenden.
In diesem Beispiel erstellen Sie eine Conda-Umgebung für Ihre Aufträge, indem Sie eine Conda-YAML-Datei verwenden. Zunächst erstellen Sie ein Verzeichnis, in dem die Datei gespeichert wird.
import os
dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)
Jetzt erstellen Sie die Datei im Abhängigkeitsverzeichnis.
%%writefile {dependencies_dir}/conda.yaml
name: model-env
channels:
- conda-forge
dependencies:
- python=3.10
- numpy=1.21.2
- pip=21.2.4
- scikit-learn=0.24.2
- scipy=1.7.1
- pandas>=1.1,<1.2
- pip:
- inference-schema[numpy-support]==1.3.0
- xlrd==2.0.1
- mlflow== 2.4.1
- azureml-mlflow==1.51.0
Die Spezifikation enthält einige übliche Pakete, die Sie in Ihrer Pipeline verwenden (numpy, pip), zusammen mit einigen Azure Machine Learning-spezifischen Paketen (azureml-mlflow).
Die Azure Machine Learning-Pakete sind nicht erforderlich, um Azure Machine Learning-Aufträge auszuführen. Durch Hinzufügen dieser Pakete können Sie mit Azure Machine Learning interagieren, um Metriken zu protokollieren und Modelle zu registrieren, die sich im Azure Machine Learning-Auftrag befinden. Sie verwenden sie später in diesem Tutorial im Trainingsskript.
Verwenden Sie die YAML-Datei, um diese benutzerdefinierte Umgebung in Ihrem Arbeitsbereich zu erstellen und zu registrieren:
from azure.ai.ml.entities import Environment
custom_env_name = "aml-scikit-learn"
pipeline_job_env = Environment(
name=custom_env_name,
description="Custom environment for Credit Card Defaults pipeline",
tags={"scikit-learn": "0.24.2"},
conda_file=os.path.join(dependencies_dir, "conda.yaml"),
image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04:latest",
version="0.2.0",
)
pipeline_job_env = ml_client.environments.create_or_update(pipeline_job_env)
print(
f"Environment with name {pipeline_job_env.name} is registered to workspace, the environment version is {pipeline_job_env.version}"
)
SDK-Referenz:
Erstellen der Trainingspipeline
Nachdem Sie nun alle zum Ausführen der Pipeline erforderlichen Ressourcen haben, ist es an der Zeit, die Pipeline selbst zu erstellen.
Azure Machine Learning-Pipelines sind wiederverwendbare ML-Workflows, die normalerweise aus mehreren Komponenten bestehen. Der typische Lebenszyklus einer Komponente ist:
- Schreiben Sie die YAML-Spezifikation der Komponente, oder erstellen Sie sie programmgesteuert mithilfe von
ComponentMethod. - Registrieren Sie die Komponente optional mit einem Namen und einer Version in Ihrem Arbeitsbereich, damit sie wiederverwendbar und freigegeben werden kann.
- Die Komponente wird über den Pipelinecode geladen.
- Implementieren Sie die Pipeline mithilfe der Eingaben, Ausgaben und Parameter der Komponente.
- Übermitteln Sie die Pipeline.
Sie können eine Komponente auf zwei Arten erstellen: programmgesteuerte Definition und YAML-Definition. In den nächsten beiden Abschnitten erfahren Sie, wie Sie eine Komponente auf beide Arten erstellen. Sie können die beiden Komponenten entweder erstellen, indem Sie beide Optionen ausprobieren oder Ihre bevorzugte Methode auswählen.
Hinweis
In diesem Lernprogramm verwenden Sie aus Gründen der Einfachheit die gleiche Berechnung für alle Komponenten. Sie können jedoch für jede Komponente unterschiedliche Berechnungen festlegen. Sie können zum Beispiel eine Zeile wie train_step.compute = "cpu-cluster" hinzufügen. Ein Beispiel für das Erstellen einer Pipeline mit unterschiedlichen Computes für jede Komponente finden Sie unter Einfache Pipelineaufträge im Tutorial zur Cifar-10-Pipeline.
Erstellen von Komponente 1: Datenaufbereitung (anhand einer programmgesteuerten Definition)
Erstellen Sie zunächst die erste Komponente. Diese Komponente sorgt für die Vorverarbeitung der Daten. Die Aufgabe zur Vorverarbeitung wird in der Python-Datei data_prep.py ausgeführt.
Erstellen Sie zunächst einen Quellordner für die data_prep Komponente:
import os
data_prep_src_dir = "./components/data_prep"
os.makedirs(data_prep_src_dir, exist_ok=True)
Dieses Skript übernimmt die einfache Aufgabe, die Daten in Trainings- und Testdatasets aufzuteilen. Azure Machine Learning stellt Datasets als Ordner für die Berechnungen bereit. Sie haben eine Hilfsfunktion select_first_file erstellt, um auf die Datendatei im bereitgestellten Eingabeordner zuzugreifen.
MLFlow wird verwendet, um die Parameter und Metriken während der Pipelineausführung zu protokollieren.
%%writefile {data_prep_src_dir}/data_prep.py
import os
import argparse
import pandas as pd
from sklearn.model_selection import train_test_split
import logging
import mlflow
def main():
"""Main function of the script."""
# input and output arguments
parser = argparse.ArgumentParser()
parser.add_argument("--data", type=str, help="path to input data")
parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
parser.add_argument("--train_data", type=str, help="path to train data")
parser.add_argument("--test_data", type=str, help="path to test data")
args = parser.parse_args()
# Start Logging
mlflow.start_run()
print(" ".join(f"{k}={v}" for k, v in vars(args).items()))
print("input data:", args.data)
credit_df = pd.read_csv(args.data, header=1, index_col=0)
mlflow.log_metric("num_samples", credit_df.shape[0])
mlflow.log_metric("num_features", credit_df.shape[1] - 1)
credit_train_df, credit_test_df = train_test_split(
credit_df,
test_size=args.test_train_ratio,
)
# output paths are mounted as folder, therefore, we are adding a filename to the path
credit_train_df.to_csv(os.path.join(args.train_data, "data.csv"), index=False)
credit_test_df.to_csv(os.path.join(args.test_data, "data.csv"), index=False)
# Stop Logging
mlflow.end_run()
if __name__ == "__main__":
main()
Da Sie nun über ein Skript verfügen, das die gewünschte Aufgabe ausführen kann, erstellen Sie daraus eine Azure Machine Learning-Komponente.
Verwenden Sie die universelle CommandComponent, die Befehlszeilenaktionen ausführen kann. Diese Befehlszeilenaktion kann direkt Systembefehle aufrufen oder ein Skript ausführen. Die Eingaben und Ausgaben werden mithilfe der ${{ ... }} Notation auf der Befehlszeile angegeben.
from azure.ai.ml import command
from azure.ai.ml import Input, Output
data_prep_component = command(
name="data_prep_credit_defaults",
display_name="Data preparation for training",
description="reads a .xl input, split the input to train and test",
inputs={
"data": Input(type="uri_folder"),
"test_train_ratio": Input(type="number"),
},
outputs=dict(
train_data=Output(type="uri_folder", mode="rw_mount"),
test_data=Output(type="uri_folder", mode="rw_mount"),
),
# The source folder of the component
code=data_prep_src_dir,
command="""python data_prep.py \
--data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} \
--train_data ${{outputs.train_data}} --test_data ${{outputs.test_data}} \
""",
environment=f"{pipeline_job_env.name}:{pipeline_job_env.version}",
)
SDK-Referenz:
Optional können Sie die Komponente zur späteren Wiederverwendung im Arbeitsbereich registrieren.
# Now register the component to the workspace
data_prep_component = ml_client.create_or_update(data_prep_component.component)
# Create and register the component in your workspace
print(
f"Component {data_prep_component.name} with Version {data_prep_component.version} is registered"
)
SDK-Referenz:
Erstellen von Komponente 2: Training (mithilfe der YAML-Definition)
Die zweite komponente, die Sie erstellen, verbraucht die Schulungs- und Testdaten, trainiert ein strukturbasiertes Modell und gibt das Ausgabemodell zurück. Verwenden Sie die Protokollierungsfunktionen von Azure Machine Learning, um den Lernfortschritt aufzuzeichnen und zu visualisieren.
Sie haben Ihre erste Komponente mithilfe der CommandComponent-Klasse erstellt. Dieses Mal verwenden Sie die Yaml-Definition, um die zweite Komponente zu definieren. Jede Methode hat ihre Vorzüge. Eine Yaml-Definition kann entlang des Codes eingecheckt werden und bietet eine lesbare Verlaufsverfolgung. Die programmgesteuerte Methode mit Verwendung von CommandComponent kann durch die integrierte Klassendokumentation und die Codevervollständigung einfacher sein.
Erstellen Sie das Verzeichnis für diese Komponente:
import os
train_src_dir = "./components/train"
os.makedirs(train_src_dir, exist_ok=True)
Erstellen Sie das Trainingsskript im Verzeichnis:
%%writefile {train_src_dir}/train.py
import argparse
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
import os
import pandas as pd
import mlflow
def select_first_file(path):
"""Selects first file in folder, use under assumption there is only one file in folder
Args:
path (str): path to directory or file to choose
Returns:
str: full path of selected file
"""
files = os.listdir(path)
return os.path.join(path, files[0])
# Start Logging
mlflow.start_run()
# enable autologging
mlflow.sklearn.autolog()
os.makedirs("./outputs", exist_ok=True)
def main():
"""Main function of the script."""
# input and output arguments
parser = argparse.ArgumentParser()
parser.add_argument("--train_data", type=str, help="path to train data")
parser.add_argument("--test_data", type=str, help="path to test data")
parser.add_argument("--n_estimators", required=False, default=100, type=int)
parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
parser.add_argument("--registered_model_name", type=str, help="model name")
parser.add_argument("--model", type=str, help="path to model file")
args = parser.parse_args()
# paths are mounted as folder, therefore, we are selecting the file from folder
train_df = pd.read_csv(select_first_file(args.train_data))
# Extracting the label column
y_train = train_df.pop("default payment next month")
# convert the dataframe values to array
X_train = train_df.values
# paths are mounted as folder, therefore, we are selecting the file from folder
test_df = pd.read_csv(select_first_file(args.test_data))
# Extracting the label column
y_test = test_df.pop("default payment next month")
# convert the dataframe values to array
X_test = test_df.values
print(f"Training with data of shape {X_train.shape}")
clf = GradientBoostingClassifier(
n_estimators=args.n_estimators, learning_rate=args.learning_rate
)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
print(classification_report(y_test, y_pred))
# Registering the model to the workspace
print("Registering the model via MLFlow")
mlflow.sklearn.log_model(
sk_model=clf,
registered_model_name=args.registered_model_name,
artifact_path=args.registered_model_name,
)
# Saving the model to a file
mlflow.sklearn.save_model(
sk_model=clf,
path=os.path.join(args.model, "trained_model"),
)
# Stop Logging
mlflow.end_run()
if __name__ == "__main__":
main()
Wie Sie in diesem Schulungsskript sehen können, wird nach dem Trainieren des Modells die Modelldatei gespeichert und im Arbeitsbereich registriert. Jetzt können Sie das registrierte Modell in Rückschlussendpunkten verwenden.
Als Umgebung für diesen Schritt verwenden Sie eine der integrierten (kuratierten) Azure Machine Learning-Umgebungen. Das Tag azureml weist das System an, nach dem Namen in kuratierten Umgebungen zu suchen.
Erstellen Sie zunächst die YAML-Datei, die die Komponente beschreibt:
%%writefile {train_src_dir}/train.yml
# <component>
name: train_credit_defaults_model
display_name: Train Credit Defaults Model
# version: 1 # Not specifying a version will automatically update the version
type: command
inputs:
train_data:
type: uri_folder
test_data:
type: uri_folder
learning_rate:
type: number
registered_model_name:
type: string
outputs:
model:
type: uri_folder
code: .
environment:
# for this step, we'll use an AzureML curate environment
azureml://registries/azureml/environments/sklearn-1.0/labels/latest
command: >-
python train.py
--train_data ${{inputs.train_data}}
--test_data ${{inputs.test_data}}
--learning_rate ${{inputs.learning_rate}}
--registered_model_name ${{inputs.registered_model_name}}
--model ${{outputs.model}}
# </component>
Erstellen und registrieren Sie jetzt die Komponente. Durch die Registrierung können Sie sie in anderen Pipelines wiederverwenden. Jede andere Person mit Zugriff auf Ihren Arbeitsbereich kann auch die registrierte Komponente verwenden.
# importing the Component Package
from azure.ai.ml import load_component
# Loading the component from the yml file
train_component = load_component(source=os.path.join(train_src_dir, "train.yml"))
# Now register the component to the workspace
train_component = ml_client.create_or_update(train_component)
# Create and register the component in your workspace
print(
f"Component {train_component.name} with Version {train_component.version} is registered"
)
SDK-Referenz:
Erstellen der Pipeline aus Komponenten
Nachdem Sie Ihre Komponenten definiert und registriert haben, beginnen Sie mit der Implementierung der Pipeline.
Die Python-Funktionen, die load_component() zurückgegeben werden, funktionieren wie jede andere normale Python-Funktion. Verwenden Sie sie in einer Pipeline, um jeden Schritt aufzurufen.
Verwenden Sie zum Codieren der Pipeline einen bestimmten @dsl.pipeline Dekorateur, der die Azure Machine Learning-Pipelines identifiziert. Geben Sie im Dekorateur die Pipelinebeschreibung und Standardressourcen wie Compute und Speicher an. Wie eine Python-Funktion können auch Pipelines Eingaben verwenden. Sie können mehrere Instanzen einer einzelnen Pipeline mit unterschiedlichen Eingaben erstellen.
Verwenden Sie im folgenden Beispiel Eingabedaten, geteiltes Verhältnis und registrierten Modellnamen als Eingabevariablen. Rufen Sie dann die Komponenten auf, und verbinden Sie sie mithilfe ihrer Eingabe- und Ausgabe-IDs. Greifen Sie mithilfe der .outputs Eigenschaft auf die Ausgaben der einzelnen Schritte zu.
# the dsl decorator tells the sdk that we are defining an Azure Machine Learning pipeline
from azure.ai.ml import dsl, Input, Output
@dsl.pipeline(
compute="serverless", # "serverless" value runs pipeline on serverless compute
description="E2E data_perp-train pipeline",
)
def credit_defaults_pipeline(
pipeline_job_data_input,
pipeline_job_test_train_ratio,
pipeline_job_learning_rate,
pipeline_job_registered_model_name,
):
# using data_prep_function like a python call with its own inputs
data_prep_job = data_prep_component(
data=pipeline_job_data_input,
test_train_ratio=pipeline_job_test_train_ratio,
)
# using train_func like a python call with its own inputs
train_job = train_component(
train_data=data_prep_job.outputs.train_data, # note: using outputs from previous step
test_data=data_prep_job.outputs.test_data, # note: using outputs from previous step
learning_rate=pipeline_job_learning_rate, # note: using a pipeline input as parameter
registered_model_name=pipeline_job_registered_model_name,
)
# a pipeline returns a dictionary of outputs
# keys will code for the pipeline output identifier
return {
"pipeline_job_train_data": data_prep_job.outputs.train_data,
"pipeline_job_test_data": data_prep_job.outputs.test_data,
}
SDK-Referenz:
- dsl.pipeline
- Input (Eingabe)
- Ausgabe
Verwenden Sie nun Ihre Pipelinedefinition, um eine Pipeline mit Ihrem Dataset, mit der Teilungsrate Ihrer Wahl und dem von Ihnen für das Modell gewählten Namen zu instanziieren.
registered_model_name = "credit_defaults_model"
# Let's instantiate the pipeline with the parameters of our choice
pipeline = credit_defaults_pipeline(
pipeline_job_data_input=Input(type="uri_file", path=credit_data.path),
pipeline_job_test_train_ratio=0.25,
pipeline_job_learning_rate=0.05,
pipeline_job_registered_model_name=registered_model_name,
)
SDK-Referenz:
- Input (Eingabe)
Übermitteln des Auftrags
Übermitteln Sie nun den Auftrag, der in Azure Machine Learning ausgeführt werden soll. Verwenden Sie diesmal create_or_update für ml_client.jobs.
Geben Sie einen Experimentnamen an. Ein Experiment ist ein Container für alle Iterationen, die man für ein bestimmtes Projekt durchführt. Alle unter demselben Experimentnamen übermittelten Aufträge werden in Azure Machine Learning Studio nebeneinander angezeigt.
Nach dem Abschließen registriert die Pipeline ein Modell in Ihrem Arbeitsbereich als Ergebnis des Trainings.
# submit the pipeline job
pipeline_job = ml_client.jobs.create_or_update(
pipeline,
# Project's name
experiment_name="e2e_registered_components",
)
ml_client.jobs.stream(pipeline_job.name)
SDK-Referenz:
Sie können den Fortschritt Ihrer Pipeline nachverfolgen, indem Sie die in der vorherigen Zelle generierte Verknüpfung verwenden. Wenn Sie diesen Link zum ersten Mal anklicken, könnte Ihnen auffallen, dass die Pipeline noch läuft. Nach Abschluss der Ausführung können Sie die Ergebnisse der einzelnen Komponenten untersuchen.
Doppelklicken Sie auf die Komponente Trainieren des Kreditausfallmodells.
Zwei wichtige Ergebnisse, die Sie in Bezug auf das Training sehen möchten:
Zeigen Sie Ihre Protokolle an:
- Wählen Sie die Registerkarte Ausgaben+Protokolle aus.
- Öffnen Sie die Ordner für
user_logs>std_log.txtDieser Abschnitt zeigt die Skriptausführung „stdout“.
Anzeigen Ihrer Metriken: Wählen Sie die Registerkarte Metriken aus. Dieser Abschnitt zeigt verschiedene protokollierte Metriken an. In diesem Beispiel protokolliert mlflow
autologgingautomatisch die Schulungsmetriken.
Bereitstellen des Modells als Onlineendpunkt
Weitere Informationen zum Bereitstellen Ihres Modells auf einem Onlineendpunkt finden Sie unter Bereitstellen eines Modells als Onlineendpunkt-Lernprogramm.
Bereinigen von Ressourcen
Wenn Sie vorhaben, weitere Tutorials zu machen, überspringen Sie zu dem nächsten Schritt.
Beenden der Compute-Instanz
Wenn Sie die Computeinstanz jetzt nicht verwenden werden, beenden Sie sie:
- Wählen Sie im Studio im linken Bereich "Berechnen" aus.
- Wählen Sie auf den oberen Registerkarten die Option Compute-Instanzen aus.
- Wählen Sie in der Liste die Compute-Instanz aus.
- Wählen Sie auf der oberen Symbolleiste Beenden aus.
Löschen aller Ressourcen
Wichtig
Die von Ihnen erstellten Ressourcen können ggf. auch in anderen Azure Machine Learning-Tutorials und -Anleitungen verwendet werden.
Wenn Sie die erstellten Ressourcen nicht mehr benötigen, löschen Sie diese, damit Ihnen keine Kosten entstehen:
Geben Sie im Azure-Portal den Suchbegriff Ressourcengruppen in das Suchfeld ein, und wählen Sie in den Ergebnissen die entsprechende Option aus.
Wählen Sie in der Liste die Ressourcengruppe aus, die Sie erstellt haben.
Wählen Sie auf der Seite Übersicht die Option Ressourcengruppe löschen aus.
Geben Sie den Ressourcengruppennamen ein. Wählen Sie anschließend die Option Löschen.