MLflow modellerini günlüğe kaydetme

Bu makalede, eğitilen modellerinizin (veya yapıtlarınızın) MLflow modelleri olarak nasıl günlüğe kaydedildiği açıklanır. MLflow'un modellerinizi nasıl paketleyişini ve bu modelleri nasıl çalıştıracaklarını özelleştirmenin farklı yollarını keşfeder.

Neden yapıtlar yerine modelleri günlüğe kaydetmeli?

MLflow'da yapıtlardan modellere, MLflow modellerini günlüğe kaydetmeye kıyasla günlük yapıtları veya dosyaları arasındaki farkı açıklar.

MLflow modeli de bir yapıttır. Ancak bu model, modeli oluşturan kişi ile kullanmayı amaçlayan kişi arasında sözleşme görevi görecek belirli bir yapıya sahiptir. Bu sözleşme, yapıtların kendileri ve anlamları arasında bir köprü oluşturulmasına yardımcı olur.

Model günlüğü şu avantajlara sahiptir:

• Modelleri çıkarım için ile mlflow.<flavor>.load_modeldoğrudan yükleyebilir ve işlevini kullanabilirsiniz predict
• İşlem hattı girişleri modelleri doğrudan kullanabilir
• Puanlama betiği veya ortam belirtmeden modelleri dağıtabilirsiniz
• Dağıtılan uç noktalarda Swagger otomatik olarak etkinleştirilir ve Azure Machine Learning stüdyosu Test özelliğini kullanabilir
• Sorumlu yapay zeka panosunu kullanabilirsiniz

Bu bölümde, MLflow ile Azure Machine Learning'de modelin kavramının nasıl kullanılacağı açıklanmaktadır:

Otomatik kaydetme kullanarak modelleri günlüğe kaydetme

MLflow otomatik tamamlama işlevini kullanabilirsiniz. Otomatik kaydetme, MLflow'un çerçevenin ilgili olarak değerlendirdiğini düşündüğü tüm ölçümleri, parametreleri, yapıtları ve modelleri günlüğe kaydetmek için kullanılan çerçeveyi bildirmesine olanak tanır. Varsayılan olarak, otomatik kaydetme etkinse çoğu model günlüğe kaydedilir. Bazı durumlarda, bazı tatlar bir modeli günlüğe kaydetmeyebilir. Örneğin, PySpark aroması belirli bir boyutu aşan modelleri günlüğe kaydetmez.

mlflow.autolog() Otomatik kaydetmeyi etkinleştirmek için veya mlflow.<flavor>.autolog() kullanın. Bu örnek, XGBoost ile eğitilen bir sınıflandırıcı modelini günlüğe kaydetmek için kullanır autolog() :

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)

İpucu

Scikit-Learn işlem hatları gibi Machine Learning işlem hatlarını kullanıyorsanız modelleri günlüğe kaydetmek için bu işlem hattı özelliğinin işlevselliğini kullanın autolog . Yöntem işlem hattı nesnesinde fit() çağrıldığında model günlüğü otomatik olarak gerçekleşir. MLflow not defteriyle bir XGBoost sınıflandırıcısını eğitmek ve izlemek, işlem hatlarını kullanarak bir modelin ön işleme ile nasıl günlüğe kaydedileceklerini gösterir.

Özel imza, ortam veya örneklerle modelleri günlüğe kaydetme

MLflow mlflow.<flavor>.log_model yöntemi modelleri el ile günlüğe kaydedebilir. Bu iş akışı, model günlüğünün farklı yönlerini denetleyebilir.

Şu durumlarda bu yöntemi kullanın:

• Pip paketlerini veya otomatik olarak algılananlardan farklı bir conda ortamını belirtmek istiyorsunuz
• Giriş örnekleri eklemek istiyorsunuz
• Belirli yapıtları gerekli pakete eklemek istiyorsunuz
• autolog imzanızı doğru çıkarmıyor. Bu, imzanın belirli şekillere ihtiyaç duyduğu tensor girişleriyle uğraşırken önemlidir
• Otomatik tamamlama davranışı bir nedenden dolayı amacınızı kapsamaz

Bu kod örneği, XGBoost sınıflandırıcısı için bir modeli günlüğe kaydeder:

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)

Not

• autolog yapılandırmaya log_models=False sahiptir. Bu, otomatik MLflow modeli günlüğünü engeller. Otomatik MLflow model günlüğü daha sonra el ile gerçekleştirilen bir işlem olarak gerçekleşir
• İmzayı infer_signature doğrudan girişlerden ve çıkışlardan çıkarmaya çalışmak için yöntemini kullanın
• mlflow.utils.environment._mlflow_conda_env yöntemi, MLflow SDK'sında özel bir yöntemdir. Bu örnekte, kodu daha basit hale getirir, ancak dikkatli kullanın. Gelecekte değişebilir. Alternatif olarak YAML tanımını Python sözlüğü olarak el ile oluşturabilirsiniz.

Tahmin yönteminde farklı davranışa sahip modelleri günlüğe kaydetme

Veya mlflow.<flavor>.log_modelile mlflow.autolog bir modeli günlüğe kaydettiğinizde, modelin türü çıkarımın nasıl yürütüleceğini ve modelin ne döndüreceğini belirler. MLflow, sonuçların oluşturulmasıyla predict ilgili belirli bir davranışı zorunlu kılmaz. Bazı senaryolarda, modeliniz yürütülmeden önce ve sonra bazı ön işleme veya işlem sonrası işlemler yapmak isteyebilirsiniz.

Bu durumda girişlerden çıkışlara doğrudan taşınan makine öğrenmesi işlem hatlarını uygulayın. Bu uygulama mümkün olsa ve bazen performansı geliştirmek için teşvik edilse de, elde etmek zor olabilir. Bu gibi durumlarda, modelinizin çıkarımla nasıl başa çıkabileceğini sonraki bölümde açıklandığı gibi özelleştirmenize yardımcı olabilir.

Özel modelleri günlüğe kaydetme

MLflow, dahil olmak üzere birçok makine öğrenmesi çerçevesini destekler

• CatBoost
• FastAI
• h2o
• Keras
• LightGBM
• MLeap
• MXNet Gluon
• ONNX
• Peygamber
• PyTorch
• Scikit-Learn
• spaCy
• Spark MLLib
• statsmodeller
• TensorFlow
• XGBoost

Ancak, bir aromanın çalışma şeklini değiştirmeniz, MLflow tarafından yerel olarak desteklenmeyen bir modeli günlüğe kaydetmeniz ve hatta farklı çerçevelerden birden çok öğe kullanan bir modeli günlüğe kaydetmeniz gerekebilir. Bu gibi durumlarda, özel bir model türü oluşturmanız gerekebilir.

MLflow, sorunu çözmek için aromayı pyfunc tanıtır (Python işlevinden başlayarak). Bu özellik, nesne iki koşulu karşıladıkça herhangi bir nesneyi model olarak günlüğe kaydedebilir:

• Yöntem predict yöntemini en azından uygularsınız
• Python nesnesinin devraldığı yer: mlflow.pyfunc.PythonModel

İpucu

Scikit-learn API'sini uygulayan serileştirilebilir modeller, modelin Scikit-learn ile oluşturulmuş olup olmadığına bakılmaksızın modeli günlüğe kaydetmek için Scikit-learn türünü kullanabilir. Modelinizi Pickle biçiminde kalıcı hale getirebiliyorsanız ve nesnesi ve yöntemlerine predict() (en azından) sahipse, modeli bir MLflow çalıştırmasının içinde günlüğe kaydetmek için kullanabilirsinizmlflow.sklearn.log_model().predict_proba()

Model sarmalayıcı kullanma

Mevcut model nesnenizin çevresinde bir sarmalayıcı oluşturursanız, özel modeliniz için bir tür oluşturmak en kolay hale gelir. MLflow bunu sizin için seri hale getirerek paketler. Python nesneleri, nesne dosya sisteminde genellikle Pickle biçiminde bir dosya olarak depolanabilirse seri hale getirilebilir. Çalışma zamanında nesnesi bu dosyadan gerçekleştirebilir. Bu, kaydedildiğinde kullanılabilen tüm değerleri, özellikleri ve yöntemleri geri yükler.

Şu durumlarda bu yöntemi kullanın:

• Modelinizi Pickle biçiminde seri hale getirebilirsiniz
• Modelin durumunu eğitimden hemen sonra olduğu gibi korumak istiyorsunuz
• İşlevin predict nasıl çalıştığını özelleştirmek istiyorsunuz.

Bu kod örneği, XGBoost flavor varsayılan uygulamasından farklı bir şekilde davranmasını sağlamak için XGBoost ile oluşturulan bir modeli sarmalar. Bunun yerine, sınıflar yerine olasılıkları döndürür:

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

Çalıştırmada özel bir modeli günlüğe kaydedin:

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)

İpucu

Burada yöntemi, imzayı infer_signature çıkarsamak için kullanır y_probs . Hedef sütunumuzda hedef sınıf vardır, ancak modelimiz artık her sınıf için iki olasılığı döndürür.

Yapıtları kullanma

Modeliniz yüklenmesi gereken birden çok parçadan oluşuyor olabilir. Pickle dosyası olarak seri hale getirmek için bir yolunuz olmayabilir. Bu gibi durumlarda, PythonModel rastgele bir yapıt listesinin göstergesini destekler. Her yapıt modelinizle birlikte paketlenmiş olur.

Şu durumlarda bu tekniği kullanın:

• Modelinizi Pickle biçiminde seri hale getiremezsiniz veya daha iyi bir serileştirme biçimine sahipsiniz
• Modelinizin bir veya daha fazla yapıtı var, modeli yüklemek için başvurulmalıdır
• Bazı çıkarım yapılandırma özelliklerini (örneğin, önerecek öğe sayısını) kalıcı hale getirmek isteyebilirsiniz
• Modelin yüklenme şeklini ve işlevin nasıl çalıştığını özelleştirmek predict istiyorsunuz

Bu kod örneği, yapıtları kullanarak özel modeli günlüğe kaydetmeyi gösterir:

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)

Not

• Model bir turşu olarak kaydedilmez. Bunun yerine kod, kullandığınız çerçevenin kaydetme yöntemiyle modeli kaydetti
• Model sarmalayıcı şeklindedir ModelWrapper(), ancak model oluşturucuya parametre olarak geçirilmemiş Yeni sözlük parametresi - artifacts - yapıt adları olarak anahtarlara ve yapıtın depolandığı yerel dosya sisteminde yol olarak değerlere sahiptir

Buna karşılık gelen model sarmalayıcı şöyle görünür:

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)

Tam eğitim yordamı şöyle görünür:

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)

Model yükleyici kullanma

Modelin karmaşık mantığı olabilir veya çıkarım zamanında birkaç kaynak dosyası yükleyebilir. Örneğin, modeliniz için bir Python kitaplığınız varsa bu durum ortaya çıkar. Bu senaryoda, kitaplığı modelinizle birlikte paketlemelisiniz; böylece tek parça olarak taşınabilir.

Şu durumlarda bu tekniği kullanın:

• Modelinizi Pickle biçiminde seri hale getiremezsiniz veya daha iyi bir serileştirme biçimine sahipsiniz
• Model yapıtlarınızı tüm gerekli yapıtları depolayan bir klasörde depolayabilirsiniz
• Model kaynak kodunuz çok karmaşıktır ve birden çok Python dosyası gerektirir. Büyük olasılıkla, bir kitaplık modelinizi destekler
• Modelin yüklenme şeklini ve işlevin predict çalışma şeklini özelleştirmek istiyorsunuz

MLflow bu modelleri destekler. MLflow ile, bir yükleyici modülü olduğu sürece modelle birlikte paketlenecek herhangi bir rastgele kaynak kodu belirtebilirsiniz. Yönergede yükleyici modüllerini, yükleyiciyi log_model()loader_module uygulayan Python ad alanını gösteren bağımsız değişkeniyle belirtebilirsiniz. code_path bağımsız değişkeni, öğesini tanımlayan loader_modulekaynak dosyaları belirtmek için de gereklidir. Bu ad alanında, yapıtların yolunu alan ve tahmin yöntemine (en azından) sahip bir nesne döndüren bir işlev uygulamanız _load_pyfunc(data_path: str) gerekir.

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)

Not

• Model bir turşu olarak kaydedilmez. Bunun yerine kod, kullandığınız çerçevenin kaydetme yöntemiyle modeli kaydetti
• Yeni bir parametre - data_path - model yapıtlarını barındıran klasörü işaret eder. Yapıtlar bir klasör veya dosya olabilir. Bu yapıtlar (klasör veya dosya) modelle birlikte paketlenir
• Yeni bir parametre - code_path - kaynak kod konumunu gösterir. Bu konumdaki bu kaynak bir yol veya tek bir dosya olabilir. Bu kaynak (klasör veya dosya) modelle birlikte paketlenir
• İşlev _load_pyfunc işlevi Python modülünde loader_module depolanır

src klasörü dosyayı içerirloader_module.py. Bu dosya yükleyici modülüdür:

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)

Not

• Sınıfı MyModel , daha önce gösterildiği gibi öğesinden PythonModel devralmaz. Ancak, bir predict işlevi vardır
• Model kaynak kodu bir dosyadadır. Herhangi bir kaynak kodu çalışır. Src klasörü bunun için idealdir
• İşlev _load_pyfunc , model sınıfının bir örneğini döndürür

Eğitim kodunun tamamı şöyle görünür:

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)

Sonraki adımlar

• MLflow modellerini dağıtma