Crea conjuntos de datos

Un conjunto de datos es la colección de elementos de datos que deseas que etiqueten las personas a cargo del etiquetado. Contiene muestras representativas que deseas clasificar o analizar. Un conjunto de datos bien etiquetado puede usarse para entrenar un modelo personalizado.

Los pasos principales para compilar un conjunto de datos son:

  1. Sube los elementos de datos a un depósito de Cloud Storage.
  2. Crea un archivo de valores separados por comas (CSV) que clasifique los elementos de datos y súbelo al mismo depósito de Cloud Storage.
  3. Crear un recurso de conjuntos de datos
  4. Importar los elementos de datos al recurso de conjuntos de datos

Un proyecto puede tener varios conjuntos de datos que se usen para diferentes solicitudes del Servicio de etiquetado de datos de AI Platform. Puedes obtener una lista de los conjuntos de datos disponibles y borrar los que ya no necesites. Consulta la página del recurso de conjuntos de datos para obtener más información.

Almacena en etapa intermedia los datos sin etiquetar

El primer paso para crear un conjunto de datos es subir los elementos de datos a un depósito de Cloud Storage para su etiquetado. Para obtener información sobre cómo crear un depósito, consulta Antes de comenzar.

El servicio de etiquetado de datos admite el etiquetado de tres tipos de datos. Puedes expandir las secciones que aparecen a continuación para obtener más información sobre cómo suministrar elementos de datos de calidad pertenecientes a cada tipo. Por el momento, solo se admite el etiquetado de conjuntos de datos en inglés.

Imágenes

Las imágenes deben tener un tipo de archivo compatible, como los siguientes:

  • JPEG
  • PNG

El tamaño máximo del archivo es de 30 MB para todos los casos de etiquetado de imágenes, excepto para la segmentación de imágenes. Para este último caso, el tamaño máximo del archivo es de 10 MB.

Las dimensiones máximas de una imagen son de 1920 x 1080.

Los datos de entrenamiento deben ser lo más parecido posible a los datos sobre los que se harán las predicciones. Por ejemplo, si tu caso práctico incluye imágenes borrosas y de baja resolución (como las de una cámara de seguridad), tus datos de entrenamiento deben estar compuestos por imágenes borrosas de baja resolución. En general, también deberías tratar de proporcionar imágenes de entrenamiento con múltiples ángulos, resoluciones y fondos.

El entrenamiento de un modelo funciona mejor cuando hay, como máximo, 100 veces más imágenes destinadas a la etiqueta más común que a la etiqueta menos común. Recomendamos quitar etiquetas de muy baja frecuencia.

Video

Los videos deben estar en formato MP4, con un códec H.264, H.265 y MPEG4. El tamaño máximo de video es de 2 GB.

Los datos de entrenamiento deben ser lo más parecido posible a los datos sobre los que se harán las predicciones. Por ejemplo, si tu caso práctico incluye videos borrosos y de baja resolución (como los de una cámara de seguridad), los datos de entrenamiento deben estar compuestos por videos borrosos y de baja resolución. En general, también deberías tratar de proporcionar videos de entrenamiento con múltiples ángulos, resoluciones y fondos.

Recomendamos que agregues aproximadamente 1,000 videos de entrenamiento por etiqueta. El mínimo por etiqueta es de 10 (50 para los modelos avanzados). En general, se necesitan más ejemplos por etiqueta para entrenar modelos con múltiples etiquetas por video. Además, las puntuaciones resultantes son más difíciles de interpretar.

El modelo funciona mejor cuando hay como máximo 100 veces más videos para la etiqueta más común que para la etiqueta menos común. Recomendamos quitar etiquetas de muy baja frecuencia.

Texto

Los archivos de texto deben usar el formato de codificación de archivo UTF-8.

Cada documento debe ser un archivo de texto independiente. No puedes proporcionar varios documentos en un solo archivo de texto. Por ejemplo, no puedes tratar cada fila de un archivo de texto como su propio documento.

La cantidad máxima de caracteres por archivo de texto es 100,000.

Trata de que tus datos de entrenamiento sean tan variados como los datos sobre los cuales se harán las predicciones. Los conjuntos de datos deben contener documentos de diferentes extensiones, documentos de diferentes autores, documentos que usen diferentes palabras o estilos, etcétera.

Te recomendamos que proporciones al menos 1000 documentos de entrenamiento por etiqueta. El número mínimo de documentos por etiqueta es de 10. Sin embargo, puedes mejorar las puntuaciones de confianza de tu modelo utilizando más ejemplos por etiqueta. Las mejores puntuaciones de confianza son especialmente útiles en los casos en que el modelo muestra varias etiquetas para clasificar un documento.

El modelo funciona mejor cuando hay, como máximo, 100 veces más documentos para la etiqueta más común que para la etiqueta menos común. Recomendamos quitar etiquetas de muy baja frecuencia.

Crea el archivo CSV de entrada

Además de los elementos de datos de muestra, también debes crear un archivo de valores separados por comas (CSV) que catalogue todos los datos. El archivo CSV puede tener cualquier nombre de archivo, debe estar codificado en UTF-8 y debe terminar con una extensión .csv.

En el caso de los datos de imagen y video, cada fila del archivo CSV corresponde a la ubicación (en el bucket de Google Cloud Storage de tu proyecto) de una imagen o un video. Por ejemplo:

gs://my_project_bucket/image1.png
gs://my_project_bucket/image2.png
gs://my_project_bucket/image3.png
gs://my_project_bucket/image4.png

En el caso de los datos de texto, cada fila del archivo CSV corresponde a la ubicación de almacenamiento de un archivo de texto. Por ejemplo:

gs://my_project_bucket/file1.txt
gs://my_project_bucket/file2.txt
gs://my_project_bucket/file3.txt
gs://my_project_bucket/file4.txt

Cada archivo de datos debe contener los datos que deseas etiquetar. El contenido de cada archivo de datos se mostrará a los etiquetadores como una pregunta de etiquetado.

Después de crear el archivo CSV que cataloga los elementos de datos, súbelo al mismo depósito de Cloud Storage en el que se encuentran los elementos de datos.

Crea el recurso de conjunto de datos

El siguiente paso es crear un recurso del conjunto de datos que, finalmente, contendrá los elementos de datos. El conjunto de datos recién creado estará vacío hasta que importes elementos de datos en el siguiente paso.

IU web

En la IU del Servicio de etiquetado de datos, puedes crear un conjunto de datos y, también, importar elementos desde la misma página.

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

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

    Para agregar un conjunto de datos a 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 Agregar un conjunto de datos, ingresa un nombre y una descripción para el conjunto de datos.

  4. En la lista desplegable Tipo de conjunto de datos, elige el tipo de elemento de datos que subirás a este conjunto de datos: imágenes, video o texto.

  5. En el cuadro Ubicación del archivo CSV, ingresa la ruta de acceso completa al archivo CSV de entrada.

    El archivo CSV debe estar en el mismo bucket de Google Cloud Storage que los elementos que enumera.

  6. Haz clic en Crear.

    Regresarás a la página Conjuntos de datos. En el conjunto de datos, se mostrará el estado “En curso” mientras se importan los documentos. Este proceso suele tomar alrededor de 10 minutos por cada 1,000 elementos, aunque el tiempo puede variar.

    Si el servicio muestra un error 405, sube menos archivos a la vez. Tendrás que actualizar la página antes de volver a intentarlo.

Línea de comandos

En el siguiente ejemplo, se crea un conjunto de datos llamado test_dataset. El conjunto de datos recién creado no contendrá ningún dato hasta que importes elementos a él.

Guarda el "name" del conjunto de datos nuevo (de la respuesta) para usarlo con otras operaciones, como importar elementos en el conjunto de datos. 

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}/datasets \
   -d '{
     "dataset": {
     "displayName": "test_dataset",
     "description": "dataset for curl commands testing",
     },
   }'

Debería ver un resultado similar al siguiente:

{
  "name": "projects/data-labeling-codelab/datasets/5c897e1e_0000_2ab5_9159_94eb2c0b4daa",
  "displayName": "test_dataset",
  "description": "dataset for curl commands testing",
  "createTime": "2019-03-14T03:11:50.926475415Z"
}

Python

Antes de que puedas ejecutar este ejemplo de código, debes instalar las bibliotecas cliente de Python.

def create_dataset(project_id):
    """Creates a dataset for the given Google Cloud project."""
    from google.cloud import datalabeling_v1beta1 as datalabeling

    client = datalabeling.DataLabelingServiceClient()

    formatted_project_name = f"projects/{project_id}"

    dataset = datalabeling.Dataset(
        display_name="YOUR_DATASET_SET_DISPLAY_NAME", description="YOUR_DESCRIPTION"
    )

    response = client.create_dataset(
        request={"parent": formatted_project_name, "dataset": dataset}
    )

    # The format of resource name:
    # project_id/{project_id}/datasets/{dataset_id}
    print(f"The dataset resource name: {response.name}")
    print(f"Display name: {response.display_name}")
    print(f"Description: {response.description}")
    print("Create time:")
    print(f"\tseconds: {response.create_time.timestamp_pb().seconds}")
    print(f"\tnanos: {response.create_time.timestamp_pb().nanos}\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.CreateDatasetRequest;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceClient;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceSettings;
import com.google.cloud.datalabeling.v1beta1.Dataset;
import com.google.cloud.datalabeling.v1beta1.ProjectName;
import java.io.IOException;

class CreateDataset {

  // Create a dataset that is initially empty.
  static void createDataset(String projectId, String datasetName) throws IOException {
    // String projectId = "YOUR_PROJECT_ID";
    // String datasetName = "YOUR_DATASET_DISPLAY_NAME";


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

      Dataset dataset =
          Dataset.newBuilder()
              .setDisplayName(datasetName)
              .setDescription("YOUR_DESCRIPTION")
              .build();

      CreateDatasetRequest createDatasetRequest =
          CreateDatasetRequest.newBuilder()
              .setParent(projectName.toString())
              .setDataset(dataset)
              .build();

      Dataset createdDataset = dataLabelingServiceClient.createDataset(createDatasetRequest);

      System.out.format("Name: %s\n", createdDataset.getName());
      System.out.format("DisplayName: %s\n", createdDataset.getDisplayName());
      System.out.format("Description: %s\n", createdDataset.getDescription());
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Importa los elementos de datos en el conjunto de datos

Después de crear un conjunto de datos, puedes usar el archivo CSV para importar los elementos de datos.

IU web

En la IU del Servicio de etiquetado de datos, puedes omitir este paso debido a que la importación ya se ha realizado en el paso anterior.

Línea de comandos

  • Reemplaza DATASET_ID por el ID de tu conjunto de datos, que se incluye en la respuesta que recibiste cuando lo creaste. El ID aparece al final del nombre completo del conjunto de datos: projects/{project-id}/locations/us-central1/datasets/{dataset-id}

  • Reemplaza CSV_FILE con la ruta de acceso completa al archivo CSV de entrada. 

    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}/datasets/${DATASET_ID}:importData \
   -d '{
     "inputConfig": {
       "dataType": "IMAGE",
       "gcsSource": {
          "inputUri": "${CSV_FILE}",
          "mimeType": "text/csv",
        }
       },
   }'

    Deberías ver un resultado similar al siguiente. Puedes usar el ID de operación para obtener el estado de la tarea. Un ejemplo es obtener el estado de una operación.

    {
  "name": "projects/data-labeling-codelab/operations/5c73dd6b_0000_2b34_a920_883d24fa2064",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.data-labeling.v1beta1.ImportDataOperationMetadata",
    "dataset": "projects/data-labeling-codelab/datasets/5c73db3d_0000_23e0_a25b_94eb2c119c4c"
  }
}

Python

Antes de que puedas ejecutar este ejemplo de código, debes instalar las bibliotecas cliente de Python.

def import_data(dataset_resource_name, data_type, input_gcs_uri):
    """Imports data to the given Google Cloud project and dataset."""
    from google.cloud import datalabeling_v1beta1 as datalabeling

    client = datalabeling.DataLabelingServiceClient()

    gcs_source = datalabeling.GcsSource(input_uri=input_gcs_uri, mime_type="text/csv")

    csv_input_config = datalabeling.InputConfig(
        data_type=data_type, gcs_source=gcs_source
    )

    response = client.import_data(
        request={"name": dataset_resource_name, "input_config": csv_input_config}
    )

    result = response.result()

    # The format of resource name:
    # project_id/{project_id}/datasets/{dataset_id}
    print(f"Dataset resource name: {result.dataset}\n")

    return result

Java

Antes de que puedas ejecutar este ejemplo de código, debes instalar las bibliotecas cliente de Java. 
import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceClient;
import com.google.cloud.datalabeling.v1beta1.DataLabelingServiceSettings;
import com.google.cloud.datalabeling.v1beta1.DataType;
import com.google.cloud.datalabeling.v1beta1.GcsSource;
import com.google.cloud.datalabeling.v1beta1.ImportDataOperationMetadata;
import com.google.cloud.datalabeling.v1beta1.ImportDataOperationResponse;
import com.google.cloud.datalabeling.v1beta1.ImportDataRequest;
import com.google.cloud.datalabeling.v1beta1.InputConfig;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class ImportData {

  // Import data to an existing dataset.
  static void importData(String datasetName, String gcsSourceUri) throws IOException {
    // String datasetName = DataLabelingServiceClient.formatDatasetName(
    //     "YOUR_PROJECT_ID", "YOUR_DATASETS_UUID");
    // String gcsSourceUri = "gs://YOUR_BUCKET_ID/path_to_data";


    DataLabelingServiceSettings settings =
        DataLabelingServiceSettings.newBuilder()
            .build();
    try (DataLabelingServiceClient dataLabelingServiceClient =
        DataLabelingServiceClient.create(settings)) {
      GcsSource gcsSource =
          GcsSource.newBuilder().setInputUri(gcsSourceUri).setMimeType("text/csv").build();

      InputConfig inputConfig =
          InputConfig.newBuilder()
              .setDataType(DataType.IMAGE) // DataTypes: AUDIO, IMAGE, VIDEO, TEXT
              .setGcsSource(gcsSource)
              .build();

      ImportDataRequest importDataRequest =
          ImportDataRequest.newBuilder().setName(datasetName).setInputConfig(inputConfig).build();

      OperationFuture<ImportDataOperationResponse, ImportDataOperationMetadata> operation =
          dataLabelingServiceClient.importDataAsync(importDataRequest);

      ImportDataOperationResponse response = operation.get();

      System.out.format("Imported items: %d\n", response.getImportCount());
    } catch (IOException | InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }
  }
}

Visualiza los elementos de datos incluidos en el conjunto de datos

Sigue estos pasos para ver los elementos de datos que se incluyen en un conjunto de datos importado:

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

    En la página Conjuntos de datos, verás conjuntos de datos que corresponden al proyecto actual en el Servicio de etiquetado de datos.

  2. En la lista de conjuntos de datos, haz clic en el nombre del conjunto de datos cuyos elementos deseas ver.

  3. Usa la pestaña Detalles de la página Detalles del conjunto de datos para ver los elementos de datos individuales incluidos en el conjunto de datos.