Logga MLflow-modeller

Den här artikeln beskriver hur du loggar dina tränade modeller (eller artefakter) som MLflow-modeller. Den utforskar de olika sätten att anpassa hur MLflow paketera dina modeller och hur de kör dessa modeller.

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

Från artefakter till modeller i MLflow beskriver skillnaden mellan loggningsartefakter eller filer, jämfört med loggning av MLflow-modeller.

En MLflow-modell är också en artefakt. Den modellen har dock en specifik struktur som fungerar som ett kontrakt mellan den person som skapade modellen och den person som avser att använda den. Det här kontraktet hjälper dig att skapa en brygga mellan själva artefakterna och deras betydelser.

Modellloggning har följande fördelar:

• Du kan läsa in modeller direkt för slutsatsdragning med mlflow.<flavor>.load_model, och du kan använda predict funktionen
• Pipelineindata kan använda modeller direkt
• Du kan distribuera modeller utan att ange ett bedömningsskript eller en miljö
• Swagger aktiveras automatiskt i distribuerade slutpunkter och Azure Machine Learning-studio kan använda testfunktionen
• Du kan använda instrumentpanelen ansvarsfull AI

I det här avsnittet beskrivs hur du använder modellens koncept i Azure Machine Learning med MLflow:

Loggningsmodeller med automatisk loggning

Du kan använda funktionen för automatisk MLflow-loggning. Med automatisk loggning kan MLflow instruera ramverket som används att logga alla mått, parametrar, artefakter och modeller som ramverket anser vara relevanta. Om automatisk loggning är aktiverat loggas de flesta modeller som standard. I vissa situationer kanske vissa smaker inte loggar en modell. 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. Det här exemplet används autolog() för att logga en klassificerarmodell som tränats 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 Machine Learning-pipelines, till exempel Scikit-Learn-pipelines, använder du funktionerna i pipelinesmaken autolog för att logga modeller. Modellloggning sker automatiskt när fit() metoden anropas för pipelineobjektet. Utbildnings - och spårningsklassificeraren XGBoost med MLflow Notebook visar hur du loggar en modell med förbearbetning med hjälp av pipelines.

Loggningsmodeller med en anpassad signatur, miljö eller exempel

MLflow-metoden mlflow.<flavor>.log_model kan manuellt logga modeller. Det här arbetsflödet kan styra olika aspekter av modellloggningen.

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

• Du vill ange pip-paket eller en conda-miljö som skiljer sig från dem som identifieras automatiskt
• Du vill ta med indataexempel
• Du vill inkludera specifika artefakter i det nödvändiga paketet
• autolog inte korrekt härleder din signatur. Detta är viktigt när du hanterar tensor-indata, där signaturen behöver specifika former
• Autolog-beteendet täcker inte ditt syfte av någon anledning

Det här kodexemplet loggar en modell för en XGBoost-klassificerare:

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)

Kommentar

• autolog har konfigurationen log_models=False . Detta förhindrar automatisk MLflow-modellloggning. Automatisk MLflow-modellloggning sker senare, som en manuell process
• infer_signature Använd metoden 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 gör det koden enklare, men använd den med försiktighet. Det kan ändras i framtiden. Alternativt kan du generera YAML-definitionen manuellt som en Python-ordlista.

Loggningsmodeller med ett annat beteende i förutsägelsemetoden

När du loggar en modell med antingen mlflow.autolog eller mlflow.<flavor>.log_modelavgör modellsmaken hur slutsatsdragningen ska köras och vad modellen returnerar. MLflow tillämpar inte något specifikt beteende om genereringen av predict resultat. I vissa scenarier kanske du vill utföra viss förbearbetning eller efterbearbetning före och efter att din modell har körts.

I den här situationen implementerar du maskininlärningspipelines som direkt flyttas från indata till utdata. Även om den här implementeringen är möjlig och ibland uppmuntras att förbättra prestandan kan det bli svårt att uppnå. I dessa fall kan det hjälpa dig att anpassa hur din modell hanterar slutsatsdragning enligt beskrivningen i nästa avsnitt.

Logga anpassade modeller

MLflow stöder många maskininlärningsramverk, inklusive

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

Du kan dock behöva ändra hur en smak fungerar, logga en modell som inte stöds internt av MLflow eller till och med logga en modell som använder flera element från olika ramverk. I dessa fall kan du behöva skapa en anpassad modellsmak.

För att lösa problemet introducerar pyfunc MLflow smaken (från och med en Python-funktion). Den här smaken kan logga valfritt objekt som en modell, så länge objektet uppfyller två villkor:

• Du implementerar metodmetoden predict , åtminstone
• Python-objektet ärver från mlflow.pyfunc.PythonModel

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 predict() metoderna och predict_proba() (åtminstone) kan du använda mlflow.sklearn.log_model() för att logga modellen i en MLflow-körning.

Använda en modellomslutning

Om du skapar en omslutning runt ditt befintliga modellobjekt blir det enklast att skapa en smak för din anpassade modell. MLflow serialiserar och paketerar det å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 materialiseras från filen. Detta återställer alla värden, egenskaper och metoder som är tillgängliga när det sparades.

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

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

Det här kodexemplet omsluter en modell som skapats med XGBoost så att den fungerar på ett annat sätt än standardimplementeringen för XGBoost-smaken. I stället returneras sannolikheterna i stället för klasserna:

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

Logga en anpassad modell på körningen:

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

infer_signature Här använder y_probs metoden för att härleda signaturen. Vår målkolumn har målklassen, men vår modell returnerar nu de två sannolikheterna för varje klass.

Använda artefakter

Din modell kan bestå av flera delar som måste läsas in. Du kanske inte kan serialisera den som en Pickle-fil. I dessa fall PythonModel stöder indikeringen av 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 tillgängligt
• Din modell har en eller många artefakter måste refereras för att läsa in modellen
• Du kanske vill spara vissa egenskaper för slutsatsdragningskonfiguration – till exempel antalet objekt som ska rekommenderas
• Du vill anpassa hur modellen läses in och hur predict funktionen fungerar

Det här kodexemplet visar hur du loggar en anpassad modell med 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 som en pickle. I stället sparade koden modellen med save-metoden för det ramverk som du använde
• Modellomslutningen är ModelWrapper(), men modellen skickas inte som en parameter till konstruktorn En ny ordlisteparameter – artifacts – har nycklar som artefaktnamn och värden som sökväg i det lokala filsystemet där artefakten lagras

Motsvarande modellomslutning skulle då se ut så här:

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 skulle se ut så här:

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)

Använda en modellinläsare

En modell kan ha komplex logik eller läsa in flera källfiler vid inferens. Detta händer om 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 det kan flyttas som en enda del.

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 tillgängligt
• Du kan lagra dina modellartefakter i en mapp som lagrar alla nödvändiga artefakter
• Din modells källkod har stor komplexitet 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 modeller. Med MLflow kan du ange valfri godtycklig källkod som ska paketeras tillsammans med modellen, så länge den har en inläsningsmodul. Du kan ange inläsningsmoduler i instruktionen log_model()loader_module med argumentet, vilket anger python-namnområdet som implementerar inläsaren. Argumentet code_path krävs också för att ange de källfiler som definierar loader_module. I det här namnområdet måste du implementera en _load_pyfunc(data_path: str) funktion som tar emot artefaktens sökväg och returnerar ett objekt med en metodförsägning (minst).

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 som en pickle. I stället sparade koden modellen med save-metoden för det ramverk som du använde
• En ny parameter – data_path – pekar på mappen som innehåller modellartefakterna. Artefakterna kan vara en mapp eller en fil. Dessa artefakter – antingen en mapp eller en fil – paketeras med modellen
• En ny parameter – code_path – pekar på källkodsplatsen. Den här resursen på den här platsen kan vara en sökväg eller en enda fil. Resursen – antingen en mapp eller en fil – paketeras med modellen
• Funktionsfunktionen _load_pyfunc lagras i loader_module Python-modulen

Mappen src innehåller loader_module.py filen. Filen är inläsningsmodulen:

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)

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. Alla källkoder fungerar. En src-mapp är perfekt för detta
• En _load_pyfunc funktion returnerar en instans av modellens klass

Den fullständiga träningskoden ser ut så här:

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

• Distribuera MLflow-modeller