Imaginați-vă că sunteți un proprietar de produs care dorește să știe ce spun oamenii despre produsul dvs. în social media. Poate că compania dvs. a lansat un produs nou și doriți să știți cum au reacționat oamenii la acesta. S-ar putea să doriți să utilizați un analizor de sentiment, cum ar fi MonkeyLearn sau Talkwalker. Dar nu ar fi mișto dacă ne-am putea face propriul analizor de sentimente? Să reușim atunci!

În acest tutorial, vom face un Telegram Bot care va face analiza sentimentelor tweet-urilor legate de cuvântul cheie pe care îl definim.

Dacă este pentru prima dată când construiți un bot Telegram, vă recomandăm să citiți acest post primul.

Noțiuni de bază

1. Instalați bibliotecile

Vom folosi tweepy pentru a aduna datele tweet. Noi vom folosi nltk pentru a ne ajuta să curățăm tweet-urile. API pentru limbaj natural Google va face analiza sentimentului. python-telegram-bot va trimite rezultatul prin chat Telegram.

pip3 install tweepy nltk google-cloud-language python-telegram-bot

2. Obțineți chei API Twitter

Pentru a putea colecta tweet-urile de pe Twitter, trebuie să creăm un cont de dezvoltator pentru a obține mai întâi cheile API Twitter.

Mergi la Dezvoltator Twitter și creați un cont dacă nu aveți unul.

ad-banner

Deschis Aplicații pagina, faceți clic pe „Creați o aplicație”, completați formularul și faceți clic pe „Creați”.

Faceți clic pe fila „Chei și jetoane”, copiați cheia API și cheia secretă API în secțiunea „Chei API consumator”.

Faceți clic pe butonul „Creați” din secțiunea „Acces token & access token secret”. Copiați jetonul de acces și secretul de jeton de acces care au fost generate.

Cum sa ti faci propriul analizor de sentimente folosind Python si

Grozav! Acum ar trebui să aveți patru chei – API Key, API Secret Key, Access Token și Access Token Secret. Salvați acele taste pentru utilizare ulterioară.

3. Activați Google Natural Language API

Mai întâi trebuie să activăm API-ul Google Natural Language dacă dorim să folosim serviciul.

Mergi la Consola pentru dezvoltatori Google și creați un proiect nou (sau selectați-l pe cel pe care îl aveți).

În tabloul de bord al proiectului, faceți clic pe „ENABLE APIS AND SERVICES” și căutați API-ul Cloud Natural Language.

1611509167 569 Cum sa ti faci propriul analizor de sentimente folosind Python si

Faceți clic pe „ENABLE” pentru a activa API-ul.

1611509168 828 Cum sa ti faci propriul analizor de sentimente folosind Python si

4. Creați cheia contului de serviciu

Dacă dorim să folosim serviciile Google Cloud precum Google Natural Language, avem nevoie de o cheie de cont de serviciu. Aceasta este ca acreditarea noastră de a utiliza serviciile Google.

Mergi la Consola pentru dezvoltatori Google, faceți clic pe fila „Acreditări”, alegeți „Creați acreditări” și faceți clic pe „Cheia contului de serviciu”.

1611509168 246 Cum sa ti faci propriul analizor de sentimente folosind Python si

Alegeți „Cont de serviciu implicit App Engine” și JSON ca tip de cheie, apoi faceți clic pe „Creați”.

1611509169 147 Cum sa ti faci propriul analizor de sentimente folosind Python si

Există un fișier .json care va fi descărcat automat, denumiți-l creds.json.

Seteaza GOOGLE_APPLICATION_CREDENTIALS cu calea noastră creds.json fișier în terminal.

export GOOGLE_APPLICATION_CREDENTIALS='[PATH_TO_CREDS.JSON]'

Dacă totul este bun, atunci este timpul să ne scriem programul.

Scrieți programul

Acest program va strânge toate tweet-urile care conțin cuvântul cheie definit în ultimele 24 de ore cu maximum 50 de tweets. Apoi va analiza sentimentele tweet-urilor unul câte unul. Vom trimite rezultatul (scor mediu al sentimentului) prin chat Telegram.

Acesta este un flux de lucru simplu al programului nostru.

conectați la API-ul Twitter – & gt; search tweets bazate pe cuvântul cheie -> curățați toate tweet-urile -> obțineți tweet-ul este trimisent scor -> trimiteți rezultatul

Să facem o singură funcție pentru a defini fiecare flux.

1. Conectați-vă la API-ul Twitter

Primul lucru pe care trebuie să-l facem este să adunăm datele tweet-urilor, așa că trebuie să ne conectăm mai întâi la API-ul Twitter.

Importați biblioteca tweepy.

import tweepy

Definiți cheile pe care le-am generat mai devreme.

ACC_TOKEN = 'YOUR_ACCESS_TOKEN'
ACC_SECRET = 'YOUR_ACCESS_TOKEN_SECRET'
CONS_KEY = 'YOUR_CONSUMER_API_KEY'
CONS_SECRET = 'YOUR_CONSUMER_API_SECRET_KEY'

Faceți o funcție numită authentication pentru a vă conecta la API, cu patru parametri care sunt toate cheile.

def authentication(cons_key, cons_secret, acc_token, acc_secret):
    auth = tweepy.OAuthHandler(cons_key, cons_secret)
    auth.set_access_token(acc_token, acc_secret)
    api = tweepy.API(auth)
    return api

2. Căutați tweet-urile

Putem căuta tweet-urile cu două criterii, în funcție de timp sau cantitate. Dacă se bazează pe timp, definim intervalul de timp și dacă se bazează pe cantitate, definim numărul total de tweeturi pe care dorim să le adunăm. Din moment ce dorim să adunăm tweet-urile din ultimele 24 de ore cu maximum tweets de 50, vom folosi ambele criterii.

Întrucât dorim să strângem tweet-urile din ultimele 24 de ore, să luăm data de ieri ca parametru de timp.

from datetime import datetime, timedelta

today_datetime = datetime.today().now()
yesterday_datetime = today_datetime - timedelta(days=1)
today_date = today_datetime.strftime('%Y-%m-%d')
yesterday_date = yesterday_datetime.strftime('%Y-%m-%d')

Conectați-vă la API-ul Twitter utilizând o funcție definită anterior.

api = authentication(CONS_KEY,CONS_SECRET,ACC_TOKEN,ACC_SECRET)

Definiți parametrii noștri de căutare. q aici ne definim cuvântul cheie, since este data de începere a căutării noastre, result_type="recent" înseamnă că vom lua cele mai noi tweets, lang='en' va lua doar tweet-urile englezești și items(total_tweets) este locul în care definim tweet-urile maxime pe care le vom lua.

search_result = tweepy.Cursor(api.search, 
                              q=keyword, 
                              since=yesterday_date,
                              result_type="recent", 
                              lang='en').items(total_tweets)

Înfășurați aceste coduri într-o funcție numită search_tweets cu keyword și total_tweets ca parametri.

def search_tweets(keyword, total_tweets):
    today_datetime = datetime.today().now()
    yesterday_datetime = today_datetime - timedelta(days=1)
    today_date = today_datetime.strftime('%Y-%m-%d')
    yesterday_date = yesterday_datetime.strftime('%Y-%m-%d')
    api = authentication(CONS_KEY,CONS_SECRET,ACC_TOKEN,ACC_SECRET)
    search_result = tweepy.Cursor(api.search, 
                                  q=keyword, 
                                  since=yesterday_date, 
                                  result_type="recent", 
                                  lang='en').items(total_tweets)
    return search_result

3. Curățați tweet-urile

Înainte de a analiza sentimentul tweet-urilor, trebuie să le curățăm puțin, astfel încât API-ul Google Natural Language să le poată identifica mai bine.

Vom folosi bibliotecile nltk și regex pentru a ne ajuta în acest proces.

import re
from nltk.tokenize import WordPunctTokenizer

Eliminăm numele de utilizator din fiecare tweet, deci practic putem elimina tot ce începe cu @ și folosim regex pentru ao face.

user_removed = re.sub(r'@[A-Za-z0-9]+','',tweet.decode('utf-8'))

De asemenea, eliminăm linkurile din fiecare tweet.

link_removed = re.sub('https?://[A-Za-z0-9./]+','',user_removed)

De asemenea, numerele sunt șterse din toate tweet-urile.

number_removed = re.sub('[^a-zA-Z]',' ',link_removed)

Ultimul, convertește toate caracterele în spațiu inferior, apoi îndepărtează fiecare spațiu inutil.

lower_case_tweet = number_removed.lower()
tok = WordPunctTokenizer()
words = tok.tokenize(lower_case_tweet)
clean_tweet = (' '.join(words)).strip()

Înfășurați aceste coduri într-o funcție numită clean_tweets cu tweet ca parametru al nostru.

def clean_tweets(tweet):
    user_removed = re.sub(r'@[A-Za-z0-9]+','',tweet.decode('utf-8'))
    link_removed = re.sub('https?://[A-Za-z0-9./]+','',user_removed)
    number_removed = re.sub('[^a-zA-Z]', ' ', link_removed)
    lower_case_tweet= number_removed.lower()
    tok = WordPunctTokenizer()
    words = tok.tokenize(lower_case_tweet)
    clean_tweet = (' '.join(words)).strip()
    return clean_tweet

4. Obțineți sentimentul tweet-ului

Pentru a putea obține sentimentul unui tweet, vom folosi Google Natural Language API.

API oferă analiza sentimentelor, analiza entităților și analiza sintaxei. Vom folosi analiza sentimentelor doar pentru acest tutorial.

În analiza sentimentelor Google, există score și magnitude. Score este scorul sentimentului variază de la -1,0 (foarte negativ) la 1,0 (foarte pozitiv). Magnitude este forța sentimentului și variază de la 0 la infinit.

Din simplitatea acestui tutorial, vom lua în considerare doar score. Dacă vă gândiți să faceți analize NLP profunde, ar trebui să luați în considerare magnitude de asemenea.

Importați biblioteca Google Natural Language.

from google.cloud import language
from google.cloud.language import enums
from google.cloud.language import types

Faceți o funcție numită get_sentiment_score care ia tweet ca parametru și returnează fișierul sentiment scor.

def get_sentiment_score(tweet):
    client = language.LanguageServiceClient()
    document = types
               .Document(content=tweet,
                         type=enums.Document.Type.PLAIN_TEXT)
    sentiment_score = client
                      .analyze_sentiment(document=document)
                      .document_sentiment
                      .score
    return sentiment_score

5. Analizează tweet-urile

Să facem o funcție care va bucla lista de tweets de la care primim search_tweets funcția și obțineți scorul sentimentului pentru fiecare tweet folosind get_sentiment_score funcţie. Apoi vom calcula media. Scorul mediu va determina dacă cuvântul cheie dat are un sentiment pozitiv, neutru sau negativ.

Defini score egal cu 0 , apoi folosiți search_tweets funcție pentru a obține tweet-urile legate de cuvântul cheie pe care le definim.

score = 0
tweets = search_tweets(keyword, total_tweets)

Parcurgeți lista de tweets și faceți curățarea folosind clean_tweets funcție pe care am creat-o înainte.

for tweet in tweets:
    cleaned_tweet = clean_tweets(tweet.text.encode('utf-8'))

Obțineți scorul de sentiment folosind get_sentiment_score funcție și creșteți score prin adăugarea sentiment_score.

for tweet in tweets:
    cleaned_tweet = clean_tweets(tweet.text.encode('utf-8'))
    sentiment_score = get_sentiment_score(cleaned_tweet)
    score += sentiment_score

Să imprimăm fiecare tweet și sentimentul său, astfel încât să putem vedea detaliile despre progres în terminal.

for tweet in tweets:
    cleaned_tweet = clean_tweets(tweet.text.encode('utf-8'))
    sentiment_score = get_sentiment_score(cleaned_tweet)
    score += sentiment_score
    print('Tweet: {}'.format(cleaned_tweet))
    print('Score: {}n'.format(sentiment_score))

Calculați scorul mediu și transmiteți-l final_score variabil. Înfășurați toate codurile în analyze_tweets funcție, cu keyword și total_tweets ca parametri.

def analyze_tweets(keyword, total_tweets):
    score = 0
    tweets = search_tweets(keyword, total_tweets)
    for tweet in tweets:
        cleaned_tweet = clean_tweets(tweet.text.encode('utf-8'))
        sentiment_score = get_sentiment_score(cleaned_tweet)
        score += sentiment_score
        print('Tweet: {}'.format(cleaned_tweet))
        print('Score: {}n'.format(sentiment_score))
    final_score = round((score / float(total_tweets)),2)
    return final_score

6. Trimiteți scorul de sentiment al tweet-ului

Să facem ultima funcție în fluxul de lucru. Această funcție va prelua cuvântul cheie al utilizatorului și va calcula scorul mediu al sentimentului. Apoi îl vom trimite prin Telegram Bot.

Obțineți cuvântul cheie de la utilizator.

keyword = update.message.text

Utilizare analyze_tweets funcție pentru a obține scorul final, keyword ca parametru nostru și setați total_tweets = 50 deoarece vrem să adunăm 50 de tweets.

final_score = analyze_tweets(keyword, 50)

Definim dacă un scor dat este considerat negativ, neutru sau pozitiv folosind intervalul de scor Google, așa cum vedem în imaginea de mai jos.

1611509169 795 Cum sa ti faci propriul analizor de sentimente folosind Python si
sursă: https://cloud.google.com/natural-language/
if final_score <= -0.25:
    status="NEGATIVE ❌"
elif final_score <= 0.25:
    status="NEUTRAL ?"
else:
    status="POSITIVE ✅"

În cele din urmă, trimiteți fișierul final_score si status prin Telegram Bot.

bot.send_message(chat_id=update.message.chat_id,
                 text="Average score for "
                       + str(keyword) 
                       + ' is ' 
                       + str(final_score) 
                       + ' ' 
                       + status)

Înfășurați codurile într-o funcție numită send_the_result.

def send_the_result(bot, update):
    keyword = update.message.text
    final_score = analyze_tweets(keyword, 50)
    if final_score <= -0.25:
        status="NEGATIVE ❌"
    elif final_score <= 0.25:
        status="NEUTRAL ?"
    else:
        status="POSITIVE ✅"
    bot.send_message(chat_id=update.message.chat_id,
                     text="Average score for "
                           + str(keyword) 
                           + ' is ' 
                           + str(final_score) 
                           + ' ' 
                           + status)

7. Programul principal

În cele din urmă, creați o altă funcție numită main pentru a rula programul nostru. Nu uitați să vă schimbați YOUR_TOKEN la simbolul robotului dvs.

from telegram.ext import Updater, MessageHandler, Filters

def main():
    updater = Updater('YOUR_TOKEN')
    dp = updater.dispatcher
    dp.add_handler(MessageHandler(Filters.text, send_the_result))
    updater.start_polling()
    updater.idle()
    
if __name__ == '__main__':
    main()

În cele din urmă, codul dvs. ar trebui să arate astfel

import tweepy
import re

from telegram.ext import Updater, MessageHandler, Filters
from google.cloud import language
from google.cloud.language import enums
from google.cloud.language import types
from datetime import datetime, timedelta
from nltk.tokenize import WordPunctTokenizer


ACC_TOKEN = 'YOUR_ACCESS_TOKEN'
ACC_SECRET = 'YOUR_ACCESS_TOKEN_SECRET'
CONS_KEY = 'YOUR_CONSUMER_API_KEY'
CONS_SECRET = 'YOUR_CONSUMER_API_SECRET_KEY'

def authentication(cons_key, cons_secret, acc_token, acc_secret):
    auth = tweepy.OAuthHandler(cons_key, cons_secret)
    auth.set_access_token(acc_token, acc_secret)
    api = tweepy.API(auth)
    return api
    
def search_tweets(keyword, total_tweets):
    today_datetime = datetime.today().now()
    yesterday_datetime = today_datetime - timedelta(days=1)
    today_date = today_datetime.strftime('%Y-%m-%d')
    yesterday_date = yesterday_datetime.strftime('%Y-%m-%d')
    api = authentication(CONS_KEY,CONS_SECRET,ACC_TOKEN,ACC_SECRET)
    search_result = tweepy.Cursor(api.search, 
                                  q=keyword, 
                                  since=yesterday_date, 
                                  result_type="recent", 
                                  lang='en').items(total_tweets)
    return search_result

def clean_tweets(tweet):
    user_removed = re.sub(r'@[A-Za-z0-9]+','',tweet.decode('utf-8'))
    link_removed = re.sub('https?://[A-Za-z0-9./]+','',user_removed)
    number_removed = re.sub('[^a-zA-Z]', ' ', link_removed)
    lower_case_tweet= number_removed.lower()
    tok = WordPunctTokenizer()
    words = tok.tokenize(lower_case_tweet)
    clean_tweet = (' '.join(words)).strip()
    return clean_tweet

def get_sentiment_score(tweet):
    client = language.LanguageServiceClient()
    document = types
               .Document(content=tweet,
                         type=enums.Document.Type.PLAIN_TEXT)
    sentiment_score = client
                      .analyze_sentiment(document=document)
                      .document_sentiment
                      .score
    return sentiment_score

def analyze_tweets(keyword, total_tweets):
    score = 0
    tweets = search_tweets(keyword,total_tweets)
    for tweet in tweets:
        cleaned_tweet = clean_tweets(tweet.text.encode('utf-8'))
        sentiment_score = get_sentiment_score(cleaned_tweet)
        score += sentiment_score
        print('Tweet: {}'.format(cleaned_tweet))
        print('Score: {}n'.format(sentiment_score))
    final_score = round((score / float(total_tweets)),2)
    return final_score

def send_the_result(bot, update):
    keyword = update.message.text
    final_score = analyze_tweets(keyword, 50)
    if final_score <= -0.25:
        status="NEGATIVE ❌"
    elif final_score <= 0.25:
        status="NEUTRAL ?"
    else:
        status="POSITIVE ✅"
    bot.send_message(chat_id=update.message.chat_id,
                     text="Average score for "
                           + str(keyword) 
                           + ' is ' 
                           + str(final_score) 
                           + ' ' 
                           + status)

def main():
    updater = Updater('YOUR_TOKEN')
    dp = updater.dispatcher
    dp.add_handler(MessageHandler(Filters.text, send_the_result))
    updater.start_polling()
    updater.idle()
    
if __name__ == '__main__':
    main()

Salvați fișierul și denumiți-l main.py, apoi rulați programul.

python3 main.py

Accesați botul dvs. de telegramă accesând această adresă URL: https://telegram.me/YOUR_BOT_USERNAME. Tastați orice produs, nume de persoană sau orice doriți și trimiteți-l la botul dvs. Dacă totul rulează, ar trebui să existe un scor de sentiment detaliat pentru fiecare tweet din terminal. Botul va răspunde cu scorul mediu de sentiment.

Imaginile de mai jos sunt un exemplu dacă scriu valentino rossi și trimiteți-l la bot.

1611509169 552 Cum sa ti faci propriul analizor de sentimente folosind Python si
scorul detaliat al sentimentului
Cum sa ti faci propriul analizor de sentimente folosind Python si
răspunsul robotului

Dacă ați reușit să urmați pașii până la sfârșitul acestui tutorial, este minunat! Aveți analizatorul dvs. de sentimente acum, cât de mișto este !?

Puteți verifica, de asemenea, my GitHub pentru a obține codul. Vă rugăm să nu ezitați să vă conectați și să lăsați un mesaj în Linkedin profil dacă doriți să întrebați despre ceva.

Vă rugăm să lăsați un comentariu dacă credeți că există erori în codul meu sau în scriere.

Multumesc si mult succes! 🙂