Como criar conjuntos de rótulos

Um conjunto de rótulos contém os 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". O conjunto pode incluir até 100 rótulos.

Um projeto pode ter vários conjuntos de rótulos, cada um usado para uma solicitação diferente do Serviço de rotulagem de dados. É possível ver uma lista dos conjuntos de rótulos disponíveis e excluir conjuntos desnecessários. Consulte a página de recursos do conjunto de especificações de anotação para mais informações.

Criar um bom conjunto de rótulos

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

Criar um recurso do conjunto de rótulos

IU da Web

  1. Abra a IU do Data Labeling Service.

    A página Conjuntos de rótulos mostra o status de conjuntos de rótulos criados anteriormente para o projeto atual.

    Para adicionar um conjunto de rótulos a um projeto diferente, selecione o projeto na lista suspensa no canto superior direito da barra de título.

  2. Clique no botão Criar na barra de título.

  3. Na página Criar um conjunto de rótulos, insira um nome e uma descrição para o conjunto.

  4. Na seção Rótulos, insira nomes e descrições para cada rótulo que você quer que os rotuladores humanos apliquem.

    Depois de inserir o nome e a descrição de um rótulo, clique em Adicionar rótulo para adicionar uma linha para um rótulo adicional. É possível adicionar até 100 rótulos.

  5. Clique em Criar para criar o conjunto de especificações de anotação.

    Você volta à página da lista Conjuntos de rótulos.

Linha de comando

Para criar o recurso do conjunto de rótulos, liste todos os rótulos no formato JSON e transmita-os ao Serviço de rotulagem de dados.

No exemplo a seguir, é criado um conjunto chamado code_sample_label_set com dois rótulos.

Salve o "name" do novo conjunto de rótulos (da resposta) para usar com outras operações, como enviar a solicitação de rotulagem. 

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}"/annotationSpecSets \
     -d '{
       "annotationSpecSet": {
           "displayName": "code_sample_label_set",
           "description": "code sample general label set",
           "annotationSpecs": [
               {
                   "displayName": "dog",
                   "description": "label dog",
               },
               {
                   "displayName": "cat",
                   "description": "label cat",
               }
           ],
       },
    }'

A resposta será semelhante a esta:

{
  "name": "projects/data-labeling-codelab/annotationSpecSets/5c73db2d_0000_2f46_983d_001a114a5d7c",
  "displayName": "code_sample_label_set",
  "description": "code sample general label set",
  "annotationSpecs": [
    {
      "displayName": "dog",
      "description": "label dog"
    },
    {
      "displayName": "cat",
      "description": "label cat"
    }
  ]
}

Python

Antes de executar este código de exemplo, você precisa instalar as bibliotecas de cliente do Python.

def create_annotation_spec_set(project_id):
    """Creates a data labeling annotation spec set for the given
    Google Cloud project.
    """
    from google.cloud import datalabeling_v1beta1 as datalabeling

    client = datalabeling.DataLabelingServiceClient()

    project_path = f"projects/{project_id}"

    annotation_spec_1 = datalabeling.AnnotationSpec(
        display_name="label_1", description="label_description_1"
    )

    annotation_spec_2 = datalabeling.AnnotationSpec(
        display_name="label_2", description="label_description_2"
    )

    annotation_spec_set = datalabeling.AnnotationSpecSet(
        display_name="YOUR_ANNOTATION_SPEC_SET_DISPLAY_NAME",
        description="YOUR_DESCRIPTION",
        annotation_specs=[annotation_spec_1, annotation_spec_2],
    )

    response = client.create_annotation_spec_set(
        request={"parent": project_path, "annotation_spec_set": annotation_spec_set}
    )

    # The format of the resource name:
    # project_id/{project_id}/annotationSpecSets/{annotationSpecSets_id}
    print(f"The annotation_spec_set resource name: {response.name}")
    print(f"Display name: {response.display_name}")
    print(f"Description: {response.description}")
    print("Annotation specs:")
    for annotation_spec in response.annotation_specs:
        print(f"\tDisplay name: {annotation_spec.display_name}")
        print(f"\tDescription: {annotation_spec.description}\n")

    return response

Java

Antes de executar este código de exemplo, é preciso instalar as bibliotecas de cliente do Java. 
import com.google.cloud.datalabeling.v1beta1.AnnotationSpec;
import com.google.cloud.datalabeling.v1beta1.AnnotationSpecSet;
import com.google.cloud.datalabeling.v1beta1.CreateAnnotationSpecSetRequest;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceClient;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceSettings;
import com.google.cloud.datalabeling.v1beta1.ProjectName;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

class CreateAnnotationSpecSet {

  // Create an annotation spec set.
  static void createAnnotationSpecSet(String projectId) throws IOException {
    // String projectId = "YOUR_PROJECT_ID";

    Map<String, String> annotationLabels = new HashMap<>();
    annotationLabels.put("label_1", "label_1_description");
    annotationLabels.put("label_2", "label_2_description");


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

      List<AnnotationSpec> annotationSpecs = new ArrayList<>();
      for (Entry<String, String> entry : annotationLabels.entrySet()) {
        AnnotationSpec annotationSpec =
            AnnotationSpec.newBuilder()
                .setDisplayName(entry.getKey())
                .setDescription(entry.getValue())
                .build();
        annotationSpecs.add(annotationSpec);
      }

      AnnotationSpecSet annotationSpecSet =
          AnnotationSpecSet.newBuilder()
              .setDisplayName("YOUR_ANNOTATION_SPEC_SET_DISPLAY_NAME")
              .setDescription("YOUR_DESCRIPTION")
              .addAllAnnotationSpecs(annotationSpecs)
              .build();

      CreateAnnotationSpecSetRequest request =
          CreateAnnotationSpecSetRequest.newBuilder()
              .setAnnotationSpecSet(annotationSpecSet)
              .setParent(projectName.toString())
              .build();

      AnnotationSpecSet result = dataLabelingServiceClient.createAnnotationSpecSet(request);

      System.out.format("Name: %s\n", result.getName());
      System.out.format("DisplayName: %s\n", result.getDisplayName());
      System.out.format("Description: %s\n", result.getDescription());
      System.out.format("Annotation Count: %d\n", result.getAnnotationSpecsCount());

      for (AnnotationSpec annotationSpec : result.getAnnotationSpecsList()) {
        System.out.format("\tDisplayName: %s\n", annotationSpec.getDisplayName());
        System.out.format("\tDescription: %s\n\n", annotationSpec.getDescription());
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Para avaliação contínua

Ao criar um job de avaliação, é preciso especificar um arquivo CSV que defina seu conjunto de especificações de anotação:

  • O arquivo precisa ter uma linha para cada rótulo possível que seu modelo gera durante a predição.
  • Cada linha precisa ser um par separado por vírgula contendo o rótulo e uma descrição do rótulo: LABEL_NAME,DESCRIPTION
  • Quando você cria um job de avaliação, o Serviço de rotulagem de dados usa o nome do arquivo CSV como o nome de um conjunto de especificação de anotação criado em segundo plano.

Por exemplo, se seu modelo prevê qual animal aparece na imagem, escreva a seguinte especificação em um arquivo chamado animals.csv:

bird,any animal in the class Aves - see https://en.wikipedia.org/wiki/Bird
cat,any animal in the species Felis catus (domestic cats, not wild cats) - see https://en.wikipedia.org/wiki/Cat
dog,any animal in the genus Canis (domestic dogs and close relatives) - see https://en.wikipedia.org/wiki/Canis
multiple,image contains more than one of the above
none,image contains none of the above

Em seguida, faça upload desse arquivo em um bucket do Cloud Storage no mesmo projeto que o job de avaliação contínua.