Spåra ML-experiment och modeller med MLflow

I den här artikeln får du lära dig hur du använder MLflow för att spåra dina experiment och körs på Azure Machine Learning-arbetsytor.

Spårning är processen för att spara relevant information om experiment som du kör. Den sparade informationen (metadata) varierar beroende på ditt projekt och kan innehålla:

• Kod
• Miljöinformation (till exempel OS-version, Python-paket)
• Indata
• Parameterkonfigurationer
• Modeller
• Utvärderingsmått
• Utvärderingsvisualiseringar (till exempel förvirringsmatriser, prioritetsritningar)
• Utvärderingsresultat (inklusive några utvärderingsförutsägelser)

När du arbetar med jobb i Azure Machine Learning spårar Azure Machine Learning automatiskt viss information om dina experiment, till exempel kod, miljö och indata och utdata. Men för andra som modeller, parametrar och mått måste modellbyggaren konfigurera spårningen, eftersom de är specifika för det specifika scenariot.

Kommentar

Om du vill spåra experiment som körs på Azure Databricks kan du läsa Spåra Azure Databricks ML-experiment med MLflow och Azure Machine Learning. Mer information om hur du spårar experiment som körs i Azure Synapse Analytics finns i Spåra ML-experiment för Azure Synapse Analytics med MLflow och Azure Machine Learning.

Fördelar med spårningsexperiment

Vi rekommenderar starkt att maskininlärningsutövare spårar experiment, oavsett om du tränar med jobb i Azure Machine Learning eller tränar interaktivt i notebook-filer. Med experimentspårning kan du:

• Organisera alla dina maskininlärningsexperiment på en enda plats. Du kan sedan söka efter och filtrera experiment och öka detaljnivån för att se information om experimenten som du körde tidigare.
• Jämför experiment, analysera resultat och felsöka modellträning med lite extra arbete.
• Återskapa eller köra experiment igen för att verifiera resultaten.
• Förbättra samarbetet eftersom du kan se vad andra teammedlemmar gör, dela experimentresultat och komma åt experimentdata programmatiskt.

Varför ska du använda MLflow för att spåra experiment?

Azure Machine Learning-arbetsytor är MLflow-kompatibla, vilket innebär att du kan använda MLflow för att spåra körningar, mått, parametrar och artefakter i dina Azure Machine Learning-arbetsytor. En stor fördel med att använda MLflow för spårning är att du inte behöver ändra dina träningsrutiner för att arbeta med Azure Machine Learning eller mata in någon molnspecifik syntax.

Mer information om alla MLflow- och Azure Machine Learning-funktioner som stöds finns i MLflow och Azure Machine Learning.

Begränsningar

Vissa metoder som är tillgängliga i MLflow-API:et kanske inte är tillgängliga när de är anslutna till Azure Machine Learning. Mer information om åtgärder som stöds och som inte stöds finns i Supportmatris för frågekörningar och experiment.

Förutsättningar

• En Azure-prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar. Prova den kostnadsfria eller betalda versionen av Azure Machine Learning.

• Installera MLflow SDK-paketet mlflow och Azure Machine Learning-plugin-programmet för MLflow azureml-mlflow.

  pip install mlflow azureml-mlflow
  

  Dricks

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

• En Azure Machine Learning-arbetsyta. Du kan skapa en genom att följa självstudien Skapa maskininlärningsresurser.

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

• Om du utför fjärrspårning (d.v.s. spårningsexperiment som körs utanför Azure Machine Learning) konfigurerar du MLflow så att det pekar på spårnings-URI:n för din Azure Machine Learning-arbetsyta. Mer information om hur du ansluter MLflow till din arbetsyta finns i Konfigurera MLflow för Azure Machine Learning.

Konfigurera experimentet

MLflow organiserar information i experiment och körningar (körningar kallas jobb i Azure Machine Learning). Som standard loggas körningar till ett experiment med namnet Standard som skapas automatiskt åt dig. Du kan konfigurera experimentet där spårning sker.

Arbeta interaktivt

För interaktiv träning, till exempel i en Jupyter-anteckningsbok, använder du MLflow-kommandot mlflow.set_experiment(). Följande kodfragment konfigurerar till exempel ett experiment:

experiment_name = 'hello-world-example'
mlflow.set_experiment(experiment_name)

Arbeta med jobb

Om du vill skicka jobb anger du experimentnamnet med hjälp experiment_name av egenskapen för jobbet när du använder Azure Machine Learning CLI eller SDK. Du behöver inte konfigurera det i träningsskriptet.

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: library/python:latest
tags:
  hello: world
display_name: hello-world-example
experiment_name: hello-world-example
description: |

Konfigurera körningen

Azure Machine Learning spårar alla träningsjobb i vad MLflow anropar en körning. Använd körningar för att samla in all bearbetning som jobbet utför.

Arbeta interaktivt

När du arbetar interaktivt börjar MLflow spåra din träningsrutin så snart du försöker logga information som kräver en aktiv körning. Till exempel startar MLflow-spårning när du loggar ett mått, en parameter eller startar en träningscykel och Mlflows autologgningsfunktion är aktiverad. Det är dock vanligtvis bra att starta körningen explicit, särskilt om du vill samla in den totala tiden för experimentet i fältet Varaktighet . Om du vill starta körningen explicit använder du mlflow.start_run().

Oavsett om du startar körningen manuellt eller inte måste du stoppa körningen så att MLflow vet att experimentkörningen är klar och kan markera körningens status som Slutförd. Om du vill stoppa en körning använder du mlflow.end_run().

Vi rekommenderar starkt att du startar körningar manuellt, så att du inte glömmer att avsluta dem när du arbetar i notebook-filer.

• Starta en körning manuellt och avsluta den när du är klar med att arbeta i notebook-filen:

  mlflow.start_run()
  
  # Your code
  
  mlflow.end_run()
  

• Det är vanligtvis bra att använda context manager-paradigmet för att komma ihåg att avsluta körningen:

  with mlflow.start_run() as run:
      # Your code
  

• När du startar en ny körning med mlflow.start_run()kan det vara användbart att ange parametern run_name som senare översätts till namnet på körningen i Azure Machine Learning-användargränssnittet och hjälper dig att identifiera körningen snabbare:

  with mlflow.start_run(run_name="hello-world-example") as run:
      # Your code
  

Arbeta med jobb

Med Azure Machine Learning-jobb kan du skicka långvariga tränings- eller slutsatsdragningsrutiner som isolerade och reproducerbara körningar.

Skapa en träningsrutin

När du arbetar med jobb placerar du vanligtvis all träningslogik som filer i en mapp, till exempel src. En av dessa filer är en Python-fil med startpunkten för träningskoden. I följande exempel visas ett hello_world.py exempel:

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

Det föregående kodexemplet används mlflow.start_run() inte, men om det används återanvänder MLflow den aktuella aktiva körningen. Därför behöver du inte ta bort den rad som används mlflow.start_run() om du migrerar kod till Azure Machine Learning.

Lägga till spårning i din rutin

Använd MLflow SDK för att spåra mått, parametrar, artefakter eller modeller. Exempel på hur du loggar dessa finns i Logga mått, parametrar och filer med MLflow.

Kontrollera att jobbets miljö har MLflow installerat

Alla Azure Machine Learning-miljöer har redan MLflow installerat åt dig, så ingen åtgärd krävs om du använder en kuraterad miljö. Men om du vill använda en anpassad miljö:

1. Skapa en conda.yaml fil med de beroenden du behöver:

   channels:
   - conda-forge
   dependencies:
   - python=3.8.5
   - pip
   - pip:
     - mlflow
     - azureml-mlflow
     - fastparquet
     - cloudpickle==1.6.0
     - colorama==0.4.4
     - dask==2.30.0
   

2. Referera till miljön i det jobb du använder.

Konfigurera jobbets namn

Använd parametern display_name Azure Machine Learning-jobb för att konfigurera namnet på körningen.

1. Använd egenskapen display_name för att konfigurera jobbet.

   Azure CLI

   Om du vill skicka jobbet skapar du en YAML-fil med din jobbdefinition i en job.yml fil. Den här filen bör skapas utanför src katalogen.

   $schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
   command: echo "hello world"
   environment:
     image: library/python:latest
   tags:
     hello: world
   display_name: hello-world-example
   experiment_name: hello-world-example
   description: |
   

   Python SDK

   from azure.ai.ml import command, Environment
   
   command_job = command(
       code="src",
       command="echo "hello world",
       environment=Environment(image="library/python:latest"),
       compute="cpu-cluster",
       display_name="hello-world-example"
   )
   

2. Se till att du inte använder mlflow.start_run(run_name="") i din träningsrutin.

Skicka jobbet

1. Anslut först till Azure Machine Learning-arbetsytan där du ska arbeta.

   Azure CLI

   az account set --subscription <subscription>
   az configure --defaults workspace=<workspace> group=<resource-group> location=<location>
   

   Python SDK

   Arbetsytan är resursen på den översta nivån i Azure Machine Learning, och är en central plats där du kan arbeta med alla artefakter du skapar när du använder Azure Machine Learning. I det här avsnittet ansluter du till arbetsytan där du ska utföra distributionsuppgifter.

   1. Importera de bibliotek som krävs:

      from azure.ai.ml import MLClient
      from azure.identity import DefaultAzureCredential
      

   2. Konfigurera information om arbetsytan och få ett handtag till arbetsytan:

      subscription_id = "<subscription>"
      resource_group = "<resource-group>"
      workspace = "<workspace>"
      
      ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
      

2. Skicka jobbet

   Azure CLI

   Använd Azure Machine Learning CLI för att skicka ditt jobb. Jobb som använder MLflow och körs på Azure Machine Learning loggar automatiskt all spårningsinformation till arbetsytan. Öppna terminalen och använd följande kod för att skicka jobbet.

   az ml job create -f job.yml --web
   

   Python SDK

   Använd Python SDK för att skicka ditt jobb. Jobb som använder MLflow och körs på Azure Machine Learning loggar automatiskt all spårningsinformation till arbetsytan.

   returned_job = ml_client.jobs.create_or_update(command_job)
   returned_job.studio_url
   

3. Övervaka jobbets förlopp i Azure Machine Learning-studio.

Aktivera automatisk MLflow-loggning

Du kan logga mått, parametrar och filer med MLflow manuellt. Du kan dock också förlita dig på MLflows automatiska loggningsfunktion. Varje maskininlärningsramverk som stöds av MLflow bestämmer vad du ska spåra automatiskt åt dig.

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

mlflow.autolog()

Visa mått och artefakter på din arbetsyta

Mått och artefakter från MLflow-loggning spåras på din arbetsyta. Du kan visa och komma åt dem i studion när som helst eller komma åt dem programmässigt via MLflow SDK.

Så här visar du mått och artefakter i studion:

1. Gå till Azure Machine Learning-studio.

2. Gå till din arbetsyta.

3. Hitta experimentet efter namn på din arbetsyta.

4. Välj de loggade måtten för att återge diagram till höger. Du kan anpassa diagrammen genom att använda utjämning, ändra färg eller rita flera mått i en enda graf. Du kan också ändra storlek på och ordna om layouten som du vill.

5. När du har skapat önskad vy sparar du den för framtida användning och delar den med dina teammedlemmar med hjälp av en direktlänk.

   

Om du vill komma åt eller fråga efter mått, parametrar och artefakter programatiskt via MLflow SDK använder du mlflow.get_run().

import mlflow

run = mlflow.get_run("<RUN_ID>")

metrics = run.data.metrics
params = run.data.params
tags = run.data.tags

print(metrics, params, tags)

Dricks

För mått returnerar den föregående exempelkoden endast det sista värdet för ett visst mått. Om du vill hämta alla värden för ett visst mått använder du mlflow.get_metric_history metoden. Mer information om hur du hämtar värden för ett mått finns i Hämta params och mått från en körning.

Om du vill ladda ned artefakter som du har loggat, till exempel filer och modeller, använder du mlflow.artifacts.download_artifacts().

mlflow.artifacts.download_artifacts(run_id="<RUN_ID>", artifact_path="helloworld.txt")

Mer information om hur du hämtar eller jämför information från experiment och körs i Azure Machine Learning med hjälp av MLflow finns i Fråga och jämföra experiment och körningar med MLflow.

Relaterat innehåll

• Distribuera MLflow-modeller
• Hantera modeller med MLflow
• Använda MLflow (Jupyter Notebooks)