Bagikan melalui


Mencatat model MLflow

Artikel ini menjelaskan cara mencatat model terlatih Anda (atau artefak) sebagai model MLflow. Ini mengeksplorasi berbagai cara untuk menyesuaikan bagaimana MLflow mengemas model Anda, dan bagaimana ia menjalankan model tersebut.

Mengapa harus model pengelogan dan bukan artefak?

Dari artefak hingga model di MLflow menjelaskan perbedaan antara artefak atau file pengelogan, dibandingkan dengan pengelogan model MLflow.

Model MLflow juga merupakan artefak. Namun, model tersebut memiliki struktur tertentu yang berfungsi sebagai kontrak antara orang yang membuat model dan orang yang ingin menggunakannya. Kontrak ini membantu membangun jembatan antara artefak itu sendiri dan maknanya.

Pengelogan model memiliki keuntungan berikut:

  • Anda dapat langsung memuat model, untuk inferensi, dengan mlflow.<flavor>.load_model, dan Anda dapat menggunakan predict fungsi
  • Input alur dapat menggunakan model secara langsung
  • Anda dapat menyebarkan model tanpa indikasi skrip penilaian atau lingkungan
  • Swagger secara otomatis diaktifkan di titik akhir yang disebarkan, dan studio Azure Pembelajaran Mesin dapat menggunakan fitur Uji
  • Anda dapat menggunakan dasbor AI yang bertanggung jawab

Bagian ini menjelaskan cara menggunakan konsep model di Azure Pembelajaran Mesin dengan MLflow:

Model pengelogan menggunakan autolog

Anda dapat menggunakan fungsionalitas autolog MLflow. Autolog memungkinkan MLflow untuk menginstruksikan kerangka kerja yang digunakan untuk mencatat semua metrik, parameter, artefak, dan model yang dianggap relevan oleh kerangka kerja. Secara default, jika autolog diaktifkan, sebagian besar model dicatat. Dalam beberapa situasi, beberapa rasa mungkin tidak mencatat model. Misalnya, rasa PySpark tidak mencatat model yang melebihi ukuran tertentu.

Gunakan salah satu mlflow.autolog() atau mlflow.<flavor>.autolog() untuk mengaktifkan pengelogan otomatis. Contoh ini digunakan untuk mencatat model pengklasifikasi autolog() yang dilatih dengan XGBoost:

import mlflow
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score

mlflow.autolog()

model = XGBClassifier(use_label_encoder=False, eval_metric="logloss")
model.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)

y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

Tip

Jika menggunakan alur Pembelajaran Mesin, misalnya alur Scikit-Learn, gunakan fungsionalitas ragam alur tersebut autolog untuk mencatat model. Pengelogan model secara otomatis terjadi ketika fit() metode dipanggil pada objek alur. Melatih dan melacak pengklasifikasi XGBoost dengan notebook MLflow menunjukkan cara mencatat model dengan praproscesing, menggunakan alur.

Model pengelogan dengan tanda tangan, lingkungan, atau sampel khusus

Metode MLflow mlflow.<flavor>.log_model dapat mencatat model secara manual. Alur kerja ini dapat mengontrol berbagai aspek pengelogan model.

Gunakan metode ini ketika:

  • Anda ingin menunjukkan paket pip atau lingkungan conda yang berbeda dari yang terdeteksi secara otomatis
  • Anda ingin menyertakan contoh input
  • Anda ingin menyertakan artefak tertentu dalam paket yang diperlukan
  • autolog tidak menyimpulkan tanda tangan Anda dengan benar. Ini penting ketika Anda berurusan dengan input tensor, di mana tanda tangan membutuhkan bentuk tertentu
  • Perilaku autolog tidak mencakup tujuan Anda karena alasan tertentu

Contoh kode ini mencatat model untuk pengklasifikasi XGBoost:

import mlflow
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score
from mlflow.models import infer_signature
from mlflow.utils.environment import _mlflow_conda_env

mlflow.autolog(log_models=False)

model = XGBClassifier(use_label_encoder=False, eval_metric="logloss")
model.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
y_pred = model.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)

# Signature
signature = infer_signature(X_test, y_test)

# Conda environment
custom_env =_mlflow_conda_env(
    additional_conda_deps=None,
    additional_pip_deps=["xgboost==1.5.2"],
    additional_conda_channels=None,
)

# Sample
input_example = X_train.sample(n=1)

# Log the model manually
mlflow.xgboost.log_model(model, 
                         artifact_path="classifier", 
                         conda_env=custom_env,
                         signature=signature,
                         input_example=input_example)

Catatan

  • autologlog_models=False memiliki konfigurasi. Ini mencegah pengelogan model MLflow otomatis. Pengelogan model MLflow otomatis terjadi nanti, sebagai proses manual
  • infer_signature Gunakan metode untuk mencoba menyimpulkan tanda tangan langsung dari input dan output
  • Metode ini mlflow.utils.environment._mlflow_conda_env adalah metode privat dalam MLflow SDK. Dalam contoh ini, itu membuat kode lebih sederhana, tetapi menggunakannya dengan hati-hati. Ini dapat berubah di masa depan. Sebagai alternatif, Anda dapat menghasilkan definisi YAML secara manual sebagai kamus Python.

Mencatat model dengan perilaku berbeda dalam metode prediksi

Saat mencatat model dengan mlflow.autolog atau mlflow.<flavor>.log_model, ragam model menentukan cara menjalankan inferensi, dan apa yang dikembalikan model. MLflow tidak memberlakukan perilaku spesifik apa pun tentang pembuatan predict hasil. Dalam beberapa skenario, Anda mungkin ingin melakukan beberapa praproses atau pasca-pemrosesan sebelum dan sesudah model Anda dijalankan.

Dalam situasi ini, terapkan alur pembelajaran mesin yang langsung berpindah dari input ke output. Meskipun implementasi ini dimungkinkan, dan kadang-kadang didorong untuk meningkatkan performa, mungkin menjadi tantangan untuk dicapai. Dalam kasus tersebut, ini dapat membantu menyesuaikan bagaimana model Anda menangani inferensi seperti yang dijelaskan di bagian berikutnya.

Mencatat model kustom

MLflow mendukung banyak kerangka kerja pembelajaran mesin, termasuk

  • CatBoost
  • FastAI
  • h2o
  • Keras
  • LightGBM
  • MLeap
  • MXNet Gluon
  • ONNX
  • Prophet
  • PyTorch
  • Scikit-Learn
  • spaSi
  • Spark MLLib
  • statsmodels
  • TensorFlow
  • XGBoost

Namun, Anda mungkin perlu mengubah cara kerja rasa, mencatat model yang tidak didukung secara asli oleh MLflow atau bahkan mencatat model yang menggunakan beberapa elemen dari kerangka kerja yang berbeda. Dalam kasus ini, Anda mungkin perlu membuat rasa model kustom.

Untuk mengatasi masalah tersebut, MLflow memperkenalkan pyfunc rasa (dimulai dari fungsi Python). Rasa ini dapat mencatat objek apa pun sebagai model, selama objek tersebut memenuhi dua kondisi:

  • Anda menerapkan predict metode, setidaknya
  • Objek Python mewarisi dari mlflow.pyfunc.PythonModel

Tip

Model yang dapat diserialisasikan yang mengimplementasikan API Scikit-learn dapat menggunakan rasa Scikit-learn untuk mencatat model, terlepas dari apakah model dibangun dengan Scikit-learn. Jika Anda dapat mempertahankan model dalam format Pickle, dan objek memiliki predict() metode dan predict_proba() (setidaknya), Anda dapat menggunakan mlflow.sklearn.log_model() untuk mencatat model di dalam eksekusi MLflow.

Jika Anda membuat pembungkus di sekitar objek model yang ada, itu menjadi yang paling sederhana untuk membuat rasa untuk model kustom Anda. MLflow menserialisasikan dan mengemasnya untuk Anda. Objek Python dapat diserialisasikan ketika objek dapat disimpan dalam sistem file sebagai file, umumnya dalam format Pickle. Pada runtime, objek dapat terwujud dari file tersebut. Ini memulihkan semua nilai, properti, dan metode yang tersedia ketika disimpan.

Gunakan metode ini ketika:

  • Anda dapat menserialisasikan model Anda dalam format Pickle
  • Anda ingin mempertahankan status model, karena hanya setelah pelatihan
  • Anda ingin menyesuaikan cara predict kerja fungsi.

Sampel kode ini membungkus model yang dibuat dengan XGBoost, untuk membuatnya bertingkah berbeda dari implementasi default rasa XGBoost. Sebaliknya, ia mengembalikan probabilitas alih-alih kelas:

from mlflow.pyfunc import PythonModel, PythonModelContext

class ModelWrapper(PythonModel):
    def __init__(self, model):
        self._model = model

    def predict(self, context: PythonModelContext, data):
        # You don't have to keep the semantic meaning of `predict`. You can use here model.recommend(), model.forecast(), etc
        return self._model.predict_proba(data)

    # You can even add extra functions if you need to. Since the model is serialized,
    # all of them will be available when you load your model back.
    def predict_batch(self, data):
        pass

Catat model kustom dalam proses:

import mlflow
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score
from mlflow.models import infer_signature

mlflow.xgboost.autolog(log_models=False)

model = XGBClassifier(use_label_encoder=False, eval_metric="logloss")
model.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
y_probs = model.predict_proba(X_test)

accuracy = accuracy_score(y_test, y_probs.argmax(axis=1))
mlflow.log_metric("accuracy", accuracy)

signature = infer_signature(X_test, y_probs)
mlflow.pyfunc.log_model("classifier", 
                        python_model=ModelWrapper(model),
                        signature=signature)

Tip

Di sini, metode ini infer_signature menggunakan y_probs untuk menyimpulkan tanda tangan. Kolom target kami memiliki kelas target, tetapi model kami sekarang mengembalikan dua probabilitas untuk setiap kelas.

Langkah berikutnya