Gérer le cycle de vie des modèles dans Unity Catalog

Important

• Cet article documente les modèles dans Unity Catalog, que Databricks recommande pour la gouvernance et le déploiement de modèles. Si votre espace de travail n’est pas activé pour Unity Catalog, la fonctionnalité présentée sur cette page n’est pas disponible. En lieu et place, consultez l’article Gérer le cycle de vie du modèle au moyen du Registre des modèles d’espace de travail. Pour obtenir des conseils sur la mise à niveau du Registre de modèles d’espaces de travail vers Unity Catalog, consultez Migrer les flux de travail et les modèles vers Unity Catalog.
• Les modèles de Unity Catalog ne sont pas disponibles dans les régions Azure Government.

Cet article explique comment utiliser Models dans Unity Catalog dans le cadre de votre flux de travail de l’apprentissage automatique pour gérer le cycle de vie complet des modèles ML. Databricks fournit une version hébergée du registre de modèles MLflow dans Unity Catalog. Dans Unity Catalog, Models étend les avantages de Unity Catalog aux modèles ML, notamment le contrôle d’accès centralisé, l’audit, la traçabilité et la découverte de modèles dans les espaces de travail. Dans Unity Catalog, Models est compatible avec le client Python MLflow open source.

Les principales fonctionnalités des modèles dans Unity Catalog sont les suivantes :

• L’espacement des noms et la gouvernance des modèles, afin que vous puissiez regrouper et gouverner des modèles au niveau de l’environnement, du projet ou de l’équipe (« Accorder aux scientifiques des données un accès en lecture seule aux modèles de production »).
• Traçabilité chronologique du modèle (que le MLflow a essayé et que l’exécution a produit à un moment donné).
• Service de modèle.
• Contrôle de version de modèle.
• Le déploiement de modèles via des alias. Par exemple, marquez la version « Champion » d’un modèle dans votre catalogue prod.

Si le catalogue par défaut de votre espace de travail est configuré sur un catalogue dans Unity Catalog, les modèles inscrits à l’aide d’API MLflow tels que mlflow.<model-type>.log_model(..., registered_model_name) ou mlflow.register_model(model_uri, name) sont inscrits dans Unity Catalog par défaut.

Cet article contient des instructions pour les modèles dans l’interface utilisateur et l’API Unity Catalog.

Pour obtenir une vue d’ensemble des concepts du registre des modèles, consultez l’article Gestion de cycle de vie ML à l’aide de MLflow.

Spécifications

1. Unity Catalog doit être activé dans votre espace de travail. Consultez Prise en main d’Unity Catalog pour créer un metastore Unity Catalog, l’activer dans un espace de travail et créer un catalogue. Si Unity Catalog n’est pas activé, vous pouvez toujours utiliser le registre de modèles d’espace de travail classique.

2. Votre espace de travail doit être attaché à un metastore Unity Catalog qui prend en charge l’héritage des privilèges. Cela est vrai pour tous les metastores créés après le 25 août 2022. Si vous exécutez sur un metastore plus ancien, suivez la documentation pour effectuer la mise à niveau.

3. Vous devez disposer de l’accès pour exécuter des commandes sur un cluster avec accès à Unity Catalog.

4. Pour créer de nouveaux modèles inscrits, vous devez bénéficier du privilège CREATE_MODEL sur un schéma, en plus des privilèges USE SCHEMA et USE CATALOG sur le schéma et son catalogue englobant. CREATE_MODEL est un nouveau privilège au niveau du schéma que vous pouvez accorder à l’aide de l’interface utilisateur de Catalog Explorer ou de la commande SQL GRANT, comme indiqué ci-dessous.

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

Mettre à niveau les charges de travail d’apprentissage vers Unity Catalog

Cette section contient des instructions pour mettre à niveau les charges de travail d’apprentissage existantes vers Unity Catalog.

Installer le client Python MLflow

Vous pouvez également utiliser des modèles dans Unity Catalog sur Databricks Runtime 11.3 LTS et versions ultérieures en installant la dernière version du client Python MLflow dans votre notebook, à l’aide du code ci-dessous.

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

Configurer le client MLflow pour accéder aux modèles dans Unity Catalog

Par défaut, le client Python MLflow crée des modèles dans le registre de modèles d’espace de travail Databricks. Pour effectuer une mise à niveau vers des modèles dans Unity Catalog, configurez le client MLflow :

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

Remarque

Si le catalogue par défaut de votre espace de travail est dans Unity Catalog (et non pas dans hive_metastore) et que vous exécutez un cluster en utilisant Databricks Runtime 13.3 LTS ou ultérieur (Databricks Runtime 15.0 ou ultérieur dans les régions Azure Chine), les modèles sont automatiquement créés et chargés à partir du catalogue par défaut sans qu’aucune configuration ne soit requise. Il n’y a pas de changement de comportement pour les autres versions de Databricks Runtime. Un petit nombre d’espaces de travail où le catalogue par défaut a été configuré sur un catalogue Unity avant janvier 2024 et pour lesquels le registre du modèle d’espace de travail a été utilisé avant janvier 2024 sont exemptés de ce comportement.

Effectuer l’apprentissage et inscrire des modèles compatibles avec Unity Catalog

Autorisations requises : pour créer un modèle inscrit, vous avez besoin des privilèges CREATE_MODEL et USE SCHEMA sur le schéma englobant et USE CATALOG sur le catalogue englobant. Pour créer de nouvelles versions de modèle sous un modèle inscrit, vous devez être le propriétaire du modèle inscrit et disposer des privilèges USE SCHEMA et USE CATALOG sur le schéma et le catalogue contenant le modèle.

Les versions de modèle ML dans UC doivent avoir une signature de modèle. Si vous n’enregistrez pas déjà les modèles MLflow avec des signatures dans vos charges de travail d’apprentissage de modèle, vous pouvez procéder comme suit :

• Utilisez la journalisation automatique Databricks, qui enregistre automatiquement les modèles avec des signatures pour de nombreuses infrastructures ML populaires. Consultez les infrastructures prises en charge dans la documentation MLflow.
• Avec MLflow 2.5.0 et versions ultérieures, vous pouvez spécifier un exemple d’entrée dans votre appel mlflow.<flavor>.log_model, et la signature du modèle est inférée automatiquement. Pour plus d’informations, consultez la documentation MLflow.

Ensuite, transmettez le nom à trois niveaux du modèle aux API MLflow, sous la forme <catalog>.<schema>.<model>.

Les exemples de cette section créent des modèles, et y accèdent, dans le schéma ml_team sous le catalogue prod.

Les exemples d’apprentissage de modèles de cette section créent une version de modèle et l’inscrivent dans le catalogue prod. L’utilisation du catalogue prod ne signifie pas nécessairement que la version du modèle sert le trafic de production. Le catalogue englobant, le schéma et le modèle inscrit de la version du modèle reflètent son environnement (prod) et les règles de gouvernance associées (par exemple, des privilèges peuvent être configurés de sorte que seuls les administrateurs puissent supprimer du catalogue prod), mais pas son état de déploiement. Pour gérer les états de déploiement, utilisez des alias de modèle.

Inscrire un modèle dans Unity Catalog à l’aide de la journalisation automatique

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")

Inscrire un modèle dans Unity Catalog avec une signature inférée automatiquement

La prise en charge des signatures inférées automatiquement est disponible dans MLflow 2.5.0 et versions ultérieures, et prise en charge dans Databricks Runtime 11.3 LTS ML et versions ultérieures. Pour utiliser automatiquement les signatures inférées, utilisez le code suivant pour installer le dernier client Python MLflow dans votre notebook :

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

Le code suivant montre un exemple de signature inférée automatiquement.

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",
    )

Suivre la traçabilité des données d’un modèle dans Unity Catalog

Remarque

La prise en charge de la traçabilité des tables vers les modèles dans Unity Catalog est disponible dans MLflow 2.11.0 et ultérieur.

Quand vous effectuez l’apprentissage d’un modèle sur une table dans Unity Catalog, vous pouvez suivre la traçabilité du modèle vers le ou les jeux de données en amont sur lesquels il a effectué son apprentissage et a été évalué. Pour cela, utilisez mlflow.log_input. Ceci enregistre les informations des tables d’entrée avec l’exécution MLflow qui a généré le modèle. La traçabilité des données est également capturée automatiquement pour les modèles enregistrés en utilisant des API du magasin de fonctionnalités. Consultez Afficher la traçabilité du magasin de caractéristiques.

Quand vous inscrivez le modèle dans Unity Catalog, les informations de traçabilité sont automatiquement enregistrées et sont visibles dans l’onglet Traçabilité de l’interface utilisateur des versions du modèle dans Catalog Explorer.

Le code ci-après présente un exemple.

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")

Afficher des modèles dans l’interface utilisateur

Autorisations requises : pour afficher un modèle inscrit et ses versions de modèle dans l’interface utilisateur, vous avez besoin du privilège EXECUTE sur le modèle inscrit, ainsi que des privilèges USE SCHEMA et USE CATALOG sur le schéma et le catalogue contenant le modèle

Vous pouvez afficher et gérer les modèles inscrits et les versions de modèles dans Unity Catalog à l’aide de Catalog Explorer.

Contrôler l’accès aux modèles

Pour plus d’informations sur le contrôle de l’accès aux modèles inscrits dans Unity Catalog, consultez Privilèges Unity Catalog et objets sécurisables. Pour connaître les meilleures pratiques relatives à l’organisation des modèles entre catalogues et schémas, consultez Organiser vos données.

Vous pouvez configurer des autorisations de modèle par programmation à l’aide de l’API REST Grants. Lors de la configuration des autorisations de modèle, définissez securable_type sur "FUNCTION" dans les requêtes d’API REST. Par exemple, utilisez PATCH /api/2.1/unity-catalog/permissions/function/{full_name} pour mettre à jour les autorisations de modèle inscrites.

Déployer et organiser des modèles avec des alias et des étiquettes

Les alias de modèle et les balises vous aident à organiser et à gérer les modèles dans Unity Catalog.

Les alias de modèle vous permettent d’affecter une référence nommée mutable à une version particulière d’un modèle inscrit. Vous pouvez utiliser des alias pour indiquer l’état de déploiement d’une version de modèle. Par exemple, vous pouvez allouer un alias « Champion » à la version du modèle actuellement en production et cibler cet alias dans les charges de travail qui utilisent le modèle de production. Vous pouvez ensuite mettre à jour le modèle de production en réaffectant l’alias « Champion » à une autre version du modèle.

Les balises sont des paires clé-valeur que vous associez aux modèles inscrits et aux versions de modèle, ce qui vous permet de les étiqueter et de les classer par fonction ou état. Par exemple, vous pouvez appliquer une balise avec la clé "task" et la valeur "question-answering" (affichées dans l’interface utilisateur sous la forme task:question-answering) aux modèles inscrits destinés aux tâches de réponses aux questions. Au niveau de la version du modèle, vous pouvez affecter la balise validation_status:pending aux versions en cours de validation avant le déploiement et la balise validation_status:approved à celles qui sont approuvées pour le déploiement.

Consultez les sections suivantes pour savoir comment utiliser des alias et des balises.

Définir et supprimer des alias sur les modèles

Autorisations requises : propriétaire du modèle inscrit, ainsi que les privilèges USE SCHEMA et USE CATALOG sur le schéma et le catalogue contenant le modèle.

Vous pouvez définir, mettre à jour et supprimer des alias pour les modèles dans Unity Catalog à l’aide de Catalog Explorer. Vous pouvez gérer les alias sur un modèle inscrit sur la page des détails du modèle et configurer des alias pour une version de modèle spécifique dans la page des détails de version du modèle.

Pour définir, mettre à jour et supprimer des alias à l’aide de l’API cliente MLflow, consultez les exemples ci-dessous :

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")

Définir et supprimer des balises sur les modèles

Autorisations requises : propriétaire ou le privilège APPLY_TAG sur le modèle inscrit, ainsi que les privilèges USE SCHEMA et USE CATALOG sur le schéma et le catalogue contenant le modèle.

Consultez Gérer les balises dans Catalog Explorer pour savoir comment définir et supprimer des balises à l’aide de l’interface utilisateur.

Pour définir et supprimer des balises à l’aide de l’API cliente MLflow, consultez les exemples ci-dessous :

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")

Les balises de modèle inscrit et de version de modèle doivent respecter les contraintes à l’échelle de la plateforme.

Pour plus d’informations sur les API clientes d’alias et de balise, consultez la documentation de l’API MLflow.

Charger des modèles pour l’inférence

Utiliser des versions de modèle par alias dans les charges de travail d’inférence

Autorisations requises : privilège EXECUTE sur le modèle inscrit, ainsi que les privilèges USE SCHEMAet USE CATALOG sur le schéma et le catalogue contenant le modèle.

Vous pouvez écrire des charges de travail d’inférence par lots qui référencent une version de modèle par alias. Par exemple, l’extrait de code ci-dessous charge et applique la version du modèle « Champion » pour l’inférence par lots. Si la version « Champion » est mise à jour pour référencer une nouvelle version du modèle, la charge de travail d’inférence par lots la sélectionne automatiquement lors de sa prochaine exécution. Cela vous permet de dissocier les déploiements de modèles de vos charges de travail d’inférence par lots.

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)

Vous pouvez également écrire des flux de travail de déploiement pour obtenir une version de modèle par alias et mettre à jour un point de terminaison de service de modèle pour traiter cette version, à l’aide de l’API REST du modèle de service :

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(...)

Utiliser des versions de modèle par numéro de version dans les charges de travail d’inférence

Vous pouvez également charger des versions de modèle par numéro de version :

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)

Partager des modèles dans des espaces de travail

Partager des modèles avec des utilisateurs dans la même région

Tant que vous disposez des privilèges appropriés, vous pouvez accéder aux modèles dans Unity Catalog à partir de n’importe quel espace de travail attaché au metastore contenant le modèle. Par exemple, vous pouvez accéder aux modèles à partir du catalogue prod dans un espace de travail de développement, pour faciliter la comparaison des modèles récemment développés avec la base de référence de production.

Pour collaborer avec d’autres utilisateurs (partage de privilèges d’écriture) sur un modèle inscrit que vous avez créé, vous devez accorder la propriété du modèle à un groupe qui inclut les utilisateurs avec lesquels vous souhaitez collaborer et vous-même. Les collaborateurs doivent également disposer des privilèges USE CATALOG et USE SCHEMA sur le catalogue et le schéma contenant le modèle. Consultez Privilèges Unity Catalog et objets sécurisables.

Partager des modèles avec des utilisateurs dans une autre région ou un autre compte

Pour partager des modèles avec des utilisateurs dans d’autres régions ou comptes, utilisez le flux de partage Databricks-à-Databricksde Delta Sharing. Consultez Ajouter des modèles à un partage (pour les fournisseurs) et Accéder au modèle Databricks-à-Databricks (pour les destinataires). En tant que destinataire, après votre création de catalogue à partir d’un partage, vous accédez à des modèles dans ce catalogue partagé de la même façon que tout autre modèle dans Unity Catalog.

Annoter un modèle ou une version de modèle

Autorisations requises : propriétaire du modèle inscrit, ainsi que les privilèges USE SCHEMA et USE CATALOG sur le schéma et le catalogue contenant le modèle.

Vous pouvez fournir des informations sur un modèle ou une version de modèle en l’annotant. Par exemple, vous pouvez souhaiter inclure une vue d’ensemble du problème ou des informations sur la méthodologie et l’algorithme employés.

Annoter un modèle ou une version de modèle à l’aide de l’interface utilisateur

Consultez Documenter des données dans l’Explorateur de catalogues à l’aide de commentaires Markdown.

Annoter un modèle ou une version de modèle à l’aide de l’API

Pour mettre à jour la description du modèle enregistré, utilisez la méthode update_registered_model() de l’API cliente MLflow :

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

Pour mettre à jour la description d’une version de modèle, utilisez la méthode update_model_version() de l’API cliente MLflow :

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

Renommer un modèle (API uniquement)

Autorisations requises : propriétaire du modèle inscrit, privilège CREATE_MODEL sur le schéma contenant le modèle inscrit ainsi que les privilèges USE SCHEMA et USE CATALOG sur le schéma et le catalogue contenant le modèle.

Pour renommer un modèle inscrit, utilisez la méthode rename_registered_model() de l’API cliente MLflow :

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

Supprimer un modèle ou une version de modèle

Autorisations requises : propriétaire du modèle inscrit, ainsi que les privilèges USE SCHEMA et USE CATALOG sur le schéma et le catalogue contenant le modèle.

Vous pouvez supprimer un modèle inscrit ou une version de modèle dans un modèle inscrit à l’aide de l’interface utilisateur Catalog Explorer ou de l’API.

Supprimer une version de modèle ou un modèle à l’aide de l’API

Avertissement

Vous ne pouvez pas annuler cette action. Quand vous supprimez un modèle, tous les artefacts de modèle stockés par Unity Catalog sont supprimés, de même que toutes les métadonnées associées au modèle inscrit.

Supprimer une version de modèle

Pour supprimer une version de modèle, utilisez la méthode delete_model_version() de l’API cliente 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)

Supprimer un modèle

Pour supprimer un modèle, utilisez la méthode delete_registered_model() de l’API cliente MLflow :

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

Modèles de liste et de recherche

Vous pouvez répertorier les modèles inscrits dans Unity Catalog avec l’API Python search_registered_models() de MLflow :

client=MlflowClient()
client.search_registered_models()

Vous pouvez aussi rechercher un nom de modèle spécifique et lister les détails de ses versions en utilisant la méthode search_model_versions() :

from pprint import pprint

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

Exemple

Cet exemple montre comment utiliser des modèles dans Unity Catalog pour créer une application d’apprentissage automatique.

Modèles dans Unity Catalog, exemple

Migrer des flux de travail et des modèles vers Unity Catalog

Databricks recommande d’utiliser des modèles dans Unity Catalog pour une meilleure gouvernance, un partage facile entre les espaces de travail et les environnements, et des workflows MLOps plus flexibles. Le tableau compare les fonctionnalités du registre de modèles d’espace de travail et de Unity Catalog.

Fonctionnalité	Registre de modèles d’espaces de travail (hérité)	Modèles dans Unity Catalog (recommandé)
Versions de modèle de référence par alias nommés	Phases du Registre de modèles : déplacez les versions de modèle vers l’une des quatre phases fixes pour les référencer à cette phase. Impossible de renommer ou d’ajouter des phases.	Alias du Registre de modèles : créez jusqu’à 10 références nommées personnalisées et réattribuables aux versions de modèle pour chaque modèle inscrit.
Créer des environnements contrôlés par l’accès pour les modèles	Phases du Registre de modèles : utilisez des étapes au sein d’un modèle inscrit pour désigner l’environnement de ses versions de modèle, avec des contrôles d’accès pour seulement deux des quatre phases fixes (Staging et Production).	Modèles inscrits : créez un modèle inscrit pour chaque environnement dans votre flux de travail MLOps, en utilisant des espaces de noms et des autorisations de trois niveaux de Unity Catalog pour exprimer la gouvernance.
Promouvoir des modèles dans des environnements (déployer un modèle)	Utilisez l’API cliente MLflow transition_model_version_stage() pour déplacer une version de modèle vers une autre étape, potentiellement des flux de travail cassants qui référencent l’étape précédente.	Utilisez l’API cliente MLflow copy_model_version() pour copier une version de modèle d’un modèle inscrit vers un autre.
Accéder et partager des modèles entre les espaces de travail	Exportez et importez manuellement des modèles entre des espaces de travail ou configurez des connexions à des registres de modèles distants à l’aide de jetons d’accès personnels et d’étendues secrètes d’espace de travail.	Accès prêt à l’emploi aux modèles entre les espaces de travail du même compte. Aucune configuration n’est requise.
Configurer les autorisations	Définissez les autorisations au niveau de l’espace de travail.	Définissez des autorisations au niveau du compte, qui applique une gouvernance cohérente entre les espaces de travail.
Accéder aux modèles dans la Place de marché Databricks	Non disponible.	Chargez des modèles à partir de la Place de marché Databricks dans votre metastore Unity Catalog et accédez-y entre les espaces de travail.

Les articles liés ci-dessous décrivent comment migrer des flux de travail (apprentissage de modèle et travaux d’inférence par lots) et des modèles du Registre de modèles d’espaces de travail vers Unity Catalog.

• Mettre à niveau des workflows ML en modèles cibles dans Unity Catalog
• Mettre à niveau des modèles vers Unity Catalog

Limitations concernant la prise en charge de Unity Catalog

• Les étapes ne sont pas prises en charge pour les modèles dans Unity Catalog. Databricks recommande d’utiliser l’espace de noms à trois niveaux dans Unity Catalog pour exprimer l’environnement dans lequel se trouve un modèle et d’utiliser des alias pour promouvoir des modèles pour le déploiement. Pour plus d’informations, consultez le guide de mise à niveau.
• Les webhooks ne sont pas pris en charge pour les modèles dans Unity Catalog. Consultez les alternatives suggérées dans le guide de mise à niveau.
• Certains champs et opérateurs d’API de recherche ne sont pas pris en charge pour les modèles dans Unity Catalog. Vous pouvez atténuer ce problème en appelant les API de recherche à l’aide de filtres pris en charge et en analysant les résultats. Voici quelques exemples :
  • Le paramètre order_by n’est pas pris en charge dans les API clientes search_model_versions ou search_registered_models.
  • Les filtres basés sur des balises (tags.mykey = 'myvalue') ne sont pas pris en charge pour search_model_versions ou search_registered_models.
  • Les opérateurs autres que l’égalité exacte (par exemple, LIKE, ILIKE, !=) ne sont pas pris en charge pour search_model_versions ou search_registered_models.
  • La recherche de modèles inscrits par nom (par exemple, MlflowClient().search_registered_models(filter_string="name='main.default.mymodel'") n’est pas prise en charge. Pour extraire un modèle inscrit particulier par son nom, utilisez get_registered_model.
• Les notifications par e-mail et les threads de discussion de commentaires sur les modèles inscrits et les versions de modèle ne sont pas pris en charge dans Unity Catalog.
• Le journal d’activité n’est pas pris en charge pour les modèles dans Unity Catalog. Toutefois, vous pouvez suivre l’activité sur les modèles dans Unity Catalog à l’aide des journaux d’audit.
• search_registered_models peut retourner des résultats obsolètes pour les modèles partagés via Delta Sharing. Pour garantir les résultats les plus récents, utilisez l’interface CLI Databricks ou le Kit de développement logiciel (SDK) pour répertorier les modèles dans un schéma.