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

Cette page vous explique comment obtenir des prédictions 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 de prédiction par lot, vous devez spécifier une source d'entrée et un emplacement de sortie, Cloud Storage ou BigQuery, où Vertex AI stocke les résultats des prédictions.

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

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 la prédiction. 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 prédictions. Stockez le fichier JSON Lines 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 de prédiction 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 de prédiction 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 de prédiction 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 de prédiction 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 de prédiction 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 ("). Nous n'acceptons pas les valeurs de cellule incluant un caractère de nouvelle ligne. Les valeurs sans guillemets sont lues sous forme de 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 de prédiction 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 prédictions par lot, collez votre liste de fichiers directement dans la console Google Cloud. Sinon, enregistrez votre liste de fichiers 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 de prédiction 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 de prédiction 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 de prédiction 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
String String "abc"
Integer Integer 1
Nombre à virgule flottante Nombre à virgule flottante 1.2
Numeric Nombre à virgule flottante 4925.000000000
Booléen Booléen true
TimeStamp String "2019-01-01 23:59:59.999999+00:00"
Date String "2018-12-31"
Temps String "23:59:59.999999"
DateTime String "2019-01-01T00:00:00"
Enregistrer Objet { "A": 1,"B": 2}
Type répété Array[Type] [1, 2]
Enregistrement imbriqué Objet {"A": {"a": 0}, "B": 1}

Partitionner les données

La prédiction 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 compatibles avec le partitionnement naturellement. Les lignes des fichiers CSV ne sont pas autodescriptives, ne sont pas saisies 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 à la tâche 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 dupliquées spécifié.

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

Vous pouvez filtrer et/ou transformer votre entrée par lot 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 de prédiction ou de n'inclure qu'un sous-ensemble de champs à partir des données d'entrée de votre requête de prédiction, sans avoir à effectuer de prétraitement/post-traitement personnalisé dans le conteneur de prédiction. 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 de prédiction au format JSON array ou object. Pour en savoir plus, consultez 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 de prédiction 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 du résultat 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 Prédiction par lot de modèles personnalisés avec filtrage des caractéristiques.

Demander une prédiction par lots

Pour les requêtes de prédiction 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 de prédiction par lot peut prendre un certain temps.

Lorsque vous demandez une prédiction par lot, le conteneur de prédiction 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 de prédiction à partir de la source de données ou l'écriture des résultats de la prédiction, 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 prédiction par lot.

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

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

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

  2. Pour Définir votre prédiction par lot, procédez comme suit :

    1. Saisissez un nom pour la prédiction par lot.

    2. Dans Nom du modèle, sélectionnez le nom du modèle à utiliser pour cette prédiction par lot.

    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 zip). 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 la zone de texte suivante.
      • 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 clé de chiffrement gérée par Google. 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 la prédiction par lot.

    5. Vous pouvez éventuellement cocher Activer les attributions de caractéristiques pour ce modèle afin d'obtenir des attributions de caractéristiques dans le cadre de la réponse de prédiction 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 de prédiction 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 prédictions 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 de prédiction par lot.

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

    2. Sélectionnez une source de données d'entraînement. Saisissez le chemin d'accès ou l'emplacement des données pour 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 afin de recevoir des alertes lorsqu'un modèle dépasse un seuil d'alerte.

    5. Facultatif : Pour les 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 est compatible avec les canaux de notification PagerDuty, Slack et Pub/Sub.

  4. Cliquez sur Créer.

API

Envoyez des requêtes de prédiction par lot à l'aide de l'API Vertex AI. Sélectionnez l'onglet correspondant à l'outil que vous utilisez pour obtenir des prédictions par lot :

REST

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

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

  • PROJECT_ID : l'ID de votre projet.

  • BATCH_JOB_NAME : nom à afficher de la tâche de prédiction par lot.

  • 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 de machine à utiliser pour cette tâche de prédiction par lot.

    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 cette tâche de prédiction par lot.

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_K80)
              .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 pour Python, consultez la page 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,
    max_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,
        max_replica_count=max_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

Importance des caractéristiques

Si vous souhaitez que les valeurs d'importance des caractéristiques soient renvoyées pour vos prédictions, 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 de prédiction 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 Si vous spécifiez le champ explanationSpec de BatchPredictionJob.

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

Le scaling horizontal en augmentant le nombre d'instances dupliqué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 tâche et d'augmenter le nombre d'instances dupliquées.

Pour plus de rentabilité, nous vous recommandons de choisir le nombre d'instances dupliquées afin que votre tâche de prédiction par lot s'exécute pendant au moins 10 minutes. En effet, vous êtes facturé par nœud-heure d'instance dupliquée, dont environ 5 minutes pour le démarrage de chaque instance dupliqué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 parmi les centaines. Vous pouvez également utiliser la plate-forme suivante pour estimer le nombre d'instances répliquées :

N / (T * (60 / Tb))

Où :

  • N : nombre de lots dans la tâche. Par exemple, 1 million d'instances / 100 lots = 10 000 lots.
  • T : heure souhaitée pour la tâche de prédiction par lot. Par exemple, 10 minutes.
  • Tb : temps en secondes nécessaire au traitement d'une instance dupliquée par 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 dupliquées.

Contrairement aux prédictions en ligne, les tâches de prédiction 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 dupliquée au démarrage de la tâche. Le système utilise le paramètre starting_replica_count. Le paramètre max_replica_count est ignoré.

Ces recommandations sont toutes des consignes approximatives. Il n'est pas certain qu'elles offrent un débit optimal pour chaque modèle. Elles ne fournissent pas de prédictions exactes sur le temps et le coût de traitement. De plus, elles ne capturent pas nécessairement les meilleurs compromis en termes de coût et de 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 pour les modèles sur processeur 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).
  • Les types de machines GPU prennent plus de temps pour démarrer (10 minutes). Vous pouvez donc cibler des temps plus longs (par exemple, au moins 20 minutes au lieu de 10 minutes) pour la tâche de prédiction par lot afin qu'une proportion raisonnable du temps et des coûts soit allouée à la génération des prédictions.

Récupérer des résultats de prédiction par lot

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

Exemple de résultat de prédiction 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 la prédiction 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 de prédiction.
  • instance : pour FileList, contient l'URI Cloud Storage. Pour tous les autres formats d'entrée, elle contient la valeur envoyée au conteneur de prédiction 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 de prédiction renvoie ce qui suit :

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

Alors le fichier de sortie jsonl se présente ainsi :

{ "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 de prédiction renvoie ce qui suit :

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

Alors le fichier de sortie jsonl se présente ainsi :

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

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.

La prédiction par lot n'est pas compatible avec les explications basées sur des exemples.

Étapes suivantes