Exempel på modeller i Unity Catalog
Det här exemplet illustrerar hur du använder modeller i Unity Catalog för att skapa ett maskininlärningsprogram som förutspår den dagliga utdatan för en vindkraftspark. Exemplet visar hur du:
- Spåra och logga modeller med MLflow
- Registrera modeller till Unity Catalog
- Beskriva modeller och distribuera dem för slutsatsdragning med hjälp av alias
- Integrera registrerade modeller med produktionsprogram
- Söka efter och identifiera modeller i Unity Catalog
- Arkivera och ta bort modeller
I artikeln beskrivs hur du utför de här stegen med hjälp av MLflow Tracking and Models i UIs och API:er för Unity Catalog.
Krav
Se till att du uppfyller alla krav i Krav. Dessutom förutsätter kodexemplen i den här artikeln att du har följande behörigheter:
USE CATALOGbehörighet imainkatalogen.CREATE MODELochUSE SCHEMAbehörigheter imain.defaultschemat.
Notebook-fil
All kod i den här artikeln finns i följande notebook-fil.
Modeller i Unity Catalog- exempelanteckningsbok
Installera MLflow Python-klienten
Det här exemplet kräver MLflow Python-klientversion 2.5.0 eller senare och TensorFlow. Lägg till följande kommandon överst i anteckningsboken för att installera dessa beroenden.
%pip install --upgrade "mlflow-skinny[databricks]>=2.5.0" tensorflow
dbutils.library.restartPython()
Läsa in datauppsättning, träna modell och registrera till Unity Catalog
Det här avsnittet visar hur du läser in datamängden för vindkraftsparker, tränar en modell och registrerar modellen i Unity Catalog. Modellträningskörningen och måtten spåras i en experimentkörning.
Läsa in datauppsättning
Följande kod läser in en datauppsättning som innehåller väderdata och utdatainformation för en vindkraftspark i USA. Datamängden innehåller , och funktioner som samplas var sjätte timme (en gång vid 00:00, en gång vid 08:00och en gång vid 16:00), samt dagliga aggregerade utdata (power) under flera år.air temperaturewind speedwind direction
import pandas as pd
wind_farm_data = pd.read_csv("https://github.com/dbczumar/model-registry-demo-notebook/raw/master/dataset/windfarm_data.csv", index_col=0)
def get_training_data():
training_data = pd.DataFrame(wind_farm_data["2014-01-01":"2018-01-01"])
X = training_data.drop(columns="power")
y = training_data["power"]
return X, y
def get_validation_data():
validation_data = pd.DataFrame(wind_farm_data["2018-01-01":"2019-01-01"])
X = validation_data.drop(columns="power")
y = validation_data["power"]
return X, y
def get_weather_and_forecast():
format_date = lambda pd_date : pd_date.date().strftime("%Y-%m-%d")
today = pd.Timestamp('today').normalize()
week_ago = today - pd.Timedelta(days=5)
week_later = today + pd.Timedelta(days=5)
past_power_output = pd.DataFrame(wind_farm_data)[format_date(week_ago):format_date(today)]
weather_and_forecast = pd.DataFrame(wind_farm_data)[format_date(week_ago):format_date(week_later)]
if len(weather_and_forecast) < 10:
past_power_output = pd.DataFrame(wind_farm_data).iloc[-10:-5]
weather_and_forecast = pd.DataFrame(wind_farm_data).iloc[-10:]
return weather_and_forecast.drop(columns="power"), past_power_output["power"]
Konfigurera MLflow-klienten för åtkomst till modeller i Unity Catalog
Som standard skapar MLflow Python-klienten modeller i arbetsytemodellregistret i Azure Databricks. Om du vill uppgradera till modeller i Unity Catalog konfigurerar du klienten för att komma åt modeller i Unity Catalog:
import mlflow
mlflow.set_registry_uri("databricks-uc")
Träna och registrera modell
Följande kod tränar ett neuralt nätverk med TensorFlow Keras för att förutsäga utdata baserat på väderfunktionerna i datamängden och använder MLflow-API:er för att registrera den anpassade modellen i Unity Catalog.
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
MODEL_NAME = "main.default.wind_forecasting"
def train_and_register_keras_model(X, y):
with mlflow.start_run():
model = Sequential()
model.add(Dense(100, input_shape=(X.shape[-1],), activation="relu", name="hidden_layer"))
model.add(Dense(1))
model.compile(loss="mse", optimizer="adam")
model.fit(X, y, epochs=100, batch_size=64, validation_split=.2)
example_input = X[:10].to_numpy()
mlflow.tensorflow.log_model(
model,
artifact_path="model",
input_example=example_input,
registered_model_name=MODEL_NAME
)
return model
X_train, y_train = get_training_data()
model = train_and_register_keras_model(X_train, y_train)
Visa modellen i användargränssnittet
Du kan visa och hantera registrerade modeller och modellversioner i Unity Catalog med hjälp av Katalogutforskaren. Leta efter den modell som du nyss skapade under main katalogen och default schemat.
Distribuera en modellversion för slutsatsdragning
Modeller i Unity Catalog stöder alias för modelldistribution. Alias ger föränderliga, namngivna referenser (till exempel "Champion" eller "Challenger") till en viss version av en registrerad modell. Du kan referera till och målmodellversioner med hjälp av dessa alias i efterföljande slutsatsdragningsarbetsflöden.
När du har navigerat till den registrerade modellen i Katalogutforskaren klickar du under kolumnen Alias för att tilldela aliaset "Champion" till den senaste modellversionen och trycker på Fortsätt för att spara ändringarna.
Läsa in modellversioner med hjälp av API:et
Komponenten MLflow Models definierar funktioner för inläsning av modeller från flera maskininlärningsramverk. Används till exempel mlflow.tensorflow.load_model() för att läsa in TensorFlow-modeller som har sparats i MLflow-format och mlflow.sklearn.load_model() används för att läsa in scikit-learn-modeller som har sparats i MLflow-format.
Dessa funktioner kan läsa in modeller från modeller i Unity Catalog.
import mlflow.pyfunc
model_version_uri = "models:/{model_name}/1".format(model_name=MODEL_NAME)
print("Loading registered model version from URI: '{model_uri}'".format(model_uri=model_version_uri))
model_version_1 = mlflow.pyfunc.load_model(model_version_uri)
model_champion_uri = "models:/{model_name}@Champion".format(model_name=MODEL_NAME)
print("Loading registered model version from URI: '{model_uri}'".format(model_uri=model_champion_uri))
champion_model = mlflow.pyfunc.load_model(model_champion_uri)
Prognostisera utdata med modellen champion
I det här avsnittet används modellen för att utvärdera väderprognosdata för vindkraftsparken. Programmet forecast_power() läser in den senaste versionen av prognosmodellen från den angivna fasen och använder den för att prognostisera energiproduktionen under de kommande fem dagarna.
from mlflow.tracking import MlflowClient
def plot(model_name, model_alias, model_version, power_predictions, past_power_output):
import matplotlib.dates as mdates
from matplotlib import pyplot as plt
index = power_predictions.index
fig = plt.figure(figsize=(11, 7))
ax = fig.add_subplot(111)
ax.set_xlabel("Date", size=20, labelpad=20)
ax.set_ylabel("Power\noutput\n(MW)", size=20, labelpad=60, rotation=0)
ax.tick_params(axis='both', which='major', labelsize=17)
ax.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d'))
ax.plot(index[:len(past_power_output)], past_power_output, label="True", color="red", alpha=0.5, linewidth=4)
ax.plot(index, power_predictions.squeeze(), "--", label="Predicted by '%s'\nwith alias '%s' (Version %d)" % (model_name, model_alias, model_version), color="blue", linewidth=3)
ax.set_ylim(ymin=0, ymax=max(3500, int(max(power_predictions.values) * 1.3)))
ax.legend(fontsize=14)
plt.title("Wind farm power output and projections", size=24, pad=20)
plt.tight_layout()
display(plt.show())
def forecast_power(model_name, model_alias):
import pandas as pd
client = MlflowClient()
model_version = client.get_model_version_by_alias(model_name, model_alias).version
model_uri = "models:/{model_name}@{model_alias}".format(model_name=MODEL_NAME, model_alias=model_alias)
model = mlflow.pyfunc.load_model(model_uri)
weather_data, past_power_output = get_weather_and_forecast()
power_predictions = pd.DataFrame(model.predict(weather_data))
power_predictions.index = pd.to_datetime(weather_data.index)
print(power_predictions)
plot(model_name, model_alias, int(model_version), power_predictions, past_power_output)
forecast_power(MODEL_NAME, "Champion")
Lägga till modell- och modellversionsbeskrivningar med hjälp av API:et
Koden i det här avsnittet visar hur du kan lägga till modell- och modellversionsbeskrivningar med hjälp av MLflow-API:et.
client = MlflowClient()
client.update_registered_model(
name=MODEL_NAME,
description="This model forecasts the power output of a wind farm based on weather data. The weather data consists of three features: wind speed, wind direction, and air temperature."
)
client.update_model_version(
name=MODEL_NAME,
version=1,
description="This model version was built using TensorFlow Keras. It is a feed-forward neural network with one hidden layer."
)
Skapa en ny modellversion
Klassiska maskininlärningstekniker är också effektiva för energiprognoser. Följande kod tränar en slumpmässig skogsmodell med scikit-learn och registrerar den i Unity Catalog med hjälp av mlflow.sklearn.log_model() funktionen.
import mlflow.sklearn
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
with mlflow.start_run():
n_estimators = 300
mlflow.log_param("n_estimators", n_estimators)
rand_forest = RandomForestRegressor(n_estimators=n_estimators)
rand_forest.fit(X_train, y_train)
val_x, val_y = get_validation_data()
mse = mean_squared_error(rand_forest.predict(val_x), val_y)
print("Validation MSE: %d" % mse)
mlflow.log_metric("mse", mse)
example_input = val_x.iloc[[0]]
# Specify the `registered_model_name` parameter of the `mlflow.sklearn.log_model()`
# function to register the model to <UC>. This automatically
# creates a new model version
mlflow.sklearn.log_model(
sk_model=rand_forest,
artifact_path="sklearn-model",
input_example=example_input,
registered_model_name=MODEL_NAME
)
Hämta det nya modellversionsnumret
Följande kod visar hur du hämtar det senaste modellversionsnumret för ett modellnamn.
client = MlflowClient()
model_version_infos = client.search_model_versions("name = '%s'" % MODEL_NAME)
new_model_version = max([model_version_info.version for model_version_info in model_version_infos])
Lägga till en beskrivning i den nya modellversionen
client.update_model_version(
name=MODEL_NAME,
version=new_model_version,
description="This model version is a random forest containing 100 decision trees that was trained in scikit-learn."
)
Markera ny modellversion som Challenger och testa modellen
Innan du distribuerar en modell för att hantera produktionstrafik är det bästa praxis att testa den på ett exempel på produktionsdata. Tidigare använde du aliaset "Champion" för att ange modellversionen som betjänar de flesta produktionsarbetsbelastningar. Följande kod tilldelar aliaset "Challenger" till den nya modellversionen och utvärderar dess prestanda.
client.set_registered_model_alias(
name=MODEL_NAME,
alias="Challenger",
version=new_model_version
)
forecast_power(MODEL_NAME, "Challenger")
Distribuera den nya modellversionen som Champion-modellversion
När du har kontrollerat att den nya modellversionen presterar bra i tester tilldelar följande kod aliaset "Champion" till den nya modellversionen och använder exakt samma programkod från avsnittet Prognostiserade utdata med modellen champion för att skapa en energiprognos.
client.set_registered_model_alias(
name=MODEL_NAME,
alias="Champion",
version=new_model_version
)
forecast_power(MODEL_NAME, "Champion")
Det finns nu två modellversioner av prognosmodellen: modellversionen som tränats i Keras-modellen och den version som tränats i scikit-learn. Observera att aliaset "Challenger" fortfarande är tilldelat till den nya scikit-learn-modellversionen, så alla underordnade arbetsbelastningar som riktar sig mot modellversionen "Challenger" fortsätter att köras:
Arkivera och ta bort modeller
När en modellversion inte längre används kan du ta bort den. Du kan också ta bort en hel registrerad modell. detta tar bort alla associerade modellversioner. Observera att om du tar bort en modellversion rensas alla alias som tilldelats till modellversionen.
Ta bort Version 1 med hjälp av MLflow-API:et
client.delete_model_version(
name=MODEL_NAME,
version=1,
)
Ta bort modellen med hjälp av MLflow-API:et
client = MlflowClient()
client.delete_registered_model(name=MODEL_NAME)
Feedback
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i: https://aka.ms/ContentUserFeedback.
Skicka och visa feedback för