Como criar conjuntos de dados

Um conjunto de dados é a coleção de itens de dados que você quer que os rotuladores humanos rotulem. Ele contém amostras representativas que você quer classificar ou analisar. Um conjunto de dados bem rotulado pode ser usado para treinar um modelo personalizado.

Veja a seguir os principais passos para criar um conjunto de dados:

  1. Faça o upload dos itens de dados para um bucket do Cloud Storage.
  2. Crie um arquivo de valores separados por vírgula (CSV) que catálogo os itens de dados e faça o upload para o mesmo bucket do Cloud Storage.
  3. Crie um recurso de conjunto de dados.
  4. Importe os itens de dados para o recurso do conjunto de dados.

Um projeto pode ter vários conjuntos de dados, cada um para uma solicitação diferente do Serviço de rotulagem de dados do AI Platform. É possível conseguir uma lista dos conjuntos de dados disponíveis e excluir os que não são mais necessários. Para mais informações, acesse a página de recursos dos conjuntos de dados.

Preparar os dados sem rótulos

A primeira etapa na criação de um conjunto de dados é fazer o upload dos itens de dados em um bucket do Cloud Storage para rotulagem. Para informações sobre como criar um bucket, consulte Antes de começar.

O serviço de rotulagem de dados é compatível com a rotulagem de três tipos de dados. Expanda as seções abaixo para detalhes sobre como fornecer itens de dados de qualidade para cada tipo. Atualmente, somente os conjuntos de dados em inglês são compatíveis com a rotulagem.

Imagens

As imagens precisam usar um tipo de arquivo compatível.

  • JPEG
  • PNG

O tamanho máximo do arquivo é de 30 MB para todas as caixas de marcação de imagem, exceto para segmentação de imagem. Neste caso, o tamanho máximo do arquivo é 10 MB.

As dimensões máximas de uma imagem são 1920 x 1080.

Os dados de treinamento precisam estar o mais próximo possível dos dados que serão previstos. Por exemplo, se o caso de uso envolver imagens borradas e de baixa resolução (como de uma câmera de segurança), seus dados de treinamento precisarão ser compostos por imagens borradas de baixa resolução. Em geral, pense também em fornecer vários ângulos, resoluções e planos de fundo para suas imagens de treinamento.

Treinar um modelo funciona melhor quando há no máximo 100 vezes mais imagens para o rótulo mais comum do que para o menos comum. Recomendamos remover rótulos de frequência muito baixa.

Vídeo

Os vídeos precisam estar no formato MP4, com os codecs H.264, H.265 e MPEG4. O tamanho máximo do vídeo é de 2 GB.

Os dados de treinamento precisam estar o mais próximo possível dos dados que serão previstos. Por exemplo, se o caso de uso incluir vídeos desfocados e de baixa resolução (como de uma câmera de segurança), seus dados de treinamento precisarão ser compostos por vídeos desfocados e de baixa resolução. Em geral, pense também em fornecer vários ângulos, resoluções e planos de fundo nos vídeos de treinamento.

Recomendamos cerca de 1.000 vídeos de treinamento por rótulo. O mínimo por rótulo é 10 ou 50 para modelos avançados. Em geral, são necessários mais exemplos por rótulo para treinar modelos com vários rótulos por vídeo, e os resultados são mais difíceis de interpretar.

O modelo funciona melhor quando há no máximo 100 vezes mais vídeos para o rótulo mais comum do que para o menos comum. Recomendamos remover rótulos de frequência muito baixa.

Texto

Os arquivos de texto precisam usar o formato de codificação de arquivo de texto UTF-8.

Cada documento precisa ser um arquivo de texto separado. Não é possível fornecer vários documentos em um arquivo de texto. Por exemplo, não é possível tratar cada linha de um arquivo de texto como seu próprio documento.

O número máximo de caracteres por arquivo de texto é 100.000.

Procure fazer com que seus dados de treinamento sejam tão variados quanto os dados usados para previsões. Os conjuntos de dados precisam conter documentos de diferentes tamanhos, criados por pessoas variadas, que usem palavras ou estilos diferentes e assim por diante.

Recomendamos pelo menos 1.000 documentos de treinamento por rótulo. O número mínimo de documentos por rótulo é 10. No entanto, é possível melhorar a pontuação de confiança do modelo usando mais exemplos por rótulo. Pontuações de confiança melhores são especialmente úteis quando o modelo retorna vários rótulos para classificar um documento.

O modelo funciona melhor quando há no máximo 100 vezes mais documentos para o rótulo mais comum do que para o rótulo menos comum. Recomendamos remover rótulos de frequência muito baixa.

Criar o arquivo CSV de entrada

Além da amostra dos itens de dados, também é preciso criar um arquivo em valores separados por vírgula (CSV, na sigla em inglês) que cataloga todos os dados. O arquivo CSV pode ter qualquer nome de arquivo, precisa ser codificado em UTF-8 e terminar com uma extensão .csv.

Para dados de imagem e vídeo, cada linha do arquivo CSV é o local (no segmento do Google Cloud Storage do seu projeto) de uma imagem ou vídeo. Por exemplo:

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

Para dados de texto, cada linha no arquivo CSV é o local de armazenamento de um arquivo de texto. Por exemplo:

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 arquivo de dados precisa conter os dados que você quer rotular. O conteúdo de cada arquivo de dados será mostrado aos marcadores como uma pergunta de rotulagem.

Depois de criar o arquivo CSV que cataloga os itens de dados, faça o upload para o mesmo segmento do Cloud Storage que os itens de dados.

Criar o recurso do conjunto de dados

O próximo passo é criar um recurso de conjunto de dados que futuramente conterá os itens de dados. O conjunto de dados recém-criado está vazio até você importar itens de dados para ele na próxima etapa.

IU da Web

Na IU do serviço de rotulagem de dados, você cria um conjunto de dados e importa itens para ele na mesma página.

  1. Abra a IU do Data Labeling Service.

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

    Para adicionar um conjunto de dados para 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 Adicionar um conjunto de dados, insira um nome e uma descrição para o conjunto de dados.

  4. Na lista suspensa Tipo de conjunto de dados, escolha o tipo de item de dados que você está enviando para este conjunto de dados: imagem, vídeo ou texto.

  5. Na caixa Local do arquivo CSV, digite o caminho completo para o arquivo CSV de entrada.

    O arquivo CSV precisa estar no mesmo bucket do Google Cloud Storage que os itens de dados que ele lista.

  6. Clique em Criar

    Você retornará à página Conjuntos de dados. Seu conjunto de dados mostrará um status "em andamento" enquanto seus documentos estiverem sendo importados. Esse processo leva aproximadamente 10 minutos por 1.000 itens, mas pode demorar mais ou menos tempo.

    Se o serviço retornar um erro 405, reduza o número de documentos carregados de uma só vez. Será preciso atualizar a página antes de tentar novamente.

Linha de comando

O exemplo a seguir cria um conjunto de dados chamado test_dataset. O conjunto de dados recém-criado não contém nenhum dado até que você importe itens para ele.

Salve o "name" do novo conjunto de dados (a partir da resposta) para usar com outras operações, como importar itens para o conjunto de dados.

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

A resposta será assim:

{
  "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 executar este código de exemplo, é preciso instalar as bibliotecas de cliente do 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("The dataset resource name: {}".format(response.name))
    print("Display name: {}".format(response.display_name))
    print("Description: {}".format(response.description))
    print("Create time:")
    print("\tseconds: {}".format(response.create_time.timestamp_pb().seconds))
    print("\tnanos: {}\n".format(response.create_time.timestamp_pb().nanos))

    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.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();
    }
  }
}

Importar itens de dados para o conjunto de dados

Depois de criar um conjunto de dados, é possível importar os itens de dados para ele usando o arquivo CSV.

IU da Web

Na IU do serviço de rotulagem de dados, você pode pular esta etapa, já que a importação já foi feita na etapa anterior.

Linha de comando

  • Substitua DATASET_ID pelo código do seu conjunto de dados com base na resposta recebida quando você o criou. Esse ID está no fim do nome completo do conjunto de dados: projects/{project-id}/locations/us-central1/datasets/{dataset-id}

  • Substitua CSV_FILE pelo caminho completo do arquivo 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",
            }
           },
       }'
    

    Será exibido um código semelhante a este. É possível usar o ID da operação para saber o status da tarefa. Como saber o status de uma operação é um exemplo.

    {
      "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 executar este código de exemplo, é preciso instalar as bibliotecas de cliente do 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("Dataset resource name: {}\n".format(result.dataset))

    return result

Java

Antes de executar este código de exemplo, é preciso instalar as bibliotecas de cliente do 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();
    }
  }
}

Exibir os itens de dados no conjunto de dados

Siga estas etapas para exibir os itens de dados em um conjunto de dados importado:

  1. Abra a IU do Data Labeling Service.

    A página Conjuntos de dados mostra os conjuntos de dados do serviço de rotulagem de dados para o projeto atual.

  2. Na lista de conjuntos de dados, clique no nome do conjunto de dados cujos itens você quer visualizar.

  3. Use a guia Detalhes da página Detalhes do conjunto de dados para exibir os itens de dados individuais incluídos no conjunto de dados.