Realiza predicciones individuales

Después de crear (entrenar) un modelo y de implementarlo, puedes realizar solicitudes de predicción en línea (o síncronas) en él.

Ejemplo de predicción en línea (individual)

Después de implementar el modelo entrenado, puedes solicitar una predicción para una imagen con el método predict o usar la IU a fin de obtener anotaciones de predicción. El método predict aplica etiquetas a los cuadros de límite de objetos de la imagen.

Tu modelo generará cargos mientras esté implementado. Luego de hacer predicciones con tu modelo entrenado, puedes anular su implementación si ya no deseas que se generen cargos por el uso de hosting del modelo.

IU web

  1. Abre la IU de la detección de objetos de Cloud AutoML Vision y haz clic en la pestaña Modelos (el ícono de la bombilla) en la barra de navegación izquierda para ver los modelos disponibles.

    Para ver los modelos de un proyecto diferente, puedes seleccionar el proyecto de la lista desplegable en la parte superior derecha de la barra de título.

  2. Haz clic en la fila del modelo que deseas usar para etiquetar tus imágenes.

  3. Si el modelo aún no se implementó, haz clic en Implementar modelo para implementarlo ahora.

    Se deben implementar los modelos para usar las predicciones en línea. La implementación de modelos genera costos. Para obtener más información, consulta la página Precios.

  4. Haz clic en la pestaña Test & Use (Prueba y uso) que se encuentra debajo de la barra de título.

    Página de modelos Probar y usar (Test & Use)

  5. Haz clic en Subir imágenes (Upload images) para subir las imágenes que deseas etiquetar.

    Página de predicción en una imagen subida

LÍNEA DE REST Y CMD

Para probar la predicción, primero debes implementar tu modelo alojado en Cloud.

Antes de usar cualquiera de los siguientes datos de solicitud, realiza estos reemplazos:

  • project-id: Es el ID de tu proyecto de GCP.
  • model-id: Es el ID de tu modelo, a partir de la respuesta que recibiste cuando lo creaste. El ID es el último elemento del nombre de tu modelo. Por ejemplo:
    • Nombre del modelo: projects/project-id/locations/location-id/models/IOD4412217016962778756
    • ID del modelo: IOD4412217016962778756
  • base64-encoded-image: Es la representación en Base64 (string ASCII) de los datos de la imagen binaria. Esta string debería ser similar a la siguiente: /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==. Para obtener más información, consulta el tema Codifica en Base64.

Consideraciones específicas del campo:

  • scoreThreshold: Es un valor de 0 a 1. Solo se mostrarán los valores que tengan umbrales de puntuación de este valor como mínimo. El valor predeterminado es 0.5.
  • maxBoundingBoxCount: Es el número más alto (límite superior) de cuadros de límite que se mostrarán en una respuesta. El valor predeterminado es 100 y el máximo es 500. Este valor está sujeto a restricciones de recursos y puede estar limitado por el servidor.

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

{
  "payload": {
    "image": {
      "imageBytes": "base64-encoded-image"
    }
  },
  "params": {
    "scoreThreshold": "0.5",
    "maxBoundingBoxCount": "100"
  }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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/model-id:predict

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$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/model-id:predict" | Select-Object -Expand Content

El resultado se muestra en formato JSON. Las predicciones del modelo de detección de objetos de AutoML Vision se encuentran en el campo payload:

  • El boundingBox de un objeto se especifica mediante vértices opuestos en diagonal.
  • displayName es la etiqueta del objeto que predijo el modelo de detección de objetos de AutoML Vision.
  • score representa un nivel de confianza que la etiqueta especificada aplica a la imagen. Va de 0 (sin confianza) a 1 (confianza alta).

{
  "payload": [
    {
      "imageObjectDetection": {
        "boundingBox": {
          "normalizedVertices": [
            {
              "x": 0.034553755,
              "y": 0.015524037
            },
            {
              "x": 0.941527,
              "y": 0.9912563
            }
          ]
        },
        "score": 0.9997793
      },
      "displayName": "Salad"
    },
    {
      "imageObjectDetection": {
        "boundingBox": {
          "normalizedVertices": [
            {
              "x": 0.11737197,
              "y": 0.7098793
            },
            {
              "x": 0.510878,
              "y": 0.87987
            }
          ]
        },
        "score": 0.63219965
      },
      "displayName": "Tomato"
    }
  ]
}

Go

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

import (
	"context"
	"fmt"
	"io"
	"io/ioutil"
	"os"

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

// visionObjectDetectionPredict does a prediction for image classification.
func visionObjectDetectionPredict(w io.Writer, projectID string, location string, modelID string, filePath string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// modelID := "IOD123456789..."
	// filePath := "path/to/image.jpg"

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

	file, err := os.Open(filePath)
	if err != nil {
		return fmt.Errorf("Open: %v", err)
	}
	defer file.Close()
	bytes, err := ioutil.ReadAll(file)
	if err != nil {
		return fmt.Errorf("ReadAll: %v", err)
	}

	req := &automlpb.PredictRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/models/%s", projectID, location, modelID),
		Payload: &automlpb.ExamplePayload{
			Payload: &automlpb.ExamplePayload_Image{
				Image: &automlpb.Image{
					Data: &automlpb.Image_ImageBytes{
						ImageBytes: bytes,
					},
				},
			},
		},
		// Params is additional domain-specific parameters.
		Params: map[string]string{
			// score_threshold is used to filter the result.
			"score_threshold": "0.8",
		},
	}

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

	for _, payload := range resp.GetPayload() {
		fmt.Fprintf(w, "Predicted class name: %v\n", payload.GetDisplayName())
		fmt.Fprintf(w, "Predicted class score: %v\n", payload.GetImageObjectDetection().GetScore())
		boundingBox := payload.GetImageObjectDetection().GetBoundingBox()
		fmt.Fprintf(w, "Normalized vertices:\n")
		for _, vertex := range boundingBox.GetNormalizedVertices() {
			fmt.Fprintf(w, "\tX: %v, Y: %v\n", vertex.GetX(), vertex.GetY())
		}
	}

	return nil
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

import com.google.cloud.automl.v1.AnnotationPayload;
import com.google.cloud.automl.v1.BoundingPoly;
import com.google.cloud.automl.v1.ExamplePayload;
import com.google.cloud.automl.v1.Image;
import com.google.cloud.automl.v1.ModelName;
import com.google.cloud.automl.v1.NormalizedVertex;
import com.google.cloud.automl.v1.PredictRequest;
import com.google.cloud.automl.v1.PredictResponse;
import com.google.cloud.automl.v1.PredictionServiceClient;
import com.google.protobuf.ByteString;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

class VisionObjectDetectionPredict {

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

  static void predict(String projectId, String modelId, String filePath) 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 (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);
      ByteString content = ByteString.copyFrom(Files.readAllBytes(Paths.get(filePath)));
      Image image = Image.newBuilder().setImageBytes(content).build();
      ExamplePayload payload = ExamplePayload.newBuilder().setImage(image).build();
      PredictRequest predictRequest =
          PredictRequest.newBuilder()
              .setName(name.toString())
              .setPayload(payload)
              .putParams(
                  "score_threshold", "0.5") // [0.0-1.0] Only produce results higher than this value
              .build();

      PredictResponse response = client.predict(predictRequest);
      for (AnnotationPayload annotationPayload : response.getPayloadList()) {
        System.out.format("Predicted class name: %s\n", annotationPayload.getDisplayName());
        System.out.format(
            "Predicted class score: %.2f\n",
            annotationPayload.getImageObjectDetection().getScore());
        BoundingPoly boundingPoly = annotationPayload.getImageObjectDetection().getBoundingBox();
        System.out.println("Normalized Vertices:");
        for (NormalizedVertex vertex : boundingPoly.getNormalizedVerticesList()) {
          System.out.format("\tX: %.2f, Y: %.2f\n", vertex.getX(), vertex.getY());
        }
      }
    }
  }
}

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas 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 filePath = 'path_to_local_file.jpg';

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

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

// Read the file content for translation.
const content = fs.readFileSync(filePath);

async function predict() {
  // Construct request
  // params is additional domain-specific parameters.
  // score_threshold is used to filter the result
  const request = {
    name: client.modelPath(projectId, location, modelId),
    payload: {
      image: {
        imageBytes: content,
      },
    },
    params: {
      score_threshold: '0.8',
    },
  };

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

  for (const annotationPayload of response.payload) {
    console.log(`Predicted class name: ${annotationPayload.displayName}`);
    console.log(
      `Predicted class score: ${annotationPayload.imageObjectDetection.score}`
    );
    console.log('Normalized vertices:');
    for (const vertex of annotationPayload.imageObjectDetection.boundingBox
      .normalizedVertices) {
      console.log(`\tX: ${vertex.x}, Y: ${vertex.y}`);
    }
  }
}

predict();

PHP

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

use Google\Cloud\AutoMl\V1\ExamplePayload;
use Google\Cloud\AutoMl\V1\Image;
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';
// $filePath = 'path_to_local_file.jpg';

$client = new PredictionServiceClient();

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

    // read the file
    $content = file_get_contents($filePath);
    $image = (new Image())
        ->setImageBytes($image);
    // create payload
    $payload = (new ExamplePayload())
        ->setImage($image);

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

    // predict with above model and payload
    $response = $client->predict($formattedName, $payload, $params);
    $annotations = $response->getPayload();

    // display results
    foreach ($annotations as $annotation) {
        $imageObjectDetection = $annotation->getImageObjectDetection();
        printf('Predicted class name: %s' . PHP_EOL, $annotation->getDisplayName());
        printf('Predicted class score: %s' . PHP_EOL, $imageObjectDetection->getScore());
        $vertices = $imageObjectDetection->getBoundingBox()
            ->getNormalizedVertices();
        print('Normalized bounding box vertices: ');
        foreach ($vertices as $vertex) {
            printf(' (%d, %d)', $vertex->getX(), $vertex->getY());
        }
        print(PHP_EOL);
    }
} finally {
    $client->close();
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

from google.cloud import automl

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

prediction_client = automl.PredictionServiceClient()

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

# Read the file.
with open(file_path, "rb") as content_file:
    content = content_file.read()

image = automl.types.Image(image_bytes=content)
payload = automl.types.ExamplePayload(image=image)

# params is additional domain-specific parameters.
# score_threshold is used to filter the result
# https://cloud.google.com/automl/docs/reference/rpc/google.cloud.automl.v1#predictrequest
params = {"score_threshold": "0.8"}

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.image_object_detection.score
        )
    )
    bounding_box = result.image_object_detection.bounding_box
    print("Normalized Vertices:")
    for vertex in bounding_box.normalized_vertices:
        print("\tX: {}, Y: {}".format(vertex.x, vertex.y))

Ruby

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

require "google/cloud/automl"

project_id = "YOUR_PROJECT_ID"
model_id = "YOUR_MODEL_ID"
file_path = "path_to_local_file.txt"

prediction_client = Google::Cloud::AutoML::Prediction.new

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

# Read the file.
content = File.binread file_path
payload = {
  image: {
    image_bytes: content
  }
}
# params is additional domain-specific parameters.
# score_threshold is used to filter the result
params = { "score_threshold" => "0.8" }

response = prediction_client.predict model_full_id, payload, params: params

puts "Prediction results:"
response.payload.each do |result|
  puts "Predicted class name: #{result.display_name}"
  puts "Predicted class score: #{result.image_object_detection.score}"
  bounding_box = result.image_object_detection.bounding_box
  puts "Normalized Vertices:"
  bounding_box.normalized_vertices.each do |vertex|
    puts "\tX: #{vertex.x}, Y: #{vertex.y}"
  end
end