Prédictions par lots

Bêta

Ce produit est soumis aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les produits pré-DG sont disponibles "en l'état" et peuvent bénéficier d'une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Cette page décrit comment fournir plusieurs lignes de données à AutoML Tables en même temps et recevoir une prédiction pour chaque ligne.

Introduction

Après avoir créé (entraîné) un modèle, vous pouvez envoyer une requête asynchrone pour un lot de prédictions à l'aide de la méthode batchPredict. Vous fournissez les données d'entrée à la méthode batchPredict, sous forme de table. Chaque ligne fournit les valeurs de caractéristiques que vous avez entraîné le modèle à utiliser. La méthode batchPredict envoie ces données au modèle et renvoie des prédictions pour chaque ligne de données.

Les modèles doivent être réentraînés tous les six mois pour continuer à fournir des prédictions.

Demander une prédiction par lot

Pour les prédictions par lot, vous spécifiez une source de données et une destination des résultats dans une table BigQuery ou un fichier CSV dans Cloud Storage. Vous n'avez pas besoin d'utiliser la même technologie pour la source et la destination. Par exemple, vous pouvez utiliser BigQuery pour la source de données et un fichier CSV dans Cloud Storage pour la destination des résultats. Suivez les étapes des deux tâches indiquées ci-dessous en fonction de vos exigences.

Votre source de données doit contenir des données tabulaires dans lesquelles toutes les colonnes utilisées pour entraîner le modèle sont incluses. 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 de la prédiction, mais elles ne sont pas utilisées pour générer la prédiction.

Utiliser les tables BigQuery

Les noms de colonne et les types de données d'entrée doivent correspondre à ceux que vous avez utilisés dans les données d'entraînement. Les colonnes peuvent se présenter dans un ordre différent de celui des données d'entraînement.

Exigences relatives aux tables BigQuery

• Les tables de source de données BigQuery ne doivent pas dépasser 100 Go.
• Vous devez utiliser un ensemble de données BigQuery multirégional dans les zones US ou EU.
• Si la table se trouve dans un autre projet, vous devez attribuer le rôle BigQuery Data Editor au compte de service AutoML Tables de ce projet. En savoir plus

Demander la prédiction par lot

Console

1. Accédez à la page "AutoML Tables" dans la console Google Cloud.

   Accéder à la page AutoML Tables

2. Cliquez sur Modèles et ouvrez le modèle que vous souhaitez utiliser.

3. Sélectionnez l'onglet Test et utilisation.

4. Cliquez sur Prédiction par lot.

5. Dans Input dataset (Ensemble de données d'entrée), sélectionnez Table from BigQuery (Table de BigQuery) et indiquez les ID du projet, de l'ensemble de données et de la table correspondant à votre source de données.

6. Dans Result (Résultats), sélectionnez BigQuery project (projet BigQuery) et indiquez l'ID de projet pour votre destination de résultats.

7. Pour connaître l'incidence de chaque caractéristique sur la prédiction, cliquez sur Générer l'importance des caractéristiques.

   Générer l'importance des caractéristiques augmente le temps et les ressources de calcul nécessaires pour réaliser la prédiction. L'importance des caractéristiques locales n'est pas disponible avec une destination de résultats Cloud Storage.

8. Cliquez sur Send batch prediction (Envoyer une prédiction par lot) pour demander une prédiction par lot.

   

REST

Vous demandez des prédictions par lot à l'aide de la méthode models.batchPredict.

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

• endpoint: automl.googleapis.com pour la zone internationale et eu-automl.googleapis.com pour la région UE.
• project-id : ID de votre projet Google Cloud.
• location : emplacement de la ressource : us-central1 pour l'emplacement mondial ou eu pour l'Union européenne.
• model-id : ID du modèle. Par exemple, TBL543.
• dataset-id: ID de l'ensemble de données BigQuery où se trouvent les données de prédiction.

• table-id : ID de la table BigQuery où se trouvent les données de prédiction.

  AutoML Tables crée un sous-dossier pour les résultats de prédiction nommé prediction-<model_name>-<timestamp> dans project-id.dataset-id.table-id.

Méthode HTTP et URL :

POST https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict

Corps JSON de la requête :

{
  "inputConfig": {
    "bigquerySource": {
      "inputUri": "bq://project-id.dataset-id.table-id"
    },
  },
  "outputConfig": {
    "bigqueryDestination": {
      "outputUri": "bq://project-id"
    },
  },
}

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 et exécutez la commande suivante:

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "x-goog-user-project: project-id" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict"

PowerShell

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

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict" | Select-Object -Expand Content

La prédiction par lot est une opération de longue durée. Vous pouvez interroger l'état de l'opération ou attendre qu'elle ait abouti. En savoir plus

Vous pouvez obtenir l'importance des caractéristiques locales en ajoutant le paramètre feature_importance aux données de la requête. Pour en savoir plus, consultez l'article Importance des caractéristiques locales.

Java

Si vos ressources sont situées dans la région UE, vous devez définir explicitement le point de terminaison. En savoir plus

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1beta1.BatchPredictInputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictOutputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictRequest;
import com.google.cloud.automl.v1beta1.BatchPredictResult;
import com.google.cloud.automl.v1beta1.BigQueryDestination;
import com.google.cloud.automl.v1beta1.BigQuerySource;
import com.google.cloud.automl.v1beta1.ModelName;
import com.google.cloud.automl.v1beta1.OperationMetadata;
import com.google.cloud.automl.v1beta1.PredictionServiceClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

abstract class TablesBatchPredictBigQuery {

  static void batchPredict() throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String inputUri = "bq://YOUR_PROJECT_ID.bqDatasetID.bqTableId";
    String outputUri = "bq://YOUR_PROJECT_ID";
    batchPredict(projectId, modelId, inputUri, outputUri);
  }

  static void batchPredict(String projectId, String modelId, String inputUri, String outputUri)
      throws IOException, ExecutionException, InterruptedException {
    // 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 (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);

      // Configure the source of the file from BigQuery
      BigQuerySource bigQuerySource = BigQuerySource.newBuilder().setInputUri(inputUri).build();
      BatchPredictInputConfig inputConfig =
          BatchPredictInputConfig.newBuilder().setBigquerySource(bigQuerySource).build();

      // Configure where to store the output in BigQuery
      BigQueryDestination bigQueryDestination =
          BigQueryDestination.newBuilder().setOutputUri(outputUri).build();
      BatchPredictOutputConfig outputConfig =
          BatchPredictOutputConfig.newBuilder().setBigqueryDestination(bigQueryDestination).build();

      // Build the request that will be sent to the API
      BatchPredictRequest request =
          BatchPredictRequest.newBuilder()
              .setName(name.toString())
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .build();

      // Start an asynchronous request
      OperationFuture<BatchPredictResult, OperationMetadata> future =
          client.batchPredictAsync(request);

      System.out.println("Waiting for operation to complete...");
      future.get();
      System.out.println("Batch Prediction results saved to BigQuery.");
    }
  }
}

Node.js

Si vos ressources sont situées dans la région UE, vous devez définir explicitement le point de terminaison. En savoir plus

/**
 * Demonstrates using the AutoML client to request prediction from
 * automl tables using bigQuery.
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = '[PROJECT_ID]' e.g., "my-gcloud-project";
// const computeRegion = '[REGION_NAME]' e.g., "us-central1";
// const modelId = '[MODEL_ID]' e.g., "TBL4704590352927948800";
// const inputUri = '[BIGQUERY_PATH]'
// e.g., "bq://<project_id>.<dataset_id>.<table_id>",
// `The Big Query URI containing the inputs`;
// const outputUri = '[BIGQUERY_PATH]' e.g., "bq://<project_id>",
// `The destination Big Query URI for storing outputs`;

const automl = require('@google-cloud/automl');

// Create client for prediction service.
const automlClient = new automl.v1beta1.PredictionServiceClient();

// Get the full path of the model.
const modelFullId = automlClient.modelPath(projectId, computeRegion, modelId);

async function batchPredict() {
  // Construct request
  // Get the Big Query input URI.
  const inputConfig = {
    bigquerySource: {
      inputUri: inputUri,
    },
  };

  // Get the Big Query output URI.
  const outputConfig = {
    bigqueryDestination: {
      outputUri: outputUri,
    },
  };

  const [, operation] = await automlClient.batchPredict({
    name: modelFullId,
    inputConfig: inputConfig,
    outputConfig: outputConfig,
  });

  // Get the latest state of long-running operation.
  console.log(`Operation name: ${operation.name}`);
}

batchPredict();

Python

La bibliothèque cliente AutoML Tables comprend des méthodes Python supplémentaires qui simplifient l'utilisation de l'API AutoML Tables. Ces méthodes référencent les ensembles de données et les modèles par nom et non par identifiant. L'ensemble de données et les noms de modèles doivent être uniques. Pour plus d'informations, consultez la documentation de référence du client.

Si vos ressources sont situées dans la région UE, vous devez définir explicitement le point de terminaison. En savoir plus

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_display_name = 'MODEL_DISPLAY_NAME_HERE'
# bq_input_uri = 'bq://my-project.my-dataset.my-table'
# bq_output_uri = 'bq://my-project'
# params = {}

from google.cloud import automl_v1beta1 as automl

client = automl.TablesClient(project=project_id, region=compute_region)

# Query model
response = client.batch_predict(
    bigquery_input_uri=bq_input_uri,
    bigquery_output_uri=bq_output_uri,
    model_display_name=model_display_name,
    params=params,
)
print("Making batch prediction... ")
# `response` is a async operation descriptor,
# you can register a callback for the operation to complete via `add_done_callback`:
# def callback(operation_future):
#   result = operation_future.result()
# response.add_done_callback(callback)
#
# or block the thread polling for the operation's results:
response.result()
# AutoML puts predictions in a newly generated dataset with a name by a mask "prediction_" + model_id + "_" + timestamp
# here's how to get the dataset name:
dataset_name = (
    response.metadata.batch_predict_details.output_info.bigquery_output_dataset
)

print(
    "Batch prediction complete.\nResults are in '{}' dataset.\n{}".format(
        dataset_name, response.metadata
    )
)

Utiliser des fichiers CSV dans Cloud Storage

Les noms de colonne et les types de données d'entrée doivent correspondre à ceux que vous avez utilisés dans les données d'entraînement. Les colonnes peuvent se présenter dans un ordre différent de celui des données d'entraînement.

Exigences relatives aux fichiers CSV

• La première ligne de la source de données doit contenir le nom des colonnes.

• Chaque fichier de source de données ne doit pas dépasser 10 Go.

  Vous pouvez inclure plusieurs fichiers, jusqu'à une taille maximale de 100 Go.

• Le bucket Cloud Storage doit être conforme aux exigences de bucket.

• Si le bucket Cloud Storage se trouve dans un autre projet que celui pour lequel vous utilisez AutoML Tables, vous devez attribuer le rôle Storage Object Creator au compte de service AutoML Tables de ce projet. En savoir plus

Console

1. Accédez à la page "AutoML Tables" dans la console Google Cloud.

   Accéder à la page AutoML Tables

2. Cliquez sur Modèles et ouvrez le modèle que vous souhaitez utiliser.

3. Sélectionnez l'onglet Test et utilisation.

4. Cliquez sur Prédiction par lot.

5. Dans Input dataset (Ensemble de données d'entrée), sélectionnez CSVs from Cloud Storage (Fichiers CSV provenant de Cloud Storage) et indiquez l'URI de bucket pour votre source de données.

6. Dans Result (Résultats), sélectionnez Cloud Storage bucket (bucket Cloud Storage) et indiquez l'URI de bucket pour votre bucket de destination.

7. Pour connaître l'incidence de chaque caractéristique sur la prédiction, cliquez sur Générer l'importance des caractéristiques.

   Générer l'importance des caractéristiques augmente le temps et les ressources de calcul nécessaires pour réaliser la prédiction. L'importance des caractéristiques locales n'est pas disponible avec une destination de résultats Cloud Storage.

8. Cliquez sur Send batch prediction (Envoyer une prédiction par lot) pour demander une prédiction par lot.

   

REST

Vous demandez des prédictions par lot à l'aide de la méthode models.batchPredict.

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

• endpoint: automl.googleapis.com pour la zone internationale et eu-automl.googleapis.com pour la région UE.
• project-id : ID de votre projet Google Cloud.
• location : emplacement de la ressource : us-central1 pour l'emplacement mondial ou eu pour l'Union européenne.
• model-id : ID du modèle. Par exemple, TBL543.
• input-bucket-name : nom du bucket Cloud Storage où se trouvent les données de la prédiction.
• input-directory-name : nom du répertoire Cloud Storage où se trouvent les données de la prédiction.
• object-name : nom de l'objet Cloud Storage où se trouvent les données de la prédiction.
• output-bucket-name : nom du bucket Cloud Storage pour les résultats de la prédiction.
• output-directory-name : nom du répertoire Cloud Storage pour les résultats de la prédiction.

  AutoML Tables crée un sous-dossier pour les résultats de la prédiction nommés prediction-<model_name>-<timestamp> dans gs://output-bucket-name/output-directory-name... Vous devez disposer des autorisations en écriture pour ce chemin.

Méthode HTTP et URL :

POST https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict

Corps JSON de la requête :

{
  "inputConfig": {
    "gcsSource": {
      "inputUris": [
        "gs://input-bucket-name/input-directory-name/object-name.csv"
      ]
    },
  },
  "outputConfig": {
    "gcsDestination": {
      "outputUriPrefix": "gs://output-bucket-name/output-directory-name"
     },
  },
}

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 et exécutez la commande suivante:

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "x-goog-user-project: project-id" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict"

PowerShell

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

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict" | Select-Object -Expand Content

La prédiction par lot est une opération de longue durée. Vous pouvez interroger l'état de l'opération ou attendre qu'elle ait abouti. En savoir plus

Vous pouvez obtenir l'importance des caractéristiques locales en ajoutant le paramètre feature_importance aux données de la requête. Pour en savoir plus, consultez l'article Importance des caractéristiques locales.

Remarque : L'importance des caractéristiques locales n'est pas affichée pour les requêtes utilisant Cloud Storage comme destination de résultats.

Java

Si vos ressources sont situées dans la région UE, vous devez définir explicitement le point de terminaison. En savoir plus

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1beta1.BatchPredictInputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictOutputConfig;
import com.google.cloud.automl.v1beta1.BatchPredictRequest;
import com.google.cloud.automl.v1beta1.BatchPredictResult;
import com.google.cloud.automl.v1beta1.GcsDestination;
import com.google.cloud.automl.v1beta1.GcsSource;
import com.google.cloud.automl.v1beta1.ModelName;
import com.google.cloud.automl.v1beta1.OperationMetadata;
import com.google.cloud.automl.v1beta1.PredictionServiceClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

abstract class BatchPredict {

  static void batchPredict() throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String inputUri = "gs://YOUR_BUCKET_ID/path_to_your_input_csv_or_jsonl";
    String outputUri = "gs://YOUR_BUCKET_ID/path_to_save_results/";
    batchPredict(projectId, modelId, inputUri, outputUri);
  }

  static void batchPredict(String projectId, String modelId, String inputUri, String outputUri)
      throws IOException, ExecutionException, InterruptedException {
    // 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 (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);

      // Configure the source of the file from a GCS bucket
      GcsSource gcsSource = GcsSource.newBuilder().addInputUris(inputUri).build();
      BatchPredictInputConfig inputConfig =
          BatchPredictInputConfig.newBuilder().setGcsSource(gcsSource).build();

      // Configure where to store the output in a GCS bucket
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(outputUri).build();
      BatchPredictOutputConfig outputConfig =
          BatchPredictOutputConfig.newBuilder().setGcsDestination(gcsDestination).build();

      // Build the request that will be sent to the API
      BatchPredictRequest request =
          BatchPredictRequest.newBuilder()
              .setName(name.toString())
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .build();

      // Start an asynchronous request
      OperationFuture<BatchPredictResult, OperationMetadata> future =
          client.batchPredictAsync(request);

      System.out.println("Waiting for operation to complete...");
      future.get();
      System.out.println("Batch Prediction results saved to specified Cloud Storage bucket.");
    }
  }
}

Node.js

Si vos ressources sont situées dans la région UE, vous devez définir explicitement le point de terminaison. En savoir plus

/**
 * Demonstrates using the AutoML client to request prediction from
 * automl tables using GCS.
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = '[PROJECT_ID]' e.g., "my-gcloud-project";
// const computeRegion = '[REGION_NAME]' e.g., "us-central1";
// const modelId = '[MODEL_ID]' e.g., "TBL4704590352927948800";
// const inputUri = '[GCS_PATH]' e.g., "gs://<bucket-name>/<csv file>",
// `The Google Cloud Storage URI containing the inputs`;
// const outputUriPrefix = '[GCS_PATH]'
// e.g., "gs://<bucket-name>/<folder-name>",
// `The destination Google Cloud Storage URI for storing outputs`;

const automl = require('@google-cloud/automl');

// Create client for prediction service.
const automlClient = new automl.v1beta1.PredictionServiceClient();

// Get the full path of the model.
const modelFullId = automlClient.modelPath(projectId, computeRegion, modelId);

async function batchPredict() {
  // Construct request
  const inputConfig = {
    gcsSource: {
      inputUris: [inputUri],
    },
  };

  // Get the Google Cloud Storage output URI.
  const outputConfig = {
    gcsDestination: {
      outputUriPrefix: outputUriPrefix,
    },
  };

  const [, operation] = await automlClient.batchPredict({
    name: modelFullId,
    inputConfig: inputConfig,
    outputConfig: outputConfig,
  });

  // Get the latest state of long-running operation.
  console.log(`Operation name: ${operation.name}`);
  return operation;
}

batchPredict();

Python

La bibliothèque cliente AutoML Tables comprend des méthodes Python supplémentaires qui simplifient l'utilisation de l'API AutoML Tables. Ces méthodes référencent les ensembles de données et les modèles par nom et non par identifiant. L'ensemble de données et les noms de modèles doivent être uniques. Pour plus d'informations, consultez la documentation de référence du client.

Si vos ressources sont situées dans la région UE, vous devez définir explicitement le point de terminaison. En savoir plus

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_display_name = 'MODEL_DISPLAY_NAME_HERE'
# gcs_input_uri = 'gs://YOUR_BUCKET_ID/path_to_your_input_csv'
# gcs_output_uri = 'gs://YOUR_BUCKET_ID/path_to_save_results/'
# params = {}

from google.cloud import automl_v1beta1 as automl

client = automl.TablesClient(project=project_id, region=compute_region)

# Query model
response = client.batch_predict(
    gcs_input_uris=gcs_input_uri,
    gcs_output_uri_prefix=gcs_output_uri,
    model_display_name=model_display_name,
    params=params,
)
print("Making batch prediction... ")
# `response` is a async operation descriptor,
# you can register a callback for the operation to complete via `add_done_callback`:
# def callback(operation_future):
#   result = operation_future.result()
# response.add_done_callback(callback)
#
# or block the thread polling for the operation's results:
response.result()

print(f"Batch prediction complete.\n{response.metadata}")

Récupérer vos résultats

Récupérer les résultats de prédiction dans BigQuery

Si vous avez spécifié BigQuery comme destination de sortie, les résultats de votre requête de prédiction par lot sont affichés en tant que nouvel ensemble de données dans le projet BigQuery spécifié. Le nom de l'ensemble de données BigQuery 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 de l'ensemble de données BigQuery dans Prédictions récentes sur la page Prédiction par lot de l'onglet Test et utilisation pour votre modèle.

L'ensemble de données BigQuery contient deux tables : predictions et errors. La table errors comprend une ligne pour chaque ligne de votre requête de prédiction pour laquelle AutoML Tables n'a pas pu afficher de prédiction (par exemple, une caractéristique ne pouvant être vide contient une valeur nulle). La table predictions contient une ligne pour chaque prédiction affichée.

Dans la table predictions, AutoML Tables affiche les données de prédiction et crée une colonne pour les résultats de prédiction en ajoutant "predicted_" au nom de la colonne cible. La colonne des résultats de prédiction comporte une structure BigQuery imbriquée qui contient les résultats de prédiction.

Pour extraire les résultats de prédiction, vous pouvez utiliser une requête dans la console BigQuery. Le format de la requête dépend du type de votre modèle.

Classification binaire :

SELECT predicted_<target-column-name>[OFFSET(0)].tables AS value_1,
predicted_<target-column-name>[OFFSET(1)].tables AS value_2
FROM <bq-dataset-name>.predictions

"value_1" et "value_2" sont des repères de position. Vous pouvez les remplacer par les valeurs cibles ou un équivalent.

Classification à classes multiples :

SELECT predicted_<target-column-name>[OFFSET(0)].tables AS value_1,
predicted_<target-column-name>[OFFSET(1)].tables AS value_2,
predicted_<target-column-name>[OFFSET(2)].tables AS value_3,
...
predicted_<target-column-name>[OFFSET(4)].tables AS value_5
FROM <bq-dataset-name>.predictions

"valeur_1", "valeur_2", etc. sont des repères de position. Vous pouvez les remplacer par les valeurs cibles ou un équivalent.

Régression :

SELECT predicted_<target-column-name>[OFFSET(0)].tables.value,
predicted_<target-column-name>[OFFSET(0)].tables.prediction_interval.start,
predicted_<target-column-name>[OFFSET(0)].tables.prediction_interval.end
FROM <bq-dataset-name>.predictions

Récupérer les résultats dans 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 de fichiers 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 de prédiction. Vous trouverez le nom du dossier Cloud Storage dans Prédictions récentes en bas de la page Prédiction par lot de l'onglet Test et utilisation pour votre modèle.

Le dossier Cloud Storage contient deux types de fichiers : les fichiers d'erreur et les fichiers de prédiction. Si les résultats sont volumineux, des fichiers supplémentaires sont créés.

Les fichiers 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 votre requête de prédiction pour laquelle AutoML Tables n'a pas pu afficher de prédiction.

Les fichiers de prédiction sont nommés tables_1.csv, tables_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 fichiers de prédiction, AutoML Tables affiche vos données de prédiction et crée une ou plusieurs colonnes pour les résultats de prédiction, en fonction du type de votre 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.

L'importance des caractéristiques locales n'est pas disponible dans les résultats de Cloud Storage.

Interpréter vos résultats

La façon dont vous interprétez vos résultats dépend du problématique métier que vous résolvez et de la manière dont vos données sont distribuées.

Interpréter vos résultats pour les modèles de classification

Les résultats de prédiction pour les modèles de classification (binaires et multiclasses) affichent un score de probabilité pour chaque valeur potentielle de la colonne cible. Vous devez déterminer comment vous souhaitez utiliser les scores. Par exemple, pour obtenir une classification binaire à partir des scores fournis, vous devez identifier une valeur de seuil. S'il existe deux classes, A et B, vous devez classer l'exemple dans A si le score de A est supérieur au seuil choisi, et dans B dans le cas contraire. Pour les ensembles de données déséquilibrés, le seuil peut atteindre 100 % ou 0 %.

Vous pouvez utiliser le graphique de courbe de précision et de rappel, ainsi que d'autres statistiques pertinentes par étiquette sur la page Évaluer de votre modèle dans la console Google Cloud pour voir comment la modification du seuil modifie vos métriques d'évaluation. Cela vous aidera à déterminer la meilleure façon d'utiliser les valeurs de score pour interpréter vos résultats de prédiction.

Interpréter les résultats pour les modèles de régression

Pour les modèles de régression, une valeur attendue est affichée. Cette valeur peut être utilisée directement dans de nombreux cas. S'il s'affiche, et si une plage convient à votre problématique métier, vous pouvez également utiliser l'intervalle de prédiction

Interpréter les résultats de l'importance des caractéristiques locales

Pour plus d'informations sur l'interprétation des résultats de l'importance des caractéristiques locales, consultez la page Importance des caractéristiques locales.

Étapes suivantes

• Apprenez-en plus sur l'importance des caractéristiques locales.
• Apprenez-en plus sur les opérations de longue durée.