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.

Menggunakan pembungkus model

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.

Menggunakan artefak

Model Anda mungkin terdiri dari beberapa bagian yang perlu dimuat. Anda mungkin tidak memiliki cara untuk menserialisasikannya sebagai file Pickle. Dalam kasus tersebut PythonModel , mendukung indikasi daftar artefak arbitrer. Setiap artefak dibungkus bersama dengan model Anda.

Gunakan teknik ini ketika:

• Anda tidak dapat membuat serial model dalam format Pickle, atau Anda memiliki format serialisasi yang lebih baik yang tersedia
• Model Anda memiliki satu, atau banyak, artefak harus dirujuk untuk memuat model
• Anda mungkin ingin mempertahankan beberapa properti konfigurasi inferensi - misalnya, jumlah item yang akan direkomendasikan
• Anda ingin menyesuaikan cara model dimuat, dan cara predict kerja fungsi

Sampel kode ini menunjukkan cara mencatat model kustom, menggunakan artefak:

encoder_path = 'encoder.pkl'
joblib.dump(encoder, encoder_path)

model_path = 'xgb.model'
model.save_model(model_path)

mlflow.pyfunc.log_model("classifier", 
                        python_model=ModelWrapper(),
                        artifacts={ 
                            'encoder': encoder_path,
                            'model': model_path 
                        },
                        signature=signature)

Catatan

• Model tidak disimpan sebagai acar. Sebagai gantinya, kode menyimpan model dengan metode simpan kerangka kerja yang Anda gunakan
• Pembungkus model adalah ModelWrapper(), tetapi model tidak diteruskan sebagai parameter ke konstruktor Parameter kamus baru - - artifacts memiliki kunci sebagai nama artefak, dan nilai sebagai jalur dalam sistem file lokal tempat artefak disimpan

Pembungkus model yang sesuai kemudian akan terlihat seperti ini:

from mlflow.pyfunc import PythonModel, PythonModelContext

class ModelWrapper(PythonModel):
    def load_context(self, context: PythonModelContext):
        import pickle
        from xgboost import XGBClassifier
        from sklearn.preprocessing import OrdinalEncoder
        
        self._encoder = pickle.loads(context.artifacts["encoder"])
        self._model = XGBClassifier(use_label_encoder=False, eval_metric="logloss")
        self._model.load_model(context.artifacts["model"])

    def predict(self, context: PythonModelContext, data):
        return self._model.predict_proba(data)

Rutinitas pelatihan lengkap akan terlihat seperti ini:

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

mlflow.xgboost.autolog(log_models=False)

encoder = OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=np.nan)
X_train['thal'] = encoder.fit_transform(X_train['thal'].to_frame())
X_test['thal'] = encoder.transform(X_test['thal'].to_frame())

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)

encoder_path = 'encoder.pkl'
joblib.dump(encoder, encoder_path)
model_path = "xgb.model"
model.save_model(model_path)

signature = infer_signature(X, y_probs)
mlflow.pyfunc.log_model("classifier", 
                        python_model=ModelWrapper(),
                        artifacts={ 
                            'encoder': encoder_path,
                            'model': model_path 
                        },
                        signature=signature)

Menggunakan pemuat model

Model mungkin memiliki logika yang kompleks, atau mungkin memuat beberapa file sumber pada waktu inferensi. Ini terjadi jika Anda memiliki pustaka Python untuk model Anda, misalnya. Dalam skenario ini, Anda harus mengemas pustaka bersama dengan model Anda, sehingga dapat bergerak sebagai satu bagian.

Gunakan teknik ini ketika:

• Anda tidak dapat membuat serial model dalam format Pickle, atau Anda memiliki format serialisasi yang lebih baik yang tersedia
• Anda dapat menyimpan artefak model Anda di folder yang menyimpan semua artefak yang diperlukan
• Kode sumber model Anda memiliki kompleksitas besar, dan memerlukan beberapa file Python. Berpotensi, pustaka mendukung model Anda
• Anda ingin menyesuaikan cara model dimuat, dan cara predict fungsi beroperasi

MLflow mendukung model ini. Dengan MLflow, Anda dapat menentukan kode sumber arbitrer apa pun untuk dipaketkan bersama dengan model, selama memiliki modul pemuat. Anda dapat menentukan modul pemuat dalam log_model() instruksi dengan loader_module argumen , yang menunjukkan namespace layanan Python yang mengimplementasikan pemuat. Argumen code_path juga diperlukan, untuk menunjukkan file sumber yang menentukan loader_module. Di namespace layanan ini, Anda harus menerapkan _load_pyfunc(data_path: str) fungsi yang menerima jalur artefak, dan mengembalikan objek dengan prediksi metode (setidaknya).

model_path = 'xgb.model'
model.save_model(model_path)

mlflow.pyfunc.log_model("classifier", 
                        data_path=model_path,
                        code_path=['src'],
                        loader_module='loader_module'
                        signature=signature)

Catatan

• Model tidak disimpan sebagai acar. Sebagai gantinya, kode menyimpan model dengan metode simpan kerangka kerja yang Anda gunakan
• Parameter baru - data_path - menunjuk ke folder yang menyimpan artefak model. Artefak dapat berupa folder atau file. Artefak tersebut - baik folder atau file - akan dimas dengan model
• Parameter baru - code_path - menunjuk ke lokasi kode sumber. Sumber daya di lokasi ini dapat berupa jalur atau satu file. Sumber daya tersebut - baik folder atau file - akan dimas dengan model
• Fungsi fungsi _load_pyfunc disimpan dalam loader_module modul Python

Folder src berisi loader_module.py file. File tersebut adalah modul pemuat:

src/loader_module.py

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

    def predict(self, data):
        return self._model.predict_proba(data)

def _load_pyfunc(data_path: str):
    import os

    model = XGBClassifier(use_label_encoder=False, eval_metric='logloss')
    model.load_model(os.path.abspath(data_path))

    return MyModel(model)

Catatan

• Kelas MyModel tidak mewarisi dari PythonModel seperti yang ditunjukkan sebelumnya. Namun, ia memiliki predict fungsi
• Kode sumber model ada dalam file. Kode sumber apa pun akan berfungsi. Folder src sangat ideal untuk ini
• Fungsi _load_pyfunc mengembalikan instans kelas model

Kode pelatihan lengkap terlihat seperti ini:

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)

model_path = "xgb.model"
model.save_model(model_path)

signature = infer_signature(X_test, y_probs)
mlflow.pyfunc.log_model("classifier",
                        data_path=model_path,
                        code_path=["loader_module.py"],
                        loader_module="loader_module",
                        signature=signature)

Langkah berikutnya

• Menyebarkan model MLflow