Condividi tramite

Convertire modelli di Machine Learning personalizzati in modelli formattati MLflow

  • Articolo

Questo articolo illustra come convertire i modelli di Machine Learning personalizzati in formato MLflow. MLflow è una libreria open source per la gestione del ciclo di vita degli esperimenti di machine learning. In alcuni casi, è possibile usare un framework di Machine Learning senza il supporto della versione del modello MLflow predefinito. A causa di questa mancanza di versioni predefinite del modello MLflow, non è possibile registrare il modello con le API Fluent del modello MLflow. Per risolvere questo problema, è possibile convertire il modello in un formato MLflow in cui è possibile sfruttare i seguenti vantaggi dei modelli Azure Machine Learning e MLflow.

Con Azure Machine Learning, i modelli MLflow ottengono i seguenti vantaggi aggiuntivi:

  • Distribuzione senza codice
  • Portabilità come formato standard open source
  • Possibilità di eseguire la distribuzione sia in locale che nel cloud

MLflow offre supporto per vari framework di Machine Learning, ad esempio scikit-learn, Keras e PyTorch. MLflow potrebbe non coprire tutti i casi d'uso. Ad esempio, è possibile creare un modello MLflow con un framework che MLflow non supporta in modo nativo. È possibile modificare il modo in cui il modello esegue la pre-elaborazione o la post-elaborazione durante l'esecuzione di processi. Per altre informazioni sui modelli MLflow, vedere Da artefatti a modelli in MLflow.

Se non è stato eseguito il training del modello con MLFlow e si vuole usare l'offerta di distribuzione senza codice MLflow di Azure Machine Learning, è necessario convertire il modello personalizzato in MLFLow. Per altre informazioni, vedere Modelli Python personalizzati.

Prerequisiti

  • Installare il pacchetto mlflow

Creare un wrapper Python per il modello

Prima di poter convertire il modello in un formato supportato da MLflow, è necessario creare un wrapper Python per il modello. Nell'esempio di codice seguente viene illustrato come creare un wrapper Python per un modello sklearn.


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

Creare un ambiente Conda

Successivamente, creare l'ambiente Conda per il nuovo modello MLflow che contenga tutte le dipendenze necessarie. Se non indicato, l'ambiente viene dedotto dall'installazione corrente. In caso contrario, può essere specificato.


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

Caricare il modello formattato MLflow e le stime di test

Dopo che l'ambiente è pronto, passare il SKlearnWrapper, l'ambiente Conda e il dizionario degli artefatti appena creati al metodo mlflow.pyfunc.save_model(). In questo modo il modello viene salvato sul disco.

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)

Per assicurarsi che il modello formattato MLflow appena salvato non sia stato modificato durante il salvataggio, caricare il modello e stampare una stima di test per confrontare il modello originale.

Il codice seguente stampa una stima di test dal modello formattato mlflow e una stima di test del modello sklearn. Salva le stime di test sul disco per il confronto.

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)

Registrare il modello formattato MLflow

Dopo aver verificato che il modello sia stato salvato correttamente, è possibile creare un'esecuzione di test. Registrare e salvare il modello formattato MLflow nel registro dei modelli.


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

Importante

In alcuni casi, è possibile usare un framework di Machine Learning senza il supporto della versione del modello MLflow predefinito. Ad esempio, la libreria vaderSentiment è una libreria NLP (elaborazione del linguaggio naturale) standard usata per l'analisi del sentiment. A causa di questa mancanza di funzionalità predefinite del modello MLflow, non è possibile registrare il modello con le API Fluent del modello MLflow. Per un esempio su come salvare, registrare e registrare un modello che non dispone di una versione MLflow supportata, vedere Registrazione di un modello di Machine Learning non supportato.

Contenuto correlato