Solicita el etiquetado de datos

La calidad de los datos de entrenamiento tiene un gran impacto en la eficacia del modelo que creas y, por extensión, en la calidad de las predicciones que muestra ese modelo. La clave para los datos de entrenamiento de alta calidad es garantizar que tengas elementos de entrenamiento que representen de forma precisa el dominio sobre el que deseas hacer predicciones y que los elementos de entrenamiento estén etiquetados de forma precisa.

Existen tres maneras de asignar etiquetas a los elementos de datos de entrenamiento:

  • Agrega los elementos de datos a tu conjunto de datos con sus etiquetas ya asignadas, por ejemplo, mediante un conjunto de datos disponible a nivel comercial.
  • Asigna etiquetas a los elementos de datos con la consola
  • Solicita que etiquetadores manuales agreguen etiquetas a los elementos de datos

Las tareas de etiquetado de datos de Vertex AI te permiten trabajar con etiquetadores manuales a fin de generar etiquetas de precisión alta para una colección de datos que puedes usar a fin de entrenar tus modelos de aprendizaje automático.

Para solicitar el etiquetado de datos por parte de los etiquetadores manuales, crea un trabajo de etiquetado de datos que proporcione a los etiquetadores manuales:

  • El conjunto de datos que contiene los elementos representativos de datos para etiquetar
  • Una lista de todas las etiquetas posibles para aplicar a los elementos de datos
  • Archivo PDF que contiene instrucciones para guiar a los etiquetadores manuales en tareas de etiquetado

Con estos recursos, los etiquetadores manuales anotan los elementos del conjunto de datos según tus instrucciones. Cuando finalicen, puedes usar el conjunto de anotaciones para entrenar un modelo de Vertex AI o exportar los elementos de datos etiquetados que se usarán en otro entorno de aprendizaje automático.

Cree un conjunto de datos

Para proporcionar a los etiquetadores manuales los elementos de datos que debes etiquetar, debes crear un conjunto de datos e importar elementos de datos en él. No es necesario etiquetar los elementos de datos. El tipo de datos (imagen, video o texto) y el objetivo (por ejemplo, clasificación o seguimiento de objetos) determina el tipo de anotaciones que aplican los etiquetadores manuales a los elementos de datos.

Proporciona etiquetas

Cuando creas una tarea de etiquetado de datos, enumeras el conjunto de etiquetas que deseas que utilicen las personas que etiquetan tus 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”).

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 las personas encargadas de etiquetar aplicarlas 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. Por ejemplo, no tenga etiquetas para "deportes" y "béisbol".
  • 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. Puedes incluir hasta 100 etiquetas.

Crea instrucciones

Las instrucciones proporcionan a los etiquetadores información sobre cómo aplicar etiquetas a los datos. Las instrucciones deben contener muestras de datos etiquetados y otras indicaciones explícitas.

Las instrucciones son archivos PDF. Con las instrucciones en PDF puedes proporcionar indicaciones sofisticadas, como ejemplos positivos y negativos o descripciones para cada caso. El archivo PDF también es un formato conveniente para proporcionar instrucciones de tareas complicadas, como cuadros de límite de imágenes o seguimiento de objetos de video.

Escribe las instrucciones, crea un archivo PDF y guarda el archivo PDF en tu bucket de Google Cloud Storage.

Diseña instrucciones buenas

Las instrucciones buenas son el factor más importante para obtener buenos resultados con el etiquetado realizado por personas. Dado que conoces mejor tu caso práctico, debes informarles a las personas que realizarán el etiquetado qué es lo que quieres que hagan. Estos son algunos lineamientos para crear buenas instrucciones:

  • Los etiquetadores no tienen tus conocimientos del tema. Las distinciones que les solicites a los etiquetadores deben ser fáciles de entender para alguien que no esté familiarizado con tu caso práctico.

  • Evita que las instrucciones sean demasiado extensas. Lo mejor es que el etiquetador pueda revisarlas y entenderlas en 20 minutos.

  • En las instrucciones debes describir el concepto de la tarea, además de los detalles sobre cómo etiquetar los datos. Por ejemplo, para una tarea de cuadros de límite, describe cómo deseas que los etiquetadores dibujen el cuadro. ¿Debería ser un cuadro restrictivo o más amplio? Si hay varias instancias del objeto, ¿deberían dibujar un solo cuadro de límite grande o varios más pequeños?

  • Si tienes instrucciones para un conjunto de etiquetas correspondiente, debes abarcar todas las etiquetas de ese conjunto. El nombre de la etiqueta en las instrucciones debe coincidir con el nombre en el conjunto de etiquetas.

  • A menudo, se necesitan varias iteraciones para crear instrucciones buenas. Recomendamos que los etiquetadores manuales trabajen primero en un conjunto de datos pequeño; luego, debes ajustar las instrucciones en función de cuánto cumplen tus expectativas los etiquetadores.

Un buen archivo de instrucciones debe incluir las siguientes secciones:

  • Lista de etiquetas y descripción: Enumera todas las etiquetas que desearías usar y describe el significado de cada una
  • Ejemplos: Para cada etiqueta, da al menos tres ejemplos positivos y un ejemplo negativo. Estos ejemplos deberían abarcar diferentes casos.
  • Abarca los casos extremos. Aclara tantos casos extremos como puedas. De esta forma, se reduce la necesidad de que el etiquetador deba interpretar la etiqueta. Por ejemplo, si necesitas dibujar un cuadro de límite para una persona, es mejor aclarar lo siguiente:
    • Si hay varias personas, ¿necesitas un cuadro para cada una?
    • ¿Necesitas un cuadro si una persona está oculta?
    • ¿Necesitas un cuadro para una persona que se vea parcialmente en la imagen?
    • ¿Necesitas un cuadro para una persona en una foto o pintura?
  • Describe cómo agregar anotaciones. Por ejemplo:
    • Para un cuadro de límite, ¿necesitas un cuadro restrictivo o más amplio?
    • Para la extracción de entidades de texto, ¿dónde debería comenzar y terminar la entidad de interés?
  • Aclaración de las etiquetas: Si dos etiquetas son similares o se pueden confundir con facilidad, brinda ejemplos para aclarar la diferencia

En los siguientes ejemplos, se muestra lo que pueden incluir las instrucciones en PDF. Los etiquetadores revisarán las instrucciones antes de comenzar la tarea.

Instrucciones en PDF 1

Instrucciones en PDF 2

Crea una tarea de etiquetado de datos

IU web

Puedes solicitar el etiquetado de datos desde dos lugares en Google Cloud Console:

  • En la pantalla de detalles del conjunto de datos, haz clic en Crear tarea de etiquetado.
  • En la pantalla de la lista Tareas de etiquetado, haz clic en Crear.

Se abrirá el panel Tarea de etiquetado nueva.

  1. Ingresa un nombre para la tarea de etiquetado.

  2. Selecciona el conjunto de datos cuyos elementos deseas que se etiqueten.

    Si abriste el panel Nueva tarea de etiquetado desde la pantalla de detalles del conjunto de datos, no puedes seleccionar un conjunto de datos diferente.

  3. Confirma que el objetivo sea correcto.

    En el cuadro Objetivo, se muestra el objetivo del conjunto de datos seleccionado, según lo determinado por su conjunto de anotaciones predeterminado. Para cambiar el objetivo, elige un conjunto de anotaciones diferente.

  4. Elige el conjunto de anotaciones que se usará para los datos etiquetados.

    Las etiquetas que apliquen los etiquetadores manuales se guardarán en el conjunto de anotaciones seleccionado. Puedes elegir un conjunto de anotaciones existente o crear uno nuevo. Si creas uno nueva, debes asignarle un nombre.

  5. Especifica si deseas usar el aprendizaje activo.

    El aprendizaje activo acelera el proceso de etiquetado mediante una etiqueta de etiquetador manual de tu conjunto de datos y, luego, aplica el aprendizaje automático para etiquetar automáticamente el resto.

    NOTA: El aprendizaje activo solo está disponible para los objetivos de Clasificación de imágenes (etiqueta única) y Cuadro de límite de imágenes.

  6. Haga clic en Continuar.

  7. Ingresa las etiquetas que deben aplicar los etiquetadores manuales y haz clic en Continuar cuando termines.

    Consulta Diseña un conjunto de etiquetas a fin de obtener lineamientos para crear un conjunto de etiquetas de alta calidad.

  8. Ingresa la ruta de acceso a las instrucciones para los etiquetadores manuales y haz clic en Continuar.

    Las instrucciones deben ser un archivo PDF almacenado en un bucket de Google Cloud Storage. Consulta Diseña instrucciones para etiquetadores manuales a fin de obtener lineamientos a fin de crear instrucciones de alta calidad.

  9. Elige si deseas usar etiquetadores administrados por Google o Proporcionar tus propios etiquetadores.

    Para proporcionar tus propios etiquetadores, debes crear grupos de etiquetadores y administrar sus actividades con DataCompute Console.

  10. Especifica cuántos etiquetadores quieres que revisen cada elemento.

    De forma predeterminada, un etiquetador manual anota cada elemento de datos. Sin embargo, puedes solicitar que varios etiquetadores anoten y revisen cada elemento. Selecciona la cantidad de etiquetadores en el cuadro Especialistas por elemento de datos.

  11. Si eliges usar etiquetadores administrados por Google, haz clic en la casilla de verificación para confirmar que leíste la guía de precios a fin de comprender el costo del etiquetado.

  12. Si proporcionas tus propios etiquetadores, elige el grupo de etiquetadores para usar en esta tarea de etiquetado.

    Elige un grupo de etiquetadores existente de la lista desplegable o elige Nuevo grupo de etiquetadores y, luego, ingresa un nombre de grupo y una lista de direcciones de correo electrónico separadas por comas para los administradores del grupo en el texto debajo de la lista desplegable. Haz clic en la casilla de verificación a fin de permitir que los administradores especificados vean la información del etiquetado de datos.

  13. Haz clic en Iniciar tarea.

    Si Iniciar tarea no está disponible, revisa las páginas dentro del panel Nueva tarea de etiquetado para verificar que has ingresado toda la información requerida.

Para revisar el progreso de la tarea de etiquetado de datos, selecciona Tareas de etiquetado en la consola. En la página, se muestra el estado de cada tarea de etiquetado solicitada. Cuando en la columna Progreso se muestra un 100%, el conjunto de datos correspondiente está etiquetado y listo para entrenar un modelo.

LÍNEA DE REST Y CMD

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT_ID: el ID de tu proyecto
  • DISPLAY_NAME: Nombre del trabajo de etiquetado de datos
  • DATASET_ID: ID del conjunto de datos que contiene los elementos que deseas etiquetar
  • LABELERS: La cantidad de etiquetadores manuales que deseas que revisen cada elemento de datos. Los valores válidos son 1, 3 y 5.
  • INSTRUCTIONS: La ruta de acceso al archivo PDF que contiene instrucciones para los etiquetadores manuales. El archivo debe estar en un bucket de Google Cloud Storage al que se pueda acceder desde tu proyecto.
  • INPUT_SCHEMA_URI: Ruta de acceso al archivo de esquema para el tipo de elemento de datos:
    • Clasificación de imágenes (una etiqueta):
      gs://google-cloud-aiplatform/schema/dataset/ioformat/image_classification_single_label_io_format_1.0.0.yaml
    • Clasificación de imágenes (varias etiquetas):
      gs://google-cloud-aiplatform/schema/dataset/ioformat/image_classification_multi_label_io_format_1.0.0.yaml
    • Detección de objetos de imagen:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/image_bounding_box_io_format_1.0.0.yaml
    • Clasificación de texto (una etiqueta):
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_classification_single_label_io_format_1.0.0.yaml
    • Clasificación de texto (varias etiquetas):
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_classification_multi_label_io_format_1.0.0.yaml
    • Extracción de entidades de texto:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_extraction_io_format_1.0.0.yaml
    • Análisis de opiniones de texto:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/text_sentiment_io_format_1.0.0.yaml
    • Clasificación de videos:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/video_classification_io_format_1.0.0.yaml
    • Seguimiento de objetos de video:
      gs://google-cloud-aiplatform/schema/dataset/ioformat/video_object_tracking_io_format_1.0.0.yaml
  • LABEL_LIST: Una lista de strings separadas por comas que enumeran las etiquetas disponibles para aplicar a un elemento de datos
  • ANNOTATION_SET: El nombre del conjunto de anotaciones para los datos etiquetados

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

{
   "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 tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "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 respuesta es un DataLabelingJob. Puedes verificar el progreso del trabajo mediante la supervisión del elemento "labelingProgress", cuyo valor es el porcentaje completado.

Java

Muestras de código adicionales:


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

Muestras de código adicionales:

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: El tiempo máximo de respuesta para un trabajo de etiquetado de datos es de 63 días. Si no se completa en este plazo, el trabajo vence y se borra junto con las tareas asignadas a los etiquetadores.

¿Qué sigue?