MLflow-modellek naplózása

Ez a cikk bemutatja, hogyan naplózhatja a betanított modelleket (vagy összetevőket) MLflow-modellként. Bemutatja, hogyan szabhatja testre az MLflow a modellek csomagjait, és hogyan futtatja ezeket a modelleket.

Miért érdemes modelleket naplózni összetevők helyett?

Az összetevőktől az MLflow-modellekig a naplózási összetevők és a fájlok közötti különbséget írja le az MLflow-modellek naplózásához képest.

Az MLflow-modell szintén összetevő. Ennek a modellnek azonban van egy konkrét struktúrája, amely szerződésként szolgál a modellt létrehozó személy és a használni kívánt személy között. Ez a szerződés segít hidat építeni az összetevők és jelentésük között.

A modellnaplózás az alábbi előnyökkel jár:

• Közvetlenül betöltheti a modelleket a következtetéshez, mlflow.<flavor>.load_modelés használhatja a függvényt predict
• A folyamatbemenetek közvetlenül használhatnak modelleket
• A modelleket pontozó szkript vagy környezet megjelölése nélkül is üzembe helyezheti
• A Swagger automatikusan engedélyezve van az üzembe helyezett végpontokon, és az Azure Machine Tanulás studio használhatja a Tesztelés funkciót
• Használhatja a Felelős AI-irányítópultot

Ez a szakasz azt ismerteti, hogyan használhatja a modell koncepcióját az Azure Machine Tanulás az MLflow használatával:

Modellek naplózása autolog használatával

Az MLflow automatikus naplófunkciói is használhatók. Az autolog lehetővé teszi, hogy az MLflow utasítsa a keretrendszert a keretrendszer által relevánsnak ítélt összes metrikának, paraméternek, összetevőnek és modellnek a naplózására. Alapértelmezés szerint, ha az autolog engedélyezve van, a legtöbb modell naplózása történik. Bizonyos esetekben előfordulhat, hogy egyes ízek nem naplóznak egy modellt. A PySpark-íz például nem naplózza azokat a modelleket, amelyek túllépnek egy bizonyos méretet.

Használja vagy mlflow.autolog()mlflow.<flavor>.autolog() aktiválja az automatikus kitöltést. Ez a példa egy XGBoosttal betanított osztályozómodell naplózására használható 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)

Tipp.

Ha gépi Tanulás folyamatokat( például Scikit-Learn-folyamatokat) használ, használja a folyamat ízének funkcióit a autolog modellek naplózásához. A modellnaplózás automatikusan megtörténik, amikor a fit() metódust meghívják a folyamatobjektumon. Az XGBoost-osztályozó betanítása és nyomon követése az MLflow-jegyzetfüzettel bemutatja, hogyan naplózhat egy modellt előfeldolgozással, folyamatok használatával.

Naplózási modellek egyéni aláírással, környezettel vagy mintákkal

Az MLflow mlflow.<flavor>.log_model metódus manuálisan naplózhatja a modelleket. Ez a munkafolyamat a modellnaplózás különböző aspektusait szabályozhatja.

Ezt a módszert akkor használja, ha:

• Olyan pipcsomagokat vagy conda környezetet szeretne jelezni, amelyek eltérnek az automatikusan észleltektől
• Bemeneti példákat szeretne felvenni
• Konkrét összetevőket szeretne belefoglalni a szükséges csomagba
• autolog nem megfelelően következtet az aláírásra. Ez akkor számít, ha tenzoros bemenetekkel foglalkozik, ahol az aláírásnak meghatározott alakzatokra van szüksége
• Az autolog viselkedés valamilyen okból nem fedi le a célját

Ez a példakód egy XGBoost-osztályozó modelljét naplózza:

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)

Feljegyzés

• autolog konfigurációval log_models=False rendelkezik. Ez megakadályozza az MLflow-modell automatikus naplózását. Az MLflow-modell automatikus naplózása később, manuális folyamatként történik
• infer_signature A metódus használatával próbálja meg közvetlenül a bemenetekből és kimenetekből kikövetkezni az aláírást
• A mlflow.utils.environment._mlflow_conda_env metódus egy privát metódus az MLflow SDK-ban. Ebben a példában egyszerűbbé teszi a kódot, de óvatosan használja. Ez a jövőben változhat. Másik lehetőségként manuálisan is létrehozhatja a YAML-definíciót Python-szótárként.

Más viselkedésű naplózási modellek az előrejelzési módszerben

Ha egy modellt egy vagy mlflow.<flavor>.log_modeltöbb mlflow.autolog típussal naplóz, a modell íze határozza meg, hogyan hajthatja végre a következtetést, és hogy a modell mit ad vissza. Az MLflow nem kényszerít semmilyen konkrét viselkedést az eredmények generálására predict vonatkozóan. Bizonyos esetekben érdemes lehet némi előfeldolgozást vagy utófeldolgozást végezni a modell végrehajtása előtt és után.

Ebben a helyzetben olyan gépi tanulási folyamatokat implementálhat, amelyek közvetlenül a bemenetekről a kimenetekre váltanak. Bár ez a megvalósítás lehetséges, és néha a teljesítmény javítására ösztönözhető, nehéz lehet elérni. Ezekben az esetekben segíthet testre szabni , hogyan kezeli a modell a következtetést a következő szakaszban ismertetett módon.

Egyéni modellek naplózása

Az MLflow számos gépi tanulási keretrendszert támogat, többek között

• CatBoost
• FastAI
• H2o
• Keras
• LightGBM
• MLeap
• MXNet Gluon
• ONNX
• Próféta
• PyTorch
• Scikit-Learn
• spaCy
• Spark MLLib
• statsmodels
• TensorFlow
• XGBoost

Előfordulhat azonban, hogy módosítania kell az ízek működését, naplóznia kell egy olyan modellt, amelyet az MLflow nem támogat natív módon, vagy akár naplóznia kell egy olyan modellt, amely különböző keretrendszerek több elemét használja. Ezekben az esetekben előfordulhat, hogy egyéni modellstílust kell létrehoznia.

A probléma megoldásához az MLflow bevezeti az pyfunc ízt (Egy Python-függvénytől kezdve). Ez az íz bármilyen objektumot képes modellként naplózni, ha az objektum két feltételnek felel meg:

• Implementálja a metódust predict , legalább
• A Python-objektum a következőtől öröklődik: mlflow.pyfunc.PythonModel

Tipp.

A Scikit-learn API-t implementáló szerializálható modellek a Scikit-learn-íz használatával naplózhatják a modellt, függetlenül attól, hogy a modell a Scikit-learn használatával készült-e. Ha meg tudja őrizni a modellt Pickle formátumban, és az objektum rendelkezik azokkal predict() és predict_proba() metódusokkal (legalább), akkor mlflow.sklearn.log_model() a modell naplózható egy MLflow-futtatáson belül.

Modellburkoló használata

Ha burkolót hoz létre a meglévő modellobjektum köré, az lesz a legegyszerűbb az egyéni modellhez. Az MLflow szerializálja és csomagolja Önnek. A Python-objektumok szerializálhatók, ha az objektum fájlként, általában Pickle formátumban tárolható a fájlrendszerben. Futásidőben az objektum az adott fájlból származhat. Ezzel visszaállítja a mentéskor elérhető összes értéket, tulajdonságot és metódust.

Ezt a módszert akkor használja, ha:

• A modellt pickle formátumban szerializálhatja
• Meg szeretné őrizni a modell állapotát, mivel az éppen a betanítás után történt
• Testre szeretné szabni a predict függvény működését.

Ez a kódminta körbefuttat egy XGBoosttal létrehozott modellt, hogy az az alapértelmezett XGBoost-verziótól eltérő módon viselkedjen. Ehelyett a valószínűségeket adja vissza az osztályok helyett:

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

Egyéni modell naplózása a futtatás során:

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)

Tipp.

Ebben a módszerben y_probs az infer_signature aláírást kell kikövetkeztetnie. A céloszlop a célosztályt tartalmazza, de a modellünk most az egyes osztályok két valószínűségét adja vissza.

Összetevők használata

Előfordulhat, hogy a modell több darabból áll, amelyeket be kell tölteni. Lehet, hogy nincs módja arra, hogy pickle-fájlként szerializálja. Ezekben az esetekben az PythonModel összetevők tetszőleges listájának jelölését támogatja. Minden összetevő a modellel együtt van csomagolva.

Használja ezt a technikát a következő esetekben:

• A modellt nem lehet pickle formátumban szerializálni, vagy jobb szerializálási formátum érhető el
• A modell egy vagy több összetevőre hivatkozik a modell betöltéséhez
• Előfordulhat, hogy meg szeretne őrizni néhány következtetési konfigurációs tulajdonságot – például az ajánlott elemek számát
• Testre szeretné szabni a modell terhelését és a predict függvény működését

Ez a kódminta bemutatja, hogyan naplózhat egyéni modellt összetevők használatával:

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)

Feljegyzés

• A modell nem pickle-ként van mentve. Ehelyett a kód mentette a modellt a használt keretrendszer mentési módszerével
• A modellburkoló , ModelWrapper()de a modell nem paraméterként van átadva a konstruktornak Egy új szótárparaméter - artifacts kulcsokkal rendelkezik az összetevő neveként, és az értékek a helyi fájlrendszer azon elérési útjaként, ahol az összetevőt tárolják

A megfelelő modellburkoló így nézne ki:

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)

A teljes betanítási rutin a következőképpen nézne ki:

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)

Modellbetöltő használata

Egy modell összetett logikával rendelkezhet, vagy több forrásfájlt is betölthet következtetési időpontban. Ez akkor fordul elő, ha rendelkezik például a modellhez tartozó Python-kódtárval. Ebben a forgatókönyvben a kódtárat a modellel együtt kell csomagolnia, hogy egyetlen darabként mozogjon.

Használja ezt a technikát a következő esetekben:

• A modellt nem lehet pickle formátumban szerializálni, vagy jobb szerializálási formátum érhető el
• A modellösszetevőket egy olyan mappában tárolhatja, amely az összes szükséges összetevőt tárolja
• A modell forráskódja nagy összetettséggel rendelkezik, és több Python-fájlt igényel. Lehetséges, hogy egy kódtár támogatja a modellt
• Testre szeretné szabni a modell terhelését és a predict függvény működését

Az MLflow támogatja ezeket a modelleket. Az MLflow használatával tetszőleges forráskódot adhat meg a modellel együtt csomagolni, feltéve, hogy rendelkezik egy betöltőmodullal. Az utasításban megadhatja a log_model() betöltőmodulokat az loader_module argumentummal, amely a betöltőt implementáló Python-névteret jelzi. Az code_path argumentumot is meg kell jelölni a forrásfájlokat, amelyek meghatározzák a loader_module. Ebben a névtérben olyan függvényt _load_pyfunc(data_path: str) kell implementálnia, amely megkapja az összetevők elérési útját, és visszaad egy objektumot egy metódus előrejelzésével (legalábbis).

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)

Feljegyzés

• A modell nem pickle-ként van mentve. Ehelyett a kód mentette a modellt a használt keretrendszer mentési módszerével
• Egy új paraméter – data_path a modellösszetevőket tartalmazó mappára mutat. Az összetevők lehetnek mappák vagy fájlok. Ezeket az összetevőket – akár egy mappát, akár egy fájlt – a modellbe csomagoljuk
• Egy új paraméter – code_path a forráskód helyére mutat. Ez az erőforrás ezen a helyen lehet elérési út vagy egyetlen fájl. Az erőforrás – akár egy mappa, akár egy fájl – a modellbe lesz csomagolva
• A függvényfüggvény _load_pyfunc a loader_module Python-modulban van tárolva

A src mappa tartalmazza a loader_module.py fájlt. Ez a fájl a betöltőmodul:

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)

Feljegyzés

• Az MyModel osztály nem öröklődik a PythonModel korábban látható módon. Azonban van egy függvénye predict
• A modell forráskódja egy fájlban található. Minden forráskód működni fog. Ehhez ideális egy src mappa
• A _load_pyfunc függvény a modell osztályának egy példányát adja vissza

A teljes betanítási kód a következőképpen néz ki:

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)

Következő lépések

• MLflow-modellek üzembe helyezése