Beispiel für Modelle in Unity Catalog
Dieses Beispiel veranschaulicht, wie Sie Modelle in Unity Catalog verwenden, um eine Machine Learning-Anwendung zu erstellen, die die tägliche Stromerzeugung eines Windparks vorhersagt. Das Beispiel veranschaulicht die folgenden Schritte:
- Nachverfolgen und Protokollieren von Modellen mit MLflow
- Registrieren von Modellen in Unity Catalog
- Beschreiben und Bereitstellen von Modellen für Rückschlüsse mithilfe von Aliasen
- Integrieren registrierter Modelle in Produktionsanwendungen
- Suchen und Ermitteln von Modellen in Unity Catalog
- Archivieren und Löschen von Modellen
In diesem Artikel wird beschrieben, wie Sie diese Schritte mithilfe der Benutzeroberflächen und APIs der MLflow-Nachverfolgung und der Modelle in Unity Catalog ausführen.
Anforderungen
Stellen Sie sicher, dass alle Anforderungen unter Anforderungen erfüllt sind. Darüber hinaus gehen die Codebeispiele in diesem Artikel davon aus, dass Sie über die folgenden Berechtigungen verfügen:
- Die Berechtigung
USE CATALOGfür den Katalogmain. - Die Berechtigungen
CREATE MODELundUSE SCHEMAfür das Schemamain.default.
Notebook
Der gesamte Code in diesem Artikel wird im folgenden Notebook bereitgestellt.
Beispiel-Notebook für Modelle in Unity Catalog
Installieren des MLflow-Python-Clients
Dieses Beispiel erfordert die MLflow-Python-Clientversion 2.5.0 oder höher und TensorFlow. Fügen Sie oben in Ihrem Notebook die folgenden Befehle hinzu, um diese Abhängigkeiten zu installieren.
%pip install --upgrade "mlflow-skinny[databricks]>=2.5.0" tensorflow
dbutils.library.restartPython()
Laden des Datasets, Trainieren des Modells und Registrieren bei Unity Catalog
In diesem Abschnitt wird gezeigt, wie Sie das Windpark-Dataset laden, ein Modell trainieren und das Modell bei Unity Catalog registrieren. Die Modelltrainingsausführung und -metriken werden in einer Experimentausführung nachverfolgt.
Laden des Datasets
Der folgende Code lädt ein Dataset mit Wetterdaten und Informationen zur Stromerzeugung für einen Windpark in den USA. Das Dataset enthält die Merkmale wind direction, wind speed und air temperature, von denen alle sechs Stunden (einmal um 00:00, einmal um 08:00 und einmal um 16:00) Stichproben genommen werden sowie die tägliche aggregierte Stromerzeugung (power), über mehrere Jahre hinweg.
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"]
Konfigurieren des MLflow-Clients für den Zugriff auf Modelle in Unity Catalog
Standardmäßig erstellt der MLflow-Python-Client Modelle in der Arbeitsbereichsmodellregistrierung in Azure Databricks. Um ein Upgrade auf Modelle in Unity Catalog durchzuführen, konfigurieren Sie den Client für den Zugriff auf Modelle in Unity Catalog:
import mlflow
mlflow.set_registry_uri("databricks-uc")
Trainieren und Registrieren von Modellen
Der folgende Code trainiert ein neuronales Netz mithilfe von TensorFlow Keras, um die Stromerzeugung basierend auf den Wettermerkmalen im Dataset vorherzusagen, und nutzt MLflow-APIs, um das angepasste Modell bei Unity Catalog zu registrieren.
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)
Anzeigen des Modells auf der Benutzeroberfläche
Sie können registrierte Modelle und Modellversionen in Unity Catalog mit dem Katalog-Explorer anzeigen und verwalten. Suchen Sie nach dem Modell, das Sie gerade im Katalog main mit dem Schema default erstellt haben.
Bereitstellen einer Modellversion für Rückschlüsse
Modelle in Unity Catalog unterstützen Aliase für die Modellbereitstellung. Aliase bieten veränderliche benannte Verweise (z. B. „Champion“ oder „Challenger“) auf eine bestimmte Version eines registrierten Modells. Sie können mithilfe dieser Aliase in nachgelagerten Rückschlussworkflows auf Modellversionen verweisen und diese als Ziel festlegen.
Nachdem Sie zum registrierten Modell im Katalog-Explorer navigiert sind, klicken Sie unter der Spalte Aliase, um der neuesten Modellversion den Alias „Champion“ zuzuweisen. Klicken Sie anschließend auf „Weiter“, um die Änderungen zu speichern.
Laden von Modellversionen mithilfe der API
Die Komponente „MLflow-Modelle“ definiert Funktionen zum Laden von Modellen aus mehreren Machine Learning-Frameworks. Beispielsweise wird mlflow.tensorflow.load_model() verwendet, um TensorFlow-Modelle zu laden, die im MLflow-Format gespeichert wurden. mlflow.sklearn.load_model() wird verwendet, um scikit-learn-Modelle zu laden, die im MLflow-Format gespeichert wurden.
Diese Funktionen können Modelle aus Modellen in Unity Catalog laden.
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)
Vorhersagen der Stromerzeugung mit dem Champion-Modell
In diesem Abschnitt wird das Champion-Modell verwendet, um Wettervorhersagedaten für den Windpark auszuwerten. Die forecast_power()-Anwendung lädt die neueste Version des Vorhersagemodells aus der angegebenen Phase und verwendet es, um die Stromerzeugung für die nächsten fünf Tage vorherzusagen.
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")
Hinzufügen von Modell- und Modellversionsbeschreibungen mithilfe der API
Der Code in diesem Abschnitt zeigt, wie Sie mithilfe der MLflow-API Modell- und Modellversionsbeschreibungen hinzufügen können.
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."
)
Erstellen einer neuen Modellversion
Klassische Machine Learning-Methoden sind auch bei der Stromerzeugungsvorhersage effektiv. Der folgende Code trainiert ein Modell mit einer zufälligen Gesamtstruktur (Random Forest) mit scikit-learn und registriert es über die mlflow.sklearn.log_model()-Funktion bei Unity Catalog.
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
)
Abrufen der neuen Modellversionsnummer
Der folgende Code zeigt, wie Sie die neueste Modellversionsnummer für einen Modellnamen abrufen.
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])
Hinzufügen einer Beschreibung zur neuen Modellversion
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."
)
Markieren der neuen Modellversion als „Challenger“ und Testen des Modells
Vor der Bereitstellung eines Modells zum Bereitstellen von Produktionsdatenverkehr empfiehlt es sich, es an einem Beispiel von Produktionsdaten zu testen. Zuvor haben Sie den Alias „Champion“ verwendet, um die Modellversion anzugeben, die den Großteil der Produktionsworkloads bedient. Der folgende Code weist der neuen Modellversion den Alias „Challenger“ zu und bewertet dessen Leistung.
client.set_registered_model_alias(
name=MODEL_NAME,
alias="Challenger",
version=new_model_version
)
forecast_power(MODEL_NAME, "Challenger")
Bereitstellen der neuen Modellversion als Champion-Modellversion
Nachdem überprüft wurde, ob die neue Modellversion in Tests gut funktioniert, weist der folgende Code den Alias „Champion“ der neuen Modellversion zu und verwendet genau denselben Anwendungscode aus dem Abschnitt Vorhersagen der Stromerzeugung mit dem Champion-Modell, um eine Stromerzeugungsvorhersage zu erstellen.
client.set_registered_model_alias(
name=MODEL_NAME,
alias="Champion",
version=new_model_version
)
forecast_power(MODEL_NAME, "Champion")
Es gibt jetzt zwei Modellversionen des Vorhersagemodells: die im Keras-Modell trainierte Modellversion und die in scikit-learn trainierte Version. Beachten Sie, dass der Challenger-Alias der neuen scikit-learn-Modellversion zugewiesen bleibt, sodass alle Downstreamworkloads für die Challenger-Modellversion weiterhin erfolgreich ausgeführt werden:
Archivieren und Löschen von Modellen
Wenn eine Modellversion nicht mehr verwendet wird, können Sie sie löschen. Sie können auch ein vollständiges registriertes Modell löschen. Dadurch werden alle zugehörigen Modellversionen entfernt. Beachten Sie, dass beim Löschen einer Modellversion alle Aliase gelöscht werden, die der Modellversion zugewiesen sind.
Löschen der Version 1 mithilfe der MLflow-API
client.delete_model_version(
name=MODEL_NAME,
version=1,
)
Löschen des Modells mithilfe der MLflow-API
client = MlflowClient()
client.delete_registered_model(name=MODEL_NAME)
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für