Megosztás a következőn keresztül:

Példa munkaterületmodell beállításjegyzékére

  • Cikk

Feljegyzés

Ez a dokumentáció a munkaterületmodell-beállításjegyzéket ismerteti. Az Azure Databricks a Modellek használatát javasolja a Unity Catalogban. A Unity Catalog modelljei központosított modellszabályozást, munkaterületek közötti hozzáférést, leágazást és üzembe helyezést biztosítanak. A munkaterületmodell-beállításjegyzék a jövőben megszűnik.

Ez a példa bemutatja, hogyan használható a Munkaterületmodell-beállításjegyzék egy olyan gépi tanulási alkalmazás létrehozására, 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 Modellregisztrációs adatbázissal
  • Modellek leírása és a modellverzió fázisáttűnések létrehozása
  • Regisztrált modellek integrálása éles alkalmazásokkal
  • Modellek keresése és felderítése a Modellregisztrációs adatbázisban
  • Modellek archiválása és törlése

A cikk bemutatja, hogyan hajthatja végre ezeket a lépéseket az MLflow Tracking és az MLflow Model Registry felhasználói felületeivel és API-kkal.

Ha az MLflow Tracking és a Registry API-k használatával hajtja végre ezeket a lépéseket, tekintse meg a Modellregisztrációs adatbázis példajegyzetfüzetét.

Adathalmaz betöltése, modell betanítása és nyomon követése az MLflow Tracking használatával

Mielőtt regisztrálna egy modellt a Modellregisztrációs adatbázisban, először be kell tanítania és naplóznia kell a modellt egy kísérlet futtatása során. Ez a szakasz bemutatja, hogyan töltheti be a szélfarm adatkészletét, hogyan taníthat be egy modellt, és hogyan naplózhatja a betanítási futtatásokat az MLflow-ba.

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 directionair temperature wind speedhatóránként (egyszer, 00:0008: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"]

Modell betanítása

Az alábbi kód beképez egy 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. Az MLflow a modell hiperparamétereinek, teljesítménymetrikáinak, forráskódjának és összetevőinek nyomon követésére szolgál.

def train_keras_model(X, y):
  import tensorflow.keras
  from tensorflow.keras.models import Sequential
  from tensorflow.keras.layers import Dense

  model = Sequential()
  model.add(Dense(100, input_shape=(X_train.shape[-1],), activation="relu", name="hidden_layer"))
  model.add(Dense(1))
  model.compile(loss="mse", optimizer="adam")

  model.fit(X_train, y_train, epochs=100, batch_size=64, validation_split=.2)
  return model

import mlflow

X_train, y_train = get_training_data()

with mlflow.start_run():
  # Automatically capture the model's parameters, metrics, artifacts,
  # and source code with the `autolog()` function
  mlflow.tensorflow.autolog()

  train_keras_model(X_train, y_train)
  run_id = mlflow.active_run().info.run_id

A modell regisztrálása és kezelése az MLflow felhasználói felületén

Ebben a szakaszban:

Új regisztrált modell létrehozása

  1. Lépjen az MLflow Kísérletfuttatások oldalsávjára az Azure Databricks-jegyzetfüzet jobb oldali oldalsávján található Kísérlet ikonra Kísérlet ikon kattintva.

    Oldalsáv futtatása

  2. Keresse meg a TensorFlow Keras-modell betanítási munkamenetének megfelelő MLflow-futtatást, és nyissa meg az MLflow Futtatás felhasználói felületén a Futtatás részleteinek megtekintése ikonra kattintva.

  3. Az MLflow felhasználói felületén görgessen le az Összetevők szakaszhoz, és kattintson a modell nevű könyvtárra. Kattintson a megjelenő Modell regisztrálása gombra.

    Modell regisztrálása

  4. Válassza az Új modell létrehozása lehetőséget a legördülő menüben, és adja meg a következő modellnevet: power-forecasting-model

  5. Kattintson a Regisztrálás parancsra. Ez regisztrál egy új, úgynevezett power-forecasting-model modellt, és létrehoz egy új modellverziót: Version 1.

    Új modellverzió

    Néhány pillanat múlva az MLflow felhasználói felülete megjeleníti az új regisztrált modellre mutató hivatkozást. Ezt a hivatkozást követve nyissa meg az új modellverziót az MLflow Modellregisztrációs adatbázis felhasználói felületén.

A Modellregisztrációs adatbázis felhasználói felületének megismerése

Az MLflow Modellregisztrációs adatbázis felhasználói felületén található modellverziólap információkat nyújt a regisztrált előrejelzési modellről Version 1 , beleértve annak szerzőjét, létrehozási idejét és aktuális szakaszát.

Modellverzió lapja

A modell verziólapján egy forrásfuttatási hivatkozás is található, amely megnyitja a modell létrehozásához használt MLflow-futtatást az MLflow run felhasználói felületén. Az MLflow-futtatási felhasználói felületen elérheti a Forrásjegyzetfüzet hivatkozást a modell betanítása során használt Azure Databricks-jegyzetfüzet pillanatképének megtekintéséhez.

Forrásfuttatás

Forrásjegyzetfüzet

Az MLflow-modellregisztrációs adatbázisra való visszalépéshez kattintson az oldalsáv Modellek gombjáraModellek ikonra.

Az eredményként kapott MLflow Modellregisztrációs adatbázis kezdőlapja megjeleníti az Azure Databricks-munkaterületen regisztrált modellek listáját, beleértve azok verzióit és szakaszait is.

A power-forecasting-model hivatkozásra kattintva nyissa meg a regisztrált modelloldalt, amely az előrejelzési modell összes verzióját megjeleníti.

Modellleírások hozzáadása

Leírásokat adhat hozzá a regisztrált modellekhez és modellverziókhoz. A regisztrált modellleírások hasznosak a több modellverzióra vonatkozó információk rögzítéséhez (például a modellezési probléma és az adatkészlet általános áttekintése). A modellverzió leírásai hasznosak egy adott modellverzió egyedi attribútumainak részletezéséhez (például a modell fejlesztéséhez használt módszertan és algoritmus).

  1. Adjon hozzá egy magas szintű leírást a regisztrált energia-előrejelzési modellhez. Kattintson az Szerkesztés ikon ikonra, és írja be a következő leírást:

    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.

    Modell leírásának hozzáadása

  2. Kattintson a Mentés gombra.

  3. A regisztrált modelllap 1. verziójára mutató hivatkozásra kattintva lépjen vissza a modell verziólapjára.

  4. Kattintson az Szerkesztés ikon ikonra, és írja be a következő leírást:

    This model version was built using TensorFlow Keras. It is a feed-forward neural network with one hidden layer.

    Modellverzió leírásának hozzáadása

  5. Kattintson a Mentés gombra.

Modellverzió áttűnés

Az MLflow modellregisztrációs adatbázisa több modellszakaszt határoz meg: None, Staging, Production és Archived. Minden szakasznak egyedi jelentése van. Az előkészítés például modelltesztelésre szolgál, míg az éles környezet olyan modellekre vonatkozik, amelyek befejezték a tesztelési vagy felülvizsgálati folyamatokat, és üzembe lettek helyezve az alkalmazásokban.

  1. A Fázis gombra kattintva megjelenítheti az elérhető modellszakaszok listáját és a rendelkezésre álló fázisátmeneti beállításokat.

  2. Válassza az Áttűnés –> Éles állapot elemet, és a fázisáttűnés megerősítésének ablakában nyomja le az OK billentyűt a modell éles környezetbe való áttűnéséhez.

    Átvezetés az éles szakaszba

    A modellverzió éles környezetbe való áttűnése után az aktuális szakasz megjelenik a felhasználói felületen, és a rendszer hozzáad egy bejegyzést a tevékenységnaplóhoz, amely tükrözi az áttűnést.

    Éles fázis

    Modellverzió-tevékenység

Az MLflow modellregisztrációs adatbázisa lehetővé teszi, hogy több modellverzió is ugyanazt a fázist használja. Amikor szakaszonként hivatkozik egy modellre, a Modellregisztrációs adatbázis a legújabb modellverziót használja (a legnagyobb verzióazonosítóval rendelkező modellverziót). A regisztrált modelloldal egy adott modell összes verzióját megjeleníti.

Regisztrált modell lapja

A modell regisztrálása és kezelése az MLflow API használatával

Ebben a szakaszban:

A modell nevének programozott meghatározása

Most, hogy a modell regisztrálva lett, és áttért az éles környezetbe, MLflow programozott API-k használatával hivatkozhat rá. Adja meg a regisztrált modell nevét az alábbiak szerint:

model_name = "power-forecasting-model"

Regisztrálja a modellt

model_name = get_model_name()

import mlflow

# The default path where the MLflow autologging function stores the TensorFlow Keras model
artifact_path = "model"
model_uri = "runs:/{run_id}/{artifact_path}".format(run_id=run_id, artifact_path=artifact_path)

model_details = mlflow.register_model(model_uri=model_uri, name=model_name)

import time
from mlflow.tracking.client import MlflowClient
from mlflow.entities.model_registry.model_version_status import ModelVersionStatus

# Wait until the model is ready
def wait_until_ready(model_name, model_version):
  client = MlflowClient()
  for _ in range(10):
    model_version_details = client.get_model_version(
      name=model_name,
      version=model_version,
    )
    status = ModelVersionStatus.from_string(model_version_details.status)
    print("Model status: %s" % ModelVersionStatus.to_string(status))
    if status == ModelVersionStatus.READY:
      break
    time.sleep(1)

wait_until_ready(model_details.name, model_details.version)

Modell- és modellverzió-leírások hozzáadása az API-val

from mlflow.tracking.client import MlflowClient

client = MlflowClient()
client.update_registered_model(
  name=model_details.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_details.name,
  version=model_details.version,
  description="This model version was built using TensorFlow Keras. It is a feed-forward neural network with one hidden layer."
)

Modellverzió áttűnés és részletek lekérése az API használatával

client.transition_model_version_stage(
  name=model_details.name,
  version=model_details.version,
  stage='production',
)
model_version_details = client.get_model_version(
  name=model_details.name,
  version=model_details.version,
)
print("The current model stage is: '{stage}'".format(stage=model_version_details.current_stage))

latest_version_info = client.get_latest_versions(model_name, stages=["production"])
latest_production_version = latest_version_info[0].version
print("The latest production version of the model '%s' is '%s'." % (model_name, latest_production_version))

A regisztrált modell verzióinak 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 betölthetnek modelleket az MLflow-modellregisztrációs adatbázisbó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_production_uri = "models:/{model_name}/production".format(model_name=model_name)

print("Loading registered model version from URI: '{model_uri}'".format(model_uri=model_production_uri))
model_production = mlflow.pyfunc.load_model(model_production_uri)

Teljesítménykimenet előrejelzése az éles modellel

Ebben a szakaszban az éles modell a szélfarm időjárás-előrejelzési adatainak kiértékelésére szolgál. 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.

def plot(model_name, model_stage, model_version, power_predictions, past_power_output):
  import pandas as pd
  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'\nin stage '%s' (Version %d)" % (model_name, model_stage, 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_stage):
  from mlflow.tracking.client import MlflowClient
  client = MlflowClient()
  model_version = client.get_latest_versions(model_name, stages=[model_stage])[0].version
  model_uri = "models:/{model_name}/{model_stage}".format(model_name=model_name, model_stage=model_stage)
  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_stage, int(model_version), power_predictions, past_power_output)

Ú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 az MLflow-modellregisztrációs adatbázisba a mlflow.sklearn.log_model() függvényen keresztül.

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)

  # Specify the `registered_model_name` parameter of the `mlflow.sklearn.log_model()`
  # function to register the model with the MLflow Model Registry. This automatically
  # creates a new model version
  mlflow.sklearn.log_model(
    sk_model=rand_forest,
    artifact_path="sklearn-model",
    registered_model_name=model_name,
  )

from mlflow.tracking.client import MlflowClient
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])

wait_until_ready(model_name, new_model_version)

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ó áttűnése előkészítésre és a modell tesztelésére

Mielőtt üzembe helyeznénk egy modellt egy éles alkalmazásban, gyakran ajánlott tesztelni egy átmeneti környezetben. Az alábbi kód áttűnés az új modellverzióra átmeneti állapotba, és kiértékeli annak teljesítményét.

client.transition_model_version_stage(
  name=model_name,
  version=new_model_version,
  stage="Staging",
)

forecast_power(model_name, "Staging")

Az új modellverzió üzembe helyezése az éles környezetben

Miután ellenőrizte, hogy az új modellverzió megfelelően működik-e az előkészítés során, az alábbi kód áttűnés a modell éles környezetbe, és pontosan ugyanazt az alkalmazáskódot használja az előrejelzési teljesítménykimenetből az éles modell szakaszával, hogy energia-előrejelzést készítsen.

client.transition_model_version_stage(
  name=model_name,
  version=new_model_version,
  stage="production",
)

forecast_power(model_name, "production")

Az előrejelzési modellnek már két modellverziója van az éles szakaszban: a Keras-modellben betanított modellverzió és a scikit-learnben betanított verzió.

Termékmodell-verziók

Feljegyzés

Amikor szakaszonként hivatkozik egy modellre, az MLflow modellregisztrációs adatbázisa automatikusan a legújabb éles verziót használja. Ez lehetővé teszi az éles modellek frissítését alkalmazáskód módosítása nélkül.

Modellek archiválása és törlése

Ha már nem használ modellverziót, archiválhatja vagy törölheti azt. Egy teljes regisztrált modellt is törölhet; ezzel eltávolítja az összes társított modellverziót.

Az energia-előrejelzési modell archívuma Version 1

Az energia-előrejelzési modell archiválása Version 1 , mert már nincs használatban. A modellek archiválhatók az MLflow modellregisztrációs felhasználói felületén vagy az MLflow API-val.

Archívum Version 1 az MLflow felhasználói felületén

Az energia-előrejelzési modell archiválása Version 1 :

  1. Nyissa meg a megfelelő modellverzió lapját az MLflow Modellregisztrációs adatbázis felhasználói felületén:

    Váltás archiváltra

  2. Kattintson a Szakasz gombra, és válassza az Áttűnés –> Archiválva lehetőséget:

    Archivált szakasz

  3. Nyomja le az OK gombot a fázisátmenet-megerősítési ablakban.

    Archivált modellverzió

Archiválás Version 1 az MLflow API használatával

Az alábbi kód a függvény használatával MlflowClient.update_model_version() archiválja Version 1 az energia-előrejelzési modellt.

from mlflow.tracking.client import MlflowClient

client = MlflowClient()
client.transition_model_version_stage(
  name=model_name,
  version=1,
  stage="Archived",
)

Az energia-előrejelzési modell törlése Version 1

A modellverziók törléséhez az MLflow felhasználói felületét vagy az MLflow API-t is használhatja.

Figyelmeztetés

A modellverzió törlése végleges, és nem vonható vissza.

Törlés Version 1 az MLflow felhasználói felületén

Az energia-előrejelzési modell törlése Version 1 :

  1. Nyissa meg a megfelelő modellverzió lapját az MLflow Modellregisztrációs adatbázis felhasználói felületén.

    Modellverzió törlése

  2. Válassza a verzióazonosító melletti legördülő nyilat, és kattintson a Törlés gombra.

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

Először át kell váltania az összes többi modellverziós fázist a Nincs vagy az Archivált állapotra.

from mlflow.tracking.client import MlflowClient

client = MlflowClient()
client.transition_model_version_stage(
  name=model_name,
  version=2,
  stage="Archived",
)

client.delete_registered_model(name=model_name)

Jegyzetfüzet

MLflow-modell beállításjegyzékének példajegyzetfüzete

Jegyzetfüzet beszerzése