Obtenir des prédictions par lot TabNet

Cette page explique comment envoyer une requête de prédiction par lot au modèle de classification ou de régression entraîné à l'aide de la console Google Cloud ou de l'API Vertex AI.

Une requête de prédiction par lot est une requête asynchrone (par opposition à la prédiction en ligne, qui est une requête synchrone). Vous demandez des prédictions par lot directement à partir de la ressource de modèle sans avoir à le déployer sur un point de terminaison. Pour les données tabulaires, utilisez les prédictions par lot lorsque vous n'avez pas besoin d'une réponse immédiate et que vous souhaitez traiter des données accumulées à l'aide d'une seule requête.

Pour effectuer une requête de prédiction par lot, vous devez spécifier une source d'entrée et un format de sortie dans lesquels Vertex AI stocke les résultats des prédictions.

Avant de commencer

Avant de pouvoir effectuer une requête de prédiction par lot, vous devez d'abord entraîner un modèle.

Données d'entrée

Les données d'entrée des requêtes de prédiction par lot sont les données que le modèle utilise pour effectuer des prédictions. Pour les modèles de classification ou de régression, vous pouvez fournir des données d'entrée dans l'un des deux formats suivants :

  • Tables BigQuery
  • Objets CSV dans Cloud Storage

Nous vous recommandons d'utiliser le même format pour les données d'entrée et l'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 la prédiction par lot. Comme Vertex AI traite tous les champs d'entrée CSV comme des chaînes, l'utilisation de formats de données d'entrée et d'entraînement différents peut entraîner des erreurs.

Votre source de données doit contenir des données tabulaires incluant toutes les colonnes, dans n'importe quel ordre, qui ont été utilisées pour entraîner le modèle. 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 la sortie, mais n'affectent pas les résultats de la prédiction.

Exigences concernant les données d'entrée

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 de 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 de ce projet.
  • Vous devez placer toutes les chaînes entre guillemets doubles (").

Format de sortie

Le format de sortie de votre requête de prédiction par lot n'a pas besoin d'être identique au format utilisé pour l'entrée. Par exemple, si vous avez utilisé la table BigQuery en tant qu'entrée, vous pouvez générer les résultats dans un objet CSV dans Cloud Storage.

Envoyer une requête de prédiction par lot au modèle

Pour effectuer des requêtes de prédiction par lot, vous pouvez utiliser Google Cloud Console 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 de prédiction par lot peut prendre un certain temps.

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"

  2. Cliquez sur Créer pour ouvrir la fenêtre Nouvelle prédiction par lot.
  3. 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. Pour Version, sélectionnez la version de modèle à utiliser pour cette prédiction par lot.
    4. Dans le champ 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 le champ Résultat, 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 l'ID du projet dans le champ ID du 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 du projet Google Cloud, tel que bq://projectid.datasetid.
  4. 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.
  5. Cliquez sur Créer.

API : BigQuery

REST

Utilisez la méthode batchPredictionJobs.create pour demander une prédiction 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 de prédiction par lot est exécutée. Exemple : us-central1.
  • PROJECT_ID : ID du projet.
  • BATCH_JOB_NAME : nom à afficher du job par lot.
  • MODEL_ID : ID du modèle à utiliser pour effectuer des prédictions.
  • 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 prédictions seront écrites). Spécifiez l'ID du projet et, éventuellement, un un ID d'ensemble de données existant. 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.bqDatasetId
  • MACHINE_TYPE : ressources de machine à utiliser pour cette tâche de prédiction par lot. En savoir plus
  • STARTING_REPLICA_COUNT : nombre de nœuds initial pour cette tâche de prédiction par lot. Le nombre de nœuds peut être augmenté ou réduit selon les besoins de la charge, jusqu'à atteindre le nombre maximal de nœuds. Toutefois, il ne sera jamais inférieur à ce nombre.
  • MAX_REPLICA_COUNT : nombre maximal de nœuds pour cette tâche de prédiction par lot. Le nombre de nœuds peut être augmenté ou réduit selon les besoins de la charge, mais ne dépassera jamais le maximum. (Facultatif) La valeur par défaut est 10.

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": "MODEL_ID",
  "inputConfig": {
    "instancesFormat": "bigquery",
    "bigquerySource": {
      "inputUri": "INPUT_URI"
    }
  },
  "outputConfig": {
    "predictionsFormat": "bigquery",
    "bigqueryDestination": {
      "outputUri": "OUTPUT_URI"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "MACHINE_TYPE",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT,
    "maxReplicaCount": MAX_REPLICA_COUNT
  },

}

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
  },
  "generateExplanation": false,
  "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.

Dans l'exemple suivant, définissez les paramètres "instances_format" et "predictions_format" sur "bigquery". Pour savoir comment définir les autres paramètres, consultez l'onglet "REST et ligne de commande" de cette section. 
from google.cloud import aiplatform_v1beta1
from google.protobuf import json_format
from google.protobuf.struct_pb2 import Value


def create_batch_prediction_job_bigquery_sample(
    project: str,
    display_name: str,
    model_name: str,
    instances_format: str,
    bigquery_source_input_uri: str,
    predictions_format: str,
    bigquery_destination_output_uri: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform_v1beta1.JobServiceClient(client_options=client_options)
    model_parameters_dict = {}
    model_parameters = json_format.ParseDict(model_parameters_dict, Value())

    batch_prediction_job = {
        "display_name": display_name,
        # Format: 'projects/{project}/locations/{location}/models/{model_id}'
        "model": model_name,
        "model_parameters": model_parameters,
        "input_config": {
            "instances_format": instances_format,
            "bigquery_source": {"input_uri": bigquery_source_input_uri},
        },
        "output_config": {
            "predictions_format": predictions_format,
            "bigquery_destination": {"output_uri": bigquery_destination_output_uri},
        },
        # optional
        "generate_explanation": True,
    }
    parent = f"projects/{project}/locations/{location}"
    response = client.create_batch_prediction_job(
        parent=parent, batch_prediction_job=batch_prediction_job
    )
    print("response:", response)

API : Cloud Storage

REST

Utilisez la méthode batchPredictionJobs.create pour demander une prédiction 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 de prédiction par lot est exécutée. Exemple : us-central1.
  • PROJECT_ID : ID du projet.
  • BATCH_JOB_NAME : nom à afficher du job par lot.
  • MODEL_ID : ID du modèle à utiliser pour effectuer des prédictions.
  • 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 prédictions seront écrites. Vertex AI écrit des prédictions par lots dans un sous-répertoire horodaté de ce chemin. Définissez cette valeur sur une chaîne au format suivant : 
    gs://bucketName/pathToOutputDirectory
  • MACHINE_TYPE : ressources de machine à utiliser pour cette tâche de prédiction par lot. En savoir plus
  • STARTING_REPLICA_COUNT : nombre de nœuds initial pour cette tâche de prédiction par lot. Le nombre de nœuds peut être augmenté ou réduit selon les besoins de la charge, jusqu'à atteindre le nombre maximal de nœuds. Toutefois, il ne sera jamais inférieur à ce nombre.
  • MAX_REPLICA_COUNT : nombre maximal de nœuds pour cette tâche de prédiction par lot. Le nombre de nœuds peut être augmenté ou réduit selon les besoins de la charge, mais ne dépassera jamais le maximum. (Facultatif) La valeur par défaut est 10.

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": "MODEL_ID",
  "inputConfig": {
    "instancesFormat": "csv",
    "gcsSource": {
      "uris": [
        URI1,...
      ]
    },
  },
  "outputConfig": {
    "predictionsFormat": "csv",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_URI_PREFIX"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "MACHINE_TYPE",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT,
    "maxReplicaCount": MAX_REPLICA_COUNT
  },

}

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
  },
  "manualBatchTuningParameters": {
    "batchSize": 4
  }
  "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",
}

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

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

BigQuery

Ensemble de données de sortie

Si vous utilisez BigQuery, le résultat de la prédiction par lot 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 Prédictions par lots de Vertex AI.

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

  2. Sélectionnez la prédiction que vous avez créée.
  3. L'ensemble de données de sortie est indiqué dans Emplacement d'exportation. Le nom de la ressource est formaté de la façon suivante : prediction_MODEL_NAME_TIMESTAMP
Tables de sortie

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

  • Table des prédictions

    Cette table contient une ligne pour chaque ligne de vos données d'entrée où une prédiction a été demandée (c'est-à-dire une ligne avec TARGET_COLUMN_NAME = null).

  • Table des erreurs

    Cette table contient une ligne pour chaque erreur non critique rencontrée lors de la prédiction par lot. Chaque erreur non critique correspond à une ligne dans les 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 de la tâche de prédiction par lot : predictions_TIMESTAMP

Pour récupérer les prédictions, accédez à la page BigQuery.

Accéder à BigQuery

Le format de la requête dépend du type de votre modèle :

Classification :

SELECT predicted_TARGET_COLUMN_NAME.classes AS classes,
predicted_TARGET_COLUMN_NAME.scores AS scores
FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME

classes est la liste des classes potentielles, et scores sont les scores de confiance correspondants.

Régression :

SELECT predicted_TARGET_COLUMN_NAME.value
FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME

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 fournit des valeurs et des prédictions de quantiles en plus de la minimisation de l'objectif d'optimisation. Les valeurs de quantile sont définies lors de l'entraînement du modèle. Les prédictions de quantiles sont les valeurs de prédiction associées aux valeurs quantiles.

Vous pouvez également consulter l'importance des caractéristiques dans la table des prédictions. Pour accéder à l'importance d'une caractéristique BQ_FEATURE_NAME, exécutez la requête suivante : 

SELECT predicted_TARGET_COLUMN_NAME.feature_importance.BQ_FEATURE_NAME FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_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 de prédiction par lot : errors_TIMESTAMP Pour récupérer la table de validation des erreurs :

  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 de prédiction par lot sont affiché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 "prediction-" et suivi de l'horodatage du début de la tâche de prédiction. Vous trouverez le nom du dossier Cloud Storage dans l'onglet Prédictions par lot de votre modèle.

Le dossier Cloud Storage contient deux types d'objets :
  • Objets de prédiction

    Les objets de prédiction 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édiction affichée. Dans les objets de prédiction, Vertex AI renvoie les données de prédiction et crée une ou plusieurs colonnes pour les résultats de prédiction, en fonction de votre type de modèle :

    • Classification : Pour chaque valeur potentielle de votre colonne cible, une colonne nommée TARGET_COLUMN_NAME_VALUE_score est ajoutée aux résultats. Cette colonne contient le score, ou estimation du niveau de confiance, pour cette valeur.
    • Régression : La valeur prédite pour cette ligne est affichée dans une colonne intitulée predicted_TARGET_COLUMN_NAME. L'intervalle de prédiction n'est pas affiché dans la sortie au format CSV.
  • 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édiction (par exemple, une caractéristique ne pouvant être vide contient une valeur nulle).

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

L'importance des caractéristiques n'est pas disponible pour les résultats de prédictions par lot renvoyés dans Cloud Storage.

Interpréter les résultats des prédictions

Classification

Les modèles de classification renvoient un score de confiance.

Le score de confiance indique à quel point votre modèle associe chaque classe ou étiquette à un élément de test. Plus le score est élevé, plus le modèle a de chances d'appliquer l'étiquette à cet élément. C'est vous qui décidez du seuil de confiance auquel vous acceptez les résultats du modèle.

Régression

Les modèles de régression renvoient une valeur de prédiction.

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

Si votre modèle utilise une inférence probabiliste avec des quantiles, Vertex AI fournit des valeurs et des prédictions de quantiles en plus de la minimisation de l'objectif d'optimisation. Les valeurs de quantile sont définies lors de l'entraînement du modèle. Les prédictions de quantiles sont les valeurs de prédiction associées aux valeurs quantiles.

Pour les résultats de prédictions par lot stockés dans BigQuery, TabNet offre une interprétabilité inhérente au modèle, en permettant aux utilisateurs d'identifier les caractéristiques sur lesquelles le modèle s'est appuyé pour prendre sa décision. L'algorithme utilise l'attention, qui apprend à améliorer de manière sélective l'influence de certaines caractéristiques tout en diminuant l'influence d'autres, via une moyenne pondérée. À chaque décision, TabNet détermine l'importance à accorder à chaque caractéristique en procédant par étapes. Il combine ensuite chacune de ces étapes pour créer une prédiction finale. L'attention revêt un effet de multiplication, en ce sens que des valeurs plus élevées indiquent que la caractéristique a joué un rôle plus important dans la prédiction, tandis qu'une valeur de zéro signifie que la caractéristique n'a joué aucun rôle dans cette décision. Étant donné que TabNet utilise plusieurs étapes de décision, l'attention accordée aux caractéristiques pour l'ensemble des étapes est combinée de manière linéaire après avoir défini un scaling approprié. Cette combinaison linéaire de l'ensemble des étapes de décision de TabNet correspond à l'importance totale des caractéristiques, transmise par TabNet.

Étapes suivantes