Como gerenciar conjuntos de dados

Um conjunto de dados contém amostras representativas do tipo de conteúdo que você quer classificar, marcado com as etiquetas de categoria que você quer que seu modelo personalizado use. O conjunto de dados serve como entrada para treinar um modelo.

Veja a seguir as principais etapas para criar um conjunto de dados:

  1. Crie um conjunto de dados e especifique se quer permitir várias etiquetas em cada item.
  2. Importe itens de dados para o conjunto de dados.
  3. Use etiquetas nos itens.

Em muitos casos, as etapas 2 e 3 são combinadas: você importa itens de dados com as etiquetas já atribuídas.

Um projeto pode ter vários conjuntos de dados, cada um usado para treinar um modelo separado. É possível conseguir uma lista dos conjuntos de dados disponíveis e excluir aqueles que não são mais necessários.

Como criar um conjunto de dados

A primeira etapa no desenvolvimento de um modelo personalizado é criar um conjunto de dados vazio que vai armazenar os dados de treinamento do modelo. Ao criar um conjunto de dados, você especifica o tipo de classificação que quer que seu modelo personalizado execute:

  • MULTICLASS atribui uma única etiqueta a cada documento classificado
  • MULTILABEL permite que um documento seja atribuído a várias etiquetas

IU da Web

A IU do AutoML Vision permite criar um novo conjunto de dados e importar itens para ele usando a mesma página. Se preferir importar itens mais tarde, selecione Importar imagens mais tarde, no passo 3 abaixo.

  1. Abra a IU do AutoML Vision.

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

    Página da lista de conjuntos de dados

    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 Novo conjunto de dados na barra de título.

  3. Na página Criar conjunto de dados, insira o nome do conjunto de dados e identifique onde encontrar as imagens rotuladas usadas para treinar o modelo.

    É possível realizar as seguintes ações:

    • Fazer upload de um arquivo .csv que contenha as imagens de treinamento e os rótulos de categoria associados de seu computador local ou do Google Cloud Storage.

    • Carregar uma coleção de arquivos .txt ou .zip que contenha as imagens de treinamento de seu computador local.

    • Adiar o upload de imagens e etiquetas para mais tarde. Use essa opção para rotulagem manual por meio da IU ou do serviço de rotulagem humana.

  4. Especifique se quer ativar a classificação de vários rótulos.

    Clique na caixa de seleção se quiser que o modelo atribua várias etiquetas a um documento.

  5. Clique em Criar conjunto de dados.

    Você retornará para a página Conjuntos de dados e verá uma animação de andamento enquanto os documentos estão sendo importados. Esse processo leva aproximadamente 10 minutos por 1.000 documentos, 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. Você precisará atualizar a página antes de tentar novamente.

Linha de comando

No exemplo a seguir, é criado um conjunto de dados chamado test_dataset, compatível com um rótulo por item (consulte MULTICLASS). O conjunto de dados recém-criado não contém dados até que você importe itens para ele.

Salve o "name" do novo conjunto de dados (da resposta) para uso com outras operações, como importação de itens para o conjunto de dados e treinamento de um modelo.

curl \
  -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  https://automl.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/datasets \
  -d '{
    "displayName": "test_dataset",
    "imageClassificationDatasetMetadata": {
      "classificationType": "MULTICLASS"
    },
  }'

O resultado será semelhante a:

{
  "name": "projects/434039606874/locations/us-central1/datasets/356587829854924648",
  "displayName": "test_dataset",
  "createTime": "2018-04-26T18:02:59.825060Z",
  "imageClassificationDatasetMetadata": {
    "classificationType": "MULTICLASS"
  }
}

Python

Antes de executar este código de exemplo, é preciso instalar as bibliotecas de cliente do Python.

O exemplo a seguir cria um conjunto de dados que suporta um rótulo por item (consulte MULTICLASS). O conjunto de dados recém-criado não contém dados até que você importe itens para ele.

Salve o nome do novo conjunto de dados (response.name) para uso com outras operações, como importação de itens para o conjunto de dados e treinamento de um modelo.

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# dataset_name = 'DATASET_NAME_HERE'
# multilabel = True for multilabel or False for multiclass

from google.cloud import automl_v1beta1 as automl

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, compute_region)

# Classification type is assigned based on multilabel value.
classification_type = "MULTICLASS"
if multilabel:
    classification_type = "MULTILABEL"

# Specify the image classification type for the dataset.
dataset_metadata = {"classification_type": classification_type}
# Set dataset name and metadata of the dataset.
my_dataset = {
    "display_name": dataset_name,
    "image_classification_dataset_metadata": dataset_metadata,
}

# Create a dataset with the dataset metadata in the region.
dataset = client.create_dataset(project_location, my_dataset)

# Display the dataset information.
print("Dataset name: {}".format(dataset.name))
print("Dataset id: {}".format(dataset.name.split("/")[-1]))
print("Dataset display name: {}".format(dataset.display_name))
print("Image classification dataset metadata:")
print("\t{}".format(dataset.image_classification_dataset_metadata))
print("Dataset example count: {}".format(dataset.example_count))
print("Dataset create time:")
print("\tseconds: {}".format(dataset.create_time.seconds))
print("\tnanos: {}".format(dataset.create_time.nanos))

Java

/**
 * Demonstrates using the AutoML client to create a dataset
 *
 * @param projectId the Google Cloud Project ID.
 * @param computeRegion the Region name. (e.g., "us-central1")
 * @param datasetName the name of the dataset to be created.
 * @param multiLabel the type of classification problem. Set to FALSE by default. False -
 *     MULTICLASS , True - MULTILABEL
 * @throws IOException on Input/Output errors.
 */
public static void createDataset(
    String projectId, String computeRegion, String datasetName, Boolean multiLabel)
    throws IOException {
  // Instantiates a client
  AutoMlClient client = AutoMlClient.create();

  // A resource that represents Google Cloud Platform location.
  LocationName projectLocation = LocationName.of(projectId, computeRegion);

  // Classification type assigned based on multiLabel value.
  ClassificationType classificationType =
      multiLabel ? ClassificationType.MULTILABEL : ClassificationType.MULTICLASS;

  // Specify the image classification type for the dataset.
  ImageClassificationDatasetMetadata imageClassificationDatasetMetadata =
      ImageClassificationDatasetMetadata.newBuilder()
          .setClassificationType(classificationType)
          .build();

  // Set dataset with dataset name and set the dataset metadata.
  Dataset myDataset =
      Dataset.newBuilder()
          .setDisplayName(datasetName)
          .setImageClassificationDatasetMetadata(imageClassificationDatasetMetadata)
          .build();

  // Create dataset with the dataset metadata in the region.
  Dataset dataset = client.createDataset(projectLocation, myDataset);

  // Display the dataset information
  System.out.println(String.format("Dataset name: %s", dataset.getName()));
  System.out.println(
      String.format(
          "Dataset id: %s",
          dataset.getName().split("/")[dataset.getName().split("/").length - 1]));
  System.out.println(String.format("Dataset display name: %s", dataset.getDisplayName()));
  System.out.println("Image classification dataset specification:");
  System.out.print(String.format("\t%s", dataset.getImageClassificationDatasetMetadata()));
  System.out.println(String.format("Dataset example count: %d", dataset.getExampleCount()));
  System.out.println("Dataset create time:");
  System.out.println(String.format("\tseconds: %s", dataset.getCreateTime().getSeconds()));
  System.out.println(String.format("\tnanos: %s", dataset.getCreateTime().getNanos()));
}

Node.js

  const automl = require(`@google-cloud/automl`).v1beta1;

  const client = new automl.AutoMlClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = `The GCLOUD_PROJECT string, e.g. "my-gcloud-project"`;
  // const computeRegion = `region-name, e.g. "us-central1"`;
  // const datasetName = `name of the dataset to create, e.g. “myDataset”`;
  // const multiLabel = `type of classification problem, true for multilabel and false for multiclass e.g. "false"`;

  // A resource that represents Google Cloud Platform location.
  const projectLocation = client.locationPath(projectId, computeRegion);

  // Classification type is assigned based on multilabel value.
  let classificationType = `MULTICLASS`;
  if (multiLabel) {
    classificationType = `MULTILABEL`;
  }

  // Specify the text classification type for the dataset.
  const datasetMetadata = {
    classificationType: classificationType,
  };

  // Set dataset name and metadata.
  const myDataset = {
    displayName: datasetName,
    imageClassificationDatasetMetadata: datasetMetadata,
  };

  // Create a dataset with the dataset metadata in the region.
  const [dataset] = await client.createDataset({
    parent: projectLocation,
    dataset: myDataset,
  });
  // Display the dataset information.
  console.log(`Dataset name: ${dataset.name}`);
  console.log(`Dataset id: ${dataset.name.split(`/`).pop(-1)}`);
  console.log(`Dataset display name: ${dataset.displayName}`);
  console.log(`Dataset example count: ${dataset.exampleCount}`);
  console.log(`Image Classification type:`);
  console.log(
    `\t ${dataset.imageClassificationDatasetMetadata.classificationType}`
  );
  console.log(`Dataset create time:`);
  console.log(`\tseconds: ${dataset.createTime.seconds}`);
  console.log(`\tnanos: ${dataset.createTime.nanos}`);

Como importar itens para um conjunto de dados

Depois de criar um conjunto de dados, você pode importar URIs e rótulos de itens para os de um arquivo CSV armazenado em um intervalo do Google Cloud Storage. Para ver detalhes sobre como preparar os dados e criar um arquivo CSV para importação, consulte Como preparar dados de treinamento.

Você pode importar itens para um conjunto de dados vazio ou importar itens adicionais para um conjunto de dados existente.

IU da Web

A IU do AutoML Vision permite criar um novo conjunto de dados e importar itens para ele usando a mesma página. Consulte Como criar um conjunto de dados. As etapas abaixo importam itens para um conjunto de dados existente.

  1. Abra a IU do AutoML Vision e selecione o conjunto de dados na página Datasets.

    Página da lista de conjuntos de dados

  2. Na página Imagens, clique em Adicionar itens na barra de título e selecione o método de importação na lista suspensa.

    É possível realizar as seguintes ações:

    • Fazer upload de um arquivo .csv que contenha as imagens de treinamento e os rótulos de categoria associados de seu computador local ou do Google Cloud Storage.

    • Enviar arquivos .txt ou .zip que contenham as imagens de treinamento do seu computador local.

  3. Selecione os arquivos para importação.

Linha de comando

  • Substitua dataset-name pelo nome completo do conjunto de dados com base na resposta de quando você criou o conjunto. O nome completo tem o formato: projects/{project-id}/locations/us-central1/datasets/{dataset-id}

  • Substitua bucket-name pelo nome do intervalo do Google Cloud Storage em que você armazenou o arquivo CSV.

  • Substitua csv-file-name pelo nome do arquivo CSV.

    curl \
      -X POST \
      -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
      -H "Content-Type: application/json" \
      https://automl.googleapis.com/v1beta1/dataset-name:import \
      -d '{
        "inputUris": "gs://bucket-name-vcm/csv/csv-file-name.csv",
      }'
    

    Um código semelhante a este será exibido. Você pode usar o código da operação para saber o status da tarefa. Para ver um exemplo, consulte Como saber o status de uma operação.

    {
      "name": "projects/434039606874/locations/us-central1/operations/1979469554520650937",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
        "createTime": "2018-04-27T01:28:36.128120Z",
        "updateTime": "2018-04-27T01:28:36.128150Z",
        "cancellable": true
      }
    }
    

Python

Antes de executar este código de exemplo, é preciso instalar as bibliotecas de cliente do Python.

  • dataset_full_id é o nome completo do conjunto de dados no formato: projects/{project-id}/locations/us-central1/datasets/{dataset-id}

  • O valor de input_uris precisa ser o caminho para o arquivo CSV no intervalo do Google Cloud Storage associado ao projeto. O formato é: `gs://{project-id}-lcm/{document-name}.csv

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# dataset_id = 'DATASET_ID_HERE'
# path = 'gs://path/to/file.csv'

from google.cloud import automl_v1beta1 as automl

client = automl.AutoMlClient()

# Get the full path of the dataset.
dataset_full_id = client.dataset_path(
    project_id, compute_region, dataset_id
)

# Get the multiple Google Cloud Storage URIs.
input_uris = path.split(",")
input_config = {"gcs_source": {"input_uris": input_uris}}

# Import data from the input URI.
response = client.import_data(dataset_full_id, input_config)

print("Processing import...")
# synchronous check of operation status.
print("Data imported. {}".format(response.result()))

Java

/**
 * Demonstrates using the AutoML client to import labeled images.
 *
 * @param projectId the Id of the project.
 * @param computeRegion the Region name.
 * @param datasetId the Id of the dataset to which the training data will be imported.
 * @param path the Google Cloud Storage URIs. Target files must be in AutoML vision CSV format.
 * @throws Exception on AutoML Client errors
 */
public static void importData(
    String projectId, String computeRegion, String datasetId, String path) throws Exception {
  // Instantiates a client
  AutoMlClient client = AutoMlClient.create();

  // Get the complete path of the dataset.
  DatasetName datasetFullId = DatasetName.of(projectId, computeRegion, datasetId);

  GcsSource.Builder gcsSource = GcsSource.newBuilder();

  // Get multiple training data files to be imported
  String[] inputUris = path.split(",");
  for (String inputUri : inputUris) {
    gcsSource.addInputUris(inputUri);
  }

  // Import data from the input URI
  InputConfig inputConfig = InputConfig.newBuilder().setGcsSource(gcsSource).build();
  System.out.println("Processing import...");
  Empty response = client.importDataAsync(datasetFullId.toString(), inputConfig).get();
  System.out.println(String.format("Dataset imported. %s", response));
}

Node.js

  const automl = require(`@google-cloud/automl`).v1beta1;

  const client = new automl.AutoMlClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = `The GCLOUD_PROJECT string, e.g. "my-gcloud-project"`;
  // const computeRegion = `region-name, e.g. "us-central1"`;
  // const datasetId = `Id of the dataset`;
  // const path = `string or array of .csv paths in AutoML Vision CSV format, e.g. “gs://myproject/traindata.csv”;`

  // Get the full path of the dataset.
  const datasetFullId = client.datasetPath(projectId, computeRegion, datasetId);

  // Get one or more Google Cloud Storage URI(s).
  const inputUris = path.split(`,`);
  const inputConfig = {
    gcsSource: {
      inputUris: inputUris,
    },
  };

  // Import the dataset from the input URI.
  const [operation] = await client.importData({
    name: datasetFullId,
    inputConfig: inputConfig,
  });
  console.log(`Processing import...`);

  const [, , response] = await operation.promise();

  // The final result of the operation.
  if (response.done) {
    console.log(`Data imported.`);
  }

Como rotular itens de treinamento

Para ser útil ao treinamento de um modelo, cada item em um conjunto de dados precisa ter pelo menos um rótulo de categoria atribuído a ele. O AutoML Vision ignora itens sem um rótulo de categoria. É possível fornecer rótulos para seus itens de treinamento de três maneiras:

  • Com a inclusão de rótulos no seu arquivo .csv
  • rotulando seus itens na IU do AutoML Vision;
  • solicitando um serviço de rotulagem humana.

A API do AutoML não inclui métodos para rotulagem.

Para ver detalhes sobre os itens de rotulagem no seu arquivo .csv, consulte Como preparar seus dados de treinamento.

Para rotular itens na IU do AutoML Vision, selecione o conjunto de dados na página de listagem do conjunto de dados para ver seus detalhes. O nome de exibição do conjunto de dados selecionado aparece na barra de título, e a página relaciona os itens individuais no conjunto de dados com os respectivos rótulos. A barra de navegação à esquerda resume o número de itens rotulados ou não e permite filtrar a lista de itens por rótulo.

Página de imagens

Para atribuir rótulos a itens não rotulados ou alterá-los, selecione os itens que você quer atualizar e os rótulos que você quer atribuir a eles.

Solicitar rotulagem humana

Aproveite o serviço de rotulagem humana do Google nas suas imagens. O tempo de resposta costuma ser de alguns dias e depende do número de imagens e da complexidade da rotulagem.

Os requisitos para rotulagem humana são os seguintes:

  • Ter pelo menos 100 imagens não rotuladas no seu conjunto de dados.
  • Ter entre 2 e 20 rótulos definidos.
  • Ter descrições para cada rótulo.
  • Ter pelo menos 3 imagens de exemplo por rótulo.

Para solicitar a rotulagem humana:

Na guia Rótulo do fluxo de importação do conjunto de dados:

  1. Definir rótulos. Digite os nomes dos rótulos para este conjunto de dados. Também pode ser necessário adicionar um rótulo None_of_the_above para imagens que não correspondam a nenhum dos outros rótulos. Fornecer imagens que não correspondam a nenhum dos seus rótulos e rotulá-los como None_of_the_above pode melhorar a qualidade do seu modelo.

  2. Depois da criação, clique no nome de cada rótulo na lista Definir rótulos e forneça uma descrição ao rótulo e uma ou mais imagens de exemplo. As imagens podem ser extraídas do seu conjunto de dados ou carregadas do disco local.

  3. Selecione a opção Usar serviço de rotulagem humana. Digite um nome de tarefa e clique em Iniciar. O sistema começará a processar sua solicitação.

Quando a rotulagem humana é concluída, uma guia Tarefas é adicionada à interface do AutoML Vision. Nessa guia, você pode aprovar os rótulos ou tomar qualquer outra ação necessária.

Como listar conjuntos de dados

Um projeto pode incluir vários conjuntos de dados. Esta seção descreve como recuperar uma lista dos conjuntos de dados disponíveis para um projeto.

IU da Web

Para uma lista dos conjuntos de dados disponíveis usando a IU do AutoML Vision, clique no link Datasets, na parte superior do menu de navegação à esquerda.

Página da lista de conjuntos de dados

Para ver os conjuntos de dados de um projeto diferente, selecione o projeto na lista suspensa no canto superior direito da barra de título.

Linha de comando

curl \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  https://automl.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/datasets

O resultado será semelhante a:

{
  "datasets": [
    {
      "name": "projects/434039606874/locations/us-central1/datasets/356587829854924648",
      "displayName": "test_dataset",
      "createTime": "2018-04-26T18:02:59.825060Z",
      "imageClassificationDatasetMetadata": {
        "classificationType": "MULTICLASS"
      }
    },
    {
      "name": "projects/434039606874/locations/us-central1/datasets/3104518874390609379",
      "displayName": "test",
      "createTime": "2017-12-16T01:10:38.328280Z",
      "imageClassificationDatasetMetadata": {
        "classificationType": "MULTICLASS"
      }
    }
  ]
}

Python

Antes de executar este código de exemplo, é preciso instalar as bibliotecas de cliente do Python.
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# filter_ = 'filter expression here'

from google.cloud import automl_v1beta1 as automl

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, compute_region)

# List all the datasets available in the region by applying filter.
response = client.list_datasets(project_location, filter_)

print("List of datasets:")
for dataset in response:
    # Display the dataset information.
    print("Dataset name: {}".format(dataset.name))
    print("Dataset id: {}".format(dataset.name.split("/")[-1]))
    print("Dataset display name: {}".format(dataset.display_name))
    print("Image classification dataset metadata:")
    print("\t{}".format(dataset.image_classification_dataset_metadata))
    print("Dataset example count: {}".format(dataset.example_count))
    print("Dataset create time:")
    print("\tseconds: {}".format(dataset.create_time.seconds))
    print("\tnanos: {}".format(dataset.create_time.nanos))

Java

/**
 * Demonstrates using the AutoML client to list all datasets.
 *
 * @param projectId the Id of the project.
 * @param computeRegion the Region name.
 * @param filter the Filter expression.
 * @throws IOException on Input/Output errors.
 */
public static void listDatasets(String projectId, String computeRegion, String filter)
    throws IOException {
  // Instantiates a client
  AutoMlClient client = AutoMlClient.create();

  // A resource that represents Google Cloud Platform location.
  LocationName projectLocation = LocationName.of(projectId, computeRegion);

  // Build the List datasets request
  ListDatasetsRequest request =
      ListDatasetsRequest.newBuilder()
          .setParent(projectLocation.toString())
          .setFilter(filter)
          .build();

  // List all the datasets available in the region by applying the filter.
  System.out.print("List of datasets:");
  for (Dataset dataset : client.listDatasets(request).iterateAll()) {
    // Display the dataset information
    System.out.println(String.format("\nDataset name: %s", dataset.getName()));
    System.out.println(
        String.format(
            "Dataset id: %s",
            dataset.getName().split("/")[dataset.getName().split("/").length - 1]));
    System.out.println(String.format("Dataset display name: %s", dataset.getDisplayName()));
    System.out.println("Image classification dataset specification:");
    System.out.print(String.format("\t%s", dataset.getImageClassificationDatasetMetadata()));
    System.out.println(String.format("Dataset example count: %d", dataset.getExampleCount()));
    System.out.println("Dataset create time:");
    System.out.println(String.format("\tseconds: %s", dataset.getCreateTime().getSeconds()));
    System.out.println(String.format("\tnanos: %s", dataset.getCreateTime().getNanos()));
  }
}

Node.js

  const automl = require(`@google-cloud/automl`).v1beta1;

  const client = new automl.AutoMlClient();
  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = `The GCLOUD_PROJECT string, e.g. "my-gcloud-project"`;
  // const computeRegion = `region-name, e.g. "us-central1"`;
  // const filter = `filter expressions, must specify field e.g. “imageClassificationModelMetadata:*”`;

  // A resource that represents Google Cloud Platform location.
  const projectLocation = client.locationPath(projectId, computeRegion);

  // List all the datasets available in the region by applying filter.
  const [datasets] = await client.listDatasets({
    parent: projectLocation,
    filter: filter,
  });
  console.log(`List of datasets:`);
  datasets.forEach(dataset => {
    console.log(`Dataset name: ${dataset.name}`);
    console.log(`Dataset Id: ${dataset.name.split(`/`).pop(-1)}`);
    console.log(`Dataset display name: ${dataset.displayName}`);
    console.log(`Dataset example count: ${dataset.exampleCount}`);
    console.log(`Image Classification type:`);
    console.log(
      `\t`,
      dataset.imageClassificationDatasetMetadata.classificationType
    );
    console.log(`Dataset create time: `);
    console.log(`\tseconds: ${dataset.createTime.seconds}`);
    console.log(`\tnanos: ${dataset.createTime.nanos}`);
    console.log(`\n`);
  });

Como excluir um conjunto de dados

IU da Web

  1. Na IU do AutoML Vision, clique no link Datasets, na parte superior do menu de navegação à esquerda, para exibir a lista de conjuntos de dados disponíveis.

    Página da lista de conjuntos de dados

  2. Clique no menu de três pontos à extrema direita da linha que você quer excluir e selecione Excluir conjunto de dados.

  3. Clique em Excluir na caixa de diálogo de confirmação.

Linha de comando

  • Substitua dataset-name pelo nome completo do conjunto de dados com base na resposta de quando você criou o conjunto. O nome completo tem o formato: projects/{project-id}/locations/us-central1/datasets/{dataset-id}
curl -X DELETE \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" https://automl.googleapis.com/v1beta1/dataset-name

O resultado será semelhante a:

{
  "name": "projects/434039606874/locations/us-central1/operations/3512013641657611176",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2018-05-04T01:45:16.735340Z",
    "updateTime": "2018-05-04T01:45:16.735360Z",
    "cancellable": true
  }
}

Python

Antes de executar este código de exemplo, é preciso instalar as bibliotecas de cliente do Python.

  • dataset_id é o nome completo do conjunto de dados, no formato: projects/{project-id}/locations/us-central1/datasets/{dataset-id}
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# dataset_id = 'DATASET_ID_HERE'

from google.cloud import automl_v1beta1 as automl

client = automl.AutoMlClient()

# Get the full path of the dataset.
dataset_full_id = client.dataset_path(
    project_id, compute_region, dataset_id
)

# Delete a dataset.
response = client.delete_dataset(dataset_full_id)

# synchronous check of operation status.
print("Dataset deleted. {}".format(response.result()))

Java

/**
 * Delete a dataset.
 *
 * @param projectId the Id of the project.
 * @param computeRegion the Region name.
 * @param datasetId the Id of the dataset.
 * @throws Exception on AutoML Client errors
 */
public static void deleteDataset(String projectId, String computeRegion, String datasetId)
    throws Exception {
  // Instantiates a client
  AutoMlClient client = AutoMlClient.create();

  // Get the complete path of the dataset.
  DatasetName datasetFullId = DatasetName.of(projectId, computeRegion, datasetId);

  // Delete a dataset.
  Empty response = client.deleteDatasetAsync(datasetFullId).get();

  System.out.println(String.format("Dataset deleted. %s", response));
}

Node.js

  const automl = require(`@google-cloud/automl`).v1beta1;

  const client = new automl.AutoMlClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = `The GCLOUD_PROJECT string, e.g. "my-gcloud-project"`;
  // const computeRegion = `region-name, e.g. "us-central1"`;
  // const datasetId = `Id of the dataset`;

  // Get the full path of the dataset.
  const datasetFullId = client.datasetPath(projectId, computeRegion, datasetId);

  // Delete a dataset.
  const [operation] = await client.deleteDataset({name: datasetFullId});
  const [, , response] = await operation.promise();
  // The final result of the operation.
  if (response.done) {
    console.log(`Dataset deleted.`);
  }

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Cloud AutoML Vision
Precisa de ajuda? Acesse nossa página de suporte.