Delen via

MLflow-modellen registreren

  • Artikel

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.

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.

Volgende stappen