Rejestrowanie modeli MLflow

  • Artykuł

W tym artykule opisano sposób rejestrowania wytrenowanych modeli (lub artefaktów) jako modeli MLflow. Poznaje różne sposoby dostosowywania sposobu tworzenia pakietów modeli przez platformę MLflow oraz sposobu uruchamiania tych modeli.

Dlaczego modele rejestrowania zamiast artefaktów?

Z artefaktów po modele w MLflow opisuje różnicę między artefaktami rejestrowania lub plikami, w porównaniu z rejestrowaniem modeli MLflow.

Model MLflow jest również artefaktem. Jednak ten model ma określoną strukturę, która służy jako umowa między osobą, która utworzyła model i osobę, która zamierza jej używać. Ten kontrakt pomaga zbudować most między samymi artefaktami a ich znaczeniem.

Rejestrowanie modeli ma następujące zalety:

  • Możesz bezpośrednio ładować modele, na potrzeby wnioskowania za pomocą mlflow.<flavor>.load_modelfunkcji , i można użyć predict funkcji
  • Dane wejściowe potoku mogą używać modeli bezpośrednio
  • Modele można wdrażać bez wskazania skryptu oceniania lub środowiska
  • Program Swagger jest automatycznie włączony we wdrożonych punktach końcowych, a program Azure Machine Edukacja Studio może korzystać z funkcji Test
  • Możesz użyć pulpitu nawigacyjnego Odpowiedzialne używanie sztucznej inteligencji

W tej sekcji opisano sposób używania koncepcji modelu w usłudze Azure Machine Edukacja z rozwiązaniem MLflow:

Rejestrowanie modeli przy użyciu autologu

Możesz użyć funkcji autologu MLflow. Autolog umożliwia usłudze MLflow poinstruowanie platformy używanej do rejestrowania wszystkich metryk, parametrów, artefaktów i modeli, które platforma uważa za istotne. Domyślnie, jeśli funkcja automatycznego rejestrowania jest włączona, większość modeli jest rejestrowana. W niektórych sytuacjach niektóre smaki mogą nie rejestrować modelu. Na przykład smak PySpark nie rejestruje modeli, które przekraczają określony rozmiar.

Użyj opcji mlflow.autolog() lub mlflow.<flavor>.autolog() , aby aktywować automatyczne rejestrowanie. W tym przykładzie użyto autolog() metody rejestrowania modelu klasyfikatora wytrenowanego za pomocą biblioteki 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)

Napiwek

Jeśli używasz potoków usługi Machine Edukacja, na przykład potoków Scikit-Learn, użyj autolog funkcji tego potoku w celu rejestrowania modeli. Rejestrowanie modelu odbywa się automatycznie, gdy fit() metoda jest wywoływana w obiekcie potoku. Trenowanie i śledzenie klasyfikatora XGBoost za pomocą notesu MLflow pokazuje, jak rejestrować model przy użyciu przetwarzania wstępnego przy użyciu potoków.

Rejestrowanie modeli przy użyciu niestandardowego podpisu, środowiska lub przykładów

Metoda MLflow mlflow.<flavor>.log_model może ręcznie rejestrować modele. Ten przepływ pracy może kontrolować różne aspekty rejestrowania modelu.

Użyj tej metody, gdy:

  • Chcesz wskazać pakiety pip lub środowisko conda, które różni się od tych, które są wykrywane automatycznie
  • Chcesz dołączyć przykłady danych wejściowych
  • Chcesz uwzględnić określone artefakty w wymaganym pakiecie
  • autolog nie poprawnie wywnioskuje podpisu. Ma to znaczenie w przypadku czynienia z danymi wejściowymi tensor, w których podpis wymaga określonych kształtów
  • Zachowanie autologu nie obejmuje twojego celu z jakiegoś powodu

Ten przykładowy kod rejestruje model klasyfikatora XGBoost:

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)

Uwaga

  • autolog ma konfigurację log_models=False . Zapobiega to automatycznemu rejestrowaniu modeli MLflow. Automatyczne rejestrowanie modelu MLflow odbywa się później w ramach procesu ręcznego
  • infer_signature Użyj metody , aby spróbować wywnioskować podpis bezpośrednio z danych wejściowych i wyjściowych
  • Metoda mlflow.utils.environment._mlflow_conda_env jest prywatną metodą w zestawie MLflow SDK. W tym przykładzie kod jest prostszy, ale należy go używać z ostrożnością. Może to ulec zmianie w przyszłości. Alternatywnie możesz wygenerować definicję YAML ręcznie jako słownik języka Python.

Rejestrowanie modeli przy użyciu innego zachowania w metodzie predict

Podczas rejestrowania modelu za pomocą mlflow.autolog elementu lub mlflow.<flavor>.log_model, smak modelu określa sposób wykonywania wnioskowania i zwracany przez model. Platforma MLflow nie wymusza żadnego konkretnego zachowania na temat generowania predict wyników. W niektórych scenariuszach warto wykonać wstępne przetwarzanie lub przetwarzanie końcowe przed wykonaniem modelu i po nim.

W takiej sytuacji zaimplementuj potoki uczenia maszynowego, które bezpośrednio przechodzą z danych wejściowych do danych wyjściowych. Chociaż ta implementacja jest możliwa, a czasami zachęcana do poprawy wydajności, może to stać się trudne do osiągnięcia. W takich przypadkach może to pomóc w dostosowaniu sposobu, w jaki model obsługuje wnioskowanie , jak wyjaśniono w następnej sekcji.

Rejestrowanie modeli niestandardowych

Platforma MLflow obsługuje wiele platform uczenia maszynowego, w tym

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

Może jednak być konieczne zmianę sposobu działania smaku, zarejestrowanie modelu nieobsługiwanego natywnie przez platformę MLflow, a nawet zarejestrowanie modelu korzystającego z wielu elementów z różnych struktur. W takich przypadkach może być konieczne utworzenie niestandardowej odmiany modelu.

Aby rozwiązać ten problem, platforma MLflow wprowadza pyfunc smak (począwszy od funkcji języka Python). Ten smak może rejestrować dowolny obiekt jako model, o ile ten obiekt spełnia dwa warunki:

  • Implementujesz metodę predict , co najmniej
  • Obiekt języka Python dziedziczy z mlflow.pyfunc.PythonModel

Napiwek

Modele z możliwością serializacji, które implementują interfejs API Scikit-learn, mogą używać odmiany Scikit-learn do rejestrowania modelu, niezależnie od tego, czy model został utworzony za pomocą biblioteki Scikit-learn. Jeśli możesz utrwał model w formacie Pickle, a obiekt ma predict() metody i predict_proba() (co najmniej), możesz użyć mlflow.sklearn.log_model() polecenia , aby zarejestrować model wewnątrz przebiegu platformy MLflow.

Jeśli tworzysz otokę wokół istniejącego obiektu modelu, najprostsze staje się utworzenie odmiany modelu niestandardowego. MLflow serializuje i pakuje go za Ciebie. Obiekty języka Python można serializować, gdy obiekt może być przechowywany w systemie plików jako plik, zazwyczaj w formacie Pickle. W czasie wykonywania obiekt może zmaterializować się z tego pliku. Spowoduje to przywrócenie wszystkich wartości, właściwości i metod dostępnych podczas zapisywania.

Użyj tej metody, gdy:

  • Model można serializować w formacie pickle
  • Chcesz zachować stan modelu, tak jak to miało miejsce tuż po trenowaniu
  • Chcesz dostosować sposób predict działania funkcji.

Ten przykładowy kod opakowuje model utworzony za pomocą biblioteki XGBoost, aby zachowywać się w innej niż domyślna implementacja języka XGBoost. Zamiast tego zwraca prawdopodobieństwa zamiast klas:

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

Rejestrowanie modelu niestandardowego w przebiegu:

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)

Napiwek

infer_signature W tym miejscu metoda używa y_probs metody do wnioskowania podpisu. Nasza kolumna docelowa ma klasę docelową, ale nasz model zwraca teraz dwa prawdopodobieństwa dla każdej klasy.

Następne kroki