Hantera modelllivscykel i Unity Catalog

Den här artikeln beskriver hur du använder modeller i Unity Catalog som en del av ditt maskininlärningsarbetsflöde för att hantera hela livscykeln för ML-modeller. Databricks tillhandahåller en värdbaserad version av MLflow Model Registry i Unity Catalog. Modeller i Unity Catalog utökar fördelarna med Unity Catalog till ML-modeller, inklusive centraliserad åtkomstkontroll, granskning, ursprung och modellidentifiering mellan arbetsytor. Modeller i Unity Catalog är kompatibla med MLflow Python-klienten med öppen källkod.

En översikt över modellregisterbegrepp finns i ML-livscykelhantering med MLflow.

Krav

1. Unity-katalogen måste vara aktiverad på arbetsytan. Se Kom igång använda Unity Catalog för att skapa ett Unity Catalog-metaarkiv, aktivera det på en arbetsyta och skapa en katalog. Om Unity Catalog inte är aktiverat använder du arbetsytans modellregister.

2. Du måste använda en beräkningsresurs som har åtkomst till Unity Catalog. För ML-arbetsbelastningar innebär det att åtkomstläget för beräkningen måste vara Enskild användare. Mer information finns i Åtkomstlägen.

3. För att skapa nya registrerade modeller behöver du följande behörigheter:

   • USE SCHEMA och USE CATALOG behörigheter för schemat och dess omslutande katalog.
   • CREATE_MODEL behörighet i schemat. Om du vill bevilja den här behörigheten använder du katalogutforskarens användargränssnitt eller följande SQL GRANT-kommando:

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

Installera och konfigurera MLflow-klienten för Unity Catalog

Det här avsnittet innehåller instruktioner för att installera och konfigurera MLflow-klienten för Unity Catalog.

Installera MLflow Python-klienten

Stöd för modeller i Unity Catalog ingår i Databricks Runtime 13.2 ML och senare (Databricks Runtime 15.0 ML och senare i Azure China).

Du kan också använda modeller i Unity Catalog på Databricks Runtime 11.3 LTS och senare genom att installera den senaste versionen av MLflow Python-klienten i notebook-filen med hjälp av följande kod.

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

Konfigurera MLflow-klienten för åtkomst till modeller i Unity Catalog

Om din arbetsytas standardkatalog finns i Unity Catalog (i stället hive_metastoreför ) och du kör ett kluster med Databricks Runtime 13.3 LTS eller senare (Databricks Runtime 15.0 eller senare i Azure China-regioner) skapas modellerna automatiskt i och läses in från standardkatalogen. Du behöver inte utföra det här steget.

För andra arbetsytor skapar MLflow Python-klienten modeller i databricks-arbetsytemodellregistret. Om du vill uppgradera till modeller i Unity Catalog använder du följande kod i dina notebook-filer för att konfigurera MLflow-klienten:

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

För ett litet antal arbetsytor där både standardkatalogen konfigurerades till en katalog i Unity Catalog före januari 2024 och arbetsytemodellregistret användes före januari 2024 måste du manuellt ange standardkatalogen till Unity Catalog med kommandot som visas ovan.

Träna och registrera Unity Catalog-kompatibla modeller

Behörigheter som krävs: För att skapa en ny registrerad modell behöver CREATE_MODEL du behörigheterna och USE SCHEMA för det omslutande schemat och USE CATALOG behörigheten för den omslutande katalogen. Om du vill skapa nya modellversioner under en registrerad modell måste du vara ägare till den registrerade modellen och ha USE SCHEMA och USE CATALOG behörigheter för schemat och katalogen som innehåller modellen.

ML-modellversioner i UC måste ha en modellsignatur. Om du inte redan loggar MLflow-modeller med signaturer i dina modellträningsarbetsbelastningar kan du antingen:

• Använd Automatisk loggning av Databricks, som automatiskt loggar modeller med signaturer för många populära ML-ramverk. Se ramverk som stöds i MLflow-dokumenten.
• Med MLflow 2.5.0 och senare kan du ange ett indataexempel i mlflow.<flavor>.log_model anropet och modellsignaturen härleds automatiskt. Mer information finns i MLflow-dokumentationen.

Skicka sedan modellens namn på tre nivåer till MLflow-API:er i formuläret <catalog>.<schema>.<model>.

Exemplen i det här avsnittet skapar och kommer åt modeller i ml_team schemat under prod katalogen.

Modellträningsexemplen i det här avsnittet skapar en ny modellversion och registrerar den prod i katalogen. prod Att använda katalogen betyder inte nödvändigtvis att modellversionen hanterar produktionstrafik. Modellversionens omslutande katalog, schema och registrerade modell återspeglar dess miljö (prod) och tillhörande styrningsregler (till exempel behörigheter kan konfigureras så att endast administratörer kan ta bort från prod katalogen), men inte dess distributionsstatus. Om du vill hantera distributionsstatusen använder du modellalias.

Registrera en modell i Unity Catalog med automatisk loggning

Om du vill registrera en modell använder du MLflow Client API-metoden register_model() . Se 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")

Registrera en modell med hjälp av API:et

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

Registrera en modell i Unity Catalog med automatiskt härledd signatur

Stöd för automatiskt antagna signaturer finns i MLflow version 2.5.0 och senare och stöds i Databricks Runtime 11.3 LTS ML och senare. Om du vill använda automatiskt härledda signaturer använder du följande kod för att installera den senaste MLflow Python-klienten i notebook-filen:

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

Följande kod visar ett exempel på en automatiskt härledd signatur.

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

Registrera en modell med hjälp av användargränssnittet

Följ de här stegen:

1. Från experimentkörningssidan klickar du på Registrera modell i det övre högra hörnet i användargränssnittet.

2. I dialogrutan väljer du Unity Catalog och väljer en målmodell i listrutan.

   

3. Klicka på Registrera.

   

Det kan ta tid att registrera en modell. Om du vill övervaka förloppet går du till målmodellen i Unity Catalog och uppdaterar regelbundet.

Distribuera modeller med hjälp av alias

Med modellalias kan du tilldela en föränderlig, namngiven referens till en viss version av en registrerad modell. Du kan använda alias för att ange distributionsstatus för en modellversion. Du kan till exempel allokera ett "Champion"-alias till den modellversion som för närvarande är i produktion och rikta det här aliaset i arbetsbelastningar som använder produktionsmodellen. Du kan sedan uppdatera produktionsmodellen genom att omtilldela aliaset "Champion" till en annan modellversion.

Ange och ta bort alias för modeller

Behörigheter som krävs: Ägare av den registrerade modellen samt USE SCHEMAUSE CATALOG behörigheter för schemat och katalogen som innehåller modellen.

Du kan ange, uppdatera och ta bort alias för modeller i Unity Catalog med hjälp av Catalog Explorer. Du kan hantera alias i en registrerad modell på sidan med modellinformation och konfigurera alias för en specifik modellversion på sidan med information om modellversion.

Information om hur du anger, uppdaterar och tar bort alias med MLflow-klient-API:et finns i exemplen nedan:

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

Mer information om API:er för aliasklient finns i MLflow API-dokumentationen.

Läsa in modellversion efter alias för slutsatsdragningsarbetsbelastningar

Behörigheter som krävs: EXECUTE behörighet för den registrerade modellen samt USE SCHEMAUSE CATALOG behörigheter för schemat och katalogen som innehåller modellen.

Batch-slutsatsdragningsarbetsbelastningar kan referera till en modellversion efter alias. Kodfragmentet nedan läser in och tillämpar modellversionen "Champion" för batchinferens. Om "Champion"-versionen uppdateras för att referera till en ny modellversion hämtar batchinferensarbetsbelastningen automatiskt den vid nästa körning. På så sätt kan du frikoppla modelldistributioner från batchinferensarbetsbelastningar.

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)

Modell som betjänar slutpunkter kan också referera till en modellversion efter alias. Du kan skriva distributionsarbetsflöden för att hämta en modellversion efter alias och uppdatera en modell som betjänar slutpunkten för att hantera den versionen med hjälp av modellen som betjänar REST API. Till exempel:

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

Läsa in modellversion efter versionsnummer för slutsatsdragningsarbetsbelastningar

Du kan också läsa in modellversioner efter versionsnummer:

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)

Dela modeller mellan arbetsytor

Dela modeller med användare i samma region

Så länge du har rätt behörigheter kan du komma åt modeller i Unity Catalog från alla arbetsytor som är kopplade till metaarkivet som innehåller modellen. Du kan till exempel komma åt modeller från prod katalogen på en utvecklingsarbetsyta för att underlätta jämförelsen av nyutvecklade modeller med produktionsbaslinjen.

Om du vill samarbeta med andra användare (dela skrivbehörigheter) för en registrerad modell som du har skapat måste du bevilja ägarskapet för modellen till en grupp som innehåller dig själv och de användare som du vill samarbeta med. Medarbetare måste också ha behörigheterna USE CATALOG och USE SCHEMA i katalogen och schemat som innehåller modellen. Mer information finns i Behörigheter och skyddsbara objekt i Unity Catalog.

Dela modeller med användare i en annan region eller ett annat konto

Om du vill dela modeller med användare i andra regioner eller konton använder du delningsflödet Delta Sharing Databricks-to-Databricks. Se Lägga till modeller i en resurs (för leverantörer) och Få åtkomst i Databricks-till-Databricks-modellen (för mottagare). När du har skapat en katalog från en resurs som mottagare får du åtkomst till modeller i den delade katalogen på samma sätt som andra modeller i Unity Catalog.

Spåra data härstamningen för en modell i Unity Catalog

När du tränar en modell på en tabell i Unity Catalog kan du spåra modellens ursprung till de överordnade datauppsättningar som den har tränats och utvärderats på. Det gör du genom att använda mlflow.log_input. Detta sparar indatatabellinformationen med MLflow-körningen som genererade modellen. Data härkomst registreras också automatiskt för modeller som loggas med hjälp av funktionslager-API:er. Se Funktionsstyrning och ursprung.

När du registrerar modellen i Unity Catalog sparas ursprungsinformation automatiskt och visas på fliken Ursprung i modellversionsgränssnittet i Catalog Explorer.

Följande kod visar ett exempel.

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

Kontrollera åtkomst till modeller

I Unity Catalog är registrerade modeller en undertyp av det FUNCTION skyddsbara objektet. Om du vill bevilja åtkomst till en modell som är registrerad i Unity Catalog använder GRANT ON FUNCTIONdu . Mer information finns i Behörigheter och skyddsbara objekt i Unity Catalog. Metodtips för att organisera modeller mellan kataloger och scheman finns i Ordna dina data.

Du kan konfigurera modellbehörigheter programmatiskt med hjälp av GRANTS REST API. När du konfigurerar modellbehörigheter anger du securable_type till "FUNCTION" i REST API-begäranden. Använd till exempel PATCH /api/2.1/unity-catalog/permissions/function/{full_name} för att uppdatera registrerade modellbehörigheter.

Visa modeller i användargränssnittet

Behörigheter som krävs: Om du vill visa en registrerad modell och dess modellversioner i användargränssnittet behöver EXECUTE du behörighet för den registrerade modellen samt USE SCHEMAUSE CATALOG behörigheter för schemat och katalogen som innehåller modellen

Du kan visa och hantera registrerade modeller och modellversioner i Unity Catalog med hjälp av Katalogutforskaren.

Byt namn på en modell

Behörigheter som krävs: Ägare av den registrerade modellen, CREATE_MODEL behörighet för schemat som innehåller den registrerade modellen samt USE SCHEMAUSE CATALOG behörigheter för schemat och katalogen som innehåller modellen.

Om du vill byta namn på en registrerad modell använder du metoden rename_registered_model() för MLflow-klient-API:et:

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

Kopiera en modellversion

Du kan kopiera en modellversion från en modell till en annan i Unity Catalog.

Kopiera en modellversion med hjälp av användargränssnittet

Följ de här stegen:

1. På sidan modellversion klickar du på Kopiera den här versionen i det övre högra hörnet i användargränssnittet.

2. Välj en målmodell i listrutan och klicka på Kopiera.

   

Det kan ta tid att kopiera en modell. Om du vill övervaka förloppet går du till målmodellen i Unity Catalog och uppdaterar regelbundet.

Kopiera en modellversion med hjälp av API:et

Om du vill kopiera en modellversion använder du MLflows copy_model_version() Python API:

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

Ta bort en modell eller modellversion

Behörigheter som krävs: Ägare av den registrerade modellen samt USE SCHEMAUSE CATALOG behörigheter för schemat och katalogen som innehåller modellen.

Du kan ta bort en registrerad modell eller en modellversion i en registrerad modell med hjälp av katalogutforskarens användargränssnitt eller API.

Ta bort en modellversion eller modell med hjälp av användargränssnittet

Följ dessa steg om du vill ta bort en modell eller modellversion i Unity Catalog.

1. På modellsidan eller modellversionssidan klickar du på menyn för kebab i det övre högra hörnet.

   Från modellsidan:

   

   Från modellversionssidan:

   

2. Välj Ta bort.

3. En dialogruta för bekräftelse visas. Bekräfta genom att klicka på Ta bort .

Ta bort en modellversion eller modell med hjälp av API:et

Om du vill tar bort en modellversion använder du metoden delete_model_version() för MLflow-klient-API:et:

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

Om du vill tar bort en modell använder du metoden delete_registered_model() för MLflow-klient-API:et:

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

Använda taggar på modeller

Taggar är nyckel/värde-par som du associerar med registrerade modeller och modellversioner, så att du kan märka och kategorisera dem efter funktion eller status. Du kan till exempel använda en tagg med nyckel "task" och värde "question-answering" (visas i användargränssnittet som task:question-answering) på registrerade modeller som är avsedda för frågor som besvarar uppgifter. På modellversionsnivå kan du tagga versioner som genomgår fördistributionsverifiering med validation_status:pending och de som har rensats för distribution med validation_status:approved.

Behörigheter som krävs: Ägare till eller har APPLY_TAG behörighet för den registrerade modellen samt USE SCHEMAUSE CATALOG behörigheter för schemat och katalogen som innehåller modellen.

Se Lägga till och uppdatera taggar med Hjälp av Katalogutforskaren om hur du anger och tar bort taggar med hjälp av användargränssnittet.

Om du vill ange och ta bort taggar med hjälp av MLflow-klient-API:et läser du exemplen nedan:

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

Både registrerade modell- och modellversionstaggar måste uppfylla begränsningarna för hela plattformen.

Mer information om taggklient-API:er finns i MLflow API-dokumentationen.

Lägga till en beskrivning (kommentarer) i en modell eller modellversion

Behörigheter som krävs: Ägare av den registrerade modellen samt USE SCHEMAUSE CATALOG behörigheter för schemat och katalogen som innehåller modellen.

Du kan inkludera en textbeskrivning för valfri modell eller modellversion i Unity Catalog. Du kan till exempel ge en översikt över problemet eller information om den metod och algoritm som används.

För modeller har du också möjlighet att använda AI-genererade kommentarer. Se Lägga till AI-genererade kommentarer till Unity Catalog-objekt.

Lägga till en beskrivning i en modell med hjälp av användargränssnittet

Om du vill lägga till en beskrivning för en modell kan du använda AI-genererade kommentarer eller ange egna kommentarer. Du kan redigera AI-genererade kommentarer efter behov.

• Om du vill lägga till automatiskt genererade kommentarer klickar du på knappen AI-generera .
• Om du vill lägga till egna kommentarer klickar du på Lägg till. Ange dina kommentarer i dialogrutan och klicka på Spara.

Lägga till en beskrivning i en modellversion med hjälp av användargränssnittet

Följ dessa steg om du vill lägga till en beskrivning i en modellversion i Unity Catalog:

1. På modellversionssidan klickar du på pennikonen under Beskrivning.

   

2. Ange dina kommentarer i dialogrutan och klicka på Spara.

Lägga till en beskrivning i en modell eller modellversion med hjälp av API:et

Om du vill uppdatera en registrerad modellbeskrivning använder du MLflow Client API-metoden update_registered_model() :

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

Om du vill uppdatera en beskrivning för en modellversion använder du metoden update_model_version() för MLflow-klient-API:et:

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

Lista och sökmodeller

Om du vill hämta en lista över registrerade modeller i Unity Catalog använder du MLflows python-API search_registered_models():

client=MlflowClient()
client.search_registered_models()

Om du vill söka efter ett specifikt modellnamn och få information om modellens versioner använder du search_model_versions():

from pprint import pprint

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

Ladda ned modellfiler (avancerat användningsfall)

För att läsa in modeller bör du i de flesta fall använda MLflow-API:er som mlflow.pyfunc.load_model eller mlflow.<flavor>.load_model (till exempel mlflow.transformers.load_model för HuggingFace-modeller).

I vissa fall kan du behöva ladda ned modellfiler för att felsöka modellbeteende eller problem med modellinläsning. Du kan ladda ned modellfiler med hjälp av mlflow.artifacts.download_artifacts, enligt följande:

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)

Höja upp en modell mellan miljöer

Databricks rekommenderar att du distribuerar ML-pipelines som kod. Detta eliminerar behovet av att marknadsföra modeller i olika miljöer, eftersom alla produktionsmodeller kan skapas via automatiserade träningsarbetsflöden i en produktionsmiljö.

I vissa fall kan det dock vara för dyrt att träna modeller i olika miljöer. I stället kan du kopiera modellversioner mellan registrerade modeller i Unity Catalog för att marknadsföra dem i olika miljöer.

Du behöver följande behörigheter för att köra exempelkoden nedan:

• USE CATALOG på katalogerna staging och prod .
• USE SCHEMA på scheman staging.ml_team och prod.ml_team .
• EXECUTE på staging.ml_team.fraud_detection.

Dessutom måste du vara ägare till den registrerade modellen prod.ml_team.fraud_detection.

Följande kodfragment använder MLflow-klient-API:et copy_model_version, som är tillgängligt i MLflow version 2.8.0 och senare.

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)

När modellversionen finns i produktionsmiljön kan du utföra alla nödvändiga verifieringar före distributionen. Sedan kan du markera modellversionen för distribution med hjälp av alias.

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

I exemplet ovan kan endast användare som kan läsa från den staging.ml_team.fraud_detection registrerade modellen och skriva till den prod.ml_team.fraud_detection registrerade modellen flytta mellanlagringsmodeller till produktionsmiljön. Samma användare kan också använda alias för att hantera vilka modellversioner som distribueras i produktionsmiljön. Du behöver inte konfigurera några andra regler eller principer för att styra modellhöjning och distribution.

Du kan anpassa det här flödet för att höja upp modellversionen i flera miljöer som matchar konfigurationen, till exempel dev, qaoch prod. Åtkomstkontroll tillämpas enligt konfigurationen i varje miljö.

Exempelanteckningsbok

Den här notebook-filen visar hur du använder modeller i Unity Catalog-API:er för att hantera modeller i Unity Catalog, inklusive registrering av modeller och modellversioner, lägga till beskrivningar, läsa in och distribuera modeller, använda modellalias och ta bort modeller och modellversioner.

Modeller i Unity Catalog- exempelanteckningsbok

Hämta anteckningsbok

Migrera arbetsflöden och modeller till Unity Catalog

Databricks rekommenderar att du använder Modeller i Unity Catalog för bättre styrning, enkel delning mellan arbetsytor och miljöer och mer flexibla MLOps-arbetsflöden. Tabellen jämför funktionerna i Arbetsytemodellregistret och Unity Catalog.

Kapacitet	Arbetsytemodellregister (äldre)	Modeller i Unity Catalog (rekommenderas)
Referensmodellversioner efter namngivna alias	Modellregistersteg: Flytta modellversioner till ett av fyra fasta steg för att referera till dem i den fasen. Det går inte att byta namn på eller lägga till faser.	Modellregisteralias: Skapa upp till 10 anpassade och omtilldelbara namngivna referenser till modellversioner för varje registrerad modell.
Skapa åtkomststyrda miljöer för modeller	Modellregistersteg: Använd faser i en registrerad modell för att ange miljön för dess modellversioner, med åtkomstkontroller för endast två av de fyra fasta stegen (Staging och Production).	Registrerade modeller: Skapa en registrerad modell för varje miljö i ditt MLOps-arbetsflöde med hjälp av namnområden på tre nivåer och behörigheter för Unity Catalog för att uttrycka styrning.
Höja upp modeller mellan miljöer (distribuera modell)	Använd MLflow-klient-API:et transition_model_version_stage() för att flytta en modellversion till en annan fas, vilket kan bryta arbetsflöden som refererar till föregående steg.	Använd MLflow-klient-API:et copy_model_version() för att kopiera en modellversion från en registrerad modell till en annan.
Komma åt och dela modeller mellan arbetsytor	Exportera och importera modeller manuellt mellan arbetsytor eller konfigurera anslutningar till fjärrmodellregister med hjälp av personliga åtkomsttoken och arbetsytehemlighetsomfång.	Direktåtkomst till modeller mellan arbetsytor i samma konto. Ingen konfiguration krävs.
Konfigurera behörigheter	Ange behörigheter på arbetsytans nivå.	Ange behörigheter på kontonivå, vilket tillämpar konsekvent styrning mellan arbetsytor.
Åtkomstmodeller i Databricks markplace	Oanträffbar.	Läs in modeller från Databricks Marketplace till ditt Unity Catalog-metaarkiv och få åtkomst till dem mellan arbetsytor.

Artiklarna nedan beskriver hur du migrerar arbetsflöden (modelltränings- och batchinferensjobb) och modeller från Arbetsytemodellregistret till Unity Catalog.

• Uppgradera ML-arbetsflöden till målmodeller i Unity Catalog
• Uppgradera modeller till Unity Catalog

Begränsningar

• Faser stöds inte för modeller i Unity Catalog. Databricks rekommenderar att du använder namnområdet på tre nivåer i Unity Catalog för att uttrycka miljön som en modell finns i och använda alias för att höja upp modeller för distribution. Mer information finns i Flytta upp en modell mellan miljöer .
• Webhooks stöds inte för modeller i Unity Catalog. Se föreslagna alternativ i uppgraderingsguiden.
• Vissa sök-API-fält och operatorer stöds inte för modeller i Unity Catalog. Detta kan minimeras genom att anropa sök-API:er med hjälp av filter som stöds och genomsöka resultaten. Följande är några exempel:
  • Parametern order_by stöds inte i search_model_versions eller search_registered_models klient-API:er.
  • Taggbaserade filter (tags.mykey = 'myvalue') stöds inte för search_model_versions eller search_registered_models.
  • Andra operatorer än exakt likhet (till exempel LIKE, ILIKE, !=) stöds inte för search_model_versions eller search_registered_models.
  • Sökning efter registrerade modeller efter namn (till exempel MlflowClient().search_registered_models(filter_string="name='main.default.mymodel'") stöds inte. Om du vill hämta en viss registrerad modell efter namn använder du get_registered_model.
• E-postaviseringar och kommentarsdiskussionstrådar på registrerade modeller och modellversioner stöds inte i Unity Catalog.
• Aktivitetsloggen stöds inte för modeller i Unity Catalog. Om du vill spåra aktivitet på modeller i Unity Catalog använder du granskningsloggar.
• search_registered_models kan returnera inaktuella resultat för modeller som delas via Deltadelning. För att säkerställa de senaste resultaten använder du Databricks CLI eller SDK för att lista modellerna i ett schema.