Exporter des artefacts de modèle pour l'inférence et l'explication

Gemini Enterprise Agent Platform offers des conteneurs prédéfinis pour diffuser les inférences 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 Agent Platform.

Si vous souhaitez utiliser un conteneur personnalisé pour diffuser des inférences, 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 l' inférence, 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 inférences à l'aide de ces artefacts, créez un Model avec le conteneur prédéfini pour l'inférence 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 inférences, 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 inférences, 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 vos artefacts de modèle dans un fichier d'archive de modèle (.mar). Cette archive doit inclure un script de gestionnaire, soit par défaut ou personnalisé, qui définit la manière dont le modèle traite les requêtes d'inférence. Pour les workflows plus avancés, vous devriez envisager d'utiliser des conteneurs personnalisés au lieu de vous appuyer sur l'image de diffusion PyTorch prédéfinie.

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" lors de la création de l'archive.

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 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.

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)

Pour diffuser des inférences à l’aide de cet artefact, créez un Model avec le conteneur prédéfini pour l’inférence correspondant à la version de XGBoost que vous avez 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 à l'aide de la bibliothèque joblib pour exporter un fichier nommé model.joblib.

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 scikit-learn pipelines standards.

L'exemple suivant montre 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)

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

Étape suivante