Tutoriel sur la détection sur le Web

Audience

L'objectif de ce tutoriel est de vous aider à développer des applications en faisant appel à la fonctionnalité de détection Web de l'API Cloud Vision. Nous partons du principe que vous maîtrisez les concepts et les techniques de programmation de base. Toutefois, même si vous êtes un programmeur débutant, vous pouvez suivre et exécuter ce tutoriel sans difficulté, puis utiliser la documentation de référence de l'API Cloud Vision pour créer des applications de base.

Ce tutoriel décrit une application de l'API Vision en vous montrant comment appeler cette API pour en utiliser la fonctionnalité de détection sur le Web.

Prérequis

Python

Présentation

Ce tutoriel vous présente une application de base de l'API Cloud Vision, qui utilise une requête Web detection. Une réponse Web detection annote l'image envoyée dans la requête avec :

  • des libellés obtenus à partir du Web ;
  • les URL de sites comportant des images correspondantes ;
  • les URL d'images du Web correspondant partiellement ou parfaitement à l'image de la requête ;
  • les URL d'images visuellement similaires.

Intégralité du code

Lorsque vous lisez le code, nous vous recommandons de vous reporter à la documentation de référence de l'API Cloud Vision pour 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))

Cette application simple effectue les tâches suivantes :

  • Elle importe les bibliothèques nécessaires pour exécuter l'application.
  • Elle utilise un chemin d'accès d'image en tant qu'argument et le transmet à la fonction main().
  • Elle utilise le client de l'API Google Cloud pour effectuer une détection sur le Web.
  • Elle effectue une boucle sur la réponse et affiche les résultats.
  • Elle affiche la liste des entités Web assorties d'une description et d'un score.
  • Elle affiche la liste des pages correspondantes.
  • Elle affiche la liste des images qui correspondent partiellement.
  • Elle affiche la liste des images qui correspondent parfaitement.

En détail

Importer des bibliothèques

import argparse

from google.cloud import vision

Nous importons des bibliothèques standards :

  • argparse pour autoriser l'application à accepter les noms de fichiers d'entrée comme arguments
  • io pour la lecture à partir des fichiers

Autres importations :

  • La classe ImageAnnotatorClient de la bibliothèque google.cloud.vision pour l'accès à l'API Cloud Vision.
  • Le module types de la bibliothèque google.cloud.vision pour la création des requêtes.

Exécuter l'application

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

Ici, nous analysons simplement l'argument transmis, qui spécifie l'URL de l'image Web, et nous le transmettons à la fonction main().

S'authentifier dans l'API

Avant de communiquer avec le service de l'API Vision, vous devez authentifier votre service avec les identifiants précédemment acquis. Dans une application, le moyen le plus simple d'obtenir des identifiants est d'utiliser les identifiants par défaut de l'application. La bibliothèque cliente obtient les identifiants automatiquement. Par défaut, elle accède pour cela aux identifiants de la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS, laquelle doit être définie de manière à pointer sur le fichier de clé JSON de votre compte de service (consultez la section Configurer un compte de service pour en savoir plus).

Construire la requête

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

Maintenant que le service de l'API Vision est prêt, nous pouvons créer une requête à lui envoyer.

Cet extrait de code effectue les tâches suivantes :

  1. Crée une instance ImageAnnotatorClient en tant que client.
  2. Crée un objet Image à partir d'un fichier local ou d'un URI.
  3. Transmet l'objet Image à la méthode web_detection du client.
  4. Il renvoie les annotations.

Afficher la réponse

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

Une fois l'opération terminée, nous parcourons WebDetection et nous affichons les entités et les URL contenues dans l'annotation (les deux premiers résultats de chaque type d'annotation sont présentés dans la section suivante).

Exécuter l'application

Pour exécuter l'application, nous transmettons l'URL Web (http://www.photos-public-domain.com/wp-content/uploads/2011/01/old-vw-bug-and-van.jpg) de l'image de voiture suivante.

Voici la commande Python avec l'URL Web de l'image de voiture transmise, suivie de la sortie de la console. Notez qu'un score de pertinence est ajouté après les entités répertoriées. Notez que les scores ne sont pas normalisés, ni comparables entre différentes requêtes d'image.

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

Félicitations ! Vous avez effectué une détection Web à l'aide de l'API Cloud Vision.