Példa a Unity Catalog modelljeire
Ez a példa bemutatja, hogyan használhat modelleket a Unity Catalogban egy olyan gépi tanulási alkalmazás létrehozásához, amely előrejelzést készít egy szélfarm napi teljesítménykimenetéről. A példa bemutatja, hogyan:
- Modellek nyomon követése és naplózása az MLflow használatával
- Modellek regisztrálása a Unity Catalogban
- Modellek leírása és üzembe helyezése következtetés céljából aliasok használatával
- Regisztrált modellek integrálása éles alkalmazásokkal
- Modellek keresése és felfedezése a Unity Katalógusban
- Modellek archiválása és törlése
A cikk bemutatja, hogyan hajthatja végre ezeket a lépéseket az MLflow tracking és models használatával a Unity Catalog felhasználói felületén és API-jában.
Követelmények
Győződjön meg arról, hogy megfelel a Követelmények összes követelményének. A cikkben szereplő példakódok emellett feltételezik, hogy a következő jogosultságokkal rendelkezik:
USE CATALOG
jogosultságot a katalógusbanmain
.CREATE MODEL
ésUSE SCHEMA
jogosultságokat amain.default
sémán.
Jegyzetfüzet
A cikkben szereplő összes kód az alábbi jegyzetfüzetben található.
Modellek a Unity Catalog példajegyzetfüzetében
MLflow Python-ügyfél telepítése
Ehhez a példához az MLflow Python-ügyfél 2.5.0-s vagy újabb verziója és a TensorFlow szükséges. A függőségek telepítéséhez adja hozzá a következő parancsokat a jegyzetfüzet tetején.
%pip install --upgrade "mlflow-skinny[databricks]>=2.5.0" tensorflow
dbutils.library.restartPython()
Adathalmaz betöltése, modell betanítása és regisztrálás a Unity Katalógusba
Ez a szakasz bemutatja, hogyan töltheti be a szélerőmű-adathalmazt, hogyan taníthat be egy modellt, és hogyan regisztrálhatja a modellt a Unity Catalogban. A modell betanítási futtatása és a metrikák egy kísérletfuttatásban lesznek nyomon követve.
Adatkészlet betöltése
Az alábbi kód betölt egy olyan adatkészletet, amely időjárási adatokat és teljesítménykimeneti információkat tartalmaz a Egyesült Államok egy szélfarmhoz. Az adathalmaz wind direction
air temperature
wind speed
hatóránként (egyszer, 00:00
08:00
és egyszerre16:00
) vett mintát, valamint a napi összesített áramkimenetet (power
) tartalmazza több éven keresztül.
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"]
MLflow-ügyfél konfigurálása modellek elérésére a Unity Katalógusban
Az MLflow Python-ügyfél alapértelmezés szerint az Azure Databricks munkaterületi modellregisztrációs adatbázisában hoz létre modelleket. A Unity Catalog modelljeire való frissítéshez konfigurálja az ügyfelet a Unity Catalog modelljeinek elérésére:
import mlflow
mlflow.set_registry_uri("databricks-uc")
Modell betanítása és regisztrálása
Az alábbi kód betanítja a neurális hálózatot a TensorFlow Keras használatával az adathalmaz időjárási jellemzői alapján történő teljesítmény-előrejelzéshez, és MLflow API-k használatával regisztrálja a beszerelt modellt a Unity Catalogban.
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)
A modell megtekintése a felhasználói felületen
A Regisztrált modelleket és modellverziókat a Katalóguskezelővel tekintheti meg és kezelheti a Unity Katalógusban. Keresse meg az imént létrehozott modellt a katalógusban és default
a main
sémában.
Modellverzió üzembe helyezése következtetéshez
A Unity Catalog modelljei támogatják a modell üzembe helyezésének aliasát . Az aliasok egy regisztrált modell egy adott verziójára mutató, elnevezett hivatkozásokat (például "Champion" vagy "Challenger") biztosítanak. Ezeket az aliasokat használva hivatkozhat és célozhat meg modellverziókat az alsóbb rétegbeli következtetési munkafolyamatokban.
Miután a Katalóguskezelőben a regisztrált modellre navigált, kattintson az Aliasok oszlop alatt a "Champion" alias hozzárendeléséhez a legújabb modellverzióhoz, és a módosítások mentéséhez nyomja le a "Folytatás" billentyűt.
Modellverziók betöltése az API használatával
Az MLflow Models összetevő függvényeket határoz meg a modellek több gépi tanulási keretrendszerből való betöltéséhez. Például mlflow.tensorflow.load_model()
az MLflow formátumban mentett TensorFlow-modellek betöltésére szolgál, és mlflow.sklearn.load_model()
az MLflow formátumban mentett scikit-learn modellek betöltésére szolgál.
Ezek a függvények modelleket tölthetnek be a Unity Catalog modelljeiből.
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)
Teljesítménykimenet előrejelzése a bajnoki modellel
Ebben a szakaszban a bajnokmodellt használjuk a szélfarm időjárás-előrejelzési adatainak kiértékelésére. Az forecast_power()
alkalmazás betölti az előrejelzési modell legújabb verzióját a megadott fázisból, és a következő öt napban az áramtermelés előrejelzésére használja.
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")
Modell- és modellverzió-leírások hozzáadása az API-val
Az ebben a szakaszban található kód bemutatja, hogyan adhat hozzá modell- és modellverzió-leírásokat az MLflow API használatával.
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."
)
Új modellverzió létrehozása
A klasszikus gépi tanulási technikák az energia-előrejelzéshez is hatékonyak. Az alábbi kód betanít egy véletlenszerű erdőmodellt a scikit-learn használatával, és regisztrálja azt a Unity Catalogban a mlflow.sklearn.log_model()
függvény használatával.
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
)
Az új modell verziószámának lekérése
Az alábbi kód bemutatja, hogyan kérhető le a modellnév legújabb modellverziószáma.
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])
Leírás hozzáadása az új modellverzióhoz
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."
)
Az új modellverzió megjelölése Kihívóként és a modell tesztelése
Mielőtt üzembe helyeznénk egy modellt az éles forgalom kiszolgálására, ajánlott tesztelni az éles adatok mintáján. Korábban a "Champion" aliast használta az éles számítási feladatok többségét kiszolgáló modellverzió jelölésére. Az alábbi kód hozzárendeli a "Challenger" aliast az új modellverzióhoz, és kiértékeli annak teljesítményét.
client.set_registered_model_alias(
name=MODEL_NAME,
alias="Challenger",
version=new_model_version
)
forecast_power(MODEL_NAME, "Challenger")
Az új modellverzió üzembe helyezése Bajnok modellverzióként
Miután ellenőrizte, hogy az új modellverzió jól teljesít-e a tesztekben, az alábbi kód hozzárendeli a "Champion" aliast az új modellverzióhoz, és pontosan ugyanazt az alkalmazáskódot használja az előrejelzési teljesítménykimenetből a bajnokmodell szakaszával, hogy energia-előrejelzést készítsen.
client.set_registered_model_alias(
name=MODEL_NAME,
alias="Champion",
version=new_model_version
)
forecast_power(MODEL_NAME, "Champion")
Az előrejelzési modellnek most két modellverziója van: a Keras-modellben betanított modellverzió és a scikit-learnben betanított verzió. Vegye figyelembe, hogy a "Challenger" alias továbbra is hozzá van rendelve az új scikit-learn modellverzióhoz, így a "Challenger" modellverziót megcélzó alsóbb rétegbeli számítási feladatok továbbra is sikeresen futnak:
Modellek archiválása és törlése
Ha a modellverzió már nincs használatban, törölheti azt. Egy teljes regisztrált modellt is törölhet; ez eltávolítja az összes társított modellverziót. Vegye figyelembe, hogy a modellverzió törlése törli a modellverzióhoz rendelt aliasokat.
Törlés Version 1
az MLflow API használatával
client.delete_model_version(
name=MODEL_NAME,
version=1,
)
A modell törlése az MLflow API használatával
client = MlflowClient()
client.delete_registered_model(name=MODEL_NAME)
Visszajelzés
https://aka.ms/ContentUserFeedback.
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ:Visszajelzés küldése és megtekintése a következőhöz: