Logga MLflow-modeller

2025-05-03

Den här artikeln beskriver hur du loggar dina tränade maskininlärningsmodeller eller artefakter som MLflow-modeller. MLflow är ett ramverk med öppen källkod för att hantera arbetsflöden för maskininlärning. I den här artikeln beskrivs olika alternativ för att anpassa hur MLflow paketerar och kör modeller.

Förutsättningar

MLflow SDK-paketet mlflow

Varför logga modeller i stället för artefakter?

En MLflow-modell är en typ av artefakt. En modell har dock en specifik struktur som fungerar som ett kontrakt mellan den person som skapar modellen och den person som tänker använda den. Det här kontraktet hjälper dig att skapa en brygga mellan själva artefakterna och deras betydelser.

Skillnaden mellan loggningsartefakter eller filer och loggning av MLflow-modeller finns i Artefakter och modeller i MLflow.

Du kan logga modellens filer som artefakter, men modellloggning ger följande fördelar:

Du kan använda mlflow.<flavor>.load_model för att läsa in modeller direkt för slutsatsdragning och du kan använda predict funktionen.
Indata i en pipeline kan använda modeller direkt.
Du kan distribuera modeller utan att ange ett bedömningsskript eller en miljö.
Swagger aktiveras automatiskt i distribuerade slutpunkter. Därför kan du använda testfunktionen i Azure Machine Learning Studio för att testa modeller.
Du kan använda instrumentpanelen för ansvarsfull AI. För mer information, se Använd instrumentpanelen för ansvarsfull AI i Azure Machine Learning studio.

Använda automatisk loggning för att logga modeller

Du kan använda MLflow-funktioner autolog för att automatiskt logga modeller. När du använder automatisk loggning samlar MLflow in alla relevanta mått, parametrar, artefakter och modeller i ditt ramverk. Vilka data som loggas beror på ramverket. Om automatisk loggning är aktiverad loggas de flesta modeller som standard. I vissa situationer loggar vissa versioner inte modeller. PySpark-smaken loggar till exempel inte modeller som överskrider en viss storlek.

Använd antingen mlflow.autolog eller mlflow.<flavor>.autolog för att aktivera automatisk loggning. Följande kod används autolog för att logga en klassificerarmodell som tränas med 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)

Dricks

Om du använder maskininlärningspipelines, till exempel scikit-learn-pipelines, använder du funktionerna i pipelinesmaken autolog för att logga modeller. Modellloggning körs automatiskt när fit metoden anropas på pipelineobjektet. För en notebook som loggar en modell, inkluderar förbearbetning och använder pipelines, se Träna och spåra en XGBoost-klassificerare med MLflow.

Loggmodeller som använder en anpassad signatur, miljö eller exempel

Du kan använda MLflow-metoden mlflow.<flavor>.log_model för att manuellt logga modeller. Det här arbetsflödet ger kontroll över olika aspekter av modellloggning.

Använd den här metoden när:

Du vill ange en Conda-miljö eller pip-paket som skiljer sig från de automatiskt identifierade paketen eller miljön.
Du vill ta med indataexempel.
Du vill inkludera specifika artefakter i det paket som du behöver.
Metoden autolog härleder inte din signatur korrekt. Det här fallet uppstår när du arbetar med tensor-indata, vilket kräver att signaturen har en specifik form.
Metoden autolog uppfyller inte alla dina behov.

Följande kod loggar en XGBoost-klassificerarmodell:

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)

Kommentar

Anropet till autolog använder en konfiguration av log_models=False. Den här inställningen inaktiverar automatisk MLflow-modellloggning. Metoden log_model används senare för att logga modellen manuellt.
Metoden infer_signature används för att försöka härleda signaturen direkt från indata och utdata.
Metoden mlflow.utils.environment._mlflow_conda_env är en privat metod i MLflow SDK. I det här exemplet effektiviserar det koden. Men använd den här metoden med försiktighet, eftersom den kan ändras i framtiden. Alternativt kan du generera YAML-definitionen manuellt som en Python-ordlista.

Loggmodeller som använder ändrat förutsägelsebeteende

När du använder mlflow.autolog eller mlflow.<flavor>.log_model för att logga en modell, avgör modellformatet hur inference-processen utförs. Smaken avgör också vad modellen returnerar. MLflow framtvingar inte specifikt beteende för generering av predict resultat. I vissa scenarier kanske du vill förbearbeta eller efterbehandla dina data.

I den här situationen kan du implementera maskininlärningspipelines som direkt flyttas från indata till utdata. Även om den här typen av implementering ibland kan förbättra prestandan kan det vara svårt att uppnå. I sådana fall kan det vara bra att anpassa hur din modell hanterar slutsatsdragning. Mer information finns i nästa avsnitt , Logga anpassade modeller.

Logga anpassade modeller

MLflow stöder många maskininlärningsramverk, inklusive följande varianter:

CatBoost
FastAI
H2O
Keras
LightGBM
MLeap
ONNX
Profet
PyTorch
scikit-learn (en maskininlärningsbibliotek)
spaCy
Spark MLlib
statsmodels (ett verktyg för statistisk modellering)
TensorFlow
XGBoost

För en komplett lista, se Built-In Modellflavors.

Du kan dock behöva ändra hur en smak fungerar eller logga en modell som MLflow inte har inbyggt stöd för. Eller så kan du behöva logga en modell som använder flera element från olika ramverk. I dessa fall kan du skapa en anpassad modellvariant.

För att lösa problemet erbjuder MLflow PyFunc-varianten, ett standardgränssnitt för modeller i Python. Den här varianten kan registrera valfritt objekt som en modell så länge objektet uppfyller två villkor:

Du implementerar åtminstone predict -metoden.
Python-objektet ärver från mlflow.pyfunc.PythonModel klassen.

Dricks

Serialiserbara modeller som implementerar scikit-learn-API:et kan använda scikit-learn-smaken för att logga modellen, oavsett om modellen har skapats med scikit-learn. Om du kan bevara din modell i Pickle-format och objektet har minst predict metoderna och predict_proba kan du använda mlflow.sklearn.log_model för att logga modellen i en MLflow-körning.

Det enklaste sättet att skapa en smak för din anpassade modell är att skapa en omslutning runt ditt befintliga modellobjekt. MLflow serialiserar och paketerar din modell åt dig. Python-objekt kan serialiseras när objektet kan lagras i filsystemet som en fil, vanligtvis i Pickle-format. Vid körning kan objektet läsas in från filen. Inläsning återställer alla värden, egenskaper och metoder som är tillgängliga när de sparas.

Använd den här metoden när:

Du kan serialisera din modell i Pickle-format.
Du vill behålla modellens tillstånd strax efter träningen.
Du vill anpassa hur predict funktionen fungerar.

Följande kod omsluter en modell skapad med XGBoost så att den fungerar på ett annat sätt än standardimplementeringen av XGBoost-varianten. Den returnerar sannolikheter i stället för klasser.

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

Använd följande kod för att logga en anpassad modell under en körning:

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)

Dricks

I föregående kod infer_signature använder y_probs metoden för att härleda signaturen. Målkolumnen innehåller målklassen, men modellen returnerar två sannolikheter för varje klass.

Ibland består en modell av flera delar som måste läsas in. Och ibland kan du inte serialisera modellen som en Pickle-fil. I dessa fall kan du använda PythonModel klassen . Det ger stöd för en godtycklig lista över artefakter. Varje artefakt paketeras tillsammans med din modell.

Använd den här tekniken när:

Du kan inte serialisera din modell i Pickle-format, eller så har du ett bättre serialiseringsformat.
Din modell har en eller flera artefakter som måste refereras till för att ladda modellen.
Du vill spara vissa egenskaper för slutsatsdragningskonfiguration, till exempel antalet objekt som ska rekommenderas.
Du vill anpassa hur modellen läses in och hur funktionen predict fungerar.

Följande kod visar hur du loggar en anpassad modell som använder artefakter:

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)

Kommentar

Modellen sparas inte i Pickle-format. I stället sparar koden modellen med hjälp av save-metoden för det ramverk som du använder.
Klassen ModelWrapper används för att omsluta modellen, men modellen skickas inte som ett argument till ModelWrapper konstruktorn.
Metoden log_model har en ordlisteparameter, artifacts. Dess nycklar innehåller artefaktnamn. Varje värde innehåller sökvägen i det lokala filsystemet till en artefakt.

Motsvarande modellomslutning liknar följande kod:

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)

Den fullständiga träningsrutinen liknar följande kod:

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)

En modell har ibland komplex logik eller läser in flera källfiler vid slutsatsdragning. Den här situationen uppstår när du till exempel har ett Python-bibliotek för din modell. I det här scenariot bör du paketera biblioteket tillsammans med din modell så att de fungerar som ett enda stycke.

Använd den här tekniken när:

Du kan inte serialisera din modell i Pickle-format, eller så har du ett bättre serialiseringsformat.
Du kan lagra dina modellartefakter i en mapp som lagrar alla nödvändiga artefakter.
Din modells källkod är komplex och kräver flera Python-filer. Ett bibliotek kan eventuellt ha stöd för din modell.
Du vill anpassa hur modellen läses in och hur predict funktionen fungerar.

MLflow stöder dessa typer av modeller. När du använder MLflow kan du ange godtycklig källkod som ska paketeras tillsammans med modellen, så länge källkoden har en inläsningsmodul. Du kan ange inläsningsmoduler i anropet till log_model med hjälp av parametern loader_module , som anger python-namnområdet som implementerar inläsaren. Parametern code_path krävs också. Den innehåller källfilerna som definierar inläsningsmodulen. I det här namnområdet måste du implementera en _load_pyfunc(data_path: str) funktion som tar emot sökvägen till artefakterna och returnerar ett objekt som implementerar minst en predict metod.

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)

Kommentar

Modellen sparas inte i Pickle-format. I stället sparar koden modellen med hjälp av save-metoden för det ramverk som du använder.
Metoden log_model har en data_path parameter som pekar på mappen som innehåller modellartefakterna. Artefakterna kan finnas i en mapp eller en fil. Artefakterna paketeras med modellen.
Metoden log_model har en code_path parameter som pekar på platsen för källkoden. Värdet code_path kan vara en sökväg eller en enda fil. Källkoden paketeras med modellen.
Funktionen _load_pyfunc lagras i loader_module Python-modulen.

Mappen src innehåller filen loader_module.py. Filen fungerar som inläsningsmodul och innehåller följande rader:

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)

Kommentar

Klassen MyModel ärver inte från PythonModel det som visades tidigare. Den har dock en predict funktion.
Modellens källkod finns i en fil. All källkod är lämplig. En mapp med namnet src är idealisk i den här situationen.
En _load_pyfunc funktion returnerar en instans av modellens klass.

Den fullständiga träningsrutinen liknar följande kod:

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)

Nästa steg

Riktlinjer för att distribuera MLflow-modeller

Feedback

Var den här sidan till hjälp?

Dela via

Logga MLflow-modeller

Förutsättningar

Varför logga modeller i stället för artefakter?

Använda automatisk loggning för att logga modeller

Loggmodeller som använder en anpassad signatur, miljö eller exempel

Loggmodeller som använder ändrat förutsägelsebeteende

Logga anpassade modeller

Nästa steg

Feedback

Ytterligare resurser