Annotazione immagini batch offline

L'API Vision può eseguire servizi di rilevamento offline (asincroni) e annotazione di un grande lotto di file immagine utilizzando qualsiasi tipo di elemento Vision. Ad esempio, puoi specificare una o più funzionalità dell'API Vision (ad esempio TEXT_DETECTION, LABEL_DETECTION e LANDMARK_DETECTION) per un singolo batch di immagini.

L'output di una richiesta batch offline viene scritto in un file JSON creato nel bucket Cloud Storage specificato.

Nota: tutti i tipi di funzionalità dell'API Vision offrono anche l'annotazione di immagini batch sincrona online. Le richieste sincrone online offrono una risposta immediata a una richiesta di annotazione. Per ulteriori informazioni, consulta le pagine di istruzioni.

• Richieste online (sincrone): una richiesta di annotazione online (images:annotate o files:annotate) restituisce immediatamente all'utente le annotazioni in linea. Le richieste di annotazione online limitano il numero di file che puoi annotare in una singola richiesta. Con una richiesta images:annotate puoi specificare solo un numero limitato di immagini (<=16) da annotare; con una richiesta files:annotate puoi specificare solo un singolo file e un numero limitato di pagine (<=5) da annotare in quel file.
• Richieste offline (asincrone): una richiesta di annotazione offline (images:asyncBatchAnnotate o files:asyncBatchAnnotate) avvia un'operazione a lunga esecuzione (LRO) e non restituisce immediatamente una risposta al chiamante. Al termine dell'operazione LRO, le annotazioni vengono archiviate come file in un bucket Cloud Storage specificato. Una richiesta images:asyncBatchAnnotate consente di specificare fino a 2000 immagini per richiesta, mentre una richiesta files:asyncBatchAnnotate consente di specificare più pagine (<=2000) per file per l'annotazione contemporaneamente rispetto alle richieste online.

Limitazioni

L'API Vision accetta fino a 2000 file immagine. Un batch più grande di file immagine riporterà un errore.

Nota: se in una richiesta batch sono presenti file che Cloud Vision non ha elaborato correttamente, invia nuovamente i file di cui non è andata a buon fine l'elaborazione per evitare di pagare per i file elaborati correttamente.

Tipi di funzionalità attualmente supportati

Tipo di caratteristica
CROP_HINTS	Determina i vertici suggeriti per un'area di ritaglio su un'immagine.
DOCUMENT_TEXT_DETECTION	Esegui l'OCR sulle immagini ad alta densità di testo, ad esempio documenti (PDF/TIFF) e immagini con scrittura a mano libera. TEXT_DETECTION può essere utilizzato per immagini con testo sparso. Ha la precedenza quando sono presenti sia DOCUMENT_TEXT_DETECTION che TEXT_DETECTION.
FACE_DETECTION	Rileva i volti all'interno dell'immagine.
IMAGE_PROPERTIES	Calcola un insieme di proprietà relative all'immagine, come i colori predominanti dell'immagine.
LABEL_DETECTION	Aggiungi etichette in base al contenuto dell'immagine.
LANDMARK_DETECTION	Rileva i punti di riferimento geografici nell'immagine.
LOGO_DETECTION	Rileva i loghi aziendali nell'immagine.
OBJECT_LOCALIZATION	Rileva ed estrai più oggetti in un'immagine.
SAFE_SEARCH_DETECTION	Esegui SafeSearch per rilevare contenuti potenzialmente non sicuri o indesiderati.
TEXT_DETECTION	Esegui il riconoscimento ottico dei caratteri (OCR) per il testo all'interno dell'immagine. Il rilevamento del testo è ottimizzato per aree di testo sparso all'interno di un'immagine più grande. Se l'immagine è un documento (PDF/TIFF), contiene testo ad alta densità o con scrittura a mano libera, utilizza invece DOCUMENT_TEXT_DETECTION.
WEB_DETECTION	Rileva entità suddivise per argomento, ad esempio notizie, eventi o celebrità all'interno dell'immagine e trova immagini simili sul Web grazie alla potenza della ricerca di immagini di Google.

Codice di esempio

Utilizza i seguenti esempi di codice per eseguire i servizi di annotazione offline su un batch di file immagine in Cloud Storage.

Nota: nei seguenti esempi di codice, ogni elemento di richiesta (requests_element/requestsElement) corrisponde a una singola immagine. Per annotare altre immagini, crea un elemento request per ogni immagine e aggiungilo all'array di richieste (requests).

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida dell'API Vision sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento Java dell'API Vision.

Nota: per gli utenti di Spring Framework Java, Spring Cloud Google Cloud offre un modo per configurare automaticamente le impostazioni di autenticazione e gli oggetti client per utilizzare l'API Vision.

import com.google.cloud.vision.v1.AnnotateImageRequest;
import com.google.cloud.vision.v1.AsyncBatchAnnotateImagesRequest;
import com.google.cloud.vision.v1.AsyncBatchAnnotateImagesResponse;
import com.google.cloud.vision.v1.Feature;
import com.google.cloud.vision.v1.GcsDestination;
import com.google.cloud.vision.v1.Image;
import com.google.cloud.vision.v1.ImageAnnotatorClient;
import com.google.cloud.vision.v1.ImageSource;
import com.google.cloud.vision.v1.OutputConfig;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class AsyncBatchAnnotateImages {

  public static void asyncBatchAnnotateImages()
      throws InterruptedException, ExecutionException, IOException {
    String inputImageUri = "gs://cloud-samples-data/vision/label/wakeupcat.jpg";
    String outputUri = "gs://YOUR_BUCKET_ID/path/to/save/results/";
    asyncBatchAnnotateImages(inputImageUri, outputUri);
  }

  public static void asyncBatchAnnotateImages(String inputImageUri, String outputUri)
      throws IOException, ExecutionException, InterruptedException {
    // 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 (ImageAnnotatorClient imageAnnotatorClient = ImageAnnotatorClient.create()) {

      // You can send multiple images to be annotated, this sample demonstrates how to do this with
      // one image. If you want to use multiple images, you have to create a `AnnotateImageRequest`
      // object for each image that you want annotated.
      // First specify where the vision api can find the image
      ImageSource source = ImageSource.newBuilder().setImageUri(inputImageUri).build();
      Image image = Image.newBuilder().setSource(source).build();

      // Set the type of annotation you want to perform on the image
      // https://cloud.google.com/vision/docs/reference/rpc/google.cloud.vision.v1#google.cloud.vision.v1.Feature.Type
      Feature feature = Feature.newBuilder().setType(Feature.Type.LABEL_DETECTION).build();

      // Build the request object for that one image. Note: for additional images you have to create
      // additional `AnnotateImageRequest` objects and store them in a list to be used below.
      AnnotateImageRequest imageRequest =
          AnnotateImageRequest.newBuilder().setImage(image).addFeatures(feature).build();

      // Set where to store the results for the images that will be annotated.
      GcsDestination gcsDestination = GcsDestination.newBuilder().setUri(outputUri).build();
      OutputConfig outputConfig =
          OutputConfig.newBuilder()
              .setGcsDestination(gcsDestination)
              .setBatchSize(2) // The max number of responses to output in each JSON file
              .build();

      // Add each `AnnotateImageRequest` object to the batch request and add the output config.
      AsyncBatchAnnotateImagesRequest request =
          AsyncBatchAnnotateImagesRequest.newBuilder()
              .addRequests(imageRequest)
              .setOutputConfig(outputConfig)
              .build();

      // Make the asynchronous batch request.
      AsyncBatchAnnotateImagesResponse response =
          imageAnnotatorClient.asyncBatchAnnotateImagesAsync(request).get();

      // The output is written to GCS with the provided output_uri as prefix
      String gcsOutputUri = response.getOutputConfig().getGcsDestination().getUri();
      System.out.format("Output written to GCS with prefix: %s%n", gcsOutputUri);
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Vision con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Vision Node.js.

Per autenticarti a Vision, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const inputImageUri = 'gs://cloud-samples-data/vision/label/wakeupcat.jpg';
// const outputUri = 'gs://YOUR_BUCKET_ID/path/to/save/results/';

// Imports the Google Cloud client libraries
const {ImageAnnotatorClient} = require('@google-cloud/vision').v1;

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

// You can send multiple images to be annotated, this sample demonstrates how to do this with
// one image. If you want to use multiple images, you have to create a request object for each image that you want annotated.
async function asyncBatchAnnotateImages() {
  // Set the type of annotation you want to perform on the image
  // https://cloud.google.com/vision/docs/reference/rpc/google.cloud.vision.v1#google.cloud.vision.v1.Feature.Type
  const features = [{type: 'LABEL_DETECTION'}];

  // Build the image request object for that one image. Note: for additional images you have to create
  // additional image request objects and store them in a list to be used below.
  const imageRequest = {
    image: {
      source: {
        imageUri: inputImageUri,
      },
    },
    features: features,
  };

  // Set where to store the results for the images that will be annotated.
  const outputConfig = {
    gcsDestination: {
      uri: outputUri,
    },
    batchSize: 2, // The max number of responses to output in each JSON file
  };

  // Add each image request object to the batch request and add the output config.
  const request = {
    requests: [
      imageRequest, // add additional request objects here
    ],
    outputConfig,
  };

  // Make the asynchronous batch request.
  const [operation] = await client.asyncBatchAnnotateImages(request);

  // Wait for the operation to complete
  const [filesResponse] = await operation.promise();

  // The output is written to GCS with the provided output_uri as prefix
  const destinationUri = filesResponse.outputConfig.gcsDestination.uri;
  console.log(`Output written to GCS with prefix: ${destinationUri}`);
}

asyncBatchAnnotateImages();

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python riportate nella guida rapida di Vision con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Vision Python.

Per autenticarti a Vision, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

from google.cloud import vision_v1


def sample_async_batch_annotate_images(
    input_image_uri="gs://cloud-samples-data/vision/label/wakeupcat.jpg",
    output_uri="gs://your-bucket/prefix/",
):
    """Perform async batch image annotation."""
    client = vision_v1.ImageAnnotatorClient()

    source = {"image_uri": input_image_uri}
    image = {"source": source}
    features = [
        {"type_": vision_v1.Feature.Type.LABEL_DETECTION},
        {"type_": vision_v1.Feature.Type.IMAGE_PROPERTIES},
    ]

    # Each requests element corresponds to a single image.  To annotate more
    # images, create a request element for each image and add it to
    # the array of requests
    requests = [{"image": image, "features": features}]
    gcs_destination = {"uri": output_uri}

    # The max number of responses to output in each JSON file
    batch_size = 2
    output_config = {"gcs_destination": gcs_destination, "batch_size": batch_size}

    operation = client.async_batch_annotate_images(
        requests=requests, output_config=output_config
    )

    print("Waiting for operation to complete...")
    response = operation.result(90)

    # The output is written to GCS with the provided output_uri as prefix
    gcs_output_uri = response.output_config.gcs_destination.uri
    print(f"Output written to GCS with prefix: {gcs_output_uri}")

Risposta

Una richiesta riuscita restituisce i file JSON di risposta nel bucket Cloud Storage indicato nell'esempio di codice. Il numero di risposte per file JSON è dettato da batch_size nell'esempio di codice.

La risposta restituita è simile alle risposte delle funzionalità dell'API Vision standard, a seconda delle funzionalità richieste per un'immagine.

Le seguenti risposte mostrano annotazioni LABEL_DETECTION e TEXT_DETECTION per image1.png, annotazioni IMAGE_PROPERTIES per image2.jpg e annotazioni OBJECT_LOCALIZATION per image3.jpg.

La risposta contiene anche un campo context che mostra l'URI del file.

offline_batch_output/output-1-to-2.json

{
  "responses": [
    {
      "labelAnnotations": [
        {
          "mid": "/m/07s6nbt",
          "description": "Text",
          "score": 0.93413997,
          "topicality": 0.93413997
        },
        {
          "mid": "/m/0dwx7",
          "description": "Logo",
          "score": 0.8733531,
          "topicality": 0.8733531
        },
        ...
        {
          "mid": "/m/03bxgrp",
          "description": "Company",
          "score": 0.5682425,
          "topicality": 0.5682425
        }
      ],
      "textAnnotations": [
        {
          "locale": "en",
          "description": "Google\n",
          "boundingPoly": {
            "vertices": [
              {
                "x": 72,
                "y": 40
              },
              {
                "x": 613,
                "y": 40
              },
              {
                "x": 613,
                "y": 233
              },
              {
                "x": 72,
                "y": 233
              }
            ]
          }
        },
        ...
                ],
                "blockType": "TEXT"
              }
            ]
          }
        ],
        "text": "Google\n"
      },
      "context": {
        "uri": "gs://cloud-samples-data/vision/document_understanding/image1.png"
      }
    },
    {
      "imagePropertiesAnnotation": {
        "dominantColors": {
          "colors": [
            {
              "color": {
                "red": 229,
                "green": 230,
                "blue": 238
              },
              "score": 0.2744754,
              "pixelFraction": 0.075339235
            },
            ...
            {
              "color": {
                "red": 86,
                "green": 87,
                "blue": 95
              },
              "score": 0.025770646,
              "pixelFraction": 0.13109145
            }
          ]
        }
      },
      "cropHintsAnnotation": {
        "cropHints": [
          {
            "boundingPoly": {
              "vertices": [
                {},
                {
                  "x": 1599
                },
                {
                  "x": 1599,
                  "y": 1199
                },
                {
                  "y": 1199
                }
              ]
            },
            "confidence": 0.79999995,
            "importanceFraction": 1
          }
        ]
      },
      "context": {
        "uri": "gs://cloud-samples-data/vision/document_understanding/image2.jpg"
      }
    }
  ]
}

offline_batch_output/output-3-to-3.json

{
  "responses": [
    {
      "context": {
        "uri": "gs://cloud-samples-data/vision/document_understanding/image3.jpg"
      },
      "localizedObjectAnnotations": [
        {
          "mid": "/m/0bt9lr",
          "name": "Dog",
          "score": 0.9669734,
          "boundingPoly": {
            "normalizedVertices": [
              {
                "x": 0.6035543,
                "y": 0.1357359
              },
              {
                "x": 0.98546547,
                "y": 0.1357359
              },
              {
                "x": 0.98546547,
                "y": 0.98426414
              },
              {
                "x": 0.6035543,
                "y": 0.98426414
              }
            ]
          }
        },
        ...
        {
          "mid": "/m/0jbk",
          "name": "Animal",
          "score": 0.58003056,
          "boundingPoly": {
            "normalizedVertices": [
              {
                "x": 0.014534635,
                "y": 0.1357359
              },
              {
                "x": 0.37197515,
                "y": 0.1357359
              },
              {
                "x": 0.37197515,
                "y": 0.98426414
              },
              {
                "x": 0.014534635,
                "y": 0.98426414
              }
            ]
          }
        }
      ]
    }
  ]
}