Bagikan melalui

Model dalam contoh Katalog Unity

  • Artikel

Contoh ini menggambarkan cara menggunakan Model di Unity Catalog untuk membangun aplikasi pembelajaran mesin yang memperkirakan output daya harian dari wind farm. Contoh ini memperlihatkan cara:

  • Melacak dan mencatat model dengan MLflow
  • Mendaftarkan model ke Unity Catalog
  • Menjelaskan model dan menyebarkannya untuk inferensi menggunakan alias
  • Mengintegrasikan model terdaftar dengan aplikasi produksi
  • Mencari dan menemukan model di Unity Catalog
  • Mengarsipkan dan menghapus model

Artikel ini menjelaskan cara melakukan langkah-langkah ini menggunakan Pelacakan dan Model MLflow di UI dan API Katalog Unity.

Persyaratan

Pastikan Anda memenuhi semua persyaratan dalam Persyaratan. Selain itu, contoh kode dalam artikel ini mengasumsikan bahwa Anda memiliki hak istimewa berikut:

  • USE CATALOG hak istimewa pada main katalog.
  • CREATE MODEL hak USE SCHEMA istimewa pada main.default skema.

Notebook

Semua kode dalam artikel ini disediakan dalam buku catatan berikut.

Model di buku catatan contoh Katalog Unity

Dapatkan buku catatan

Menginstal klien MLflow Python

Contoh ini memerlukan klien MLflow Python versi 2.5.0 atau lebih tinggi dan TensorFlow. Tambahkan perintah berikut di bagian atas buku catatan Anda untuk menginstal dependensi ini.

%pip install --upgrade "mlflow-skinny[databricks]>=2.5.0" tensorflow
dbutils.library.restartPython()

Memuat himpunan data, melatih model, dan mendaftar ke Unity Catalog

Bagian ini menunjukkan cara memuat himpunan data wind farm, melatih model, dan mendaftarkan model ke Unity Catalog. Eksekusi pelatihan model dan metrik dilacak dalam eksekusi eksperimen.

Memuat himpunan data

Kode berikut memuat himpunan data yang berisi informasi data cuaca dan output daya untuk unit pembangkit tenaga angin di Amerika Serikat. Himpunan data berisi fitur wind direction, wind speed, dan air temperature yang diambil sampelnya setiap enam jam (sekali pada 00:00, sekali pada 08:00, dan sekali pada 16:00), serta output daya agregat harian (power), selama beberapa tahun.

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

Mengonfigurasi klien MLflow untuk mengakses model di Unity Catalog

Secara default, klien MLflow Python membuat model di registri model ruang kerja di Azure Databricks. Untuk meningkatkan ke model di Unity Catalog, konfigurasikan klien untuk mengakses model di Unity Catalog:

import mlflow
mlflow.set_registry_uri("databricks-uc")

Melatih dan mendaftarkan model

Kode berikut melatih jaringan neural menggunakan TensorFlow Keras untuk memprediksi output daya berdasarkan fitur cuaca dalam himpunan data dan menggunakan API MLflow untuk mendaftarkan model yang dipasang ke 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)

Menampilkan model di UI

Anda dapat melihat dan mengelola model terdaftar dan versi model di Unity Catalog menggunakan Catalog Explorer. Cari model yang baru saja Anda buat di main bawah katalog dan default skema.

Halaman model terdaftar

Menyebarkan versi model untuk inferensi

Model di Unity Catalog mendukung alias untuk penyebaran model. Alias menyediakan referensi yang dapat diubah dan dinamai (misalnya, "Juara" atau "Penantang") ke versi model terdaftar tertentu. Anda dapat mereferensikan dan menargetkan versi model menggunakan alias ini dalam alur kerja inferensi hilir.

Setelah Anda menavigasi ke model terdaftar di Catalog Explorer, klik di bawah kolom Alias untuk menetapkan alias "Juara" ke versi model terbaru, dan tekan "Lanjutkan" untuk menyimpan perubahan.

Mengatur alias model terdaftar

Memuat versi model menggunakan API

Komponen Model MLflow mendefinisikan fungsi untuk memuat model dari beberapa kerangka kerja pembelajaran mesin. Misalnya, mlflow.tensorflow.load_model() digunakan untuk memuat model TensorFlow yang disimpan dalam format MLflow, dan mlflow.sklearn.load_model() digunakan untuk memuat model scikit-learn yang disimpan dalam format MLflow.

Fungsi-fungsi ini dapat memuat model dari Model di Unity Catalog.

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)

Memperkirakan output daya dengan model juara

Di bagian ini, model juara digunakan untuk mengevaluasi data prakiraan cuaca untuk peternakan angin. Aplikasi forecast_power() memuat versi terbaru model prakiraan dari tahap yang ditentukan dan menggunakannya untuk memperkirakan produksi daya selama lima hari ke depan.

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

Menambahkan deskripsi model dan versi model menggunakan API

Kode di bagian ini menunjukkan bagaimana Anda dapat menambahkan deskripsi versi model dan model menggunakan API MLflow.

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."
)

Membuat versi model baru

Teknik pembelajaran mesin klasik juga efektif untuk prakiraan daya. Kode berikut melatih model forest acak menggunakan scikit-learn dan mendaftarkannya ke Unity Catalog menggunakan mlflow.sklearn.log_model() fungsi .

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
  )

Ambil nomor versi model baru

Kode berikut menunjukkan cara mengambil nomor versi model terbaru untuk nama model.

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

Menambahkan deskripsi ke versi model baru

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."
)

Menandai versi model baru sebagai Challenger dan menguji model

Sebelum menyebarkan model untuk melayani lalu lintas produksi, ini adalah praktik terbaik untuk mengujinya pada sampel data produksi. Sebelumnya, Anda menggunakan alias "Juara" untuk menunjukkan versi model yang melayani sebagian besar beban kerja produksi. Kode berikut menetapkan alias "Challenger" ke versi model baru, dan mengevaluasi performanya.

client.set_registered_model_alias(
  name=MODEL_NAME,
  alias="Challenger",
  version=new_model_version
)

forecast_power(MODEL_NAME, "Challenger")

Menyebarkan versi model baru sebagai versi model Champion

Setelah memverifikasi bahwa versi model baru berkinerja baik dalam pengujian, kode berikut menetapkan alias "Juara" ke versi model baru dan menggunakan kode aplikasi yang sama persis dari output daya Prakiraan dengan bagian model juara untuk menghasilkan perkiraan daya.

client.set_registered_model_alias(
  name=MODEL_NAME,
  alias="Champion",
  version=new_model_version
)

forecast_power(MODEL_NAME, "Champion")

Sekarang ada dua versi model dari model prakiraan: versi model yang dilatih dalam model Keras dan versi yang dilatih dalam scikit-learn. Perhatikan bahwa alias "Challenger" tetap ditetapkan ke versi model scikit-learn baru, sehingga beban kerja hilir apa pun yang menargetkan versi model "Challenger" terus berjalan dengan sukses:

Versi model produk

Mengarsipkan dan menghapus model

Saat versi model tidak lagi digunakan, Anda dapat menghapusnya. Anda juga dapat menghapus seluruh model terdaftar; ini menghapus semua versi model terkait. Perhatikan bahwa menghapus versi model menghapus alias apa pun yang ditetapkan ke versi model.

Menghapus Version 1 menggunakan API MLflow

client.delete_model_version(
   name=MODEL_NAME,
   version=1,
)

Menghapus model menggunakan API MLflow

client = MlflowClient()
client.delete_registered_model(name=MODEL_NAME)