Solicitar o serviço de rotulagem de dados da Vertex AI

Cuidado:O serviço de rotulagem de dados da Vertex AI (que solicita rotuladores humanos) foi descontinuado e não estará mais disponível no Google Cloud após 1º de julho de 2024. Para novas tarefas de rotulagem, é possível adicionar rótulos usando o console do Google Cloud ou acessar soluções de rotulagem de dados de nossos parceiros no Marketplace do console do Google Cloud, como o Labelbox e o Snorkel.

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 do Cloud
• 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 mais informações sobre os preços da rotulagem de dados, consulte Rotulagem de dados.

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". E, conforme observado na lista a seguir, você também pode querer rótulos "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 precisarão 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 Cloud Storage.

Fornecer 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 ler e entender as instruções em 20 minutos.

• As instruções precisam descrever o conceito da tarefa e fornecer 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 ou várias caixas?

• 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 inclui as seguintes seções:

• Lista de rótulos e descrição: uma lista de todos os rótulos que você quer usar e 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. Para reduzir a necessidade do rotulador interpretar o rótulo, esclareça o maior número possível de casos extremos. Por exemplo, se você precisa desenhar uma caixa delimitadora para uma pessoa, é melhor esclarecer os itens abaixo:
  • Se houver várias pessoas, você precisará de uma caixa para cada uma delas?
  • Se uma pessoa estiver obstruída, você precisará de uma caixa?
  • Se uma pessoa for exibida parcialmente na imagem, você precisará de uma caixa?
  • Se uma pessoa estiver em uma foto ou pintura, você precisará de uma caixa?
• 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.

Os exemplos a seguir mostram o que as instruções em PDF podem incluir. Os marcadores analisarão as instruções antes de iniciarem a tarefa.

Criar uma tarefa de rotulagem de dados

IU da Web

É possível solicitar a rotulagem de dados no Console do Google Cloud.

1. No Console do Google Cloud, acesse a página Como rotular tarefas.

   Acessar tarefas de rotulagem

2. 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 sã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 objetivosClassificação de imagem (Rótulo único) e Caixa delimitadora de imagem.

6. Clique em Continuar.

7. Digite os rótulos a serem aplicados pelos rotuladores humanos. Para informações sobre como criar um conjunto de alta qualidade de rótulos, consulte Como projetar um conjunto de rótulos.

8. Clique em Continuar.

9. Digite o caminho para as instruções dos rotuladores humanos. As instruções precisam ser um arquivo PDF armazenado em um bucket do Cloud Storage. Para saber mais sobre como criar instruções de alta qualidade, consulte Como projetar instruções para rotuladores humanos.

10. Clique em Continuar.

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

    • 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.

    • Se você estiver fornecendo seus próprios rotuladores, precisará criar grupos de rotuladores e gerenciar as atividades deles usando o Console do DataCompute. Caso contrário, escolha o grupo de rotuladores que será usado nessa 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 acesso aos administradores especificados para ver suas informações de rotulagem de dados.

12. 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.

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 rotulagem para verificar se você inseriu todas as informações necessárias.

Você pode analisar o progresso da tarefa de rotulagem de dados no Console do Google Cloud na página Tarefas de rotulagem.

Acessar tarefas de rotulagem

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

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 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:

curl (Linux, macOS ou Cloud Shell)

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

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)

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$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

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:

• Uso do aprendizado ativo

• Como usar um pool de rotuladores personalizados

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:

• Uso do aprendizado ativo

• Como usar um pool de rotuladores personalizados

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 os dados não forem rotulados nesse período, o job expirará e será excluído com as tarefas atribuídas aos rotuladores.

A seguir

• Treine um modelo usando o AutoML.
• Treine um modelo usando seu código de treinamento personalizado.