Cette ancienne version d'AutoML Video Intelligence est obsolète et ne sera plus disponible sur Google Cloud après le 23 janvier 2024. Toutes les anciennes fonctionnalités d'AutoML Video Intelligence sont disponibles sur la plate-forme Vertex AI. Consultez la page Migrer vers Vertex AI pour savoir comment migrer vos ressources.

Gérer les ensembles de données

Un ensemble de données contient des échantillons représentatifs du type de contenu auquel vous souhaitez étiqueter, avec les étiquettes de cadre de délimitation que vous souhaitez que le modèle utilise. Il sert d'entrée pour l'entraînement d'un modèle.

Voici les principales étapes à suivre pour créer un ensemble de données :

Créer un ensemble de données et spécifier s'il faut autoriser plusieurs étiquettes sur chaque élément.
Importer des éléments de données dans l'ensemble de données.

Avant d'entraîner un modèle, veillez à préparer vos données.

Un projet peut avoir plusieurs ensembles de données, chacun servant à entraîner un modèle distinct. Vous pouvez accéder à la liste des ensembles de données disponibles et supprimer les ensembles de données dont vous n'avez plus besoin.

Créer un ensemble de données

La première étape de l'élaboration d'un modèle consiste à créer un ensemble de données vide, qui contiendra à terme les données d'entraînement du modèle.

UI Web

L'interface utilisateur d'AutoML Video Object Tracking vous permet de créer un ensemble de données, puis d'y importer des éléments à partir de la même page.

Ouvrez l'interface utilisateur d'AutoML Video Object Tracking. La page Datasets (Ensembles de données) indique l'état des ensembles de données créés précédemment pour le projet en cours. Si vous souhaitez ajouter un ensemble de données pour un autre projet, sélectionnez ce projet dans la liste déroulante située dans l'angle supérieur droit de la barre de titre.
Sur la page Datasets (Ensembles de données), cliquez sur Create Dataset (Créer un ensemble de données).
Dans la boîte de dialogue Créer un ensemble de données, procédez comme suit :
- Spécifiez un nom pour cet ensemble de données.
- Sélectionnez Suivi des objets vidéo.
- Cliquez sur Créer un ensemble de données.
Sur la page de votre ensemble de données, indiquez l'URI Cloud Storage du fichier CSV contenant les URI de vos données d'entraînement, sans le préfixe gs:// au début.
Toujours sur la page de votre ensemble de données, cliquez sur Continuer pour commencer l'importation.

REST

L'exemple suivant crée un ensemble de données nommé my_dataset01 compatible avec les cas d'utilisation du suivi des objets. Ce nouvel ensemble de données ne contient aucune donnée tant que vous n'y importez pas d'éléments.

Enregistrez le nom ("name") du nouvel ensemble de données (issu de la réponse) afin de l'utiliser pour d'autres opérations, par exemple y importer des éléments ou entraîner un modèle.

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

dataset-name : nom de l'ensemble de données cible.
Par exemple, my_dataset_01
Remarque :
- project-number : numéro de votre projet.
- location-id : région cloud dans laquelle l'annotation doit avoir lieu. Les régions cloud compatibles sont les suivantes : us-east1, us-west1, europe-west1 et asia-east1. Si aucune région n'est spécifiée, une région sera déterminée en fonction de l'emplacement du fichier vidéo.

Méthode HTTP et URL :

POST https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/datasets

Corps JSON de la requête :

{
    "displayName": "dataset-name",
    "videoObjectTrackingDatasetMetadata": { }
}

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

curl

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter gcloud auth list pour vérifier le compte actuellement actif.

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-number" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/datasets"

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-number" }

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

Si la réponse aboutit, l'API de suivi des objets AutoML Video Intelligence renvoie le nom de votre opération. Voici un exemple de ce type de réponse, où project-number est le numéro de votre projet et operation-id est l'ID de l'opération de longue durée créée pour la requête. Par exemple : VOT12345....

Réponse

{
  "name": "projects/project-number/locations/location-id/datasets/operation-id",
  "displayName": "my_dataset_01",
  "createTime": "2020-02-18T21:18:13.975412Z",
  "videoObjectTrackingDatasetMetadata": {}
}

Java

Pour vous authentifier auprès du suivi des objets AutoML Video, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

import com.google.cloud.automl.v1beta1.AutoMlClient;
import com.google.cloud.automl.v1beta1.Dataset;
import com.google.cloud.automl.v1beta1.LocationName;
import com.google.cloud.automl.v1beta1.VideoObjectTrackingDatasetMetadata;
import java.io.IOException;

class VideoObjectTrackingCreateDataset {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String displayName = "YOUR_DATASET_NAME";
    createDataset(projectId, displayName);
  }

  // Create a dataset
  static void createDataset(String projectId, String displayName) throws IOException {
    // 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 (AutoMlClient client = AutoMlClient.create()) {
      // A resource that represents Google Cloud Platform location.
      LocationName projectLocation = LocationName.of(projectId, "us-central1");
      VideoObjectTrackingDatasetMetadata metadata =
          VideoObjectTrackingDatasetMetadata.newBuilder().build();
      Dataset dataset =
          Dataset.newBuilder()
              .setDisplayName(displayName)
              .setVideoObjectTrackingDatasetMetadata(metadata)
              .build();

      Dataset createdDataset = client.createDataset(projectLocation, dataset);

      // Display the dataset information.
      System.out.format("Dataset name: %s%n", createdDataset.getName());
      // To get the dataset id, you have to parse it out of the `name` field. As dataset Ids are
      // required for other methods.
      // Name Form: `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`
      String[] names = createdDataset.getName().split("/");
      String datasetId = names[names.length - 1];
      System.out.format("Dataset id: %s%n", datasetId);
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const displayName = 'YOUR_DISPLAY_NAME';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1beta1;

// Instantiates a client
const client = new AutoMlClient();

async function createDataset() {
  // Construct request
  const request = {
    parent: client.locationPath(projectId, location),
    dataset: {
      displayName: displayName,
      videoObjectTrackingDatasetMetadata: {},
    },
  };

  // Create dataset
  const [response] = await client.createDataset(request);

  console.log(`Dataset name: ${response.name}`);
  console.log(`
    Dataset id: ${
      response.name
        .split('/')
        [response.name.split('/').length - 1].split('\n')[0]
    }`);
}

createDataset();

Python

from google.cloud import automl_v1beta1 as automl

def create_dataset(
    project_id="YOUR_PROJECT_ID", display_name="your_datasets_display_name"
):
    """Create a automl video object tracking dataset."""
    client = automl.AutoMlClient()

    # A resource that represents Google Cloud Platform location.
    project_location = f"projects/{project_id}/locations/us-central1"
    metadata = automl.VideoObjectTrackingDatasetMetadata()
    dataset = automl.Dataset(
        display_name=display_name,
        video_object_tracking_dataset_metadata=metadata,
    )

    # Create a dataset with the dataset metadata in the region.
    created_dataset = client.create_dataset(parent=project_location, dataset=dataset)
    # Display the dataset information
    print(f"Dataset name: {created_dataset.name}")
    print("Dataset id: {}".format(created_dataset.name.split("/")[-1]))

Importer des éléments dans un ensemble de données

Une fois que vous avez créé un ensemble de données, vous pouvez importer des données étiquetées à partir de fichiers CSV stockés dans un bucket Cloud Storage. Pour plus de détails sur la préparation des données et la création d'un fichier CSV à importer, consultez la page Préparer les données d'entraînement.

Vous pouvez importer des éléments dans un ensemble de données vide, ou importer des éléments supplémentaires dans un ensemble de données existant.

UI Web

En règle générale, vous importez vos données lorsque vous créez votre ensemble de données.

Toutefois, si vous devez importer les données après avoir créé votre ensemble de données, procédez comme suit :

Ouvrez l'interface utilisateur d'AutoML Video Object Tracking. La page Datasets (Ensembles de données) indique l'état des ensembles de données créés précédemment pour le projet en cours.
Dans la liste, cliquez sur l'ensemble de données dans lequel vous souhaitez importer des données.
Dans l'onglet Import (Importer), indiquez l'URI Cloud Storage du fichier CSV contenant les URI de vos données d'entraînement, sans le préfixe gs:// au début.
Toujours dans l'onglet Importer de votre ensemble de données, cliquez sur Continuer pour commencer l'importation.

REST

Pour importer vos données d'entraînement, utilisez la méthode importData. Cette méthode nécessite de fournir deux paramètres :

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

dataset-id : ID de votre ensemble de données. L'ID correspond au dernier élément du nom de l'ensemble de données. Exemple :
- Nom de l'ensemble de données : projects/project-number/locations/location-id/datasets/3104518874390609379
- ID de l'ensemble de données : 3104518874390609379
bucket-name : remplacez cette valeur par le nom du bucket Cloud Storage dans lequel vous avez stocké le fichier CSV de votre liste de fichiers d'entraînement de modèle.
csv-file-name : remplacez cette valeur par le nom du fichier CSV de votre liste de fichiers d'entraînement de modèle.
Remarque :
- project-number : numéro de votre projet.
- location-id : région cloud dans laquelle l'annotation doit avoir lieu. Les régions cloud compatibles sont les suivantes : us-east1, us-west1, europe-west1 et asia-east1. Si aucune région n'est spécifiée, une région sera déterminée en fonction de l'emplacement du fichier vidéo.

Méthode HTTP et URL :

POST https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/datasets/dataset-id:importData

Corps JSON de la requête :

{
  "inputConfig": {
    "gcsSource": {
      "inputUris": ["gs://bucket-name/csv-file-name.csv"]
    }
  }
}

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-number" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/datasets/dataset-id:importData"

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-number" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/datasets/dataset-id:importData" | Select-Object -Expand Content

Vous devez recevoir un ID d'opération pour l'opération d'importation des données. L'exemple montre une réponse contenant l'ID de l'opération d'importation VOT7506374678919774208.

Réponse

{
  "name": "projects/project-number/locations/location-id/operations/VOT7506374678919774208",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2020-02-18T21:23:15.181451Z",
    "updateTime": "2020-02-18T21:23:15.181451Z",
    "importDataDetails": {}
  }
}

Java

import com.google.api.gax.longrunning.OperationFuture;
import com.google.api.gax.retrying.RetrySettings;
import com.google.cloud.automl.v1beta1.AutoMlClient;
import com.google.cloud.automl.v1beta1.AutoMlSettings;
import com.google.cloud.automl.v1beta1.DatasetName;
import com.google.cloud.automl.v1beta1.GcsSource;
import com.google.cloud.automl.v1beta1.InputConfig;
import com.google.cloud.automl.v1beta1.OperationMetadata;
import com.google.protobuf.Empty;
import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.threeten.bp.Duration;

class ImportDataset {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String datasetId = "YOUR_DATASET_ID";
    String path = "gs://BUCKET_ID/path_to_training_data.csv";
    importDataset(projectId, datasetId, path);
  }

  // Import a dataset
  static void importDataset(String projectId, String datasetId, String path)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    Duration totalTimeout = Duration.ofMinutes(45);
    RetrySettings retrySettings = RetrySettings.newBuilder().setTotalTimeout(totalTimeout).build();
    AutoMlSettings.Builder builder = AutoMlSettings.newBuilder();
    builder.importDataSettings().setRetrySettings(retrySettings).build();
    AutoMlSettings settings = builder.build();

    // 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 (AutoMlClient client = AutoMlClient.create(settings)) {
      // Get the complete path of the dataset.
      DatasetName datasetFullId = DatasetName.of(projectId, "us-central1", datasetId);

      // Get multiple Google Cloud Storage URIs to import data from
      GcsSource gcsSource =
          GcsSource.newBuilder().addAllInputUris(Arrays.asList(path.split(","))).build();

      // Import data from the input URI
      InputConfig inputConfig = InputConfig.newBuilder().setGcsSource(gcsSource).build();
      System.out.println("Processing import...");

      // Start the import job
      OperationFuture<Empty, OperationMetadata> operation =
          client.importDataAsync(datasetFullId, inputConfig);

      System.out.format("Operation name: %s%n", operation.getName());

      // If you want to wait for the operation to finish, adjust the timeout appropriately. The
      // operation will still run if you choose not to wait for it to complete. You can check the
      // status of your operation using the operation's name.
      Empty response = operation.get(45, TimeUnit.MINUTES);
      System.out.format("Dataset imported. %s%n", response);
    } catch (TimeoutException e) {
      System.out.println("The operation's polling period was not long enough.");
      System.out.println("You can use the Operation's name to get the current status.");
      System.out.println("The import job is still running and will complete as expected.");
      throw e;
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const datasetId = 'YOUR_DISPLAY_ID';
// const path = 'gs://BUCKET_ID/path_to_training_data.csv';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1beta1;

// Instantiates a client
const client = new AutoMlClient();

async function importDataset() {
  // Construct request
  const request = {
    name: client.datasetPath(projectId, location, datasetId),
    inputConfig: {
      gcsSource: {
        inputUris: path.split(','),
      },
    },
  };

  // Import dataset
  console.log('Proccessing import');
  const [operation] = await client.importData(request);

  // Wait for operation to complete.
  const [response] = await operation.promise();
  console.log(`Dataset imported: ${response}`);
}

importDataset();

Python

from google.cloud import automl_v1beta1 as automl

def import_dataset(
    project_id="YOUR_PROJECT_ID",
    dataset_id="YOUR_DATASET_ID",
    path="gs://YOUR_BUCKET_ID/path/to/data.csv",
):
    """Import a dataset."""
    client = automl.AutoMlClient()
    # Get the full path of the dataset.
    dataset_full_id = client.dataset_path(project_id, "us-central1", dataset_id)
    # Get the multiple Google Cloud Storage URIs
    input_uris = path.split(",")
    gcs_source = automl.GcsSource(input_uris=input_uris)
    input_config = automl.InputConfig(gcs_source=gcs_source)
    # Import data from the input URI
    response = client.import_data(name=dataset_full_id, input_config=input_config)

    print("Processing import...")
    print(f"Data imported. {response.result()}")

Appliquer des étiquettes aux éléments d'entraînement

Chaque élément d'un ensemble de données doit contenir au moins un cadre de délimitation et être associé à au moins une étiquette de catégorie pour pouvoir servir à l'entraînement d'un modèle. Vous pouvez fournir des étiquettes et des cadres de délimitation pour vos éléments d'entraînement de deux manières :

Incluez des étiquettes et des cadres de délimitation dans votre fichier CSV.
Appliquez des étiquettes et des cadres de délimitation à vos éléments dans l'interface utilisateur d'AutoML Video Object Tracking.

Pour savoir comment attribuer des étiquettes aux éléments dans votre fichier CSV, consultez la page Préparer les données d'entraînement.

Pour appliquer des étiquettes à des éléments dans l'interface utilisateur d'AutoML Video Object Tracking, sélectionnez un ensemble de données sur la page où ils sont répertoriés afin d'afficher les détails correspondants. Le nom à afficher de l'ensemble de données sélectionné s'affiche dans la barre de titre. La page répertorie chaque élément de l'ensemble de données et l'étiquette correspondante. La barre de navigation de gauche récapitule le nombre d'éléments avec et sans étiquette. Elle vous permet également de filtrer la liste d'éléments par étiquette.

Vidéos dans un ensemble de données

Pour attribuer des étiquettes et des cadres de délimitation à des vidéos sans étiquette ou pour modifier les étiquettes et les cadres de délimitation des vidéos, procédez comme suit :

Sur la page de l'ensemble de données, cliquez sur la vidéo pour laquelle vous souhaitez ajouter des étiquettes.
Sur la page de la vidéo, procédez comme suit :
1. Lancez la vidéo jusqu'à ce que l'élément auquel vous souhaitez ajouter une étiquette apparaisse.
2. Faites glisser le curseur pour tracer un cadre de délimitation autour de l'élément.
3. Après avoir tracé le cadre de délimitation, sélectionnez l'étiquette que vous souhaitez utiliser.
4. Cliquez sur Enregistrer.

Traçage d'un cadre de délimitation autour d'une vache dans une vidéo

Si vous devez ajouter une étiquette à l'ensemble de données, cliquez sur les trois points à côté de la rubrique Filter labels (Filtrer les étiquettes), puis sur Add new label (Ajouter une étiquette) au-dessus de la liste des étiquettes existantes sur la page de l'ensemble de données.

Modifier des étiquettes dans les données

Vous pouvez également modifier les étiquettes appliquées aux vidéos d'un ensemble de données. Dans l'interface utilisateur d'AutoML Video Object Tracking, procédez comme suit :

Sur la page de l'ensemble de données, cliquez sur la vidéo dont vous souhaitez modifier les étiquettes.
Sur la page de la vidéo, procédez comme suit :
1. Dans la liste des étiquettes sur la gauche, sélectionnez celle que vous souhaitez modifier.
2. Dans l'aperçu de la vidéo, effectuez un clic droit sur le cadre de délimitation de la vidéo et sélectionnez l'étiquette de votre choix.
3. Cliquez sur Enregistrer.

Modification de l'étiquette appliquée à la berline dans une vidéo

Répertorier les ensembles de données

Un projet peut inclure de nombreux ensembles de données. Cette section explique comment récupérer la liste des ensembles de données disponibles pour un projet.

UI Web

Pour afficher la liste des ensembles de données disponibles à l'aide de l'interface utilisateur d'AutoML Video Object Tracking, accédez à la page Ensembles de données.

Liste des ensembles de données du projet

Pour afficher les ensembles de données d'un autre projet, sélectionnez le projet dans la liste déroulante située dans l'angle supérieur droit de la barre de titre.

REST

Utilisez les commandes curl ou PowerShell suivantes pour obtenir la liste de vos ensembles de données et le nombre d'échantillons vidéo qui y ont été importés.

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

project-number : numéro de votre projet.
location-id : région cloud dans laquelle l'annotation doit avoir lieu. Les régions cloud compatibles sont les suivantes : us-east1, us-west1, europe-west1 et asia-east1. Si aucune région n'est spécifiée, une région sera déterminée en fonction de l'emplacement du fichier vidéo.

Méthode HTTP et URL :

GET https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/datasets

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

curl

exécutez la commande suivante :

curl -X GET \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "x-goog-user-project: project-number" \
    "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/datasets
"

PowerShell

exécutez la commande suivante :

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

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/datasets
" | Select-Object -Expand Content

Dans la réponse ci-dessous, VOT3940649673949184000 est l'ID de l'opération de longue durée créée pour la requête et fourni dans la réponse lorsque vous avez lancé l'opération.

Réponse

{
  "datasets": [
    {
      "name": "projects/project-number/locations/location-id/datasets/VOT3940649673949184000",
      "displayName": "my_dataset_01",
      "createTime": "2020-02-18T21:18:13.975412Z",
      "exampleCount": 5097,
      "videoObjectTrackingDatasetMetadata": {}
    }
  ]
}

Java

import com.google.cloud.automl.v1beta1.AutoMlClient;
import com.google.cloud.automl.v1beta1.Dataset;
import com.google.cloud.automl.v1beta1.ListDatasetsRequest;
import com.google.cloud.automl.v1beta1.LocationName;
import java.io.IOException;

class ListDatasets {

  static void listDatasets() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    listDatasets(projectId);
  }

  // List the datasets
  static void listDatasets(String projectId) throws IOException {
    // 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 (AutoMlClient client = AutoMlClient.create()) {
      // A resource that represents Google Cloud Platform location.
      LocationName projectLocation = LocationName.of(projectId, "us-central1");
      ListDatasetsRequest request =
          ListDatasetsRequest.newBuilder().setParent(projectLocation.toString()).build();

      // List all the datasets available in the region by applying filter.
      System.out.println("List of datasets:");
      for (Dataset dataset : client.listDatasets(request).iterateAll()) {
        // Display the dataset information
        System.out.format("%nDataset name: %s%n", dataset.getName());
        // To get the dataset id, you have to parse it out of the `name` field. As dataset Ids are
        // required for other methods.
        // Name Form: `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`
        String[] names = dataset.getName().split("/");
        String retrievedDatasetId = names[names.length - 1];
        System.out.format("Dataset id: %s%n", retrievedDatasetId);
        System.out.format("Dataset display name: %s%n", dataset.getDisplayName());
        System.out.println("Dataset create time:");
        System.out.format("\tseconds: %s%n", dataset.getCreateTime().getSeconds());
        System.out.format("\tnanos: %s%n", dataset.getCreateTime().getNanos());

        System.out.format(
            "Video object tracking dataset metadata: %s%n",
            dataset.getVideoObjectTrackingDatasetMetadata());
      }
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1beta1;

// Instantiates a client
const client = new AutoMlClient();

async function listDatasets() {
  // Construct request
  const request = {
    parent: client.locationPath(projectId, location),
    filter: 'translation_dataset_metadata:*',
  };

  const [response] = await client.listDatasets(request);

  console.log('List of datasets:');
  for (const dataset of response) {
    console.log(`Dataset name: ${dataset.name}`);
    console.log(
      `Dataset id: ${
        dataset.name.split('/')[dataset.name.split('/').length - 1]
      }`
    );
    console.log(`Dataset display name: ${dataset.displayName}`);
    console.log('Dataset create time');
    console.log(`\tseconds ${dataset.createTime.seconds}`);
    console.log(`\tnanos ${dataset.createTime.nanos / 1e9}`);

    console.log(
      `Video object tracking dataset metadata: ${dataset.videoObjectTrackingDatasetMetadata}`
    );
  }
}

listDatasets();

Python

from google.cloud import automl_v1beta1 as automl

def list_datasets(project_id="YOUR_PROJECT_ID"):
    """List datasets."""
    client = automl.AutoMlClient()
    # A resource that represents Google Cloud Platform location.
    project_location = f"projects/{project_id}/locations/us-central1"

    # List all the datasets available in the region.
    request = automl.ListDatasetsRequest(parent=project_location, filter="")
    response = client.list_datasets(request=request)

    print("List of datasets:")
    for dataset in response:
        print(f"Dataset name: {dataset.name}")
        print("Dataset id: {}".format(dataset.name.split("/")[-1]))
        print(f"Dataset display name: {dataset.display_name}")
        print(f"Dataset create time: {dataset.create_time}")
        print(
            "Video object tracking dataset metadata: {}".format(
                dataset.video_object_tracking_dataset_metadata
            )
        )

Supprimer un ensemble de données

Le code suivant montre comment supprimer un ensemble de données.

UI Web

Accédez à la page Ensembles de données dans l'interface utilisateur d'AutoML Video Object Tracking.
Cliquez sur le menu à trois points à l'extrémité droite de la ligne à supprimer, puis sélectionnez Supprimer l'ensemble de données.
Cliquez sur Supprimer dans la boîte de dialogue de confirmation.

REST

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

project-number : numéro de votre projet.
location-id : région cloud dans laquelle l'annotation doit avoir lieu. Les régions cloud compatibles sont les suivantes : us-east1, us-west1, europe-west1 et asia-east1. Si aucune région n'est spécifiée, une région sera déterminée en fonction de l'emplacement du fichier vidéo.
datase-id : remplacez cette valeur par l'identifiant de votre ensemble de données.

Méthode HTTP et URL :

DELETE https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/datasets/dataset-id

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

exécutez la commande suivante :

curl -X DELETE \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "x-goog-user-project: project-number" \
    "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/datasets/dataset-id"

PowerShell (Windows)

exécutez la commande suivante :

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

Invoke-WebRequest `
    -Method DELETE `
    -Headers $headers `
    -Uri "https://automl.googleapis.com/v1beta1/projects/project-number/locations/location-id/datasets/dataset-id" | Select-Object -Expand Content

Vous devriez recevoir un code d'état indiquant le succès de l'opération (2xx), ainsi qu'une réponse vide.

Java

import com.google.cloud.automl.v1beta1.AutoMlClient;
import com.google.cloud.automl.v1beta1.DatasetName;
import com.google.protobuf.Empty;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class DeleteDataset {

  static void deleteDataset() throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String datasetId = "YOUR_DATASET_ID";
    deleteDataset(projectId, datasetId);
  }

  // Delete a dataset
  static void deleteDataset(String projectId, String datasetId)
      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 (AutoMlClient client = AutoMlClient.create()) {
      // Get the full path of the dataset.
      DatasetName datasetFullId = DatasetName.of(projectId, "us-central1", datasetId);
      Empty response = client.deleteDatasetAsync(datasetFullId).get();
      System.out.format("Dataset deleted. %s%n", response);
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const datasetId = 'YOUR_DATASET_ID';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1beta1;

// Instantiates a client
const client = new AutoMlClient();

async function deleteDataset() {
  // Construct request
  const request = {
    name: client.datasetPath(projectId, location, datasetId),
  };

  const [operation] = await client.deleteDataset(request);

  // Wait for operation to complete.
  const [response] = await operation.promise();
  console.log(`Dataset deleted: ${response}`);
}

deleteDataset();

Python

from google.cloud import automl_v1beta1 as automl

def delete_dataset(project_id="YOUR_PROJECT_ID", dataset_id="YOUR_DATASET_ID"):
    """Delete a dataset."""
    client = automl.AutoMlClient()
    # Get the full path of the dataset
    dataset_full_id = client.dataset_path(project_id, "us-central1", dataset_id)
    response = client.delete_dataset(name=dataset_full_id)

    print(f"Dataset deleted. {response.result()}")