Solicita el Servicio de etiquetado de datos de Vertex AI

Precaución: El Servicio de etiquetado de datos de Vertex AI (solicitud de etiquetadores manuales) dejó de estar disponible y dejará de estar disponible en Google Cloud a partir del 1 de julio de 2024. Para las tareas de etiquetado nuevas, puedes usaragregar etiquetas con la consola de Google Cloud o acceder a soluciones de etiquetado de datos de nuestros socios en elmarketplace de la consola de Google Cloud, como Labelbox y Snorkel.

La calidad de los datos de entrenamiento afecta en gran medida a 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 mediante la consola de Google Cloud
• 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 obtener información sobre los precios del etiquetado de datos, consulta Etiquetado de datos.

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”. Además, como se indica en la siguiente lista, te recomendamos 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. Por ejemplo, si las únicas etiquetas disponibles son “perro” y “gato”, los etiquetadores deben etiquetar todas las imágenes con una de esas 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 guárdalo en tu bucket de Cloud Storage.

Proporciona buenas instrucciones

Las instrucciones buenas son el factor más importante para obtener buenos resultados con el etiquetado realizado por personas. Debido a que conoces mejor tu caso de uso, 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 revisar y comprender las instrucciones en 20 minutos.

• En las instrucciones debes describir el concepto de la tarea y proporcionar 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 existen varias instancias del objeto, ¿deberían dibujar uno o varios cuadros de límite?

• 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 incluye las siguientes secciones:

• Lista de etiquetas y descripción: Una lista de todas las etiquetas que desearías usar y 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. Para reducir la necesidad de que el etiquetador deba interpretar la etiqueta, aclara tantos casos extremos como puedas. 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?
  • Si una persona está oculta, ¿necesitas un cuadro?
  • Si una persona se muestra parcialmente en la imagen, ¿necesitas un cuadro?
  • Si una persona está en una foto o pintura, ¿necesitas un cuadro?
• 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.

Crea una tarea de etiquetado de datos

IU web

Puedes solicitar el etiquetado de datos desde la consola de Google Cloud.

1. En la consola de Google Cloud, ve a la página Etiqueta tareas.

   Ir a Tareas de etiquetado

2. Haga 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 aplican los etiquetadores manuales se guardan 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 de los etiquetadores manuales que se deben aplicar. Si deseas obtener información para crear un conjunto de etiquetas de alta calidad, consulta Diseña un conjunto de etiquetas.

8. Haga clic en Continuar.

9. Ingresa la ruta de acceso a las instrucciones para los etiquetadores manuales. Las instrucciones deben ser un archivo PDF almacenado en un bucket de Cloud Storage. Si deseas obtener información a fin de crear instrucciones de alta calidad, consulta Diseña instrucciones para los etiquetadores manuales.

10. Haga clic en Continuar.

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

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

    • Si proporcionas tus propios etiquetadores, debes crear grupos de etiquetadores y administrar sus actividades mediante DataCompute Console. De lo contrario, elige el grupo de etiquetadores que se usará para 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 otorgar acceso a los administradores especificados para ver la información de etiquetado de los datos.

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

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.

Puedes revisar el progreso de la tarea de etiquetado de datos en la consola de Google Cloud desde la página Etiqueta tareas.

Ir a Tareas de etiquetado

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.

REST

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

curl (Linux, macOS o Cloud Shell)

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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)

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario mediante la ejecución de gcloud init o gcloud auth login. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$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

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:

• Usa aprendizaje activo

• Usa un grupo de etiquetadores personalizado

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:

• Usa aprendizaje activo

• Usa un grupo de etiquetadores personalizado

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 los datos no se etiquetan dentro de ese tiempo, el trabajo se vence y se borra junto con las tareas asignadas a los etiquetadores.

¿Qué sigue?

• Entrena un modelo con AutoML.
• Entrena un modelo mediante tu código de entrenamiento personalizado.