Análise de sentimentos | Twitter com Azure Cognitive Services
Tags: twitter, python, azure, api
Published: 2020-04-15 01:21:16

Com Python + Azure temos uma forma fácil de usar inteligência artificial em nossas aplicações

O objetivo desse artigo não é apresentar uma aplicação complexa, tenho como foco destrinchar o uso de API’s com inteligência artificial integrando com uma das maiores redes sociais do mundo.

O Twitter se tornou bem mais que apenas uma rede social, políticos o utilizam para se comunicarem diretamente com seu público, ameaçar outros governantes entre outras coisas possíveis no meio de muitos MEME’s e gifs engraçados. Para nós da área de tecnologia é um cenário repleto de dados que podemos analisar e foi isso que fiz, utilizado o Azure e a API do Twitter fiz uma análise de sentimentos de alguns Tweets de personalidades importantes atualmente.

## Twitter
O Twitter oferece acesso as suas APIs por meio do site deles, elas são os segmentadas em

- Standard API
- Premium API
- Enterprise API
- Ads API

Irei utilizar a Padrão (Standard API) que não é preciso pagar e também é a mais fácil de se ter acesso, como única exigência é preciso ter uma conta de desenvolvedor, ação bem simples de ser concluída, assim que fizer a inscrição basta esperar o e-mail de confirmação.

Já logado você vai entrar no site e criar o seu APP, assim que finalizado, vai ter acesso a sua API key e a API secret key (CUIDADO, apenas você de ter acesso a elas).

![API Twitter](https://miro.medium.com/max/700/1*W9Fn7xlNo9B2u6OiNmQHFA.png)



Com essas duas chaves você agora poderá integrar ao seu código

## O que é Azure Cognitive services?

A Microsoft oferece um meio de desenvolvedores que não tem conhecimentos avançados em inteligência artificial a implementarem em suas soluções tecnologias “Cognitivas”, ou seja, que emulam os serem humanos com funcionalidades como ver, ouvir, falar, pesquisar, entender e auxiliar na tomada de decisão.

Vamos utilizar a Análise de texto para identificar o sentimento em uma frase, um dos pontos fortes é que essa análise funciona tanto em português quanto em outros idiomas. É possível testar o recurso no próprio site deles:

![Teste da API de analise de sentimento no site do Azure](https://dev-to-uploads.s3.amazonaws.com/i/jtddc44wwx3w4xjhsb0q.png)


Assim que fizer o cadastro no Azure e criar um novo cognitive service vai receber o seu subscription_key e o endpoint no qual poderá consumir o serviço.

![Tela do serviço criado no Azure](https://miro.medium.com/max/700/1*a-6fnoNKL010NxmDvGE59Q.png)

Com as keys do Twitter(4 primeiros campos) e da API do Azure(2 últimos campos) vamos criar o env.json, nele teremos tudo que nosso projeto precisa para funcionar, ele vai ter esse formato:

![env.json](https://miro.medium.com/max/700/1*NkFlTuLRJmoGk1PH5co8wg.png)


###

Agora que temos tudo que precisamos,

## Vamos por a mão na massa!

Para criar uma aplicação simples primeiro vamos coletar os tweets da rede social, o módulo que vamos precisar importar primeiro é o tweepy, ele que vai nos ajudar a coletar as publicações de uma determinada conta, como exemplo estou coletando da minha pessoal @jeanjacques1999, defini para coletar até 500 tweets, você pode alterar essas variáveis.


```
# -*- coding: utf-8 -*-
import tweepy, json, os

def get_tweets():
    try:
        #Acessando o arquivo com as keys
        with open('env.json', 'r') as f:
            content = json.loads(f.read())
        f.close()
        
        chave_consumidor = content['chave_consumidor']
        segredo_consumidor = content['segredo_consumidor']
        token_acesso = content['token_acesso']
        token_acesso_segredo = content['token_acesso_segredo']

        #Fazendo a autenticão
        autenticacao = tweepy.OAuthHandler(chave_consumidor, segredo_consumidor)
        autenticacao.set_access_token(token_acesso, token_acesso_segredo)

        twitter = tweepy.API(autenticacao)

        #Fazendo as pesquisa (Você pode alterar o language)
        result = twitter.search(q='jeanjacques1999', count=1000, tweet_mode="extended")
        
        data = []
        for tweet in result:
            data.append({'id':str(tweet._json['id']), 'language':'pt', 'text':tweet._json['full_text']})

        return data
    except Exception as e:
        erro = "Encountered exception. {}".format(e)
        return erro 
```

A Função get_tweets() vai se conectar ao Twitter e retornar um JSON com o seguinte formato:

ID, language e text, a linguagem pode ser alterada no código para uma das seguintes suportadas:

![JSON que salva as informações](https://miro.medium.com/max/500/1*8g8S2oPp907HWeTBbeqU-g.png)

- Português (pt)
- Inglês (en)
- Espanhol (es)
- Francês (fr)
- Russo (ru)

O campo text é o corpo que será analisado pela nossa inteligência artificial, assim que retornamos todos os tweets vamos passa-los para outro método, que está em nosso main(), nossa função principal ficou assim:

```
from get_tweets import get_tweets
from cognitiveService import sentiment
import os, json

def main():
    #Coletandos os tweets
    tweet = get_tweets()
    insert_data(tweet)

    if(tweet):
        #Passando em nossa IA para identificar sentimento
        tweet_score = sentiment()
        insert_data(tweet_score)
    else:
        print(tweet)

def insert_data(data):
    #Apagando o arquivo caso ele exista
    dir = os.listdir()
    for file in dir:
        if file == "twitters.json":
            os.remove(file)

    #Inserindo os dados entro do arquivo twitters.json
    with open('twitters.json', 'a', encoding='utf-8') as f:
        json.dump(data, f)
    f.close()

if __name__ == "__main__":
    main()
```

No main() chamamos a função get_tweets() que mostrei anteriormente e então inserimos dentro do arquivo twitters.json, a análise de sentimento será feita na função sentiment() que vou mostrar a seguir. Para que ela funciona antes instale o pacote:

> pip install azure.cognitiveservices.language.textanalytics

```
# -*- coding: utf-8 -*-
import os, json
from azure.cognitiveservices.language.textanalytics import TextAnalyticsClient
from msrest.authentication import CognitiveServicesCredentials

#Acessando o arquivo com as keys
with open('env.json', 'r') as f:
    content = json.loads(f.read())
f.close()

subscription_key = content['subscription_key']
endpoint = content['endpoint']

def authenticateClient():
    credentials = CognitiveServicesCredentials(subscription_key)
    text_analytics_client = TextAnalyticsClient(
        endpoint=endpoint, credentials=credentials)
    return text_analytics_client

def sentiment():
    #Criando um client já autenticado
    client = authenticateClient()
    try:
        #Lendo os tweets que foram salvos anteriormente
        with open('twitters.json', 'r') as f:
            tweets = json.loads(f.read())

        #Fazendo a análise dos sentimentos
        response = client.sentiment(documents=tweets)
        sum_total = 0

        for index, document in enumerate(response.documents):
            tweets[index]["score"] = document.score
            sum_total += document.score

        #Calculo e mostro a média de Scores
        average = (sum_total/len(response.documents)) * 100
        print("Média dos Scores: {0:.2f}%".format(average))

        #Retornando os tweets com o score
        return tweets
    except Exception as err:
        print("Encountered exception. {}".format(err))
```

Chegamos na parte em que a mágica acontece, faço a leitura do arquivo que foi salvo anteriormente e passo para o meu client, o client autenticado é a nossa API do cognitive service que estamos consumindo diretamente do Azure. Quando o processo for finalizados vamos ter no mesmo JSON o seguinte resultado:

O Score foi adicionado ao nosso objeto e ele é a porcentagem do sentimento, quanto maior mais positivo/feliz o texto.

![JSON que salva as informações finais](https://miro.medium.com/max/500/1*AW4QTKarC3QcogFVzi2vsA.png)

Também optei por mostrar na tela uma média a qual diz se o twitter analisado é mais positivo ou negativo. O meu resultado ficou assim: “Média dos Scores: 46.20%”, poderia ter sido melhor claro 😅

## Analisando outros perfis

Vamos rodar o algoritmo em alguns perfis de pessoas influentes no Twitter

- Trump (@realDonaldTrump)

Média dos Scores: 53.41%
- Globo News (@GloboNews)

Média dos Scores: 36.32%
- Bolsonaro (@jairbolsonaro)

Média dos Scores: 52.24%
- Tabata Amaral (@tabataamaralsp)

Média dos Scores: 43.10%

# A Solução

Ao final de tudo vamos ter as seguintes informações

- Porcentual de felicidade em um tweet
- Média de felicidade de um perfil na rede social

Não tive como objetivo criar o melhor e mais completo programa para análise de sentimento aqui, só quis lhe mostrar como é possível iniciar algo que pode ter várias aplicações de uma forma bem rápida e com pouca enrolação.

Agora você pode baixar o código no GitHub e brincar a vontade. Veja quem é uma pessoa mais positiva na rede social, você ou seu amigo.

## Repositório Github

> Análise de sentimentos com Python e Azure - https://github.com/jjeanjacques10/analise-de-sentimento-python-azure


Caso tenha alguma crítica, sugestão ou dúvida fique a vontade para me enviar uma mensagem:

Linkedin: https://www.linkedin.com/in/jjean-jacques10/

Até a próxima!

# Referências

Azure Cognitive Services <https://azure.microsoft.com/pt-br/services/cognitive-services/text-analytics/ >Acesso em: 22 janeiro. 2020.

API do Twitter <https://developer.twitter.com/en/dashboard> Acesso em: 22 janeiro. 2020.