Hantera MLflow-modeller mellan arbetsytor och plattformar

Maskininlärning i produktion kräver mer än att träna en bra modell. Du behöver tillförlitliga arbetsflöden för att flytta modeller från utveckling till produktion. Loggning mellan arbetsytor i Microsoft Fabric möjliggör två viktiga scenarier:

Skapa MLOps-arbetsflöden från slutpunkt till slutpunkt. Träna och experimentera på en utvecklingsarbetsyta, validera på en testarbetsyta och distribuera till en arbetsyta som betjänar produktion med hjälp av standard-MLflow-API:er. Den här uppdelningen av miljöer hjälper teamen att införa kvalitetsgrindar och underhålla tydliga revisionsspår från experiment till produktion.
Bringa befintliga maskininlärningstillgångar till Fabric. Om du redan har tränat modeller i Azure Databricks, Azure Machine Learning, en lokal miljö eller någon annan plattform som stöder MLflow kan du logga dessa experiment och modeller direkt till en Fabric arbetsyta. Du kan enkelt konsolidera dina maskininlärningsartefakter på ett ställe utan att återskapa dina träningspipelines.

Loggning mellan arbetsytor fungerar via paketet synapseml-mlflow, som tillhandahåller ett Fabric-kompatibelt MLflow-spårningstillägg. Du autentiserar med målarbetsytan, anger spårnings-URI:n och använder MLflow-standardkommandon.

Anmärkning

Loggning mellan arbetsytor fokuserar på kodfokuserad upplevelse. Användargränssnittsintegrering för scenarier mellan arbetsytor kommer att behandlas i en framtida version.

Förutsättningar

En Microsoft Fabric-prenumeration eller en kostnadsfri utvärderingsversion Microsoft Fabric.
Skrivbehörighet på målarbetsytan Fabric.
Ett system för maskininlärningsspårning som uppgraderas för både käll- och målarbetsytor.

För Fabric notebook-scenarier skapar du en ny notebook-fil och bifogar ett lakehouse innan du kör någon kod.

Tips/Råd

Loggning mellan arbetsytor stöds i arbetsytor med utgående åtkomstskydd aktiverat. Loggning mellan arbetsytor till en annan arbetsyta kräver en hanterad privat slutpunkt. Loggning på samma arbetsyta och utifrån Fabric fungerar utan ytterligare konfiguration.

Installera MLflow-plugin-programmet

Paketet synapseml-mlflow möjliggör loggning mellan arbetsytor genom att tillhandahålla Fabric plugin-program för MLflow-spårning. Välj installationskommandot baserat på din miljö.

Viktigt!

MLflow 3 stöds inte för närvarande. Du måste fästa mlflow-skinny till version 2.22.2 eller tidigare.

Textilanteckningsbok
Outside Fabric arbetsyta

För en Fabric-notebook använder du det här kommandot för att installera paketet med online-notebook-beroenden.

%pip install -U "synapseml-mlflow[online-notebook]" "mlflow-skinny<=2.22.2"

Använd det här kommandot i alla miljöer utanför Fabric, till exempel en lokal dator (Visual Studio Code, Jupyter), Azure Databricks, Azure Machine Learning eller någon annan plattform som stöder Python och MLflow:

pip install -U "synapseml-mlflow" "mlflow-skinny<=2.22.2"

Starta om kerneln efter installationen innan du kör den återstående koden.

Logga MLflow-objekt till en annan Fabric arbetsyta

I det här scenariot kör du en notebook-fil i en Fabric-arbetsyta (källa) och loggar experiment och modeller i en annan Fabric-arbetsyta (mål).

Ange målarbetsytan

Peka på målarbetsytan genom att ange MLFLOW_TRACKING_URI miljövariabeln:

import os

target_workspace_id = "<your-target-workspace-id>"
target_uri = f"sds://api.fabric.microsoft.com/v1/workspaces/{target_workspace_id}/mlflow"
os.environ["MLFLOW_TRACKING_URI"] = target_uri

Loggexperiment och modeller

Skapa ett experiment och logga en körning med parametrar, mått och en modell:

import mlflow
import mlflow.sklearn
import numpy as np
from sklearn.linear_model import LogisticRegression
from mlflow.models.signature import infer_signature

# Create or set the experiment in the target workspace
EXP_NAME = "my-cross-workspace-experiment"
MODEL_NAME = "my-cross-workspace-model"
mlflow.set_experiment(EXP_NAME)

with mlflow.start_run() as run:
    lr = LogisticRegression()
    X = np.array([-2, -1, 0, 1, 2, 1]).reshape(-1, 1)
    y = np.array([0, 0, 1, 1, 1, 0])
    lr.fit(X, y)

    score = lr.score(X, y)
    signature = infer_signature(X, y)

    mlflow.log_params({
        "objective": "classification",
        "learning_rate": 0.05,
    })
    mlflow.log_metric("score", score)

    mlflow.sklearn.log_model(lr, "model", signature=signature)

    mlflow.register_model(
        f"runs:/{run.info.run_id}/model",
        MODEL_NAME
    )

När körningen är klar visas experimentet och den registrerade modellen på målarbetsytan.

Flytta MLflow-objekt mellan Fabric arbetsytor

I det här scenariot loggar du först objekt i källarbetsytan och laddar sedan ned artefakterna och loggar dem igen till målarbetsytan. Den här metoden är användbar när du behöver höja upp en tränad modell från en utvecklingsarbetsyta till en produktionsarbetsyta.

Steg 1: Logga objekt på källarbetsytan

import mlflow
import mlflow.sklearn
import numpy as np
from sklearn.linear_model import LogisticRegression
from mlflow.models.signature import infer_signature

# Log to the current (source) workspace
EXP_NAME = "source-experiment"
mlflow.set_experiment(EXP_NAME)

with mlflow.start_run() as run:
    lr = LogisticRegression()
    X = np.array([-2, -1, 0, 1, 2, 1]).reshape(-1, 1)
    y = np.array([0, 0, 1, 1, 1, 0])
    lr.fit(X, y)

    signature = infer_signature(X, y)
    mlflow.sklearn.log_model(lr, "model", signature=signature)

    source_run_id = run.info.run_id

Steg 2: Ladda ned artefakter från källaexekveringen

import mlflow.artifacts

# Download the model artifacts locally
local_artifact_path = mlflow.artifacts.download_artifacts(
    run_id=source_run_id,
    artifact_path="model"
)

Steg 3: Logga om artefakter till målarbetsytan

import os

target_workspace_id = "<your-target-workspace-id>"
target_uri = f"sds://api.fabric.microsoft.com/v1/workspaces/{target_workspace_id}/mlflow"
os.environ["MLFLOW_TRACKING_URI"] = target_uri

TARGET_EXP_NAME = "promoted-experiment"
TARGET_MODEL_NAME = "promoted-model"
mlflow.set_experiment(TARGET_EXP_NAME)

with mlflow.start_run() as run:
    mlflow.log_artifacts(local_artifact_path, "model")
    mlflow.register_model(
        f"runs:/{run.info.run_id}/model",
        TARGET_MODEL_NAME
    )

Logga MLflow-objekt utifrån Fabric

Du kan logga MLflow-experiment och modeller till en Fabric arbetsyta från valfri miljö där du skapar dina modeller, inklusive:

Lokala datorer. VS Code, Jupyter Notebooks eller någon lokal Python miljö.
Azure Databricks. Azure Databricks anteckningsböcker och arbetsuppgifter.
Azure Machine Learning. Azure Machine Learning beräkningsinstanser och pipelines.
Alla andra plattformar. Alla miljöer som stöder Python och MLflow.

Steg 1: Installera paketet

synapseml-mlflow Installera paketet i din miljö:

pip install -U "synapseml-mlflow" "mlflow-skinny<=2.22.2"

Steg 2: Autentisera med Fabric

Välj en autentiseringsmetod baserat på din miljö:

Använd den här metoden för lokala utvecklingsmiljöer med webbläsaråtkomst, till exempel VS Code eller Jupyter.

from fabric.analytics.environment.credentials import SetFabricAnalyticsDefaultTokenCredentialsGlobally
from azure.identity import DefaultAzureCredential

SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=DefaultAzureCredential(exclude_interactive_browser_credential=False)
)

Använd den här metoden för miljöer utan webbläsare, till exempel Azure Databricks notebook-filer eller fjärrservrar. Följ anvisningarna på skärmen för att slutföra autentiseringen.

from fabric.analytics.environment.credentials import SetFabricAnalyticsDefaultTokenCredentialsGlobally
from azure.identity import DeviceCodeCredential

device_code_credential = DeviceCodeCredential()
SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=device_code_credential
)

Använd den här metoden för icke-interaktiva scenarier som automatiserade pipelines, kontinuerlig integrering och kontinuerlig leverans (CI/CD) eller produktionsarbetsbelastningar.

I Microsoft Entra ID skapa en appregistrering.
Observera värdena för hyrande-ID och klient-ID. Skapa en klienthemlighet.

Bevilja skrivbehörighet till tjänsteprincicalen på Fabric-arbetsytan.

from fabric.analytics.environment.credentials import SetFabricAnalyticsDefaultTokenCredentialsGlobally
from azure.identity import ClientSecretCredential

spn_credential = ClientSecretCredential(
    tenant_id="<your-tenant-id>",
    client_id="<your-client-id>",
    client_secret="<your-client-secret>"
)

SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=spn_credential
)

Steg 3: Ange målarbetsytan och logga MLflow-objekt

Efter autentiseringen anger du spårnings-URI:n så att den pekar på ditt målarbetsområde, och logga experiment och modeller med hjälp av standard-MLflow-API:er.

import os
import mlflow
import mlflow.sklearn
import numpy as np
from sklearn.linear_model import LogisticRegression
from mlflow.models.signature import infer_signature

target_workspace_id = "<your-target-workspace-id>"
target_uri = f"sds://api.fabric.microsoft.com/v1/workspaces/{target_workspace_id}/mlflow"
os.environ["MLFLOW_TRACKING_URI"] = target_uri

EXP_NAME = "external-experiment"
MODEL_NAME = "external-model"
mlflow.set_experiment(EXP_NAME)

with mlflow.start_run() as run:
    lr = LogisticRegression()
    X = np.array([-2, -1, 0, 1, 2, 1]).reshape(-1, 1)
    y = np.array([0, 0, 1, 1, 1, 0])
    lr.fit(X, y)

    signature = infer_signature(X, y)
    mlflow.log_metric("score", lr.score(X, y))
    mlflow.sklearn.log_model(lr, "model", signature=signature)

    mlflow.register_model(
        f"runs:/{run.info.run_id}/model",
        MODEL_NAME
    )

Använda loggning mellan arbetsytor med utgående åtkomstskydd

Om din arbetsyta har aktiverat utgående åtkomstskydd kräver loggning mellan arbetsytor en hanterad privat slutpunkt mellan arbetsytor från källarbetsytan till målarbetsytan.

Loggning på samma arbetsyta och loggning utifrån Fabric (lokala datorer, Azure Databricks, Azure Machine Learning) fungerar utan ytterligare konfiguration.

Mer information om scenarier som stöds och nödvändig konfiguration finns i Arbetsytans utgående åtkomstskydd för Fabric Data Science.

Installera paketet på en OAP-aktiverad arbetsyta

Standardkommandot %pip install kräver utgående Internetåtkomst, som blockeras i arbetsytor med OAP (outbound access protection) aktiverat. Om du vill installera synapseml-mlflow paketet laddar du först ned det från en icke-OAP-miljö och laddar sedan upp det till lakehouse.

synapseml-mlflow Ladda ned paketet från en dator som har internetåtkomst.
```
pip download synapseml-mlflow[online-notebook]
```
Ladda upp de nedladdade filerna till lakehouse på din OAP-aktiverade arbetsyta. Ladda upp alla .whl filer till avsnittet Filer i lakehouse (till exempel /lakehouse/default/Files).

Installera från lakehouse-sökvägen i din Fabric notebook:

%pip install --no-index --find-links=/lakehouse/default/Files "synapseml-mlflow[online-notebook]>2.0.0" "mlflow-skinny<=2.22.2" --pre

Ange spårnings-URI:n så att den hanterade privata slutpunkten används. Om den aktuella arbetsytan har OAP aktiverat måste du konfigurera en hanterad privat slutpunkt för flera arbetsytor från källarbetsytan till målarbetsytan. Dirigera sedan spårnings-URI:n via den privata slutpunkten.

import os
from fabric.analytics.environment.context import FabricContext, InternalContext

context = FabricContext(workspace_id=target_workspace_id, internal_context=InternalContext(is_wspl_enabled=True))
print(context.pbi_shared_host)
# You need to set up and use this private endpoint if your current workspace has OAP enabled

os.environ["MLFLOW_TRACKING_URI"] = f"sds://{context.pbi_shared_host}/v1/workspaces/{target_workspace_id}/mlflow"

Kända begränsningar

Skrivbehörighet krävs. Du måste ha skrivbehörighet på målarbetsytan.
Arbetsyta-härledning stöds inte. Du kan inte visa relationer mellan notebook-filer, experiment och modeller när dessa objekt loggas från olika arbetsytor.
Källanteckningsboken visas inte på målarbetsytan. Källanteckningsboken visas inte på målarbetsytan. På artefaktinformation och listsidor är länken till källanteckningsboken tom.
Objektögonblicksbilder stöds inte. Maskininlärningsexperiment eller modeller som loggas till en annan arbetsyta visas inte i ögonblicksbilden av det källdrivna notebook-objektet.
Stora språkmodeller stöds inte. Loggning mellan arbetsytor stöder inte stora språkmodeller (LLM).

Feedback

Var den här sidan till hjälp?

Last updated on 2026-05-01