Crea conjuntos de etiquetas

Beta

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

Un conjunto de etiquetas contiene aquellas etiquetas que quieres que los etiquetadores manuales usen para las imágenes. Por ejemplo, si deseas clasificar imágenes en función de si contienen un perro o un gato, debes crear un conjunto de etiquetas con dos etiquetas: “Perro” y “Gato”. En realidad, como se indica a continuación, también te recomendamos crear las etiquetas “Ninguno” y “Ambos”. El conjunto de etiquetas puede incluir hasta 100 etiquetas.

Un proyecto puede tener varios conjuntos de etiquetas, y cada uno se puede usar para una solicitud distinta del Servicio de etiquetado de datos. Se puede obtener una lista de los conjuntos de etiquetas disponibles y borrar los que ya no sean necesarios. Consulta la página de recursos del conjunto de especificaciones de anotación para obtener más información.

Diseña un buen conjunto de etiquetas

A continuación, se presentan algunas pautas para la creación de un conjunto de etiquetas de alta calidad.

• Selecciona una palabra significativa para el nombre visible de cada etiqueta, como "perro", "gato" o "edificio". No uses nombres abstractos como “etiqueta1”, “etiqueta2” ni acrónimos desconocidos. Cuanto más significativos sean los nombres de las etiquetas, más fácil será para los etiquetadores manuales aplicar las etiquetas de forma precisa y coherente.
• Asegúrate de que las etiquetas se distingan fácilmente unas de otras. Para las tareas de clasificación en las que se aplica una sola etiqueta a cada elemento de datos, trata de no utilizar etiquetas cuyos significados se superpongan.
• En las tareas de clasificación, suele ser una buena idea incluir una etiqueta llamada "otro" o "ninguno" para usarla en los datos que no coincidan con las otras etiquetas. Si las únicas etiquetas disponibles son "perro" y "gato", por ejemplo, los etiquetadores tendrán que etiquetar todas las imágenes con una de esas dos etiquetas. El modelo personalizado será más sólido si incluyes imágenes que no sean de perros ni gatos en los datos de entrenamiento.
• Recuerda que los etiquetadores son más eficientes y precisos cuando hay, como máximo, 20 etiquetas definidas en el conjunto de etiquetas.

Crea un recurso del conjunto de etiquetas

IU web

Nota: El término “conjuntos de etiquetas” en la IU del Servicio de etiquetado de datos equivale al término “conjuntos de especificaciones de anotación” en la API del Servicio de etiquetado de datos.

1. Abre la IU del Servicio de etiquetado de datos.

   En la página Conjuntos de etiquetas, se muestra el estado de los conjuntos de etiquetas creados anteriormente para el proyecto actual.

   A fin de agregar un conjunto de etiquetas para un proyecto diferente, selecciona el proyecto de la lista desplegable en la esquina superior derecha de la barra de título.

2. Haz clic en el botón Crear en la barra de título.

3. En la página Crear un conjunto de etiquetas, ingresa un nombre y una descripción para el conjunto.

4. En la sección Etiquetas, ingresa los nombres y las descripciones de cada etiqueta que deseas que apliquen los etiquetadores.

   Después de ingresar el nombre y la descripción para una etiqueta, haz clic en Agregar etiqueta a fin de incorporar una fila para una etiqueta adicional. Puedes agregar hasta 100 etiquetas.

5. Haz clic en Crear para crear el conjunto de especificaciones de la anotación.

   Volverás a la página de la lista de Conjuntos de etiquetas.

Línea de comandos

Para crear el recurso del conjunto de etiquetas, enumera todas las etiquetas en formato JSON y, luego, pásalas al Servicio de etiquetado de datos.

En el siguiente ejemplo, se crea un conjunto de etiquetas llamado code_sample_label_set que tiene dos etiquetas.

Guarda el "name" del nuevo conjunto de etiquetas (de la respuesta) para usarlo con otras operaciones, como enviar la solicitud de etiquetado.

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",
               }
           ],
       },
    }'

Debería ver un resultado similar al siguiente:

{
  "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 que puedas ejecutar este ejemplo de código, debes instalar las bibliotecas cliente de 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 que puedas ejecutar este ejemplo de código, debes instalar las bibliotecas cliente de 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 la evaluación continua

Cuando creas un trabajo de evaluación, debes especificar un archivo CSV que defina tu conjunto de especificaciones de la anotación:

• El archivo debe tener una fila por cada etiqueta posible que el modelo produzca durante la predicción.
• Cada fila debe ser un par separado por comas que contenga la etiqueta y su descripción: LABEL_NAME,DESCRIPTION.
• Cuando creas un trabajo de evaluación, el Servicio de etiquetado de datos usa el nombre del archivo CSV como el nombre de un conjunto de especificaciones de anotación que crea en segundo plano.

Por ejemplo, si el modelo predice qué animal figura en una imagen, puedes escribir la siguiente especificación en un archivo llamado 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

Luego, sube este archivo a un depósito de Cloud Storage en el mismo proyecto que tu trabajo de evaluación continua.