Cette ancienne version de l'étiquetage de données AI Platform est obsolète et ne sera plus disponible sur Google Cloud après le 23 janvier 2024. Toutes les anciennes fonctionnalités d'AI Platform d'étiquetage de données ainsi que les nouvelles sont disponibles sur la plate-forme Vertex AI. Consultez la page Migrer vers Vertex AI pour savoir comment migrer vos ressources.

Créer des ensembles de données

Un ensemble de données est la collection d'éléments de données que les étiqueteurs doivent étiqueter manuellement. Il contient des échantillons représentatifs que vous souhaitez classer ou analyser. Un ensemble de données correctement étiqueté peut permettre d'entraîner un modèle personnalisé.

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

Importez les éléments de données dans un bucket Cloud Storage.
Créez un fichier CSV (valeurs séparées par une virgule) qui catalogue les éléments de données, puis importez-le dans le même bucket Cloud Storage.
Créez une ressource d'ensemble de données.
Importez les éléments de données dans la ressource d'ensemble de données.

Un projet peut comporter plusieurs ensembles de données, chacun étant utilisé pour une requête différente envoyée au service d'étiquetage de données AI Platform. Vous pouvez obtenir la liste des ensembles de données disponibles et supprimer ceux dont vous n'avez plus besoin. Pour en savoir plus, consultez la page concernant les ressources d'ensembles de données.

Entreposer les données sans étiquette

La première étape de la création d'un ensemble de données consiste à importer les éléments de données dans un bucket Cloud Storage à des fins d'étiquetage. Pour en savoir plus sur la création d'un bucket, consultez la page Avant de commencer.

Le service d'étiquetage de données permet d'étiqueter trois types de données. Vous pouvez développer les sections ci-dessous pour découvrir en détail comment fournir des éléments de données de qualité pour chaque type. Actuellement, seuls les ensembles de données en anglais peuvent être étiquetés.

Images

Les images doivent utiliser un type de fichier compatible :

JPEG
PNG

La taille maximale des fichiers est de 30 Mo pour tous les cas d'étiquetage d'image, à l'exception de la segmentation d'image, pour laquelle la taille maximale des fichiers est de 10 Mo.

Les dimensions maximales d'une image sont de 1920 x 1080 pixels.

Les données d'entraînement doivent être aussi proches que possible des données sur lesquelles les prédictions sont fondées. Par exemple, si votre cas pratique implique des images floues en basse résolution (comme celles d'une caméra de sécurité), vos données d'entraînement doivent être composées d'images floues à basse résolution. En général, il est recommandé de fournir également différents angles, résolutions et arrière-plans pour vos images d'entraînement.

L'entraînement d'un modèle fonctionne mieux lorsqu'il existe au maximum 100 fois plus d'images pour l'étiquette la plus courante que pour la plus rare. Nous recommandons de supprimer les étiquettes les moins fréquentes.

Vidéo

Les vidéos doivent être au format MP4 et encodées en H.264, H.265 ou MPEG4. La taille maximale des vidéos est de 2 Go.

Les données d'entraînement doivent être aussi proches que possible des données sur lesquelles les prédictions sont fondées. Par exemple, si votre cas pratique implique des vidéos floues en basse résolution (comme celles d'une caméra de sécurité), vos données d'entraînement doivent être composées de vidéos floues à basse résolution. En général, il est également recommandé de fournir différents types d'angles, de résolutions et d'arrière-plans pour les vidéos d'entraînement.

Nous recommandons environ 1000 vidéos d'entraînement par étiquette. Le nombre minimal de vidéos requis par étiquette est de 10, ou de 50 pour les modèles avancés. En général, l'entraînement de modèles avec plusieurs étiquettes par vidéo nécessite davantage d'exemples par étiquette, et les résultats sont plus difficiles à interpréter.

Le modèle fonctionne mieux lorsqu'il existe au maximum 100 fois plus de vidéos pour l'étiquette la plus courante que pour la plus rare. Nous recommandons de supprimer les étiquettes les moins fréquentes.

Texte

Les fichiers texte doivent utiliser le format d'encodage UTF-8.

Chaque document doit être un fichier texte distinct. Vous ne pouvez pas fournir plusieurs documents dans un même fichier texte. Par exemple, vous ne pouvez pas traiter chaque ligne d'un fichier texte comme son propre document.

Le nombre maximal de caractères par fichier texte est de 100 000.

Essayez d'utiliser des données d'entraînement aussi variées que les données sur lesquelles les prédictions sont fondées. Les ensembles de données doivent contenir des documents de différentes longueurs, des documents écrits par des auteurs différents, des documents rédigés dans des styles différents ou avec des formulations différentes, etc.

Nous recommandons de fournir au moins 1 000 documents d'entraînement par étiquette. Le nombre minimum de documents par étiquette est de 10. Cependant, vous pouvez améliorer le score de confiance du modèle en utilisant davantage d'exemples par étiquette. Les scores de confiance élevés sont particulièrement utiles lorsque le modèle renvoie plusieurs étiquettes pour classer un document.

Le modèle fonctionne de manière optimale s'il existe au maximum 100 fois plus de documents pour l'étiquette la plus courante que pour la plus rare. Nous recommandons de supprimer les étiquettes les moins fréquentes.

Créer le fichier CSV d'entrée

Outre les exemples d'éléments de données, vous devez également créer un fichier CSV (valeurs séparées par des virgules) cataloguant toutes les données. Le fichier .csv peut porter n'importe quel nom, doit être encodé en UTF-8 et doit se terminer par une extension .csv.

Pour les données de type "image" et "vidéo", chaque ligne du fichier CSV correspond à l'emplacement (dans le bucket Google Cloud Storage de votre projet) d'une image ou d'une vidéo. Exemple :

gs://my_project_bucket/image1.png
gs://my_project_bucket/image2.png
gs://my_project_bucket/image3.png
gs://my_project_bucket/image4.png

Pour les données textuelles, chaque ligne du fichier CSV correspond à l'emplacement de stockage d'un fichier texte. Exemple :

gs://my_project_bucket/file1.txt
gs://my_project_bucket/file2.txt
gs://my_project_bucket/file3.txt
gs://my_project_bucket/file4.txt

Chaque fichier de données doit contenir les données que vous souhaitez étiqueter. Le contenu de chaque fichier de données est présenté aux étiqueteurs sous la forme d'une "question d'étiquetage" unique.

Après avoir créé le fichier CSV qui catalogue les éléments de données, importez-le dans le même bucket Cloud Storage que les éléments de données.

Créer la ressource d'ensemble de données

L'étape suivante consiste à créer une ressource d'ensemble de données qui contiendra à terme les éléments de données. Ce nouvel ensemble de données reste vide tant que vous ne procédez pas à l'étape suivante d'importation des éléments de données.

UI Web

Dans l'UI du service d'étiquetage de données, vous créez un ensemble de données, puis y importez des éléments à partir de la même page.

Ouvrez l'interface utilisateur du service d'étiquetage des données.

La page 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 dernier dans la liste déroulante située dans l'angle supérieur droit de la barre de titre.
Cliquez sur le bouton Créer dans la barre de titre.
Sur la page Ajouter un ensemble de données, saisissez un nom et une description pour l'ensemble de données.
Dans la liste déroulante Type d'ensemble de données, choisissez le type d'éléments de données que vous avez ajoutés dans cet ensemble de données : images, vidéos ou texte.
Dans la zone Emplacement du fichier CSV, saisissez le chemin d'accès complet au fichier CSV d'entrée.

Le fichier CSV doit se trouver dans le même bucket Google Cloud Storage que les éléments de données qu'il répertorie.
Cliquez sur Créer.

Vous êtes redirigé vers la page Ensembles de données, et votre ensemble de données affiche un état en cours pendant l'importation de vos documents. Ce processus prend environ 10 minutes pour 1 000 éléments, ce délai restant indicatif et pouvant évoluer à la hausse ou à la baisse.

Si le service renvoie une erreur 405, réduisez le nombre de documents que vous importez simultanément. Vous devez actualiser la page avant de faire une nouvelle tentative.

Ligne de commande

L'exemple suivant crée un ensemble de données nommé test_dataset. Ce nouvel ensemble de données ne contient aucune donnée tant que vous n'y avez pas importé 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.

curl -X POST \
   -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
   -H "Content-Type: application/json" \
   https://datalabeling.googleapis.com/v1beta1/projects/${PROJECT_ID}/datasets \
   -d '{
     "dataset": {
     "displayName": "test_dataset",
     "description": "dataset for curl commands testing",
     },
   }'

Le résultat obtenu doit ressembler à ceci :

{
  "name": "projects/data-labeling-codelab/datasets/5c897e1e_0000_2ab5_9159_94eb2c0b4daa",
  "displayName": "test_dataset",
  "description": "dataset for curl commands testing",
  "createTime": "2019-03-14T03:11:50.926475415Z"
}

Python

Avant de pouvoir exécuter cet exemple de code, vous devez installer les bibliothèques clientes Python.

def create_dataset(project_id):
    """Creates a dataset for the given Google Cloud project."""
    from google.cloud import datalabeling_v1beta1 as datalabeling

    client = datalabeling.DataLabelingServiceClient()

    formatted_project_name = f"projects/{project_id}"

    dataset = datalabeling.Dataset(
        display_name="YOUR_DATASET_SET_DISPLAY_NAME", description="YOUR_DESCRIPTION"
    )

    response = client.create_dataset(
        request={"parent": formatted_project_name, "dataset": dataset}
    )

    # The format of resource name:
    # project_id/{project_id}/datasets/{dataset_id}
    print(f"The dataset resource name: {response.name}")
    print(f"Display name: {response.display_name}")
    print(f"Description: {response.description}")
    print("Create time:")
    print(f"\tseconds: {response.create_time.timestamp_pb().seconds}")
    print(f"\tnanos: {response.create_time.timestamp_pb().nanos}\n")

    return response

Java

Avant de pouvoir exécuter cet exemple de code, vous devez installer les bibliothèques clientes Java.

import com.google.cloud.datalabeling.v1beta1.CreateDatasetRequest;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceClient;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceSettings;
import com.google.cloud.datalabeling.v1beta1.Dataset;
import com.google.cloud.datalabeling.v1beta1.ProjectName;
import java.io.IOException;

class CreateDataset {

  // Create a dataset that is initially empty.
  static void createDataset(String projectId, String datasetName) throws IOException {
    // String projectId = "YOUR_PROJECT_ID";
    // String datasetName = "YOUR_DATASET_DISPLAY_NAME";

    DataLabelingServiceSettings settings =
        DataLabelingServiceSettings.newBuilder()
            .build();
    try (DataLabelingServiceClient dataLabelingServiceClient =
        DataLabelingServiceClient.create(settings)) {
      ProjectName projectName = ProjectName.of(projectId);

      Dataset dataset =
          Dataset.newBuilder()
              .setDisplayName(datasetName)
              .setDescription("YOUR_DESCRIPTION")
              .build();

      CreateDatasetRequest createDatasetRequest =
          CreateDatasetRequest.newBuilder()
              .setParent(projectName.toString())
              .setDataset(dataset)
              .build();

      Dataset createdDataset = dataLabelingServiceClient.createDataset(createDatasetRequest);

      System.out.format("Name: %s\n", createdDataset.getName());
      System.out.format("DisplayName: %s\n", createdDataset.getDisplayName());
      System.out.format("Description: %s\n", createdDataset.getDescription());
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Importer les éléments de données dans l'ensemble de données

Une fois que vous avez créé un ensemble de données, vous pouvez y importer des éléments de données à l'aide du fichier CSV.

UI Web

Dans l'UI du service d'étiquetage de données, vous pouvez ignorer cette étape, car l'importation a déjà été effectuée à l'étape précédente.

Ligne de commande

Remplacez DATASET_ID par l'ID de l'ensemble de données, issu de la réponse obtenue lorsque vous avez créé l'ensemble de données. L'ID s'affiche à la fin du nom complet de l'ensemble de données : projects/{project-id}/locations/us-central1/datasets/{dataset-id}

Remplacez CSV_FILE par le chemin d'accès complet au fichier CSV d'entrée.

curl -X POST \
   -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
   -H "Content-Type: application/json" \
   https://datalabeling.googleapis.com/v1beta1/projects/${PROJECT_ID}/datasets/${DATASET_ID}:importData \
   -d '{
     "inputConfig": {
       "dataType": "IMAGE",
       "gcsSource": {
          "inputUri": "${CSV_FILE}",
          "mimeType": "text/csv",
        }
       },
   }'

Des résultats semblables aux lignes suivantes devraient s'afficher : Vous pouvez obtenir l'état de la tâche à l'aide de l'ID d'opération. Obtenir l'état d'une opération en est un exemple.

{
  "name": "projects/data-labeling-codelab/operations/5c73dd6b_0000_2b34_a920_883d24fa2064",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.data-labeling.v1beta1.ImportDataOperationMetadata",
    "dataset": "projects/data-labeling-codelab/datasets/5c73db3d_0000_23e0_a25b_94eb2c119c4c"
  }
}

Python

Avant de pouvoir exécuter cet exemple de code, vous devez installer les bibliothèques clientes Python.

def import_data(dataset_resource_name, data_type, input_gcs_uri):
    """Imports data to the given Google Cloud project and dataset."""
    from google.cloud import datalabeling_v1beta1 as datalabeling

    client = datalabeling.DataLabelingServiceClient()

    gcs_source = datalabeling.GcsSource(input_uri=input_gcs_uri, mime_type="text/csv")

    csv_input_config = datalabeling.InputConfig(
        data_type=data_type, gcs_source=gcs_source
    )

    response = client.import_data(
        request={"name": dataset_resource_name, "input_config": csv_input_config}
    )

    result = response.result()

    # The format of resource name:
    # project_id/{project_id}/datasets/{dataset_id}
    print(f"Dataset resource name: {result.dataset}\n")

    return result

Java

Avant de pouvoir exécuter cet exemple de code, vous devez installer les bibliothèques clientes Java.

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceClient;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceSettings;
import com.google.cloud.datalabeling.v1beta1.DataType;
import com.google.cloud.datalabeling.v1beta1.GcsSource;
import com.google.cloud.datalabeling.v1beta1.ImportDataOperationMetadata;
import com.google.cloud.datalabeling.v1beta1.ImportDataOperationResponse;
import com.google.cloud.datalabeling.v1beta1.ImportDataRequest;
import com.google.cloud.datalabeling.v1beta1.InputConfig;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class ImportData {

  // Import data to an existing dataset.
  static void importData(String datasetName, String gcsSourceUri) throws IOException {
    // String datasetName = DataLabelingServiceClient.formatDatasetName(
    //     "YOUR_PROJECT_ID", "YOUR_DATASETS_UUID");
    // String gcsSourceUri = "gs://YOUR_BUCKET_ID/path_to_data";

    DataLabelingServiceSettings settings =
        DataLabelingServiceSettings.newBuilder()
            .build();
    try (DataLabelingServiceClient dataLabelingServiceClient =
        DataLabelingServiceClient.create(settings)) {
      GcsSource gcsSource =
          GcsSource.newBuilder().setInputUri(gcsSourceUri).setMimeType("text/csv").build();

      InputConfig inputConfig =
          InputConfig.newBuilder()
              .setDataType(DataType.IMAGE) // DataTypes: AUDIO, IMAGE, VIDEO, TEXT
              .setGcsSource(gcsSource)
              .build();

      ImportDataRequest importDataRequest =
          ImportDataRequest.newBuilder().setName(datasetName).setInputConfig(inputConfig).build();

      OperationFuture<ImportDataOperationResponse, ImportDataOperationMetadata> operation =
          dataLabelingServiceClient.importDataAsync(importDataRequest);

      ImportDataOperationResponse response = operation.get();

      System.out.format("Imported items: %d\n", response.getImportCount());
    } catch (IOException | InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }
  }
}

Afficher les éléments de données de l'ensemble de données

Pour afficher les éléments de données d'un ensemble de données importé, procédez comme suit :

Ouvrez l'interface utilisateur du service d'étiquetage des données.

La page Ensembles de données répertorie les ensembles de données traités par le service d'étiquetage de données pour le projet actuel.
Dans la liste des ensembles de données, cliquez sur le nom de celui dont vous souhaitez afficher les éléments.
Utilisez l'onglet Détails de la page Informations sur l'ensemble de données pour visualiser les éléments de données individuels inclus dans l'ensemble de données.