Condividi tramite

Registrare modelli MLflow

Questo articolo descrive come registrare i modelli di Machine Learning sottoposti a training o artefatti come modelli MLflow. MLflow è un framework open source per la gestione dei flussi di lavoro di Machine Learning. Questo articolo illustra varie opzioni per personalizzare il modo in cui vengono eseguiti i pacchetti MLflow ed esegue i modelli.

Prerequisiti

  • Pacchetto MLflow SDK mlflow

Perché i modelli di log anziché gli artefatti?

Un modello MLflow è un tipo di artefatto. Tuttavia, un modello ha una struttura specifica che funge da contratto tra la persona che crea il modello e la persona che intende usarla. Questo contratto consente di creare un ponte tra gli artefatti stessi e i loro significati.

Per la differenza tra gli artefatti di registrazione o i file e la registrazione dei modelli MLflow, vedere Artefatti e modelli in MLflow.

È possibile registrare i file del modello come artefatti, ma la registrazione dei modelli offre i vantaggi seguenti:

  • È possibile usare mlflow.<flavor>.load_model per caricare direttamente i modelli per l'inferenza ed è possibile usare la predict funzione .
  • Gli input della pipeline possono usare direttamente i modelli.
  • È possibile distribuire modelli senza specificare uno script di assegnazione dei punteggi o un ambiente.
  • Swagger viene attivato automaticamente negli endpoint distribuiti. Di conseguenza, è possibile usare la funzionalità di test in Azure Machine Learning Studio per testare i modelli.
  • È possibile usare il dashboard di intelligenza artificiale responsabile. Per altre informazioni, vedere Usare il dashboard di intelligenza artificiale responsabile in Azure Machine Learning Studio.

Usare la registrazione automatica per registrare i modelli

È possibile usare la funzionalità MLflow autolog per registrare automaticamente i modelli. Quando si usa la registrazione automatica, MLflow acquisisce tutte le metriche, i parametri, gli artefatti e i modelli pertinenti nel framework. I dati registrati dipendono dal framework. Per impostazione predefinita, se la registrazione automatica è attivata, la maggior parte dei modelli viene registrata. In alcune situazioni, alcune varianti non registrano modelli. Ad esempio, la versione PySpark non registra modelli che superano una determinata dimensione.

Usare mlflow.autolog o mlflow.<flavor>.autolog per attivare la registrazione automatica. Il codice seguente usa autolog per registrare un modello di classificatore sottoposto a training con 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)

Suggerimento

Se si usano pipeline di Machine Learning, ad esempio pipeline scikit-learn, utilizzare la funzionalità di quel tipo di pipeline per registrare i modelli. La registrazione del modello viene eseguita automaticamente quando il fit metodo viene chiamato sull'oggetto pipeline. Per un notebook che registra un modello, include la pre-elaborazione e utilizza la pipeline, vedere Addestramento e tracciamento di un classificatore XGBoost con MLflow.

Modelli di log che usano una firma, un ambiente o esempi personalizzati

È possibile usare il metodo MLflow mlflow.<flavor>.log_model per registrare manualmente i modelli. Questo flusso di lavoro offre il controllo su vari aspetti della registrazione dei modelli.

Usare questo metodo nei casi seguenti:

  • Si vuole indicare un ambiente Conda o pacchetti pip che differiscono dai pacchetti o dall'ambiente rilevati automaticamente.
  • Si vogliono includere esempi di input.
  • Vuoi includere specifici artefatti nel pacchetto di cui hai bisogno.
  • Il autolog metodo non deduce correttamente la firma. Questo caso si verifica quando si lavora con gli input tensor, che richiedono la firma per avere una forma specifica.
  • Il autolog metodo non soddisfa tutte le esigenze.

Il codice seguente registra un modello di classificatore 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)

# Infer the signature.
signature = infer_signature(X_test, y_test)

# Set up a Conda environment.
custom_env =_mlflow_conda_env(
    additional_conda_deps=None,
    additional_pip_deps=["xgboost==1.5.2"],
    additional_conda_channels=None,
)

# Sample the data.
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)

Nota

  • La chiamata a autolog usa una configurazione di log_models=False. Questa impostazione disattiva la registrazione automatica del modello MLflow. Il log_model metodo viene usato in un secondo momento per registrare manualmente il modello.
  • Il infer_signature metodo viene usato per provare a dedurre la firma direttamente dagli input e dagli output.
  • Il metodo mlflow.utils.environment._mlflow_conda_env è un metodo privato nell’SDK MLflow. In questo esempio semplifica il codice. Ma usare questo metodo con cautela, perché potrebbe cambiare in futuro. In alternativa, è possibile generare manualmente la definizione YAML come dizionario Python.

Modelli di log che usano il comportamento di stima modificato

Quando si usa mlflow.autolog o mlflow.<flavor>.log_model per registrare un modello, il sapore del modello determina la modalità di esecuzione dell'inferenza. Il sapore determina anche il risultato restituito dal modello. MLflow non applica un comportamento specifico sulla generazione dei predict risultati. In alcuni scenari, è possibile pre-elaborare o post-elaborare i dati.

In questo caso, è possibile implementare pipeline di Machine Learning che passano direttamente dagli input agli output. Anche se questo tipo di implementazione può talvolta migliorare le prestazioni, può essere difficile da ottenere. In questi casi, può essere utile personalizzare il modo in cui il modello gestisce l'inferenza. Per ulteriori informazioni, vedere la sezione successiva Registrare modelli personalizzati.

Registrare modelli personalizzati

MLflow supporta molti framework di Machine Learning, inclusi i tipi seguenti:

  • CatBoost
  • FastAI
  • acqua
  • Keras
  • LightGBM
  • MLeap
  • ONNX
  • Profeta
  • PyTorch
  • scikit-learn
  • spaCy
  • Spark MLlib
  • statsmodels
  • TensorFlow
  • XGBoost

Per un elenco completo, vedere Built-In modelli di sapori.

Tuttavia, potrebbe essere necessario modificare il funzionamento di un sapore o registrare un modello che MLflow non supporta in modo nativo. Oppure potrebbe essere necessario registrare un modello che usa più elementi di vari framework. In questi casi, è possibile creare una variante personalizzata del modello.

Per risolvere il problema, MLflow offre il tipo PyFunc, un'interfaccia predefinita per modelli Python. Questo sapore può registrare qualsiasi oggetto come modello, purché l'oggetto soddisfi due condizioni:

  • Devi implementare almeno il metodo predict.
  • L'oggetto Python eredita dalla mlflow.pyfunc.PythonModel classe .

Suggerimento

I modelli serializzabili che implementano l'API scikit-learn possono usare il profilo scikit-learn per registrare il modello, indipendentemente dal fatto che il modello sia stato sviluppato con scikit-learn. Se è possibile rendere persistente il modello in formato Pickle e l'oggetto ha almeno i predict metodi e predict_proba , è possibile usare mlflow.sklearn.log_model per registrare il modello all'interno di un'esecuzione MLflow.

Il modo più semplice per creare un sapore per il modello personalizzato consiste nel creare un wrapper intorno all'oggetto modello esistente. MLflow serializza e impacchetta il tuo modello. Gli oggetti Python sono serializzabili quando l'oggetto può essere archiviato nel file system come file, generalmente in formato Pickle. In fase di esecuzione, l'oggetto può essere caricato da tale file. Il caricamento ripristina tutti i valori, le proprietà e i metodi disponibili al salvataggio.

Usare questo metodo nei casi seguenti:

  • È possibile serializzare il modello in formato Pickle.
  • Si vuole mantenere lo stato del modello subito dopo il training.
  • Si desidera personalizzare il funzionamento della funzione predict.

Il codice seguente esegue il wrapping di un modello creato con XGBoost in modo che si comporti in modo diverso rispetto all'implementazione predefinita di XGBoost flavor. Restituisce probabilità anziché classi.

from mlflow.pyfunc import PythonModel, PythonModelContext

class ModelWrapper(PythonModel):
    def __init__(self, model):
        self._model = model

    def predict(self, context: PythonModelContext, data):
        # The next line uses a prediction function. However, you could also use model.recommend(), model.forecast(), or a similar function instead.
        return self._model.predict_proba(data)

    # You can add extra functions if you need to. Because the model is serialized,
    # all of them are available when you load your model.
    def predict_batch(self, data):
        pass

Usare il codice seguente per registrare un modello personalizzato durante un'esecuzione:

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)

Suggerimento

Nel codice precedente il infer_signature metodo usa y_probs per dedurre la firma. La colonna di destinazione contiene la classe di destinazione, ma il modello restituisce due probabilità per ogni classe.

Passo successivo