Richiedi Vertex AI Data Labeling Service

Attenzione: Vertex AI Data Labeling Service (con etichettatori umani) è deprecato e non sarà più disponibile su Google Cloud dopo il 1° luglio 2024. Per le nuove attività di etichettatura, puoi utilizzare la possibilità di aggiungere etichette utilizzando la console Google Cloud o accedere alle soluzioni di etichettatura dei dati dei nostri partner in Google Cloud Console Marketplace, come Labelbox e Snorkel.

La qualità dei dati di addestramento influisce notevolmente sull'efficacia del modello creato e, di conseguenza, sulla qualità delle previsioni restituite da quel modello. La chiave per dati di addestramento di alta qualità è garantire che gli elementi di addestramento rappresentino accuratamente il dominio su cui vuoi fare previsioni e che gli elementi di addestramento siano etichettati in modo accurato.

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

• Aggiungi elementi al set di dati con le relative etichette già assegnate, ad esempio utilizzando un set di dati disponibile in commercio
• Assegnare etichette agli elementi di dati utilizzando la console Google Cloud
• Richiedere 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 etichette estremamente accurate per una raccolta di dati da utilizzare per addestrare i 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, puoi creare 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 nel 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 per utilizzarli in un altro ambiente di machine learning.

crea un set di dati

Per fornire agli etichettatori umani gli elementi da etichettare, devi creare un set di dati e importarvi elementi di dati. Gli elementi di dati non devono essere etichettati. Il tipo di dati (immagine, video o testo) e l'obiettivo (ad esempio, classificazione o monitoraggio degli oggetti) determinano il tipo di annotazioni che gli etichettatori umani applicano agli elementi di dati.

Fornisci etichette

Quando crei un'attività di etichettatura dei dati, elenchi l'insieme di etichette che vuoi che gli etichettatori umani utilizzino per etichettare le tue immagini. Ad esempio, se vuoi classificare le immagini in base al fatto che contengano un cane o un gatto, crei un set di etichette con due etichette: "Cane" e "Gatto". E, come indicato nell'elenco seguente, potresti volere etichette anche per "Nessuno" e "Entrambi".

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

• Rendi il nome visualizzato di ogni etichetta una parola significativa, ad esempio "cane", "gatto" o "edificio". Non usare nomi astratti come "label1" ed "label2" o acronimi sconosciuti. Più sono significativi i nomi delle etichette, più facile sarà per gli etichettatori umani applicarli in modo accurato e coerente.
• Assicurati che le etichette siano facilmente distinguibili l'una dall'altra. Per le attività di classificazione in cui a ogni elemento dati viene applicata una singola etichetta, cerca di non utilizzare etichette il cui significato si sovrappone. Ad esempio, non avere etichette per "Sport" e "Baseball".
• Per le attività di classificazione, di solito è una buona idea includere un'etichetta denominata"altro " o"nessuno", da utilizzare per i dati che non corrispondono alle altre etichette. Se le uniche etichette disponibili sono "cane" e "gatto", ad esempio, gli etichettatori devono etichettare ogni immagine con una di queste etichette. Il modello personalizzato è in genere più solido se includi immagini diverse da cani o gatti nei dati di addestramento.
• Tieni presente che gli etichettatori sono più efficienti e precisi se nel set di etichette sono definite al massimo 20 etichette. Puoi includere fino a 100 etichette.

Crea istruzioni

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

Le istruzioni sono file PDF. Le istruzioni in formato PDF possono fornire indicazioni sofisticate come descrizioni o esempi positivi e negativi per ogni caso. Il PDF è anche un formato pratico per fornire istruzioni per attività complicate come riquadri di delimitazione delle immagini o tracciamento di oggetti video.

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

Fornisci istruzioni efficaci

Le istruzioni corrette sono il fattore più importante per ottenere buoni risultati di etichettatura umana. Poiché conosci meglio il tuo caso d'uso, devi far sapere agli etichettatori umani cosa vuoi che facciano. Ecco alcune linee guida per creare istruzioni efficaci:

• Gli etichettatori umani non conoscono il tuo dominio. Le distinzioni che chiedi agli etichettatori di fare devono essere facilmente comprensibili per chi non conosce il tuo caso d'uso.

• Evita di rendere le istruzioni troppo lunghe. L'ideale è che un etichettatore possa esaminare e capire le istruzioni entro 20 minuti.

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

• Se le tue istruzioni hanno un set di etichette corrispondente, devono coprire tutte le etichette del set. Il nome dell'etichetta nelle istruzioni deve corrispondere a quello nel set di etichette.

• Spesso sono necessarie diverse iterazioni per creare istruzioni efficaci. Consigliamo che gli etichettatori umani lavorino prima su un set di dati di piccole dimensioni, poi modifichi le istruzioni in base al livello di corrispondenza del lavoro degli etichettatori alle tue aspettative.

Un file di istruzioni efficace include le seguenti sezioni:

• Elenco e descrizione delle etichette: un elenco di tutte le etichette che desideri utilizzare e il significato di ogni etichetta.
• Esempi: per ogni etichetta, fornisci almeno tre esempi positivi e un esempio negativo. Questi esempi dovrebbero riguardare diversi casi.
• Proteggi le custodie perimetrali. Per ridurre la necessità da parte dell'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, ti serve una casella per ognuna?
  • 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 è ritratta in un quadro o in un quadro, ti serve una scatola?
• Descrivi come aggiungere annotazioni. Ad esempio:
  • Come riquadro di delimitazione, hai bisogno di un riquadro stretto o sfuso?
  • Per l'estrazione delle entità di testo, dove devono iniziare e terminare l'entità interessata?
• Chiarimento sulle etichette. Se due etichette sono simili o facili da combinare, fornisci degli esempi per chiarire la differenza.

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

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 l'obiettivo sia corretto.

   La casella Obiettivo mostra l'obiettivo per il set di dati selezionato, come stabilito dal relativo set di annotazioni predefinito. Per modificare l'obiettivo, scegli un altro set di annotazioni.

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. Se ne crei una nuova, devi specificare un nome.

5. Specifica se utilizzare l'apprendimento attivo.

   L'apprendimento attivo accelera il processo di etichettatura tramite l'etichettatura di un etichettatore umano parte del tuo set di dati e applicando il machine learning per etichettare automaticamente il resto.

   Nota: l'apprendimento attivo è disponibile solo per gli obiettivi Classificazione delle immagini (etichetta singola) e riquadro di delimitazione delle immagini.

6. Fai clic su Continua.

7. Inserisci le etichette che gli etichettatori umani applicare. Per informazioni 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 sulla creazione di istruzioni di alta qualità, consulta la pagina Progettazione di 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 etichettatori gestiti da Google, fai clic sulla casella di controllo per confermare di aver letto la guida ai prezzi e comprendere i costi dell'etichettatura.

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

      Scegli un gruppo di etichettatori esistente dall'elenco a discesa oppure scegli Nuovo gruppo di etichettatori e inserisci un nome di gruppo e un elenco di indirizzi email separati da virgole per i gestori del gruppo nelle caselle di testo sotto l'elenco a discesa. Fai clic sulla casella di controllo per concedere ai gestori specificati l'accesso in modo da visualizzare le informazioni sull'etichettatura dei dati.

12. Specifica quanti etichettatori vuoi esaminare ogni elemento.

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

13. Fai clic su Avvia attività.

    Se l'opzione Avvia attività non è disponibile, controlla le pagine nel riquadro Nuova attività di etichettatura per verificare di aver inserito tutte le informazioni richieste.

Puoi rivedere lo stato di avanzamento dell'attività di etichettatura dei dati nella pagina Attività di etichettatura della console Google Cloud.

Vai alle attività di etichettatura

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

REST

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

• PROJECT_ID: il tuo ID progetto
• DISPLAY_NAME: nome del job di etichettatura dati
• DATASET_ID: ID del set di dati contenente gli elementi da etichettare
• LABELERS: il numero di etichettatori umani di cui vuoi che vengano esaminati ogni elemento 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 progetto
• INPUT_SCHEMA_URI: percorso del file di schema per il tipo di elemento di dati:
  • Etichetta singola per la classificazione delle immagini:
    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
  • Etichetta singola per classificazione del testo:
    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 elencano 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:

curl (Linux, macOS o Cloud Shell)

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti fa accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/dataLabelingJobs"

PowerShell (Windows)

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/dataLabelingJobs" | Select-Object -Expand Content

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 verificare l'avanzamento del job monitorando l'elemento "labelingProgress", il cui valore è la percentuale di completamento.

Java

Altri esempi di codice:

• Tramite l'apprendimento attivo

• Utilizzo di un pool di etichettatori personalizzati

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:

• Tramite l'apprendimento attivo

• Utilizzo di un pool di etichettatori personalizzati

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)

Nota: il tempo di risposta massimo per un job di etichettatura dei dati è di 63 giorni. Se i dati non vengono etichettati entro questo periodo di tempo, il job scade e viene eliminato insieme alle attività assegnate agli etichettatori.

Passaggi successivi

• Addestra un modello utilizzando AutoML.
• Addestra un modello utilizzando il codice di addestramento personalizzato.