Share via

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

  • Cikk

Megjegyzés

Ez a dokumentáció a munkaterületi modell beállításjegyzékét ismerteti. Az Azure Databricks a Modellek használatát javasolja a Unity Catalogban. A Unity Catalog modelljei központosított modellirányítást, munkaterületek közötti hozzáférést, életútot és üzembe helyezést biztosítanak. A munkaterületi modell beállításjegyzéke a jövőben elavult lesz.

Ez a példa bemutatja, hogyan hozhat létre egy olyan gépi tanulási alkalmazást a Workspace Model Registry használatával, amely előrejelezheti egy szélfarm napi teljesítménykimenetét. A példa bemutatja, hogyan:

  • Modellek nyomon követése és naplózása az MLflow-val
  • Modellek regisztrálása a Modellregisztrációs adatbázissal
  • Modellek leírása és a modellverzió fázisáttűnéseinek 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ületeinek és API-inak használatával.

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 adathalmazá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 adatkészletet, amely időjárási adatokat és az energiakimeneti adatokat tartalmazza a Egyesült Államok lévő szélfarmhoz. Az adathalmaz hatóránként mintavételezett , és funkciókat tartalmaz wind direction(egyszer a helyen00:00, egyszer a helyen 08:00és egyszer a helyen16:00), valamint a napi összesített áramkimenetet (power) több éven air temperature keresztül. wind speed

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"]

Betanítási modell

Az alábbi kód betanított 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 ikonra kattintva.

    Futtatás oldalsávja

  2. Keresse meg a TensorFlow Keras-modell betanítási munkamenetének megfelelő MLflow-futtatást, és nyissa meg az MLflow futtatási 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 model 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ása. Ez regisztrál egy nevű power-forecasting-model új 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ó oldal információkat nyújt a regisztrált előrejelzési modellről Version 1 , beleértve a szerzőt, a létrehozási időt és az aktuális szakaszt.

Modellverzió lapja

A modellverzió oldalán található egy Forrásfuttatás hivatkozás is, amely megnyitja a modellt az MLflow-futtatás felhasználói felületén a modell létrehozásához használt MLflow-futtatás megnyitásához. Az MLflow futtatási felhasználói felületén a Forrásjegyzetfüzet hivatkozásra kattintva megtekintheti a modell betanítása során használt Azure Databricks-jegyzetfüzet pillanatképét.

Forrásfuttatás

Forrásjegyzetfüzet

Az MLflow-modell beállításjegyzékéhez való visszatéréshez kattintson a Modellekikonmodellek elemre az oldalsávon.

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 fázisait.

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

A regisztrált modellekhez és modellverziókhoz leírásokat adhat hozzá. 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 általános áttekintéséhez és az adatkészlethez). A modellverzió-leírások egy adott modellverzió egyedi attribútumainak részletezéséhez hasznosak (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 Ikon szerkesztése ikonra, és adja meg 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.

    Modellleírás hozzáadása

  2. Kattintson a Save (Mentés) gombra.

  3. A regisztrált modell oldaláról az 1. verzió hivatkozásra kattintva lépjen vissza a modellverzió oldalára.

  4. Kattintson az Ikon szerkesztése ikonra, és adja meg 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 Save (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 fázisnak egyedi jelentése van. Az előkészítés például modelltesztelésre szolgál, míg a Production olyan modellekre vonatkozik, amelyek befejezték a tesztelési vagy felülvizsgálati folyamatokat, és üzembe lettek helyezve az alkalmazásokban.

  1. Kattintson a Fázis gombra az elérhető modellszakaszok és a rendelkezésre álló fázisáttűnés-beállítások megjelenítéséhez.

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

    Átállás éles környezetbe

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

    Éles fázis

    Modellverzió-tevékenység

Az MLflow-modell beállításjegyzéke lehetővé teszi, hogy több modellverzió osztozzon ugyanazon a fázison. Amikor szakaszonként hivatkozik egy modellre, a Modellregisztrációs adatbázis a legújabb modellverziót (a legnagyobb verzióazonosítóval rendelkező modellverziót) használja. A regisztrált modell lapon egy adott modell összes verziója megjelenik.

Regisztrált modell oldala

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 át lett állítva az éles környezetbe, hivatkozhat rá az MLflow programozott API-kkal. 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 használatá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-modell beállításjegyzékébő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ény-kimenet előrejelzése az éles modellel

Ebben a szakaszban az éles modellt 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 azt használja az áramtermelés előrejelzésére a következő öt napra.

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 szintén hatékonyak az energia-előrejelzéshez. 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ázisában 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ót az előkészítésre , é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 éles környezetben

Miután meggyőződett arról, hogy az új modellverzió jól teljesít az előkészítés során, az alábbi kód átállítja a modellt éles környezetbe, és pontosan ugyanazt az alkalmazáskódot használja az Előrejelzési teljesítménykimenet és az éles modell szakaszból az energia-előrejelzés előállításához.

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

forecast_power(model_name, "production")

Az előrejelzési modellnek most 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

Megjegyzé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 az alkalmazáskód módosítása nélkül.

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

Ha a modellverzió már nincs használatban, 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 adatbázis 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:

    Áttérés archiváltra

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

    Archivált szakasz

  3. Nyomja le az OK gombot a fázisáttűnést megerősítő ablakban.

    Archivált modellverzió

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

Az alábbi kód a függvényt használja az MlflowClient.update_model_version() energia-előrejelzési modell archiválásához Version 1 .

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ó oldalá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 fennmaradó modellverzió-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)

Notebook

MLflow-modellregisztrációs adatbázis - példajegyzetfüzet

Jegyzetfüzet lekérése