Voorbeeld van modellen in Unity Catalog
In dit voorbeeld ziet u hoe u modellen in Unity Catalog kunt gebruiken om een machine learning-toepassing te bouwen waarmee de dagelijkse stroomuitvoer van een windturbine wordt voorspeld. In het voorbeeld ziet u hoe u:
- Modellen bijhouden en registreren met MLflow
- Modellen registreren bij Unity Catalog
- Modellen beschrijven en implementeren voor deductie met behulp van aliassen
- Geregistreerde modellen integreren met productietoepassingen
- Modellen zoeken en ontdekken in Unity Catalog
- Modellen archiveren en verwijderen
In het artikel wordt beschreven hoe u deze stappen uitvoert met behulp van de MLflow Tracking and Models in Unity Catalog UIs en API's.
Vereisten
Zorg ervoor dat u voldoet aan alle vereisten in Vereisten. Bovendien gaan de codevoorbeelden in dit artikel ervan uit dat u de volgende bevoegdheden hebt:
USE CATALOGbevoegdheid voor demaincatalogus.CREATE MODELenUSE SCHEMAbevoegdheden voor hetmain.defaultschema.
Notebook
Alle code in dit artikel vindt u in het volgende notebook.
Voorbeeldnotebook modellen in Unity Catalog
MLflow Python-client installeren
Voor dit voorbeeld is de MLflow Python-clientversie 2.5.0 of hoger en TensorFlow vereist. Voeg de volgende opdrachten toe boven aan uw notebook om deze afhankelijkheden te installeren.
%pip install --upgrade "mlflow-skinny[databricks]>=2.5.0" tensorflow
dbutils.library.restartPython()
Gegevensset laden, model trainen en registreren bij Unity Catalog
In deze sectie ziet u hoe u de gegevensset van de windfarm laadt, een model traint en het model registreert bij Unity Catalog. De uitvoering van de modeltraining en metrische gegevens worden bijgehouden in een experimentuitvoering.
Gegevensset laden
Met de volgende code wordt een gegevensset geladen met weergegevens en energie-uitvoerinformatie voor een windmolenpark in de Verenigde Staten. De gegevensset bevat , en air temperature functies die elke zes uur (één keer, 00:00één keer op 08:00, en één keer op ), 16:00evenals de dagelijkse geaggregeerde energie-uitvoer (power), gedurende meerdere jaren worden bemonsterd. wind 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"]
MLflow-client configureren voor toegang tot modellen in Unity Catalog
De MLflow Python-client maakt standaard modellen in het werkruimtemodelregister in Azure Databricks. Als u wilt upgraden naar modellen in Unity Catalog, configureert u de client voor toegang tot modellen in Unity Catalog:
import mlflow
mlflow.set_registry_uri("databricks-uc")
Model trainen en registreren
Met de volgende code wordt een neuraal netwerk getraind met TensorFlow Keras om energie-uitvoer te voorspellen op basis van de weerfuncties in de gegevensset en worden MLflow-API's gebruikt om het aangepaste model te registreren bij 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)
Het model weergeven in de gebruikersinterface
U kunt geregistreerde modellen en modelversies in Unity Catalog bekijken en beheren met behulp van De Catalogusverkenner. Zoek naar het model dat u zojuist hebt gemaakt onder de catalogus en default het main schema.
Een modelversie implementeren voor deductie
Modellen in Unity Catalog ondersteunen aliassen voor modelimplementatie. Aliassen bieden veranderlijke, benoemde verwijzingen (bijvoorbeeld 'Champion' of 'Challenger') aan een bepaalde versie van een geregistreerd model. U kunt verwijzen naar en doelmodelversies met behulp van deze aliassen in downstreamdeductiewerkstromen.
Nadat u naar het geregistreerde model in Catalog Explorer hebt genavigeerd, klikt u onder de kolom Aliassen om de alias Champion toe te wijzen aan de nieuwste modelversie en drukt u op Doorgaan om wijzigingen op te slaan.
Modelversies laden met behulp van de API
Het onderdeel MLflow-modellen definieert functies voor het laden van modellen uit verschillende machine learning-frameworks. Wordt bijvoorbeeld mlflow.tensorflow.load_model() gebruikt voor het laden van TensorFlow-modellen die zijn opgeslagen in MLflow-indeling en mlflow.sklearn.load_model() wordt gebruikt voor het laden van scikit-learn-modellen die zijn opgeslagen in MLflow-indeling.
Met deze functies kunnen modellen uit modellen in Unity Catalog worden geladen.
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)
Energie-uitvoer voorspellen met het kampioensmodel
In deze sectie wordt het kampioensmodel gebruikt om weersvoorspellingsgegevens voor het windturbinepark te evalueren. De forecast_power() toepassing laadt de nieuwste versie van het prognosemodel uit de opgegeven fase en gebruikt deze om de productie van energie in de komende vijf dagen te voorspellen.
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")
Beschrijvingen van model- en modelversies toevoegen met behulp van de API
De code in deze sectie laat zien hoe u beschrijvingen van model- en modelversies kunt toevoegen met behulp van de MLflow-API.
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."
)
Een nieuwe modelversie maken
Klassieke machine learning-technieken zijn ook effectief voor energieprognoses. Met de volgende code wordt een willekeurig forestmodel getraind met scikit-learn en wordt het geregistreerd bij Unity Catalog met behulp van de mlflow.sklearn.log_model() functie.
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
)
Het nieuwe modelversienummer ophalen
De volgende code laat zien hoe u het meest recente modelversienummer voor een modelnaam ophaalt.
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])
Een beschrijving toevoegen aan de nieuwe modelversie
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."
)
Nieuwe modelversie markeren als Challenger en het model testen
Voordat u een model implementeert voor productieverkeer, is het een best practice om het model te testen op een voorbeeld van productiegegevens. Eerder hebt u de alias Champion gebruikt om de modelversie aan te geven die het merendeel van de productieworkloads bedient. Met de volgende code wordt de alias 'Challenger' toegewezen aan de nieuwe modelversie en worden de prestaties geëvalueerd.
client.set_registered_model_alias(
name=MODEL_NAME,
alias="Challenger",
version=new_model_version
)
forecast_power(MODEL_NAME, "Challenger")
De nieuwe modelversie implementeren als de champion-modelversie
Nadat u hebt gecontroleerd of de nieuwe modelversie goed presteert in tests, wijst de volgende code de alias 'Champion' toe aan de nieuwe modelversie en gebruikt u exact dezelfde toepassingscode uit de prognosestroomuitvoer met de sectie model van het kampioenmodel om een energieprognose te produceren.
client.set_registered_model_alias(
name=MODEL_NAME,
alias="Champion",
version=new_model_version
)
forecast_power(MODEL_NAME, "Champion")
Er zijn nu twee modelversies van het prognosemodel: de modelversie die is getraind in Keras-model en de versie die is getraind in scikit-learn. Houd er rekening mee dat de alias 'Challenger' toegewezen blijft aan de nieuwe versie van het scikit-learn-model, zodat alle downstreamworkloads die gericht zijn op de modelversie 'Challenger' blijven worden uitgevoerd:
Modellen archiveren en verwijderen
Wanneer een modelversie niet meer wordt gebruikt, kunt u deze verwijderen. U kunt ook een volledig geregistreerd model verwijderen; hiermee verwijdert u alle gekoppelde modelversies. Als u een modelversie verwijdert, worden alle aliassen gewist die zijn toegewezen aan de modelversie.
Verwijderen Version 1 met behulp van de MLflow-API
client.delete_model_version(
name=MODEL_NAME,
version=1,
)
Het model verwijderen met behulp van de MLflow-API
client = MlflowClient()
client.delete_registered_model(name=MODEL_NAME)
Feedback
Binnenkort beschikbaar: In de loop van 2024 zullen we GitHub-problemen geleidelijk uitfaseren als het feedbackmechanisme voor inhoud en deze vervangen door een nieuw feedbacksysteem. Zie voor meer informatie: https://aka.ms/ContentUserFeedback.
Feedback verzenden en weergeven voor