Richiedi Vertex AI Data Labeling Service

La qualità dei dati di addestramento influisce fortemente sull'efficacia del modello creato e, per estensione, sulla qualità delle previsioni restituite dal modello. La chiave per dati di addestramento di alta qualità è assicurarti di disporre di elementi di addestramento che rappresentino con precisione il dominio per cui vuoi fare delle previsioni e che siano etichettati con precisione.

Esistono tre modi per assegnare etichette agli elementi dei dati di addestramento:

  • Aggiungi gli elementi di dati al tuo set di dati con le etichette già assegnate, ad esempio utilizzando un set di dati disponibile in commercio
  • Assegna le etichette agli elementi di dati utilizzando la console Google Cloud
  • Richiedi agli etichettatori umani di aggiungere etichette agli elementi di dati

Le attività di etichettatura dei dati di Vertex AI consentono di lavorare con etichettatori umani per generare molto precise per una raccolta di dati che puoi utilizzare per addestrare modelli di machine learning.

Per informazioni sui prezzi dell'etichettatura dei dati, consulta Etichettatura dei dati.

Per richiedere l'etichettatura dei dati da parte di etichettatori umani, crea un job di etichettatura dei dati che fornisca agli etichettatori umani:

  • Il set di dati contenente gli elementi di dati rappresentativi da etichettare
  • Un elenco di tutte le possibili etichette da applicare agli elementi di dati
  • Un file PDF contenente le istruzioni che guidano gli etichettatori umani attraverso le attività di etichettatura

Utilizzando queste risorse, gli etichettatori umani annotano gli elementi del set di dati in base alle tue istruzioni. Al termine, puoi utilizzare il set di annotazioni per addestrare un modello Vertex AI o esportare gli elementi di dati etichettati da utilizzare in un altro ambiente di machine learning.

Crea un set di dati

Fornisci agli etichettatori umani gli elementi da etichettare creando un set di dati e importandovi elementi di dati. Gli elementi di dati non devono essere etichettati. Il tipo di dati (immagine, video o testo) e obiettivo (ad esempio, classificazione o monitoraggio di oggetti) determina il tipo di annotazioni a cui applicano gli etichettatori umani gli elementi di dati.

Fornisci etichette

Quando crei un'attività di etichettatura dei dati, elenchi l'insieme di etichette che vuoi che l'utente umano etichettatori da utilizzare per etichettare le immagini. Ad esempio, se vuoi classificare le immagini in base al fatto che includano un cane o un gatto, crea un insieme di etichette con due etichette: "Cane" e "Gatto". Come indicato nell'elenco che segue, potresti volere anche etichette per "Nessuno dei due" sia "Entrambi".

Di seguito sono riportate alcune linee guida per la creazione di un set di etichette di alta qualità.

  • Assegna a ogni etichetta un nome visualizzato significativo, ad esempio "cane", "gatto" o "edificio". Non utilizzare nomi astratti come "etichetta1" ed "etichetta2" o acronimo sconosciuti. Più significativi sono i nomi delle etichette, più è facile per gli etichettatori umani applicarle in modo accurato e coerente.
  • Assicurati che le etichette siano facilmente distinguibili l'una dall'altra. Per la classificazione in cui a ogni elemento dati viene applicata una singola etichetta, cerca di non usare le etichette i cui significati si sovrappongono. Ad esempio, non avere etichette per "Sport" e "Baseball".
  • Per le attività di classificazione, in genere è buona norma includere un'etichetta denominata "Altro" o "Nessuna" da utilizzare per i dati che non corrispondono alle altre etichette. Se solo le etichette disponibili sono "cane" e "gatto", ad esempio, gli etichettatori devono etichetta ogni immagine con una di queste etichette. Il modello personalizzato è in genere più affidabile se includi immagini diverse da cani o gatti nei dati di addestramento.
  • Tieni presente che gli etichettatori sono più efficienti e precisi quando sono definite al massimo 20 etichette nell'insieme di etichette. Puoi includere fino a 100 etichette.

Crea istruzioni

Le istruzioni forniscono agli etichettatori umani informazioni su come applicare le etichette i tuoi dati. Le istruzioni devono contenere dati etichettati di esempio e altre indicazioni esplicite.

Le istruzioni sono file PDF. Le istruzioni in PDF possono fornire direzioni sofisticate, come descrizioni o esempi positivi e negativi per ciascun caso. Il PDF è anche un formato conveniente per fornire istruzioni per attività complicate come riquadri di delimitazione delle immagini o monitoraggio di oggetti video.

Scrivi le istruzioni, crea un file PDF e salva il file PDF nel tuo nel bucket Cloud Storage.

Fornisci istruzioni efficaci

Le istruzioni corrette sono il fattore più importante per ottenere una buona etichettatura umana che consentono di analizzare i dati e visualizzare i risultati. Poiché conosci meglio il tuo caso d'uso, devi comunicare agli etichettatori umani cosa vuoi che facciano. Di seguito sono riportate alcune linee guida per creare buone istruzioni:

  • Gli etichettatori umani non conoscono il tuo dominio. La Le distinzioni che chiedi agli etichettatori devono essere facili da comprendere per qualcuno che non conoscono il tuo caso d'uso.

  • Evita di rendere le istruzioni troppo lunghe. È meglio che un etichettatore possa esaminare a comprendere le istruzioni entro 20 minuti.

  • Le istruzioni devono descrivere il concetto dell'attività e fornire dettagli sul come etichettare i dati. Ad esempio, per un'attività riquadro di delimitazione, descrivi come che gli etichettatori disegneranno il riquadro di delimitazione. Deve essere una scatola rigida o ? Se sono presenti più istanze dell'oggetto, devono essere disegnati uno o più riquadri di delimitazione?

  • Se alle tue istruzioni è impostata un'etichetta corrispondente, deve coprire tutte le etichette del set. Il nome dell'etichetta nelle istruzioni deve corrispondere al nome nell'insieme di etichette.

  • Spesso sono necessarie diverse iterazioni per creare istruzioni efficaci. Ti consigliamo di far lavorare gli etichettatori umani su un piccolo set di dati, quindi di modificare le istruzioni in base alla corrispondenza del loro lavoro alle tue aspettative.

Un buon file di istruzioni include le seguenti sezioni:

  • Elenco e descrizione delle etichette: un elenco di tutte le etichette che vuoi utilizzare e il significato di ciascuna.
  • Esempi: per ogni etichetta, fornisci almeno tre esempi positivi e uno negativo esempio. Questi esempi dovrebbero coprire casi diversi.
  • Coprire i casi limite. Per ridurre la necessità per l'etichettatore di interpretare l'etichetta, chiarisci il maggior numero possibile di casi limite. Ad esempio, se devi disegnare un riquadro di delimitazione per una persona, è meglio chiarire:
    • Se ci sono più persone, hai bisogno di una casella per ogni persona?
    • Se una persona è nascosta, ti serve una scatola?
    • Se nell'immagine è visibile anche solo una parte della persona, ti serve una casella?
    • Se una persona è in una foto o in un dipinto, hai bisogno di una casella?
  • Descrivi come aggiungere annotazioni. Ad esempio:
    • Per un riquadro di delimitazione, hai bisogno di una casella stretta o una casella larga?
    • Per l'estrazione delle entità di testo, dove deve iniziare e terminare l'entità interessata?
  • Chiarimento sulle etichette. Se due etichette sono simili o facili da confondere, assegna esempi per chiarire la differenza.

I seguenti esempi mostrano cosa potrebbero essere inclusi nelle istruzioni per i PDF. I titolisti esamineranno le istruzioni prima di iniziare l'attività.

Istruzioni PDF 1.

Istruzioni in formato PDF 2.

Crea un'attività di etichettatura dei dati

UI web

Puoi richiedere l'etichettatura dei dati dalla console Google Cloud.

  1. Nella console Google Cloud, vai alla pagina Attività di etichettatura.

    Vai alle attività di etichettatura

  2. Fai clic su Crea.

Si apre il riquadro Nuova attività di etichettatura.

  1. Inserisci un nome per l'attività di etichettatura.

  2. Seleziona il set di dati di cui vuoi etichettare gli elementi.

    Se hai aperto il riquadro Nuova attività di etichettatura dalla schermata dei dettagli del set di dati, non puoi selezionare un set di dati diverso.

  3. Verifica che lo scopo sia corretto.

    La casella Obiettivo mostra l'obiettivo per il set di dati selezionato, determinato dal suo set di annotazioni predefinito. Per modificare lo scopo, scegli un set di annotazioni diverso.

  4. Scegli il set di annotazioni da utilizzare per i dati etichettati.

    Le etichette applicate dagli etichettatori umani vengono salvate nel set di annotazioni selezionato. Puoi scegliere un set di annotazioni esistente o crearne uno nuovo uno. Se ne crei una nuova, devi assegnarle un nome.

  5. Specifica se utilizzare l'apprendimento attivo.

    L'apprendimento attivo accelera il processo di etichettatura facendo in modo che un etichettatore umano etichetti parte del set di dati, quindi applicando il machine learning per etichettare automaticamente il resto.

  6. Fai clic su Continua.

  7. Inserisci le etichette che gli etichettatori umani applicare. Per informazioni su sulla creazione di un insieme di etichette di alta qualità, consulta la sezione Progettazione di un set di etichette.

  8. Fai clic su Continua.

  9. Inserisci il percorso delle istruzioni per gli etichettatori umani. Le istruzioni devono essere un file PDF archiviato in un bucket Cloud Storage. Per informazioni su come creare istruzioni di alta qualità, consulta la sezione Creare istruzioni per gli etichettatori umani.

  10. Fai clic su Continua.

  11. Scegli se utilizzare Etichettatori gestiti da Google o Fornisci i tuoi etichettatori.

    • Se hai scelto di utilizzare gli etichettatori gestiti da Google, fai clic sulla casella di controllo per confermare di aver letto la guida ai prezzi per comprendere il costo dell'etichettatura.

    • Se fornisci i tuoi etichettatori, devi creare gruppi di etichettatori e gestire le proprie attività usando la console DataCompute. In caso contrario, scegli il gruppo di labeler da utilizzare per questa attività di etichettatura.

      Scegli un gruppo di etichettatori esistente dall'elenco a discesa o scegli Nuovo gruppo di labeler e inserisci un nome per il gruppo e un elenco di indirizzi email separati da virgole per gli amministratori del gruppo nelle caselle di testo sotto l'elenco a discesa. Clic la casella di controllo per concedere ai gestori specificati l'accesso alla visualizzazione dei tuoi dati informazioni sull'etichettatura.

  12. Specifica il numero di labeler che vuoi che esaminino ogni elemento.

    Per impostazione predefinita, un etichettatore umano annota ogni elemento di dati. Tuttavia, puoi richiedere di avere più labeler che annotano e rivedano ogni articolo. Seleziona il numero di etichettatori dalla casella Specialisti per elemento di dati.

  13. Fai clic su Avvia attività.

    Se Avvia attività non è disponibile, controlla le pagine all'interno della sezione Nuova etichettatura del riquadro delle attività per verificare di aver inserito tutte le informazioni richieste.

Puoi esaminare l'avanzamento dell'attività di etichettatura dei dati nella console Google Cloud dalla pagina Attività di etichettatura.

Vai ad Attività di etichettatura

La pagina mostra lo stato di ogni attività di etichettatura richiesta. Quando la colonna Avanzamento mostra il 100%, il set di dati corrispondente è etichettato e pronto per l'addestramento di un modello.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

  • PROJECT_ID: il tuo ID progetto
  • DISPLAY_NAME: nome del job di etichettatura dei dati
  • DATASET_ID: ID del set di dati contenente gli elementi da etichettare
  • LABELERS: il numero di etichettatori umani che vuoi che esaminino ogni elemento di dati. I valori validi sono 1, 3 e 5.
  • INSTRUCTIONS: il percorso del file PDF contenente le istruzioni per gli etichettatori umani. Il file deve trovarsi in un bucket Cloud Storage accessibile dal tuo progetto
  • INPUT_SCHEMA_URI: percorso del file dello schema per il tipo di elemento dati:
    • Classificazione delle immagini con etichetta singola:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/image_classification_single_label_io_format_1.0.0.yaml
    • Classificazione delle immagini con più etichette:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/image_classification_multi_label_io_format_1.0.0.yaml
    • Rilevamento di oggetti immagine:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/image_bounding_box_io_format_1.0.0.yaml
    • Classificazione del testo con etichetta singola:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_classification_single_label_io_format_1.0.0.yaml
    • Più etichette per la classificazione del testo:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_classification_multi_label_io_format_1.0.0.yaml
    • Estrazione delle entità di testo:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_extraction_io_format_1.0.0.yaml
    • Analisi del sentiment del testo:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_sentiment_io_format_1.0.0.yaml
    • Classificazione video:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/video_classification_io_format_1.0.0.yaml
    • Rilevamento di oggetti video:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/video_object_tracking_io_format_1.0.0.yaml
  • LABEL_LIST: un elenco di stringhe separate da virgole che elenca le etichette disponibili da applicare a un elemento di dati
  • ANNOTATION_SET: il nome del set di annotazioni per i dati etichettati

Metodo HTTP e URL: 

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/dataLabelingJobs

Corpo JSON della richiesta: 

{
   "displayName":"DISPLAY_NAME",
   "datasets":"DATASET_ID",
   "labelerCount":LABELERS,
   "instructionUri":"INSTRUCTIONS",
   "inputsSchemaUri":"INPUT_SCHEMA_URI",
   "inputs": {
     "annotation_specs": [LABEL_LIST]
   },
   "annotationLabels": {
     "aiplatform.googleapis.com/annotation_set_name": "ANNOTATION_SET"
   }
}

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_ID/locations/us-central1/dataLabelingJobs/JOB_ID",
  "displayName": "DISPLAY_NAME",
  "datasets": [
    "DATASET_ID"
  ],
  "labelerCount": LABELERS,
  "instructionUri": "INSTRUCTIONS",
  "inputsSchemaUri": "INPUT_SCHEMA_URI",
  "inputs": {
    "annotationSpecs": [
      LABEL_LIST
    ]
  },
  "state": "JOB_STATE_PENDING",
  "labelingProgress": "0",
  "createTime": "2020-05-30T23:13:49.121133Z",
  "updateTime": "2020-05-30T23:13:49.121133Z",
  "savedQuery": {
    "name": "projects/PROJECT_ID/locations/us-central1/datasets/DATASET_ID/savedQueries/ANNOTATION_SET_ID"
  },
  "annotationSpecCount": 2
}
La risposta è DataLabelingJob. Puoi controllare l'avanzamento del job monitorando l'elemento "labelingProgress", il cui valore è la percentuale completata.

Java

Altri esempi di codice:


import com.google.cloud.aiplatform.v1.DataLabelingJob;
import com.google.cloud.aiplatform.v1.DatasetName;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import com.google.type.Money;
import java.io.IOException;
import java.util.Map;

public class CreateDataLabelingJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String displayName = "YOUR_DATA_LABELING_DISPLAY_NAME";
    String datasetId = "YOUR_DATASET_ID";
    String instructionUri =
        "gs://YOUR_GCS_SOURCE_BUCKET/path_to_your_data_labeling_source/file.pdf";
    String inputsSchemaUri = "YOUR_INPUT_SCHEMA_URI";
    String annotationSpec = "YOUR_ANNOTATION_SPEC";
    createDataLabelingJob(
        project, displayName, datasetId, instructionUri, inputsSchemaUri, annotationSpec);
  }

  static void createDataLabelingJob(
      String project,
      String displayName,
      String datasetId,
      String instructionUri,
      String inputsSchemaUri,
      String annotationSpec)
      throws IOException {
    JobServiceSettings jobServiceSettings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .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 (JobServiceClient jobServiceClient = JobServiceClient.create(jobServiceSettings)) {
      String location = "us-central1";
      LocationName locationName = LocationName.of(project, location);

      String jsonString = "{\"annotation_specs\": [ " + annotationSpec + "]}";
      Value.Builder annotationSpecValue = Value.newBuilder();
      JsonFormat.parser().merge(jsonString, annotationSpecValue);

      DatasetName datasetName = DatasetName.of(project, location, datasetId);
      DataLabelingJob dataLabelingJob =
          DataLabelingJob.newBuilder()
              .setDisplayName(displayName)
              .setLabelerCount(1)
              .setInstructionUri(instructionUri)
              .setInputsSchemaUri(inputsSchemaUri)
              .addDatasets(datasetName.toString())
              .setInputs(annotationSpecValue)
              .putAnnotationLabels(
                  "aiplatform.googleapis.com/annotation_set_name", "my_test_saved_query")
              .build();

      DataLabelingJob dataLabelingJobResponse =
          jobServiceClient.createDataLabelingJob(locationName, dataLabelingJob);

      System.out.println("Create Data Labeling Job Response");
      System.out.format("\tName: %s\n", dataLabelingJobResponse.getName());
      System.out.format("\tDisplay Name: %s\n", dataLabelingJobResponse.getDisplayName());
      System.out.format("\tDatasets: %s\n", dataLabelingJobResponse.getDatasetsList());
      System.out.format("\tLabeler Count: %s\n", dataLabelingJobResponse.getLabelerCount());
      System.out.format("\tInstruction Uri: %s\n", dataLabelingJobResponse.getInstructionUri());
      System.out.format("\tInputs Schema Uri: %s\n", dataLabelingJobResponse.getInputsSchemaUri());
      System.out.format("\tInputs: %s\n", dataLabelingJobResponse.getInputs());
      System.out.format("\tState: %s\n", dataLabelingJobResponse.getState());
      System.out.format("\tLabeling Progress: %s\n", dataLabelingJobResponse.getLabelingProgress());
      System.out.format("\tCreate Time: %s\n", dataLabelingJobResponse.getCreateTime());
      System.out.format("\tUpdate Time: %s\n", dataLabelingJobResponse.getUpdateTime());
      System.out.format("\tLabels: %s\n", dataLabelingJobResponse.getLabelsMap());
      System.out.format(
          "\tSpecialist Pools: %s\n", dataLabelingJobResponse.getSpecialistPoolsList());
      for (Map.Entry<String, String> annotationLabelMap :
          dataLabelingJobResponse.getAnnotationLabelsMap().entrySet()) {
        System.out.println("\tAnnotation Level");
        System.out.format("\t\tkey: %s\n", annotationLabelMap.getKey());
        System.out.format("\t\tvalue: %s\n", annotationLabelMap.getValue());
      }
      Money money = dataLabelingJobResponse.getCurrentSpend();

      System.out.println("\tCurrent Spend");
      System.out.format("\t\tCurrency Code: %s\n", money.getCurrencyCode());
      System.out.format("\t\tUnits: %s\n", money.getUnits());
      System.out.format("\t\tNanos: %s\n", money.getNanos());
    }
  }
}

Python

Altri esempi di codice:

from google.cloud import aiplatform
from google.protobuf import json_format
from google.protobuf.struct_pb2 import Value


def create_data_labeling_job_sample(
    project: str,
    display_name: str,
    dataset_name: str,
    instruction_uri: str,
    inputs_schema_uri: str,
    annotation_spec: 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.gapic.JobServiceClient(client_options=client_options)
    inputs_dict = {"annotation_specs": [annotation_spec]}
    inputs = json_format.ParseDict(inputs_dict, Value())

    data_labeling_job = {
        "display_name": display_name,
        # Full resource name: projects/{project_id}/locations/{location}/datasets/{dataset_id}
        "datasets": [dataset_name],
        # labeler_count must be 1, 3, or 5
        "labeler_count": 1,
        "instruction_uri": instruction_uri,
        "inputs_schema_uri": inputs_schema_uri,
        "inputs": inputs,
        "annotation_labels": {
            "aiplatform.googleapis.com/annotation_set_name": "my_test_saved_query"
        },
    }
    parent = f"projects/{project}/locations/{location}"
    response = client.create_data_labeling_job(
        parent=parent, data_labeling_job=data_labeling_job
    )
    print("response:", response)

Passaggi successivi