Spåra ML-modeller med MLflow och Azure Machine Learning

GÄLLER FÖR:Azure Machine Learning SDK v1 för Python

I den här artikeln får du lära dig hur du aktiverar MLflow Tracking för att ansluta Azure Machine Learning som serverdel för dina MLflow-experiment.

MLflow är ett bibliotek med öppen källkod för att hantera livscykeln för dina maskininlärningsexperiment. MLflow Tracking är en komponent i MLflow som loggar och spårar dina träningskörningsmått och modellartefakter, oavsett experimentets miljö – lokalt på datorn, på ett fjärrberäkningsmål, en virtuell dator eller ett Azure Databricks-kluster.

Se MLflow och Azure Machine Learning för alla MLflow- och Azure Machine Learning-funktioner som stöds, inklusive stöd för MLflow-projekt (förhandsversion) och modelldistribution.

Förutsättningar

• Installera paketet mlflow.

  • Du kan använda MLflow Skinny som är ett enkelt MLflow-paket utan SQL-lagring, server, användargränssnitt eller datavetenskapsberoenden. Detta rekommenderas för användare som främst behöver spårnings- och loggningsfunktionerna utan att importera hela paketet med MLflow-funktioner, inklusive distributioner.

• Installera paketet azureml-mlflow.

• Skapa en Azure Machine Learning-arbetsyta.

  • Se vilka åtkomstbehörigheter du behöver för att utföra dina MLflow-åtgärder med din arbetsyta.

• Installera och konfigurera Azure Machine Learning CLI (v1) och se till att du installerar ML-tillägget.

  Viktigt!

  Viktigt!

  Några av Azure CLI-kommandona i den här artikeln använder azure-cli-mltillägget , eller v1, för Azure Machine Learning. Stödet för CLI v1 upphörde den 30 september 2025. Microsoft tillhandahåller inte längre teknisk support eller uppdateringar för den här tjänsten. Dina befintliga arbetsflöden med CLI v1 fortsätter att fungera efter supportdatumet. De kan dock utsättas för säkerhetsrisker eller förändringar som bryter kompatibiliteten vid arkitektoniska förändringar i produkten.

  Vi rekommenderar att du övergår till mltillägget , eller v2, så snart som möjligt. Mer information om v2-tillägget finns i Azure Machine Learning CLI-tillägget och Python SDK v2.

• Installera och konfigurera Azure Machine Learning SDK för Python.

Spåra körningar från din lokala dator eller fjärrberäkning

Genom att använda MLflow med Azure Machine Learning kan du lagra metrikvärden och artefakter från körningar som utfördes på din lokala maskin i din Azure Machine Learning-arbetsyta.

Konfigurera spårningsmiljö

Om du vill spåra en körning som inte körs på Azure Machine Learning-beräkning (från och med nu kallas "lokal beräkning") måste du peka din lokala beräkning till Azure Machine Learning MLflow Tracking URI.

export MLFLOW_TRACKING_URI=$(az ml workspace show --query mlflow_tracking_uri | sed 's/"//g') 

import mlflow

region = ""
subscription_id = ""
resource_group = ""
workspace_name = ""

azureml_mlflow_uri = f"azureml://{region}.api.azureml.ms/mlflow/v1.0/subscriptions/{subscription_id}/resourceGroups/{resource_group}/providers/Microsoft.MachineLearningServices/workspaces/{workspace_name}"
mlflow.set_tracking_uri(azureml_mlflow_uri)

Ange experimentnamn

Alla MLflow-körningar loggas till det aktiva experimentet. Som standard loggas körningar till ett experiment med namnet Default som skapas automatiskt åt dig. För att konfigurera experimentet som du vill arbeta med använder du MLflow-kommandot mlflow.set_experiment().

experiment_name = 'experiment_with_mlflow'
mlflow.set_experiment(experiment_name)

Starta träningssession

När du har angett MLflow-experimentnamnet kan du starta träningskörningen med start_run(). Använd log_metric() sedan för att aktivera MLflow-loggnings-API:et och börja logga dina träningskörningsmått.

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

Mer information om hur du loggar mått, parametrar och artefakter i en körning med MLflow-vyn Så här loggar och visar du mått.

Spåra körningar som körs i Azure Machine Learning

GÄLLER FÖR:Azure Machine Learning SDK v1 för Python

Med fjärrkörningar (jobb) kan du träna dina modeller på ett mer robust och repetitivt sätt. De kan också använda mer kraftfulla beräkningar, till exempel Machine Learning Compute-kluster. Mer information om olika beräkningsalternativ finns i Använda beräkningsmål för modellträning .

När du skickar körningar konfigurerar Azure Machine Learning automatiskt MLflow så att det fungerar med den arbetsyta som körningen körs i. Det innebär att du inte behöver konfigurera URI:n för MLflow-spårning. Dessutom namnges experiment automatiskt baserat på information om experimentöverföringen.

Skapa en träningsrutin

Först bör du skapa en src underkatalog och skapa en fil med träningskoden i en train.py fil i underkatalogen src . All träningskod kommer att gå till underkatalogen src , inklusive train.py.

Träningskoden hämtas från det här MLflow-exemplet i Azure Machine Learning-exempellagringsplatsen.

Kopiera den här koden till filen:

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

Konfigurera experimentet

Du måste använda Python för att skicka experimentet till Azure Machine Learning. Konfigurera din beräknings- och träningskörningsmiljö med Environment klassen i en notebook- eller Python-fil.

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

ScriptRunConfig Skapa sedan med fjärrberäkningen som beräkningsmål.

from azureml.core import ScriptRunConfig

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

Med den här konfigurationen för beräknings- och träningskörningar, använd Experiment.submit()-metoden för att skicka in en körning. Den här metoden anger automatiskt MLflow-spårnings-URI:n och dirigerar loggningen från MLflow till din arbetsyta.

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)

Visa mått och artefakter på din arbetsyta

Mätvärden och artefakter från loggar från MLflow spåras på din arbetsyta. Om du vill visa dem när som helst navigerar du till din arbetsyta och hittar experimentet efter namn på din arbetsyta i Azure Machine Learning-studio. Eller kör koden nedan.

Hämta resultatmått med MLflow get_run().

from mlflow.tracking import MlflowClient

# Use MlFlow to retrieve the run that was just completed
client = MlflowClient()
run_id = mlflow_run.info.run_id
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)

För att visa artefakter från en körning kan du använda MlFlowClient.list_artifacts()

client.list_artifacts(run_id)

Om du vill ladda ned en artefakt till den aktuella katalogen kan du använda MLFlowClient.download_artifacts()

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

Mer information om hur du hämtar information från experiment och körningar i Azure Machine Learning genom MLflow-vyn Hantera experiment och körningar med MLflow.

Jämför och fråga

Jämför och fråga efter alla MLflow-körningar på din Azure Machine Learning-arbetsyta med följande kod. Läs mer om hur man frågar efter körningar med 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)

Automatisk loggning

Med Azure Machine Learning och MLFlow kan användarna logga mått, modellparametrar och modellartefakter automatiskt när de tränar en modell. En mängd populära maskininlärningsbibliotek stöds.

Om du vill aktivera automatisk loggning infogar du följande kod före träningskoden:

mlflow.autolog()

Läs mer om automatisk loggning med MLflow.

Hantera modeller

Registrera och spåra dina modeller med Azure Machine Learning-modellregistret, som stöder MLflow-modellregistret. Azure Machine Learning-modeller är anpassade till MLflow-modellschemat, vilket gör det enkelt att exportera och importera dessa modeller i olika arbetsflöden. MLflow-relaterade metadata, till exempel körnings-ID, spåras också med den registrerade modellen för spårbarhet. Användare kan skicka träningskörningar, registrera och distribuera modeller som skapats från MLflow-körningar.

Om du vill distribuera och registrera din produktionsklara modell i ett steg kan du läsa Distribuera och registrera MLflow-modeller.

Om du vill registrera och visa en modell från en körning använder du följande steg:

1. När en körning är klar anropar du register_model() metoden.

   # 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. Visa den registrerade modellen på din arbetsyta med Azure Machine Learning-studio.

   I följande exempel har den registrerade modellen my-model MLflow-spårningsmetadata taggade.

   

3. Välj fliken Artefakter för att se alla modellfiler som överensstämmer med MLflow-modellschemat (conda.yaml, MLmodel, model.pkl).

   

4. Välj MLmodel för att se MLmodel-filen som genereras av körningen.

   

Rensa resurser

Om du inte planerar att använda de loggade måtten och artefakterna på din arbetsyta är möjligheten att ta bort dem individuellt för närvarande inte tillgänglig. Ta i stället bort resursgruppen som innehåller lagringskontot och arbetsytan, så att du inte debiteras några avgifter:

1. I Azure-portalen väljer du Resursgrupper längst till vänster.

   

2. Välj den resursgrupp i listan som du har skapat.

3. Välj Ta bort resursgrupp.

4. Ange resursgruppsnamnet. Välj sedan ta bort.

Exempelnotebookar

MLflow med Azure Machine Learning-anteckningsböcker demonstrerar och fördjupar begrepp som presenteras i den här artikeln. Se även den communitydrivna lagringsplatsen AzureML-Examples.

Nästa steg

• Distribuera modeller med MLflow.
• Övervaka dina produktionsmodeller för dataavvikelse.
• Spåra Azure Databricks-körningar med MLflow.
• Hantera dina modeller.