Gerir modelos MLflow em espaços de trabalho e plataformas

A aprendizagem automática em produção exige mais do que treinar um bom modelo — precisa de fluxos de trabalho fiáveis para mover os modelos do desenvolvimento, passando pela validação até à produção. O registo entre espaços de trabalho no Microsoft Fabric permite dois cenários-chave:

• Construir fluxos de trabalho MLOps de ponta a ponta. Treine e experimente num espaço de trabalho de desenvolvimento, valide num espaço de trabalho de teste e implemente para um espaço de trabalho de serviço de produção — tudo isto usando APIs padrão de MLflow. Esta separação de ambientes ajuda as equipas a impor limites de qualidade e a manter registos de auditoria claros desde a experimentação até à produção.

• Traz ativos de Machine Learning (ML) existentes para o Fabric. Se já tiver modelos treinados no Azure Databricks, Azure Machine Learning, num ambiente local ou em qualquer outra plataforma que suporte MLflow, pode registar esses experimentos e modelos diretamente num espaço de trabalho Fabric. Isto facilita a consolidação dos artefactos de Machine Learning num único local, sem a necessidade de reconstruir os seus pipelines de treinamento.

O registo entre espaços de trabalho é realizado através do pacote synapseml-mlflow, que fornece um plugin de acompanhamento MLflow compatível com Fabric. Autenticas com o teu espaço de trabalho de destino, defines o URI de rastreamento e usas comandos MLflow padrão — o mesmo código que já conheces.

Pré-requisitos

• Uma subscrição do Microsoft Fabric. Ou, inscreva-se para um teste gratuito Microsoft Fabric.
• Permissão WRITE no espaço de trabalho Fabric alvo.
• Atualize o seu sistema de rastreamento de aprendizagem automática tanto para os espaços de trabalho de origem como para os de destino.
• Para cenários de notebooks do Fabric: Crie um novo notebook e anexe um Lakehouse antes de executar o código.

Instalar o plugin MLflow

O pacote synapseml-mlflow permite registos entre espaços de trabalho ao fornecer o plugin de rastreamento Fabric MLflow. Escolha o comando de instalação com base no seu ambiente:

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

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

Após a instalação, reinicie o kernel antes de executar o código restante.

Registar objetos MLflow em outro espaço de trabalho do Fabric

Neste cenário, executa um notebook num espaço de trabalho Fabric (fonte) e regista experiências e modelos num espaço de trabalho Fabric diferente (alvo).

Definir o espaço de trabalho alvo

Defina a MLFLOW_TRACKING_URI variável de ambiente para apontar para o seu espaço de trabalho de destino:

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

Registar experiências e modelos

Crie um experimento e registre uma execução com parâmetros, métricas e um modelo:

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
    )

Após a execução, o experimento e o modelo registado aparecem no espaço de trabalho alvo.

Mover objetos MLflow entre espaços de trabalho do Fabric

Neste cenário, primeiro registas objetos no workspace de origem, depois descarregas os artefactos e voltas a logá-los no workspace de destino. Isto é útil quando é necessário promover um modelo treinado de um espaço de trabalho de desenvolvimento para um espaço de produção.

Passo 1: Registar objetos no espaço de trabalho de origem

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

Passo 2: Descarregar artefatos da execução de origem

import mlflow.artifacts

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

Passo 3: Voltar a registar artefactos no espaço de trabalho alvo

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
    )

Registar os objetos MLflow de fora do Fabric

Pode registar experiências e modelos de MLflow num espaço de trabalho Fabric a partir de qualquer ambiente onde constrói os seus modelos, incluindo:

• Máquinas locais — VS Code, notebooks Jupyter ou qualquer ambiente local de Python.
• Azure Databricks — Databricks, notebooks e trabalhos.
• Azure Machine Learning — instâncias de computação do Azure ML e pipelines.
• Qualquer outra plataforma — Qualquer ambiente que suporte Python e MLflow.

Passo 1: Instalar o pacote

Instale o synapseml-mlflow pacote no seu ambiente:

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

O Passo 2: Autenticar-se com o Fabric

Escolha um método de autenticação baseado no seu 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
)

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
)

Passo 3: Definir o espaço de trabalho alvo e registar objetos MLflow

Após a autenticação, defina o URI de rastreamento para apontar para o seu espaço de trabalho Fabric alvo e registre experiências e modelos usando APIs MLflow padrão:

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
    )

Utilizar o registo entre espaços de trabalho com proteção de acesso de saída

Se o seu espaço de trabalho tiver a proteção de acesso de saída ativada, o registo entre espaços de trabalho requer um endpoint privado gerido entre espaços de trabalho do espaço de trabalho de origem para o espaço de trabalho alvo. O registo dentro do mesmo espaço de trabalho e o registo externo ao Fabric (máquinas locais, Azure Databricks, Azure Machine Learning) funcionam sem configuração adicional.

Para detalhes sobre cenários suportados e configuração necessária, consulte Proteção de acesso de saída do espaço de trabalho para Ciência de Dados.

Instale o pacote num espaço de trabalho compatível com OAP

O comando padrão %pip install requer acesso à internet de saída, que está bloqueado em espaços de trabalho com OAP. Para instalar o synapseml-mlflow pacote, primeiro descarrega-o de um ambiente não OAP e depois carrega-o para a casa do lago.

Passo 1: Descarregar o pacote Descarregue o pacote synapseml-mlflow a partir de uma máquina que tenha acesso à internet.

pip download synapseml-mlflow[online-notebook]

Passo 2: Carregar os ficheiros descarregados Carregue os ficheiros descarregados para a casa do lago no seu espaço de trabalho com OAP. Carregue todos os .whl ficheiros para a secção Ficheiros do lakehouse (por exemplo, /lakehouse/default/Files).

Passo 3: Instale a partir do caminho do lakehouse no seu notebook Fabric

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

Passo 4: Defina o URI de rastreamento para usar o endpoint privado gerido

Se o seu espaço de trabalho atual tiver o OAP ativado, deve configurar um endpoint privado gerido entre espaços de trabalho a partir do workspace de origem para o workspace de destino e encaminhar o URI de rastreio através do endpoint privado.

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"

Limitações conhecidas

• É necessária autorização para escrever. Tens de ter permissão de ESCRITA no espaço de trabalho de destino.
• Linhagem entre espaços de trabalho não suportada. Não se podem ver relações entre cadernos, experiências e modelos quando estes objetos são registados em diferentes espaços de trabalho.
• Notebook de origem não visível no workspace de destino. O caderno de origem não aparece no espaço de trabalho de destino. Nos detalhes dos artefactos e nas páginas de lista, o link para o caderno de origem está vazio.
• Capturas de itens não são suportadas. Experiências ou modelos de ML registados noutro espaço de trabalho não aparecem no snapshot do item do notebook de execução de origem.
• Grandes modelos de linguagem não são suportados. O registo entre espaços de trabalho não suporta grandes modelos de linguagem (LLMs).

Conteúdo relacionado

• Experiências de aprendizagem automática em Microsoft Fabric
• Rastreie e gerencie modelos de aprendizado de máquina
• Atualize o seu sistema de rastreamento de aprendizagem automática
• Autolog em Microsoft Fabric
• Experiências e modelos de aprendizagem automática Pipelines de integração e implementação Git
• Proteção de acesso outbound para espaço de trabalho em Ciência de Dados