Konvertera anpassade ML-modeller till MLflow-formaterade modeller

  • Artikel

I den här artikeln lär du 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 detta kan du konvertera din modell till ett MLflow-format där du kan dra nytta av följande fördelar med Azure Machine Learning- och MLflow-modeller.

Med Azure Machine Learning får MLflow-modeller de extra fördelarna med,

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

MLflow ger stöd för en mängd olika ramverk för maskininlärning (scikit-learn, Keras, Pytorch med mera); Det kanske dock 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, eller så kanske du 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 har tränat din modell med MLFlow och vill använda distributionserbjudandet MLflow no-code i Azure Machine Learning måste du konvertera din anpassade modell till MLFLow. Läs mer om anpassade Python-modeller och MLflow.

Förutsättningar

Endast mlflow-paketet som är installerat behövs för att konvertera dina anpassade modeller till ett MLflow-format.

Skapa en Python-adapter för din modell

Innan du kan konvertera din modell till ett format som stöds av MLflow måste du först skapa en Python-adapter för din modell. Följande kod visar hur du skapar en Python-adapter 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ö

Därefter måste du skapa 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 den anges.


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 den MLFlow-formaterade modellen och testa förutsägelser

När din miljö är klar kan du skicka SKlearnWrapper, Conda-miljön och din nyligen skapade artefaktordlista till metoden mlflow.pyfunc.save_model(). 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 kan du läsa in din modell och skriva 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 den sklearnmodell som sparas 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 så att du kan 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 (Natural Language Processing) som används för attitydanalys. Eftersom den saknar en inbyggd MLflow-modellsmak kan du inte logga eller registrera modellen med MLflow-modellens fluent-API:er. Se ett exempel på hur du sparar, loggar och registrerar en modell som inte har en inbyggd MLflow-modellsmak som stöds.

Nästa steg