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:

Construya flujos de trabajo de MLOps integrales. 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, todo ello 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.
Incorpore los recursos de ML 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. Esto simplifica la consolidación de los artefactos de Aprendizaje Automático en un solo lugar sin necesidad de 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 de MLflow estándar, el mismo código que ya conoce.

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 bien, regístrese para obtener una prueba gratuita Microsoft Fabric.
WRITE permisos en el espacio de trabajo de Fabric de destino.
Actualice el sistema de seguimiento de aprendizaje automático para las áreas de trabajo de origen y destino.
Para escenarios de cuadernos de Fabric: cree un cuaderno nuevo y conecte un Lakehouse antes de ejecutar el 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 install en función de su entorno:

Importante

Todavía 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

Use este comando en un cuaderno de Fabric para instalar el paquete con dependencias de cuadernos en línea.

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

Use este comando en cualquier entorno fuera de Fabric, como una máquina local (VS Code, Jupyter), Azure Databricks, Azure Machine Learning o cualquier otra plataforma que admita Python y MLflow.

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

Establezca la variable de entorno MLFLOW_TRACKING_URI para que apunte al área de trabajo 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

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 completada 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. Esto resulta ú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 de Jupyter o cualquier entorno de Python local.
Azure Databricks: cuadernos y trabajos de Databricks.
Azure Machine Learning: las instancias de cómputo y las canalizaciones de Azure ML.
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, CI/CD o cargas de trabajo de producción.

En Microsoft Entra ID, crear un registro de aplicaciones.
Anote el identificador de inquilino, el identificador de cliente y cree un secreto de cliente.
Conceda a la entidad de servicio el permiso WRITE 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 apunte a su Fabric workspace de destino y registre experimentos y modelos mediante 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 detalles sobre los escenarios admitidos y la configuración necesaria, consulte Protección de acceso de salida del área de trabajo para Ciencia de Datos.

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 habilitadas para OAP. Para instalar el synapseml-mlflow paquete, descárguelo primero desde un entorno que no sea de OAP y cárguelo en lakehouse.

Paso 1: Descargar el paquete Descargue el paquete synapseml-mlflow desde una máquina que tenga acceso a Internet.

pip download synapseml-mlflow[online-notebook]

Paso 2: Cargar los archivos descargados 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).

Paso 3: Instalar desde la ruta 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

Paso 4: Establecimiento del 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 y enrutar 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 permiso de escritura en el espacio 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.
Cuaderno de origen no visible en el espacio 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 ML registrados en otra área de trabajo no aparecen en la captura del elemento de cuaderno de ejecución original.
No se admiten modelos de lenguaje de gran tamaño. El registro entre áreas de trabajo no admite modelos de lenguaje grandes (LLM).

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-04-09