Gestire i modelli MLflow tra aree di lavoro e piattaforme

L'apprendimento automatico di produzione richiede più del training di un modello valido. Sono necessari flussi di lavoro affidabili per spostare i modelli dallo sviluppo alla convalida nell'ambiente di produzione. La registrazione tra aree di lavoro in Microsoft Fabric abilita due scenari chiave:

• Sviluppa flussi di lavoro MLOps completi. Eseguire il training e l'esperimento in un'area di lavoro di sviluppo, convalidare in un'area di lavoro di test e distribuirla in un'area di lavoro di produzione usando le API MLflow standard. Questa separazione degli ambienti consente ai team di applicare controlli di qualità e mantenere percorsi di controllo chiari dalla sperimentazione alla produzione.

• Porta gli asset esistenti di Machine Learning in Fabric. Se è già stato eseguito il training dei modelli in Azure Databricks, Azure Machine Learning, un ambiente locale o qualsiasi altra piattaforma che supporta MLflow, è possibile registrare questi esperimenti e modelli direttamente in un'area di lavoro Fabric. È possibile consolidare facilmente gli artefatti di Machine Learning in un'unica posizione senza ricompilare le pipeline di training.

La registrazione tra aree di lavoro funziona tramite il pacchetto synapseml-mlflow, che fornisce un plug-in di rilevamento MLflow compatibile con Fabric. Si esegue l'autenticazione con l'area di lavoro di destinazione, si imposta l'URI di rilevamento e si usano i comandi MLflow standard.

Prerequisiti

• Una sottoscrizione Microsoft Fabric o una versione di valutazione gratuita Microsoft Fabric.
• Autorizzazione di scrittura per l'area di lavoro Fabric di destinazione.
• Un sistema di rilevamento di Machine Learning aggiornato per le aree di lavoro di origine e di destinazione.

Per gli scenari di notebook di Fabric, crea un nuovo notebook e collega un lakehouse prima di eseguire il codice.

Installare il plug-in MLflow

Il pacchetto synapseml-mlflow abilita la registrazione tra aree di lavoro fornendo il plug-in di rilevamento MLflow Fabric. Scegliere il comando di installazione in base all'ambiente in uso.

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

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

Dopo l'installazione, riavviare il kernel prima di eseguire il codice rimanente.

Registrare gli oggetti MLflow in un'altra area di lavoro di Fabric

In questo scenario si esegue un notebook in un'area di lavoro Fabric (origine) e si registrano esperimenti e modelli in un'area di lavoro Fabric diversa (destinazione).

Impostare l'area di lavoro di destinazione

Puntare all'area di lavoro di destinazione impostando la MLFLOW_TRACKING_URI variabile di ambiente:

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

Registrare esperimenti e modelli

Creare un esperimento e registrare un'esecuzione con parametri, metriche e un modello:

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
    )

Al termine dell'esecuzione, l'esperimento e il modello registrato vengono visualizzati nell'area di lavoro di destinazione.

Spostare oggetti MLflow tra aree di lavoro di Fabric

In questo scenario si registrano prima gli oggetti nell'area di lavoro di origine, quindi si scaricano gli artefatti e li registra nuovamente nell'area di lavoro di destinazione. Questo metodo è utile quando è necessario alzare di livello un modello sottoposto a training da un'area di lavoro di sviluppo a un'area di lavoro di produzione.

Passaggio 1: Registrare gli oggetti nell'area di lavoro di origine

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

Passaggio 2: Scaricare gli artefatti dall'esecuzione di origine

import mlflow.artifacts

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

Passaggio 3: Registrare nuovamente gli artefatti nell'area di lavoro di destinazione

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
    )

Registrare gli oggetti MLflow dall'esterno di Fabric

È possibile registrare esperimenti e modelli MLflow in un'area di lavoro Fabric da qualsiasi ambiente in cui si compilano i modelli, tra cui:

• Computer locali. VS Code, jupyter notebook o qualsiasi ambiente Python locale.
• Azure Databricks. Azure Databricks notebook e attività.
• Azure Machine Learning. Azure Machine Learning: istanze di calcolo e pipeline.
• Qualsiasi altra piattaforma. Qualsiasi ambiente che supporta Python e MLflow.

Passaggio 1: Installare il pacchetto

Installare il pacchetto synapseml-mlflow nell'ambiente:

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

Passaggio 2: Eseguire l'autenticazione con Fabric

Scegliere un metodo di autenticazione basato sull'ambiente:

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

SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=DefaultAzureCredential(exclude_interactive_browser_credential=False)
)

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

device_code_credential = DeviceCodeCredential()
SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=device_code_credential
)

Passaggio 3: Impostare l'area di lavoro di destinazione e registrare gli oggetti MLflow

Dopo l'autenticazione, impostare l'URI di rilevamento in modo che punti all'area di lavoro di destinazione Fabric e registrare esperimenti e modelli usando le API MLflow standard:

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
    )

Usare la registrazione tra più aree di lavoro con la protezione dell'accesso in uscita

Se per l'area di lavoro è abilitata la protezione dell'accesso in uscita , la registrazione tra aree di lavoro richiede un endpoint privato gestito tra aree di lavoro dall'area di lavoro di origine all'area di lavoro di destinazione.

La registrazione all'interno della stessa area di lavoro e la registrazione dall'esterno di Fabric (computer locali, Azure Databricks Azure Machine Learning) funzionano senza configurazione aggiuntiva.

Per informazioni dettagliate sugli scenari supportati e sulla configurazione necessaria, vedere Protezione dell'accesso in uscita per Fabric Data Science.

Installare il pacchetto in un'area di lavoro abilitata per OAP

Il comando standard %pip install richiede l'accesso a Internet in uscita, bloccato nelle aree di lavoro con la protezione dall'accesso in uscita abilitata. Per installare il synapseml-mlflow pacchetto, scaricarlo prima da un ambiente non OAP, quindi caricarlo nel lakehouse.

1. Scaricare il synapseml-mlflow pacchetto da un computer con accesso a Internet.

   pip download synapseml-mlflow[online-notebook]
   

2. Caricate i file scaricati nel Lakehouse nella vostra area di lavoro con funzionalità OAP. Caricare tutti i .whl file nella sezione File della lakehouse (ad esempio, /lakehouse/default/Files).

3. Eseguire l'installazione dal percorso lakehouse nel notebook Fabric:

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

4. Impostare l'URI di rilevamento per l'uso dell'endpoint privato gestito. Se l'area di lavoro corrente ha abilitato OAP, è necessario configurare un endpoint privato gestito tra aree di lavoro dall'area di lavoro di origine all'area di lavoro di destinazione. Instradare quindi l'URI di rilevamento tramite l'endpoint privato.

   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"
   

Limitazioni note

• È necessaria l'autorizzazione di scrittura. È necessario disporre dell'autorizzazione di scrittura per l'area di lavoro di destinazione.
• La derivazione tra aree di lavoro non è supportata. Non è possibile visualizzare le relazioni tra notebook, esperimenti e modelli quando questi oggetti vengono registrati da aree di lavoro diverse.
• Il notebook di origine non è visibile nell'area di lavoro di destinazione. Il notebook di origine non viene visualizzato nell'area di lavoro di destinazione. Nei dettagli dell'artefatto e nelle pagine elenco il collegamento al notebook di origine è vuoto.
• Gli snapshot degli elementi non sono supportati. Gli esperimenti o i modelli di Machine Learning registrati in un'altra area di lavoro non vengono visualizzati nello snapshot dell'elemento del notebook di esecuzione dell'origine.
• I modelli linguistici di grandi dimensioni non sono supportati. La registrazione dei log tra aree di lavoro non supporta i modelli di linguaggio di grandi dimensioni (LLMs).

Contenuti correlati

• Esperimenti di apprendimento automatico in Microsoft Fabric
• Monitorare e gestire i modelli di apprendimento automatico
• Aggiornare il sistema di rilevamento di Machine Learning
• Accesso automatico in Microsoft Fabric
• Pipeline di integrazione e distribuzione Git per esperimenti e modelli di Machine Learning
• Protezione dell'accesso in uscita per l'area di lavoro per l'analisi scientifica dei dati