Administración del ciclo de vida del modelo en Unity Catalog

En este artículo se describe cómo usar los modelos en Unity Catalog como parte del flujo de trabajo de aprendizaje automático para administrar el ciclo de vida completo de los modelos de ML. Databricks proporciona una versión hospedada del Registro de modelos de MLflow en Unity Catalog. Los modelos de Unity Catalog amplían las ventajas de Unity Catalog a los modelos de ML, incluidos el control de acceso centralizado, la auditoría, el linaje y la detección de modelos entre áreas de trabajo. Los modelos de Unity Catalog son compatibles con el cliente de Python de MLflow de código abierto.

Para obtener información general sobre los conceptos del Registro de modelos, consulte Administración del ciclo de vida de ML mediante MLflow.

Requisitos

1. El Unity Catalog debe estar habilitado en tu área de trabajo. Consulta Introducción al uso de Unity Catalog para crear un metastore de Unity Catalog, habilitarlo en un área de trabajo y crear un catálogo. Si Unity Catalog no está habilitado, usa el Registro de modelos del área de trabajo.

2. Debes usar un recurso de proceso que tenga acceso al Unity Catalog. En el caso de las cargas de trabajo de ML, esto significa que el modo de acceso para el proceso debe ser Un solo usuario. Para obtener más información, vea Modos de acceso.

3. Para crear nuevos modelos registrados, necesitas los siguientes privilegios:

   • Los privilegios USE SCHEMA y USE CATALOG en el esquema y su catálogo adjunto.
   • Privilegio CREATE_MODEL sobre el esquema. Para conceder este privilegio, usa la interfaz de usuario del Explorador de catálogos o el siguiente comando SQL GRANT:

   GRANT CREATE_MODEL ON SCHEMA <schema-name> TO <principal>
   

Instalación y configuración del cliente de MLflow para Unity Catalog

En esta sección, se incluyen instrucciones para instalar y configurar el cliente de MLflow para el Unity Catalog.

Instalación del cliente de Python de MLflow

También puedes usar modelos de Unity Catalog en Databricks Runtime 11.3 LTS y versiones posteriores instalando la versión más reciente del cliente de Python de MLflow en tu cuaderno, con el siguiente código.

%pip install --upgrade "mlflow-skinny[databricks]"
dbutils.library.restartPython()

Configuración del cliente de MLflow para acceder a los modelos de Unity Catalog

Si el catálogo predeterminado del área de trabajo está en Unity Catalog (en lugar de hive_metastore) y ejecutas un clúster mediante Databricks Runtime 13.3 LTS o versiones posteriores (Databricks Runtime 15.0 ML o versiones posteriores en Azure China), los modelos se crean y cargan automáticamente en el catálogo predeterminado. No es necesario realizar este paso.

Para otros espacios de trabajo, el cliente de Python de MLflow crea modelos en el registro de modelos del área de trabajo de Databricks. Para actualizar a los modelos en Unity Catalog, usa el siguiente código en tus Notebook para configurar el cliente de MLflow:

import mlflow
mlflow.set_registry_uri("databricks-uc")

Para un pequeño número de áreas de trabajo en las que el catálogo predeterminado se configuró en un catálogo de Unity Catalog antes de enero de 2024 y el registro del modelo de área de trabajo se usó antes de enero de 2024, debes establecer manualmente el catálogo predeterminado en Catálogo de Unity con el comando mostrado anteriormente.

Entrenamiento y registro de modelos compatibles con el Unity Catalog

Permisos necesarios: para crear un nuevo modelo registrado, necesitas los privilegios CREATE_MODEL y USE SCHEMA en el esquema envolvente y el privilegio USE CATALOG en el catálogo envolvente. Para crear nuevas versiones de modelo a partir de un modelo registrado, debes ser el propietario del modelo registrado y tener los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo.

Las versiones del modelo ML en UC deben tener una firma de modelo. Si aún no registras modelos de MLflow con firmas en las cargas de trabajo de entrenamiento del modelo, puedes hacer lo siguiente:

• Usa el registro automático de Databricks, que registra automáticamente los modelos con firmas para muchos marcos de ML populares. Consulta los marcos admitidos en la documentación de MLflow.
• Con MLflow 2.5.0 y versiones posteriores, puede especificar un ejemplo de entrada en su llamada mlflow.<flavor>.log_model y la firma del modelo se deducirá automáticamente. Para más información, consulte la documentación de MLflow.

Después, pasa el nombre de tres niveles del modelo a las API de MLflow, con el formato <catalog>.<schema>.<model>.

Los ejemplos de esta sección crean y acceden a modelos en el ml_team esquema a partir del catálogo prod.

Los ejemplos de entrenamiento de modelos de esta sección crean una nueva versión del modelo y la registran en el catálogo prod. Utilizar el catálogo prod no significa necesariamente que la versión del modelo tenga tráfico de producción. El catálogo, el esquema y el modelo registrado de la versión del modelo reflejan su entorno (prod) y las reglas de gobernanza asociadas (por ejemplo, los privilegios se pueden configurar para que solo los administradores puedan eliminar en el catálogo prod), pero no su estado de implementación. Para administrar el estado de implementación, use alias de modelos.

Registro de un modelo en Unity Catalog mediante el registro automático

Para registrar una versión del modelo, usa el método register_model() de Client API de MLflow. Consulte mlflow.register_model.

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier

# Train a sklearn model on the iris dataset
X, y = datasets.load_iris(return_X_y=True, as_frame=True)
clf = RandomForestClassifier(max_depth=7)
clf.fit(X, y)

# Note that the UC model name follows the pattern
# <catalog_name>.<schema_name>.<model_name>, corresponding to
# the catalog, schema, and registered model name
# in Unity Catalog under which to create the version
# The registered model will be created if it doesn't already exist
autolog_run = mlflow.last_active_run()
model_uri = "runs:/{}/model".format(autolog_run.info.run_id)
mlflow.register_model(model_uri, "prod.ml_team.iris_model")

Inscripción de un modelo mediante la API

mlflow.register_model(
  "runs:/<run_uuid>/model", "prod.ml_team.iris_model"
)

Registre un modelo en Unity Catalog con firma deducida automáticamente

El soporte técnico para firmas deducidas automáticamente está disponible en la versión 2.5.0 de MLflow y versiones posteriores, y es compatible con Databricks Runtime 11.3 LTS ML y posteriores. Para usar firmas deducidas automáticamente, use el siguiente código para instalar el cliente de Python de MLflow más reciente en su cuaderno:

%pip install --upgrade "mlflow-skinny[databricks]"
dbutils.library.restartPython()

En el siguiente código se muestra un ejemplo de firma deducida automáticamente.

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier

with mlflow.start_run():
    # Train a sklearn model on the iris dataset
    X, y = datasets.load_iris(return_X_y=True, as_frame=True)
    clf = RandomForestClassifier(max_depth=7)
    clf.fit(X, y)
    # Take the first row of the training dataset as the model input example.
    input_example = X.iloc[[0]]
    # Log the model and register it as a new version in UC.
    mlflow.sklearn.log_model(
        sk_model=clf,
        artifact_path="model",
        # The signature is automatically inferred from the input example and its predicted output.
        input_example=input_example,
        registered_model_name="prod.ml_team.iris_model",
    )

Registro de un modelo mediante la interfaz de usuario

Siga estos pasos:

1. En la página de la ejecución experimental, haga clic en Registro del modelo en la esquina superior derecha de la interfaz de usuario.

2. En el cuadro de diálogo, seleccione Unity Catalog y seleccione un modelo de destino en la lista desplegable.

   

3. Haga clic en Registrar.

   

Registrar un modelo puede llevar un tiempo. Para supervisar el progreso, vaya al modelo de destino en Unity Catalog y actualice periódicamente.

Implementación de modelos mediante alias

Los alias de modelo permiten asignar una referencia mutable y nominal a una versión determinada dentro de un modelo registrado. Puede usar alias para indicar el estado de implementación de una versión de modelo. Por ejemplo, podría asignar un alias "Champion" a la versión de modelo actualmente en producción y dirigirse a este alias en cargas de trabajo que usan el modelo de producción. Puede actualizar el modelo de producción reasignando el alias "Champion" a otra versión del modelo.

Establecer y eliminar de alias en modelos

Permisos necesarios: ser propietario del modelo registrado, más los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo.

Puede establecer, actualizar y quitar alias para modelos en Unity Catalog mediante Catalog Explorer. Puede administrar alias en un modelo registrado en la página de detalles del modelo y configurar alias para una versión de modelo específica en la página de detalles de la versión del modelo.

Para establecer, actualizar y eliminar alias mediante la API de cliente de MLflow, consulte los siguientes ejemplos:

from mlflow import MlflowClient
client = MlflowClient()

# create "Champion" alias for version 1 of model "prod.ml_team.iris_model"
client.set_registered_model_alias("prod.ml_team.iris_model", "Champion", 1)

# reassign the "Champion" alias to version 2
client.set_registered_model_alias("prod.ml_team.iris_model", "Champion", 2)

# get a model version by alias
client.get_model_version_by_alias("prod.ml_team.iris_model", "Champion")

# delete the alias
client.delete_registered_model_alias("prod.ml_team.iris_model", "Champion")

Para saber más sobre las API de cliente de alias, consulta la documentación de la API de MLflow.

Carga de la versión del modelo por alias para cargas de trabajo de inferencia

Permisos necesarios: privilegio EXECUTE del modelo registrado, más los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo.

Las cargas de trabajo de inferencia por lotes pueden hacer referencia a una versión del modelo por alias. El siguiente fragmento de código carga y aplica la versión del modelo "Champion" para la inferencia por lotes. Si la versión "Champion" se actualiza para hacer referencia a una nueva versión del modelo, la carga de trabajo de inferencia por lotes la recoge automáticamente en su siguiente ejecución. Esto te permite desacoplar las implementaciones de modelos de las cargas de trabajo de inferencia por lotes.

import mlflow.pyfunc
model_version_uri = "models:/prod.ml_team.iris_model@Champion"
champion_version = mlflow.pyfunc.load_model(model_version_uri)
champion_version.predict(test_x)

Los puntos de conexión de servicio de modelos también pueden hacer referencia a una versión de modelo por alias. Puedes escribir flujos de trabajo de implementación para obtener una versión del modelo por alias y actualizar un punto de conexión de servicio de modelo para atender esa versión, mediante el modelo que sirve la API de REST. Por ejemplo:

import mlflow
import requests
client = mlflow.tracking.MlflowClient()
champion_version = client.get_model_version_by_alias("prod.ml_team.iris_model", "Champion")
# Invoke the model serving REST API to update endpoint to serve the current "Champion" version
model_name = champion_version.name
model_version = champion_version.version
requests.request(...)

Carga de versión de modelo por número de versión en cargas de trabajo de inferencia

También puedes cargar las versiones del modelo por número de versión:

import mlflow.pyfunc
# Load version 1 of the model "prod.ml_team.iris_model"
model_version_uri = "models:/prod.ml_team.iris_model/1"
first_version = mlflow.pyfunc.load_model(model_version_uri)
first_version.predict(test_x)

Uso compartido de modelos en áreas de trabajo

Uso compartido de modelos con usuarios de la misma región

Siempre que tenga los privilegios adecuados, puede acceder a los modelos en Unity Catalog desde cualquier área de trabajo que esté asociada al metastore que contiene el modelo. Por ejemplo, puedes acceder a los modelos desde el catálogo prod de un área de trabajo de desarrollo para facilitar la comparación de los modelos recién desarrollados con la línea base de producción.

Para colaborar con otros usuarios (compartir privilegios de escritura) en un modelo registrado que has creado, debes conceder la propiedad del modelo a un grupo en el que estés tú y los usuarios con los que quieres colaborar. Los colaboradores también deben tener los privilegios USE CATALOG y USE SCHEMA en el catálogo y el esquema que contiene el modelo. Consulta Privilegios de Unity Catalog y objetos protegibles para saber más.

Uso compartido de modelos con usuarios de otra región o cuenta

Para compartir modelos con usuarios de otras regiones o cuentas, use el flujo de uso compartido de Delta Flujo de uso compartido de Databricks a Databricks. Vea Agregar modelos a un recurso compartido (para proveedores) y Obtener acceso en el modelo de Databricks a Databricks (para destinatarios). Como destinatario, después de crear un catálogo a partir de un recurso compartido, se accede a los modelos de ese catálogo compartido de la misma manera que cualquier otro modelo en Unity Catalog.

Seguimiento del linaje de datos de un modelo en Unity Catalog

Al entrenar un modelo en una tabla de Unity Catalog, puedes realizar un seguimiento del linaje del modelo a los conjuntos de datos ascendentes en los que se entrenó y evaluó. Para ello, usa mlflow.log_input. Esto guarda la información de la tabla de entrada con la ejecución de MLflow que generó el modelo. El linaje de datos también se captura automáticamente para los modelos registrados mediante las API del almacén de características. Consulte Gobernanza y linaje de características.

Al registrar el modelo en Unity Catalog, la información de linaje se guarda automáticamente y está visible en la pestaña Linaje de la interfaz de usuario de la versión del modelo en el Explorador de catálogos.

El código siguiente muestra un ejemplo.

import mlflow
import pandas as pd
import pyspark.pandas as ps
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestRegressor

# Write a table to Unity Catalog
iris = load_iris()
iris_df = pd.DataFrame(iris.data, columns=iris.feature_names)
iris_df.rename(
  columns = {
    'sepal length (cm)':'sepal_length',
    'sepal width (cm)':'sepal_width',
    'petal length (cm)':'petal_length',
    'petal width (cm)':'petal_width'},
  inplace = True
)
iris_df['species'] = iris.target
ps.from_pandas(iris_df).to_table("prod.ml_team.iris", mode="overwrite")

# Load a Unity Catalog table, train a model, and log the input table
dataset = mlflow.data.load_delta(table_name="prod.ml_team.iris", version="0")
pd_df = dataset.df.toPandas()
X = pd_df.drop("species", axis=1)
y = pd_df["species"]
with mlflow.start_run():
    clf = RandomForestRegressor(n_estimators=100)
    clf.fit(X, y)
    mlflow.log_input(dataset, "training")
    # Take the first row of the training dataset as the model input example.
    input_example = X.iloc[[0]]
    # Log the model and register it as a new version in UC.
    mlflow.sklearn.log_model(
        sk_model=clf,
        artifact_path="model",
        # The signature is automatically inferred from the input example and its predicted output.
        input_example=input_example,
        registered_model_name="prod.ml_team.iris_classifier",
    )

Control del acceso a los modelos

En el catálogo de Unity, los modelos registrados son un subtipo del objeto protegible FUNCTION. Para conceder acceso a un modelo registrado en el catálogo de Unity, use GRANT ON FUNCTION. Para obtener más información, consulte Privilegios de Unity Catalog y objetos protegibles. Para conocer los procedimientos recomendados para organizar modelos entre catálogos y esquemas, consulte Organizar datos.

Puede configurar los permisos de modelo mediante programación mediante las Concesiones API de REST. Al configurar los permisos de modelo, establezca securable_type a "FUNCTION" en Solicitudes de API REST. Por ejemplo, utilice PATCH /api/2.1/unity-catalog/permissions/function/{full_name} para actualizar los permisos de modelo registrados.

Visualización de modelos en la UI

Permisos necesarios: para ver un modelo registrado y sus versiones de modelo en la IU, necesitas el privilegio EXECUTE en el modelo registrado, además de los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo

Puede establecer, actualizar y quitar alias para modelos en Unity Catalog usando Catalog Explorer.

Cambiar el nombre de un modelo

Permisos necesarios: ser propietario del modelo registrado, tener el privilegio CREATE_MODEL en el esquema que contiene el modelo registrado y los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo.

Para cambiar el nombre de un modelo inscrito, use el método rename_registered_model() de Client API de MLflow:

client=MlflowClient()
client.rename_registered_model("<full-model-name>", "<new-model-name>")

Copia de una versión del modelo

Puede copiar una versión de un modelo a otro en Unity Catalog.

Copia de una versión del modelo mediante la interfaz de usuario

Siga estos pasos:

1. En la página de la versión del modelo, haga clic en Copiar esta versión en la esquina superior derecha de la interfaz de usuario.

2. Seleccione un modelo de destino en la lista desplegable y haga clic en Copiar.

   

La copia de un modelo puede llevar tiempo. Para supervisar el progreso, vaya al modelo de destino en Unity Catalog y actualice periódicamente.

Copia de una versión del modelo mediante la API

Para copiar una versión del modelo, use la API de Python copy_model_version() de MLflow:

client = MlflowClient()
client.copy_model_version(
  "models:/<source-model-name>/<source-model-version>",
  "<destination-model-name>",
)

Eliminación de un modelo o una versión de un modelo

Permisos necesarios: ser propietario del modelo registrado, más los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo.

Puede eliminar un modelo registrado o una versión de modelo dentro de un modelo registrado mediante la IU de Catalog Explorer o la API.

Eliminación de una versión de un modelo o un modelo mediante la interfaz de usuario

Para eliminar un modelo o una versión del modelo en el Unity Catalog, sigue estos pasos.

1. En la página del modelo o la página de la versión del modelo, haz clic en el menú vertical de la esquina superior derecha.

   Desde la página modelos:

   

   Desde la página versión del modelo:

   

2. Seleccione Eliminar.

3. Aparece un cuadro de diálogo de confirmación. Haga clic en Delete (Eliminar) para confirmar.

Eliminación de una versión de un modelo o un modelo mediante la API

Para eliminar una versión del modelo, use el método delete_model_version() de Client API de MLflow:

# Delete versions 1,2, and 3 of the model
client = MlflowClient()
versions=[1, 2, 3]
for version in versions:
  client.delete_model_version(name="<model-name>", version=version)

Para eliminar un modelo, use el método delete_registered_model() de Client API de MLflow:

client = MlflowClient()
client.delete_registered_model(name="<model-name>")

Uso de etiquetas en modelos

Las etiquetas son pares clave-valor que se asocian a modelos registrados y versiones de modelo, permitiendo etiquetarlos y clasificarlos por función o estado. Por ejemplo, podría aplicar una etiqueta con clave "task" y valor "question-answering" (que se muestra en la UI como task:question-answering) a los modelos registrados destinados a las tareas de respuesta a preguntas. En el nivel de versión del modelo, podría etiquetar las versiones que se someten a la validación previa a la implementación con validation_status:pending y las desactivadas para la implementación con validation_status:approved.

Permisos necesarios: ser propietario o tener privilegio APPLY_TAG sobre el modelo registrado, más los privilegios USE SCHEMAy USE CATALOG en el esquema y el catálogo que contiene el modelo.

Consulte la sección Adición y actualización de etiquetas mediante Catalog Explorer para saber cómo establecer y eliminar etiquetas desde la interfaz de usuario.

Para establecer y eliminar etiquetas mediante la API de cliente de MLflow, consulte los siguientes ejemplos:

from mlflow import MlflowClient
client = MlflowClient()

# Set registered model tag
client.set_registered_model_tag("prod.ml_team.iris_model", "task", "classification")

# Delete registered model tag
client.delete_registered_model_tag("prod.ml_team.iris_model", "task")

# Set model version tag
client.set_model_version_tag("prod.ml_team.iris_model", "1", "validation_status", "approved")

# Delete model version tag
client.delete_model_version_tag("prod.ml_team.iris_model", "1", "validation_status")

Tanto las etiquetas de modelo registrado como las de versión de modelo deben cumplir las restricciones de toda la plataforma.

Para saber más sobre las API de cliente de etiquetas, consulta la documentación de la API de MLflow.

Agregar una descripción (comentarios) a un modelo o la versión de un modelo

Permisos necesarios: ser propietario del modelo registrado, más los privilegios USE SCHEMA y USE CATALOG en el esquema y el catálogo que contiene el modelo.

Puedes incluir una descripción de texto para cualquier modelo o versión del modelo en el Unity Catalog. Por ejemplo, puedes proporcionar información general del problema o información sobre la metodología y el algoritmo usados.

En el caso de los modelos, también tienes la opción de usar comentarios generados por IA. Consulte Adición de comentarios generados por IA a objetos de catálogo de Unity.

Agregar una descripción a un modelo mediante la interfaz de usuario

Para agregar una descripción para un modelo, puedes usar comentarios generados por IA o escribir tus propios comentarios. Puedes editar los comentarios generados por IA según sea necesario.

• Para agregar comentarios generados automáticamente, haz clic en elbotón Generar IA.
• Para agregar tus propios comentarios, haz clic en Agregar. Escribe tus comentarios en el cuadro de diálogo y haz clic en Guardar.

Adición de una descripción a una versión del modelo usando la interfaz de usuario

Para agregar una descripción a una versión de modelo en el Unity Catalog, sigue estos pasos:

1. En la página versión del modelo, haz clic en el icono de lápiz en Descripción.

   

2. Escribe tus comentarios en el cuadro de diálogo y haz clic en Guardar.

Adición de una descripción a un modelo o version del modelo mediante la API

Para actualizar la descripción de un modelo registrado, usa el método update_registered_model() de Client API de MLflow:

client = MlflowClient()
client.update_registered_model(
  name="<model-name>",
  description="<description>"
)

Para actualizar la descripción de una versión del modelo, use el método update_model_version() de Client API de MLflow:

client = MlflowClient()
client.update_model_version(
  name="<model-name>",
  version=<model-version>,
  description="<description>"
)

Enumerar y buscar modelos

Para obtener una enumeración de los modelos registrados en el Unity Catalog, usa la API de Python search_registered_models() de MLflow:

client=MlflowClient()
client.search_registered_models()

Para buscar un nombre de modelo específico y obtener información sobre las versiones de ese modelo, usa search_model_versions():

from pprint import pprint

client=MlflowClient()
[pprint(mv) for mv in client.search_model_versions("name='<model-name>'")]

Descargar archivos de modelo (caso de uso avanzado)

En la mayoría de los casos, para cargar modelos, debe usar las API de MLflow como mlflow.pyfunc.load_model o mlflow.<flavor>.load_model (por ejemplo, mlflow.transformers.load_model para los modelos HuggingFace).

En algunos casos, es posible que tenga que descargar archivos de modelo para depurar el comportamiento del modelo o los problemas de carga de modelos. Puede descargar archivos de modelo mediante mlflow.artifacts.download_artifacts, como se indica a continuación:

import mlflow
mlflow.set_registry_uri("databricks-uc")
model_uri = f"models:/{model_name}/{version}" # reference model by version or alias
destination_path = "/local_disk0/model"
mlflow.artifacts.download_artifacts(artifact_uri=model_uri, dst_path=destination_path)

Promover un modelo entre entornos

Databricks recomienda implementar canalizaciones de ML como código. Esto elimina la necesidad de promover modelos entre entornos, ya que todos los modelos de producción se pueden producir a través de flujos de trabajo de entrenamiento automatizados en un entorno de producción.

Sin embargo, en algunos casos, puede ser demasiado caro volver a entrenar modelos en entornos. En su lugar, puede copiar versiones de modelo en modelos registrados en Unity Catalog para promoverlas entre entornos.

Necesita los siguientes privilegios para ejecutar el código de ejemplo siguiente:

• USE CATALOG en los catálogostaging y prod.
• USE SCHEMA en los esquemas staging.ml_team y prod.ml_team.
• EXECUTEactivadostaging.ml_team.fraud_detection.

Además, debe ser el propietario del modelo registrado prod.ml_team.fraud_detection.

El siguiente fragmento de código usa la copy_model_version API de cliente de MLflow, que está disponible tanto en la versión 2.8.0 de en MLflow como en las posteriores.

import mlflow
mlflow.set_registry_uri("databricks-uc")

client = mlflow.tracking.MlflowClient()
src_model_name = "staging.ml_team.fraud_detection"
src_model_version = "1"
src_model_uri = f"models:/{src_model_name}/{src_model_version}"
dst_model_name = "prod.ml_team.fraud_detection"
copied_model_version = client.copy_model_version(src_model_uri, dst_model_name)

Una vez que la versión del modelo se encuentra en el entorno de producción, puede realizar cualquier validación previa a la implementación necesaria. A continuación, puede marcar la versión del modelo para la implementación mediante alias.

client = mlflow.tracking.MlflowClient()
client.set_registered_model_alias(name="prod.ml_team.fraud_detection", alias="Champion", version=copied_model_version.version)

En el ejemplo anterior, solo los usuarios que pueden leer desde el staging.ml_team.fraud_detection modelo registrado y escribir en el prod.ml_team.fraud_detection modelo registrado pueden promover modelos de ensayo al entorno de producción. Los mismos usuarios también pueden usar alias para administrar qué versiones de modelo se implementan en el entorno de producción. No es necesario configurar ninguna otra regla o directiva para regular la promoción y la implementación de modelos.

Puede personalizar este flujo para promover la versión del modelo en varios entornos que coincidan con la configuración, como dev, qa, y prod. El control de acceso es aplicado según lo configurado en cada entorno.

Ejemplo

Este ejemplo muestra cómo usar modelos del Unity Catalog para compilar una aplicación de aprendizaje automático.

Ejemplo de modelos en Unity Catalog

Migración de flujos de trabajo y modelos a Unity Catalog

Databricks recomienda usar Modelos en Unity Catalog para mejorar la gobernanza, facilitar el uso compartido entre áreas de trabajo y entornos, y flujos de trabajo de MLOps más flexibles. En la tabla se comparan las funcionalidades del registro de modelos del área de trabajo y el catálogo de Unity.

Funcionalidad	Registro de modelos del área de trabajo (heredado)	Modelos en el catálogo de Unity (recomendado)
Referencia de las versiones del modelo por alias con nombre	Fases del registro de modelos: mueva las versiones del modelo a una de las cuatro fases fijas para hacer referencia a ellas por esa fase. No se puede cambiar el nombre ni agregar fases.	Alias del registro de modelos: cree hasta 10 referencias con nombre personalizadas y reasignables a las versiones del modelo para cada modelo registrado.
Creación de entornos controlados por acceso para modelos	Fases del registro de modelos: use fases dentro de un modelo registrado para indicar el entorno de sus versiones de modelo, con controles de acceso solo para dos de las cuatro fases fijas (Staging y Production).	Modelos registrados: cree un modelo registrado para cada entorno en el flujo de trabajo de MLOps, utilizando espacios de nombres de tres niveles y permisos del catálogo de Unity para expresar la gobernanza.
Promoción de modelos entre entornos (implementar modelo)	Use la API de cliente de MLflow de transition_model_version_stage() para mover una versión de modelo a otra fase, lo que podría interrumpir los flujos de trabajo que hacen referencia a la fase anterior.	Use la API de cliente de MLflow de copy_model_version() para copiar una versión de modelo de un modelo registrado a otro.
Acceso y uso compartido de modelos entre áreas de trabajo	Exporte e importe manualmente modelos entre áreas de trabajo o configure conexiones a registros de modelos remotos mediante tokens de acceso personal y ámbitos secretos del área de trabajo.	Acceso de fábrica a los modelos entre áreas de trabajo de la misma cuenta. No requiere configuración.
Configuración de permisos	Establezca permisos en el nivel de área de trabajo.	Establezca permisos en el nivel de cuenta, que aplica una gobernanza coherente entre áreas de trabajo.
Obtención de acceso a los modelos de marketplace de Databricks	No disponible.	Cargue modelos desde el marketplace de Databricks en el metastore del catálogo de Unity y acceda a ellos entre áreas de trabajo.

Los artículos vinculados a continuación describen cómo migrar flujos de trabajo (trabajos de inferencia por lotes y entrenamiento de modelos) y modelos del registro de modelos del área de trabajo al catálogo de Unity.

• Actualizar flujos de trabajo de ML a modelos de destino en Unity Catalog
• Actualizar modelos a Unity Catalog

Limitaciones

• Las fases no son compatibles con los modelos en Unity Catalog. Databricks recomienda usar el espacio de nombres de tres niveles en Unity Catalog para expresar el entorno en el que se encuentra un modelo y usar alias para promover modelos que implementar. Vea Promover un modelo entre entornos para obtener más información.
• Los webhooks no son compatibles con modelos en Unity Catalog. Consulte alternativas en la guía de actualización.
• Algunos campos y operadores de API de búsqueda no son compatibles con modelos en Unity Catalog. Esto se puede mitigar llamando a las API de búsqueda con filtros admitidos y examinando los resultados. A continuación se muestran algunos ejemplos:
  • El order_by parámetro no se admite en las API de cliente search_model_versions o search_registered_models.
  • Los filtros basados en etiquetas (tags.mykey = 'myvalue') no son compatibles consearch_model_versions ni search_registered_models.
  • Los operadores distintos a la igualdad exacta (por ejemplo, LIKE, ILIKE, !=) no son compatibles consearch_model_versions o search_registered_models.
  • No se admite la búsqueda de modelos registrados por nombre (por ejemplo, MlflowClient().search_registered_models(filter_string="name='main.default.mymodel'")). Para recuperar un modelo registrado determinado por nombre, use get_registered_model.
• No se admiten en Unity Catalog ni emails con notificaciones ni hilos de comentarios sobre modelos registrados y versiones de modelos.
• El registro de actividad no es compatible con los modelos en Unity Catalog. Para realizar un seguimiento de la actividad en los modelos de Unity Catalog usa registros de auditoría.
• search_registered_models podría devolver resultados obsoletos para los modelos compartidos a través de Delta Sharing. Para garantizar los resultados más recientes, use la CLI de Databricks o SDK para enumerar los modelos de un esquema.