Obtenir des inférences par lot pour un modèle de prévision

Vertex AI fournit deux options pour projeter les valeurs futures à l'aide de votre modèle de prévision entraîné : les inférences en ligne et les inférences par lot.

Une inférence en ligne est une requête synchrone. Utilisez les inférences en ligne lorsque vous effectuez des requêtes en réponse à une entrée d'une application ou dans d'autres situations nécessitant une inférence rapide.

Une requête d'inférence par lot est une requête asynchrone. Utilisez l'inférence par lot lorsque vous n'avez pas besoin d'une réponse immédiate et souhaitez traiter les données accumulées en une seule requête.

Cette page explique comment projeter des valeurs futures à l'aide d'inférences par lots. Pour apprendre à projeter des valeurs à l'aide d'inférences en ligne, consultez Obtenir des inférences en ligne pour un modèle de prévision.

Vous pouvez demander des inférences par lot directement à partir de la ressource de modèle.

Vous pouvez demander une inférence avec des explications (également appelées attributions de caractéristiques) pour voir comment votre modèle est arrivé à une inférence. Les valeurs d'importance des caractéristiques locales indiquent dans quelle mesure chaque caractéristique a contribué au résultat de l'inférence. Pour obtenir une présentation des concepts, consultez Attributions de caractéristiques pour la prévision.

Pour en savoir plus sur les tarifs des inférences par lots, consultez Tarifs des workflows tabulaires.

Avant de commencer

Avant d'envoyer une requête d'inférence par lot, entraînez d'abord un modèle.

Données d'entrée

Les données d'entrée des requêtes d'inférence par lot sont les données que le modèle utilise pour créer des prévisions. Vous pouvez fournir des données d'entrée dans l'un des deux formats suivants :

  • Objets CSV dans Cloud Storage
  • Tables BigQuery

Nous vous recommandons d'utiliser le même format pour les données d'entrée et les données d'entraînement du modèle. Par exemple, si vous avez entraîné votre modèle à l'aide de données dans BigQuery, il est préférable d'utiliser une table BigQuery comme entrée pour l'inférence par lots. Comme Vertex AI traite tous les champs d'entrée CSV comme des chaînes, ne pas utiliser le même format pour les données d'entrée et celles d'entraînement peut entraîner des erreurs.

Votre source de données doit contenir des données tabulaires incluant toutes les colonnes qui ont été utilisées pour entraîner le modèle, dans n'importe quel ordre. Vous pouvez inclure des colonnes qui ne figuraient pas dans les données d'entraînement, ou qui y figuraient, mais qui ont été exclues de l'entraînement. Ces colonnes supplémentaires sont incluses dans le résultat, mais n'affectent pas les résultats de la prévision.

Exigences concernant les données d'entrée

Les entrées des modèles de prévision doivent respecter les exigences suivantes :

  • Toutes les valeurs de la colonne Heure doivent être présentes et valides.
  • Toutes les colonnes utilisées dans votre requête d'inférence doivent être présentes dans les données d'entrée. Lorsque des colonnes sont vides ou n'existent pas, Vertex AI complète automatiquement les données.
  • La fréquence des données d'entrée et d'entraînement doit correspondre. S'il manque des lignes dans la série temporelle, vous devez les insérer manuellement en fonction des connaissances du domaine.
  • Les séries temporelles avec des codes temporels en double sont supprimées des inférences. Pour les inclure, supprimez les codes temporels en double.
  • Fournissez des données historiques pour chaque série temporelle à prédire. Pour les prévisions les plus précises, la quantité de données doit être égale à la fenêtre de contexte, définie lors de l'entraînement du modèle. Par exemple, si la fenêtre de contexte est de 14 jours, indiquez au moins 14 jours de données historiques. Si vous fournissez moins de données, Vertex AI remplit les données avec des valeurs vides.
  • La prévision commence à la première ligne d'une série temporelle (classée par heure) et comporte une valeur nulle dans la colonne cible. La valeur nulle doit être continue au sein de la série temporelle. Par exemple, si la colonne cible est classée par heure, vous ne pouvez pas avoir une valeur telle que 1, 2, null, 3, 4, null et null pour une seule série temporelle. Pour les fichiers CSV, Vertex AI traite une chaîne vide comme une valeur nulle et, pour BigQuery, les valeurs nulles sont compatibles de manière native.

Table BigQuery

Si vous choisissez une table BigQuery comme entrée, vous devez remplir les conditions suivantes :

  • Les tables de source de données BigQuery ne doivent pas dépasser 100 Go.
  • Si la table se trouve dans un autre projet, vous devez accorder le rôle BigQuery Data Editor au compte de service Vertex AI dans ce projet.

Fichier CSV

Si vous choisissez un objet CSV dans Cloud Storage comme entrée, vous devez remplir les conditions suivantes :

  • La source de données doit commencer par une ligne d'en-tête avec les noms de colonne.
  • Chaque objet de source de données ne doit pas dépasser 10 Go. Vous pouvez inclure plusieurs fichiers, jusqu'à une taille maximale de 100 Go.
  • Si le bucket Cloud Storage se trouve dans un autre projet, vous devez attribuer le rôle Storage Object Creator au compte de service Vertex AI dans ce projet.
  • Vous devez placer toutes les chaînes entre guillemets doubles (").

Format de sortie

Le format de sortie de votre requête d'inférence par lot n'a pas besoin d'être identique au format d'entrée. Par exemple, si vous utilisez une table BigQuery comme entrée, vous pouvez générer les résultats de la prévision dans un objet CSV dans Cloud Storage.

Envoyer une requête d'inférence par lot à votre modèle

Pour envoyer des requêtes d'inférence par lots, vous pouvez utiliser la console Google Cloud ou l'API Vertex AI. La source de données d'entrée peut être des objets CSV stockés dans un bucket Cloud Storage ou des tables BigQuery. Selon la quantité de données que vous envoyez en tant qu'entrée, une tâche d'inférence par lot peut prendre un certain temps.

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 Inférences par lot.

    Accéder à la page "Inférences par lot"

  2. Cliquez sur Créer pour ouvrir la fenêtre Nouvelle inférence par lot.
  3. Dans Définir votre inférence 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 lot.
    3. Pour Version, sélectionnez la version du modèle.
    4. Dans Sélectionner une source, indiquez si vos données d'entrée source sont un fichier CSV sur Cloud Storage ou une table dans BigQuery.
      • Pour les fichiers CSV, spécifiez l'emplacement Cloud Storage où se trouve votre fichier d'entrée CSV.
      • Pour les tables BigQuery, spécifiez l'ID du projet dans lequel se trouve la table, l'ID de l'ensemble de données BigQuery et l'ID de la table ou de la vue BigQuery.
    5. Dans Résultat de l'inférence par lots, sélectionnez CSV ou BigQuery.
      • Pour le format CSV, spécifiez le bucket Cloud Storage dans lequel Vertex AI stocke votre sortie.
      • Pour BigQuery, vous pouvez spécifier un ID de projet ou un ensemble de données existant :
        • Pour spécifier l'ID du projet, saisissez-le dans le champ ID de projet Google Cloud. Vertex AI crée automatiquement un ensemble de données de sortie.
        • Pour spécifier un ensemble de données existant, saisissez son chemin BigQuery dans le champ ID de projet Google Cloud, tel que bq://projectid.datasetid.
      • Facultatif. Si votre destination de sortie est BigQuery ou JSONL dans Cloud Storage, vous pouvez activer les attributions de caractéristiques en plus des inférences. Pour ce faire, sélectionnez Activer les attributions de caractéristiques pour ce modèle. Les attributions de caractéristiques ne sont pas compatibles avec le format CSV dans Cloud Storage. En savoir plus
  4. 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 inférence par lot.
    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 : dans 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.
  5. Cliquez sur Créer.

API : BigQuery

REST

Utilisez la méthode batchPredictionJobs.create pour demander une inférence par lot.

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 la tâche d'inférence par lot est exécutée. Par exemple : us-central1.
  • PROJECT_ID : ID de votre projet.
  • BATCH_JOB_NAME : nom à afficher du job par lot.
  • MODEL_ID : ID du modèle à utiliser pour effectuer des inférences.
  • INPUT_URI : référence à la source de données BigQuery, au format : 
    bq://bqprojectId.bqDatasetId.bqTableId
  • OUTPUT_URI : référence à la destination BigQuery (où les inférences sont écrites). Spécifiez l'ID du projet et, éventuellement, un ID d'ensemble de données existant. Utilisez le format suivant : 
    bq://bqprojectId.bqDatasetId
    Si vous ne spécifiez que l'ID du projet, Vertex AI crée un ensemble de données de sortie à votre place. Utilisez le format suivant : 
    bq://bqprojectId
  • GENERATE_EXPLANATION : la valeur par défaut est false. Définissez la valeur sur true pour activer les attributions de caractéristiques. Pour en savoir plus, consultez Attributions de caractéristiques pour la prévision.

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": "bigquery",
    "bigquerySource": {
      "inputUri": "INPUT_URI"
    }
  },
  "outputConfig": {
    "predictionsFormat": "bigquery",
    "bigqueryDestination": {
      "outputUri": "OUTPUT_URI"
    }
  },
  "generate_explanation": GENERATE_EXPLANATION
}

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_ID/locations/LOCATION_ID/batchPredictionJobs/67890",
  "displayName": "batch_job_1 202005291958",
  "model": "projects/12345/locations/us-central1/models/5678",
  "state": "JOB_STATE_PENDING",
  "inputConfig": {
    "instancesFormat": "bigquery",
    "bigquerySource": {
      "inputUri": "INPUT_URI"
    }
  },
  "outputConfig": {
    "predictionsFormat": "bigquery",
    "bigqueryDestination": {
        "outputUri": bq://12345
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "n1-standard-32",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": 2,
    "maxReplicaCount": 6
  },
  "manualBatchTuningParameters": {
    "batchSize": 4
  },
  "outputInfo": {
    "bigqueryOutputDataset": "bq://12345.reg_model_2020_10_02_06_04
  }
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-09-30T02:58:44.341643Z",
  "updateTime": "2020-09-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 INSTANCES_FORMAT et PREDICTIONS_FORMAT par "bigquery". Pour savoir comment remplacer les autres espaces réservés, consultez l'onglet "REST et ligne de commande" de cette section. 
import com.google.cloud.aiplatform.v1.BatchPredictionJob;
import com.google.cloud.aiplatform.v1.BigQueryDestination;
import com.google.cloud.aiplatform.v1.BigQuerySource;
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.ModelName;
import com.google.gson.JsonObject;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;

public class CreateBatchPredictionJobBigquerySample {

  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 bigquerySourceInputUri = "BIGQUERY_SOURCE_INPUT_URI";
    String predictionsFormat = "PREDICTIONS_FORMAT";
    String bigqueryDestinationOutputUri = "BIGQUERY_DESTINATION_OUTPUT_URI";
    createBatchPredictionJobBigquerySample(
        project,
        displayName,
        modelName,
        instancesFormat,
        bigquerySourceInputUri,
        predictionsFormat,
        bigqueryDestinationOutputUri);
  }

  static void createBatchPredictionJobBigquerySample(
      String project,
      String displayName,
      String model,
      String instancesFormat,
      String bigquerySourceInputUri,
      String predictionsFormat,
      String bigqueryDestinationOutputUri)
      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)) {
      JsonObject jsonModelParameters = new JsonObject();
      Value.Builder modelParametersBuilder = Value.newBuilder();
      JsonFormat.parser().merge(jsonModelParameters.toString(), modelParametersBuilder);
      Value modelParameters = modelParametersBuilder.build();
      BigQuerySource bigquerySource =
          BigQuerySource.newBuilder().setInputUri(bigquerySourceInputUri).build();
      BatchPredictionJob.InputConfig inputConfig =
          BatchPredictionJob.InputConfig.newBuilder()
              .setInstancesFormat(instancesFormat)
              .setBigquerySource(bigquerySource)
              .build();
      BigQueryDestination bigqueryDestination =
          BigQueryDestination.newBuilder().setOutputUri(bigqueryDestinationOutputUri).build();
      BatchPredictionJob.OutputConfig outputConfig =
          BatchPredictionJob.OutputConfig.newBuilder()
              .setPredictionsFormat(predictionsFormat)
              .setBigqueryDestination(bigqueryDestination)
              .build();
      String modelName = ModelName.of(project, location, model).toString();
      BatchPredictionJob batchPredictionJob =
          BatchPredictionJob.newBuilder()
              .setDisplayName(displayName)
              .setModel(modelName)
              .setModelParameters(modelParameters)
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .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_bigquery_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    bigquery_source: str,
    bigquery_destination_prefix: str,
    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,
        bigquery_source=bigquery_source,
        bigquery_destination_prefix=bigquery_destination_prefix,
        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

API : Cloud Storage

REST

Utilisez la méthode batchPredictionJobs.create pour demander une inférence par lot.

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 la tâche d'inférence par lot est exécutée. Par exemple : us-central1.
  • PROJECT_ID :
  • BATCH_JOB_NAME : nom à afficher du job par lot.
  • MODEL_ID : ID du modèle à utiliser pour effectuer des inférences.
  • URI : chemins (URI) vers les buckets Cloud Storage contenant les données d'entraînement. Il peut y en avoir plusieurs. Chaque URI se présente sous la forme suivante : 
    gs://bucketName/pathToFileName
  • OUTPUT_URI_PREFIX : chemin d'accès à une destination Cloud Storage où les inférences seront écrites. Vertex AI écrit les inférences par lot dans un sous-répertoire horodaté de ce chemin. Définissez cette valeur sur une chaîne au format suivant : 
    gs://bucketName/pathToOutputDirectory
  • GENERATE_EXPLANATION : la valeur par défaut est false. Définissez la valeur sur true pour activer les attributions de caractéristiques. Cette option n'est disponible que si votre destination de sortie est JSONL. Les attributions de caractéristiques ne sont pas compatibles avec le format CSV dans Cloud Storage. Pour en savoir plus, consultez Attributions de caractéristiques pour la prévision.

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": "csv",
    "gcsSource": {
      "uris": [
        URI1,...
      ]
    },
  },
  "outputConfig": {
    "predictionsFormat": "csv",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_URI_PREFIX"
    }
  },
  "generate_explanation": GENERATE_EXPLANATION
}

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_ID/locations/LOCATION_ID/batchPredictionJobs/67890",
  "displayName": "batch_job_1 202005291958",
  "model": "projects/12345/locations/us-central1/models/5678",
  "state": "JOB_STATE_PENDING",
  "inputConfig": {
    "instancesFormat": "csv",
    "gcsSource": {
      "uris": [
        "gs://bp_bucket/reg_mode_test"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "csv",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_URI_PREFIX"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "n1-standard-32",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": 2,
    "maxReplicaCount": 6
  }
  "outputInfo": {
    "gcsOutputDataset": "OUTPUT_URI_PREFIX/prediction-batch_job_1 202005291958-2020-09-30T02:58:44.341643Z"
  }
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-09-30T02:58:44.341643Z",
  "updateTime": "2020-09-30T02:58:44.341643Z",
}

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_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    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,
        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

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

Vertex AI envoie la sortie des inférences par lot à la destination spécifiée, qui peut être BigQuery ou Cloud Storage.

La sortie Cloud Storage pour les attributions de caractéristiques n'est pas disponible.

BigQuery

Ensemble de données de sortie

Si vous utilisez BigQuery, le résultat de l'inférence par lots est stocké dans un ensemble de données de sortie. Si vous avez fourni un ensemble de données à Vertex AI, le nom de l'ensemble de données (BQ_DATASET_NAME) est le nom que vous avez fourni précédemment. Si vous n'avez pas spécifié d'ensemble de données de sortie, Vertex AI en a créé un pour vous. Vous pouvez trouver son nom (BQ_DATASET_NAME) en procédant comme suit :

  1. Dans la console Google Cloud , accédez à la page Inférences par lot de Vertex AI.

    Accéder à la page "Inférences par lot"

  2. Sélectionnez l'inférence que vous avez créée.
  3. L'ensemble de données de sortie est indiqué dans Emplacement d'exportation. Le nom de l'ensemble de données est au format suivant : prediction_MODEL_NAME_TIMESTAMP

Tables de sortie

L'ensemble de données de sortie contient une ou plusieurs des trois tables de sortie suivantes :

  • Table d'inférence

    Cette table contient une ligne pour chaque ligne de vos données d'entrée où une inférence a été demandée (c'est-à-dire une ligne avec TARGET_COLUMN_NAME = null). Par exemple, si votre entrée comprend 14 entrées NULL pour la colonne cible (telles que les ventes pour les 14 jours suivants), votre requête d'inférence renvoie 14 lignes, le nombre de ventes de chaque jour. Si votre requête d'inférence dépasse l'horizon de prévision du modèle, Vertex AI ne renvoie que les inférences jusqu'à l'horizon de prévision.

  • Table de validation des erreurs

    Cette table contient une ligne pour chaque erreur non critique rencontrée pendant la phase d'agrégation qui a lieu avant l'inférence par lot. Chaque erreur non critique correspond à une ligne des données d'entrée pour laquelle Vertex AI n'a pas pu renvoyer de prévision.

  • Table des erreurs

    Cette table contient une ligne pour chaque erreur non critique rencontrée lors de l'inférence par lots. Chaque erreur non critique correspond à une ligne des données d'entrée pour laquelle Vertex AI n'a pas pu renvoyer de prévision.

Table des prédictions

Le nom de la table (BQ_PREDICTIONS_TABLE_NAME) est constitué en ajoutant "predictions_" avec l'horodatage du début du job d'inférence par lot : predictions_TIMESTAMP

Pour récupérer la table des inférences :

  1. Dans la console, accédez à la page BigQuery.
    Accéder à BigQuery
  2. Exécutez la requête suivante : 
    SELECT * FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME

Vertex AI stocke les inférences dans la colonne predicted_TARGET_COLUMN_NAME.value.

Si vous avez entraîné un modèle à l'aide du transformateur de fusion temporelle (TFT), vous trouverez le résultat d'interprétabilité TFT dans la colonne predicted_TARGET_COLUMN_NAME.tft_feature_importance.

Cette colonne est divisée en deux parties :

  • context_columns : caractéristiques de prévision dont les valeurs de fenêtre de contexte servent d'entrées dans l'encodeur TFT de type LSTM (Long Short-Term Memory).
  • context_weights : pondérations de l'importance des caractéristiques associées à chacune des context_columns pour l'instance prédite.
  • horizon_columns : caractéristiques de prévision dont les valeurs de l'horizon de prévision sont utilisées comme entrées pour le décodeur TFT de type LSTM (Long Short-Term Memory).
  • horizon_weights : pondérations de l'importance des caractéristiques associées à chacune des horizon_columns pour l'instance prédite.
  • attribute_columns : caractéristiques de prévision invariantes dans le temps.
  • attribute_weights : pondérations associées à chacune des attribute_columns.

Si votre modèle est optimisé pour la perte de quantiles et que votre ensemble de quantiles inclut la médiane, predicted_TARGET_COLUMN_NAME.value est la valeur d'inférence à la médiane. Sinon, predicted_TARGET_COLUMN_NAME.value est la valeur d'inférence au quantile le plus bas de l'ensemble. Par exemple, si votre ensemble de quantiles est [0.1, 0.5, 0.9], value correspond à l'inférence pour le quantile 0.5. Si votre ensemble de quantiles est [0.1, 0.9], value correspond à l'inférence pour le quantile 0.1.

De plus, Vertex AI stocke les valeurs et les inférences de quantiles dans les colonnes suivantes :

  • predicted_TARGET_COLUMN_NAME.quantile_values : valeurs des quantiles, qui sont définies lors de l'entraînement du modèle. Exemples : 0.1, 0.5 et 0.9.
  • predicted_TARGET_COLUMN_NAME.quantile_predictions : valeurs d'inférence associées aux valeurs quantiles.

Si votre modèle utilise une inférence probabiliste, predicted_TARGET_COLUMN_NAME.value contient la minimisation de l'objectif d'optimisation. Par exemple, si votre objectif d'optimisation est minimize-rmse, predicted_TARGET_COLUMN_NAME.value contient la valeur moyenne. Si la valeur est minimize-mae, predicted_TARGET_COLUMN_NAME.value contient la valeur médiane.

Si votre modèle utilise une inférence probabiliste avec des quantiles, Vertex AI stocke les valeurs et les inférences de quantiles dans les colonnes suivantes :

  • predicted_TARGET_COLUMN_NAME.quantile_values : valeurs des quantiles, qui sont définies lors de l'entraînement du modèle. Exemples : 0.1, 0.5 et 0.9.
  • predicted_TARGET_COLUMN_NAME.quantile_predictions : valeurs d'inférence associées aux valeurs de quantiles.

Si vous avez activé les attributions de caractéristiques, vous pouvez également les trouver dans le tableau des inférences. Pour accéder aux attributions d'une caractéristique BQ_FEATURE_NAME, exécutez la requête suivante :

SELECT explanation.attributions[OFFSET(0)].featureAttributions.BQ_FEATURE_NAME FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME

Pour en savoir plus, consultez Attributions de caractéristiques pour la prévision.

Table de validation des erreurs

La table (BQ_ERRORS_VALIDATION_TABLE_NAME) est nommée "errors_validation", suivi du code temporel du début du job d'inférence par lot : errors_validation_TIMESTAMP.

Pour récupérer la table de validation des erreurs, procédez comme suit :
  1. Dans la console, accédez à la page BigQuery.
    Accéder à BigQuery
  2. Exécutez la requête suivante : 
    SELECT * FROM BQ_DATASET_NAME.BQ_ERRORS_VALIDATION_TABLE_NAME
Le message d'erreur est stocké dans la colonne suivante :
  • errors_TARGET_COLUMN_NAME

Table des erreurs

Le nom de la table (BQ_ERRORS_TABLE_NAME) est constitué en ajoutant "errors_" avec l'horodatage du début du job d'inférence par lot : errors_TIMESTAMP

Pour récupérer la table de validation des erreurs, procédez comme suit :
  1. Dans la console, accédez à la page BigQuery.
    Accéder à BigQuery
  2. Exécutez la requête suivante : 
    SELECT * FROM BQ_DATASET_NAME.BQ_ERRORS_TABLE_NAME
Les erreurs sont stockées dans les colonnes suivantes :
  • errors_TARGET_COLUMN_NAME.code
  • errors_TARGET_COLUMN_NAME.message

Cloud Storage

Si vous avez spécifié Cloud Storage comme destination de sortie, les résultats de votre requête d'inférence par lot sont renvoyés sous forme d'objets CSV dans un nouveau dossier du bucket spécifié. Le nom du dossier est celui de votre modèle, précédé de "prédiction-" et suivi de l'horodatage du début de la tâche d'inférence par lot. Vous trouverez le nom du dossier Cloud Storage dans l'onglet Prédictions par lots de votre modèle.

Le dossier Cloud Storage contient deux types d'objets :
  • Objets d'inférence

    Les objets d'inférence sont nommés "predictions_1.csv", "predictions_2.csv", etc. Ils contiennent une ligne d'en-tête avec les noms de colonne et une ligne pour chaque prévision renvoyée. Le nombre de valeurs d'inférence dépend de vos données d'entrée et de l'horizon de prévision. Par exemple, si votre entrée comprend 14 entrées NULL pour la colonne cible (telles que les ventes pour les 14 jours suivants), votre requête d'inférence renvoie 14 lignes, le nombre de ventes de chaque jour. Si votre requête d'inférence dépasse l'horizon de prévision du modèle, Vertex AI ne renvoie que les inférences jusqu'à l'horizon de prévision.

    Les valeurs prévues sont renvoyées dans une colonne nommée "predicted_TARGET_COLUMN_NAME". Pour les prévisions de quantiles, la colonne de sortie contient les inférences et les valeurs de quantiles au format JSON.

  • Objets d'erreur

    Les objets d'erreur sont nommés "errors_1.csv", "errors_2.csv", etc. Ils contiennent une ligne d'en-tête et une ligne pour chaque ligne de vos données d'entrée pour laquelle Vertex AI n'a pas pu renvoyer de prévision (par exemple, une caractéristique ne pouvant avoir une valeur nulle contient une valeur nulle).

Remarque : Si les résultats comportent une grande quantité de données, ils sont divisés en plusieurs objets.

Exemples de requêtes d'attribution de caractéristiques dans BigQuery

Exemple 1 : Déterminer les attributions pour une seule inférence

Prenons la question suivante :

Dans quelle proportion une publicité pour un produit a augmenté les ventes prévues le 24 novembre dans un magasin donné ?

La requête correspondante est la suivante :

SELECT
  * EXCEPT(explanation, predicted_sales),
  ROUND(predicted_sales.value, 2) AS predicted_sales,
  ROUND(
    explanation.attributions[OFFSET(0)].featureAttributions.advertisement,
    2
  ) AS attribution_advertisement
FROM
  `project.dataset.predictions`
WHERE
  product = 'product_0'
  AND store = 'store_0'
  AND date = '2019-11-24'

Exemple 2 : Déterminer l'importance des caractéristiques globales

Prenons la question suivante :

Dans quelle mesure chaque caractéristique a-t-elle contribué à la prédiction des ventes ?

Vous pouvez calculer manuellement l'importance globale des caractéristiques en agrégeant les attributions d'importance des caractéristiques locales. La requête correspondante est la suivante :

WITH

/*
* Aggregate from (id, date) level attributions to global feature importance.
*/
attributions_aggregated AS (
 SELECT
   SUM(ABS(attributions.featureAttributions.date)) AS date,
   SUM(ABS(attributions.featureAttributions.advertisement)) AS advertisement,
   SUM(ABS(attributions.featureAttributions.holiday)) AS holiday,
   SUM(ABS(attributions.featureAttributions.sales)) AS sales,
   SUM(ABS(attributions.featureAttributions.store)) AS store,
   SUM(ABS(attributions.featureAttributions.product)) AS product,
 FROM
   project.dataset.predictions,
   UNNEST(explanation.attributions) AS attributions

),

/*
* Calculate the normalization constant for global feature importance.
*/
attributions_aggregated_with_total AS (
 SELECT
   *,
   date + advertisement + holiday + sales + store + product AS total
 FROM
   attributions_aggregated
)

/*
* Calculate the normalized global feature importance.
*/
SELECT
 ROUND(date / total, 2) AS date,
 ROUND(advertisement / total, 2) AS advertisement,
 ROUND(holiday / total, 2) AS holiday,
 ROUND(sales / total, 2) AS sales,
 ROUND(store / total, 2) AS store,
 ROUND(product / total, 2) AS product,
FROM
 attributions_aggregated_with_total

Exemple de résultat d'une inférence par lots dans BigQuery

Dans l'exemple d'ensemble de données des ventes de boissons alcoolisées, il existe quatre magasins dans la ville de "Ida Grove" : "Ida Grove Food Pride", "Discount Liquors of Ida Grove", "Casey's General Store #3757" et "Brew Ida Grove". store_name est le series identifier, et trois des quatre magasins demandent des inférences pour la colonne cible sale_dollars. Une erreur de validation est générée, car aucune prévision n'a été demandée pour "Discount Liquors of Ida Grove".

Voici un extrait de l'ensemble de données d'entrée utilisé pour l'inférence :

Exemple d'ensemble de données d'entrée pour la prédiction de prévisions

Voici un extrait des résultats de l'inférence :

Exemples de résultats de prévision

Voici un extrait des erreurs de validation :

Exemples d'erreurs de validation

Exemple de résultat d'une inférence par lot pour un modèle optimisé pour la perte de quantiles

L'exemple suivant est une sortie d'inférence par lot pour un modèle optimisé pour la perte de quantiles. Dans ce scénario, le modèle de prévision prédit les ventes des 14 prochains jours pour chaque magasin.

Exemple de résultat d'inférence par lot pour un modèle optimisé pour la perte de quantiles

Les valeurs de quantile sont indiquées dans la colonne predicted_Sales.quantile_values. Dans cet exemple, le modèle a prédit des valeurs pour les quantiles 0.1, 0.5 et 0.9.

Les valeurs d'inférence sont indiquées dans la colonne predicted_Sales.quantile_predictions. Il s'agit d'un tableau de valeurs de vente, qui correspondent aux valeurs de quantile présentes dans la colonne predicted_Sales.quantile_values. Sur la première ligne, nous constatons que la probabilité que la valeur des ventes soit inférieure à 4484.04 est de 10 %. La probabilité que la valeur des ventes soit inférieure à 5615.64 est de 50 %. La probabilité que la valeur des ventes soit inférieure à 6853.29 est de 90 %. L'inférence pour la première ligne, représentée sous la forme d'une valeur unique, est 5615.64.

Étapes suivantes