Solicitar rotulagem de dados

A qualidade dos dados de treinamento tem forte impacto sobre a eficácia do modelo criado e, por consequência, sobre a qualidade das predições retornadas pelo modelo. A chave para dados de treinamento de alta qualidade é garantir que você tenha itens de treinamento que representam com precisão o domínio sobre o qual você quer fazer previsões e que os itens de treinamento estejam rotulados corretamente.

Há três maneiras de atribuir rótulos aos itens de dados de treinamento:

  • Adicione os itens de dados ao conjunto de dados com os rótulos já atribuídos, por exemplo, usando um conjunto de dados comercialmente disponível.
  • Atribuir rótulos aos itens de dados usando o console
  • Solicitação para que rotuladores humanos adicionem rótulos aos itens de dados

Com as tarefas de rotulagem de dados da Vertex AI, é possível trabalhar com rotuladores humanos para gerar rótulos altamente precisos para uma coleção de dados que pode ser usada para treinar modelos de machine learning.

Para solicitar a rotulagem de dados por rotuladores humanos, crie um job de rotulagem de dados que forneça aos rotuladores humanos:

  • O conjunto de dados que contém os itens de dados representativos a serem rotulados
  • Uma lista de todos os rótulos possíveis a serem aplicados aos itens de dados
  • Um arquivo PDF contendo instruções orientando os rotuladores humanos por meio de tarefas de rotulagem

Usando esses recursos, os rotuladores humanos anotam os itens no conjunto de dados de acordo com suas instruções. Quando terminarem, use o conjunto de anotações para treinar um modelo da Vertex AI ou exportar os itens de dados rotulados a serem usados em outro ambiente de machine learning.

crie um conjunto de dados

Para fornecer aos rotuladores humanos os itens de dados que serão rotulados, crie um conjunto de dados e importe os itens de dados para ele. Os itens de dados não precisam ser rotulados. O tipo de dados (imagem, vídeo ou texto) e o objetivo (por exemplo, classificação ou rastreamento de objetos) determinam o tipo de anotação que os rotuladores humanos aplicam aos itens de dados.

Inserir rótulos

Ao criar uma tarefa de rotulagem de dados, liste o conjunto de rótulos que você quer que os rotuladores humanos usem com suas imagens. Por exemplo, se você quiser classificar imagens com base no fato de elas conterem um cachorro ou um gato, crie um conjunto com dois rótulos: "Cachorro" e "Gato". Inclusive, como indicado abaixo, também é possível criar rótulos para "Nenhum" e "Ambos".

Veja algumas diretrizes para criar um conjunto de rótulos de alta qualidade.

  • Use uma palavra significativa como o nome de exibição de cada rótulo, como "cachorro", "gato" ou "prédio". Não use nomes abstratos como "rótulo1" e "rótulo2" ou siglas desconhecidas. Quanto mais significativos forem os nomes dos rótulos, mais fácil será para os rotuladores humanos aplicá-los com precisão e consistência.
  • Os rótulos precisam ser facilmente distinguíveis um do outro. Para tarefas de classificação em que um único rótulo é aplicado a cada item de dados, tente não usar rótulos com significados sobrepostos. Por exemplo, não há rótulos para "Esportes" e "Beisebol".
  • Para tarefas de classificação, geralmente é uma boa ideia incluir um rótulo chamado “outro” ou “nenhum”, para usar em dados que não correspondam aos outros rótulos. Se os únicos rótulos disponíveis forem "cachorro" e "gato", por exemplo, os rotuladores terão que rotular cada imagem com um desses rótulos. Normalmente, seu modelo personalizado será mais robusto se você incluir outras imagens além de cachorros ou gatos nos dados de treinamento.
  • Tenha em mente que os rotuladores são mais eficientes e precisos quando há no máximo 20 rótulos definidos no conjunto. É possível incluir até 100 rótulos.

Criar instruções

As instruções oferecem aos rotuladores humanos informações sobre como aplicar rótulos aos seus dados. As instruções devem conter exemplos de dados rotulados e outras orientações explícitas.

As instruções estão em arquivos PDF. As instruções em PDF podem oferecer orientações sofisticadas, como exemplos positivos e negativos ou descrições para cada caso. O PDF também é um formato conveniente para fornecer instruções de tarefas complicadas, como caixas delimitadoras de imagens ou rastreamento de objetos de vídeo.

Escreva as instruções, crie um arquivo PDF e salve o arquivo PDF no seu bucket do Google Cloud Storage.

Como criar boas instruções

Boas instruções são o fator mais importante para conseguir bons resultados de rotulagem humana. Como você conhece melhor seu caso de uso, é preciso deixar os rotuladores humanos saberem o que você quer que eles façam. Aqui estão algumas diretrizes para criar boas instruções:

  • Os rotuladores humanos não têm conhecimento do seu domínio. As distinções que você pede aos rotuladores precisam ser fáceis de serem compreendidas por alguém não familiarizado com seu caso de uso.

  • Evite tornar as instruções muito longas. É bom que um rotulador possa analisá-las e compreendê-las em até 20 minutos.

  • As instruções precisam descrever o conceito da tarefa, bem como detalhes sobre como rotular os dados. Por exemplo, para uma tarefa com caixa delimitadora, descreva como você quer que os rotuladores desenhem a caixa delimitadora. Será uma caixa justa ou folgada? Se houver várias instâncias do objeto, eles precisarão desenhar uma caixa delimitadora grande ou várias menores?

  • Se as instruções têm um conjunto de rótulos correspondente, elas precisam abranger todos os rótulos nesse conjunto. O nome do rótulo nas instruções precisa corresponder ao nome no conjunto de rótulos.

  • Geralmente, são necessárias várias iterações para criar boas instruções. Recomendamos que os rotuladores humanos trabalhem com um conjunto de dados pequeno primeiro e depois você pode ajustar as instruções com base no desempenho do trabalho do rotulador com relação às suas expectativas.

Um bom arquivo de instruções precisa incluir as seções a seguir:

  • Lista de rótulos e descrição: liste todos os rótulos que você quer usar e descreva o significado de cada um deles.
  • Exemplos: para cada rótulo, forneça pelo menos três exemplos positivos e um negativo. Esses exemplos precisam cobrir casos diferentes.
  • Cubra os casos extremos. Esclareça o máximo de casos extremos que puder. Isso reduz a necessidade de o rotulador interpretar o rótulo. Por exemplo, se você precisa desenhar uma caixa delimitadora para uma pessoa, é melhor esclarecer os itens abaixo:
    • Você precisará de uma caixa por pessoa se houver várias pessoas?
    • Você precisará de uma caixa se uma pessoa estiver obstruída?
    • Você precisará de uma caixa para uma pessoa que é mostrada parcialmente na imagem?
    • Você precisará de uma caixa para uma pessoa em uma foto ou pintura?
  • Descreva como adicionar anotações. Por exemplo:
    • Você precisa de uma caixa delimitadora justa ou folgada?
    • Para a extração de entidade de texto, onde a entidade interessada começará e terminará?
  • Esclarecimento nos rótulos. Se dois rótulos são semelhantes ou fáceis de serem confundidos, ofereça exemplos para esclarecer a diferença.

Abaixo, mostramos exemplos do que as instruções em PDF podem incluir. Os marcadores analisarão as instruções antes de iniciarem a tarefa.

Instruções em PDF 1

Instruções em PDF 2

Criar uma tarefa de rotulagem de dados

IU da Web

É possível solicitar a rotulagem de dados em dois locais no Console do Google Cloud:

  • Na tela de detalhes do conjunto de dados, clique em Criar tarefa de rotulagem.
  • Na tela da lista Tarefas de rotulagem, clique em Criar.

O painel Nova tarefa de rotulagem será aberto.

  1. Dê um nome à tarefa de rotulagem.

  2. Selecione o conjunto de dados que contém os itens que você quer rotular.

    Se você abrir o painel Nova tarefa de rotulagem na tela de detalhes do conjunto de dados, não poderá selecionar um conjunto de dados diferente.

  3. Confirme se o objetivo está correto.

    A caixa Objetivo mostra o objetivo do conjunto de dados selecionado, conforme determinado pelo conjunto de anotações padrão. Para alterar o objetivo, escolha outro conjunto de anotações.

  4. Escolha o conjunto de anotações que será usado para os dados rotulados.

    Os rótulos aplicados pelos rotuladores humanos serão salvos no conjunto de anotações selecionado. Você pode escolher um conjunto de anotações existente ou criar um novo. Se você criar um novo, será necessário fornecer um nome para ele.

  5. Especifique se quer usar a aprendizagem ativa.

    O aprendizado ativo agiliza o processo de rotulagem com uma parte do conjunto de dados feita por rotuladores humanos e, em seguida, aplicando o aprendizado de máquina para rotular o restante automaticamente.

    OBSERVAÇÂO: o aprendizado ativo está disponível apenas para os objetivos Classificação de imagem (Rótulo único) e Caixa delimitadora de imagem.

  6. Clique em Continuar.

  7. Insira os rótulos a serem aplicados pelos rotuladores e clique em Continuar, quando terminar.

    Consulte Como projetar um conjunto de rótulos para ver as diretrizes sobre como criar um conjunto de rótulos de alta qualidade.

  8. Digite o caminho para as instruções para os rotuladores humanos e clique em Continuar.

    As instruções precisam ser um arquivo PDF armazenado em um bucket do Google Cloud Storage. Consulte as diretrizes em Como criar instruções para rotuladores humanos para instruções sobre como criar instruções de alta qualidade.

  9. Escolha se você usará os rotuladores gerenciados pelo Google ou fornecer seus próprios rotuladores.

    Para fornecer seus próprios rotuladores, você precisa criar grupos de rotuladores e gerenciar suas atividades usando o Console do DataCompute.

  10. Especifique quantos rotuladores você quer que revisem cada item.

    Por padrão, um rotulador humano insere uma anotação em cada item de dados. No entanto, é possível solicitar que vários rotuladores façam anotações e revisem cada item. Selecione o número de rotuladores na caixa Especialistas por item de dados.

  11. Se você escolheu usar rotuladores gerenciados pelo Google, clique na caixa de seleção para confirmar que leu o guia de preços para entender o custo da rotulagem.

  12. Se você estiver fornecendo seus próprios rotuladores, escolha o grupo de rotuladores a serem usados nesta tarefa de rotulagem.

    Escolha um grupo de rotuladores existentes na lista suspensa ou escolha Novo grupo de rotuladores e insira na caixa de texto um nome e uma lista de endereços de e-mail separados por vírgula para os administradores do grupo, abaixo da lista suspensa. Clique na caixa de seleção para conceder aos administradores especificados acesso para ver suas informações de rotulagem de dados.

  13. Clique em Iniciar tarefa.

    Se a opção Iniciar tarefa não estiver disponível, revise as páginas no painel Nova tarefa de rotulagempara verificar se você inseriu todas as informações necessárias.

Você pode analisar o progresso da tarefa de rotulagem de dados selecionando Tarefas de rotulagem no console. A página mostra o status de cada tarefa de rotulagem solicitada. Quando a coluna Progress mostrar 100%, o conjunto de dados correspondente será rotulado e estará pronto para treinar um modelo.

REST e LINHA DE CMD

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT_ID: o ID do projeto
  • DISPLAY_NAME: nome do job de rotulagem de dados
  • DATASET_ID: código do conjunto de dados que contém os itens a serem rotulados.
  • LABELERS: o número de rotuladores humanos que você quer que analise cada item de dados. Os valores válidos são 1, 3 e 5.
  • INSTRUCTIONS: o caminho para o arquivo PDF que contém instruções para os rotuladores humanos. O arquivo precisa estar em um bucket do Google Cloud Storage acessível pelo seu projeto.
  • INPUT_SCHEMA_URI: caminho para o arquivo de esquema para o tipo de item de dados:
    • Classificação de imagem, etiqueta única:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/image_classification_single_label_io_format_1.0.0.yaml
    • Classificação de imagem, vários rótulos:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/image_classification_multi_label_io_format_1.0.0.yaml
    • Detecção de objetos de imagem:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/image_bounding_box_io_format_1.0.0.yaml
    • Classificação de texto, rótulo único:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_classification_single_label_io_format_1.0.0.yaml
    • Classificação de texto, vários rótulos:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_classification_multi_label_io_format_1.0.0.yaml
    • Extração de entidades de texto:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_extraction_io_format_1.0.0.yaml
    • Análise de sentimento em texto:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_sentiment_io_format_1.0.0.yaml
    • Classificação do vídeo:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/video_classification_io_format_1.0.0.yaml
    • Rastreamento de objeto em vídeos:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/video_object_tracking_io_format_1.0.0.yaml
  • LABEL_LIST: uma lista de strings separadas por vírgulas, enumerando os rótulos disponíveis para aplicar a um item de dados
  • ANNOTATION_SET: o nome da anotação definida para os dados rotulados

Método HTTP e URL:

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

Corpo JSON da solicitação:

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

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

{
  "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
}
A resposta é um DataLabelingJob. É possível verificar o progresso do job monitorando o elemento "labelingProgress", que apresenta o valor que representa a porcentagem concluída.

Java

Outros exemplos de código:


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

Outros exemplos de código:

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)

OBSERVAÇÃO: o tempo máximo de resposta de um job de rotulagem de dados é de 63 dias. Se ele não for concluído dentro desse período, o job expirará e será excluído junto com as tarefas atribuídas aos rotuladores.

A seguir