Obtenir des inférences par lot à partir d'un modèle entraîné personnalisé

Cette page explique comment obtenir des inférences par lot à partir de vos modèles entraînés personnalisés à l'aide de la console Google Cloud ou de l'API Vertex AI.

Pour effectuer une requête d'inférence par lot, vous devez spécifier une source d'entrée et un emplacement de sortie (Cloud Storage ou BigQuery) dans lequel Vertex AI stocke les résultats de l'inférence par lot.

Limites et exigences

Tenez compte des limites et des exigences suivantes lorsque vous obtenez des inférences par lots :

  • Pour réduire le temps de traitement, vos emplacements d'entrée et de sortie doivent se trouver dans la même région ou le même emplacement multirégional. Par exemple, si votre entrée se trouve dans us-central1, la sortie peut être localisée dans us-central1 ou US, mais pas dans europe-west4. Pour en savoir plus, consultez Emplacements Cloud Storage et Emplacements BigQuery.
  • Votre entrée et votre sortie doivent également se trouver dans la même région ou le même emplacement multirégional que votre modèle.
  • Contrairement à l'inférence en ligne, les jobs d'inférence par lot n'effectuent pas d'autoscaling. Étant donné que toutes les données d'entrée sont connues à l'avance, le système partitionne les données sur chaque instance répliquée au démarrage du job. Le système utilise le paramètre starting_replica_count. Le paramètre max_replica_count est ignoré.
  • Remarque : Les modèles BigQuery ML ne sont pas des modèles entraînés personnalisés. Toutefois, les informations de cette page peuvent être utilisées pour obtenir des inférences par lot à partir d'un modèle BigQuery ML dans les conditions suivantes :
    • Le modèle BigQuery ML doit être enregistré auprès de Vertex AI Model Registry.
    • Pour utiliser une table BigQuery comme entrée, vous devez définir InstanceConfig.instanceType sur "object" à l'aide de l'API Vertex AI.
  • Le chargement d'un modèle d'inférence par lots expire au bout d'environ 40 minutes. Si le message d'erreur suivant s'affiche, utilisez un modèle plus petit pour les inférences par lots : Error: model server never became ready. Please validate that your model file or container configuration are valid.
  • Les comptes de service personnalisés ne sont compatibles qu'avec le serveur de modèle, et non avec le client d'inférence par lot qui effectue des opérations de lecture et d'écriture de données vers et depuis Cloud Storage et BigQuery.

Exigences concernant les données d'entrée

L'entrée des requêtes par lot spécifie les éléments à envoyer à votre modèle pour l'inférence. Les formats d'entrée suivants sont acceptés :

JSON Lines

Utilisez un fichier JSON Lines pour spécifier une liste d'instances d'entrée sur lesquelles effectuer des inférences. Stockez le fichier dans un bucket Cloud Storage.

Exemple 1

L'exemple suivant montre un fichier JSON Lines où chaque ligne contient un tableau :

[1, 2, 3, 4]
[5, 6, 7, 8]

Voici ce qui est envoyé au conteneur dans le corps de la requête HTTP :

Tous les autres conteneurs

{"instances": [ [1, 2, 3, 4], [5, 6, 7, 8] ]}

Conteneurs PyTorch

{"instances": [
{ "data": [1, 2, 3, 4] },
{ "data": [5, 6, 7, 8] } ]}

Exemple 2

L'exemple suivant montre un fichier JSON Lines dans lequel chaque ligne contient un objet.

{ "values": [1, 2, 3, 4], "key": 1 }
{ "values": [5, 6, 7, 8], "key": 2 }

Voici ce qui est envoyé au conteneur dans le corps de la requête HTTP. Notez que le même corps de requête est envoyé à tous les conteneurs.

{"instances": [
  { "values": [1, 2, 3, 4], "key": 1 },
  { "values": [5, 6, 7, 8], "key": 2 }
]}

Exemple 3

Pour les conteneurs prédéfinis PyTorch, assurez-vous d'encapsuler chaque instance dans un champ data comme requis par le gestionnaire par défaut de TorchServe. Vertex AI n'encapsule pas vos instances pour vous. Exemple :

{ "data": { "values": [1, 2, 3, 4], "key": 1 } }
{ "data": { "values": [5, 6, 7, 8], "key": 2 } }

Voici ce qui est envoyé au conteneur d'inférence dans le corps de la requête HTTP :

{"instances": [
  { "data": { "values": [1, 2, 3, 4], "key": 1 } },
  { "data": { "values": [5, 6, 7, 8], "key": 2 } }
]}

TFRecord

Enregistrez les instances d'entrée au format TFRecord. Vous pouvez éventuellement compresser les fichiers TFRecord avec Gzip. Stockez les fichiers TFRecord dans un bucket Cloud Storage.

Vertex AI lit chaque instance de vos fichiers TFRecord en tant qu'élément binaire, puis l'encode en base64 en tant qu'objet JSON avec une seule clé nommée b64.

Voici ce qui est envoyé au conteneur dans le corps de la requête HTTP :

Tous les autres conteneurs

{"instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

Conteneurs PyTorch

{"instances": [ { "data": {"b64": "b64EncodedASCIIString" } }, { "data": {"b64": "b64EncodedASCIIString" } }
]}

Assurez-vous que votre conteneur sait comment décoder l'instance.

CSV

Spécifiez une instance d'entrée par ligne dans un fichier CSV. La première ligne doit être une ligne d'en-tête. Vous devez placer toutes les chaînes entre guillemets doubles ("). Vertex AI n'accepte pas les valeurs de cellule contenant des sauts de ligne. Les valeurs sans guillemets sont lues comme des nombres à virgule flottante.

L'exemple suivant montre un fichier CSV avec deux instances d'entrée :

"input1","input2","input3"
0.1,1.2,"cat1"
4.0,5.0,"cat2"

Voici ce qui est envoyé au conteneur dans le corps de la requête HTTP :

Tous les autres conteneurs

{"instances": [ [0.1,1.2,"cat1"], [4.0,5.0,"cat2"] ]}

Conteneurs PyTorch

{"instances": [
{ "data": [0.1,1.2,"cat1"] },
{ "data": [4.0,5.0,"cat2"] } ]}

Liste de fichiers

Créez un fichier texte dans lequel chaque ligne correspond à l'URI Cloud Storage d'un fichier. Vertex AI lit le contenu de chaque fichier en tant qu'élément binaire, puis l'encode en base64 en tant qu'objet JSON avec une seule clé nommée b64.

Si vous prévoyez d'utiliser la console Google Cloud pour obtenir des inférences par lot, collez votre liste de fichiers directement dans la console Google Cloud . Sinon, enregistrez la liste dans un bucket Cloud Storage.

L'exemple suivant montre une liste de fichiers avec deux instances d'entrée :

gs://path/to/image/image1.jpg
gs://path/to/image/image2.jpg

Voici ce qui est envoyé au conteneur dans le corps de la requête HTTP :

Tous les autres conteneurs

{ "instances": [
{ "b64": "b64EncodedASCIIString" },
{ "b64": "b64EncodedASCIIString" } ]}

Conteneurs PyTorch

{ "instances": [ { "data": { "b64": "b64EncodedASCIIString" } }, { "data": { "b64": "b64EncodedASCIIString" } }
]}

Assurez-vous que votre conteneur sait comment décoder l'instance.

BigQuery

Spécifiez une table BigQuery en tant que projectId.datasetId.tableId. Vertex AI transforme chaque ligne de la table en instance JSON.

Par exemple, si votre table contient les éléments suivants :

Colonne 1 Colonne 2 Colonne 3
1.0 3.0 "Cat1"
2.0 4.0 "Cat2"

Voici ce qui est envoyé au conteneur dans le corps de la requête HTTP :

Tous les autres conteneurs

{"instances": [ [1.0,3.0,"cat1"], [2.0,4.0,"cat2"] ]}

Conteneurs PyTorch

{"instances": [
{ "data": [1.0,3.0,"cat1"] },
{ "data": [2.0,4.0,"cat2"] } ]}

Voici comment les types de données BigQuery sont convertis au format JSON :

Type BigQuery Type JSON Exemple de valeur
Chaîne Chaîne "abc"
Entier Entier 1
Nombre à virgule flottante Nombre à virgule flottante 1.2
Numérique Nombre à virgule flottante 4925.000000000
Booléen Booléen true
Code temporel Chaîne "2019-01-01 23:59:59.999999+00:00"
Date Chaîne "2018-12-31"
Heure Chaîne "23:59:59.999999"
DateTime Chaîne "2019-01-01T00:00:00"
Enregistrement Objet { "A": 1,"B": 2}
Type répété Type Array (tableau) [1, 2]
Enregistrement imbriqué Objet {"A": {"a": 0}, "B": 1}

Partitionner les données

L'inférence par lot utilise MapReduce pour segmenter l'entrée sur chaque instance dupliquée. Pour utiliser les fonctionnalités de MapReduce, l'entrée doit être partitionnable.

Vertex AI partitionne automatiquement l'entrée BigQuery, la liste de fichiers et les lignes JSON.

Vertex AI ne partitionne pas automatiquement les fichiers CSV, car ils ne sont pas naturellement compatibles avec le partitionnement. Les lignes des fichiers CSV ne sont pas autodescriptives, sont typées et peuvent contenir des sauts de ligne. Nous vous déconseillons d'utiliser des entrées CSV pour les applications sensibles au débit.

Pour les entrées TFRecord, veillez à partitionner manuellement les données en divisant les instances en fichiers plus petits et en transmettant les fichiers au job avec un caractère générique (par exemple, gs://my-bucket/*.tfrecord). Le nombre de fichiers doit être au moins équivalent au nombre d'instances répliquées spécifié.

Filtrer et transformer les données d'entrée

Vous pouvez filtrer et transformer votre entrée par lots en spécifiant instanceConfig dans votre requête BatchPredictionJob.

Le filtrage vous permet d'exclure certains champs des données d'entrée de votre requête d'inférence ou de n'inclure qu'un sous-ensemble de champs à partir des données d'entrée de votre requête d'inférence, sans avoir à effectuer de prétraitement/post-traitement personnalisé dans le conteneur d'inférence. Cela s'avère utile lorsque votre fichier de données d'entrée contient des colonnes supplémentaires dont le modèle n'a pas besoin, telles que des clés ou des données supplémentaires.

La transformation vous permet d'envoyer les instances à votre conteneur au format JSON array ou object. Pour en savoir plus, consultez la page sur instanceType.

Par exemple, si votre table contient les éléments suivants :

customerId col1 col2
1001 1 2
1002 5 6

et que vous spécifiez l'élément instanceConfig suivant :

{
  "name": "batchJob1",
  ...
  "instanceConfig": {
    "excludedFields":["customerId"]
    "instanceType":"object"
  }
}

Ensuite, les instances de votre requête d'inférence sont envoyées en tant qu'objets JSON et la colonne customerId est exclue :

{"col1":1,"col2":2}
{"col1":5,"col2":6}

Notez que la spécification de l'élément instanceConfig suivant donne le même résultat :

{
  "name": "batchJob1",
  ...
  "instanceConfig": {
    "includedFields": ["col1","col2"]
    "instanceType":"object"
  }
}

Pour une démonstration de l'utilisation des filtres de caractéristiques, consultez le notebook Inférence par lot de modèles personnalisés avec filtrage des caractéristiques.

Demander une inférence par lot

Pour les requêtes d'inférence par lot, vous pouvez utiliser la console Google Cloud ou l'API Vertex AI. Selon le nombre d'éléments d'entrée envoyés, la tâche d'inférence par lot peut prendre plus ou moins de temps.

Lorsque vous demandez une inférence par lot, le conteneur d'inférence s'exécute en tant que compte de service personnalisé fourni par l'utilisateur. Les opérations de lecture/écriture, telles que la lecture des instances d'inférence à partir de la source de données ou l'écriture des résultats de l'inférence, sont effectuées à l'aide de l'agent de service Vertex AI, lequel, par défaut, a accès à BigQuery et à Cloud Storage.

Console Google Cloud

Utilisez la console Google Cloud pour demander une inférence par lot.

  1. Dans la section Vertex AI de la console Google Cloud , accédez à la page Prédictions par lots.

Accéder à la page "Prédictions par lots"

  1. Cliquez sur Créer pour ouvrir la fenêtre Nouvelle prédiction par lots.

  2. Dans Définir votre prédiction par lots, procédez comme suit :

    1. Saisissez un nom pour l'inférence par lot.

    2. Dans Nom du modèle, sélectionnez le nom du modèle à utiliser pour cette inférence par lots.

    3. Dans le champ Sélectionner une source, sélectionnez la source qui s'applique à vos données d'entrée :

      • Si vous avez formaté votre entrée au format JSON Lines, CSV ou TFRecord, sélectionnez Fichier sur Cloud Storage (JSON Lines, CSV, TFRecord, TFRecord, TFRecord Gzip). Ensuite, spécifiez votre fichier d'entrée dans le champ Chemin source.
      • Si vous utilisez une liste de fichiers en entrée, sélectionnez Fichiers sur Cloud Storage (autre) et collez votre liste de fichiers dans le champ suivant.
      • Pour l'entrée BigQuery, sélectionnez Chemin d'accès dans BigQuery. Si vous sélectionnez BigQuery en tant qu'entrée, vous devez également sélectionner BigQuery en tant que sortie et Google-managed encryption key. La clé de chiffrement gérée par le client (CMEK) n'est pas compatible avec BigQuery en tant qu'entrée/sortie.

    4. Dans le champ Chemin de la destination, spécifiez le répertoire Cloud Storage dans lequel vous souhaitez que Vertex AI stocke le résultat de l'inférence par lot.

    5. Vous pouvez éventuellement cocher Activer les attributions de caractéristiques pour ce modèle pour obtenir des attributions de caractéristiques dans la réponse d'inférence par lot. Cliquez ensuite sur Modifier pour configurer les paramètres d'explication. (La modification des paramètres d'explication est facultative si vous avez précédemment configuré les paramètres d'explication pour le modèle. Elle est obligatoire dans les autres cas.)

    6. Spécifiez les options de calcul pour la tâche d'inférence par lot : Nombre de nœuds de calcul, Type de machine et (éventuellement) Type d'accélérateur et Nombre d'accélérateurs.

  3. Facultatif : L'analyse Model Monitoring pour les inférences par lot est disponible en version preview. Consultez la section Prérequis pour ajouter une configuration de détection de décalages à votre tâche d'inférence par lot.

    1. Cliquez sur Activer la surveillance du modèle pour cette prédiction par lots.

    2. Sélectionnez une source de données d'entraînement. Saisissez le chemin d'accès ou l'emplacement de la source de données d'entraînement que vous avez sélectionnée.

    3. Facultatif : sous Seuils d'alerte, spécifiez les seuils auxquels les alertes doivent être déclenchées.

    4. Dans le champ E-mails de notification, saisissez une ou plusieurs adresses e-mail séparées par une virgule afin de recevoir des alertes lorsqu'un modèle dépasse un seuil d'alerte.

    5. Facultatif : Pour Canaux de notification, ajoutez des canaux Cloud Monitoring afin de recevoir des alertes lorsqu'un modèle dépasse un seuil d'alerte. Vous pouvez sélectionner des canaux Cloud Monitoring existants ou en créer un en cliquant sur Gérer les canaux de notification. La console Google Cloud est compatible avec les canaux de notification PagerDuty, Slack et Pub/Sub.

  4. Cliquez sur Créer.

API

Envoyez des requêtes d'inférence par lot à l'aide de l'API Vertex AI. Sélectionnez l'onglet correspondant à l'outil que vous utilisez pour obtenir des inférences par lot.

REST

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • LOCATION_ID : région où le modèle est stocké et la tâche de prédiction par lots est exécutée. Par exemple : us-central1.

  • PROJECT_ID : ID de votre projet.

  • BATCH_JOB_NAME : nom à afficher du job de prédiction par lots.

  • MODEL_ID : ID du modèle à utiliser pour effectuer des prédictions.

  • INPUT_FORMAT : format des données d'entrée : jsonl, csv, tf-record, tf-record-gzip ou file-list.

  • INPUT_URI : URI Cloud Storage de vos données d'entrée. Peut contenir des caractères génériques.

  • OUTPUT_DIRECTORY : URI Cloud Storage d'un répertoire dans lequel vous souhaitez que Vertex AI enregistre la sortie.

  • MACHINE_TYPE : ressources machine à utiliser pour ce job de prédiction par lots.

    Vous pouvez éventuellement configurer le champ machineSpec pour utiliser des accélérateurs, mais l'exemple suivant n'illustre pas ce cas de figure.

  • BATCH_SIZE : nombre d'instances à envoyer dans chaque requête de prédiction. La valeur par défaut est 64. L'augmentation de la taille du lot peut entraîner un débit plus élevé, mais elle peut également provoquer l'expiration des requêtes.

  • STARTING_REPLICA_COUNT : nombre de nœuds pour ce job de prédiction par lots.

Méthode HTTP et URL : 

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs

Corps JSON de la requête : 

{
  "displayName": "BATCH_JOB_NAME",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "INPUT_FORMAT",
    "gcsSource": {
      "uris": ["INPUT_URI"],
    },
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY",
    },
  },
  "dedicatedResources" : {
    "machineSpec" : {
      "machineType": MACHINE_TYPE
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT
  },
  "manualBatchTuningParameters": {
    "batch_size": BATCH_SIZE,
  }
}

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs"

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs" | Select-Object -Expand Content

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/batchPredictionJobs/BATCH_JOB_ID",
  "displayName": "BATCH_JOB_NAME 202005291958",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "jsonl",
    "gcsSource": {
      "uris": [
        "INPUT_URI"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_DIRECTORY"
    }
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-05-30T02:58:44.341643Z",
  "updateTime": "2020-05-30T02:58:44.341643Z",
}

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Dans l'exemple suivant, remplacez PREDICTIONS_FORMAT par jsonl. Pour savoir comment remplacer les autres espaces réservés, consultez l'onglet REST & CMD LINE de cette section.

import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.AcceleratorType;
import com.google.cloud.aiplatform.v1.BatchDedicatedResources;
import com.google.cloud.aiplatform.v1.BatchPredictionJob;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.GcsSource;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.protobuf.Value;
import java.io.IOException;

public class CreateBatchPredictionJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";
    String modelName = "MODEL_NAME";
    String instancesFormat = "INSTANCES_FORMAT";
    String gcsSourceUri = "GCS_SOURCE_URI";
    String predictionsFormat = "PREDICTIONS_FORMAT";
    String gcsDestinationOutputUriPrefix = "GCS_DESTINATION_OUTPUT_URI_PREFIX";
    createBatchPredictionJobSample(
        project,
        displayName,
        modelName,
        instancesFormat,
        gcsSourceUri,
        predictionsFormat,
        gcsDestinationOutputUriPrefix);
  }

  static void createBatchPredictionJobSample(
      String project,
      String displayName,
      String model,
      String instancesFormat,
      String gcsSourceUri,
      String predictionsFormat,
      String gcsDestinationOutputUriPrefix)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient client = JobServiceClient.create(settings)) {

      // Passing in an empty Value object for model parameters
      Value modelParameters = ValueConverter.EMPTY_VALUE;

      GcsSource gcsSource = GcsSource.newBuilder().addUris(gcsSourceUri).build();
      BatchPredictionJob.InputConfig inputConfig =
          BatchPredictionJob.InputConfig.newBuilder()
              .setInstancesFormat(instancesFormat)
              .setGcsSource(gcsSource)
              .build();
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(gcsDestinationOutputUriPrefix).build();
      BatchPredictionJob.OutputConfig outputConfig =
          BatchPredictionJob.OutputConfig.newBuilder()
              .setPredictionsFormat(predictionsFormat)
              .setGcsDestination(gcsDestination)
              .build();
      MachineSpec machineSpec =
          MachineSpec.newBuilder()
              .setMachineType("n1-standard-2")
              .setAcceleratorType(AcceleratorType.NVIDIA_TESLA_T4)
              .setAcceleratorCount(1)
              .build();
      BatchDedicatedResources dedicatedResources =
          BatchDedicatedResources.newBuilder()
              .setMachineSpec(machineSpec)
              .setStartingReplicaCount(1)
              .setMaxReplicaCount(1)
              .build();
      String modelName = ModelName.of(project, location, model).toString();
      BatchPredictionJob batchPredictionJob =
          BatchPredictionJob.newBuilder()
              .setDisplayName(displayName)
              .setModel(modelName)
              .setModelParameters(modelParameters)
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .setDedicatedResources(dedicatedResources)
              .build();
      LocationName parent = LocationName.of(project, location);
      BatchPredictionJob response = client.createBatchPredictionJob(parent, batchPredictionJob);
      System.out.format("response: %s\n", response);
      System.out.format("\tName: %s\n", response.getName());
    }
  }
}

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API Python. 

def create_batch_prediction_job_dedicated_resources_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    instances_format: str = "jsonl",
    machine_type: str = "n1-standard-2",
    accelerator_count: int = 1,
    accelerator_type: Union[str, aiplatform_v1.AcceleratorType] = "NVIDIA_TESLA_K80",
    starting_replica_count: int = 1,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    my_model = aiplatform.Model(model_resource_name)

    batch_prediction_job = my_model.batch_predict(
        job_display_name=job_display_name,
        gcs_source=gcs_source,
        gcs_destination_prefix=gcs_destination,
        instances_format=instances_format,
        machine_type=machine_type,
        accelerator_count=accelerator_count,
        accelerator_type=accelerator_type,
        starting_replica_count=starting_replica_count,
        sync=sync,
    )

    batch_prediction_job.wait()

    print(batch_prediction_job.display_name)
    print(batch_prediction_job.resource_name)
    print(batch_prediction_job.state)
    return batch_prediction_job

BigQuery

L'exemple REST précédent utilise Cloud Storage pour la source et la destination. Pour utiliser BigQuery, apportez les modifications suivantes :

  • Remplacez le champ inputConfig par ce qui suit :

    "inputConfig": {
   "instancesFormat": "bigquery",
   "bigquerySource": {
      "inputUri": "bq://SOURCE_PROJECT_ID.SOURCE_DATASET_NAME.SOURCE_TABLE_NAME"
   }
}

  • Remplacez le champ outputConfig par ce qui suit :

    "outputConfig": {
   "predictionsFormat":"bigquery",
   "bigqueryDestination":{
      "outputUri": "bq://DESTINATION_PROJECT_ID.DESTINATION_DATASET_NAME.DESTINATION_TABLE_NAME"
   }
 }

  • Remplacez les éléments suivants :

    • SOURCE_PROJECT_ID : ID du projet Google Cloud source.
    • SOURCE_DATASET_NAME : nom de l'ensemble de données BigQuery source.
    • SOURCE_TABLE_NAME : nom de la table BigQuery source.
    • DESTINATION_PROJECT_ID : ID du projet Google Cloud de destination.
    • DESTINATION_DATASET_NAME : nom de l'ensemble de données BigQuery de destination.
    • DESTINATION_TABLE_NAME : nom de la table BigQuery de destination.

Importance des caractéristiques

Si vous souhaitez que les valeurs d'importance des caractéristiques soient renvoyées pour vos inférences, définissez la propriété generateExplanation sur true. Notez que les modèles de prévision ne sont pas compatibles avec l'importance des caractéristiques. Vous ne pouvez donc pas l'inclure dans vos requêtes d'inférence par lot.

L'importance des caractéristiques, parfois appelée attribution de caractéristiques, fait partie de Vertex Explainable AI.

Vous pouvez uniquement définir generateExplanation sur true si vous avez configuré votre Model pour obtenir des explications ou si vous spécifiez le champ explanationSpec de BatchPredictionJob.

Choisir le type de machine et le nombre d'instances répliquées

Le scaling horizontal en augmentant le nombre d'instances répliquées améliore le débit de manière plus linéaire et prévisible qu'avec des types de machines plus volumineux.

En règle générale, nous vous recommandons de spécifier le plus petit type de machine possible pour votre job et d'augmenter le nombre d'instances répliquées.

Pour plus de rentabilité, nous vous recommandons de choisir le nombre d'instances dupliquées afin que votre tâche d'inférence par lot s'exécute pendant au moins 10 minutes. En effet, vous êtes facturé par heure-nœud d'instance répliquée, dont environ 5 minutes pour le démarrage de chaque instance répliquée. Il n'est pas rentable de procéder pendant quelques secondes, puis d'arrêter.

En règle générale, pour des milliers d'instances, nous recommandons une valeur starting_replica_count exprimée en dizaines. Pour des millions d'instances, nous recommandons une valeur starting_replica_count exprimée en centaines. Vous pouvez également utiliser la formule suivante pour estimer le nombre d'instances répliquées :

N / (T * (60 / Tb))

Où :

  • N : nombre de lots dans le job. Par exemple, 1 million d'instances/100 lots = 10 000 lots.
  • T : durée attendue pour le job d'inférence par lot. Par exemple, 10 minutes.
  • Tb : temps en secondes nécessaire à une instance répliquée pour traiter un seul lot. Par exemple, 1 seconde par lot sur un type de machine à 2 cœurs.

Dans notre exemple, 10 000 lots/(10 minutes * (60/1 s)) arrondis à 17 instances répliquées.

Ces recommandations sont toutes des consignes approximatives. Elles n'offrent pas nécessairement un débit optimal pour chaque modèle. Elles ne fournissent pas d'estimations exactes sur le temps et le coût de traitement. De plus, elles ne capturent pas nécessairement les meilleurs compromis coût/débit pour chaque scénario. Utilisez-les comme point de départ raisonnable et ajustez-les si nécessaire. Pour mesurer les caractéristiques telles que le débit de votre modèle, exécutez le notebook Trouver le type de machine idéal.

Pour les machines accélérées par GPU ou TPU

Suivez les consignes précédentes (qui s'appliquent également aux modèles CPU uniquement), en tenant compte des considérations supplémentaires suivantes :

  • Vous aurez peut-être besoin de plus de processeurs et de GPU (par exemple, pour le prétraitement des données).
  • Le démarrage des types de machines avec GPU est plus long (10 minutes). Vous pouvez donc cibler des temps plus longs (par exemple, au moins 20 minutes au lieu de 10 minutes) pour le job d'inférence par lots afin qu'une proportion raisonnable du temps et des coûts soit allouée à la génération des inférences.

Récupérer les résultats de l'inférence par lot

Lorsqu'une tâche d'inférence par lot est terminée, le résultat de l'inférence est stocké dans le bucket Cloud Storage ou l'emplacement BigQuery que vous avez spécifié dans votre requête.

Exemple de résultat d'inférence par lot

Le dossier de sortie contient un ensemble de fichiers JSON Lines.

Les fichiers sont nommés {gcs_path}/prediction.results-{file_number}-of-{number_of_files_generated}. Le nombre de fichiers est non déterministe, en raison de la nature distribuée de l'inférence par lot.

Chaque ligne du fichier correspond à une instance de l'entrée et possède les paires clé/valeur suivantes :

  • prediction : contient la valeur renvoyée par le conteneur.
  • instance : pour une liste de fichiers, contient l'URI Cloud Storage. Pour tous les autres formats d'entrée, elle contient la valeur envoyée au conteneur dans le corps de la requête HTTP.

Exemple 1

Si la requête HTTP contient les éléments suivants :

{
  "instances": [
    [1, 2, 3, 4],
    [5, 6, 7, 8]
]}

Et que le conteneur renvoie ce qui suit :

{
  "predictions": [
    [0.1,0.9],
    [0.7,0.3]
  ],
}

Le fichier de sortie JSON Lines se présente alors comme suit :

{ "instance": [1, 2, 3, 4], "prediction": [0.1,0.9]}
{ "instance": [5, 6, 7, 8], "prediction": [0.7,0.3]}

Exemple 2

Si la requête HTTP contient les éléments suivants :

{
  "instances": [
    {"values": [1, 2, 3, 4], "key": 1},
    {"values": [5, 6, 7, 8], "key": 2}
]}

Et que le conteneur renvoie ce qui suit :

{
  "predictions": [
    {"result":1},
    {"result":0}
  ],
}

Le fichier de sortie JSON Lines se présente alors comme suit :

{ "instance": {"values": [1, 2, 3, 4], "key": 1}, "prediction": {"result":1}}
{ "instance": {"values": [5, 6, 7, 8], "key": 2}, "prediction": {"result":0}}

Point de terminaison visible par l'utilisateur

Pour améliorer l'observabilité et réduire le nombre de quotas à gérer, le serveur de modèles est disponible en tant que point de terminaison Vertex AI destiné aux utilisateurs. Si vous configurez l'une des fonctionnalités suivantes, le modèle sera déployé sur un point de terminaison destiné aux utilisateurs :

  • Réservations partagées
  • VM Spot
  • VM à démarrage flexible

Utiliser Explainable AI

Nous vous déconseillons d'exécuter des explications basées sur les caractéristiques sur une grande quantité de données. En effet, chaque entrée peut potentiellement être ramifiée vers des milliers de requêtes en fonction de l'ensemble des valeurs de caractéristiques possibles, ce qui peut entraîner une augmentation considérable du temps de traitement et des coûts. En général, un petit ensemble de données est suffisant pour comprendre l'importance des caractéristiques.

L'inférence par lot n'est pas compatible avec les explications basées sur des exemples.

Notebooks

Étapes suivantes