Administración de modelos de MLflow en áreas de trabajo y plataformas

El aprendizaje automático de producción requiere más que entrenar un buen modelo. Necesita flujos de trabajo confiables para mover modelos de desarrollo a través de la validación a producción. El registro entre áreas de trabajo en Microsoft Fabric habilita dos escenarios clave:

Cree flujos de trabajo MLOps de principio a fin. Entrene y experimente en un área de trabajo de desarrollo, valide en un área de trabajo de prueba e implemente en un área de trabajo de servicio de producción mediante las API estándar de MLflow. Esta separación de entornos ayuda a los equipos a aplicar puertas de calidad y mantener pistas de auditoría claras de experimentación a producción.
Importa los activos de aprendizaje automático existentes a Fabric Si ya ha entrenado modelos en Azure Databricks, Azure Machine Learning, un entorno local o cualquier otra plataforma que admita MLflow, puede registrar esos experimentos y modelos directamente en un área de trabajo de Fabric. Puede consolidar fácilmente los elementos de aprendizaje automático en un solo lugar sin tener que reconstruir las canalizaciones de entrenamiento.

El registro entre áreas de trabajo funciona mediante el paquete synapseml-mlflow, que proporciona un complemento de seguimiento de MLflow compatible con Fabric. Se autentica con el área de trabajo de destino, se establece el URI de seguimiento y se usan comandos estándar de MLflow.

Nota:

El registro entre áreas de trabajo se centra en la experiencia centrada en el código. La integración de la interfaz de usuario para escenarios entre áreas de trabajo se abordará en una versión futura.

Prerrequisitos

Una suscripción Microsoft Fabric o una Microsoft Fabric evaluación gratuita.
Permiso de escritura en el área de trabajo de Fabric de destino.
Un sistema de seguimiento de aprendizaje automático que se actualiza para las áreas de trabajo de origen y de destino.

Para escenarios de cuadernos de Fabric, cree un nuevo cuaderno y adjunte un lakehouse antes de ejecutar cualquier código.

Sugerencia

El registro entre áreas de trabajo se admite en áreas de trabajo con la protección de acceso saliente habilitada. El registro entre áreas de trabajo en un área de trabajo diferente requiere un punto de conexión privado administrado. El registro dentro de la misma área de trabajo y desde fuera de Fabric funciona sin ninguna configuración adicional.

Instalación del complemento MLflow

El paquete synapseml-mlflow habilita el registro entre áreas de trabajo proporcionando el complemento de seguimiento de Fabric MLflow. Elija el comando de instalación en función de su entorno.

Importante

Actualmente no se admite MLflow 3. Debe anclar mlflow-skinny a la versión 2.22.2 o anterior.

Cuaderno de tela
Área de trabajo externa de Fabric

Para un cuaderno de Fabric, use este comando para instalar el paquete con dependencias de cuadernos en línea:

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

En cualquier entorno fuera de Fabric, como una máquina local (Visual Studio Code, Jupyter), Azure Databricks, Azure Machine Learning o cualquier otra plataforma que admita Python y MLflow, use este comando:

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

Después de la instalación, reinicie el kernel antes de ejecutar el código restante.

Registrar objetos MLflow en otro área de trabajo de Fabric

En este escenario, ejecutará un cuaderno en un área de trabajo de Fabric (origen) y registrará experimentos y modelos en otro área de trabajo de Fabric (destino).

Establecimiento del área de trabajo de destino

Indique su área de trabajo de destino estableciendo la variable de entorno 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

Registros de experimentos y modelos

Cree un experimento y registre una ejecución con parámetros, métricas y un 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
    )

Una vez finalizada la ejecución, el experimento y el modelo registrado aparecen en el área de trabajo de destino.

Mover objetos de MLflow entre áreas de trabajo de Fabric

En este escenario, primero registrará objetos en el área de trabajo de origen y, a continuación, descargará los artefactos y los volverá a registrar en el área de trabajo de destino. Este método es útil cuando es necesario promover un modelo entrenado de un área de trabajo de desarrollo a un área de trabajo de producción.

Paso 1: Registrar objetos en el área de trabajo de origen

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

Paso 2: Descargar componentes de la ejecución de origen

import mlflow.artifacts

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

Paso 3: Volver a registrar artefactos en el área de trabajo 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 de MLflow desde fuera de Fabric

Puede registrar experimentos y modelos de MLflow en un área de trabajo de Fabric desde cualquier entorno en el que cree los modelos, entre los que se incluyen:

Máquinas locales. VS Code, cuadernos Jupyter o cualquier entorno local de Python.
Azure Databricks. Azure Databricks cuadernos y trabajos.
Azure Machine Learning. Azure Machine Learning, las instancias de cómputo y las canalizaciones.
Cualquier otra plataforma. Cualquier entorno que admita Python y MLflow.

Paso 1: Instalar el paquete

Instale el synapseml-mlflow paquete en el entorno:

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

Paso 2: Autenticación con Fabric

Elija un método de autenticación basado en su entorno:

Use este método para entornos de desarrollo local con acceso al explorador, como VS Code o 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 entornos sin explorador, como Azure Databricks cuadernos o servidores remotos. Siga las instrucciones en pantalla para completar la autenticación.

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

device_code_credential = DeviceCodeCredential()
SetFabricAnalyticsDefaultTokenCredentialsGlobally(
    credential=device_code_credential
)

Use este método para escenarios no interactivos, como canalizaciones automatizadas, integración continua y entrega continua (CI/CD) o cargas de trabajo de producción.

En Microsoft Entra ID, crear un registro de aplicaciones.
Anote los valores de Id. de inquilino e Id. de cliente. Cree un secreto de cliente.

Otorgue permiso de escritura a la entidad de servicio en el área de trabajo 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
)

Paso 3: Establecer el área de trabajo de destino y registrar objetos MLflow

Después de la autenticación, establezca el URI de seguimiento para que se dirija al área de trabajo Fabric de destino y registre experimentos y modelos utilizando las API estándar 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
    )

Uso del registro entre áreas de trabajo con protección de acceso saliente

Si el área de trabajo tiene habilitada la protección de acceso saliente , el registro entre áreas de trabajo requiere un punto de conexión privado administrado entre áreas de trabajo desde el área de trabajo de origen al área de trabajo de destino.

El registro dentro del mismo área de trabajo y el registro desde fuera de Fabric (máquinas locales, Azure Databricks, Azure Machine Learning) funcionan sin configuración adicional.

Para obtener detalles sobre los escenarios compatibles y la configuración requerida, consulte Protección de acceso saliente de Fabric Data Science.

Instalación del paquete en un área de trabajo habilitada para OAP

El comando estándar %pip install requiere acceso saliente a Internet, que está bloqueado en áreas de trabajo con la protección de acceso saliente (OAP) habilitada. Para instalar el synapseml-mlflow paquete, descárguelo primero desde un entorno que no sea de OAP y cárguelo en lakehouse.

Descargue el synapseml-mlflow paquete desde una máquina que tenga acceso a Internet.
```
pip download synapseml-mlflow[online-notebook]
```
Cargue los archivos descargados en lakehouse en el área de trabajo habilitada para OAP. Cargue todos los .whl archivos en la sección Archivos de lakehouse (por ejemplo, /lakehouse/default/Files).

Instalar desde la ruta de acceso del Lakehouse en el cuaderno de Fabric:

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

Establezca el URI de seguimiento para usar el punto de conexión privado administrado. Si el área de trabajo actual tiene habilitado OAP, debe configurar un punto de conexión privado administrado entre áreas de trabajo desde el área de trabajo de origen al área de trabajo de destino. A continuación, enrute el URI de seguimiento a través del punto de conexión 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"

Limitaciones conocidas

Se requiere el permiso de escritura. Debe tener permisos de edición en el área de trabajo de destino.
No se admite el linaje entre áreas de trabajo. No se pueden ver las relaciones entre cuadernos, experimentos y modelos cuando estos objetos se registran desde áreas de trabajo diferentes.
El cuaderno de origen no está visible en el área de trabajo de destino. El cuaderno de origen no aparece en el área de trabajo de destino. En las páginas de detalles y listas de artefactos, el enlace al cuaderno de origen está vacío.
No se admiten instantáneas de elementos. Los experimentos o modelos de aprendizaje automático que se registran en otra área de trabajo no aparecen en la instantánea del ítem del cuaderno de ejecución de la fuente.
No se admiten modelos de lenguaje grande. El registro entre áreas de trabajo no admite modelos de lenguaje grandes (LLM).

Comentarios

¿Le resultó útil esta página?

Last updated on 2026-04-09