MLflow-modellen registreren

2025-05-02

In dit artikel wordt beschreven hoe u uw getrainde machine learning-modellen of artefacten kunt registreren als MLflow-modellen. MLflow is een opensource-framework voor het beheren van machine learning-werkstromen. In dit artikel worden verschillende opties besproken voor het aanpassen van de manier waarop MLflow-pakketten en modellen worden uitgevoerd.

Vereiste voorwaarden

Het MLflow SDK-pakket mlflow

Waarom logboekmodellen in plaats van artefacten?

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

Zie Artefacten en modellen in MLflow voor het verschil tussen logboekregistratieartefacten of bestanden en het vastleggen van MLflow-modellen.

U kunt de bestanden van uw model registreren als artefacten, maar modellogboekregistratie biedt de volgende voordelen:

U kunt modellen mlflow.<flavor>.load_model rechtstreeks laden voor deductie en u kunt de predict functie gebruiken.
Pijplijninvoer kan modellen rechtstreeks gebruiken.
U kunt modellen implementeren zonder een scorescript of een omgeving op te geven.
Swagger wordt automatisch ingeschakeld in geïmplementeerde eindpunten. Als gevolg hiervan kunt u de testfunctie in Azure Machine Learning Studio gebruiken om modellen te testen.
U kunt het verantwoordelijke AI-dashboard gebruiken. Zie Het verantwoordelijke AI-dashboard gebruiken in Azure Machine Learning Studio voor meer informatie.

Automatische logboekregistratie gebruiken om modellen te registreren

U kunt MLflow-functionaliteit autolog gebruiken om automatisch modellen te registreren. Wanneer u automatische logboekregistratie gebruikt, legt MLflow alle relevante metrische gegevens, parameters, artefacten en modellen vast in uw framework. De gegevens die worden geregistreerd, zijn afhankelijk van het framework. Als automatische logboekregistratie is ingeschakeld, worden de meeste modellen standaard geregistreerd. In sommige situaties registreren sommige smaken geen modellen. De PySpark-smaak logeert bijvoorbeeld geen modellen die een bepaalde grootte overschrijden.

Gebruik mlflow.autolog of mlflow.<flavor>.autolog om automatische logboekregistratie te activeren. De volgende code gebruikt autolog om een classificatiemodel te registreren 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)

Aanbeveling

Als u machine learning-pijplijnen gebruikt, bijvoorbeeld scikit-learn-pijplijnen, gebruikt u de functionaliteit van die pijplijnvariant om modellen te registreren. Modellogboekregistratie wordt automatisch uitgevoerd wanneer de fit methode wordt aangeroepen op het pijplijnobject. Zie voor een notebook waarin een model wordt gelogd, inclusief voorafverwerking en het gebruik van pijplijnen, Training en tracking van een XGBoost-classificatie met MLflow.

Logboekmodellen die gebruikmaken van een aangepaste handtekening, omgeving of voorbeelden

U kunt de MLflow-methode mlflow.<flavor>.log_model gebruiken om handmatig modellen te registreren. Deze werkstroom biedt controle over verschillende aspecten van modellogboekregistratie.

Gebruik deze methode wanneer:

U wilt een Conda-omgeving of pip-pakketten aangeven die verschillen van de automatisch gedetecteerde pakketten of omgevingen.
U wilt invoervoorbeelden opnemen.
U wilt specifieke artefacten opnemen in het pakket dat u nodig hebt.
Met de autolog methode wordt uw handtekening niet correct afgeleid. Dit geval treedt op wanneer u met tensor-invoer werkt, waarvoor de handtekening een specifieke vorm moet hebben.
De autolog methode voldoet niet aan al uw behoeften.

Met de volgende code wordt een XGBoost-classificatiemodel vastgelegd:

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)

# Infer the signature.
signature = infer_signature(X_test, y_test)

# Set up a Conda environment.
custom_env =_mlflow_conda_env(
    additional_conda_deps=None,
    additional_pip_deps=["xgboost==1.5.2"],
    additional_conda_channels=None,
)

# Sample the data.
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

De aanroep naar autolog maakt gebruik van een configuratie van log_models=False. Met deze instelling wordt automatische logboekregistratie van MLflow-modellen uitgeschakeld. De log_model methode wordt later gebruikt om het model handmatig te registreren.
De infer_signature methode wordt gebruikt om de handtekening rechtstreeks van invoer en uitvoer af te stellen.
De mlflow.utils.environment._mlflow_conda_env methode is een privémethode in de MLflow SDK. In dit voorbeeld wordt de code gestroomlijnd. Maar gebruik deze methode met voorzichtigheid, omdat deze in de toekomst kan veranderen. Als alternatief kunt u de YAML-definitie handmatig genereren als een Python-woordenlijst.

Logboekmodellen die gebruikmaken van gewijzigd voorspellingsgedrag

Wanneer u mlflow.autolog of mlflow.<flavor>.log_model gebruikt om een model te registreren, bepaalt de modelsmaak hoe de inferentie wordt uitgevoerd. De smaak bepaalt ook wat het model teruggeeft. MLflow dwingt geen specifiek gedrag af over het genereren van predict resultaten. In sommige scenario's wilt u mogelijk uw gegevens vooraf verwerken of nabewerken.

In deze situatie kunt u machine learning-pijplijnen implementeren die rechtstreeks van invoer naar uitvoer worden verplaatst. Hoewel dit type implementatie soms de prestaties kan verbeteren, kan het lastig zijn om te bereiken. In dergelijke gevallen kan het handig zijn om aan te passen hoe uw model deductie verwerkt. Zie de volgende sectie, Aangepaste modellen vastleggen voor meer informatie.

Aangepaste modellen registreren

MLflow ondersteunt veel machine learning-frameworks, waaronder de volgende smaken:

CatBoost
FastAI
H2O
Keras
LightGBM
MLeap
ONNX
Profeet
PyTorch
scikit-learn
spaCy
Spark MLlib
statsmodels
TensorFlow
XGBoost

Zie Built-In Model flavors voor een volledige lijst.

U moet mogelijk echter de manier veranderen waarop een variant werkt of een model registreren dat MLflow niet natively ondersteunt. Of mogelijk moet u een model vastleggen dat meerdere elementen uit verschillende frameworks gebruikt. In dergelijke gevallen kunt u een aangepaste modelsmaak maken.

Om het probleem op te lossen, biedt MLflow de PyFunc-smaak, een standaardmodelinterface voor Python-modellen. Met deze smaak kan elk object als model worden vastgelegd zolang dat object aan twee voorwaarden voldoet:

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

Aanbeveling

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 ten minste de predict en predict_proba methoden heeft, kunt mlflow.sklearn.log_model u het model in een MLflow-uitvoering registreren.

De eenvoudigste manier om een smaak voor uw aangepaste model te maken, is door een wrapper rond uw bestaande modelobject te maken. MLflow serialiseert en verpakt uw model 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 vanuit dat bestand worden geladen. Bij het laden worden alle waarden, eigenschappen en methoden hersteld die beschikbaar zijn wanneer deze worden opgeslagen.

Gebruik deze methode wanneer:

U kunt uw model serialiseren in Pickle-formaat.
U wilt de toestand van het model net na de training behouden.
U wilt aanpassen hoe de predict functie werkt.

Met de volgende code wordt een model ingepakt dat is gemaakt met XGBoost, zodat het zich anders gedraagt dan de standaardimplementatie van de XGBoost-versie. Het retourneert waarschijnlijkheden in plaats van klassen.

from mlflow.pyfunc import PythonModel, PythonModelContext

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

    def predict(self, context: PythonModelContext, data):
        # The next line uses a prediction function. However, you could also use model.recommend(), model.forecast(), or a similar function instead.
        return self._model.predict_proba(data)

    # You can add extra functions if you need to. Because the model is serialized,
    # all of them are available when you load your model.
    def predict_batch(self, data):
        pass

Gebruik de volgende code om een aangepast model te registreren tijdens een 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)

Aanbeveling

In de voorgaande code gebruikt de infer_signature methode y_probs om de handtekening af te leiden. De doelkolom bevat de doelklasse, maar het model retourneert twee waarschijnlijkheden voor elke klasse.

Soms bestaat een model uit meerdere onderdelen die moeten worden geladen. En soms kunt u het model niet serialiseren als pickle-bestand. In dergelijke gevallen kunt u de PythonModel klasse gebruiken. Het biedt ondersteuning voor 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-formaat, ofwel u hebt een betere serialisatie-indeling beschikbaar.
Uw model heeft een of meer artefacten waarnaar moet worden verwezen om het model te laden.
U wilt bepaalde eigenschappen van deductieconfiguratie behouden, bijvoorbeeld het aantal items dat u moet aanbevelen.
U wilt aanpassen hoe het model wordt geladen en hoe de predict functie werkt.

De volgende code laat zien hoe u een aangepast model kunt registreren dat gebruikmaakt 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 in Pickle-formaat. In plaats daarvan slaat de code het model op met behulp van de opslagmethode van het framework dat u gebruikt.
De ModelWrapper klasse wordt gebruikt om het model te verpakken, maar het model wordt niet doorgegeven als argument aan de ModelWrapper constructor.
De log_model methode heeft een woordenlijstparameter. artifacts De sleutels bevatten artefaktnamen. Elke waarde bevat het pad in het lokale bestandssysteem naar een artefact.

Het bijbehorende modelframework ziet er qua code ongeveer 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 ongeveer 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 model heeft soms complexe logica of laadt meerdere bronbestanden tijdens deductietijd. Deze situatie treedt op wanneer u bijvoorbeeld een Python-bibliotheek voor uw model hebt. In dit scenario moet u de bibliotheek samen met uw model verpakken, zodat ze als één stuk functioneren.

Gebruik deze techniek wanneer:

U kunt uw model niet serialiseren in Pickle-indeling, of u kunt kiezen voor een betere serialisatie-indeling die beschikbaar is.
U kunt uw modelartefacten opslaan in een map waarin alle vereiste artefacten worden opgeslagen.
De broncode van uw model is complex 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 dit type modellen. Wanneer u MLflow gebruikt, kunt u willekeurige broncode opgeven om samen met het model te verpakken, zolang de broncode een laadmodule heeft. U kunt laadprogramma's in de aanroep log_model opgeven met behulp van de loader_module parameter, die de Python-naamruimte aangeeft waarmee het laadprogramma wordt geïmplementeerd. De code_path parameter is ook vereist. Het biedt de bronbestanden die de laadmodule definië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 dat ten minste een predict methode implementeert.

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 in Pickle-formaat. In plaats daarvan slaat de code het model op met behulp van de opslagmethode van het framework dat u gebruikt.
De log_model methode heeft een data_path parameter die verwijst naar de map met de modelartefacten. De artefacten kunnen zich in een map of een bestand bevinden. De artefacten worden verpakt met het model.
De log_model methode heeft een code_path parameter die verwijst naar de locatie van de broncode. De code_path waarde kan een pad of één bestand zijn. De broncode is verpakt met het model.
De _load_pyfunc functie wordt opgeslagen in de loader_module Python-module.

De src-map bevat het bestand loader_module.py. Dat bestand fungeert als de laadprogrammamodule en bevat de volgende regels:

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 is geschikt. Een map met de naam src is ideaal in deze situatie.
Een _load_pyfunc functie retourneert een exemplaar van de klasse van het model.

De volledige trainingsroutine ziet er ongeveer 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 stap

Richtlijnen voor het implementeren van MLflow-modellen

Feedback

Is deze pagina nuttig?

Delen via

MLflow-modellen registreren

Vereiste voorwaarden

Waarom logboekmodellen in plaats van artefacten?

Automatische logboekregistratie gebruiken om modellen te registreren

Logboekmodellen die gebruikmaken van een aangepaste handtekening, omgeving of voorbeelden

Logboekmodellen die gebruikmaken van gewijzigd voorspellingsgedrag

Aangepaste modellen registreren

Volgende stap

Feedback

Aanvullende resources