Dela via

Konvertera anpassade ML-modeller till MLflow-formaterade modeller

  • Artikel

I den här artikeln får du lära dig hur du konverterar din anpassade ML-modell till MLflow-format. MLflow är ett bibliotek med öppen källkod för att hantera livscykeln för dina maskininlärningsexperiment. I vissa fall kan du använda ett maskininlärningsramverk utan dess inbyggda MLflow-modellsmakstöd. På grund av den här bristen på inbyggd MLflow-modellsmak kan du inte logga eller registrera modellen med MLflow-modellens fluent-API:er. För att lösa det här problemet kan du konvertera din modell till ett MLflow-format där du kan använda följande fördelar med Azure Mašinsko učenje- och MLflow-modeller.

Med Azure Mašinsko učenje får MLflow-modeller de extra fördelarna med:

  • Ingen koddistribution
  • Portabilitet som ett standardformat med öppen källkod
  • Möjlighet att distribuera både lokalt och i molnet

MLflow ger stöd för olika ramverk för maskininlärning, till exempel scikit-learn, Keras och Pytorch. MLflow kanske inte täcker alla användningsfall. Du kanske till exempel vill skapa en MLflow-modell med ett ramverk som MLflow inte har inbyggt stöd för. Du kanske vill ändra hur din modell utför förbearbetning eller efterbearbetning när jobb körs. Mer information om MLflow-modeller finns i Från artefakter till modeller i MLflow.

Om du inte tränade din modell med MLFlow och vill använda Azure Mašinsko učenje distributionserbjudande utan MLflow-kod måste du konvertera din anpassade modell till MLFLow. Mer information finns i Anpassade Python-modeller.

Förutsättningar

  • Installera mlflow-paketet

Skapa en Python-omslutning för din modell

Innan du kan konvertera din modell till ett MLflow-format som stöds måste du skapa en Python-omslutning för din modell. Följande kod visar hur du skapar en Python-omslutning för en sklearn modell.


# Load training and test datasets
from sys import version_info
import sklearn
import mlflow.pyfunc


PYTHON_VERSION = "{major}.{minor}.{micro}".format(major=version_info.major,
                                                  minor=version_info.minor,
                                                  micro=version_info.micro)

# Train and save an SKLearn model
sklearn_model_path = "model.pkl"

artifacts = {
    "sklearn_model": sklearn_model_path
}

# create wrapper
class SKLearnWrapper(mlflow.pyfunc.PythonModel):

    def load_context(self, context):
        import pickle
        self.sklearn_model = pickle.load(open(context.artifacts["sklearn_model"], 'rb'))
    
    def predict(self, model, data):
        return self.sklearn_model.predict(data)

Skapa en Conda-miljö

Skapa sedan Conda-miljön för den nya MLflow-modellen som innehåller alla nödvändiga beroenden. Om det inte anges härleds miljön från den aktuella installationen. Annars kan du ange det.


import cloudpickle
conda_env = {
    'channels': ['defaults'],
    'dependencies': [
      'python={}'.format(PYTHON_VERSION),
      'pip',
      {
        'pip': [
          'mlflow',
          'scikit-learn=={}'.format(sklearn.__version__),
          'cloudpickle=={}'.format(cloudpickle.__version__),
        ],
      },
    ],
    'name': 'sklearn_env'
}

Läs in MLflow-formaterad modell och testa förutsägelser

När miljön är klar skickar SKlearnWrapperdu , Conda-miljön och din nyligen skapade artefaktordlista till mlflow.pyfunc.save_model() metoden. När du gör det sparas modellen på disken.

mlflow_pyfunc_model_path = "sklearn_mlflow_pyfunc_custom"
mlflow.pyfunc.save_model(path=mlflow_pyfunc_model_path, python_model=SKLearnWrapper(), conda_env=conda_env, artifacts=artifacts)

För att säkerställa att den nyligen sparade MLflow-formaterade modellen inte ändrades under sparande läser du in din modell och skriver ut en testförutsägelse för att jämföra din ursprungliga modell.

Följande kod skriver ut en testförutsägelse från den mlflow-formaterade modellen och en testförutsägelse från sklearnmodellen. Det sparar testförutsägelserna på disken för jämförelse.

loaded_model = mlflow.pyfunc.load_model(mlflow_pyfunc_model_path)

input_data = "<insert test data>"
# Evaluate the model
import pandas as pd
test_predictions = loaded_model.predict(input_data)
print(test_predictions)

# load the model from disk
import pickle
loaded_model = pickle.load(open(sklearn_model_path, 'rb'))
result = loaded_model.predict(input_data)
print(result)

Registrera den MLflow-formaterade modellen

När du har bekräftat att din modell har sparats korrekt kan du skapa en testkörning. Registrera och spara din MLflow-formaterade modell i modellregistret.


mlflow.start_run()

mlflow.pyfunc.log_model(artifact_path=mlflow_pyfunc_model_path, 
                        loader_module=None, 
                        data_path=None, 
                        code_path=None,
                        python_model=SKLearnWrapper(),
                        registered_model_name="Custom_mlflow_model", 
                        conda_env=conda_env,
                        artifacts=artifacts)
mlflow.end_run()

Viktigt!

I vissa fall kan du använda ett maskininlärningsramverk utan dess inbyggda MLflow-modellsmakstöd. Biblioteket är till exempel vaderSentiment ett NLP-bibliotek (Standard Natural Language Processing) som används för attitydanalys. Eftersom den saknar en inbyggd MLflow-modellsmak kan du inte logga eller registrera modellen med API:er för MLflow-modellen fluent. Ett exempel på hur du sparar, loggar och registrerar en modell som inte har en inbyggd MLflow-modellsmak som stöds finns i Registrera en Mašinsko učenje modell som inte stöds.

Relaterat innehåll