Exporter des artefacts de modèle pour la prédiction et l'explication

Vertex AI propose des conteneurs prédéfinis pour diffuser les prédictions et les explications des modèles entraînés à l'aide des frameworks de machine learning (ML) suivants :

  • TensorFlow
  • PyTorch
  • XGBoost
  • scikit-learn

Pour utiliser l'un de ces conteneurs prédéfinis, vous devez enregistrer votre modèle sous la forme d'un ou de plusieurs artefacts de modèle qui respectent les exigences du conteneur prédéfini. Ces exigences s'appliquent que vos artefacts de modèle soient créés ou non sur Vertex AI.

Si vous souhaitez utiliser un conteneur personnalisé pour livrer des prédictions, vous n'avez pas besoin de respecter les exigences décrites sur cette page. Toutefois, vous pouvez toujours les utiliser comme consignes.

Exigences spécifiques au framework pour l'exportation vers des conteneurs prédéfinis

Selon le framework de ML que vous prévoyez d'utiliser pour la prédiction, vous devez exporter les artefacts de modèle dans différents formats. Les sections suivantes décrivent les formats de modèle acceptables pour chaque framework de ML.

TensorFlow

Si vous utilisez TensorFlow pour entraîner un modèle, exportez-le en tant que répertoire TensorFlow SavedModel.

Il existe plusieurs façons d'exporter des SavedModel à partir de code d'entraînement TensorFlow. La liste suivante décrit plusieurs méthodes applicables à différentes API TensorFlow :

Pour diffuser des prédictions à l'aide de ces artefacts, créez un Model avec le conteneur de prédiction prédéfini correspondant à la version de TensorFlow que vous avez utilisée pour l'entraînement.

TensorFlow pour Vertex Explainable AI

Si vous souhaitez obtenir des explications à partir d'un Model qui utilise un conteneur prédéfini TensorFlow pour diffuser des prédictions, lisez les exigences supplémentaires pour exporter un modèle TensorFlow pour Vertex Explainable AI.

Activer le traitement par lot des requêtes côté serveur pour TensorFlow

Si vous souhaitez activer le traitement par lot des requêtes pour un Model qui utilise un conteneur TensorFlow prédéfini pour diffuser les prédictions, incluez le fichier config/batching_parameters_config dans le même répertoire Cloud Storage que le fichier saved_model.pb. Pour configurer le fichier de configuration par lot, consultez la documentation officielle de TensorFlow.

PyTorch

Vous devez empaqueter les artefacts de modèle, y compris un gestionnaire par défaut ou personnalisé, en créant un fichier d'archive à l'aide de l'archiveur de modèles Torch. Les images PyTorch prédéfinies s'attendent à ce que l'archive soit nommée model.mar. Par conséquent, veillez à définir le nom du modèle sur "model".

Pour en savoir plus sur l'optimisation de l'utilisation de la mémoire, de la latence ou du débit d'un modèle PyTorch diffusé avec TorchServe, consultez le guide de performances de PyTorch.

XGBoost

Si vous utilisez un conteneur prédéfini XGBoost pour entraîner un modèle, vous pouvez exporter le modèle entraîné de différentes manières :

Le nom de fichier de votre artefact de modèle doit correspondre exactement à l'une de ces options.

Les exemples suivants montrent comment entraîner et exporter un modèle :

xgboost.Booster

import os

from google.cloud import storage
from sklearn import datasets
import xgboost as xgb

digits = datasets.load_digits()
dtrain = xgb.DMatrix(digits.data, label=digits.target)
bst = xgb.train({}, dtrain, 20)

artifact_filename = 'model.bst'

# Save model artifact to local filesystem (doesn't persist)
local_path = artifact_filename
bst.save_model(local_path)

# Upload model artifact to Cloud Storage
model_directory = os.environ['AIP_MODEL_DIR']
storage_path = os.path.join(model_directory, artifact_filename)
blob = storage.blob.Blob.from_string(storage_path, client=storage.Client())
blob.upload_from_filename(local_path)

joblib

import os

from google.cloud import storage
from sklearn import datasets
import joblib
import xgboost as xgb

digits = datasets.load_digits()
dtrain = xgb.DMatrix(digits.data, label=digits.target)
bst = xgb.train({}, dtrain, 20)

artifact_filename = 'model.joblib'

# Save model artifact to local filesystem (doesn't persist)
local_path = artifact_filename
joblib.dump(bst, local_path)

# Upload model artifact to Cloud Storage
model_directory = os.environ['AIP_MODEL_DIR']
storage_path = os.path.join(model_directory, artifact_filename)
blob = storage.blob.Blob.from_string(storage_path, client=storage.Client())
blob.upload_from_filename(local_path)

pickle

import os
import pickle

from google.cloud import storage
from sklearn import datasets
import xgboost as xgb

digits = datasets.load_digits()
dtrain = xgb.DMatrix(digits.data, label=digits.target)
bst = xgb.train({}, dtrain, 20)

artifact_filename = 'model.pkl'

# Save model artifact to local filesystem (doesn't persist)
local_path = artifact_filename
with open(local_path, 'wb') as model_file:
  pickle.dump(bst, model_file)

# Upload model artifact to Cloud Storage
model_directory = os.environ['AIP_MODEL_DIR']
storage_path = os.path.join(model_directory, artifact_filename)
blob = storage.blob.Blob.from_string(storage_path, client=storage.Client())
blob.upload_from_filename(local_path)

Pour diffuser des prédictions à l'aide de cet artefact, créez une ressource Model avec le conteneur de prédiction prédéfini correspondant à la version de XGBoost utilisée pour l'entraînement.

scikit-learn

Si vous utilisez un modèle prédéfini scikit-learn pour entraîner un modèle, vous pouvez l'exporter de différentes manières :

Le nom de fichier de votre artefact de modèle doit correspondre exactement à l'une de ces options. Vous pouvez exporter des estimateurs scikit-learn ou des pipelines scikit-learn standards.

Les exemples suivants montrent comment entraîner et exporter un modèle :

joblib

import os

from google.cloud import storage
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier
import joblib

digits = datasets.load_digits()
classifier = RandomForestClassifier()
classifier.fit(digits.data, digits.target)

artifact_filename = 'model.joblib'

# Save model artifact to local filesystem (doesn't persist)
local_path = artifact_filename
joblib.dump(classifier, local_path)

# Upload model artifact to Cloud Storage
model_directory = os.environ['AIP_MODEL_DIR']
storage_path = os.path.join(model_directory, artifact_filename)
blob = storage.blob.Blob.from_string(storage_path, client=storage.Client())
blob.upload_from_filename(local_path)

pickle

import os
import pickle

from google.cloud import storage
from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier

digits = datasets.load_digits()
classifier = RandomForestClassifier()
classifier.fit(digits.data, digits.target)

artifact_filename = 'model.pkl'

# Save model artifact to local filesystem (doesn't persist)
local_path = artifact_filename
with open(local_path, 'wb') as model_file:
  pickle.dump(classifier, model_file)

# Upload model artifact to Cloud Storage
model_directory = os.environ['AIP_MODEL_DIR']
storage_path = os.path.join(model_directory, artifact_filename)
blob = storage.blob.Blob.from_string(storage_path, client=storage.Client())
blob.upload_from_filename(local_path)

Pour diffuser des prédictions à l'aide de cet artefact, créez une classe Model avec le conteneur de prédiction prédéfini correspondant à la version de scikit-learn que vous avez utilisée pour l'entraînement.

Étapes suivantes