Effectuer des prédictions individuelles

Après avoir créé (entraîné) un modèle et l'avoir déployé, vous pouvez effectuer des requêtes de prédiction en ligne (ou synchrones).

La durée de vie maximale d'un modèle personnalisé est de 18 mois dans le cadre du lancement de la version en disponibilité générale. Vous devrez créer un nouveau modèle et l'entraîner pour continuer à classifier le contenu au-delà de cette période.

Exemple de prédiction en ligne (individuelle)

Après avoir déployé le modèle que vous avez entraîné, vous pouvez lui demander de faire une prédiction pour une image à l'aide de la méthode predict ou utiliser l'UI pour obtenir des annotations de prédiction. La méthode predict applique des étiquettes aux cadres de délimitation des objets dans votre image.

Les performances de prédiction du modèle peuvent être affectées lorsque les cadres de prédiction sont inférieurs à 10 par 10 px.

Des frais vous sont facturés pour le déploiement du modèle. Après avoir effectué des prédictions avec le modèle entraîné, vous pouvez annuler le déploiement de votre modèle si vous ne souhaitez plus payer de frais d'utilisation pour son hébergement.

UI Web

1. Ouvrez l'UI de AutoML Vision Object Detection et cliquez sur l'onglet Modèles (avec l'icône représentant une ampoule) dans la barre de navigation de gauche pour afficher les modèles disponibles.

   Pour afficher les modèles d'un autre projet, sélectionnez le projet dans la liste déroulante située en haut à droite de la barre de titre.

2. Cliquez sur la ligne du modèle que vous souhaitez utiliser pour étiqueter vos images.

3. Si votre modèle n'est pas encore déployé, déployez-le maintenant en sélectionnant Déployer le modèle.

   Pour pouvoir utiliser les prédictions en ligne, le modèle doit être déployé. Le déploiement de votre modèle entraîne des frais. Pour plus d'informations, reportez-vous à la page des tarifs.

4. Cliquez sur l'onglet Test et utilisation situé juste en dessous de la barre de titre.

   

5. Cliquez sur Importer des images pour importer les images que vous souhaitez labelliser.

   

REST

Pour tester la prédiction, vous devez d'abord déployer votre modèle hébergé dans le cloud.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

• project-id : ID de votre projet GCP.
• model-id : ID de votre modèle, issu de la réponse obtenue lors de sa création. L'ID est le dernier élément du nom du modèle. Exemple :
  • Nom du modèle : projects/project-id/locations/location-id/models/IOD4412217016962778756
  • ID du modèle : IOD4412217016962778756
• base64-encoded-image : représentation en base64 (chaîne ASCII) de vos données d'image binaires. Cette chaîne doit ressembler à la chaîne suivante : /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q== Pour plus d'informations, consultez la section Encodage Base64.

Remarques sur les champs :

• scoreThreshold : une valeur comprise entre 0 et 1. Pour être affichées, les valeurs associées devront être supérieures ou égales à ces seuils de score. La valeur par défaut est 0,5.
• maxBoundingBoxCount : nombre maximal (limite supérieure) de cadres de délimitation à afficher dans une réponse. La valeur par défaut est 100 et la valeur maximale est 500. Cette valeur est soumise à des contraintes de ressources et peut être limitée par le serveur.

Méthode HTTP et URL :

POST https://automl.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/models/MODEL_ID:predict

Corps JSON de la requête :

{
  "payload": {
    "image": {
      "imageBytes": "BASE64_ENCODED_IMAGE"
    }
  },
  "params": {
    "scoreThreshold": "0.5",
    "maxBoundingBoxCount": "100"
  }
}

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter gcloud auth list pour vérifier le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: project-id" \
     -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

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter gcloud auth list pour vérifier le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

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

Le résultat est renvoyé au format JSON. Les prédictions de votre modèle de détection d'objets AutoML Vision sont contenues dans le champ payload :

• boundingBox d'un objet est spécifié par des sommets diagonalement opposés.
• displayName correspond à l'étiquette de l'objet prédit par le modèle de détection d'objets AutoML Vision.
• score représente le niveau de confiance que l'étiquette spécifiée applique à l'image. Ce score varie de 0 (aucune confiance) à 1 (confiance élevée).

Remarque : Les valeurs de coordonnées nulles sont ignorées. Lorsque l'API détecte une valeur de coordonnée ("x" ou "y") égale à zéro, cette coordonnée est ignorée dans la réponse JSON. Ainsi, une réponse qui contient les coordonnées de la zone d'intérêt ("boundingpoly") autour de l'image entière s'affiche au format
[{},{"x": 1,"y": 1}]. Pour en savoir plus, consultez la page Méthode : projects.locations.models.predict.

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

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.

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

	automl "cloud.google.com/go/automl/apiv1"
	"cloud.google.com/go/automl/apiv1/automlpb"
)

// 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: %w", err)
	}
	defer client.Close()

	file, err := os.Open(filePath)
	if err != nil {
		return fmt.Errorf("Open: %w", err)
	}
	defer file.Close()
	bytes, err := ioutil.ReadAll(file)
	if err != nil {
		return fmt.Errorf("ReadAll: %w", 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: %w", 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

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.

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

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.

/**
 * 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();

Python

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.

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 = automl.AutoMlClient.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.Image(image_bytes=content)
payload = automl.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"}

request = automl.PredictRequest(name=model_full_id, payload=payload, params=params)

response = prediction_client.predict(request=request)
print("Prediction results:")
for result in response.payload:
    print(f"Predicted class name: {result.display_name}")
    print(f"Predicted class score: {result.image_object_detection.score}")
    bounding_box = result.image_object_detection.bounding_box
    print("Normalized Vertices:")
    for vertex in bounding_box.normalized_vertices:
        print(f"\tX: {vertex.x}, Y: {vertex.y}")

Langages supplémentaires

C# : Veuillez suivre les Instructions de configuration pour C# sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur la détection d'objets AutoML Vision pour .NET.

PHP : Veuillez suivre les Instructions de configuration pour PHP sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur la détection d'objets AutoML Vision pour PHP.

Ruby : Veuillez suivre les Instructions de configuration de Ruby sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur la détection d'objets AutoML Vision pour Ruby.

Important : Le message d'erreur "Le modèle est en cours de mise en route. Veuillez réessayer ultérieurement." indique que vous devez attendre quelques minutes avant de réessayer d'interroger le modèle. Ce délai de mise en route peut survenir lorsque vous interrogez votre modèle pour la première fois ou lorsque vous effectuez une requête auprès d'un modèle qui n'a pas été interrogé récemment.