Gerir modelos MLflow em espaços de trabalho e plataformas

O machine learning em produção exige mais do que treinar um bom modelo. Precisas de fluxos de trabalho fiáveis para mover 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 que serve produção 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.
Integre ativos de aprendizagem automática existentes para Fabric. Se já treinaste modelos no Azure Databricks, Azure Machine Learning, num ambiente local ou em qualquer outra plataforma que suporte MLflow, podes registar esses experimentos e modelos diretamente num espaço de trabalho Fabric. Pode facilmente consolidar os seus artefatos de aprendizagem automática num só local sem reconstruir os seus pipelines de treino.

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. Autentica-se com o espaço de trabalho de destino, define-se o URI de rastreio e utiliza-se comandos padrão do MLflow.

Observação

O registo entre espaços de trabalho foca-se na experiência de prioridade ao código. A integração da interface para cenários entre espaços de trabalho será abordada numa versão futura.

Pré-requisitos

Uma subscrição Microsoft Fabric ou um teste gratuito Microsoft Fabric.
Permissão para escrever no workspace de destino Fabric.
Um sistema de rastreamento de aprendizagem automática que é atualizado tanto para espaços de trabalho de origem como de destino.

Para cenários de cadernos Fabric, cria um novo caderno e anexa um lakehouse antes de executares qualquer código.

Sugestão

O registo cruzado de espaços de trabalho é suportado em espaços de trabalho com proteção de acesso de saída ativada. O registo entre espaços de trabalho para um espaço de trabalho diferente requer um endpoint privado gerido. Fazer login dentro do mesmo espaço de trabalho e fora do Fabric funciona sem configuração adicional.

Instalar o plugin MLflow

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

Importante

O MLflow 3 não é atualmente suportado. Deve fixar mlflow-skinny na versão 2.22.2 ou anterior.

Caderno de tecido
Fora do espaço de trabalho Fabric

Para um notebook do Fabric, utilize este comando para instalar o pacote com dependências específicas para notebooks online:

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

Em qualquer ambiente fora do Fabric, como uma máquina local (Visual Studio Code, Jupyter), Azure Databricks, Azure Machine Learning ou qualquer outra plataforma que suporte Python e MLflow, use este comando:

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

Aponte para o seu espaço de trabalho alvo definindo a MLFLOW_TRACKING_URI variável de 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

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 o fim da 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. Este método é útil quando é necessário promover um modelo treinado de um espaço de trabalho de desenvolvimento para um espaço de trabalho 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 Python local.
Azure Databricks. Cadernos e tarefas do Azure Databricks.
Azure Machine Learning. Azure Machine Learning computa instâncias 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:

Use este método para ambientes de desenvolvimento locais com acesso a navegador, como VS Code ou Jupyter.

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

SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=DefaultAzureCredential(exclude_interactive_browser_credential=False)
)

Use este método para ambientes sem navegador, como notebooks Azure Databricks ou servidores remotos. Siga as instruções no ecrã para completar a autenticação.

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

device_code_credential = DeviceCodeCredential()
SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=device_code_credential
)

Utilize este método para cenários não interativos, como pipelines automatizados, integração contínua e distribuição contínua (CI/CD), ou cargas de trabalho de produção.

Em Microsoft Entra ID, criar um registo de aplicação.
Note os valores do ID do Tenant e do ID do Cliente. Crie um Segredo para o Cliente.

Conceda permissão de escrita ao principal de serviço no espaço de trabalho Fabric alvo.

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 padrão de 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
    )

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 Workspace para Fabric Data Science.

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 é bloqueado nos espaços de trabalho com proteção de acesso de saída (OAP) ativada. Para instalar o synapseml-mlflow pacote, primeiro descarrega-o de um ambiente não OAP e depois carrega-o para a casa do lago.

Descarrega o synapseml-mlflow pacote a partir de uma máquina que tenha acesso à internet.
```
pip download synapseml-mlflow[online-notebook]
```
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).

Instale a partir do caminho da casa do lago no seu caderno Fabric:

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

Defina o URI de monitorização 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 desde o espaço de trabalho de origem até ao espaço de trabalho de destino. Depois, encaminha 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 de escrita. Deve ter permissão de escrita na área de trabalho de destino.
A linhagem entre diferentes 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.
O caderno de origem não é visível no espaço de trabalho 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.
Snapshots de itens não são suportados. Experiências ou modelos de aprendizagem automática que são registados noutro espaço de trabalho não aparecem na imagem instantânea do item do caderno de execução da origem.
Modelos de linguagem grandes não são suportados. O registo entre espaços de trabalho não suporta grandes modelos de linguagem (LLMs).

Comentários

Esta página foi útil?

Last updated on 2026-05-01