Zarządzanie modelami MLflow w obszarach roboczych i platformach

Uczenie maszynowe w środowisku produkcyjnym wymaga więcej niż trenowania dobrego modelu. Potrzebujesz niezawodnych przepływów pracy, aby przenieść modele z programowania przez walidację do środowiska produkcyjnego. Logowanie między obszarami roboczymi w Microsoft Fabric umożliwia dwa kluczowe scenariusze:

Twórz kompletne przepływy pracy MLOps. Trenowanie i eksperymentowanie w obszarze roboczym programowania, weryfikowanie w obszarze roboczym testowym i wdrażanie w obszarze roboczym obsługującym środowisko produkcyjne przy użyciu standardowych interfejsów API platformy MLflow. To rozdzielenie środowisk pomaga zespołom egzekwować bramki jakości i zachować jasne ślady audytu od eksperymentowania po produkcję.
Wprowadź istniejące zasoby uczenia maszynowego do platformy Fabric. Jeśli wytrenujesz już modele w Azure Databricks, Azure Machine Learning, środowisku lokalnym lub dowolnej innej platformie obsługującej platformę MLflow, możesz rejestrować te eksperymenty i modele bezpośrednio w obszarze roboczym Fabric. Artefakty uczenia maszynowego można łatwo skonsolidować w jednym miejscu bez odbudowywania potoków szkoleniowych.

Rejestrowanie między obszarami roboczymi działa za pośrednictwem pakietu synapseml-mlflow, który zapewnia wtyczkę śledzenia MLflow zgodną z Fabric. Uwierzytelniasz się w docelowym obszarze roboczym, ustawiasz identyfikator URI śledzenia i używasz standardowych poleceń platformy MLflow.

Uwaga / Notatka

Rejestrowanie między obszarami roboczymi koncentruje się na podejściu code-first. Integracja interfejsu użytkownika dla scenariuszy obejmujących wiele obszarów roboczych zostanie rozwiązana w przyszłej wersji.

Wymagania wstępne

Subskrypcja Microsoft Fabric lub bezpłatna wersja próbna Microsoft Fabric.
Uprawnienie do zapisu w docelowym obszarze roboczym Fabric.
System śledzenia uczenia maszynowego uaktualniony zarówno dla źródłowych, jak i docelowych obszarów roboczych.

W przypadku scenariuszy notatnika Fabric utwórz nowy notatnik i dołącz lakehouse przed wykonaniem jakiegokolwiek kodu.

Wskazówka

Rejestrowanie między obszarami roboczymi jest obsługiwane w obszarach roboczych z włączoną ochroną dostępu wychodzącego . Rejestrowanie między obszarami roboczymi w innym obszarze roboczym wymaga zarządzanego prywatnego punktu końcowego. Rejestrowanie w tym samym obszarze roboczym oraz spoza Fabric działa bez potrzeby dodatkowej konfiguracji.

Instalowanie wtyczki MLflow

Pakiet synapseml-mlflow umożliwia rejestrowanie między obszarami roboczymi przez udostępnienie wtyczki śledzenia Fabric MLflow. Wybierz polecenie instalacji na podstawie środowiska.

Uwaga / Notatka

Pakiet synapseml-mlflow obsługuje teraz MLflow 3. Nie trzeba już przypinać mlflow-skinny do wersji 2.22.2. Aby zapoznać się z omówieniem funkcji platformy MLflow 3 w Fabric, zobacz MLflow 3 w Fabric Data Science.

Notebook z tkaniny
Obszar roboczy Outside Fabric

W przypadku notesu Fabric użyj tego polecenia, aby zainstalować pakiet z zależnościami notesu online:

%pip install -U "synapseml-mlflow[online-notebook]"

W dowolnym środowisku poza Fabric, takim jak maszyna lokalna (Visual Studio Code, Jupyter), Azure Databricks, Azure Machine Learning lub dowolna inna platforma, która obsługuje Python i MLflow, użyj następującego polecenia:

pip install -U "synapseml-mlflow"

Po zakończeniu instalacji uruchom ponownie jądro przed uruchomieniem pozostałego kodu.

Rejestrowanie obiektów MLflow w innym obszarze roboczym Fabric

W tym scenariuszu uruchamiasz notatnik w jednej przestrzeni roboczej Fabric (źródłowej) i zapisujesz eksperymenty oraz modele w innej przestrzeni roboczej Fabric (docelowej).

Ustawianie docelowego obszaru roboczego

Wskaż docelowy obszar roboczy, ustawiając zmienną MLFLOW_TRACKING_URI środowiskową:

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

Rejestrowanie eksperymentów i modeli

Utwórz eksperyment i zarejestruj przebieg z parametrami, metrykami i modelem:

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
    )

Po zakończeniu przebiegu eksperyment i zarejestrowany model pojawią się w docelowym obszarze roboczym.

Przenoszenie obiektów MLflow między obszarami roboczymi Fabric

W tym scenariuszu najpierw logujesz obiekty w źródłowym obszarze roboczym, a następnie pobierasz artefakty i ponownie logujesz je do docelowego obszaru roboczego. Ta metoda jest przydatna, gdy konieczne jest podwyższenie poziomu wytrenowanego modelu z obszaru roboczego programowania do obszaru roboczego produkcyjnego.

Krok 1. Rejestrowanie obiektów w źródłowym obszarze roboczym

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

Krok 2. Pobieranie artefaktów z przebiegu źródłowego

import mlflow.artifacts

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

Krok 3. Ponowne rejestrowanie artefaktów w docelowym obszarze roboczym

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
    )

Rejestrowanie obiektów MLflow spoza Fabric

Eksperymenty i modele MLflow można rejestrować w obszarze roboczym Fabric z dowolnego środowiska, w którym tworzysz modele, w tym:

Maszyny lokalne. VS Code, Jupyter notebooks lub dowolne lokalne środowisko Python.
Azure Databricks. Azure Databricks notatników i zadań.
Azure Machine Learning. Azure Machine Learning instancje obliczeniowe i potoki.
Każda inna platforma. Każde środowisko obsługujące Python i MLflow.

Krok 1. Instalowanie pakietu

synapseml-mlflow Zainstaluj pakiet w środowisku:

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

Krok 2. Uwierzytelnianie przy użyciu Fabric

Wybierz metodę uwierzytelniania na podstawie środowiska:

Użyj tej metody dla lokalnych środowisk deweloperskich z dostępem do przeglądarki, takim jak VS Code lub Jupyter.

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

SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=DefaultAzureCredential(exclude_interactive_browser_credential=False)
)

Użyj tej metody dla środowisk bez przeglądarki, takich jak notesy Azure Databricks lub serwery zdalne. Postępuj zgodnie z instrukcjami wyświetlanymi na ekranie, aby ukończyć uwierzytelnianie.

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

device_code_credential = DeviceCodeCredential()
SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=device_code_credential
)

Użyj tej metody w przypadku scenariuszy nieinteraktywnych, takich jak zautomatyzowane potoki, ciągła integracja i ciągłe dostarczanie (CI/CD) lub obciążenia produkcyjne.

W Microsoft Entra ID utwórz rejestrację aplikacji.
Zanotuj wartości Tenant ID i identyfikatora klienta. Utwórz klucz tajny klienta.

Udziel uprawnień do zapisu głównej jednostce usługi w obszarze roboczym docelowego systemu Fabric.

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
)

Krok 3. Ustawianie docelowego obszaru roboczego i rejestrowanie obiektów MLflow

Po uwierzytelnieniu, ustaw identyfikator URI śledzenia, aby wskazywał na docelowy obszar roboczy Fabric, oraz loguj eksperymenty i modele, używając standardowych interfejsów API MLflow.

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
    )

Stosuj rejestrowanie między obszarami roboczymi z ochroną dostępu wychodzącego

Jeśli obszar roboczy ma włączoną ochronę dostępu wychodzącego , rejestrowanie między obszarami roboczymi wymaga prywatnego punktu końcowego zarządzanego między obszarami roboczymi z obszaru roboczego źródłowego do docelowego obszaru roboczego.

Rejestrowanie w tym samym obszarze roboczym i rejestrowanie spoza Fabric (maszyny lokalne, Azure Databricks, Azure Machine Learning) działają bez dodatkowej konfiguracji.

Aby uzyskać szczegółowe informacje na temat obsługiwanych scenariuszy i wymaganej konfiguracji, zobacz Ochrona dostępu wychodzącego dla środowiska Fabric Data Science.

Instalowanie pakietu w obszarze roboczym z obsługą protokołu OAP

%pip install Standardowe polecenie wymaga wychodzącego dostępu do Internetu, który jest blokowany w obszarach roboczych z włączoną ochroną dostępu wychodzącego (OAP). Aby zainstalować pakiet synapseml-mlflow, najpierw pobierz go ze środowiska innego niż OAP, a następnie przekaż go do Lakehouse.

synapseml-mlflow Pobierz pakiet z komputera, który ma dostęp do Internetu.
```
pip download synapseml-mlflow[online-notebook]
```
Przekaż pobrane pliki do usługi Lakehouse w obszarze roboczym obsługującym protokół OAP. Prześlij wszystkie pliki .whl do sekcji Pliki w ramach lakehouse, na przykład /lakehouse/default/Files.

Zainstaluj z ścieżki lakehouse w notesie Fabric:

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

Ustaw URI śledzenia na korzystanie z zarządzanego prywatnego punktu końcowego. Jeśli bieżący obszar roboczy ma włączoną funkcję OAP, musisz skonfigurować prywatny punkt końcowy zarządzany przez wiele obszarów roboczych z obszaru roboczego źródłowego do docelowego obszaru roboczego. Następnie należy przekierować URI śledzenia za pośrednictwem prywatnego punktu końcowego.

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"

Znane ograniczenia

Wymagane jest uprawnienie do zapisu. Musisz mieć uprawnienia do zapisu w docelowym obszarze roboczym.
Powiązania między obszarami roboczymi nie są obsługiwane. Nie można wyświetlać relacji między notesami, eksperymentami i modelami, gdy te obiekty są rejestrowane z różnych obszarów roboczych.
Notatnik źródłowy nie jest widoczny w docelowej przestrzeni roboczej. Notatnik źródłowy nie pojawia się w docelowym obszarze roboczym. Na stronach szczegółów artefaktu i listy link do notesu źródłowego jest pusty.
Migawki elementu nie są obsługiwane. Eksperymenty lub modele uczenia maszynowego, które są rejestrowane w innym obszarze roboczym, nie pojawiają się w migawce elementu notesu z uruchomionego źródła.
Duże modele językowe nie są obsługiwane. Logowanie między różnymi obszarami roboczymi nie obsługuje dużych modeli językowych (LLMs).

Opinia

Czy ta strona była pomocna?

Last updated on 2026-05-15