Como criar conjuntos de dados e importar imagens

Um conjunto de dados contém amostras representativas do tipo de conteúdo que você quer classificar, marcado com os rótulos 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. Criar um conjunto de dados e especificar se quer permitir vários rótulos em cada item.
  2. Importar itens de dados para o conjunto de dados.
  3. Usar rótulos nos itens.

Em muitos casos, as etapas 2 e 3 são combinadas: você importa itens de dados com os rótulos já atribuídos.

Como criar um conjunto de dados

A primeira etapa na criação de um modelo personalizado é gerar um conjunto de dados vazio que vai armazenar os dados de treinamento do modelo. Ao criar um conjunto de dados, especifique o tipo de classificação que o modelo personalizado executará:

  • MULTICLASS atribui um único rótulo a cada imagem classificada.
  • MULTILABEL possibilita que vários rótulos sejam atribuídos a uma imagem.

A partir da versão v1 da API AutoML, essa solicitação retorna o ID de uma operação de longa duração.

Depois que essa operação for concluída, será possível importar imagens para ela. O conjunto de dados recém-criado não contém dados até que você importe imagens para ele.

Salve o ID do novo conjunto de dados (da resposta) para usar com outras operações, como importar imagens para o conjunto de dados e treinar um modelo.

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, na etapa 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 a 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 etiquetadas usadas para treinar o modelo.

    É possível:

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

    • carregar uma coleção de arquivos .txt ou .zip que contenha as imagens de treinamento do computador local;

    • adiar o upload de imagens e rótulo. Use essa opção para rotular manualmente por meio da IU.

  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. Será preciso atualizar a página antes de tentar novamente.

IU integrada

  1. Abra o Painel do Vision.

    Também é possível acessar essa página no console por meio do item do menu de navegação à esquerda Inteligência artificial > Vision. Isso levará você ao painel integrado da Vision. Selecione o card do AutoML Vision.

    Painel integrado da IU do Vision

  2. Selecione Conjuntos de dados no menu de navegação à esquerda.

  3. Selecione o botão Novo Conjunto de Dados na parte superior, atualize o nome do conjunto de dados (opcional) e selecione radio_button_checked rótulo único ou classificação de vários rótulos com base nos dados que você tem.

    selecionar o tipo de modelo para a página do conjunto de dados

  4. Depois de especificar o tipo de classificação, selecione Criar conjunto de dados.

  5. Na página Criar conjunto de dados, é possível escolher um arquivo CSV do Google Cloud Storage ou arquivos de imagem local para importar para o conjunto de dados.

    selecionar janela de importação de csv

    Selecione Continuar para iniciar a importação da imagem para o conjunto de dados. Durante a importação, o conjunto de dados mostrará um status Em execução: importando imagens.

  6. Você receberá um e-mail quando a importação for concluída.

REST e LINHA DE CMD

O exemplo a seguir cria um conjunto de dados 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 usar com outras operações, como importar itens para o conjunto de dados e treinar um modelo.

Antes de usar os dados de solicitação abaixo, faça as substituições a seguir:

  • project-id: o ID do projeto do GCP.
  • display-name: um nome de exibição de string escolhido por você.

Método HTTP e URL:

POST https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/datasets

Corpo JSON da solicitação:

    {
      "displayName": "display-name",
      "imageClassificationDatasetMetadata": {
        "classificationType": "MULTICLASS"
      }
    }
    

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/datasets

PowerShell

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/datasets" | Select-Object -Expand Content

Será exibida uma saída semelhante a esta. Use o ID da operação (ICN3819960680614725486, neste caso) para receber o status da tarefa. Para um exemplo, consulte Como trabalhar com operações de longa duração.

    {
      "name": "projects/project-id/locations/us-central1/operations/ICN3819960680614725486",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
        "createTime": "2019-11-14T16:49:13.667526Z",
        "updateTime": "2019-11-14T16:49:13.667526Z",
        "createDatasetDetails": {}
      }
    }

Depois que a operação for concluída, você receberá o ID do conjunto de dados com a mesma solicitação do status da operação. A resposta será semelhante a:

    {
      "name": "projects/project-id/locations/us-central1/operations/ICN3819960680614725486",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
        "createTime": "2019-11-14T16:49:13.667526Z",
        "updateTime": "2019-11-14T16:49:17.975314Z",
        "createDatasetDetails": {}
      },
      "done": true,
      "response": {
        "@type": "type.googleapis.com/google.cloud.automl.v1.Dataset",
        "name": "projects/project-id/locations/us-central1/datasets/ICN5496445433112696489"
      }
    }
    

C#

/// <summary>
    ///  Demonstrates using the AutoML client to create a dataset.
    /// </summary>
    /// <param name="projectId">GCP Project ID.</param>
    /// <param name="displayName">The name of the dataset to be created.</param>
    public static object VisionClassificationCreateDataset(string projectId = "YOUR-PROJECT-ID",
        string displayName = "YOUR-DATASET-NAME")
    {
        // Initialize the client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        AutoMlClient client = AutoMlClient.Create();

        // A resource that represents Google Cloud Platform location.
        string projectLocation = LocationName.Format(projectId, "us-central1");

        // Specify the classification type
        // Types:
        // MultiLabel: Multiple labels are allowed for one example.
        // MultiClass: At most one label is allowed per example.
        ClassificationType classificationType = ClassificationType.Multilabel;
        ImageClassificationDatasetMetadata metadata =
           new ImageClassificationDatasetMetadata
           {
               ClassificationType = classificationType
           };

        Dataset dataset = new Dataset
        {
            DisplayName = displayName,
            ImageClassificationDatasetMetadata = metadata
        };

        var result = Task.Run(() => client.CreateDatasetAsync(projectLocation, dataset)).Result;
        Dataset createdDataset = result.PollUntilCompleted().Result;

        // Display the dataset information.
        Console.WriteLine($"Dataset name: {createdDataset.Name}");
        // To get the dataset id, you have to parse it out of the `name` field. As dataset Ids are
        // required for other methods.
        // Name Form: `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`
        string[] names = createdDataset.Name.Split("/");
        string datasetId = names[names.Length - 1];
        Console.WriteLine($"Dataset id: {datasetId}");
        return 0;
    }

Go

import (
    	"context"
    	"fmt"
    	"io"

    	automl "cloud.google.com/go/automl/apiv1"
    	automlpb "google.golang.org/genproto/googleapis/cloud/automl/v1"
    )

    // visionClassificationCreateDataset creates a dataset for image classification.
    func visionClassificationCreateDataset(w io.Writer, projectID string, location string, datasetName string) error {
    	// projectID := "my-project-id"
    	// location := "us-central1"
    	// datasetName := "dataset_display_name"

    	ctx := context.Background()
    	client, err := automl.NewClient(ctx)
    	if err != nil {
    		return fmt.Errorf("NewClient: %v", err)
    	}
    	defer client.Close()

    	req := &automlpb.CreateDatasetRequest{
    		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, location),
    		Dataset: &automlpb.Dataset{
    			DisplayName: datasetName,
    			DatasetMetadata: &automlpb.Dataset_ImageClassificationDatasetMetadata{
    				ImageClassificationDatasetMetadata: &automlpb.ImageClassificationDatasetMetadata{
    					// Specify the classification type:
    					// - MULTILABEL: Multiple labels are allowed for one example.
    					// - MULTICLASS: At most one label is allowed per example.
    					ClassificationType: automlpb.ClassificationType_MULTILABEL,
    				},
    			},
    		},
    	}

    	op, err := client.CreateDataset(ctx, req)
    	if err != nil {
    		return fmt.Errorf("CreateDataset: %v", err)
    	}
    	fmt.Fprintf(w, "Processing operation name: %q\n", op.Name())

    	dataset, err := op.Wait(ctx)
    	if err != nil {
    		return fmt.Errorf("Wait: %v", err)
    	}

    	fmt.Fprintf(w, "Dataset name: %v\n", dataset.GetName())

    	return nil
    }
    

Java

import com.google.api.gax.longrunning.OperationFuture;
    import com.google.cloud.automl.v1.AutoMlClient;
    import com.google.cloud.automl.v1.ClassificationType;
    import com.google.cloud.automl.v1.Dataset;
    import com.google.cloud.automl.v1.ImageClassificationDatasetMetadata;
    import com.google.cloud.automl.v1.LocationName;
    import com.google.cloud.automl.v1.OperationMetadata;

    import java.io.IOException;
    import java.util.concurrent.ExecutionException;

    class VisionClassificationCreateDataset {

      public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException {
        // TODO(developer): Replace these variables before running the sample.
        String projectId = "YOUR_PROJECT_ID";
        String displayName = "YOUR_DATASET_NAME";
        createDataset(projectId, displayName);
      }

      // Create a dataset
      static void createDataset(String projectId, String displayName)
          throws IOException, ExecutionException, InterruptedException {
        // 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 (AutoMlClient client = AutoMlClient.create()) {
          // A resource that represents Google Cloud Platform location.
          LocationName projectLocation = LocationName.of(projectId, "us-central1");

          // Specify the classification type
          // Types:
          // MultiLabel: Multiple labels are allowed for one example.
          // MultiClass: At most one label is allowed per example.
          ClassificationType classificationType = ClassificationType.MULTILABEL;
          ImageClassificationDatasetMetadata metadata =
              ImageClassificationDatasetMetadata.newBuilder()
                  .setClassificationType(classificationType)
                  .build();
          Dataset dataset =
              Dataset.newBuilder()
                  .setDisplayName(displayName)
                  .setImageClassificationDatasetMetadata(metadata)
                  .build();
          OperationFuture<Dataset, OperationMetadata> future =
              client.createDatasetAsync(projectLocation, dataset);

          Dataset createdDataset = future.get();

          // Display the dataset information.
          System.out.format("Dataset name: %s\n", createdDataset.getName());
          // To get the dataset id, you have to parse it out of the `name` field. As dataset Ids are
          // required for other methods.
          // Name Form: `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`
          String[] names = createdDataset.getName().split("/");
          String datasetId = names[names.length - 1];
          System.out.format("Dataset id: %s\n", datasetId);
        }
      }
    }

Node.js

/**
     * TODO(developer): Uncomment these variables before running the sample.
     */
    // const projectId = 'YOUR_PROJECT_ID';
    // const location = 'us-central1';
    // const displayName = 'YOUR_DISPLAY_NAME';

    // Imports the Google Cloud AutoML library
    const {AutoMlClient} = require(`@google-cloud/automl`).v1;

    // Instantiates a client
    const client = new AutoMlClient();

    async function createDataset() {
      // Construct request
      // Specify the classification type
      // Types:
      // MultiLabel: Multiple labels are allowed for one example.
      // MultiClass: At most one label is allowed per example.
      const request = {
        parent: client.locationPath(projectId, location),
        dataset: {
          displayName: displayName,
          imageClassificationDatasetMetadata: {
            classificationType: 'MULTILABEL',
          },
        },
      };

      // Create dataset
      const [operation] = await client.createDataset(request);

      // Wait for operation to complete.
      const [response] = await operation.promise();

      console.log(`Dataset name: ${response.name}`);
      console.log(`
        Dataset id: ${
          response.name
            .split('/')
            [response.name.split('/').length - 1].split('\n')[0]
        }`);
    }

    createDataset();

PHP

use Google\Cloud\AutoMl\V1\AutoMlClient;
    use Google\Cloud\AutoMl\V1\ClassificationType;
    use Google\Cloud\AutoMl\V1\Dataset;
    use Google\Cloud\AutoMl\V1\ImageClassificationDatasetMetadata;

    /** Uncomment and populate these variables in your code */
    // $projectId = '[Google Cloud Project ID]';
    // $location = 'us-central1';
    // $displayName = 'your_dataset_name';

    $client = new AutoMlClient();

    try {
        // resource that represents Google Cloud Platform location
        $formattedParent = $client->locationName(
            $projectId,
            $location
        );

        $metadata = (new ImageClassificationDatasetMetadata())
            ->setClassificationType(ClassificationType::MULTILABEL);
        $dataset = (new Dataset())
            ->setDisplayName($displayName)
            ->setImageClassificationDatasetMetadata($metadata);

        // create dataset with the above location and metadata
        $operationResponse = $client->createDataset($formattedParent, $dataset);
        $operationResponse->pollUntilComplete();
        if ($operationResponse->operationSucceeded()) {
            $result = $operationResponse->getResult();

            // display dataset information
            $splitName = explode('/', $result->getName());
            printf('Dataset name: %s' . PHP_EOL, $result->getName());
            printf('Dataset id: %s' . PHP_EOL, end($splitName));
        } else {
            $error = $operationResponse->getError();
            // handleError($error)
        }
    } finally {
        $client->close();
    }

Python

from google.cloud import automl

    # TODO(developer): Uncomment and set the following variables
    # project_id = "YOUR_PROJECT_ID"
    # display_name = "your_datasets_display_name"

    client = automl.AutoMlClient()

    # A resource that represents Google Cloud Platform location.
    project_location = client.location_path(project_id, "us-central1")
    # Specify the classification type
    # Types:
    # MultiLabel: Multiple labels are allowed for one example.
    # MultiClass: At most one label is allowed per example.
    # https://cloud.google.com/automl/docs/reference/rpc/google.cloud.automl.v1#classificationtype
    metadata = automl.types.ImageClassificationDatasetMetadata(
        classification_type=automl.enums.ClassificationType.MULTILABEL
    )
    dataset = automl.types.Dataset(
        display_name=display_name,
        image_classification_dataset_metadata=metadata,
    )

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

    created_dataset = response.result()

    # Display the dataset information
    print("Dataset name: {}".format(created_dataset.name))
    print("Dataset id: {}".format(created_dataset.name.split("/")[-1]))

Ruby

require "google/cloud/automl"

    project_id = "YOUR_PROJECT_ID"
    display_name = "YOUR_DATASET_NAME"

    client = Google::Cloud::AutoML::AutoML.new

    # A resource that represents Google Cloud Platform location.
    project_location = client.class.location_path project_id, "us-central1"
    dataset = {
      display_name:                          display_name,
      image_classification_dataset_metadata: {
        # Specify the classification type
        # Types:
        # MultiLabel: Multiple labels are allowed for one example.
        # MultiClass: At most one label is allowed per example.
        classification_type: :MULTILABEL
      }
    }

    # Create a dataset with the dataset metadata in the region.
    created_dataset = client.create_dataset project_location, dataset

    # Display the dataset information
    puts "Dataset name: #{created_dataset.name}"
    puts "Dataset id: #{created_dataset.name.split('/').last}"

Como importar itens para um conjunto de dados

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

É possível importar itens para um conjunto de dados vazio ou importar itens complementares para um conjunto de dados atual.

AutoML Vision UI

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. Nas etapas abaixo, você importará itens para um conjunto de dados atual.

  1. Abra o e selecione o conjunto de dados na página Conjuntos de dados.

    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:

    • fazer upload de um arquivo .csv que contenha as imagens de treinamento e os rótulos de categoria associados do 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.

IU integrada

Vision Dashboard

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. Nas etapas abaixo, você importará itens para um conjunto de dados atual.

  1. Abra o e selecione o conjunto de dados na página Conjuntos de dados.

    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:

    • fazer upload de um arquivo .csv que contenha as imagens de treinamento e os rótulos de categoria associados do 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.

REST e LINHA DE CMD

Antes de usar os dados de solicitação abaixo, faça as substituições a seguir:

  • project-id: o ID do projeto do GCP.
  • dataset-id: o ID do conjunto de dados. Ele é o último elemento do nome do conjunto de dados. Por exemplo:
    • Nome do conjunto de dados: projects/project-id/locations/location-id/datasets/3104518874390609379
    • ID do conjunto de dados: 3104518874390609379
  • input-storage-path: o caminho para um arquivo CSV armazenado no Google Cloud Storage. O usuário solicitante precisa ter, pelo menos, permissão de leitura para o intervalo.

Método HTTP e URL:

POST https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/datasets/dataset-id:importData

Corpo JSON da solicitação:

    {
      "inputConfig": {
        "gcsSource": {
          "inputUris": [input-storage-path]
        }
      }
    }
    

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/datasets/dataset-id:importData

PowerShell

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/datasets/dataset-id:importData" | Select-Object -Expand Content

Será exibida uma saída semelhante a esta. Use o ID da operação (ICN3819960680614725486, neste caso) para receber o status da tarefa. Para um exemplo, consulte Como trabalhar com operações de longa duração.

    {
      "name": "projects/project-id/locations/us-central1/operations/operation-id",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
        "createTime": "2018-10-29T15:56:29.176485Z",
        "updateTime": "2018-10-29T15:56:29.176485Z",
        "importDataDetails": {}
      }
    }
    

C#

/// <summary>
    /// Import labeled items.
    /// </summary>
    /// <param name="projectId">GCP Project ID.</param>
    /// <param name="datasetId">the Id of the dataset.</param>
    /// <param name="path">Google Cloud Storage URIs.
    /// Target files must be in AutoML CSV format.</param>
    public static object ImportDataset(string projectId = "YOUR-PROJECT-ID",
        string datasetId = "YOUR-DATASET-ID",
        string path = "gs://BUCKET_ID/path_to_training_data.csv")
    {
        // Initialize the client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        AutoMlClient client = AutoMlClient.Create();

        // Get the complete path of the dataset.
        string datasetFullId = DatasetName.Format(projectId, "us-central1", datasetId);

        // Get multiple Google Cloud Storage URIs to import data from
        GcsSource gcsSource = new GcsSource
        {
            InputUris = { path.Split(",") }
        };

        // Import data from the input URI
        InputConfig inputConfig = new InputConfig
        {
            GcsSource = gcsSource
        };

        var result = Task.Run(() => client.ImportDataAsync(datasetFullId, inputConfig)).Result;
        Console.WriteLine("Processing import...");
        result.PollUntilCompleted();
        Console.WriteLine($"Data imported.");
        return 0;
    }
    

Go

import (
    	"context"
    	"fmt"
    	"io"

    	automl "cloud.google.com/go/automl/apiv1"
    	automlpb "google.golang.org/genproto/googleapis/cloud/automl/v1"
    )

    // importDataIntoDataset imports data into a dataset.
    func importDataIntoDataset(w io.Writer, projectID string, location string, datasetID string, inputURI string) error {
    	// projectID := "my-project-id"
    	// location := "us-central1"
    	// datasetID := "TRL123456789..."
    	// inputURI := "gs://BUCKET_ID/path_to_training_data.csv"

    	ctx := context.Background()
    	client, err := automl.NewClient(ctx)
    	if err != nil {
    		return fmt.Errorf("NewClient: %v", err)
    	}
    	defer client.Close()

    	req := &automlpb.ImportDataRequest{
    		Name: fmt.Sprintf("projects/%s/locations/%s/datasets/%s", projectID, location, datasetID),
    		InputConfig: &automlpb.InputConfig{
    			Source: &automlpb.InputConfig_GcsSource{
    				GcsSource: &automlpb.GcsSource{
    					InputUris: []string{inputURI},
    				},
    			},
    		},
    	}

    	op, err := client.ImportData(ctx, req)
    	if err != nil {
    		return fmt.Errorf("ImportData: %v", err)
    	}
    	fmt.Fprintf(w, "Processing operation name: %q\n", op.Name())

    	if err := op.Wait(ctx); err != nil {
    		return fmt.Errorf("Wait: %v", err)
    	}

    	fmt.Fprintf(w, "Data imported.\n")

    	return nil
    }
    

Java

import com.google.cloud.automl.v1.AutoMlClient;
    import com.google.cloud.automl.v1.DatasetName;
    import com.google.cloud.automl.v1.GcsSource;
    import com.google.cloud.automl.v1.InputConfig;
    import com.google.protobuf.Empty;

    import java.io.IOException;
    import java.util.Arrays;
    import java.util.concurrent.ExecutionException;

    class ImportDataset {

      public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException {
        // TODO(developer): Replace these variables before running the sample.
        String projectId = "YOUR_PROJECT_ID";
        String datasetId = "YOUR_DATASET_ID";
        String path = "gs://BUCKET_ID/path_to_training_data.csv";
        importDataset(projectId, datasetId, path);
      }

      // Import a dataset
      static void importDataset(String projectId, String datasetId, String path)
          throws IOException, ExecutionException, InterruptedException {
        // 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 (AutoMlClient client = AutoMlClient.create()) {
          // Get the complete path of the dataset.
          DatasetName datasetFullId = DatasetName.of(projectId, "us-central1", datasetId);

          // Get multiple Google Cloud Storage URIs to import data from
          GcsSource gcsSource =
              GcsSource.newBuilder().addAllInputUris(Arrays.asList(path.split(","))).build();

          // Import data from the input URI
          InputConfig inputConfig = InputConfig.newBuilder().setGcsSource(gcsSource).build();
          System.out.println("Processing import...");

          Empty response = client.importDataAsync(datasetFullId, inputConfig).get();
          System.out.format("Dataset imported. %s\n", response);
        }
      }
    }

Node.js

/**
     * TODO(developer): Uncomment these variables before running the sample.
     */
    // const projectId = 'YOUR_PROJECT_ID';
    // const location = 'us-central1';
    // const datasetId = 'YOUR_DISPLAY_ID';
    // const path = 'gs://BUCKET_ID/path_to_training_data.csv';

    // Imports the Google Cloud AutoML library
    const {AutoMlClient} = require(`@google-cloud/automl`).v1;

    // Instantiates a client
    const client = new AutoMlClient();

    async function importDataset() {
      // Construct request
      const request = {
        name: client.datasetPath(projectId, location, datasetId),
        inputConfig: {
          gcsSource: {
            inputUris: path.split(','),
          },
        },
      };

      // Import dataset
      console.log(`Proccessing import`);
      const [operation] = await client.importData(request);

      // Wait for operation to complete.
      const [response] = await operation.promise();
      console.log(`Dataset imported: ${response}`);
    }

    importDataset();

PHP

use Google\Cloud\AutoMl\V1\AutoMlClient;
    use Google\Cloud\AutoMl\V1\GcsSource;
    use Google\Cloud\AutoMl\V1\InputConfig;

    /** Uncomment and populate these variables in your code */
    // $projectId = '[Google Cloud Project ID]';
    // $location = 'us-central1';
    // $datasetId = 'my_dataset_id_123';
    // $gcsUri = 'gs://BUCKET_ID/path_to_training_data/'

    $client = new AutoMlClient();

    try {
        // get full path of dataset
        $formattedName = $client->datasetName(
            $projectId,
            $location,
            $datasetId
        );

        // set GCS uri
        $gcsSource = (new GcsSource())
            ->setInputUri($gcsUri);
        $inputConfig = (new InputConfig())
            ->setGcsSource($gcsSource);

        // import data from input uri
        $operationResponse = $client->importData($formattedName, $inputConfig);
        $operationResponse->pollUntilComplete();
        if ($operationResponse->operationSucceeded()) {
            $result = $operationResponse->getResult();
            printf('Dataset imported.' . PHP_EOL);
        } else {
            $error = $operationResponse->getError();
            // handleError($error)
        }
    } finally {
        $client->close();
    }

Python

from google.cloud import automl

    # TODO(developer): Uncomment and set the following variables
    # project_id = "YOUR_PROJECT_ID"
    # dataset_id = "YOUR_DATASET_ID"
    # path = "gs://YOUR_BUCKET_ID/path/to/data.csv"

    client = automl.AutoMlClient()
    # Get the full path of the dataset.
    dataset_full_id = client.dataset_path(
        project_id, "us-central1", dataset_id
    )
    # Get the multiple Google Cloud Storage URIs
    input_uris = path.split(",")
    gcs_source = automl.types.GcsSource(input_uris=input_uris)
    input_config = automl.types.InputConfig(gcs_source=gcs_source)
    # Import data from the input URI
    response = client.import_data(dataset_full_id, input_config)

    print("Processing import...")
    print("Data imported. {}".format(response.result()))

Ruby

require "google/cloud/automl"

    project_id = "YOUR_PROJECT_ID"
    dataset_id = "YOUR_DATASET_ID"
    path = "gs://BUCKET_ID/path_to_training_data.csv"

    client = Google::Cloud::AutoML::AutoML.new

    # Get the full path of the dataset.
    dataset_full_id = client.class.dataset_path project_id, "us-central1", dataset_id
    input_config = {
      gcs_source: {
        # Get the multiple Google Cloud Storage URIs
        input_uris: path.split(",")
      }
    }

    # Import data from the input URI
    operation = client.import_data dataset_full_id, input_config

    puts "Processing import..."

    # Wait until the long running operation is done
    operation.wait_until_done!

    puts "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 os itens de treinamento de três maneiras:

Para detalhes sobre como rotular itens no arquivo .csv, consulte Como preparar os 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 os detalhes. O nome de exibição do conjunto de dados selecionado é exibido 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

É possível aproveitar o Serviço de rotulagem de dados do AI Platform do Google para rotular suas imagens. Para mais informações, consulte a documentação do produto.

Como saber o status de uma operação

REST e linha de comando

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • project-id: o ID do projeto do GCP.
  • operation-id: o ID da sua operação. O ID é o último elemento do nome da sua operação. Por exemplo:
    • nome da operação: projects/project-id/locations/location-id/operations/IOD5281059901324392598
    • ID da operação: IOD5281059901324392598

Método HTTP e URL:

GET https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/operations/operation-id

Para enviar a solicitação, escolha uma destas opções:

curl

Execute o comando a seguir:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/operations/operation-id

PowerShell

Execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/operations/operation-id" | Select-Object -Expand Content
Você verá uma saída semelhante à seguinte para uma operação de importação concluída:
{
      "name": "projects/project-id/locations/us-central1/operations/operation-id",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
        "createTime": "2018-10-29T15:56:29.176485Z",
        "updateTime": "2018-10-29T16:10:41.326614Z",
        "importDataDetails": {}
      },
      "done": true,
      "response": {
        "@type": "type.googleapis.com/google.protobuf.Empty"
      }
    }

Você verá uma saída semelhante à seguinte para uma operação de modelo de criação concluída:

    {
      "name": "projects/project-id/locations/us-central1/operations/operation-id",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
        "createTime": "2019-07-22T18:35:06.881193Z",
        "updateTime": "2019-07-22T19:58:44.972235Z",
        "createModelDetails": {}
      },
      "done": true,
      "response": {
        "@type": "type.googleapis.com/google.cloud.automl.v1.Model",
        "name": "projects/project-id/locations/us-central1/models/model-id"
      }
    }
    

C#

/// <summary>
    /// Demonstrates using the AutoML client to get operation status.
    /// </summary>
    /// <param name="operationFullId">the complete name of a operation. For example, the name of your
    /// operation is projects/[projectId]/locations/us-central1/operations/[operationId].</param>
    public static object GetOperationStatus(string operationFullId
        = "projects/[projectId]/locations/us-central1/operations/[operationId]")
    {
        // Initialize the client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        AutoMlClient client = AutoMlClient.Create();

        // Get the latest state of a long-running operation.
        //TODO: I dont know why there is no 'GetOperationsClient'
        Operation operation = client.CreateModelOperationsClient.GetOperation(operationFullId);

        // Display operation details.
        Console.WriteLine("Operation details:");
        Console.WriteLine($"\tName: {operation.Name}");
        Console.WriteLine($"\tMetadata Type Url: {operation.Metadata.TypeUrl}");
        Console.WriteLine($"\tDone: {operation.Done}");
        if (operation.Response != null)
        {
            Console.WriteLine($"\tResponse Type Url: {operation.Response.TypeUrl}");
        }
        if (operation.Error != null)
        {
            Console.WriteLine("\tResponse:");
            Console.WriteLine($"\t\tError code: {operation.Error.Code}");
            Console.WriteLine($"\t\tError message: {operation.Error.Message}");
        }

        return 0;
    }
    

Go

import (
    	"context"
    	"fmt"
    	"io"

    	automl "cloud.google.com/go/automl/apiv1"
    	"google.golang.org/genproto/googleapis/longrunning"
    )

    // getOperationStatus gets an operation's status.
    func getOperationStatus(w io.Writer, projectID string, location string, operationID string) error {
    	// projectID := "my-project-id"
    	// location := "us-central1"
    	// operationID := "TRL123456789..."

    	ctx := context.Background()
    	client, err := automl.NewClient(ctx)
    	if err != nil {
    		return fmt.Errorf("NewClient: %v", err)
    	}
    	defer client.Close()

    	req := &longrunning.GetOperationRequest{
    		Name: fmt.Sprintf("projects/%s/locations/%s/operations/%s", projectID, location, operationID),
    	}

    	op, err := client.LROClient.GetOperation(ctx, req)
    	if err != nil {
    		return fmt.Errorf("GetOperation: %v", err)
    	}

    	fmt.Fprintf(w, "Name: %v\n", op.GetName())
    	fmt.Fprintf(w, "Operation details:\n")
    	fmt.Fprintf(w, "%v", op)

    	return nil
    }
    

Java

import com.google.cloud.automl.v1.AutoMlClient;
    import com.google.longrunning.Operation;

    import java.io.IOException;

    class GetOperationStatus {

      static void getOperationStatus() throws IOException {
        // TODO(developer): Replace these variables before running the sample.
        String operationFullId = "projects/[projectId]/locations/us-central1/operations/[operationId]";
        getOperationStatus(operationFullId);
      }

      // Get the status of an operation
      static void getOperationStatus(String operationFullId) throws IOException {
        // 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 (AutoMlClient client = AutoMlClient.create()) {
          // Get the latest state of a long-running operation.
          Operation operation = client.getOperationsClient().getOperation(operationFullId);

          // Display operation details.
          System.out.println("Operation details:");
          System.out.format("\tName: %s\n", operation.getName());
          System.out.format("\tMetadata Type Url: %s\n", operation.getMetadata().getTypeUrl());
          System.out.format("\tDone: %s\n", operation.getDone());
          if (operation.hasResponse()) {
            System.out.format("\tResponse Type Url: %s\n", operation.getResponse().getTypeUrl());
          }
          if (operation.hasError()) {
            System.out.println("\tResponse:");
            System.out.format("\t\tError code: %s\n", operation.getError().getCode());
            System.out.format("\t\tError message: %s\n", operation.getError().getMessage());
          }
        }
      }
    }

Node.js

/**
     * TODO(developer): Uncomment these variables before running the sample.
     */
    // const projectId = 'YOUR_PROJECT_ID';
    // const location = 'us-central1';
    // const operationId = 'YOUR_OPERATION_ID';

    // Imports the Google Cloud AutoML library
    const {AutoMlClient} = require(`@google-cloud/automl`).v1;

    // Instantiates a client
    const client = new AutoMlClient();

    async function getOperationStatus() {
      // Construct request
      const request = {
        name: `projects/${projectId}/locations/${location}/operations/${operationId}`,
      };

      const [response] = await client.operationsClient.getOperation(request);

      console.log(`Name: ${response.name}`);
      console.log(`Operation details:`);
      console.log(`${response}`);
    }

    getOperationStatus();

PHP

use Google\ApiCore\LongRunning\OperationsClient;

    /** Uncomment and populate these variables in your code */
    // $projectId = '[Google Cloud Project ID]';
    // $location = 'us-central1';
    // $operationId = 'my_operation_id_123';

    $client = new OperationsClient();

    try {
        // full name of operation
        $formattedName = 'projects/' . $projectId . '/locations/us-central1/operations/' . $operationId;

        // get latest state of long running operation
        $operation = $client->getOperation($name);
        printf('Operation name: %s' . PHP_EOL, $operation->getName());
        print('Operation details: ');
        print($operation);
    } finally {
        if (isset($client)) {
            $client->close();
        }
    }

Python

from google.cloud import automl

    # TODO(developer): Uncomment and set the following variables
    # operation_full_id = \
    #     "projects/[projectId]/locations/us-central1/operations/[operationId]"

    client = automl.AutoMlClient()
    # Get the latest state of a long-running operation.
    response = client.transport._operations_client.get_operation(
        operation_full_id
    )

    print("Name: {}".format(response.name))
    print("Operation details:")
    print(response)