Esta página se ha traducido con Cloud Translation API.

Anotación de imágenes por lotes sin conexión

La API Vision puede ejecutar servicios de detección sin conexión (asíncronos) y de anotación de un gran lote de archivos de imagen mediante cualquier tipo de función de Vision. Por ejemplo, puede especificar una o varias funciones de la API Vision (como TEXT_DETECTION, LABEL_DETECTION y LANDMARK_DETECTION) para un solo lote de imágenes.

La salida de una solicitud por lotes sin conexión se escribe en un archivo JSON creado en el segmento de Cloud Storage especificado.

Solicitudes online (síncronas): una solicitud de anotación online (images:annotate o files:annotate) devuelve inmediatamente anotaciones insertadas al usuario. Las solicitudes de anotación online limitan el número de archivos que puedes anotar en una sola solicitud. Con una solicitud images:annotate, solo puedes especificar un número reducido de imágenes (≤16) para que se anoten. Con una solicitud files:annotate, solo puedes especificar un archivo y un número reducido de páginas (≤5) de ese archivo para que se anoten.
Solicitudes sin conexión (asíncronas): una solicitud de anotación sin conexión (images:asyncBatchAnnotate o files:asyncBatchAnnotate) inicia una operación de larga duración y no devuelve inmediatamente una respuesta a la persona que llama. Cuando se completa la operación de larga duración, las anotaciones se almacenan como archivos en un segmento de Cloud Storage que especifiques. Una solicitud images:asyncBatchAnnotate te permite especificar hasta 2000 imágenes por solicitud, mientras que una solicitud files:asyncBatchAnnotate te permite especificar lotes de archivos más grandes y más páginas (≤ 2000) por archivo para la anotación a la vez que con las solicitudes online.

Limitaciones

La API Vision acepta hasta 2000 archivos de imagen. Si se envía un lote más grande de archivos de imagen, se devolverá un error.

Tipos de funciones admitidos actualmente

Tipo de característica
`CROP_HINTS`	Determina los vértices sugeridos de una región de recorte en la imagen.
`DOCUMENT_TEXT_DETECTION`	Aplica reconocimiento óptico de caracteres (OCR) en imágenes con mucho texto (por ejemplo, si incluyen escritura a mano o son documentos en formato PDF o TIFF). `TEXT_DETECTION` se puede utilizar para mostrar imágenes cuyo texto esté disperso. Tiene prioridad cuando tanto `DOCUMENT_TEXT_DETECTION` como `TEXT_DETECTION` están presentes.
`FACE_DETECTION`	Detecta caras dentro de la imagen.
`IMAGE_PROPERTIES`	Calcula un conjunto de propiedades de la imagen, como los colores predominantes.
`LABEL_DETECTION`	Añade etiquetas en función del contenido de la imagen.
`LANDMARK_DETECTION`	Detecta puntos de referencia geográficos en la imagen.
`LOGO_DETECTION`	Detecta logotipos de empresa en la imagen.
`OBJECT_LOCALIZATION`	Detecta y extrae varios objetos de la imagen.
`SAFE_SEARCH_DETECTION`	Ejecuta Búsqueda Segura para detectar contenido potencialmente no seguro o no deseado.
`TEXT_DETECTION`	Aplica reconocimiento óptico de caracteres (OCR) en el texto de la imagen. La detección de texto está optimizada para las partes en las que el texto está disperso dentro de una imagen más grande. Si la imagen en cuestión es un documento (PDF/TIFF) o contiene un texto denso o escritura a mano, utiliza `DOCUMENT_TEXT_DETECTION` en su lugar.
`WEB_DETECTION`	Detecta entidades temáticas en una imagen (como noticias, eventos o personalidades famosas) y busca imágenes similares en Internet mediante la tecnología de la Búsqueda de Google Imágenes.

Código de muestra

Usa los siguientes ejemplos de código para ejecutar servicios de anotación sin conexión en un lote de archivos de imagen de Cloud Storage.

Nota: En los siguientes ejemplos de código, cada elemento de solicitud (requests_element/requestsElement) corresponde a una sola imagen. Para anotar más imágenes, cree un elemento request para cada imagen y añádalo a la matriz de solicitudes (requests).

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración de Java que se indican en la guía de inicio rápido de la API Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Vision en Java.

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

Antes de probar este ejemplo, sigue las instrucciones de configuración de Node.js que se indican en la guía de inicio rápido de Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de Vision.

Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

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

Antes de probar este ejemplo, sigue las instrucciones de configuración de Python que se indican en la guía de inicio rápido de Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de Vision.


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

Respuesta

Si la solicitud se realiza correctamente, se devuelven archivos JSON de respuesta en el segmento de Cloud Storage que hayas indicado en el código de ejemplo. El número de respuestas por archivo JSON se indica en batch_size en el ejemplo de código.

La respuesta devuelta es similar a las respuestas de las funciones de la API Vision normales, en función de las funciones que solicites para una imagen.

Las siguientes respuestas muestran anotaciones LABEL_DETECTION y TEXT_DETECTION para image1.png, anotaciones IMAGE_PROPERTIES para image2.jpg y anotaciones OBJECT_LOCALIZATION para image3.jpg.

La respuesta también contiene un campo context que muestra el URI del archivo.

`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
              }
            ]
          }
        }
      ]
    }
  ]
}