Tutoriel sur l'analyse des sentiments

Audience

Ce tutoriel est conçu pour vous permettre d'explorer et de développer rapidement des applications avec l'API Google 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 de l'API 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 cet exemple dans le tutoriel).

Conditions préalables

Ce tutoriel a plusieurs prérequis :

• Vous disposez d'un compte Google Cloud. Si vous débutez sur la plate-forme, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
• Vous avez configuré un projet API Cloud Natural Language dans Google Cloud Console.
• Vous devez avoir configuré votre environnement à l'aide des identifiants par défaut de l'application.
• Vous possédez des connaissances de base en programmation Python.
• 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.

Analyser des sentiments dans des documents

Ce tutoriel vous présente une application de base de l'API Natural Language, à l'aide de la requête analyzeSentiment qui effectue une analyse des sentiments sur du texte. L'analyse des sentiments tente de déterminer l'attitude globale (positive ou négative) relevée dans un document. Elle est représentée par les valeurs numériques score et magnitude. (Pour plus d'informations sur ces concepts, consultez la section Principes de base de l'API Natural Language.)

Nous affichons d'abord l'ensemble du code. (Notez que nous avons supprimé la plupart des commentaires de ce code afin d'insister sur sa brièveté. Nous ajouterons d'autres commentaires en parcourant le code.)

Remarque : Pour copier le code dans le presse-papiers, cliquez sur le widget de copie qui apparaît en haut à droite de l'extrait de code lors du survol de cet extrait avec la souris. Copiez ensuite ce code dans un fichier sentiment_analysis.py de votre répertoire de développement.

Pour en savoir plus sur l'installation et l'utilisation de la bibliothèque cliente Google Cloud Natural Language pour Python, consultez la page Bibliothèques clientes de l'API Natural Language.

"""Demonstrates how to make a simple call to the Natural Language API."""

import argparse

from google.cloud import language_v1



def print_result(annotations):
    score = annotations.document_sentiment.score
    magnitude = annotations.document_sentiment.magnitude

    for index, sentence in enumerate(annotations.sentences):
        sentence_sentiment = sentence.sentiment.score
        print(f"Sentence {index} has a sentiment score of {sentence_sentiment}")

    print(f"Overall Sentiment: score of {score} with magnitude of {magnitude}")
    return 0




def analyze(movie_review_filename):
    """Run a sentiment analysis request on text within a passed filename."""
    client = language_v1.LanguageServiceClient()

    with open(movie_review_filename) as review_file:
        # Instantiates a plain text document.
        content = review_file.read()

    document = language_v1.Document(
        content=content, type_=language_v1.Document.Type.PLAIN_TEXT
    )
    annotations = client.analyze_sentiment(request={"document": document})

    # Print the results
    print_result(annotations)




if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument(
        "movie_review_filename",
        help="The filename of the movie review you'd like to analyze.",
    )
    args = parser.parse_args()

    analyze(args.movie_review_filename)

Cette application simple effectue les tâches suivantes :

• Elle importe les bibliothèques nécessaires pour exécuter l'application.
• Elle prend un fichier texte et le transmet à la fonction main().
• Elle lit le fichier texte et envoie une requête au service.
• Elle analyse la réponse du service et l'affiche à l'utilisateur.

Nous reviendrons plus en détail sur ces étapes ci-dessous.

Importer des bibliothèques

Pour en savoir plus sur l'installation et l'utilisation de la bibliothèque cliente Google Cloud Natural Language pour Python, consultez la page Bibliothèques clientes de l'API Natural Language.

import argparse

from google.cloud import language_v1

Nous importons argparse, une bibliothèque standard, pour permettre à l'application d'accepter les noms de fichiers d'entrée en tant qu'arguments.

Pour utiliser l'API Cloud Natural Language, nous allons également importer le module language à partir de la bibliothèque google-cloud-language. Le module types contient les classes nécessaires à la création des requêtes.

Exécuter l'application

if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument(
        "movie_review_filename",
        help="The filename of the movie review you'd like to analyze.",
    )
    args = parser.parse_args()

    analyze(args.movie_review_filename)

Ici, il suffit d'analyser l'argument transmis pour le nom de fichier texte et de le transmettre à la fonction analyze().

S'authentifier dans l'API

Avant de communiquer avec le service de l'API Natural Language, 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. Par défaut, la stratégie des identifiants par défaut de l'application (ADC, Application Default Credential) tente d'obtenir les identifiants à partir du fichier d'environnement GOOGLE_APPLICATION_CREDENTIALS. Ce fichier doit être défini pour pointer vers le fichier de clé JSON de votre compte de service. (Vous devez avoir configuré votre compte de service et votre environnement pour utiliser cette stratégie ADC dans le guide de démarrage rapide. Pour en savoir plus, consultez la page concernant la configuration d'un compte de service.)

La bibliothèque cliente Google Cloud pour Python utilise automatiquement les identifiants par défaut de l'application.

Envoyer la requête

Maintenant que notre service d'API Natural Language est prêt, nous pouvons accéder au service en appelant la méthode analyze_sentiment de l'instance LanguageServiceClient.

La bibliothèque cliente encapsule le détail des requêtes et des réponses de l'API. Consultez la documentation de référence sur l'API Natural Language pour obtenir des informations complètes sur la structure spécifique d'une telle requête.

Pour en savoir plus sur l'installation et l'utilisation de la bibliothèque cliente Google Cloud Natural Language pour Python, consultez la page Bibliothèques clientes de l'API Natural Language.

def analyze(movie_review_filename):
    """Run a sentiment analysis request on text within a passed filename."""
    client = language_v1.LanguageServiceClient()

    with open(movie_review_filename) as review_file:
        # Instantiates a plain text document.
        content = review_file.read()

    document = language_v1.Document(
        content=content, type_=language_v1.Document.Type.PLAIN_TEXT
    )
    annotations = client.analyze_sentiment(request={"document": document})

    # Print the results
    print_result(annotations)

Cet extrait de code effectue les tâches suivantes :

1. Il crée une instance LanguageServiceClient en tant que client.
2. Il lit le nom du fichier contenant les données de texte dans une variable.
3. Il crée une instance d'objet Document avec le contenu du fichier.
4. Il appelle la méthode analyze_sentiment du client.

Analyser la réponse

def print_result(annotations):
    score = annotations.document_sentiment.score
    magnitude = annotations.document_sentiment.magnitude

    for index, sentence in enumerate(annotations.sentences):
        sentence_sentiment = sentence.sentiment.score
        print(f"Sentence {index} has a sentiment score of {sentence_sentiment}")

    print(f"Overall Sentiment: score of {score} with magnitude of {magnitude}")
    return 0

Nous parcourons la réponse pour extraire les valeurs de sentiment score pour chaque phrase, ainsi que les valeurs globales score et magnitude pour l'ensemble de l'avis et les présenter à l'utilisateur.

Exécuter l'exemple

Pour exécuter l'exemple, nous allons le tester sur un ensemble de (faux) avis sur le film "Blade Runner".

1. Téléchargez les exemples à partir de Google Cloud Storage :

   gcloud storage cp gs://cloud-samples-tests/natural-language/sentiment-samples.tgz .
   

   Pour installer la dernière version de Google Cloud CLI, consultez la documentation de gcloud CLI.

2. Décompressez ces exemples pour créer un dossier "reviews" :

   gunzip sentiment-samples.tgz
   tar -xvf sentiment-samples.tar
   

3. Exécutez l'analyse des sentiments sur l'un des fichiers spécifiés :

   python sentiment_analysis.py reviews/bladerunner-pos.txt
   Sentence 0 has a sentiment score of 0.8
   Sentence 1 has a sentiment score of 0.9
   Sentence 2 has a sentiment score of 0.8
   Sentence 3 has a sentiment score of 0.2
   Sentence 4 has a sentiment score of 0.1
   Sentence 5 has a sentiment score of 0.4
   Sentence 6 has a sentiment score of 0.3
   Sentence 7 has a sentiment score of 0.4
   Sentence 8 has a sentiment score of 0.2
   Sentence 9 has a sentiment score of 0.9
   Overall Sentiment: score of 0.5 with magnitude of 5.5
   

L'exemple ci-dessus indiquerait un avis relativement positif (score de 0.5) et relativement émotionnel (magnitude de 5.5).

L'analyse exécutée sur les autres exemples doit produire des valeurs similaires à celles indiquées ci-dessous :

python sentiment_analysis.py reviews/bladerunner-neg.txt
...
Overall Sentiment: score of -0.6 with magnitude of 3.3

python sentiment_analysis.py reviews/bladerunner-mixed.txt
...
Overall Sentiment: score of 0 with magnitude of 4.7

python sentiment_analysis.py reviews/bladerunner-neutral.txt
...
Overall Sentiment: score of -0.1 with magnitude of 1.8

Notez que les valeurs de magnitude sont toutes similaires (indiquant un nombre de sentiments émotionnellement significatifs relativement égal) à l'exception du cas "neutre", qui indique un avis dénotant peu de sentiments émotionnels, qu'ils soient positifs ou négatifs. (Pour plus d'informations sur les scores et la magnitude des sentiments, ainsi que sur l'interprétation de ces valeurs, consultez la rubrique Interpréter les valeurs d'analyse des sentiments.)

Si vous souhaitez explorer l'analyse des sentiments avec plus de données, Stanford fournit un ensemble de données d'avis sur les films provenant de la base de données IMDB. Pour récupérer ces avis :

1. Téléchargez l'ensemble de données Large Movie Review.
2. Décompressez le fichier dans votre répertoire de travail. Les critiques de films sont réparties dans les répertoires pos et neg des répertoires de données train et test, chaque fichier contenant un avis de film.
3. Exécutez l'outil sentiment_analysis.py sur n'importe quel fichier texte d'avis de films.

Félicitations ! Vous avez effectué vos premières tâches d'inférence à l'aide de l'API Google Cloud Natural Language !