Gestire il ciclo di vita del modello nel catalogo unity

  • Articolo

Importante

Questo articolo descrive come usare Modelli in Unity Catalog come parte del flusso di lavoro di Machine Learning per gestire il ciclo di vita completo dei modelli di Machine Learning. Databricks offre una versione ospitata di MLflow Model Registry nel catalogo unity. I modelli in Unity Catalog estendono i vantaggi di Unity Catalog ai modelli di Machine Learning, inclusi il controllo di accesso centralizzato, il controllo, la derivazione e l'individuazione dei modelli nelle aree di lavoro. I modelli in Unity Catalog sono compatibili con il client Python MLflow open source.

Le funzionalità principali dei modelli nel catalogo unity includono:

  • Nomipacing e governance per i modelli, in modo da poter raggruppare e gestire i modelli a livello di ambiente, progetto o team ("Concedere ai data scientist l'accesso in sola lettura ai modelli di produzione").
  • Derivazione cronologica del modello (esperimento MLflow ed esecuzione ha prodotto il modello in un determinato momento).
  • Modello di gestione.
  • Controllo delle versioni del modello.
  • Distribuzione del modello tramite alias. Ad esempio, contrassegnare la versione "Campione" di un modello all'interno del prod catalogo.

Se il catalogo predefinito dell'area di lavoro è configurato in un catalogo in Unity Catalog, per impostazione predefinita i modelli registrati tramite API MLflow, mlflow.<model-type>.log_model(..., registered_model_name) ad esempio o mlflow.register_model(model_uri, name) vengono registrati nel catalogo Unity.

Questo articolo include istruzioni sia per i modelli nell'interfaccia utente del catalogo unity che per l'API.

Per una panoramica dei concetti relativi al Registro modelli, vedere Gestione del ciclo di vita di Ml con MLflow.

Requisiti

  1. Il catalogo unity deve essere abilitato nell'area di lavoro. Vedere Introduzione all'uso di Unity Catalog per creare un metastore del catalogo Unity, abilitarlo in un'area di lavoro e creare un catalogo. Se Il catalogo unity non è abilitato, è comunque possibile usare il registro dei modelli di area di lavoro classico.

  2. L'area di lavoro deve essere collegata a un metastore del catalogo Unity che supporta l'ereditarietà dei privilegi. Questo vale per tutti i metastore creati dopo il 25 agosto 2022. Se in esecuzione in un metastore precedente, seguire la documentazione per eseguire l'aggiornamento.

  3. È necessario avere accesso per eseguire i comandi in un cluster con accesso a Unity Catalog.

  4. Per creare nuovi modelli registrati, è necessario disporre dei CREATE_MODEL privilegi per uno schema, oltre ai USE SCHEMA privilegi e USE CATALOG per lo schema e al relativo catalogo di inclusione. CREATE_MODEL è un nuovo privilegio a livello di schema che è possibile concedere usando l'interfaccia utente di Esplora cataloghi o il comando SQL GRANT, come illustrato di seguito.

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

Aggiornare i carichi di lavoro di training a Unity Catalog

Questa sezione include istruzioni per aggiornare i carichi di lavoro di training esistenti a Unity Catalog.

Installare il client Python MLflow

È anche possibile usare i modelli in Unity Catalog in Databricks Runtime 11.3 LTS e versioni successive installando la versione più recente del client Python MLflow nel notebook usando il codice seguente.

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

Configurare il client MLflow per accedere ai modelli nel catalogo unity

Per impostazione predefinita, il client Python MLflow crea modelli nel registro dei modelli dell'area di lavoro di Databricks. Per eseguire l'aggiornamento ai modelli in Unity Catalog, configurare il client MLflow:

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

Nota

Se il catalogo predefinito dell'area di lavoro si trova in Unity Catalog (anziché hive_metastore) ed è in esecuzione un cluster usando Databricks Runtime 13.3 LTS o versione successiva (Databricks Runtime 15.0 o versione successiva nelle aree di Azure Cina), i modelli vengono creati automaticamente e caricati dal catalogo predefinito, senza alcuna configurazione necessaria. Non sono state apportate modifiche al comportamento per altre versioni di Databricks Runtime. Un numero ridotto di aree di lavoro in cui il catalogo predefinito è stato configurato per un catalogo in Unity Catalog prima di gennaio 2024 e il registro dei modelli di area di lavoro è stato usato prima di gennaio 2024 sono esenti da questo comportamento.

Eseguire il training e la registrazione di modelli compatibili con Unity Catalog

Autorizzazioni necessarie: per creare un nuovo modello registrato, sono necessari i CREATE_MODEL privilegi e USE SCHEMA per lo schema di inclusione e USE CATALOG il privilegio nel catalogo contenitore. Per creare nuove versioni del modello in un modello registrato, è necessario essere il proprietario del modello registrato e disporre USE SCHEMAUSE CATALOG dei privilegi e dello schema e del catalogo contenente il modello.

Le versioni del modello ml in UC devono avere una firma del modello. Se non si registrano già modelli MLflow con firme nei carichi di lavoro di training del modello, è possibile:

  • Usare l'assegnazione automatica di databricks, che registra automaticamente i modelli con firme per molti framework di Machine Learning più diffusi. Vedere framework supportati nella documentazione di MLflow.
  • Con MLflow 2.5.0 e versioni successive, è possibile specificare un esempio di input nella mlflow.<flavor>.log_model chiamata e la firma del modello viene dedotta automaticamente. Per altre informazioni, vedere la documentazione di MLflow.

Passare quindi il nome a tre livelli del modello alle API MLflow, nel formato <catalog>.<schema>.<model>.

Gli esempi in questa sezione creano e accedono ai modelli nello ml_team schema nel prod catalogo.

Gli esempi di training del modello in questa sezione creano una nuova versione del modello e la registrano nel prod catalogo. L'uso del prod catalogo non significa necessariamente che la versione del modello gestisce il traffico di produzione. La versione del modello che racchiude il catalogo, lo schema e il modello registrato riflettono il relativo ambiente (prod) e le regole di governance associate (ad esempio, i privilegi possono essere configurati in modo che solo gli amministratori possano eliminare dal prod catalogo), ma non il relativo stato di distribuzione. Per gestire lo stato della distribuzione, usare gli alias del modello.

Registrare un modello in Unity Catalog usando l'assegnazione automatica

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

Registrare un modello in Unity Catalog con firma dedotta automaticamente

Il supporto per le firme dedotte automaticamente è disponibile in MLflow versione 2.5.0 e successive ed è supportato in Databricks Runtime 11.3 LTS ML e versioni successive. Per usare firme dedotte automaticamente, usare il codice seguente per installare il client Python MLflow più recente nel notebook:

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

Il codice seguente mostra un esempio di firma dedotta automaticamente.

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

Tenere traccia della derivazione dei dati di un modello in Unity Catalog

Nota

Il supporto per la derivazione da tabella a modello in Unity Catalog è disponibile in MLflow 2.11.0 e versioni successive.

Quando si esegue il training di un modello in una tabella in Unity Catalog, è possibile tenere traccia della derivazione del modello nei set di dati upstream su cui è stato eseguito il training e la valutazione. A tale scopo, usare mlflow.log_input. In questo modo vengono salvate le informazioni della tabella di input con l'esecuzione MLflow che ha generato il modello. La derivazione dei dati viene acquisita automaticamente anche per i modelli registrati usando le API dell'archivio funzionalità. Vedere Visualizzare la derivazione dell'archivio funzionalità.

Quando si registra il modello in Unity Catalog, le informazioni di derivazione vengono salvate automaticamente ed è visibile nella scheda Derivazione dell'interfaccia utente della versione del modello in Esplora cataloghi.

Il seguente codice illustra un esempio.

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

Visualizzare i modelli nell'interfaccia utente

Autorizzazioni necessarie: per visualizzare un modello registrato e le relative versioni del modello nell'interfaccia utente, è necessario EXECUTE disporre dei privilegi per il modello registrato, oltre USE SCHEMAUSE CATALOG ai privilegi per lo schema e il catalogo contenente il modello

È possibile visualizzare e gestire i modelli registrati e le versioni dei modelli nel catalogo unity usando Esplora cataloghi.

Controllare l'accesso ai modelli

Per informazioni sul controllo dell'accesso ai modelli registrati in Unity Catalog, vedere Privilegi del catalogo Unity e oggetti a protezione diretta. Per le procedure consigliate per organizzare i modelli tra cataloghi e schemi, vedere Organizzare i dati.

È possibile configurare le autorizzazioni del modello a livello di codice usando l'API REST Grant. Quando si configurano le autorizzazioni del modello, impostare su securable_type"FUNCTION" nelle richieste dell'API REST. Ad esempio, usare PATCH /api/2.1/unity-catalog/permissions/function/{full_name} per aggiornare le autorizzazioni del modello registrato.

Distribuire e organizzare i modelli con alias e tag

Gli alias e i tag del modello consentono di organizzare e gestire i modelli nel catalogo unity.

Gli alias del modello consentono di assegnare un riferimento modificabile denominato a una determinata versione di un modello registrato. È possibile usare alias per indicare lo stato di distribuzione di una versione del modello. Ad esempio, è possibile allocare un alias "Champion" alla versione del modello attualmente in produzione e impostare come destinazione questo alias nei carichi di lavoro che usano il modello di produzione. È quindi possibile aggiornare il modello di produzione riassegnando l'alias "Champion" a una versione del modello diversa.

I tag sono coppie chiave-valore associate a modelli registrati e versioni del modello, consentendo di etichettarli e classificarli in base alla funzione o allo stato. Ad esempio, è possibile applicare un tag con chiave "task" e valore "question-answering" (visualizzato nell'interfaccia utente come task:question-answering) ai modelli registrati destinati alle attività di risposta alle domande. A livello di versione del modello, è possibile contrassegnare le versioni in fase di convalida pre-distribuzione con validation_status:pending e quelle cancellate per la distribuzione con validation_status:approved.

Vedere le sezioni seguenti per informazioni su come usare alias e tag.

Impostare ed eliminare alias nei modelli

Autorizzazioni necessarie: proprietario del modello registrato, oltre USE SCHEMAUSE CATALOG ai privilegi per lo schema e il catalogo che contiene il modello.

È possibile impostare, aggiornare e rimuovere alias per i modelli nel catalogo unity usando Esplora cataloghi. È possibile gestire gli alias in un modello registrato nella pagina dei dettagli del modello e configurare gli alias per una versione specifica del modello nella pagina dei dettagli della versione del modello.

Per impostare, aggiornare ed eliminare alias usando l'API client MLflow, vedere gli esempi seguenti:

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

Impostare ed eliminare tag nei modelli

Autorizzazioni necessarie: proprietario di o dispongono APPLY_TAG dei privilegi per il modello registrato, oltre USE SCHEMAUSE CATALOG ai privilegi per lo schema e il catalogo contenente il modello.

Vedere Gestire i tag in Esplora cataloghi per informazioni su come impostare ed eliminare tag usando l'interfaccia utente.

Per impostare ed eliminare tag usando l'API client MLflow, vedere gli esempi seguenti:

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

I tag di versione del modello e del modello registrati devono soddisfare i vincoli a livello di piattaforma.

Per altri dettagli sulle API client alias e tag, vedere la documentazione dell'API MLflow.

Caricare modelli per l'inferenza

Usare le versioni del modello in base all'alias nei carichi di lavoro di inferenza

Autorizzazioni necessarie: EXECUTE privilegi per il modello registrato, oltre USE SCHEMAUSE CATALOG ai privilegi per lo schema e il catalogo che contiene il modello.

È possibile scrivere carichi di lavoro di inferenza batch che fanno riferimento a una versione del modello in base all'alias. Ad esempio, il frammento seguente carica e applica la versione del modello "Campione" per l'inferenza batch. Se la versione "Campione" viene aggiornata per fare riferimento a una nuova versione del modello, il carico di lavoro di inferenza batch lo preleva automaticamente alla successiva esecuzione. In questo modo è possibile separare le distribuzioni di modelli dai carichi di lavoro di inferenza batch.

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)

È anche possibile scrivere flussi di lavoro di distribuzione per ottenere una versione del modello in base all'alias e aggiornare un endpoint del modello che serve tale versione usando l'API REST del modello:

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

Usare le versioni del modello in base al numero di versione nei carichi di lavoro di inferenza

È anche possibile caricare le versioni del modello in base al numero di versione:

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)

Condividere modelli tra le aree di lavoro

Condividere modelli con gli utenti nella stessa area

Se si hanno i privilegi appropriati, è possibile accedere ai modelli in Unity Catalog da qualsiasi area di lavoro collegata al metastore contenente il modello. Ad esempio, è possibile accedere ai modelli dal catalogo in un'area prod di lavoro di sviluppo per facilitare il confronto dei modelli appena sviluppati con la baseline di produzione.

Per collaborare con altri utenti (condividere privilegi di scrittura) su un modello registrato creato, è necessario concedere la proprietà del modello a un gruppo contenente se stessi e agli utenti con cui si vuole collaborare. I collaboratori devono avere anche i USE CATALOG privilegi e USE SCHEMA per il catalogo e lo schema che contiene il modello. Per informazioni dettagliate, vedere Privilegi del catalogo Unity e oggetti a protezione diretta.

Condividere modelli con utenti in un'altra area o account

Per condividere modelli con utenti in altre aree o account, usare il flusso di condivisione delta di Databricks a Databricks. Vedere Aggiungere modelli a una condivisione (per i provider) e Ottenere l'accesso nel modello da Databricks a Databricks (per i destinatari). Come destinatario, dopo aver creato un catalogo da una condivisione, si accede ai modelli in tale catalogo condiviso allo stesso modo di qualsiasi altro modello in Unity Catalog.

Annotare un modello o una versione del modello

Autorizzazioni necessarie: proprietario del modello registrato, oltre USE SCHEMAUSE CATALOG ai privilegi per lo schema e il catalogo che contiene il modello.

È possibile fornire informazioni su un modello o una versione del modello mediante le annotazioni. È ad esempio possibile che si voglia includere una panoramica del problema o informazioni sulla metodologia e sull'algoritmo usato.

Annotare un modello o una versione del modello usando l'interfaccia utente

Vedere Document data in Catalog Explorer using markdown comments (Visualizzare i dati dei documenti in Esplora cataloghi usando i commenti markdown).

Annotare un modello o una versione del modello usando l'API

Per aggiornare una descrizione del modello registrato, usare il metodo API update_registered_model() client MLflow:

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

Per aggiornare la descrizione di una versione del modello, usare il metodo update_model_version() dell'API MLflow Client:

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

Rinominare un modello (solo API)

Autorizzazioni necessarie: proprietario del modello registrato, CREATE_MODEL privilegio per lo schema contenente il modello registrato e USE SCHEMAUSE CATALOG privilegi per lo schema e il catalogo contenente il modello.

Per rinominare un modello registrato, usare il metodo rename_registered_model() dell'API MLflow Client:

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

Eliminare un modello o una versione del modello

Autorizzazioni necessarie: proprietario del modello registrato, oltre USE SCHEMAUSE CATALOG ai privilegi per lo schema e il catalogo che contiene il modello.

È possibile eliminare un modello registrato o una versione del modello all'interno di un modello registrato usando l'interfaccia utente di Esplora cataloghi o l'API.

Eliminare una versione del modello o un modello usando l'API

Avviso

Non è possibile annullare questa azione. Quando si elimina un modello, tutti gli artefatti del modello archiviati dal catalogo unity e tutti i metadati associati al modello registrato vengono eliminati.

Eliminare una versione del modello

Per eliminare una versione del modello, usare il metodo delete_model_version() dell'API MLflow Client:

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

Elimina un modello

Per eliminare un modello, usare il metodo delete_registered_model() dell'API MLflow Client:

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

Elencare e cercare modelli

È possibile elencare i modelli registrati nel catalogo unity con l'API Python search_registered_models() di MLflow:

client=MlflowClient()
client.search_registered_models()

È anche possibile cercare un nome di modello specifico ed elencarne i dettagli della versione usando il search_model_versions() metodo :

from pprint import pprint

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

Esempio

Questo esempio illustra come usare i modelli nel catalogo unity per creare un'applicazione di Machine Learning.

Esempio di modelli nel catalogo Unity

Eseguire la migrazione di flussi di lavoro e modelli a Unity Catalog

Databricks consiglia di usare modelli in Unity Catalog per migliorare la governance, semplificare la condivisione tra aree di lavoro e ambienti e flussi di lavoro MLOps più flessibili. La tabella confronta le funzionalità del Registro dei modelli di area di lavoro e del catalogo Unity.

Funzionalità Registro modelli dell'area di lavoro (legacy) Modelli nel catalogo unity (scelta consigliata)
Fare riferimento alle versioni del modello in base a alias denominati Fasi del Registro modelli: spostare le versioni del modello in una delle quattro fasi fisse per farvi riferimento da tale fase. Impossibile rinominare o aggiungere fasi. Alias del Registro di sistema dei modelli: creare fino a 10 riferimenti denominati personalizzati e riassegnati alle versioni del modello per ogni modello registrato.
Creare ambienti controllati dall'accesso per i modelli Fasi del Registro modelli: usare le fasi all'interno di un modello registrato per indicare l'ambiente delle versioni del modello, con i controlli di accesso solo per due delle quattro fasi fisse (Staging e Production). Modelli registrati: creare un modello registrato per ogni ambiente nel flusso di lavoro MLOps, usando spazi dei nomi a tre livelli e autorizzazioni di Unity Catalog per esprimere la governance.
Alzare di livello i modelli tra ambienti (modello di distribuzione) Usare l'API transition_model_version_stage() client MLflow per spostare una versione del modello in una fase diversa, potenzialmente interrompendo i flussi di lavoro che fanno riferimento alla fase precedente. Usare l'API copy_model_version() client MLflow per copiare una versione del modello da un modello registrato a un altro.
Accedere e condividere modelli tra aree di lavoro Esportare e importare manualmente modelli tra aree di lavoro o configurare connessioni ai registri modelli remoti usando token di accesso personali e ambiti dei segreti dell'area di lavoro. Accesso predefinito ai modelli tra aree di lavoro nello stesso account. Non è necessaria alcuna configurazione.
Configura autorizzazioni Impostare le autorizzazioni a livello di area di lavoro. Impostare le autorizzazioni a livello di account, che applica una governance coerente tra le aree di lavoro.
Accedere ai modelli in Databricks markplace Disponibile. Caricare modelli dal marketplace di Databricks nel metastore di Unity Catalog e accedervi tra aree di lavoro.

Gli articoli collegati di seguito descrivono come eseguire la migrazione dei flussi di lavoro (processi di training del modello e inferenza batch) e modelli dal Registro dei modelli dell'area di lavoro al catalogo unity.

Limitazioni per il supporto di Unity Catalog

  • Le fasi non sono supportate per i modelli nel catalogo unity. Databricks consiglia di usare lo spazio dei nomi a tre livelli in Unity Catalog per esprimere l'ambiente in cui si trova un modello e usando alias per promuovere i modelli per la distribuzione. Per informazioni dettagliate, vedere la guida all'aggiornamento.
  • I webhook non sono supportati per i modelli nel catalogo unity. Vedere le alternative suggerite nella guida all'aggiornamento.
  • Alcuni campi e operatori dell'API di ricerca non sono supportati per i modelli nel catalogo unity. Questa operazione può essere mitigata chiamando le API di ricerca usando filtri supportati e analizzando i risultati. Di seguito sono riportati alcuni esempi:
    • Il order_by parametro non è supportato nelle API client search_model_versions o search_registered_models .
    • I filtri basati su tag (tags.mykey = 'myvalue') non sono supportati per search_model_versions o search_registered_models.
    • Gli operatori diversi dall'uguaglianza esatta (ad esempio, LIKE, ILIKE, !=) non sono supportati per search_model_versions o search_registered_models.
    • La ricerca di modelli registrati in base al nome ( ad esempio, MlflowClient().search_registered_models(filter_string="name='main.default.mymodel'") non è supportata. Per recuperare un particolare modello registrato in base al nome, usare get_registered_model.
  • Le notifiche di posta elettronica e i thread di discussione dei commenti sui modelli registrati e le versioni del modello non sono supportati nel catalogo unity.
  • Il log attività non è supportato per i modelli nel catalogo unity. Tuttavia, è possibile tenere traccia delle attività sui modelli nel catalogo unity usando i log di controllo.
  • search_registered_models potrebbe restituire risultati non aggiornati per i modelli condivisi tramite la condivisione delta. Per garantire i risultati più recenti, usare l'interfaccia della riga di comando di Databricks o l'SDK per elencare i modelli in uno schema.