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 implante em um workspace de serviço de produção, tudo usando APIs de MLflow padrão. 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 ML existentes para Fabric. Se você já tiver modelos treinados 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. Isso facilita a consolidação de 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 rastreamento e usa os comandos padrão do MLflow — o mesmo código já conhecido por você.

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 inscreva-se para uma avaliação gratuita Microsoft Fabric.
permissão WRITE no workspace de destino do Fabric.
Atualize seu sistema de acompanhamento de machine learning para workspaces de origem e de destino.
Para cenários de notebook do Fabric: crie um novo notebook e anexe um Lakehouse antes de executar o 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

O MLflow 3 ainda 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

Use o comando em um notebook do Fabric para instalar o pacote com dependências para notebooks online.

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

Use esse comando em qualquer ambiente fora Fabric, como um computador local (VS Code, Jupyter), Azure Databricks, Azure Machine Learning ou qualquer outra plataforma que dê suporte a Python e MLflow.

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 a variável de ambiente MLFLOW_TRACKING_URI para apontar para o seu 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

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. Isso é útil quando você precisa promover um modelo treinado de um espaço de trabalho de desenvolvimento para um espaço de trabalho 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:

Máquinas locais — VS Code, Jupyter notebooks ou qualquer ambiente de Python local.
Azure Databricks — notebooks e trabalhos do Databricks.
Azure Machine Learning — instâncias de computação e pipelines de Azure ML.
Qualquer outra plataforma — qualquer ambiente que dê suporte a 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
)

Utilize este método para cenários sem interação, como fluxos de trabalho automatizados, CI/CD ou cargas de trabalho de produção.

Em Microsoft Entra ID, criar um registro de aplicativo.
Observe a ID do locatário, a ID do cliente e crie um segredo do cliente.
Conceda ao principal de serviço permissão WRITE no espaço de trabalho de Fabric de destino.

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: Defina o workspace de destino e registre os objetos do MLflow

Após a autenticação, defina o URI de acompanhamento para apontar para o seu workspace Fabric de destino e registre experimentos e modelos usando 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 a configuração necessária, consulte a proteção de acesso de saída do Workspace para Ciência de Dados.

Instalar o pacote em um workspace habilitado para OAP

O comando padrão %pip install requer acesso à Internet de saída, que é bloqueado em workspaces habilitados para OAP. Para instalar o pacote, primeiro baixe-o synapseml-mlflow de um ambiente não OAP e carregue-o no lakehouse.

Etapa 1: Baixar o pacote Baixe o pacote synapseml-mlflow de um computador que tenha acesso à Internet.

pip download synapseml-mlflow[online-notebook]

Etapa 2: Carregar os arquivos baixados Faça o upload dos arquivos baixados para o lakehouse no seu workspace com OAP ativado. Carregue todos os .whl arquivos na seção Arquivos do lakehouse (por exemplo, /lakehouse/default/Files).

Etapa 3: Instalar a partir do caminho do lakehouse em seu caderno do Fabric

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

Etapa 4: Definir o URI de acompanhamento para usar o ponto de extremidade privado gerenciado

Se o workspace atual tiver o OAP habilitado, você deverá configurar um ponto de extremidade privado gerenciado entre workspaces do workspace de origem para o workspace de destino e rotear 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

Permissão de gravação necessária. Você deve ter permissão de escrita no workspace 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.
Notebook de origem não 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. Experimentos ou modelos de ML registrados em outro workspace não aparecem no instantâneo do notebook de execução original.
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-04-09