Instructivo de detección web

Público

El objetivo de este instructivo es ayudarte a desarrollar aplicaciones con la función de detección web de la API de Vision. Se supone que estás familiarizado con las construcciones y técnicas de programación básicas, pero incluso si eres un programador principiante, deberías poder seguir y ejecutar este instructivo sin problemas. Luego, usa la documentación de referencia de la API de Vision para crear aplicaciones básicas.

En este instructivo, se analiza una aplicación de la API de Vision y se muestra cómo realizar una llamada a la API de Vision para usar la característica de detección web.

Requisitos previos

Configura un proyecto de la API de Vision en la consola de Google Cloud.
Configura tu entorno para usar las credenciales predeterminadas de la aplicación.

Python

Instala Python.
Instala pip.
Instala la biblioteca cliente de Google Cloud.

Resumen

En este instructivo, se muestra una aplicación básica de la API de Vision que usa una solicitud de Web detection. Una respuesta de Web detection anota la imagen enviada en la solicitud con lo siguiente:

etiquetas obtenidas desde la Web
las URL de los sitios que tienen imágenes que coinciden
las URL de imágenes web que coinciden de forma parcial o total con la imagen de la solicitud
las URL de imágenes visualmente similares

Lee el código

A medida que leas el código, te recomendamos que consultes la Referencia de la API de Vision para Python.

import argparse

from google.cloud import vision

def annotate(path: str) -> vision.WebDetection:
    """Returns web annotations given the path to an image.

    Args:
        path: path to the input image.

    Returns:
        An WebDetection object with relevant information of the
        image from the internet (i.e., the annotations).
    """
    client = vision.ImageAnnotatorClient()

    if path.startswith("http") or path.startswith("gs:"):
        image = vision.Image()
        image.source.image_uri = path

    else:
        with open(path, "rb") as image_file:
            content = image_file.read()

        image = vision.Image(content=content)

    web_detection = client.web_detection(image=image).web_detection

    return web_detection

def report(annotations: vision.WebDetection) -> None:
    """Prints detected features in the provided web annotations.

    Args:
        annotations: The web annotations (WebDetection object) from which
        the features should be parsed and printed.
    """
    if annotations.pages_with_matching_images:
        print(
            f"\n{len(annotations.pages_with_matching_images)} Pages with matching images retrieved"
        )

        for page in annotations.pages_with_matching_images:
            print(f"Url   : {page.url}")

    if annotations.full_matching_images:
        print(f"\n{len(annotations.full_matching_images)} Full Matches found: ")

        for image in annotations.full_matching_images:
            print(f"Url  : {image.url}")

    if annotations.partial_matching_images:
        print(f"\n{len(annotations.partial_matching_images)} Partial Matches found: ")

        for image in annotations.partial_matching_images:
            print(f"Url  : {image.url}")

    if annotations.web_entities:
        print(f"\n{len(annotations.web_entities)} Web entities found: ")

        for entity in annotations.web_entities:
            print(f"Score      : {entity.score}")
            print(f"Description: {entity.description}")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    path_help = str(
        "The image to detect, can be web URI, "
        "Google Cloud Storage, or path to local file."
    )
    parser.add_argument("image_url", help=path_help)
    args = parser.parse_args()

    report(annotate(args.image_url))

Esta aplicación simple ejecuta las siguientes tareas:

Importa las bibliotecas necesarias para ejecutar la aplicación.
Toma una ruta de imagen como argumento y la pasa a la función main().
Usa el cliente de la API de Google Cloud para realizar la detección web.
Repite de forma indefinida la respuesta y, además, imprime los resultados.
Imprime la lista de entidades web con la descripción y la puntuación.
Imprime una lista de páginas que coinciden.
Imprime una lista de imágenes que coinciden de forma parcial.
Imprime una lista de las imágenes que coinciden en absoluto.

Información detallada

Importa bibliotecas

import argparse

from google.cloud import vision

Importamos las siguientes bibliotecas estándar:

argparse para permitir que la aplicación acepte los nombres de archivos de entrada como argumentos
io para leer archivos

Otras importaciones son:

La clase ImageAnnotatorClient dentro de la biblioteca google.cloud.vision para acceder a la API de Vision.
El módulo types dentro de la biblioteca google.cloud.vision para crear solicitudes

Ejecuta la aplicación

parser = argparse.ArgumentParser(
    description=__doc__,
    formatter_class=argparse.RawDescriptionHelpFormatter,
)
path_help = str(
    "The image to detect, can be web URI, "
    "Google Cloud Storage, or path to local file."
)
parser.add_argument("image_url", help=path_help)
args = parser.parse_args()

report(annotate(args.image_url))

Aquí analizamos el argumento ingresado que especifica la URL de la imagen web y lo pasamos a la función main().

Autenticar en la API

Antes de comunicarte con el servicio de la API de Vision, debes autenticar tu servicio con las credenciales ya adquiridas. Dentro de una aplicación, la manera más simple de obtener credenciales es usar las Credenciales predeterminadas de la aplicación (ADC). La biblioteca cliente obtiene las credenciales de forma automática. Según la configuración predeterminada, esto se realiza mediante la obtención de las credenciales de la variable de entorno GOOGLE_APPLICATION_CREDENTIALS, que debería estar configurada para que se oriente al archivo de claves JSON de tu cuenta de servicio (consulta Configura una cuenta de servicio si deseas obtener más información).

Crea la solicitud

client = vision.ImageAnnotatorClient()

if path.startswith("http") or path.startswith("gs:"):
    image = vision.Image()
    image.source.image_uri = path

else:
    with open(path, "rb") as image_file:
        content = image_file.read()

    image = vision.Image(content=content)

web_detection = client.web_detection(image=image).web_detection

Ahora que nuestro servicio de la API de Vision está listo, podemos generar una solicitud para el servicio.

Este fragmento de código realiza las siguientes tareas:

Crea una instancia ImageAnnotatorClient como cliente.
Crea un objeto Image a partir de un archivo local o de un URI.
Pasa el objeto Image al método web_detection del cliente.
Muestra las anotaciones.

Imprime la respuesta

if annotations.pages_with_matching_images:
    print(
        f"\n{len(annotations.pages_with_matching_images)} Pages with matching images retrieved"
    )

    for page in annotations.pages_with_matching_images:
        print(f"Url   : {page.url}")

if annotations.full_matching_images:
    print(f"\n{len(annotations.full_matching_images)} Full Matches found: ")

    for image in annotations.full_matching_images:
        print(f"Url  : {image.url}")

if annotations.partial_matching_images:
    print(f"\n{len(annotations.partial_matching_images)} Partial Matches found: ")

    for image in annotations.partial_matching_images:
        print(f"Url  : {image.url}")

if annotations.web_entities:
    print(f"\n{len(annotations.web_entities)} Web entities found: ")

    for entity in annotations.web_entities:
        print(f"Score      : {entity.score}")
        print(f"Description: {entity.description}")

Una vez que la operación se haya completado, explicaremos la WebDetection y, también, imprimiremos las entidades y las URL contenidas en la anotación (los dos resultados principales de cada tipo de anotación se muestran en la siguiente sección).

Ejecuta la aplicación

Para ejecutar la aplicación, pasamos la URL web (http://www.photos-public-domain.com/wp-content/uploads/2011/01/old-vw-bug-and-van.jpg) de la siguiente imagen del automóvil.

Aquí está el comando de Python, con la URL de web transferida de la imagen del automóvil, seguido del resultado de la consola. Ten en cuenta que una puntuación de relevancia se agrega después de las entidades enumeradas. También, observa que los resultados no se normalizan ni se comparan en diferentes consultas de imágenes.

python web_detect.py "http://www.photos-public-domain.com/wp-content/uploads/2011/01/old-vw-bug-and-van.jpg"

5 Pages with matching images retrieved
Url   : http://www.photos-public-domain.com/2011/01/07/old-volkswagen-bug-and-van/
Url   : http://pix-hd.com/old+volkswagen+van+for+sale
...

2 Full Matches found:
Url  : http://www.photos-public-domain.com/wp-content/uploads/2011/01/old-vw-bug-and-van.jpg
Url  : http://www.wbwagen.com/media/old-volkswagen-bug-and-van-picture-free-photograph-photos-public_s_66f487042adad5a6.jpg

4 Partial Matches found:
Url  : http://www.photos-public-domain.com/wp-content/uploads/2011/01/old-vw-bug-and-van.jpg
Url  : http://www.wbwagen.com/media/old-vw-bug-and-vanjpg_s_ac343d7f041b5f8d.jpg
...

5 Web entities found:
Score      : 5.35028934479
Description: Volkswagen Beetle
Score      : 1.43998003006
Description: Volkswagen
Score      : 0.828279972076
Description: Volkswagen Type 2
Score      : 0.75271999836
Description: Van
Score      : 0.690039992332
Description: Car

Como se esperaba, la detección web de Cloud Vision detectó y mostró en fullMatchingImages la URL de la imagen web que pasamos como entrada a la aplicación (la última URL que aparece arriba).

Felicitaciones Realizaste la detección web con la API de Vision.