Spårning och observerbarhet för experiment

AI Runtime integreras med MLflow för att erbjuda verktyg för experimentspårning, observabilitet och felsökning. MLflow erbjuder en enda plats för parametrarna för en körning, mätvärden, GPU-systemmetrik, loggar och artefakter, oavsett om du utvecklar i en anteckningsbok, skickar ett arbetsjobb med databricks air CLI eller schemalägger ett jobb.

Vad MLflow erbjuder

Ett MLflow-experiment grupperar relaterade träningskörningar, och varje körning ger en bestående registrering av träningskonfigurationen och resultaten.

• Mätvärden och parametrarna: Registrera träningsförluster, utvärderingsmått, inlärningshastigheter och hyperparametrar, och jämför dem sedan över körningar.
• Systemmetrik: Visa GPU-, CPU- och minnesanvändning för hanterade körningar under fliken Systemmetrik.
• Loggvisning: Visa drivrutdata för en arbetsbelastning som stöds av ett jobb på körningens flik Loggar. Se Visa loggar på fliken MLflow Logs.
• Artefakter och modeller: Lagra modellfiler, konfigurationer och andra utdata med körningen. Använd en Unity Catalog-volym för stora eller beständiga artefakter.
• Delning och samarbete: Ge tillgång till ett experiment så att andra användare av arbetsytan kan se och jämföra dess körningar. Se Ordna träningskörningar med MLflow-experiment.
• Ramverksintegrationer: Använd MLflow-integrationer med Hugging Face Transformers, PyTorch Lightning och andra stödda bibliotek.

För jobbunderstödda arbetsbelastningar, till exempel arbetsbelastningar som skickas in med databricks air run, kompletterar Azure Databricks-jobbkörningen MLflow genom att registrera exekveringsstatus, beräkningsresurser, försök och utdata från drivrutinen.

Hur MLflow-körningar skapas

Hur du startar eller ansluter dig till en MLflow-run beror på hur du startar arbetsbelastningen:

Hur du hanterar arbetsbelastningen	Hur MLflow-körningen startar	Hur man väljer experimentet
Databricks CLI (databricks air run)	Varje försök skapar automatiskt en körning.	Ställ in experiment_name i workload-YAML-filen.
Notebook med Databricks AI Runtime SDK (.distributed())	Varje anrop skapar automatiskt ett körningstillfälle.	Ring mlflow.set_experiment() före .distributed(), eller ställ MLFLOW_EXPERIMENT_NAMEin .
Kod körs direkt i en ansluten anteckningsbok	Ingen körning skapas automatiskt. Använd mlflow.start_run() eller autologging.	Anropa mlflow.set_experiment() i Notebook.
Schemalagt ai_runtime_task	Uppgiften skapar automatiskt en körning.	Ställ experiment in i uppgiftskonfigurationen. Se AI Runtime-uppgiften.

När din kod startar eller ansluter till rätt körning, använd MLflow-spårnings-API:et för att registrera anpassad träningsdata. För stödda ramverk kan du använda autologging istället för att lägga till individuella loggningsanrop. För djupinlärningsmönster, se MLflow 3 djupinlärningsarbetsflöde.

Använd följande metoder när du konfigurerar MLflow-spårning:

• Sätt step till ett meningsfullt värde, såsom den globala batchen eller epoken. Logga med jämna mellanrum istället för varje batch. MLflow begränsar antalet mätvärdessteg per körning. Se Resursbegränsningar.
• För distribuerad träning, logga en metrik från rank 0 endast så att varje värde registreras en gång.
• För notebook-arbetsflöden, använd absoluta experimentvägar, såsom /Users/<username>/my-experiment eller /Workspace/Shared/<team>/my-experiment. Lägg experiment som du vill dela i en delad arbetsytemapp.
• Lagra stora, hållbara checkpoints i en Unity Catalog-volym. För checkpointmönster, se Förbättra träningsprestanda och resiliens på AI Runtime.

Note

Använd MLflow 3.7 och uppåt för exemplen på denna sida.

Spåra Databricks CLI-arbetsbelastningar

När du skickar in en arbetsbelastning med databricks air run, skapar AI Runtime en Azure Databricks-jobbkörning för exekveringsdetaljer och en MLflow-körning för experimentdata. Den ursprungliga inskickningen och dess omförsök delar en jobbkörning, medan varje försök skapar en separat MLflow-körning i samma experiment så att du kan jämföra försöken.

GPU-, CPU- och minnessystemmetriker fångas automatiskt för varje hanterad körning och visas på fliken System metrics i MLflow.

Konfigurera och logga till körningen

Använd workload-YAML-filen för att välja experimentet och eventuellt konfigurera körnamnet och artefaktplatsen. Följande exempel visar vilka MLflow-fält som behövs:

experiment_name: my-training
mlflow_run_name: baseline-lr3e5
mlflow_artifact_location: /Volumes/main/default/mlflow-artifacts/my-training

För fältkrav, standardvärden och stödda värden, se Workload YAML-referensen.

AI Runtime tillgängliggör managed run ID genom MLFLOW_RUN_ID. För att logga dina egna parametrar, mätvärden och artefakter till den körningen, öppna den igen med MLflow-spårnings-API:et:

import os

import mlflow

# Log from rank 0 only because all nodes share the same MLFLOW_RUN_ID.
if os.environ.get("RANK", "0") == "0":
    with mlflow.start_run(run_id=os.environ["MLFLOW_RUN_ID"]):
        mlflow.log_param("learning_rate", 3e-4)
        for step, loss in enumerate(training_losses):
            mlflow.log_metric("train_loss", loss, step=step)

Hitta körningar och loggar

Loggar finns tillgängliga både via Databricks CLI och MLflow-körningssidan. Använd följande kommandon för att hitta arbetsbelastningar, inspektera en arbetsbelastning och strömma eller ladda ner loggar:

databricks air list --all-status
databricks air get <job-run-id>
databricks air logs <job-run-id>
databricks air logs <job-run-id> --node 2
databricks air logs <job-run-id> --download-to ./logs/

Spåra arbetsbelastningar för notebook-datorer

Från en anteckningsbok kan du köra kod direkt i den bifogade sessionen eller köra distribuerad träning via decoratorn @distributed från Databricks AI Runtime SDK.

Kör kod direkt i en anteckningsbok

Kod som körs direkt i en ansluten anteckningsbok skapar inte automatiskt en MLflow-körning. Välj ett experiment, starta sedan en körning eller aktivera autologgning:

import mlflow

mlflow.set_experiment("/Users/<username>/my-experiment")

with mlflow.start_run(run_name="baseline"):
    train()

För att aktivera PyTorch Lightning-autologgning, använd följande mönster:

mlflow.pytorch.autolog()

with mlflow.start_run(run_name="lightning-baseline"):
    trainer.fit(model, datamodule=datamodule)

För Hugging Face Transformers, konfigurera TrainingArguments enligt följande:

from transformers import TrainingArguments

args = TrainingArguments(
    output_dir="/Volumes/<catalog>/<schema>/<volume>/checkpoints",
    report_to="mlflow",
    run_name="llama7b-sft-lr3e5",
    logging_steps=50,
)

Använd Databricks AI Runtime SDK

För distribuerad träning från en anteckningsbok, använd decoratorn @distributed från Databricks AI Runtime SDK (databricks-sdk-air). SDK:n finns tillgänglig under databricks.air namnrymden i GPU-miljö version 6 och uppåt, eller som serverless_gpu i GPU-miljö version 5 och lägre.

from databricks.air import distributed

@distributed()
def train():
    # Training code
    ...

train.distributed()

Varje .distributed() anrop skapar automatiskt en MLflow-körning. Standardexperimentet är /Users/{WORKSPACE_USER}/{notebook-name}. För att välja ett annat experiment, ställ in det innan du anropar .distributed():

mlflow.set_experiment("/Users/<username>/my-experiment")
train.distributed()

När du anropar .distributed() i en aktiv körning skapar AI Runtime en nästlad barnkörning:

with mlflow.start_run() as parent_run:
    train.distributed()

För att återuppta en tidigare körning, sätt MLFLOW_RUN_ID före .distributed():

import os

os.environ["MLFLOW_RUN_ID"] = "<previous-run-id>"
train.distributed()

Använd körlänken i cellutdata eller i anteckningsbokens Experiment-panel för att öppna MLflow-körningen.

Visa loggar

• Anteckningsboksutdata: Standardutdata och fel från träningskoden visas i anteckningsboksens cellutdata.
• MLflow-loggar: För jobbstödda notebook-arbetsbelastningar såsom anrop med .distributed(remote=True) visar fliken MLflow Loggar utdata från den tillhörande jobbkörningen.

Övervaka GPU-resurser i realtid

Notebookens GPU-resurspanel visar GPU-användning i realtid, minne och temperatur för arbetsbelastningar med en och flera noder. Använd fliken MLflow System-metrics när du behöver en persistent post kopplad till en körning.

För att öppna panelen, koppla notebooken till AI Runtime och klicka sedan på GPU-resurser i den högra sidopanelen.

Panelen hämtar mätvärden var tionde sekund och sparar upp till två timmars historik. Klicka Uppdatera för att hämta de senaste värdena. Efter fem minuters inaktivitet pausar rutan. Öppna den igen för att återuppta övervakningen.

Visa loggar i fliken MLflow Loggar

Fliken Loggar på en MLflow-körsida visar utdata från en AI Runtime-arbetsbelastning som stöds av ett jobb. För att öppna den, gå till sidan Körning och klicka på Loggar.

För nya körningar ersätter fliken Loggar de loggfiler som tidigare lagrats på körningens flik Artefakter, vilka är föråldrade. Körningar som skapats tidigare sparar sina loggfiler på fliken Artifacts .

Från fliken Loggar kan du:

• Sök: Visa endast raderna som innehåller en sökterm.
• Filtrera efter nod, nivå och tidsintervall: Välj en enskild nod i en arbetsbelastning med flera noder, visa endast information, varning eller fellinjer, eller begränsa vyn till ett tidsintervall.
• Följ en pågående arbetslast: Medan körningen är aktiv dyker ny utdata upp när den anländer. Scrolla upp för att pausa följning.
• Kopiera och ladda ner: Kopiera de laddade raderna, eller ladda ner varje rad som matchar de aktuella filtren.

Lagringstid för loggar

Loggar finns tillgängliga under fliken Loggar i 60 dagar.

Felsök åtkomst till loggar

Fliken Logs på en MLflow-körsida visar utdata från den tillhörande Azure Databricks-jobbkörningen. Tillgång till MLflow-experimentet innebär inte tillgång till jobbet.

Om fliken visar att du inte har tillgång till dessa loggar, be en användare med behörighet Kan hantera eller en administratör för arbetsområdet att åtminstone ge dig Kan visa för jobbet. Se Kontrollera åtkomst till ett jobb.

Globala gränser i Azure Databricks

Se Resursbegränsningar.