Tutorial de análise de sentimento

Público-alvo

Este tutorial foi criado para permitir que você comece a explorar e desenvolver aplicativos com a API Google Cloud Natural Language. Ele se destina a pessoas familiarizadas com a programação básica, ou seja, é possível acompanhá-lo mesmo se não tiver muito conhecimento. Após concluir este tutorial, você estará apto a usar a Documentação de referência para criar seus aplicativos básicos.

Neste tutorial, vamos trabalhar com um aplicativo da API Natural Language usando o código Python. O objetivo aqui não é explicar as bibliotecas de cliente Python, mas explicar como fazer chamadas para a API Natural Language. Aplicativos em Java e Node.js são basicamente similares. Para outras linguagens, consulte as Amostras da Natural Language API, inclusive a deste tutorial.

Pré-requisitos

Os pré-requisitos para este tutorial são:

Como analisar sentimentos no documento

Este tutorial orienta você em um aplicativo básico da API Natural Language, usando uma solicitação analyzeSentiment, que realiza a análise de sentimento no texto. A análise de sentimento tenta determinar a atitude geral (positiva ou negativa) e é representada por valores numéricos score e magnitude. (Para mais informações sobre esses conceitos, consulte Princípios básicos da Natural Language).

Primeiro, mostraremos todo o código. Retiramos grande parte dos comentários desse código para você ver como ele é curto. Forneceremos mais comentários à medida que analisarmos o código.

Para mais informações sobre como instalar e usar a biblioteca de cliente do Google Cloud Natural Language para Python, consulte Bibliotecas de cliente da 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)

Esse aplicativo simples:

  • Importa as bibliotecas necessárias para executar o aplicativo
  • Transmite um arquivo de texto para a função main()
  • Lê o arquivo de texto e criar uma solicitação para o serviço
  • analisar a resposta do serviço e exibi-la para o usuário

A seguir, veja essas etapas com mais detalhes.

Como importar bibliotecas

Para mais informações sobre como instalar e usar a biblioteca de cliente do Google Cloud Natural Language para Python, consulte Bibliotecas de cliente da API Natural Language. 
import argparse

from google.cloud import language_v1

Importamos argparse, uma biblioteca padrão, para permitir que o aplicativo aceite nomes de arquivos de entrada como argumentos.

Para usar a API Cloud Natural Language, também importaremos o módulo language da biblioteca google-cloud-language. O módulo types contém classes que são necessárias para criar solicitações.

Como executar o aplicativo

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)

Aqui, apenas analisamos o argumento transmitido como nome de arquivo de texto e enviamos esse nome para a função analyze().

Como autenticar com a API

Antes de iniciar a comunicação com o serviço da Natural Language API, é preciso autenticar o seu serviço usando as credenciais anteriormente recebidas. A maneira mais simples de receber credenciais em um aplicativo é usar o Application Default Credentials (ADC). No ADC, as credenciais são adquiridas a partir do arquivo de ambiente GOOGLE_APPLICATION_CREDENTIALS por padrão. Ele precisa apontar para o arquivo da chave JSON da sua conta de serviço. É necessário configurar essa conta de serviço e o ambiente para usar o ADC no Guia de início rápido. Para ver mais informações, consulte Como configurar uma conta de serviço.

A biblioteca de cliente do Google Cloud para Python usa automaticamente o Application Default Credentials.

Como fazer solicitações

Agora que o nosso serviço da API Natural Language está pronto, podemos acessar o serviço chamando o método analyze_sentiment da instância LanguageServiceClient.

A biblioteca de cliente encapsula os detalhes das solicitações e respostas para a API. Consulte a Referência da Natural Language API para informações detalhadas sobre a estrutura específica da solicitação.

Para mais informações sobre como instalar e usar a biblioteca de cliente do Google Cloud Natural Language para Python, consulte Bibliotecas de cliente da 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)

Esse snippet de código executa as seguintes tarefas:

  1. Cria uma instância LanguageServiceClient como o cliente
  2. Lê o nome de arquivo que contém os dados do texto em uma variável
  3. Cria uma instância de um objeto Document com o conteúdo do arquivo
  4. Chama o método analyze_sentiment do cliente

Como analisar a resposta

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

Analisamos a resposta para extrair os valores score de sentimento de cada frase e os valores gerais score e magnitude da análise completa e exibi-los ao usuário.

Executar a amostra

Para executar a nossa amostra, um conjunto de resenhas fictícias do filme "Blade Runner" será testado.

  1. Faça o download dos exemplos de código Google Cloud Storage:

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

    A gsutil geralmente é instalada como parte da gcloud CLI. Para instalar a versão mais recente da gcloud CLI, consulte a documentação da gcloud CLI.

  2. Descompacte as amostras. Uma pasta reviews será criada:

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

  3. Faça a análise de sentimentos em um dos arquivos especificados:

    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

O exemplo acima indica uma análise relativamente positiva (com pontuação de 0.5) e relativamente emocional (com magnitude de 5.5).

A análise dos outros exemplos produzirá valores semelhantes a estes:

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

Observe que as magnitudes são todas semelhantes, o que indica um grau relativo idêntico de sentimento emocionalmente significativo. A exceção é o caso "neutro", que indica uma resenha com sentimento não muito emocional, seja positivo ou negativo. Para mais informações sobre pontuações e magnitude de sentimentos e como interpretar esses valores, consulte Como interpretar valores da análise de sentimentos.

Explore a análise de sentimentos com mais dados usando o conjunto de dados de análises de filmes do IMDB fornecido pela Stanford. Para recuperar essas resenhas:

  1. faça o download do conjunto de dados de resenhas de filmes.
  2. descompacte o arquivo no diretório de trabalho. As análises de filmes são divididas em diretórios pos e neg dentro dos diretórios de dados train e test, com cada arquivo de texto contendo uma análise de filme.
  3. Execute a ferramenta sentiment_analysis.py em qualquer um dos arquivos de texto de análise de filme.

Parabéns! Você concluiu as primeiras tarefas de inferência com a API Google Cloud Natural Language.