Gerenciar modelos de MLflow em workspaces e plataformas

O aprendizado de máquina de produção requer mais do que treinar um bom modelo. Você precisa de fluxos de trabalho confiáveis para mover modelos do desenvolvimento por meio da validação para a produção. O log entre workspaces no Microsoft Fabric habilita dois cenários principais:

Crie fluxos de trabalho de ponta a ponta do MLOps. Treine e experimente em um workspace de desenvolvimento, valide em um workspace de teste e implemente em um workspace para produção usando APIs padrão do MLflow. Essa separação de ambientes ajuda as equipes a impor portões de qualidade e manter trilhas de auditoria claras da experimentação à produção.
Traga ativos de machine learning existentes para o Fabric. Se você já treinou modelos em Azure Databricks, Azure Machine Learning, um ambiente local ou qualquer outra plataforma que dê suporte ao MLflow, você poderá registrar esses experimentos e modelos diretamente em um workspace Fabric. Você pode consolidar facilmente seus artefatos de machine learning em um só lugar sem reconstruir seus pipelines de treinamento.

O registro em log entre workspaces funciona por meio do pacote synapseml-mlflow, que fornece um plug-in de acompanhamento MLflow compatível com Fabric. Você se autentica com seu workspace de destino, define o URI de acompanhamento e usa comandos MLflow padrão.

Observação

O registro em log entre workspaces concentra-se na experiência centrada no código. A integração da interface do usuário para cenários entre áreas de trabalho será tratada em uma versão futura.

Pré-requisitos

Uma assinatura Microsoft Fabric ou uma avaliação Microsoft Fabric gratuita.
Permissão de gravação no ambiente de trabalho do Fabric de destino.
Um sistema de acompanhamento de machine learning atualizado para ambientes de trabalho tanto de origem quanto de destino.

Para cenários de notebook do Fabric, crie um novo notebook e vincule um lakehouse antes de executar qualquer código.

Dica

O registro de logs entre espaços de trabalho tem suporte em espaços de trabalho com a proteção de acesso de saída habilitada. Para realizar o log entre diferentes workspaces, é necessário um endpoint privado gerenciado. O registro de logs dentro do mesmo workspace e a partir de sistemas externos ao Fabric funciona sem configuração adicional.

Instalar o plug-in do MLflow

O pacote synapseml-mlflow permite o registro em log entre diferentes workspaces fornecendo o plug-in de acompanhamento do MLflow Fabric. Escolha o comando de instalação com base em seu ambiente.

Importante

No momento, o MLflow 3 não tem suporte. Você 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 Fabric, use este comando para instalar o pacote com dependências de notebook em ambiente online.

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

Em qualquer ambiente fora Fabric, como um computador local (Visual Studio Code, Jupyter), Azure Databricks, Azure Machine Learning ou qualquer outra plataforma compatível com 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.

Registrar objetos MLflow em outro workspace do Fabric

Nesse cenário, você executa um notebook em um workspace Fabric (origem) e registra experimentos e modelos para um workspace Fabric diferente (destino).

Definir o espaço de trabalho de destino

Defina o workspace de destino apontando a variável de ambiente MLFLOW_TRACKING_URI.

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

Registrar experimentos 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 conclusão da execução, o experimento e o modelo registrado aparecem no workspace de destino.

Mover objetos do MLflow entre os workspaces do Fabric

Nesse cenário, primeiro você registra objetos no workspace de origem e, em seguida, baixa os artefatos e os registra novamente no workspace de destino. Esse método é útil quando você precisa promover um modelo treinado de um workspace de desenvolvimento para um workspace de produção.

Etapa 1: Registrar objetos no workspace 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

Etapa 2: Baixar artefatos da execução original

import mlflow.artifacts

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

Etapa 3: registrar novamente artefatos no workspace 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

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
    )

Registrar objetos MLflow fora do Fabric

Você pode registrar modelos e experimentos do MLflow em um workspace Fabric de qualquer ambiente em que você crie seus modelos, incluindo:

Computadores locais. VS Code, jupyter notebooks ou qualquer ambiente de Python local.
Azure Databricks. Azure Databricks blocos de anotações e trabalhos.
Azure Machine Learning. Instâncias de computação e pipelines do Azure Machine Learning.
Qualquer outra plataforma. Qualquer ambiente compatível com Python e MLflow.

Etapa 1: Instalar o pacote

Instale o synapseml-mlflow pacote em seu ambiente:

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

Etapa 2: autenticar com Fabric

Escolha um método de autenticação com base em seu ambiente:

Use esse método para ambientes de desenvolvimento locais com acesso ao 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 esse método para ambientes sem um navegador, como notebooks Azure Databricks ou servidores remotos. Siga as instruções na tela para concluir a autenticação.

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

device_code_credential = DeviceCodeCredential()
SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=device_code_credential
)

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

Em Microsoft Entra ID, criar um registro de aplicativo.
Observe os valores da ID do Locatário e da ID do Cliente. Criar um segredo do cliente.

Conceda permissão de gravação ao principal de serviço no workspace de destino do 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
)

Etapa 3: Configurar o workspace de destino e fazer log dos objetos MLflow

Após a autenticação, defina o URI de acompanhamento para apontar para seu workspace Fabric-alvo e registre experimentos e modelos utilizando as APIs padrão do 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
    )

Usar registro entre espaços de trabalho com proteção de acesso de saída

Se o workspace tiver a proteção de acesso de saída habilitada, o registro em log entre workspaces exigirá um ponto de extremidade privado gerenciado entre workspaces do workspace de origem para o workspace de destino.

O registro em log no mesmo workspace e registro em log de fora de Fabric (computadores locais, Azure Databricks, Azure Machine Learning) funciona sem configuração adicional.

Para obter detalhes sobre cenários com suporte e configuração necessária, consulte Proteção de acesso externo do Workspace para Data Science Fabric.

Instalar o pacote em um workspace habilitado para OAP

O comando padrão %pip install requer acesso à Internet de saída, que é bloqueado em espaços de trabalho com proteção de acesso de saída (OAP) habilitada. Para instalar o pacote, primeiro baixe-o synapseml-mlflow de um ambiente não OAP e carregue-o no lakehouse.

Baixe o synapseml-mlflow pacote de um computador que tenha acesso à Internet.
```
pip download synapseml-mlflow[online-notebook]
```
Carregue os arquivos baixados no lakehouse em seu workspace habilitado para OAP. Carregue todos os .whl arquivos na seção Arquivos do lakehouse (por exemplo, /lakehouse/default/Files).

Instale a partir do caminho do lakehouse em seu notebook do 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 rastreamento para usar o ponto de extremidade privado gerenciado. Se o seu workspace atual tiver OAP habilitado, você deve configurar um ponto de extremidade privado gerenciado entre os workspaces do workspace de origem para o workspace de destino. Em seguida, encaminhe o URI de rastreamento pelo ponto de extremidade 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

A permissão de gravação é necessária. Você deve ter permissão de gravação no espaço de trabalho de destino.
Não há suporte para a linhagem entre workspaces. Não é possível exibir relações entre blocos de anotações, experimentos e modelos quando esses objetos são registrados em diferentes workspaces.
O notebook de origem não está visível no workspace de destino. O notebook de origem não aparece no workspace de destino. Nos detalhes dos artefatos e nas páginas de listas, o link para o notebook de origem está vazio.
Não há suporte para instantâneos de itens. Os experimentos de machine learning ou modelos conectados a outro workspace não aparecem no instantâneo do item do notebook de execução de origem.
Não há suporte para modelos de linguagem grandes. O registro em log entre workspaces não dá suporte a LLMs (grandes modelos de linguagem).

Comentários

Esta página foi útil?

Last updated on 2026-05-01