Dela via

Logga MLflow-modeller

  • Artikel

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 Mašinsko učenje 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 Mašinsko učenje 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 Mašinsko učenje 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
  • Profet
  • 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.

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.

Nästa steg