Nachverfolgen von ML-Modellen mit MLflow und Azure Machine Learning

GILT FÜR:Python-SDK azureml(V1)

GILT FÜR:Python-SDK azureml(V1)

In diesem Artikel erfahren Sie, wie Sie den Nachverfolgungs-URI und die Protokollierungs-API von MLflow (zusammen als MLflow-Tracking bezeichnet) zum Verbinden von Azure Machine Learning als Back-End Ihrer MLflow-Experimente nutzen.

Unterstützte Funktionen umfassen u. a.:

MLflow ist eine Open-Source-Bibliothek zum Verwalten des Lebenszyklus Ihrer Machine Learning-Experimente. MLflow-Nachverfolgung ist eine Komponente von MLflow, die Ihre Trainingsausführungsmetriken und Modellartefakte unabhängig von der Umgebung Ihres Experiments protokolliert und nachverfolgt: lokal auf Ihrem Computer, auf einem Remotecomputeziel, auf einem virtuellen Computer oder in einem Azure Databricks-Cluster.

Weitere Informationen zur Integration von MLflow- und Azure Machine Learning-Funktionen finden Sie unter MLflow und Azure Machine Learning.

Im folgenden Diagramm ist dargestellt, wie Sie mit MLflow-Tracking die Ausführungsmetriken eines Experiments nachverfolgen und Modellartefakte in Ihrem Azure Machine Learning-Arbeitsbereich speichern.

mlflow with azure machine learning diagram

Tipp

Die Informationen in diesem Dokument sind hauptsächlich für Datenanalysten und Entwickler gedacht, die den Modelltrainingsprozess überwachen möchten. Wenn Sie Administrator sind und sich für die Überwachung der Nutzung und Ereignisse von Azure Machine Learning (z. B. Kontingente, abgeschlossene Trainingsausführungen oder abgeschlossene Modellimplementierungen) interessieren, helfen Ihnen die Informationen im Artikel Überwachen von Azure Machine Learning weiter.

Hinweis

Sie können den MLflow Skinny-Client verwenden. Dabei handelt es sich um ein einfaches MLflow-Paket ohne SQL-Speicher, Server, Benutzeroberfläche oder Data Science-Abhängigkeiten. Dies wird für Benutzer empfohlen, die in erster Linie die Nachverfolgungs- und Protokollierungsfunktionen benötigen, ohne die gesamte Suite von MLflow-Features einschließlich Bereitstellungen zu importieren.

Voraussetzungen

Nachverfolgen von lokalen Ausführungen

Mit MLflow-Tracking mit Azure Machine Learning können Sie die Ausführungen der protokollierten Metriken und Artefakte in Ihrem Azure Machine Learning-Arbeitsbereich speichern, die auf Ihrem lokalen Computer ausgeführt wurden. Weitere Informationen finden Sie unter Protokollieren und Anzeigen von Metriken (V2).

Einrichten der Nachverfolgungsumgebung

Um eine lokale Ausführung nachzuverfolgen, müssen Sie Ihren lokalen Computer auf den MLflow-Nachverfolgungs-URI von Azure Machine Learning verweisen.

Importieren Sie die Klassen mlflow und Workspace, um auf den Tracking-URI von MLflow zuzugreifen und Ihren Arbeitsbereich zu konfigurieren.

Im folgenden Code wird mit der get_mlflow_tracking_uri()-Methode dem Arbeitsbereich ws eine eindeutige Tracking-URI-Adresse zugewiesen, und mit set_tracking_uri() wird für den Tracking-URI von MLflow auf diese Adresse verwiesen.

import mlflow
from azureml.core import Workspace

ws = Workspace.from_config()

mlflow.set_tracking_uri(ws.get_mlflow_tracking_uri())

Festlegen des Experimentnamens

Alle MLflow-Ausführungen werden im aktiven Experiment protokolliert, das mit dem MLflow SDK oder der Azure CLI festgelegt werden kann.

Legen Sie den Namen des MLflow-Experiments mit dem Befehl set_experiment() fest.

experiment_name = 'experiment_with_mlflow'
mlflow.set_experiment(experiment_name)

Starten der Trainingsausführung

Nachdem Sie den Namen des MLflow-Experiments festgelegt haben, können Sie Ihre Trainingsausführung mit start_run() starten. Verwenden Sie anschließend log_metric(), um die API für die MLflow-Protokollierung zu aktivieren, und beginnen Sie mit dem Protokollieren Ihrer Metriken für die Trainingsausführungen.

import os
from random import random

with mlflow.start_run() as mlflow_run:
    mlflow.log_param("hello_param", "world")
    mlflow.log_metric("hello_metric", random())
    os.system(f"echo 'hello world' > helloworld.txt")
    mlflow.log_artifact("helloworld.txt")

Nachverfolgen von Remoteausführungen

Bei Remoteausführungen können Sie für das Trainieren Ihrer Modelle leistungsfähigere Computeumgebungen, z. B. GPU-fähige virtuelle Computer, oder Machine Learning Compute-Cluster verwenden. Informationen zu den verschiedenen Computeoptionen finden Sie unter Übermitteln einer Trainingsausführung an ein Computeziel.

Mit MLflow-Tracking mit Azure Machine Learning können Sie die protokollierten Metriken und Artefakte aus Ihren Remoteausführungen in Ihrem Azure Machine Learning-Arbeitsbereich speichern. Bei jeder Ausführung mit MLflow-Nachverfolgungscode werden automatisch Metriken im Arbeitsbereich protokolliert.

Zunächst sollten Sie ein src-Unterverzeichnis und eine Datei mit Ihrem Trainingscode in einer train.py-Datei im src-Unterverzeichnis erstellen. Der gesamte Trainingscode (einschließlich train.py) wird im Unterverzeichnis src gespeichert.

Der Trainingscode stammt aus diesem MLflow-Beispiel im Azure Machine Learning-Beispielrepository.

Kopieren Sie diesen Code in die Datei:

# imports
import os
import mlflow

from random import random

# define functions
def main():
    mlflow.log_param("hello_param", "world")
    mlflow.log_metric("hello_metric", random())
    os.system(f"echo 'hello world' > helloworld.txt")
    mlflow.log_artifact("helloworld.txt")


# run functions
if __name__ == "__main__":
    # run main function
    main()

Laden Sie das Trainingsskript, um ein Experiment zu übermitteln.

script_dir = "src"
training_script = 'train.py'
with open("{}/{}".format(script_dir,training_script), 'r') as f:
    print(f.read())

Konfigurieren Sie in Ihrem Skript die Umgebung für Computevorgänge und Trainingsausführungen mit der Environment-Klasse.

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

env = Environment(name="mlflow-env")

# Specify conda dependencies with scikit-learn and temporary pointers to mlflow extensions
cd = CondaDependencies.create(
    conda_packages=["scikit-learn", "matplotlib"],
    pip_packages=["azureml-mlflow", "pandas", "numpy"]
    )

env.python.conda_dependencies = cd

Erstellen Sie anschließend ScriptRunConfig mit Ihrer Remotecomputeumgebung als Computeziel.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory="src",
                      script=training_script,
                      compute_target="<COMPUTE_NAME>",
                      environment=env)

Verwenden Sie bei dieser Konfiguration für Computevorgänge und Trainingsausführungen die Experiment.submit()-Methode, um eine Ausführung zu übermitteln. Mit dieser Methode wird der MLflow Tracking-URI automatisch festgelegt und die Protokollierung von MLflow an Ihren Arbeitsbereich geleitet.

from azureml.core import Experiment
from azureml.core import Workspace
ws = Workspace.from_config()

experiment_name = "experiment_with_mlflow"
exp = Experiment(workspace=ws, name=experiment_name)

run = exp.submit(src)

Anzeigen von Metriken und Artefakten in Ihrem Arbeitsbereich

Die Metriken und Artefakte aus dem MLflow-Protokoll werden in Ihrem Arbeitsbereich nachverfolgt. Sie können sie jederzeit anzeigen. Navigieren Sie dazu zu Ihrem Arbeitsbereich, und suchen Sie über den Namen nach dem Experiment in Ihrem Arbeitsbereich in Azure Machine Learning-Studio. Führen Sie alternativ den folgenden Befehl aus:

Rufen Sie die Ausführungsmetrik mithilfe von MLflow get_run() ab.

from mlflow.entities import ViewType
from mlflow.tracking import MlflowClient

# Retrieve run ID for the last run experiement
current_experiment=mlflow.get_experiment_by_name(experiment_name)
runs = mlflow.search_runs(experiment_ids=current_experiment.experiment_id, run_view_type=ViewType.ALL)
run_id = runs.tail(1)["run_id"].tolist()[0]

# Use MlFlow to retrieve the run that was just completed
client = MlflowClient()
finished_mlflow_run = MlflowClient().get_run(run_id)

metrics = finished_mlflow_run.data.metrics
tags = finished_mlflow_run.data.tags
params = finished_mlflow_run.data.params

print(metrics,tags,params)

Abrufen von Artefakten mit MLflow

Zum Anzeigen der Artefakte einer Ausführung können Sie MlFlowClient.list_artifacts() verwenden.

client.list_artifacts(run_id)

Zum Herunterladen eines Artefakts in das aktuelle Verzeichnis können Sie MLFlowClient.download_artifacts() verwenden.

client.download_artifacts(run_id, "helloworld.txt", ".")

Vergleichen und Abfragen

Vergleichen und fragen Sie alle MLflow-Ausführungen in Ihrem Azure Machine Learning-Arbeitsbereich mit dem folgenden Code ab. Erfahren Sie mehr über das Abfragen von Ausführungen mit MLflow.

from mlflow.entities import ViewType

all_experiments = [exp.experiment_id for exp in MlflowClient().list_experiments()]
query = "metrics.hello_metric > 0"
runs = mlflow.search_runs(experiment_ids=all_experiments, filter_string=query, run_view_type=ViewType.ALL)

runs.head(10)

Automatische Protokollierung

Mit Azure Machine Learning und MLFlow können Benutzer Metriken, Modellparameter und Modellartefakte automatisch protokollieren, wenn sie ein Modell trainieren. Eine Vielzahl beliebter Machine Learning-Bibliotheken wird unterstützt.

Um die automatische Protokollierung zu aktivieren, fügen Sie den folgenden Code vor dem Trainingscode ein:

mlflow.autolog()

Erfahren Sie mehr über die automatische Protokollierung mit MLflow.

Verwalten von Modellen

Registrieren und verfolgen Sie Ihre Modelle mit der Azure Machine Learning-Modellregistrierung, die die MLflow-Modellregistrierung unterstützt. Azure Machine Learning-Modelle werden am MLflow-Modellschema ausgerichtet, sodass Sie diese Modelle problemlos exportieren und in verschiedene Workflows importieren können. Die Metadaten zu MLflow, z. B. die Ausführungs-ID, werden auch mit dem registrierten Modell gekennzeichnet, um sie besser nachverfolgen zu können. Benutzer können Trainingsausführungen senden, registrieren und bereitstellen, die aus MLflow-Ausführungen erstellt wurden.

Wenn Sie Ihr Produktionsbereitstellungsmodell in einem Schritt bereitstellen und registrieren möchten, finden Sie weitere Informationen unter Bereitstellen und Registrieren von MLflow-Modellen.

Führen Sie die folgenden Schritte aus, um ein Modell aus einer Ausführung zu registrieren und anzuzeigen:

  1. Wenn eine Ausführung beendet ist, rufen Sie die register_model()-Methode auf.

    # the model folder produced from a run is registered. This includes the MLmodel file, model.pkl and the conda.yaml.
    model_path = "model"
    model_uri = 'runs:/{}/{}'.format(run_id, model_path) 
    mlflow.register_model(model_uri,"registered_model_name")
    
  2. Zeigen Sie das registrierte Modell in Ihrem Arbeitsbereich in Azure Machine Learning Studio an.

    Im folgenden Beispiel sind die Metadaten für die MLflow-Nachverfolgung für das registrierte Modell my-model gekennzeichnet.

    register-mlflow-model

  3. Wählen Sie die Registerkarte Artefakte aus, um alle Modelldateien anzuzeigen, die mit dem MLflow-Modellschema („conda.yaml“, MLmodel, „model.pkl“) übereinstimmen.

    model-schema

  4. Wählen Sie „MLmodel“ aus, um die von der Ausführung generierte MLmodel-Datei anzuzeigen.

    MLmodel-schema

Bereinigen von Ressourcen

Beachten Sie Folgendes, falls Sie nicht planen, die protokollierten Metriken und Artefakte in Ihrem Arbeitsbereich zu verwenden: Das Löschen einzelner Einträge ist derzeit nicht möglich. Löschen Sie stattdessen die Ressourcengruppe, die das Speicherkonto und den Arbeitsbereich enthält, damit hierfür keine Gebühren anfallen:

  1. Wählen Sie ganz links im Azure-Portal Ressourcengruppen aus.

    Delete in the Azure portal

  2. Wählen Sie in der Liste die Ressourcengruppe aus, die Sie erstellt haben.

  3. Wählen Sie die Option Ressourcengruppe löschen.

  4. Geben Sie den Ressourcengruppennamen ein. Wählen Sie anschließend die Option Löschen.

Beispielnotebooks

Die Notebooks „MLflow mit Azure ML“ demonstrieren und erklären die in diesem Artikel vorgestellten Konzepte. Weitere Informationen finden Sie auch unter dem von der Community gesteuerten Repository AzureML-Examples.

Nächste Schritte