Cette page a été traduite par l'API Cloud Translation.

Tutoriel sur la classification de contenu

Audience

Ce tutoriel est conçu pour vous permettre d'explorer et de développer rapidement des applications avec l'API Cloud Natural Language. Il est conçu pour les personnes qui maîtrisent la programmation de base. Cependant, vous ne devriez pas avoir de souci à suivre ce tutoriel, même si vous n'avez aucune connaissance approfondie de la programmation. Après avoir parcouru ce tutoriel, vous devriez être capable de créer vos propres applications de base à l'aide de la documentation de référence.

Ce tutoriel vous présente une application Natural Language utilisant du code Python. Il ne s'agit pas ici d'expliquer les bibliothèques clientes Python, mais d'expliquer comment effectuer des appels à l'API Natural Language. Les applications Java et Node.js sont similaires pour l'essentiel. Consultez la rubrique Exemples de l'API Natural Language pour voir des exemples dans d'autres langages (y compris l'exemple de ce tutoriel).

Conditions préalables

Ce tutoriel a plusieurs prérequis :

Vous devez avoir configuré un projet Cloud Natural Language dans Google Cloud Console.
Vous devez avoir configuré votre environnement à l'aide des identifiants par défaut de l'application dans Google Cloud Console.
Vous êtes familiarisé avec Python dans le contexte de la programmation de Google Cloud Console.
Vous devez avoir configuré l'environnement de développement Python. Il est recommandé d'installer la dernière version de Python, pip et virtualenv sur votre système. Pour savoir comment faire, consultez le guide de configuration de l'environnement de développement Python pour Google Cloud Platform.
Vous devez avoir installé la bibliothèque cliente de Google Cloud pour Python.

Aperçu

Ce tutoriel vous guide à travers une application Natural Language de base, en utilisant des requêtes classifyText, qui classifient le contenu en catégories avec un score de confiance. Par exemple :

category: "/Internet & Telecom/Mobile & Wireless/Mobile Apps & Add-Ons"
confidence: 0.6499999761581421

Pour afficher la liste de tous les libellés de catégorie disponibles, consultez la section Catégories.

Dans ce tutoriel, vous allez créer une application pour effectuer les tâches suivantes :

Classer plusieurs fichiers texte et consigner le résultat dans un fichier d'index
Traiter le texte de la requête de saisie pour trouver des fichiers texte similaires
Traiter les libellés de catégorie des requêtes de saisie pour trouver des fichiers texte similaires

Le tutoriel s'appuie sur du contenu de Wikipédia. Vous pouvez créer une application similaire pour traiter des articles de presse, des commentaires en ligne, etc.

Fichiers source

Vous trouverez le code source du tutoriel dans la Exemples de bibliothèques clientes Python sur GitHub.

Ce tutoriel utilise un exemple de texte source de Wikipédia. Vous trouverez des exemples de fichiers texte resources/texts du projet GitHub.

Importer des bibliothèques

Pour utiliser l'API Cloud Natural Language, vous devez importer le module language à partir de la bibliothèque google-cloud-language. Le module language.types contient les classes nécessaires à la création des requêtes. Le module language.enums permet de spécifier le type du texte saisi. Ce tutoriel classe le contenu en texte brut (language.enums.Document.Type.PLAIN_TEXT).

Ce tutoriel utilise numpypour les calculs vectoriels afin de mesurer la similarité entre les textes en fonction de la classification de contenu obtenue.

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour Natural Language, consultez Bibliothèques clientes Natural Language. Pour en savoir plus, consultez les API Python Natural Language documentation de référence.

Pour vous authentifier auprès de Natural Language, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

import argparse
import json
import os

from google.cloud import language_v1
import numpy

1. Classer le contenu

Vous pouvez utiliser la bibliothèque cliente Python pour envoyer une requête à l'API Natural Language afin de classer le contenu. La bibliothèque cliente Python encapsule les informations sur les requêtes adressées à l'API Natural Language et sur les réponses obtenues.

La fonction classify du tutoriel appelle la méthode API Natural Language classifyText, en commençant par créer une instance de la classe LanguageServiceClient, puis en appelant la méthode classify_text de l'instance LanguageServiceClient.

La fonction classify du tutoriel ne classe que le contenu textuel de cet exemple. Vous pouvez également classifier le contenu d'une page Web en transmettant le code HTML source de la page Web comme text et en définissant le paramètre type sur language.enums.Document.Type.HTML.

Pour en savoir plus, consultez la page Classifier du contenu. Pour en savoir plus sur la structure des requêtes adressées à Natural Language, consultez la documentation de référence de Natural Language.

Python

def classify(text, verbose=True):
    """Classify the input text into categories."""

    language_client = language_v1.LanguageServiceClient()

    document = language_v1.Document(
        content=text, type_=language_v1.Document.Type.PLAIN_TEXT
    )
    response = language_client.classify_text(request={"document": document})
    categories = response.categories

    result = {}

    for category in categories:
        # Turn the categories into a dictionary of the form:
        # {category.name: category.confidence}, so that they can
        # be treated as a sparse vector.
        result[category.name] = category.confidence

    if verbose:
        print(text)
        for category in categories:
            print("=" * 20)
            print("{:<16}: {}".format("category", category.name))
            print("{:<16}: {}".format("confidence", category.confidence))

    return result

Le résultat renvoyé est un dictionnaire avec les libellés de catégorie sous forme de clés, et les scores de confiance sous forme de valeurs. Par exemple :

{
    "/Computers & Electronics": 0.800000011920929,
    "/Internet & Telecom/Mobile & Wireless/Mobile Apps & Add-Ons": 0.6499999761581421
}

Le script Python du tutoriel est organisé de manière à pouvoir être exécuté à partir de la ligne de commande pour réaliser des tests rapides. Par exemple, vous pouvez exécuter :

python classify_text_tutorial.py classify "Google Home enables users to speak voice commands to interact with services through the Home's intelligent personal assistant called Google Assistant. A large number of services, both in-house and third-party, are integrated, allowing users to listen to music, look at videos or photos, or receive news updates entirely by voice. "

Étape 2. Indexer plusieurs fichiers texte

La fonction index dans le script du tutoriel prend en entrée un répertoire contenant plusieurs fichiers texte ainsi que le chemin d'accès au fichier dans lequel il stocke la sortie indexée (le nom du fichier par défaut est index.json). La fonction index lit le contenu de chaque fichier texte dans le répertoire d'entrée, puis transmet les fichiers texte à l'API Cloud Natural Language qui les classifie en catégories de contenu.

Python

def index(path, index_file):
    """Classify each text file in a directory and write
    the results to the index_file.
    """

    result = {}
    for filename in os.listdir(path):
        file_path = os.path.join(path, filename)

        if not os.path.isfile(file_path):
            continue

        try:
            with open(file_path) as f:
                text = f.read()
                categories = classify(text, verbose=False)

                result[filename] = categories
        except Exception:
            print(f"Failed to process {file_path}")

    with open(index_file, "w", encoding="utf-8") as f:
        f.write(json.dumps(result, ensure_ascii=False))

    print(f"Texts indexed in file: {index_file}")
    return result

Les résultats de l'API Cloud Natural Language pour chaque fichier sont organisés dans un dictionnaire unique, sérialisés sous la forme d'une chaîne JSON, puis écrits dans un fichier. Exemple :

{
    "android.txt": {
        "/Computers & Electronics": 0.800000011920929,
        "/Internet & Telecom/Mobile & Wireless/Mobile Apps & Add-Ons": 0.6499999761581421
    },
    "google.txt": {
        "/Internet & Telecom": 0.5799999833106995,
        "/Business & Industrial": 0.5400000214576721
    }
}

Pour indexer des fichiers texte à partir de la ligne de commande avec le nom de fichier de sortie par défaut index.json, exécutez la commande suivante :

python classify_text_tutorial.py index resources/texts

Étape 3. Interroger l'index

Requête avec des libellés de catégorie

Une fois le fichier d'index défini (nom du fichier par défaut = index.json), nous pouvons effectuer des requêtes sur l'index pour récupérer certains des noms de fichiers et leurs scores de confiance.

Vous pouvez pour cela utiliser une étiquette de catégorie comme requête, ce que le tutoriel effectue avec la fonction query_category. L'implémentation des fonctions auxiliaires, telles que similarity, est disponible dans le fichier classify_text_tutorial.py. Dans vos applications, vous devez apporter un soin tout particulier à concevoir le classement et le score de similarité selon des cas spécifiques.

Python

def query_category(index_file, category_string, n_top=3):
    """Find the indexed files that are the most similar to
    the query label.

    The list of all available labels:
    https://cloud.google.com/natural-language/docs/categories
    """

    with open(index_file) as f:
        index = json.load(f)

    # Make the category_string into a dictionary so that it is
    # of the same format as what we get by calling classify.
    query_categories = {category_string: 1.0}

    similarities = []
    for filename, categories in index.items():
        similarities.append((filename, similarity(query_categories, categories)))

    similarities = sorted(similarities, key=lambda p: p[1], reverse=True)

    print("=" * 20)
    print(f"Query: {category_string}\n")
    print(f"\nMost similar {n_top} indexed texts:")
    for filename, sim in similarities[:n_top]:
        print(f"\tFilename: {filename}")
        print(f"\tSimilarity: {sim}")
        print("\n")

    return similarities

Pour obtenir la liste de toutes les catégories disponibles, reportez-vous à la page Catégories.

Comme auparavant, vous pouvez appeler la fonction query_category à partir de la ligne de commande :

python classify_text_tutorial.py query-category index.json "/Internet & Telecom/Mobile & Wireless"

Le résultat doit être semblable au résultat suivant :

Query: /Internet & Telecom/Mobile & Wireless


Most similar 3 indexed texts:
  Filename: android.txt
  Similarity: 0.665573579045


  Filename: google.txt
  Similarity: 0.517527175966


  Filename: gcp.txt
  Similarity: 0.5

Requête avec texte

Vous pouvez également effectuer des requêtes avec du texte qui ne fait peut-être pas partie du texte indexé. La fonction query du tutoriel est semblable à la fonction query_category, avec en plus l'étape d'envoi d'une requête classifyText pour la saisie de texte et l'utilisation des résultats pour interroger le fichier d'index.

Python

def query(index_file, text, n_top=3):
    """Find the indexed files that are the most similar to
    the query text.
    """

    with open(index_file) as f:
        index = json.load(f)

    # Get the categories of the query text.
    query_categories = classify(text, verbose=False)

    similarities = []
    for filename, categories in index.items():
        similarities.append((filename, similarity(query_categories, categories)))

    similarities = sorted(similarities, key=lambda p: p[1], reverse=True)

    print("=" * 20)
    print(f"Query: {text}\n")
    for category, confidence in query_categories.items():
        print(f"\tCategory: {category}, confidence: {confidence}")
    print(f"\nMost similar {n_top} indexed texts:")
    for filename, sim in similarities[:n_top]:
        print(f"\tFilename: {filename}")
        print(f"\tSimilarity: {sim}")
        print("\n")

    return similarities

Pour effectuer cette opération à partir de la ligne de commande, exécutez :

python classify_text_tutorial.py query index.json "Google Home enables users to speak voice commands to interact with services through the Home's intelligent personal assistant called Google Assistant. A large number of services, both in-house and third-party, are integrated, allowing users to listen to music, look at videos or photos, or receive news updates entirely by voice. "

Un résultat semblable aux lignes suivantes doit s'afficher :

Query: Google Home enables users to speak voice commands to interact with services through the Home's intelligent personal assistant called Google Assistant. A large number of services, both in-house and third-party, are integrated, allowing users to listen to music, look at videos or photos, or receive news updates entirely by voice.

  Category: /Internet & Telecom, confidence: 0.509999990463
  Category: /Computers & Electronics/Software, confidence: 0.550000011921

Most similar 3 indexed texts:
  Filename: android.txt
  Similarity: 0.600579500049


  Filename: google.txt
  Similarity: 0.401314790229


  Filename: gcp.txt
  Similarity: 0.38772339779

Étapes suivantes

L'API de classification de contenu vous permet de créer d'autres applications. Exemple :

Classer chaque paragraphe d'un article pour voir la transition entre les sujets.
Classer le contenu horodaté et analyser les tendances des sujets au fil du temps.
Comparer des catégories de contenu avec le sentiment du contenu à l'aide de la méthode analyzeSentiment.
Comparer des catégories de contenu aux entités mentionnées dans le texte.

Vous pouvez également utiliser d'autres produits Google Cloud Platform pour simplifier votre workflow:

Dans l'exemple d'application de ce tutoriel, nous avons traité des fichiers texte locaux, mais vous pouvez modifier le code pour traiter les fichiers stockés dans un bucket Google Cloud Storage en transmettant un URI Google Cloud Storage à la méthode classify_text.
Dans l'exemple d'application de ce tutoriel, nous avons stocké le fichier d'index en local et chaque requête est traitée en lisant l'intégralité du fichier d'index. Cela se traduit par une latence élevée si vous avez une grande quantité de données indexées ou si vous devez traiter de nombreuses requêtes. Le datastore est une solution qui se révèle à la fois naturelle et pratique pour stocker les données d'index.