Tweet analyse ved HJELP AV NLP

Prajwal Shreyas
Prajwal Shreyas

Følg

Jul 23, 2019 * 9 min lese

Introduksjon

i de siste dagene med eksplosjonen Av Store Data er det stor etterspørsel etter organisasjoner og datavitenskapere å utføre informasjonsutvinning ved hjelp av ikke-tradisjonelle datakilder. Forskning har vist at nesten 80% av dataene eksisterer som ustrukturerte tekstdata, derfor er tekstanalyse grunnleggende for å analysere mengden informasjon som er tilgjengelig på chat-transkripsjoner, sosiale medier, anmeldelser, nyhetsfeeder etc.

Hva Er Tekstanalyse?

Tekstanalyse er prosessene for å syntetisere ustrukturerte data for å oppdage mønstre og muliggjøre beslutningstaking. Fram til de siste årene måtte tekstanalyse utføres på den gammeldagse måten, dvs. øyeepling og manuell kategorisering av tekst, noe som er ineffektivt og tidkrevende. Også dette er ikke en praksis løsning når du arbeider med millioner av dokumenter som twitter data.

Twitter data (også kjent som tweets) er en rik kilde til informasjon om et stort sett med emner. Disse dataene kan brukes til å finne trender knyttet til et bestemt søkeord, måle merkevarefølelse eller samle tilbakemelding om nye produkter og tjenester. Dette innlegget vil gi en trinnvis veiledning for tekstanalyse på twitter-data.

hvordan utføre tekstanalyse på twitter-data?

trinnene involvert i tekstanalyse er:

Trinn 1: Samle tweets

Trinn 2: Pre-prosess tweets

Trinn 3: Bruk sentimentanalyse

Trinn 4: Bruk navngitt enhetsgjenkjenning

Trinn 5: Cluster tweets

Trinn 6: Visualiser analyse

jeg har festet en jupyter notatbok som utfører trinnene ovenfor på et utvalg av twitter-data her.

Trinn 1: Samle tweets

tweet-dataene kan nås programmatisk på to måter, dvs. Twitter Rest API eller Streaming API.

Rest API lar deg samle listen over alle tweets eller følgere for en bestemt bruker. Du kan også spørre en brukers konto og til og med endre dem forutsatt at du har de nødvendige tillatelsene. Hvor Som Streaming API lar deg samle tweets på sanntidsbasis basert på søkeord, bruker-ider eller steder.

for å få TILGANG TIL API, trenger du 4 biter av Informasjon Fra Twitter dvs. API-nøkkel, API secret, access token og Access token secret. De detaljerte trinnene for å sette opp en konto og koble til twitter API-tjenestene ved hjelp av python-pakker er dekket i bloggen her.

for vår analyse har jeg brukt twitter streaming API-tjenesten og samlet tweets for tjue FTSE 100-selskaper over en uke fra 1.oktober 2016. Dette har resultert i totalt 37,313 tweets. Utgangen av streaming API må analyseres i et egnet format før noen analyse. I neste avsnitt dekker vi trinnene som er involvert i forbehandling av tweets.

Trinn 2: Pre-Prosess tweets

her analyserer vi svaret fra twitter API til et strukturert bord. Svaret fra twitter streaming API er i formatet nedenfor:

den detaljerte koden for parsing utgangen fra twitter API er under. Utgangen er strukturert i viktige felt som «doc_id», «brukernavn»,» tekst » etc. Den analyseres svaret kan lagres i en database eller EN JSON-fil.

import simplejson as json
def get_tweet(doc):
tweetItem = {}
#Available tweet data
tweetItem = doc
#hashtags are identified and provided as a field in the tweet
tweetItem = map(lambda x: x,doc)
# user_mentiones are identified and provided as a field
tweetItem = map(lambda x: x,doc
) # symbols e.g. $APPL are identified and provided as a field
tweetItem = map(lambda x: x,doc)
tweetItem = doc
tweetItem = doc
tweetItem = doc try: tweetItem = doc
except KeyError as e:
tweetItem = 0
pass
return tweetItem

Trinn 3: Sentimentanalyse

Folk uttrykker sine meninger via tweets, og disse har vanligvis følelser knyttet til det, dvs. positive, negative eller nøytrale. Analyse av denne følelsen kan føre til nyttig innsikt om emnet eller selskapet som diskuteres. Derfor foreslår vi bruk av sentimentanalysealgoritmer for å utføre denne analysen. Jeg har laget en egen blogg med detaljer om å utføre sentimentanalyser ved hjelp av deep learning-algoritmen her.

sentimentet er en nyttig indikator, men tweets inneholder tilleggsinformasjon som navn på personer, steder og organisasjoner. Dataene når hentet kan føre til svært nyttig innsikt på produktet eller firmaet. Så i neste trinn dekker vi bruken av navngitte enhetsgjenkjenningsalgoritmer, som er utformet for å trekke ut denne informasjonen.

Trinn 4: Navngitt Enhetsgjenkjenning

den Navngitte Enhetsgjenkjenningsalgoritmen identifiserer nøkkelkoder Som personer, steder eller organisasjoner som finnes i tweets. For eksempel, hvis Det er omtale av «London» i tweeten, vil algoritmen merke det som «Plassering». Men som tweets generelt ikke følger standard engelsk syntaks, er nøyaktigheten av kodene rundt 60% til 70%.

Du kan bruke Stanford ner-taggeren til å hente enheten anerkjennelse for tweets. I eksemplet nedenfor har jeg brukt En tweet Av Donald Trump.

# -*- coding: utf-8 -*-
from nltk.tag import StanfordNERTagger
from nltk.tokenize import word_tokenize
st = StanfordNERTagger('/stanford-ner/classifiers/english.all.3class.distsim.crf.ser.gz',
'/usr/share/stanford-ner/stanford-ner.jar',
encoding='utf-8')#a tweet by Donald Trump
text = 'Just had a very good call with @SwedishPM Stefan Löfven who assured me that American citizen A$AP Rocky will be treated fairly. Likewise, I assured him that A$AP was not a flight risk and offered to personally vouch for his bail, or an alternative....'
tokenized_text = word_tokenize(text)
classified_text = st.tag(tokenized_text)
print(classified_text)

Trinn 5: Clustering av lignende tweets

en rekke tweets er veldig lik hverandre, dette kan skyldes at folk tweeting om det samme emnet dette forårsaker mye støy i dataene. Derfor for å redusere støyen ville det være nyttig å klynge tweets i grupper basert på deres likhet. Dette kan gjøres ved hjelp av clustering algoritmen.

algoritmenes indre arbeid er basert på et maskinlæringskonsept kjent som tf-idf (term frequency — Inverse document frequency) matrix. Her behandles hver tweet som et dokument (d) og ordene i tweeten som term (t).

Term Frequency-Inverse Document Frequency er en numerisk statistikk som viser hvor viktig et ord er for et korpus.

Term Frekvens er bare forholdet antall nåværende ord til antall alle ord i dokument/streng/etc.

Term Frequency Formula

Frekvens av term t_i, hvor n_t-antall t_i i gjeldende dokument / streng, summen av n_k er antallet av alle termer i gjeldende dokument / streng.

Invers Dokumentfrekvens er en logg av forholdet mellom antall alle dokumenter / streng i corpus til antall dokumenter med term t_i.

Inverse Dokument Frekvens Formel

tf-idf (t, d, D) er produktet tf (t, d) til idf (t, D). Ytterligere detaljer om tf-idf er tilgjengelig i bloggen her.

Tf-IDF Formel

i koden nedenfor for å oppnå clustering, bortsett fra tekstinngangen, er den eneste tilleggsparameteren som må spesifiseres i inngangen likhetstærskelen. Du kan angi terskelen i funksjonen » get_clusters(processedTweets, simility_threshold)». Derfor vil alle tweets, som er 80% like, bli gruppert sammen basert på likhetsmål kjent som cosinus likhet.

def cluster_text(dist_text,processedTweets,dist_threshold_txt):
cluster_id = 1
for i in range(dist_text.shape):
try:
doc_dist_array_txt = dist_text
# identify document ids where the tweets are similar
similarDocs = np.where(doc_dist_array_txt <= dist_threshold_txt)
processedTweets.ix.isin(), 'cluster_ref'] = cluster_id
cluster_id = cluster_id + 1
except ValueError:
continue
return processedTweets
# %%%%%%%%% Calculate Cosine distance of documents %%%%%%%%%%%%%%
def tokenize_only(text):
# first tokenize by sentence, then by word to ensure that punctuation is caught as it's own token
tokens =
filtered_tokens =
# filter out any tokens not containing letters (e.g., numeric tokens, raw punctuation)
for token in tokens:
if re.search('', token):
filtered_tokens.append(token)
return filtered_tokens
def get_clusters(processedTweets, similarity_threshold):
tweets = processedTweets.tolist()
#Define count vectorizer parameters
vectorizer = CountVectorizer(max_df=1.0, min_df=1, stop_words=stopwords, tokenizer=tokenize_only)
# Get document term frequency matix
dtf_matrix = vectorizer.fit_transform(tweets) #fit the vectorizer to tweets which does not contain'htttp' and 'RT'
dist_text = np.around(abs(1 - cosine_similarity(dtf_matrix)),2)
# --------1D clustering based on distance measure
# Pre clustering setup
processedTweets = None # Tweets that are 1-similarithy% similar, as defined by dist_threshold
# Clustering of tweets based on text
processedTweets = cluster_text(dist_text,processedTweets,dist_threshold_txt = (1-similarity_threshold))
return processedTweets

resultatene vil inneholde en ekstra kolonne «cluster_ref». Cluster_ref vil gruppere alle lignende dokumenter i en enkelt gruppe, for eksempel hvis dokument 1 og dokument 2 er like, derfor har begge cluster_ref av 1.

Trinn 6: Visualisering av resultater

visualiseringen av resultatene ovenfor vil bidra til å gi innsikt i forbrukernes mening om produktet eller selskapet. I avsnittet nedenfor vil jeg bruke Tableau for visualiseringsformål. Vennligst se link til dashbordet her.

den første grafen nedenfor er den positive, negative og gjennomsnittlige følelsen (Blå linje) for hvert selskap. Stolpene representerer gjennomsnittlig følelse for selskapet og er ikke vektet for antall tweets. Denne uveide følelsen gir ikke en nøyaktig sammenligning mellom selskaper, da den ikke tar hensyn til antall tweets.

Legg igjen en kommentar

Din e-postadresse vil ikke bli publisert.