Delen via

Aangepaste ML-modellen converteren naar geformatteerde MLflow-modellen

  • Artikel

In dit artikel leert u hoe u uw aangepaste ML-model converteert naar MLflow-indeling. MLflow is een opensource-bibliotheek voor het beheren van de levenscyclus van uw machine learning-experimenten. In sommige gevallen kunt u een machine learning-framework gebruiken zonder de ingebouwde ondersteuning voor de smaak van het MLflow-model. Vanwege dit gebrek aan ingebouwde MLflow-modelsmaak kunt u het model niet registreren of registreren met fluent API's van het MLflow-model. U kunt dit probleem oplossen door uw model te converteren naar een MLflow-indeling, waar u de volgende voordelen van Azure Machine Learning- en MLflow-modellen kunt toepassen.

Met Azure Machine Learning krijgen MLflow-modellen de extra voordelen van:

  • Geen code-implementatie
  • Portabiliteit als opensource-standaardindeling
  • Mogelijkheid om zowel lokaal als in de cloud te implementeren

MLflow biedt ondersteuning voor verschillende machine learning-frameworks, zoals scikit-learn, Keras en Pytorch. MLflow omvat mogelijk niet elke use-case. U kunt bijvoorbeeld een MLflow-model maken met een framework dat MLflow niet systeemeigen ondersteunt. Mogelijk wilt u de manier wijzigen waarop uw model voorverwerking of naverwerking uitvoert bij het uitvoeren van taken. Zie Van artefacten tot modellen in MLflow voor meer informatie over MLflow-modellen.

Als u uw model niet hebt getraind met MLFlow en het MLflow no-code-implementatieaanbod van Azure Machine Learning wilt gebruiken, moet u uw aangepaste model converteren naar MLFLow. Zie Aangepaste Python-modellen voor meer informatie.

Vereisten

  • Installeer het pakket mlflow

Een Python-wrapper maken voor uw model

Voordat u uw model kunt converteren naar een door MLflow ondersteunde indeling, moet u een Python-wrapper voor uw model maken. De volgende code laat zien hoe u een Python-wrapper voor een sklearn model maakt.


# 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)

Een Conda-omgeving maken

Maak vervolgens een Conda-omgeving voor het nieuwe MLflow-model dat alle benodigde afhankelijkheden bevat. Als dit niet wordt aangegeven, wordt de omgeving afgeleid van de huidige installatie. Zo niet, dan kan deze worden opgegeven.


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'
}

Het geformatteerde MLflow-model laden en voorspellingen testen

Nadat uw omgeving klaar is, geeft u de SKlearnWrapperConda-omgeving en de zojuist gemaakte artefactenwoordenlijst door aan de mlflow.pyfunc.save_model() methode. Hierdoor wordt het model op uw schijf opgeslagen.

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)

Om ervoor te zorgen dat het zojuist opgeslagen MLflow-opgemaakte model niet is gewijzigd tijdens het opslaan, laadt u uw model en drukt u een testvoorspelling af om het oorspronkelijke model te vergelijken.

Met de volgende code wordt een testvoorspelling van het model met mlflow-indeling en een testvoorspelling van het sklearn-model afgedrukt. Hiermee worden de testvoorspellingen op uw schijf opgeslagen ter vergelijking.

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)

Het geformatteerde MLflow-model registreren

Nadat u hebt bevestigd dat uw model correct is opgeslagen, kunt u een testuitvoering maken. Registreer het MLflow-geformatteerde model en sla het op in het modelregister.


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()

Belangrijk

In sommige gevallen kunt u een machine learning-framework gebruiken zonder de ingebouwde ondersteuning voor de smaak van het MLflow-model. De vaderSentiment bibliotheek is bijvoorbeeld een standaard NLP-bibliotheek (Natural Language Processing) die wordt gebruikt voor sentimentanalyse. Omdat het geen ingebouwde MLflow-modelsmaak heeft, kunt u het model niet registreren of registreren met fluent API's van het MLflow-model. Zie Een niet-ondersteund Machine Learning-model registreren voor een voorbeeld van het opslaan, registreren en registreren van een model dat geen ondersteunde ingebouwde MLflow-modelsmaak heeft.

Gerelateerde inhoud