Como anotar imagens

Depois de criar (treinar) um modelo, você pode solicitar uma previsão para uma imagem usando o método predict. O método predict aplica rótulos à sua imagem com base no objeto principal da imagem que seu modelo prevê.

A vida útil máxima de um modelo personalizado é de dois anos. É necessário criar e treinar um novo modelo para continuar classificando o conteúdo após esse período.

Como usar o cURL

Para facilitar a execução das amostras de curl neste tópico, configure a variável do ambiente a seguir. Substitua project-id pelo nome do seu projeto do GCP.

export PROJECT_ID="project-id"

Exemplo de previsão

IU da Web

  1. Abra a IU do AutoML Vision e clique no ícone da lâmpada na barra de navegação à esquerda para exibir os modelos disponíveis.

    Para ver os modelos de outro projeto, selecione o projeto na lista suspensa na parte superior direita da barra de título.

  2. Clique na linha do modelo que você quer usar para rotular suas imagens.

  3. Clique na guia Prever logo abaixo da barra de título.

  4. Clique em Carregar imagens para fazer upload das imagens que você quer rotular.

Linha de comando

Para fazer uma previsão para uma imagem, informe o conteúdo da sua imagem no campo imageBytes. Ele precisa ser codificado em base64. Para mais informações sobre codificação base64 do conteúdo de uma imagem, consulte Codificação Base64.

O exemplo a seguir solicita uma previsão para uma imagem.

  • Substitua model-id pelo código do seu modelo. O código é o último elemento do nome do modelo. Por exemplo, se o nome do modelo for projects/434039606874/locations/us-central1/models/3745331181667467569, o código dele será 3745331181667467569.
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  https://automl.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/us-central1/models/model-id:predict \
  -d '{
        "payload" : {
          "image": {
            "imageBytes" : "/9j/4AAQSkZJRgABAQAAAQ … "
          },
        }
      }'

O resultado será semelhante a:

{
  "payload": [
    {
      "displayName": "Lily",
      "classification": {
        "score": 0.8989502
      }
    },
    {
      "displayName": "Daisy",
      "classification": {
        "score": 0.10098731
      }
    },
    {
      "displayName": "--other--",
      "classification": {
        "score": 6.2490464e-05
      }
    }
  ]
}

As previsões do seu modelo do AutoML Vision estão contidas no campo payload.

  • displayName é o rótulo previsto pelo modelo AutoML Vision.
  • score representa um nível de confiança que o rótulo especificado aplica à imagem. Varia de 0 (sem confiança) a 1 (alta confiança).

Python

Antes de executar este código de exemplo, você precisa instalar as bibliotecas de cliente do Python.

  • O parâmetro model_full_id é o nome completo do modelo. Por exemplo: projects/434039606874/locations/us-central1/models/3745331181667467569.
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'
# file_path = '/local/path/to/file'
# score_threshold = 'value from 0.0 to 0.5'

from google.cloud import automl_v1beta1 as automl

automl_client = automl.AutoMlClient()

# Get the full path of the model.
model_full_id = automl_client.model_path(
    project_id, compute_region, model_id
)

# Create client for prediction service.
prediction_client = automl.PredictionServiceClient()

# Read the image and assign to payload.
with open(file_path, "rb") as image_file:
    content = image_file.read()
payload = {"image": {"image_bytes": content}}

# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# Initialize params
params = {}
if score_threshold:
    params = {"score_threshold": score_threshold}

response = prediction_client.predict(model_full_id, payload, params)
print("Prediction results:")
for result in response.payload:
    print("Predicted class name: {}".format(result.display_name))
    print("Predicted class score: {}".format(result.classification.score))

Java


/**
 * Demonstrates using the AutoML client to predict an image.
 *
 * @param projectId the Id of the project.
 * @param computeRegion the Region name.
 * @param modelId the Id of the model which will be used for text classification.
 * @param filePath the Local text file path of the content to be classified.
 * @param scoreThreshold the Confidence score. Only classifications with confidence score above
 *     scoreThreshold are displayed.
 * @throws IOException on Input/Output errors.
 */
public static void predict(
    String projectId,
    String computeRegion,
    String modelId,
    String filePath,
    String scoreThreshold)
    throws IOException {

  // Instantiate client for prediction service.
  PredictionServiceClient predictionClient = PredictionServiceClient.create();

  // Get the full path of the model.
  ModelName name = ModelName.of(projectId, computeRegion, modelId);

  // Read the image and assign to payload.
  ByteString content = ByteString.copyFrom(Files.readAllBytes(Paths.get(filePath)));
  Image image = Image.newBuilder().setImageBytes(content).build();
  ExamplePayload examplePayload = ExamplePayload.newBuilder().setImage(image).build();

  // Additional parameters that can be provided for prediction e.g. Score Threshold
  Map<String, String> params = new HashMap<>();
  if (scoreThreshold != null) {
    params.put("score_threshold", scoreThreshold);
  }
  // Perform the AutoML Prediction request
  PredictResponse response = predictionClient.predict(name, examplePayload, params);

  System.out.println("Prediction results:");
  for (AnnotationPayload annotationPayload : response.getPayloadList()) {
    System.out.println("Predicted class name :" + annotationPayload.getDisplayName());
    System.out.println(
        "Predicted class score :" + annotationPayload.getClassification().getScore());
  }
}

Node.js

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

  // Create client for prediction service.
  const client = new automl.PredictionServiceClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = `The GCLOUD_PROJECT string, e.g. "my-gcloud-project"`;
  // const computeRegion = `region-name, e.g. "us-central1"`;
  // const modelId = `id of the model, e.g. “ICN12345”`;
  // const filePath = `local text file path of content to be classified, e.g. "./resources/test.txt"`;
  // const scoreThreshold = `value between 0.0 and 1.0, e.g. "0.5"';

  // Get the full path of the model.
  const modelFullId = client.modelPath(projectId, computeRegion, modelId);

  // Read the file content for prediction.
  const content = fs.readFileSync(filePath, 'base64');

  const params = {};

  if (scoreThreshold) {
    params.score_threshold = scoreThreshold;
  }

  // Set the payload by giving the content and type of the file.
  const payload = {};
  payload.image = {imageBytes: content};

  // params is additional domain-specific parameters.
  // currently there is no additional parameters supported.
  const [response] = await client.predict({
    name: modelFullId,
    payload: payload,
    params: params,
  });
  console.log(`Prediction results:`);
  response.payload.forEach(result => {
    console.log(`Predicted class name: ${result.displayName}`);
    console.log(`Predicted class score: ${result.classification.score}`);
  });

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

Enviar comentários sobre…

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