Generazione di previsioni individuali

Dopo aver creato (addestrato) un modello e averne eseguito il deployment, puoi inviarvi richieste di previsione online (o sincrone).

La durata massima di un modello personalizzato è di 18 mesi con la release GA. Devi creare e addestrare un nuovo modello per continuare a classificare i contenuti dopo questo periodo di tempo.

Esempio di previsione online (singola)

Dopo aver eseguito il deployment del modello addestrato, puoi richiedere una previsione per un'immagine utilizzando il metodo predict oppure utilizzare l'interfaccia utente per ricevere annotazioni sulle previsioni. Il metodo predict applica le etichette ai riquadri di delimitazione degli oggetti nell'immagine.

Le prestazioni della previsione del modello possono risentirne quando i riquadri previsti sono inferiori a 10 x 10 px.

Durante il deployment del modello è previsto un addebito. Dopo aver effettuato previsioni con il modello addestrato, puoi undeploy del modello se non vuoi più incorrere in addebiti di utilizzo dell'hosting del modello.

UI web

1. Apri l'interfaccia utente di AutoML Vision Object Detection e fai clic sulla scheda Modelli (con l'icona a forma di lampadina) nella barra di navigazione a sinistra per visualizzare i modelli disponibili.

   Per visualizzare i modelli di un altro progetto, seleziona il progetto dall'elenco a discesa in alto a destra nella barra del titolo.

2. Fai clic sulla riga del modello che vuoi utilizzare per etichettare le immagini.

3. Se non è stato ancora eseguito il deployment del modello, esegui subito il deployment selezionando Esegui il deployment del modello.

   Per utilizzare le previsioni online, devi eseguire il deployment del modello. Il deployment del modello comporta costi. Per ulteriori informazioni, consulta la pagina dei prezzi.

4. Fai clic sulla scheda Testa e utilizza appena sotto la barra del titolo.

   

5. Fai clic su Carica immagini per caricare le immagini da etichettare.

   

REST

Per testare la previsione, devi prima eseguire il deployment del modello ospitato su cloud.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• project-id: l'ID del tuo progetto Google Cloud.
• model-id: l'ID del modello, dalla risposta al momento della creazione del modello. L'ID è l'ultimo elemento del nome del modello. Ad esempio:
  • nome del modello: projects/project-id/locations/location-id/models/IOD4412217016962778756
  • ID modello: IOD4412217016962778756
• base64-encoded-image: la rappresentazione base64 (stringa ASCII) dei dati di immagine binaria. Questa stringa dovrebbe essere simile alla seguente stringa: /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==. Per saperne di più, consulta l'argomento Codifica Base64.

Considerazioni specifiche sul campo:

• scoreThreshold: un valore compreso tra 0 e 1. Verranno visualizzati solo i valori con soglie di punteggio pari almeno a questo valore. Il valore predefinito è 0,5.
• maxBoundingBoxCount: il numero massimo (limite superiore) di riquadri di delimitazione da restituire in una risposta. Il valore predefinito è 100 e il massimo è 500. Questo valore è soggetto a vincoli delle risorse e potrebbe essere limitato dal server.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

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

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$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

L'output viene restituito in formato JSON. Le previsioni del modello di rilevamento di oggetti AutoML Vision sono contenute nel campo payload:

• Il valore boundingBox di un oggetto è specificato da vertici diagonalmente opposti.
• displayName è l'etichetta dell'oggetto prevista dal modello Rilevamento di oggetti AutoML Vision.
• score rappresenta un livello di confidenza che l'etichetta specificata viene applicata all'immagine. Varia da 0 (nessuna confidenza) a 1 (alta confidenza).

Nota: i valori delle coordinate pari a zero sono stati omessi. Quando l'API rileva un valore di coordinata ("x" o "y") pari a 0, la coordinata viene omessa nella risposta JSON. Pertanto, una risposta con un poligono di delimitazione intorno all'intera immagine sarebbe
[{},{"x": 1,"y": 1}]. Per ulteriori informazioni, consulta la pagina Metodo: projects.locations.models.recommend.

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

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

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e poi consulta la documentazione di riferimento di AutoML Vision Object Detection per .NET.

PHP: segui le istruzioni per la configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di AutoML Vision Object Detection per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di AutoML Vision Object Detection per Ruby.

Importante: è visualizzato il messaggio di errore "Il modello è in fase di preparazione. Riprova più tardi." indica che devi attendere qualche minuto prima di riprovare a eseguire la query. Questo ritardo di preparazione può verificarsi quando inizialmente esegui una query sul tuo modello o quando effettui una richiesta da un modello che non è stato oggetto di query di recente.