Como fazer previsões em lote

Depois de criar um modelo (treinado), faça uma solicitação de previsão assíncrona para um lote de imagens usando o método batchPredict. O método batchPredict aplica rótulos à imagem com base no objeto principal que seu modelo prevê.

A duração máxima de um modelo personalizado é de 18 meses a partir da versão em disponibilidade geral (GA, na sigla em inglês). É preciso criar e treinar um novo modelo para continuar anotando o conteúdo depois desse período.

Previsão em lote

É possível solicitar anotações (previsões) para imagens usando o comando batchPredict. O comando batchPredict recebe, como entrada, um arquivo CSV armazenado no seu bucket do Google Cloud Storage que contém os caminhos para as imagens a serem anotadas. Cada linha especifica um caminho separado para uma imagem no Google Cloud Storage.

batch_prediction.csv:

gs://my-cloud-storage-bucket/prediction_files/image1.jpg
gs://my-cloud-storage-bucket/prediction_files/image2.jpg
gs://my-cloud-storage-bucket/prediction_files/image3.jpg
gs://my-cloud-storage-bucket/prediction_files/image4.jpg
gs://my-cloud-storage-bucket/prediction_files/image5.jpg
gs://my-cloud-storage-bucket/prediction_files/image6.png

Dependendo do número de imagens que você especificou no arquivo CSV, a tarefa de previsão em lote pode demorar um pouco para ser concluída. Mesmo com um pequeno número de imagens, a previsão em lote levará, no mínimo, 30 minutos para ser concluída.

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.
  • location-id: um identificador de local válido. Atualmente, é preciso usar o seguinte valor:
    • us-central1
  • model-id: o ID do seu modelo, a partir da 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
  • 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 no bucket.
  • output-storage-bucket: um intervalo/diretório do Google Cloud Storage em que os arquivos de saída serão salvos, expressos no seguinte formato: gs://bucket/directory/. O usuário solicitante precisa ter permissão de gravação no bucket.

Considerações específicas de campo:

  • params.score_threshold - Um valor entre 0,0 e 1,0. Somente resultados com pontuações maiores ou iguais a esse valor serão retornados.

Método HTTP e URL:

POST https://automl.googleapis.com/v1/projects/project-id/locations/location-id/models/model-id:batchPredict

Corpo JSON da solicitação:

{
  "inputConfig": {
    "gcsSource": {
       "inputUris": [ "input-storage-path" ]
    }
  },
  "outputConfig": {
    "gcsDestination": {
      "outputUriPrefix": "output-storage-bucket"
    }
  },
  "params": {
    "score_threshold": "0.0"
  }
}

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/location-id/models/model-id:batchPredict

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/location-id/models/model-id:batchPredict" | Select-Object -Expand Content
Resposta:

O resultado será assim:

{
  "name": "projects/project-id/locations/location-id/operations/ICN926615623331479552",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
    "createTime": "2019-06-19T21:28:35.302067Z",
    "updateTime": "2019-06-19T21:28:35.302067Z",
    "batchPredictDetails": {
      "inputConfig": {
        "gcsSource": {
          "inputUris": [
            "input-storage-path"
          ]
        }
      }
    }
  }
}

Use o ID da operação (neste caso, ICN926615623331479552) para receber o status da tarefa. Veja um exemplo em Como trabalhar com operações de longa duração.

A tarefa de previsão em lote pode levar algum tempo para ser concluída, dependendo do número de imagens que você especificou no arquivo CSV. Mesmo em um pequeno número de imagens, a previsão em lote levará, no mínimo, 30 minutos para ser concluída.

Quando a operação for concluída, state será exibido como DONE e seus resultados serão gravados no arquivo do Google Cloud Storage especificado:

{
  "name": "projects/project-id/locations/location-id/operations/ICN926615623331479552",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
    "createTime": "2019-06-19T21:28:35.302067Z",
    "updateTime": "2019-06-19T21:57:18.310033Z",
    "batchPredictDetails": {
      "inputConfig": {
        "gcsSource": {
          "inputUris": [
            "input-storage-path"
          ]
        }
      },
      "outputInfo": {
        "gcsOutputDirectory": "gs://storage-bucket-vcm/subdirectory/prediction-8370559933346329705-YYYY-MM-DDThh:mm:ss.sssZ"
      }
    }
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.BatchPredictResult"
  }
}

Veja um exemplo de arquivo de saída na seção Arquivos JSONL de saída abaixo.

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.BatchPredictInputConfig;
import com.google.cloud.automl.v1.BatchPredictOutputConfig;
import com.google.cloud.automl.v1.BatchPredictRequest;
import com.google.cloud.automl.v1.BatchPredictResult;
import com.google.cloud.automl.v1.GcsDestination;
import com.google.cloud.automl.v1.GcsSource;
import com.google.cloud.automl.v1.ModelName;
import com.google.cloud.automl.v1.OperationMetadata;
import com.google.cloud.automl.v1.PredictionServiceClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class BatchPredict {

  static void batchPredict() throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String inputUri = "gs://YOUR_BUCKET_ID/path_to_your_input_csv_or_jsonl";
    String outputUri = "gs://YOUR_BUCKET_ID/path_to_save_results/";
    batchPredict(projectId, modelId, inputUri, outputUri);
  }

  static void batchPredict(String projectId, String modelId, String inputUri, String outputUri)
      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 (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);
      GcsSource gcsSource = GcsSource.newBuilder().addInputUris(inputUri).build();
      BatchPredictInputConfig inputConfig =
          BatchPredictInputConfig.newBuilder().setGcsSource(gcsSource).build();
      GcsDestination gcsDestination =
          GcsDestination.newBuilder().setOutputUriPrefix(outputUri).build();
      BatchPredictOutputConfig outputConfig =
          BatchPredictOutputConfig.newBuilder().setGcsDestination(gcsDestination).build();
      BatchPredictRequest request =
          BatchPredictRequest.newBuilder()
              .setName(name.toString())
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .build();

      OperationFuture<BatchPredictResult, OperationMetadata> future =
          client.batchPredictAsync(request);

      System.out.println("Waiting for operation to complete...");
      BatchPredictResult response = future.get();
      System.out.println("Batch Prediction results saved to specified Cloud Storage bucket.");
    }
  }
}

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';
// const inputUri = 'gs://YOUR_BUCKET_ID/path_to_your_input_csv_or_jsonl';
// const outputUri = 'gs://YOUR_BUCKET_ID/path_to_save_results/';

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

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

async function batchPredict() {
  // Construct request
  const request = {
    name: client.modelPath(projectId, location, modelId),
    inputConfig: {
      gcsSource: {
        inputUris: [inputUri],
      },
    },
    outputConfig: {
      gcsDestination: {
        outputUriPrefix: outputUri,
      },
    },
  };

  const [operation] = await client.batchPredict(request);

  console.log('Waiting for operation to complete...');
  // Wait for operation to complete.
  const [response] = await operation.promise();
  console.log(
    `Batch Prediction results saved to Cloud Storage bucket. ${response}`
  );
}

batchPredict();

PHP

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

Ver no GitHub (em inglês) Feedback
use Google\Cloud\AutoMl\V1\BatchPredictInputConfig;
use Google\Cloud\AutoMl\V1\BatchPredictOutputConfig;
use Google\Cloud\AutoMl\V1\GcsSource;
use Google\Cloud\AutoMl\V1\GcsDestination;
use Google\Cloud\AutoMl\V1\PredictionServiceClient;

/** Uncomment and populate these variables in your code */
// $projectId = '[Google Cloud Project ID]';
// $location = 'us-central1';
// $modelId = 'my_model_id_123';
// $inputUri = 'gs://cloud-samples-data/text.txt';
// $outputUri = 'gs://YOUR_BUCKET_ID/path_to_store_results/';

$client = new PredictionServiceClient();

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

    // set the multiple GCS uri
    $gcsSource = (new GcsSource())
        ->setInputUri($inputUri);
    $inputConfig = (new BatchPredictInputConfig())
        ->setGcsSource($gcsSource);
    $gcsDestination = (new GcsDestination())
        ->setInputUri($outputUri);
    $outputConfig = (new BatchPredictOutputConfig())
        ->setGcsDestination($gcsDestination);
    // params is additional domain-specific parameters
    // score_threshold is used to filter the result
    $params = ['score_threshold' => '0.8']; // value between 0.0 and 1.0

    $operationResponse = $client->batchPredict(
        $formattedName,
        $inputConfig,
        $outputConfig,
        $params
    );

    printf('Waiting for operation to complete...' . PHP_EOL);
    $operationResponse->pollUntilComplete();
    if ($operationResponse->operationSucceeded()) {
        $result = $operationResponse->getResult();
        printf('Batch Prediction results saved to Cloud Storage bucket. %s' . PHP_EOL, $result);
    } else {
        $error = $operationResponse->getError();
        print($error->getMessage());
    }
} finally {
    $client->close();
}

Python

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

Ver no GitHub (em inglês) Feedback
from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"
# input_uri = "gs://YOUR_BUCKET_ID/path/to/your/input/csv_or_jsonl"
# output_uri = "gs://YOUR_BUCKET_ID/path/to/save/results/"

prediction_client = automl.PredictionServiceClient()

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

gcs_source = automl.types.GcsSource(input_uris=[input_uri])

input_config = automl.types.BatchPredictInputConfig(gcs_source=gcs_source)
gcs_destination = automl.types.GcsDestination(output_uri_prefix=output_uri)
output_config = automl.types.BatchPredictOutputConfig(
    gcs_destination=gcs_destination
)

response = prediction_client.batch_predict(
    model_full_id, input_config, output_config
)

print("Waiting for operation to complete...")
print(
    "Batch Prediction results saved to Cloud Storage bucket. {}".format(
        response.result()
    )
)

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"
input_uri = "gs://YOUR_BUCKET_ID/path_to_your_input_file.csv"
output_uri = "gs://YOUR_BUCKET_ID/path_to_save_results/"

prediction_client = Google::Cloud::AutoML.prediction_service

# Get the full path of the model.
model_full_id = prediction_client.model_path project: project_id,
                                             location: "us-central1",
                                             model: model_id
input_config = {
  gcs_source: {
    input_uris: [input_uri]
  }
}
output_config = {
  gcs_destination: {
    output_uri_prefix: output_uri
  }
}
# [0.0-1.0] Only produce results higher than this value
params = { "score_threshold" => "0.8" }

operation = prediction_client.batch_predict name: model_full_id,
                                            input_config: input_config,
                                            output_config: output_config,
                                            params: params

puts "Waiting for operation to complete..."

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

puts "Batch Prediction results saved to Cloud Storage bucket."

Arquivos JSONL de saída

Quando a tarefa de previsão em lotes é concluída, a saída da previsão é armazenada no bucket do Google Cloud Storage especificado no seu comando.

No bucket de saída (se aplicável, no diretório especificado) os arquivos image_classification_1.jsonl, image_classification_2.jsonl, ..., image_classification_N.jsonl serão criados, onde N pode ser 1 e depende do número total das imagens e anotações previstas com êxito.

Uma única imagem será listada apenas uma vez com todas as suas anotações e elas nunca serão divididas entre os arquivos.

Cada arquivo JSONL conterá, por linha, uma representação JSON de um arquivo proto que une o ID da imagem: "<id_value>", seguido de uma lista de zero ou mais arquivos proto AnnotationPayload (chamados de anotações), que têm detalhes de classificação preenchidos.

Exemplo de arquivo JSONL:

image_image_classification_0.jsonl: um único arquivo .jsonl com quatro linhas, cada linha correspondendo a um JSON de anotação de arquivo de imagem.

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

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.

Ver no GitHub (em inglês) Feedback
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.

Ver no GitHub (em inglês) Feedback
/**
 * 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.

Ver no GitHub (em inglês) Feedback
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)