Contoh Registri Model Ruang Kerja
Catatan
Dokumentasi ini mencakup Registri Model Ruang Kerja. Azure Databricks merekomendasikan penggunaan Model di Unity Catalog. Model di Unity Catalog menyediakan tata kelola model terpusat, akses lintas ruang kerja, silsilah data, dan penyebaran. Registri Model Ruang Kerja tidak akan digunakan lagi di masa mendatang.
Contoh ini menggambarkan cara menggunakan Registri Model Ruang Kerja 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 dengan Registri Model
- Menjelaskan model dan membuat transisi tahap versi model
- Mengintegrasikan model terdaftar dengan aplikasi produksi
- Mencari dan menemukan model di Registri Model
- Mengarsipkan dan menghapus model
Artikel ini menjelaskan cara melakukan langkah-langkah ini menggunakan UI dan API Pelacakan MLflow dan Registri Model MLflow.
Untuk buku catatan yang melakukan semua langkah ini menggunakan API Pelacakan dan Registri MLflow, lihat Contoh buku catatan Registri Model.
Memuat himpunan data, melatih model, dan melacak dengan Pelacakan MLflow
Sebelum Anda dapat mendaftarkan model di Registri Model, Anda harus terlebih dahulu melatih dan mencatat model selama percobaan eksekusi. Bagian ini menunjukkan cara memuat himpunan data unit pembangkit tenaga angin, melatih model, dan mencatat eksekusi pelatihan ke MLflow.
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"]
Model latihan
Kode berikut melatih jaringan neural menggunakan TensorFlow Keras untuk memprediksi output daya berdasarkan fitur cuaca dalam himpunan data. MLflow digunakan untuk melacak hiperparameter, metrik performa, kode sumber, dan artefak model.
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
Mendaftarkan dan mengelola model menggunakan antarmuka pengguna MLflow
Di bagian ini:
- Membuat model terdaftar baru
- Menjelajahi antarmuka pengguna Registri Model
- Menambahkan deskripsi model
- Melakukan transisi versi model
Membuat model terdaftar baru
Navigasi ke bilah samping MLflow Experiment Runs dengan mengklik ikon
Eksperimen di bilah samping kanan buku catatan Azure Databricks.
Temukan MLflow Run yang sesuai dengan sesi pelatihan model TensorFlow Keras, dan buka di MLflow Run UI dengan mengklik ikon Tampilkan Detail Eksekusi.
Di antarmuka pengguna MLflow, gulir ke bawah ke bagian Artefak dan klik direktori bernama model. Klik tombol Daftarkan Model yang muncul.
Pilih Buat Model Baru dari menu drop-down, dan masukkan nama model berikut:
power-forecasting-model.Klik Daftar. Tindakan ini akan mendaftarkan model baru yang disebut
power-forecasting-modeldan membuat versi model baru:Version 1.
Setelah beberapa saat, antarmuka pengguna MLflow menampilkan tautan ke model terdaftar baru. Ikuti tautan ini untuk membuka versi model baru di antarmuka pengguna Registri Model MLflow.
Menjelajahi antarmuka pengguna Registri Model
Halaman versi model di antarmuka pengguna Registri Model MLflow memberikan informasi tentang Version 1 model prakiraan terdaftar, termasuk pembuatnya, waktu pembuatan, dan tahap saat ini.
Halaman versi model juga menyediakan tautan Sumber Eksekusi, yang membuka Eksekusi MLflow yang digunakan untuk membuat model di antarmuka pengguna Eksekusi MLflow. Dari antarmuka pengguna Eksekusi MLflow, Anda dapat mengakses tautan buku catatan Sumber untuk melihat snapshot buku catatan Azure Databricks yang digunakan untuk melatih model.
Untuk menavigasi kembali ke Registri Model MLflow, klik 
Model di bilah samping.
Halaman beranda Registri Model MLflow yang dihasilkan menampilkan daftar semua model terdaftar di ruang kerja Azure Databricks Anda, termasuk versi dan tahapannya.
Klik tautan model-prakiraan-daya untuk membuka halaman model terdaftar, yang menampilkan semua versi model prakiraan.
Menambahkan deskripsi model
Anda dapat menambahkan deskripsi ke model terdaftar dan versi model. Deskripsi model terdaftar berguna untuk merekam informasi yang berlaku untuk beberapa versi model (misalnya, gambaran umum masalah pemodelan dan himpunan data). Deskripsi versi model berguna untuk merinci atribut unik dari versi model tertentu (misalnya, metodologi dan algoritma yang digunakan untuk mengembangkan model).
Tambahkan deskripsi tingkat tinggi ke model prakiraan daya terdaftar.
Klik ikon dan masukkan deskripsi berikut: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.
Klik Simpan.
Klik tautan Versi 1 dari halaman model terdaftar untuk masuk kembali ke halaman versi model.
- Klik ikon dan masukkan deskripsi berikut:
This model version was built using TensorFlow Keras. It is a feed-forward neural network with one hidden layer.
Klik Simpan.
Melakukan transisi versi model
Registri Model MLflow mendefinisikan beberapa tahap model: Tidak Ada, Penahapan, Produksi, dan Archived. Setiap tahap memiliki tujuan yang unik. Misalnya, Penahapan dimaksudkan untuk pengujian model, sementara Produksi adalah untuk model yang telah menyelesaikan proses pengujian atau peninjauan dan telah disebarkan ke aplikasi.
Klik tombol Tahap untuk menampilkan daftar tahapan model yang tersedia dan opsi transisi tahap yang tersedia.
Pilih Transisi ke -> Produksi dan tekan OK di jendela konfirmasi transisi tahap untuk mengalihkan model ke Produksi.
Setelah versi model dialihkan ke Produksi, tahap saat ini ditampilkan di antarmuka pengguna, dan entri ditambahkan ke log aktivitas untuk mencerminkan transisi.
Registri Model MLflow memungkinkan beberapa versi model untuk berbagi tahap yang sama. Saat mereferensikan model berdasarkan tahap, Registri Model menggunakan versi model terbaru (versi model dengan ID versi terbesar). Halaman model terdaftar menampilkan semua versi dari model tertentu.
Mendaftarkan dan mengelola model menggunakan API MLflow
Di bagian ini:
- Menentukan nama model secara terprogram
- Mendaftarkan model
- Menambahkan deskripsi model dan versi model menggunakan API
- Melakukan transisi versi model dan mengambil detailnya menggunakan API
Menentukan nama model secara terprogram
Sekarang model telah terdaftar dan dialihkan ke Produksi, Anda dapat mereferensikannya menggunakan API terprogram MLflow. Tentukan nama model terdaftar sebagai berikut:
model_name = "power-forecasting-model"
Mendaftarkan model
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)
Menambahkan deskripsi model dan versi model menggunakan API
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."
)
Melakukan transisi versi model dan mengambil detailnya menggunakan API
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))
Memuat versi model terdaftar 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 Registri Model MLflow.
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)
Memperkirakan output daya dengan model produksi
Pada bagian ini, model produksi digunakan untuk mengevaluasi data prakiraan cuaca untuk unit pembangkit tenaga angin. Aplikasi forecast_power() memuat versi terbaru model prakiraan dari tahap yang ditentukan dan menggunakannya untuk memperkirakan produksi daya selama lima hari ke depan.
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)
Membuat versi model baru
Teknik pembelajaran mesin klasik juga efektif untuk prakiraan daya. Kode berikut melatih model hutan acak menggunakan scikit-learn dan mendaftarkannya dengan Registri Model MLflow melalui fungsi tersebut mlflow.sklearn.log_model().
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,
)
Ambil ID versi model baru menggunakan pencarian Registri Model MLflow
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)
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."
)
Mengalihkan versi model baru ke Penahapan dan menguji model
Sebelum menyebarkan model ke aplikasi produksi, merupakan praktik terbaik untuk mengujinya di lingkungan penahapan. Kode berikut mengalihkan versi model baru ke Penahapan dan mengevaluasi performanya.
client.transition_model_version_stage(
name=model_name,
version=new_model_version,
stage="Staging",
)
forecast_power(model_name, "Staging")
Menyebarkan versi model baru ke Produksi
Setelah memverifikasi bahwa versi model baru berperforma baik dalam penahapan, kode berikut mengalihkan model ke Produksi dan menggunakan kode aplikasi yang sama persis dari bagian Memperkirakan output daya dengan model produksi untuk menghasilkan prakiraan daya.
client.transition_model_version_stage(
name=model_name,
version=new_model_version,
stage="production",
)
forecast_power(model_name, "production")
Sekarang ada dua versi model dari model prakiraan dalam tahap Produksi : versi model yang dilatih dalam model Keras dan versi yang dilatih dalam scikit-learn.
Catatan
Saat mereferensikan model berdasarkan tahap, Registri Model MLflow secara otomatis menggunakan versi produksi terbaru. Tindakan ini memungkinkan Anda untuk memperbarui model produksi Anda tanpa mengubah kode aplikasi apa pun.
Mengarsipkan dan menghapus model
Ketika versi model tidak lagi digunakan, Anda dapat mengarsipkannya atau menghapusnya. Anda juga dapat menghapus seluruh model terdaftar; ini menghapus semua versi model yang terkait.
Mengarsipkan Version 1 model prakiraan daya
Arsipkan Version 1 model prakiraan daya karena sudah tidak lagi digunakan. Anda dapat mengarsipkan model di antarmuka pengguna Registri Model MLflow atau melalui API MLflow.
Mengarsipkan Version 1 di antarmuka pengguna MLflow
Untuk mengarsipkan Version 1 model prakiraan daya:
Buka halaman versi model yang sesuai di antarmuka pengguna Registri Model MLflow:
Klik tombol Tahap, pilih Alihkan Ke -> Diarsipkan:
Tekan OK di jendela konfirmasi transisi tahap.
Mengarsipkan Version 1 menggunakan API MLflow
Kode berikut menggunakan fungsi MlflowClient.update_model_version() untuk mengarsipkan Version 1 model prakiraan daya.
from mlflow.tracking.client import MlflowClient
client = MlflowClient()
client.transition_model_version_stage(
name=model_name,
version=1,
stage="Archived",
)
Menghapus Version 1 model prakiraan daya
Anda juga dapat menggunakan antarmuka pengguna MLflow atau API MLflow untuk menghapus versi model.
Peringatan
Penghapusan versi model bersifat permanen dan tidak dapat dibatalkan.
Menghapus Version 1 di antarmuka pengguna MLflow
Untuk menghapus Version 1 model prakiraan daya:
Buka halaman versi model yang sesuai di UI Registri Model MLflow.
Pilih panah drop-down di samping pengidentifikasi versi dan klik Hapus.
Menghapus Version 1 menggunakan API MLflow
client.delete_model_version(
name=model_name,
version=1,
)
Menghapus model menggunakan API MLflow
Anda harus terlebih dahulu mengalihkan semua tahapan versi model yang tersisa ke Tidak Ada atau Diarsipkan.
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)