Dela via

Hantera modelllivscykel i Unity Catalog

Viktigt!

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 MLflow för ML-modellens livscykel.

MLflow 3 gör betydande förbättringar av MLflow Model Registry i Unity Catalog, vilket gör att dina modeller direkt kan samla in data som parametrar och mått och göra dem tillgängliga på alla arbetsytor och experiment. Standardregister-URI:n i MLflow 3 är databricks-uc, vilket innebär att MLflow Model Registry i Unity Catalog används. Mer information finns i Komma igång med förbättringar av MLflow 3 och Model Registry med MLflow 3.

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 Dedikerad (tidigare enskild användare). Mer information finns i Åtkomstlägen. Med Databricks Runtime 15.4 LTS ML och senare kan du också använda dedikerat gruppåtkomstläge.

  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 eller CREATE FUNCTION behörighet i schemat. Om du vill bevilja behörigheter använder du katalogutforskarens användargränssnitt eller SQL-kommandotGRANT:
    GRANT CREATE MODEL ON SCHEMA <schema-name> TO <principal>

Kommentar

Din arbetsyta måste vara kopplad till ett Unity Catalog-metaarkiv som stöder arv av privilegier. Detta gäller för alla metaarkiv som skapats efter den 25 augusti 2022. Om du använder ett äldre metastore ska du följa dokumentationen för att uppgradera.

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 antingen kör ett kluster med Databricks Runtime 13.3 LTS eller senare (Databricks Runtime 15.0 eller senare i Azure China-regioner) eller använder MLflow 3, skapas modeller automatiskt i och läses in från standardkatalogen.

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 modeller med signaturer i MLflow i dina modellträningsbelastningar, 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 i prod katalogen. Att använda prod katalogen betyder inte nödvändigtvis att modellversionen betjänar 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.

MLflow 3

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,
# and the model version will contain all parameters and metrics
# logged with the corresponding MLflow Logged Model.
logged_model = mlflow.last_logged_model()
mlflow.register_model(logged_model.model_uri, "prod.ml_team.iris_model")

MLflow 2.x

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 3

mlflow.register_model(
  "models:/<model_id>", "prod.ml_team.iris_model"
)

MLflow 2.x

mlflow.register_model(
  "runs:/<run_id>/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.

MLflow 3

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

MLflow 2.x

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.

    Dialogrutan Registrera modellversion med den nedrullningsbara menyn

  3. Klicka på Registrera.

    Dialog för att registrera modellversion med knapp

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.

Använda modellalias

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. Se Visa och hantera modeller i användargränssnittet.

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.

Arbetsbelastningar för batchinlärning kan referera till en modellversion via 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 separera modellutrullningar från arbetsflöden för batchinferens.

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)

Modelltjänande slutpunkter kan också referera till en modellversion med ett 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(...)

Ladda modellversion efter versionsnummer för inferensarbetsbelastningar

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). Som mottagare, när du har skapat en katalog från en delning, får du åtkomst till modeller i den delade katalogen på samma sätt som till andra modeller i Unity Catalog.

Spåra datahärledningen för en modell i Unity Catalog

Kommentar

Stöd för tabell-till-modell-ursprung i Unity Catalog finns i MLflow 2.11.0 och senare.

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. Datainjäritet registreras också automatiskt för modeller som loggas med hjälp av funktioner i datalager-API:er. Se Funktionsstyrning och ursprung.

När du registrerar modellen i Unity Catalog sparas ursprungsinformation automatiskt och visas på fliken Ursprung på modellversionssidan i Katalogutforskaren. Se Visa information om modellversion och modell härkomst.

Följande kod visar ett exempel.

MLflow 3

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

MLflow 2.x

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 . Du kan också använda Catalog Explorer för att ange ägarskap och behörigheter för modellen. Mer information finns i Hantera privilegier i Unity Catalog och Unity Catalog-objektmodellen.

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 och hantera 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 Catalog Explorer.

Visa modellinformation

Så här visar du modeller i Katalogutforskaren:

  1. Klicka på dataikonen.Katalog i sidofältet.

  2. Välj en beräkningsresurs i listrutan längst upp till höger.

  3. Öppna en katalog i katalogutforskarens träd till vänster och välj ett schema.

  4. Om schemat innehåller några modeller visas de i trädet under Modeller, som du ser.

    Avsnitt i katalogutforskarens träd som visar modeller.

  5. Klicka på en modell om du vill se mer information. Sidan med modellinformation visar en lista över modellversioner med ytterligare information.

    sidan med modellinformation

Ange modellalias

Så här anger du ett modellalias med hjälp av användargränssnittet:

  1. Hovra över raden för den modellversion som du vill lägga till ett alias till på sidan med modellinformation. Knappen Lägg till alias visas.
  2. Klicka på Lägg till alias.
  3. Ange ett alias eller välj ett i den nedrullningsbara menyn. Du kan lägga till flera alias i dialogrutan.
  4. Klicka på Spara alias.

Så här lägger du till ett alias i en modellversion från sidan med modellinformation.

Så här tar du bort ett alias:

  1. Hovra över raden för modellversionen och klicka på pennikonen bredvid aliaset.
  2. I dialogrutan klickar du på X bredvid det alias som du vill ta bort.
  3. Klicka på Spara alias.

Så här tar du bort ett alias från en modellversion på sidan med modellinformation.

Visa information om modellversion och modell härkomst

Om du vill visa mer information om en modellversion klickar du på dess namn i listan över modeller. Sidan för modellens version visas. Den här sidan innehåller en länk till MLflow-källkörningen som skapade versionen. I MLflow 3 kan du också visa alla parametrar och mått som loggas med motsvarande MLflow-loggade modell.

MLflow 3

modellversionssida

MLflow 2.x

modellversionssida

På den här sidan kan du visa modellens ursprung enligt följande:

  1. Välj fliken Härkomst. Det vänstra sidofältet visar komponenter som loggades tillsammans med modellen.

    fliken Historik på modellsidan i Katalogutforskaren

  2. Klicka på Visa ursprungsdiagram. Härstamningsdiagrammet visas. Mer information om hur du utforskar ursprungsdiagrammet finns i Avbilda och utforska ursprung.

    stamtavla skärm

  3. Om du vill stänga ursprungsdiagrammet klickar du på knappen stäng för ursprungsdiagram i det övre högra hörnet.

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 MLflow Client API-metoden rename_registered_model() , där <full-model-name> är modellens fullständiga namn på tre nivåer och <new-model-name> är modellnamnet utan katalogen eller schemat.

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

Följande kod ändrar till exempel namnet på modellen hello_world till hello.

client=MlflowClient()
client.rename_registered_model("docs.models.hello_world", "hello")

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.

    Dialogrutan Kopiera modellversion

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 användargränssnittet eller API:et.

Varning

Du kan inte ångra den här åtgärden. När du tar bort en modell tas alla modellartefakter som lagras av Unity Catalog och alla metadata som är associerade med den registrerade modellen bort.

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. I Katalogutforskaren, på modellsidan eller modellversionssidan, klickar du på menyikonen för kebabmenyn Kebab. I det övre högra hörnet.

    Från modellsidan:

    modellsidans kebabmeny med borttagning

    Från modellversionssidan:

    modellversionssidans kebabmeny med borttagning

  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ågebesvarande 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 plattformens begränsningar.

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

Lägg 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.

knappar för UC-modellsbeskrivning

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.

    pennikon för att lägga till kommentarer i en modellversion

  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 modellversionsbeskrivning använder du MLflow-klient-API:et update_model_version()-metoden:

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

Kommentar

Alla sök-API-fält och -operatorer stöds inte för modeller i Unity Catalog. Mer information finns i Begränsningar.

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)

Främja en modell över 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å staging.ml_team och prod.ml_team scheman.
  • 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 styrning av modellers främjande 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.

MLflow 3

Modeller i Unity Catalog- exempelanteckningsbok för MLflow 3

Hämta anteckningsbok

MLflow 2.x

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.
Implementera 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. Omedelbar tillgång till modeller över arbetsytor inom 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.
Komma åt modeller på Databricks Marketplace 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.

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.