Generazione di previsioni individuali

Dopo aver creato (addestramento) un modello distribuito può effettuare richieste di previsione online (o sincrone).

La durata massima di un modello personalizzato è 18 mesi nell'ambito della release GA. Tu devi creare e addestrare un nuovo modello per continuare a classificare il contenuto molto tempo.

Esempio di previsione online (individuale)

Dopo aver eseguito il deployment del modello addestrato, puoi richiedere una previsione utilizzando il comando predict o utilizzare l'interfaccia utente per ottenere annotazioni di previsione. Il metodo predict applica le etichette ai riquadri di delimitazione degli oggetti dell'immagine.

Le prestazioni della previsione del modello possono risentirne quando le caselle previste vengono inferiore a 10 x 10 px.

Durante il deployment del modello vengono addebitati dei costi. Dopo aver fatto previsioni Con il tuo modello addestrato, puoi annullare il deployment del modello se non vuoi più incorrere in costi di utilizzo dell'hosting del modello.

UI web

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

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

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

3. Se non hai ancora eseguito il deployment del modello, eseguine il deployment selezionando Esegui il deployment del modello.

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

4. Fai clic sul pulsante Testa e Usa Tab 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 nel 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 quando hai creato il modello. L'ID è l'ultimo elemento del nome del modello. Ad esempio:
  • nome modello: projects/project-id/locations/location-id/models/IOD4412217016962778756
  • ID modello: IOD4412217016962778756
• base64-encoded-image: la base64 (stringa ASCII) dei dati dell'immagine binaria. Questa stringa dovrebbe essere simile alla la seguente stringa: /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==. Visita il codifica base64 per ulteriori informazioni.

Considerazioni specifiche sul campo:

• scoreThreshold: un valore compreso tra 0 e 1. Solo i valori con punteggio verranno visualizzate almeno 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:

curl

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'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 gcloud di Google. 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 a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login di Google. 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 tuo Il modello di rilevamento di oggetti di AutoML Vision è contenuto nel campo payload:

• boundingBox di un oggetto è specificato da vertici opposti diagonalmente.
• displayName è l'etichetta dell'oggetto prevista da AutoML Vision Rilevamento di oggetti un modello di machine learning.
• score rappresenta un livello di confidenza a cui si applica l'etichetta specificata dell'immagine. Varia da 0 (nessuna confidenza) a 1 (con confidenza alta).

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 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 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 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 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 per la configurazione di C# Nella pagina delle librerie client e poi visita Documentazione di riferimento per il rilevamento di oggetti di AutoML Vision per .NET.

PHP Segui le Istruzioni per la configurazione dei file PHP Nella pagina delle librerie client e poi visita Documentazione di riferimento per il rilevamento di oggetti di AutoML Vision per PHP.

Rubino: Segui le Istruzioni per la configurazione di Ruby Nella pagina delle librerie client e poi visita Documentazione di riferimento per il rilevamento di oggetti di AutoML Vision per Ruby.

Importante: viene visualizzato il messaggio di errore "Il modello è in fase di preparazione. Riprova più tardi." indica devi attendere alcuni minuti prima di riprovare a eseguire una query sul modello. Questo il ritardo di riscaldamento può verificarsi quando esegui una query iniziale sul modello o quando esegui una da un modello che non è stato oggetto di query di recente.