Como treinar modelos exportáveis do Edge

Para criar um modelo personalizado, treine-o usando um conjunto de dados preparado. A API AutoML usa os itens do conjunto de dados para treinar o modelo, testá-lo e avaliar o desempenho. Você analisa os resultados, ajusta o conjunto de dados de treinamento conforme necessário e treina um novo modelo usando o conjunto de dados aprimorado.

Esse processo pode levar várias horas para ser concluído. A API AutoML permite verificar o status do treinamento.

Como o AutoML Vision cria um novo modelo cada vez que você inicia o treinamento, seu projeto pode incluir vários modelos. É possível extrair uma lista dos modelos no projeto e excluir os que não forem necessários. Como alternativa, é possível usar a interface do usuário do Cloud AutoML Vision para listar e excluir modelos desnecessários criados por meio da API AutoML.

Observação:

  • Não é possível exportar modelos personalizados criados nos produtos do Cloud AutoML, a menos que o contrário seja especificado na documentação ou nos termos de serviço aplicáveis.
  • A duração máxima de um modelo personalizado é de 18 meses a partir da versão com disponibilidade geral. É necessário criar e treinar um novo modelo para continuar classificando o conteúdo após esse período.
  • Os modelos de borda são otimizados para inferência em um dispositivo Edge. Consequentemente, a precisão do modelo do Edge será diferente da precisão do modelo do Cloud.

Os modelos são baseados em pesquisas de ponta (em inglês) no Google. Seu modelo estará disponível como um pacote TF Lite. Para mais informações sobre como integrar um modelo do TensorFlow Lite usando o SDK do TensorFlow Lite, consulte os links a seguir para iOS e Android (ambos em inglês).

Como treinar modelos do Edge

Quando você tiver um conjunto de dados com um conjunto sólido de itens de treinamento rotulados, estará pronto para criar e treinar seu modelo personalizado do Edge.

TensorFlow Serving e modelos do TF Lite

No momento do treinamento, escolha o tipo de modelo do Edge que você quer, de acordo com seu caso de uso específico:

  • Baixa latência (mobile-low-latency-1)
  • Uso geral (mobile-versatile-1)
  • Maior qualidade de previsão (mobile-high-accuracy-1)

IU da Web

  1. Abra o Vision Dashboard.

    A página Conjuntos de dados mostra os conjuntos disponíveis para o projeto atual.

    Uma página com uma lista de conjuntos de dados
  2. Selecione aquele que você quer usar para treinar o modelo personalizado.
  3. Quando o conjunto de dados estiver pronto, selecione a guia Treinar e o botão Treinar novo modelo.

    Isso abrirá uma janela lateral Treinar novo modelo com opções de treinamento.

  4. Na seção de treinamento Definir seu modelo, altere o nome do modelo(ou use o valor padrão) e selecione radio_button_checked Edge como o tipo de modelo. Depois de selecionar para treinar um modelo do Edge, selecione Continuar. Imagem do botão de opção do modelo do Train Edge
  5. Na seção Otimizar modelo para a seguir, selecione o critério de otimização desejado: radio_button_checked Precisão maior, Melhor compensação ou Previsão mais rápida. Depois de escolher a especificação de otimização, selecione Continuar.

    Imagem do botão de opção de melhor compensação
  6. Na seção Definir um orçamento de hora de uso do nó a seguir, use o orçamento de hora de uso do nó recomendado ou especifique um valor diferente.

    Por padrão, 24 horas de uso do nó precisam ser suficientes para que a maioria dos conjuntos de dados treine seu modelo. Esse valor recomendado é uma estimativa para tornar o modelo totalmente convertido. No entanto, você pode escolher outro valor. A quantidade mínima de horas de uso do nó para classificação de imagem é 8. Para detecção de objetos, esse valor mínimo é 20.

    definir a seção de orçamento do nó
  7. Selecione Iniciar treinamento para começar o treinamento do modelo.

Esse processo pode levar várias horas para ser concluído. Depois que o modelo for treinado, você receberá uma mensagem no endereço de e-mail que usou para o projeto do Google Cloud Platform.

REST e LINHA DE CMD

Ao treinar modelos do Edge, é possível especificar três valores distintos no campo modelType, dependendo das necessidades do seu modelo:

  • mobile-low-latency-1 para baixa latência
  • mobile-versatile-1 para uso geral
  • mobile-high-accuracy-1 para maior qualidade de previsão

Antes de usar os dados da 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 de sua escolha.
  • dataset-id: o ID do conjunto de dados. O ID é 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

Método HTTP e URL:

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

Corpo JSON da solicitação:

{
  "displayName": "display-name",
  "datasetId": "dataset-id",
  "imageClassificationModelMetadata": {
    "trainBudget": "1",
    "modelType": "mobile-low-latency-1"
  }
}

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/models

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/models" | Select-Object -Expand Content

Será exibida uma resposta semelhante a esta. Use o ID da operação (ICN2106290444865378475, neste caso) para ver 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/ICN2106290444865378475",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
    "createTime": "2019-10-30T20:06:08.253243Z",
    "updateTime": "2019-10-30T20:06:08.253243Z",
    "createModelDetails": {}
  }
}

C#

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

/// <summary>
/// Demonstrates using the AutoML client to create a model.
/// </summary>
/// <param name="projectId">GCP Project ID.</param>
/// <param name="datasetId">the Id of the dataset.</param>
/// <param name="displayName">The name of the dataset to be created.</param>
public static object VisionClassificationCreateModel(string projectId = "YOUR-PROJECT-ID",
    string datasetId = "YOUR_DATASET_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");
    // Set model metadata.
    ImageClassificationModelMetadata metadata = new ImageClassificationModelMetadata
    {
        TrainBudgetMilliNodeHours = 24000
    };
    Model model = new Model
    {
        DisplayName = displayName,
        DatasetId = datasetId,
        ImageClassificationModelMetadata = metadata
    };

    // Create a model with the model metadata in the region.
    Operation<Model, OperationMetadata> response =
        client.CreateModel(projectLocation, model);
    // Don't wait for model creation to finish, as this can take several hours.
    // However, you can use the `name` of the operation to check the status of your model.

    Console.WriteLine($"Training operation name: {response.Name}");
    Console.WriteLine("Training started...");
    return 0;
}

Go

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

import (
	"context"
	"fmt"
	"io"

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

// visionClassificationCreateModel creates a model for image classification.
func visionClassificationCreateModel(w io.Writer, projectID string, location string, datasetID string, modelName string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// datasetID := "ICN123456789..."
	// modelName := "model_display_name"

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

	req := &automlpb.CreateModelRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, location),
		Model: &automlpb.Model{
			DisplayName: modelName,
			DatasetId:   datasetID,
			ModelMetadata: &automlpb.Model_ImageClassificationModelMetadata{
				ImageClassificationModelMetadata: &automlpb.ImageClassificationModelMetadata{
					TrainBudgetMilliNodeHours: 1000, // 1000 milli-node hours are 1 hour
				},
			},
		},
	}

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

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ImageClassificationModelMetadata;
import com.google.cloud.automl.v1.LocationName;
import com.google.cloud.automl.v1.Model;
import com.google.cloud.automl.v1.OperationMetadata;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class VisionClassificationCreateModel {

  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 displayName = "YOUR_DATASET_NAME";
    createModel(projectId, datasetId, displayName);
  }

  // Create a model
  static void createModel(String projectId, String datasetId, 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");
      // Set model metadata.
      ImageClassificationModelMetadata metadata =
          ImageClassificationModelMetadata.newBuilder().setTrainBudgetMilliNodeHours(24000).build();
      Model model =
          Model.newBuilder()
              .setDisplayName(displayName)
              .setDatasetId(datasetId)
              .setImageClassificationModelMetadata(metadata)
              .build();

      // Create a model with the model metadata in the region.
      OperationFuture<Model, OperationMetadata> future =
          client.createModelAsync(projectLocation, model);
      // OperationFuture.get() will block until the model is created, which may take several hours.
      // You can use OperationFuture.getInitialFuture to get a future representing the initial
      // response to the request, which contains information while the operation is in progress.
      System.out.format("Training operation name: %s\n", future.getInitialFuture().get().getName());
      System.out.println("Training started...");
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const dataset_id = 'YOUR_DATASET_ID';
// 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 createModel() {
  // Construct request
  const request = {
    parent: client.locationPath(projectId, location),
    model: {
      displayName: displayName,
      datasetId: datasetId,
      imageClassificationModelMetadata: {
        trainBudgetMilliNodeHours: 24000,
      },
    },
  };

  // Don't wait for the LRO
  const [operation] = await client.createModel(request);
  console.log(`Training started... ${operation}`);
  console.log(`Training operation name: ${operation.name}`);
}

createModel();

PHP

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

use Google\Cloud\AutoMl\V1\AutoMlClient;
use Google\Cloud\AutoMl\V1\Model;
use Google\Cloud\AutoMl\V1\ImageClassificationModelMetadata;

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

$client = new AutoMlClient();

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

    // leave model unset to use the default base model provided by Google
    $metadata = new ImageClassificationModelMetadata();
    $model = (new Model())
        ->setDisplayName($displayName)
        ->setDatasetId($datasetId)
        ->setImageClassificationModelMetadata($metadata);

    // create model with above location and metadata
    $operationResponse = $client->createModel($formattedParent, $model);
    $operation = $operationResponse->getOperation();
    printf('Training operation name: %s' . PHP_EOL, $operation->getName());
    print('Training started...' . PHP_EOL);
} finally {
    $client->close();
}

Python

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

from google.cloud import automl

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

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, "us-central1")
# Leave model unset to use the default base model provided by Google
# train_budget_milli_node_hours: The actual train_cost will be equal or
# less than this value.
# https://cloud.google.com/automl/docs/reference/rpc/google.cloud.automl.v1#imageclassificationmodelmetadata
metadata = automl.types.ImageClassificationModelMetadata(
    train_budget_milli_node_hours=24000
)
model = automl.types.Model(
    display_name=display_name,
    dataset_id=dataset_id,
    image_classification_model_metadata=metadata,
)

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

print("Training operation name: {}".format(response.operation.name))
print("Training started...")

Ruby

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

require "google/cloud/automl"

project_id = "YOUR_PROJECT_ID"
dataset_id = "YOUR_DATASET_ID"
display_name = "YOUR_MODEL_NAME"

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

# A resource that represents Google Cloud Platform location.
project_location = client.location_path project_id, "us-central1"
# Leave model unset to use the default base model provided by Google
metadata = automl.types.ImageClassificationModelMetadata()
model = automl.types.Model(
  display_name = display_name,
  dataset_id = dataset_id,
  image_classification_model_metadata = metadata
)

# Create a model with the model metadata in the region.
operation = client.create_model project_location, model

puts "Training started..."

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

puts "Training complete."

Listar status das operações

Use as amostras de código a seguir para listar as operações do projeto e filtrar os resultados.

REST e LINHA DE CMD

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

  • project-id: ID do projeto do GCP.

Método HTTP e URL:

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

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

curl

Execute o seguinte comando:

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

PowerShell

Execute o seguinte comando:

$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" | Select-Object -Expand Content

A saída que você vê varia de acordo com as operações solicitadas.

Também é possível filtrar as operações retornadas usando os parâmetros de consulta selecionados (operationId, done e worksOn). Por exemplo, para retornar uma lista de operações que concluíram a execução, modifique o URL:

GET https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/operations?filter="done=true"

C#

Antes de testar esta amostra, siga as instruções de configuração para essa linguagem na página APIs e referência > Bibliotecas de cliente.

/// <summary>
/// Demonstrates using the AutoML client to list operations.
/// </summary>
/// <param name="projectId">GCP Project ID.</param>
public static object ListOperationStatus(string projectId = "YOUR-PROJECT-ID")
{
    // 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");

    // Create list operations request.
    ListOperationsRequest listrequest = new ListOperationsRequest
    {
        Name = projectLocation
    };

    // List all the operations names available in the region by applying filter.
    foreach (Operation operation in
      client.CreateModelOperationsClient.ListOperations(listrequest))
    {
        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

Antes de testar esta amostra, siga as instruções de configuração para essa linguagem na página APIs e referência > Bibliotecas de cliente.

import (
	"context"
	"fmt"
	"io"

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

// listOperationStatus lists existing operations' status.
func listOperationStatus(w io.Writer, projectID string, location string) error {
	// projectID := "my-project-id"
	// location := "us-central1"

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

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

	it := client.LROClient.ListOperations(ctx, req)

	// Iterate over all results
	for {
		op, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("ListOperations.Next: %v", err)
		}

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

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração para essa linguagem na página APIs e referência > Bibliotecas de cliente.

import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.LocationName;
import com.google.longrunning.ListOperationsRequest;
import com.google.longrunning.Operation;
import java.io.IOException;

class ListOperationStatus {

  static void listOperationStatus() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    listOperationStatus(projectId);
  }

  // Get the status of an operation
  static void listOperationStatus(String projectId) 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()) {
      // A resource that represents Google Cloud Platform location.
      LocationName projectLocation = LocationName.of(projectId, "us-central1");

      // Create list operations request.
      ListOperationsRequest listrequest =
          ListOperationsRequest.newBuilder().setName(projectLocation.toString()).build();

      // List all the operations names available in the region by applying filter.
      for (Operation operation :
          client.getOperationsClient().listOperations(listrequest).iterateAll()) {
        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\n", operation.getError().getMessage());
        }
      }
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração para essa linguagem na página APIs e referência > Bibliotecas de cliente.

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

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

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

async function listOperationStatus() {
  // Construct request
  const request = {
    name: client.locationPath(projectId, location),
    filter: '',
  };

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

  console.log('List of operation status:');
  for (const operation of response) {
    console.log(`Name: ${operation.name}`);
    console.log('Operation details:');
    console.log(`${operation}`);
  }
}

listOperationStatus();

PHP

Antes de testar esta amostra, siga as instruções de configuração para essa linguagem na página APIs e referência > Bibliotecas de cliente.

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 {
    // resource that represents Google Cloud Platform location
    $formattedName = $client->locationName(
        $projectId,
        $location
    );

    // list all operations
    $filter = '';
    $pagedResponse = $client->listOperations($formattedName, '');

    print('List of models' . PHP_EOL);
    foreach ($pagedResponse->iteratePages() as $page) {
        foreach ($page as $operation) {
            // display operation information
            printf('Operation name: %s' . PHP_EOL, $operation->getName());
            print('Operation details: ');
            print($operation);
        }
    }
} finally {
    if (isset($client)) {
        $client->close();
    }
}

Python

Antes de testar esta amostra, siga as instruções de configuração para essa linguagem na página APIs e referência > Bibliotecas de cliente.

from google.cloud import automl

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

client = automl.AutoMlClient()
# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, "us-central1")
# List all the operations names available in the region.
response = client.transport._operations_client.list_operations(
    project_location, ""
)

print("List of operations:")
for operation in response:
    print("Name: {}".format(operation.name))
    print("Operation details:")
    print(operation)

Como trabalhar com operações de longa duração

REST e LINHA DE CMD

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 operação. Ele é o último elemento do nome da 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#

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página APIs e referência > Bibliotecas de cliente.

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

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página APIs e referência > Bibliotecas de cliente.

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

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página APIs e referência > Bibliotecas de cliente.

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

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página APIs e referência > Bibliotecas de cliente.

/**
 * 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

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página APIs e referência > Bibliotecas de cliente.

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

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página APIs e referência > Bibliotecas de cliente.

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)

Como cancelar uma operação

É possível cancelar uma tarefa de importação ou treinamento. Basta usar o ID da operação.

REST e LINHA DE CMD

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

  • project-id: ID do projeto do GCP.
  • operation-id: ID da operação. Ele é o último elemento do nome da 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:

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

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

curl

Execute o seguinte comando:

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

PowerShell

Execute o seguinte comando:

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

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/operations/operation-id:cancel" | Select-Object -Expand Content
Você verá um objeto JSON vazio retornado de uma solicitação bem-sucedida:
{}

Como conseguir informações sobre um modelo

Quando o treinamento for concluído, será possível conseguir informações sobre o modelo recém-criado.

REST e LINHA DE CMD

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

  • project-id: ID do projeto do GCP.
  • model-id: ID do seu modelo, com base na resposta de quando você o criou. Ele é o último elemento no nome do modelo. Por exemplo:
    • nome do modelo: projects/project-id/locations/location-id/models/IOD4412217016962778756
    • ID do modelo: IOD4412217016962778756

Método HTTP e URL:

GET https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-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/models/model-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/models/model-id" | Select-Object -Expand Content

Você receberá uma resposta JSON semelhante a esta:



    {
  "name": "projects/project-id/locations/us-central1/models/model-id",
  "displayName": "display-name",
  "datasetId": "dataset-id",
  "createTime": "2019-10-30T20:06:08.253243Z",
  "deploymentState": "UNDEPLOYED",
  "updateTime": "2019-10-30T20:54:50.472328Z",
  "imageClassificationModelMetadata": {
    "trainBudget": "1",
    "modelType": "mobile-low-latency-1",
    "nodeQps": 3.2
  }
}

C#

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

/// <summary>
/// Demonstrates using the AutoML client to get a model by ID.
/// </summary>
/// <param name="projectId">GCP Project ID.</param>
/// <param name="modelId">the Id of the model.</param>
public static object GetModel(string projectId = "YOUR-PROJECT-ID",
    string modelId = "YOUR-MODEL-ID")
{
    // 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 full path of the model.
    string modelFullId = ModelName.Format(projectId, "us-central1", modelId);
    Model model = client.GetModel(modelFullId);

    // Display the model information.
    Console.WriteLine($"Model name: {model.Name}");
    Console.WriteLine($"Model id: {model.ModelName.ModelId}");
    Console.WriteLine($"Model display name: {model.DisplayName}");
    Console.WriteLine($"Model create time:");
    Console.WriteLine($"\tseconds: { model.CreateTime.Seconds}");
    Console.WriteLine($"\tnanos: {model.CreateTime.Nanos}");
    Console.WriteLine($"Model deployment state: { model.DeploymentState}");

    return 0;
}

Go

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

import (
	"context"
	"fmt"
	"io"

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

// getModel gets a model.
func getModel(w io.Writer, projectID string, location string, modelID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// modelID := "TRL123456789..."

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

	req := &automlpb.GetModelRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/models/%s", projectID, location, modelID),
	}

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

	// Retrieve deployment state.
	deploymentState := "undeployed"
	if model.GetDeploymentState() == automlpb.Model_DEPLOYED {
		deploymentState = "deployed"
	}

	// Display the model information.
	fmt.Fprintf(w, "Model name: %v\n", model.GetName())
	fmt.Fprintf(w, "Model display name: %v\n", model.GetDisplayName())
	fmt.Fprintf(w, "Model create time:\n")
	fmt.Fprintf(w, "\tseconds: %v\n", model.GetCreateTime().GetSeconds())
	fmt.Fprintf(w, "\tnanos: %v\n", model.GetCreateTime().GetNanos())
	fmt.Fprintf(w, "Model deployment state: %v\n", deploymentState)

	return nil
}

Java

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.Model;
import com.google.cloud.automl.v1.ModelName;
import java.io.IOException;

class GetModel {

  static void getModel() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    getModel(projectId, modelId);
  }

  // Get a model
  static void getModel(String projectId, String modelId) 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 full path of the model.
      ModelName modelFullId = ModelName.of(projectId, "us-central1", modelId);
      Model model = client.getModel(modelFullId);

      // Display the model information.
      System.out.format("Model name: %s\n", model.getName());
      // To get the model id, you have to parse it out of the `name` field. As models Ids are
      // required for other methods.
      // Name Format: `projects/{project_id}/locations/{location_id}/models/{model_id}`
      String[] names = model.getName().split("/");
      String retrievedModelId = names[names.length - 1];
      System.out.format("Model id: %s\n", retrievedModelId);
      System.out.format("Model display name: %s\n", model.getDisplayName());
      System.out.println("Model create time:");
      System.out.format("\tseconds: %s\n", model.getCreateTime().getSeconds());
      System.out.format("\tnanos: %s\n", model.getCreateTime().getNanos());
      System.out.format("Model deployment state: %s\n", model.getDeploymentState());
    }
  }
}

Node.js

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

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

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

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

async function getModel() {
  // Construct request
  const request = {
    name: client.modelPath(projectId, location, modelId),
  };

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

  console.log(`Model name: ${response.name}`);
  console.log(
    `Model id: ${
      response.name.split('/')[response.name.split('/').length - 1]
    }`
  );
  console.log(`Model display name: ${response.displayName}`);
  console.log('Model create time');
  console.log(`\tseconds ${response.createTime.seconds}`);
  console.log(`\tnanos ${response.createTime.nanos / 1e9}`);
  console.log(`Model deployment state: ${response.deploymentState}`);
}

getModel();

PHP

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

use Google\Cloud\AutoMl\V1\AutoMlClient;
use Google\Cloud\AutoMl\V1\Model\DeploymentState;

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

$client = new AutoMlClient();

try {
    // get full path of model
    $formattedName = $client->modelName(
        $projectId,
        $location,
        $modelId
    );

    $model = $client->getModel($formattedName);

    // retrieve deployment state
    if ($model->getDeploymentState() == DeploymentState::DEPLOYED) {
        $deployment_state = 'deployed';
    } else {
        $deployment_state = 'undeployed';
    }

    // display model information
    $splitName = explode('/', $model->getName());
    printf('Model name: %s' . PHP_EOL, $model->getName());
    printf('Model id: %s' . PHP_EOL, end($splitName));
    printf('Model display name: %s' . PHP_EOL, $model->getDisplayName());
    printf('Model create time' . PHP_EOL);
    printf('seconds: %d' . PHP_EOL, $model->getCreateTime()->getSeconds());
    printf('nanos : %d' . PHP_EOL, $model->getCreateTime()->getNanos());
    printf('Model deployment state: %s' . PHP_EOL, $deployment_state);
} finally {
    $client->close();
}

Python

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

from google.cloud import automl

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

client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, "us-central1", model_id)
model = client.get_model(model_full_id)

# Retrieve deployment state.
if model.deployment_state == automl.enums.Model.DeploymentState.DEPLOYED:
    deployment_state = "deployed"
else:
    deployment_state = "undeployed"

# Display the model information.
print("Model name: {}".format(model.name))
print("Model id: {}".format(model.name.split("/")[-1]))
print("Model display name: {}".format(model.display_name))
print("Model create time:")
print("\tseconds: {}".format(model.create_time.seconds))
print("\tnanos: {}".format(model.create_time.nanos))
print("Model deployment state: {}".format(deployment_state))

Ruby

Antes de testar esta amostra, siga as instruções de configuração dessa linguagem na página Bibliotecas de cliente.

require "google/cloud/automl"

project_id = "YOUR_PROJECT_ID"
model_id = "YOUR_MODEL_ID"

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

# Get the full path of the model.
model_full_id = client.class.model_path project_id, "us-central1", model_id

model = client.get_model model_full_id

# Retrieve deployment state.
deployment_state = if model.deployment_state == :DEPLOYED
                     "deployed"
                   else
                     "undeployed"
                   end

# Display the model information.
puts "Model name: #{model.name}"
puts "Model id: #{model.name.split('/').last}"
puts "Model display name: #{model.display_name}"
puts "Model create time: #{model.create_time.to_time}"
puts "Model deployment state: #{deployment_state}"

Treinamento recuperável

Agora é possível pausar e retomar o treinamento de modelo personalizado para grandes conjuntos de dados com mais de mil imagens.

IU da Web

  1. Abra o AutoML Vision UI.

    A página Conjuntos de dados mostra os conjuntos disponíveis para o projeto atual.

    Página da lista de conjuntos de dados
  2. Selecione aquele que você quer usar para treinar o modelo personalizado.

    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.

    Página de itens de imagem
  3. Quando terminar de revisar o conjunto de dados, selecione a guia Treinar logo abaixo da barra de título.

    Se você treinou modelos anteriormente, eles serão exibidos em uma lista nesta guia.

    Lista de modelos treinados
  4. Se o treinamento de um modelo for retomável, essa opção aparecerá ao lado de Ver avaliação completa.

    Selecione Retomar treinamento para continuar o treinamento em um modelo aplicável.

    Opção Retomar treinamento
  5. Assim como o treinamento do modelo original, selecionar Retomar treinamento abrirá uma janela lateral "Treinar novo modelo". Na seção Definir seu modelo, você pode alterar o nome do novo modelo. Você também verá o nome do modelo de base usado para treinar esse modelo.

    Definir a janela lateral do modelo

    Depois de definir o modelo, selecione Continuar para ir para a próxima seção.

  6. Na seção Definir um orçamento de hora de uso do nó, especifique um orçamento de hora de uso do nó. Esse orçamento está sujeito a uma estrutura de preços e restrições de cotas semelhantes ao treinamento inicial do modelo.

    Depois de especificar um orçamento de treinamento, selecione Iniciar treinamento. Você receberá um e-mail quando o treinamento retomável for concluído.

REST e LINHA DE CMD

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

  • base-model-id: o ID do modelo base (existente). O novo modelo é criado com base nesse modelo básico. As novas especificações de modelo a seguir precisam corresponder ao modelo base:

    * A base e o novo modelType serão verificados mesmo que esse campo seja omitido na nova solicitação de modelo.

  • project-id: o ID do projeto do GCP.
  • display-name: um nome de exibição de string de sua escolha.
  • dataset-id: o ID do conjunto de dados. O ID é 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

Método HTTP e URL:

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

Corpo JSON da solicitação:

{
  "baseModelId": base-model-id,
  "displayName": "display-name",
  "datasetId": "dataset-id",
  "imageClassificationModelMetadata": {
    "trainBudget": "1",
    "modelType": "mobile-low-latency-1"
  }
}

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/models

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/models" | Select-Object -Expand Content

Será exibida uma resposta semelhante a esta. Use o ID da operação (ICN2106290444865378475, neste caso) para ver 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/ICN2106290444865378475",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
    "createTime": "2019-10-30T20:06:08.253243Z",
    "updateTime": "2019-10-30T20:06:08.253243Z",
    "createModelDetails": {}
  }
}