MLflow-modellen registreren

In dit artikel wordt beschreven hoe u uw getrainde modellen (of artefacten) kunt registreren als MLflow-modellen. Het verkent de verschillende manieren om aan te passen hoe MLflow uw modellen verpakt en hoe deze modellen worden uitgevoerd.

Waarom logboekregistratiemodellen in plaats van artefacten?

Van artefacten tot modellen in MLflow beschrijft het verschil tussen logboekartefacten of bestanden, vergeleken met MLflow-modellen.

Een MLflow-model is ook een artefact. Dit model heeft echter een specifieke structuur die fungeert als een contract tussen de persoon die het model heeft gemaakt en de persoon die het wil gebruiken. Dit contract helpt bij het bouwen van een brug tussen de artefacten zelf en hun betekenissen.

Modellogboekregistratie heeft de volgende voordelen:

• U kunt modellen rechtstreeks laden, voor deductie, met mlflow.<flavor>.load_model, en u kunt de predict functie gebruiken
• Pijplijninvoer kan modellen rechtstreeks gebruiken
• U kunt modellen implementeren zonder indicatie van een scorescript of een omgeving
• Swagger wordt automatisch ingeschakeld in geïmplementeerde eindpunten en de Azure Machine Learning-studio kan de functie Testen gebruiken
• U kunt het verantwoordelijke AI-dashboard gebruiken

In deze sectie wordt beschreven hoe u het concept van het model gebruikt in Azure Machine Learning met MLflow:

Modellen registreren met behulp van autolog

U kunt de functionaliteit voor automatische logboekregistratie van MLflow gebruiken. Met Autolog kan MLflow het framework instrueren dat wordt gebruikt om alle metrische gegevens, parameters, artefacten en modellen te registreren die door het framework relevant worden geacht. Als autolog is ingeschakeld, worden de meeste modellen standaard geregistreerd. In sommige gevallen kunnen sommige smaken een model niet registreren. De PySpark-smaak logeert bijvoorbeeld geen modellen die een bepaalde grootte overschrijden.

Gebruik autologging mlflow.autolog() of mlflow.<flavor>.autolog() om automatische aanmelding te activeren. In dit voorbeeld wordt een autolog() classificatiemodel geregistreerd dat is getraind met 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

Als u Machine Learning-pijplijnen gebruikt, bijvoorbeeld Scikit-Learn-pijplijnen, gebruikt u de autolog functionaliteit van die pijplijnsmaak om modellen te registreren. Modelregistratie vindt automatisch plaats wanneer de fit() methode wordt aangeroepen in het pijplijnobject. Het trainen en bijhouden van een XGBoost-classificatie met MLflow-notebook laat zien hoe u een model kunt registreren met voorverwerking, met behulp van pijplijnen.

Modellen vastleggen met een aangepaste handtekening, omgeving of voorbeelden

Met de MLflow-methode mlflow.<flavor>.log_model kunnen modellen handmatig worden vastgelegd. Deze werkstroom kan verschillende aspecten van de modellogboekregistratie beheren.

Gebruik deze methode wanneer:

• U wilt pip-pakketten of een Conda-omgeving aangeven die afwijken van de pakketten die automatisch worden gedetecteerd
• U wilt invoervoorbeelden opnemen
• U wilt specifieke artefacten opnemen in het benodigde pakket
• autolog leidt uw handtekening niet correct af. Dit is belangrijk wanneer u te maken hebt met tensor-invoer, waarbij de handtekening specifieke shapes nodig heeft
• Het gedrag van autolog heeft om een of andere reden geen betrekking op uw doel

In dit codevoorbeeld wordt een model vastgelegd voor een XGBoost-classificatie:

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)

Notitie

• autolog heeft de log_models=False configuratie. Dit voorkomt automatische logboekregistratie van MLflow-modellen. Automatische logboekregistratie van MLflow-modellen vindt later plaats, als handmatig proces
• Gebruik de infer_signature methode om de handtekening rechtstreeks af te stellen van invoer en uitvoer
• De mlflow.utils.environment._mlflow_conda_env methode is een privémethode in de MLflow SDK. In dit voorbeeld is de code eenvoudiger, maar gebruik deze met voorzichtigheid. Het kan in de toekomst veranderen. Als alternatief kunt u de YAML-definitie handmatig genereren als een Python-woordenlijst.

Modellen vastleggen met een ander gedrag in de voorspellingsmethode

Bij het vastleggen van een model met een mlflow.autolog of mlflow.<flavor>.log_model, bepaalt de modelsmaak hoe de deductie moet worden uitgevoerd en wat het model retourneert. MLflow dwingt geen specifiek gedrag af over het genereren van predict resultaten. In sommige scenario's wilt u mogelijk een voorverwerking of naverwerking uitvoeren voor en nadat uw model is uitgevoerd.

In deze situatie implementeert u machine learning-pijplijnen die rechtstreeks van invoer naar uitvoer worden verplaatst. Hoewel deze implementatie mogelijk is en soms wordt aangemoedigd om de prestaties te verbeteren, kan het lastig worden om te bereiken. In die gevallen kan het helpen om aan te passen hoe uw model deductie verwerkt, zoals wordt uitgelegd in de volgende sectie.

Aangepaste modellen vastleggen

MLflow ondersteunt veel machine learning-frameworks, waaronder

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

Mogelijk moet u echter de manier wijzigen waarop een smaak werkt, een model registreren dat niet systeemeigen wordt ondersteund door MLflow of zelfs een model registreren dat meerdere elementen uit verschillende frameworks gebruikt. In deze gevallen moet u mogelijk een aangepaste modelsmaak maken.

Om het probleem op te lossen, introduceert MLflow de pyfunc smaak (beginnend vanuit een Python-functie). Met deze smaak kan elk object als model worden vastgelegd, zolang dat object aan twee voorwaarden voldoet:

• U implementeert de methodemethode predict ten minste
• Het Python-object neemt over van mlflow.pyfunc.PythonModel

Tip

Serialiseerbare modellen die de Scikit-learn-API implementeren, kunnen de scikit-learn-smaak gebruiken om het model te registreren, ongeacht of het model is gebouwd met Scikit-learn. Als u uw model in Pickle-indeling kunt behouden en het object de predict() en predict_proba() methoden heeft (ten minste), kunt mlflow.sklearn.log_model() u het model in een MLflow-uitvoering registreren.

Een modelwikkelaar gebruiken

Als u een wrapper rond uw bestaande modelobject maakt, is het de eenvoudigste om een smaak voor uw aangepaste model te maken. MLflow serialiseert en verpakt deze voor u. Python-objecten zijn serialiseerbaar wanneer het object als een bestand in het bestandssysteem kan worden opgeslagen, meestal in Pickle-indeling. Tijdens runtime kan het object worden gerealiseerd vanuit dat bestand. Hiermee worden alle waarden, eigenschappen en methoden hersteld die beschikbaar zijn toen deze werd opgeslagen.

Gebruik deze methode wanneer:

• U kunt uw model serialiseren in Pickle-indeling
• U wilt de status van het model behouden, net als na de training
• U wilt aanpassen hoe de predict functie werkt.

Met dit codevoorbeeld wordt een model verpakt dat is gemaakt met XGBoost, zodat het zich anders gedraagt dan de standaard-implementatie van de XGBoost-smaak. In plaats daarvan worden de waarschijnlijkheden geretourneerd in plaats van de klassen:

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

Een aangepast model registreren in de uitvoering:

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

Hier wordt de infer_signature methode gebruikt y_probs om de handtekening af te stellen. De doelkolom heeft de doelklasse, maar het model retourneert nu de twee waarschijnlijkheden voor elke klasse.

Artefacten gebruiken

Uw model kan bestaan uit meerdere onderdelen die moeten worden geladen. Mogelijk hebt u geen manier om het te serialiseren als een Pickle-bestand. In die gevallen ondersteunt de PythonModel functie indicaties van een willekeurige lijst met artefacten. Elk artefact wordt samen met uw model verpakt.

Gebruik deze techniek wanneer:

• U kunt uw model niet serialiseren in Pickle-indeling of u hebt een betere serialisatie-indeling beschikbaar
• Uw model heeft een of meer artefacten waarnaar moet worden verwezen om het model te laden
• Mogelijk wilt u bepaalde eigenschappen van deductieconfiguratie behouden, bijvoorbeeld het aantal items dat moet worden aanbevolen
• U wilt de manier aanpassen waarop het model wordt geladen en hoe de predict functie werkt

In dit codevoorbeeld ziet u hoe u een aangepast model kunt registreren met behulp van artefacten:

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)

Notitie

• Het model wordt niet opgeslagen als een pickle. In plaats daarvan heeft de code het model opgeslagen met de opslagmethode van het framework dat u hebt gebruikt
• De modelwikkelaar is ModelWrapper(), maar het model wordt niet doorgegeven als een parameter aan de constructor Een nieuwe woordenlijstparameter - artifacts heeft sleutels als de artefactnamen en waarden als het pad in het lokale bestandssysteem waar het artefact wordt opgeslagen

De bijbehorende modelwikkelaar ziet er dan als volgt uit:

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)

De volledige trainingsroutine ziet er als volgt uit:

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)

Een modellaadprogramma gebruiken

Een model kan complexe logica hebben of meerdere bronbestanden laden tijdens deductietijd. Dit gebeurt als u bijvoorbeeld een Python-bibliotheek voor uw model hebt. In dit scenario moet u de bibliotheek samen met uw model verpakken, zodat deze als één stuk kan worden verplaatst.

Gebruik deze techniek wanneer:

• U kunt uw model niet serialiseren in Pickle-indeling of u hebt een betere serialisatie-indeling beschikbaar
• U kunt uw modelartefacten opslaan in een map waarin alle vereiste artefacten worden opgeslagen
• De broncode van uw model heeft een grote complexiteit en vereist meerdere Python-bestanden. Mogelijk ondersteunt een bibliotheek uw model
• U wilt de manier aanpassen waarop het model wordt geladen en hoe de predict functie werkt

MLflow ondersteunt deze modellen. Met MLflow kunt u elke willekeurige broncode opgeven die samen met het model moet worden verpakt, zolang het een laadmodule heeft. U kunt laadprogramma's opgeven in de log_model() instructie met het loader_module argument, wat de Python-naamruimte aangeeft waarmee het laadprogramma wordt geïmplementeerd. Het code_path argument is ook vereist om de bronbestanden aan te geven die het loader_moduledefiniëren. In deze naamruimte moet u een _load_pyfunc(data_path: str) functie implementeren die het pad van de artefacten ontvangt en een object retourneert met een methode voorspellen (ten minste).

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)

Notitie

• Het model wordt niet opgeslagen als een pickle. In plaats daarvan heeft de code het model opgeslagen met de opslagmethode van het framework dat u hebt gebruikt
• Een nieuwe parameter: data_path verwijst naar de map met de modelartefacten. De artefacten kunnen een map of een bestand zijn. Deze artefacten - een map of een bestand - worden verpakt met het model
• Een nieuwe parameter - code_path verwijst naar de locatie van de broncode. Deze resource op deze locatie kan een pad of één bestand zijn. Die resource, een map of een bestand, wordt verpakt met het model
• De functiefunctie _load_pyfunc wordt opgeslagen in de loader_module Python-module

De src map bevat het loader_module.py bestand. Dat bestand is de laadprogrammamodule:

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)

Notitie

• De MyModel klasse neemt niet over van PythonModel zoals eerder wordt weergegeven. Het heeft echter een predict functie
• De broncode van het model bevindt zich in een bestand. Elke broncode werkt. Een src-map is ideaal voor dit
• Een _load_pyfunc functie retourneert een exemplaar van de klasse van het model

De volledige trainingscode ziet er als volgt uit:

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)

Volgende stappen

• MLflow-modellen implementeren