Twitter API

0 Commenti

In questo post ci si occuperà di capire il problema dell'acquisizione e dell'analisi dei dati proveniente da Twitter.

Come specificato nel mio post precedente Mining Twitter, Twitter è un sistema che propone ai propri utenti un servizio di micro blogging, il quale permette agli utenti di postare i propri pensieri/status chiamati tweets. I tweets possono contenere entità diverse per un massimo di 140 caratteri e inoltre si può geo-referenziare il contenuto mappando uno o più luoghi nel mondo reale.

Per poter capire l'utilizzo delle API di Twitter bisogna tenere quindi a mente fattori essenziali come:

  • Utenti
  • Tweets
  • Linea temporale (timeline)

I tweets rappresentano l'essenza di Twitter, e anche se sono solo 140 caratteri relativi ad un pensiero/status di un utente, noi possiamo estrarre diverse informazioni rilevanti dai metadati presenti. Infatti i tweets, insieme al messaggio relativo ai 140 caratteri, sono provvisti anche di due metadati particolarmente interessanti: entità (entities) e luoghi (places).

Tweets entities = riguardano essenzialmente l'utente menzionato, gli hashtags, gli URL e i media che possono essere associati insieme al tweet.

Tweets places = riguardano i luoghi nel mondo reale che possono essere referenziati all'interno del tweet. Il luogo può riferirsi alla posizione dell'autore del tweet o ad un altro luogo descritto.

La linea temporale (timeline), si riferisce alla cronologia con cui vengono presentati i tweets nella pagina. In maniera astratta si può dire che la linea temporale è una qualsivoglia collezione di tweets presentati in ordine cronologico.

Dal punto di vista dell'utente, la "Home timeline" coincide con la vista alla quali si viene rediretti dopo il login, e che mostra i tweets in ordine cronologico degli utenti che noi seguiamo.

Mentre una timeline differente è rappresentata dalla vista della pagina dei tweets di un determinato utente.

Ad esempio collegandoci al nostro account Twitter https://twitter.com/ , noi visualizziamo la home della nostra timeline, tuttavia se volessimo visualizzare i tweets pubblicati da un'utente e la sua timeline dovremmo mettere come suffisso il suo nickname.

Ad esempio da https://twitter.com/ per visualizzare la mia timeline personale dovrò aggiungere il suffisso JacopoKahl all'URL -> https://twitter.com/ che diventa così -> https://twitter.com/JacopoKahl.

Inoltre se fossimo curiosi di conoscere la timeline di un utente relativamente alle persone che segue dovremo aggiungere /NomeUtente/following .

Ad esempio se vogliamo sapere quali utenti segue Lady Gaga, ci basterà digitare sulla barra degli URL https://twitter.com/ladygaga/following .

Inoltre si può notare l'icona "Account verificato", che permette di capire se un account di interesse pubblico (come quelli dei VIPs) è autentico oppure no. Clicca qui per saperne di più.

Tuttavia le timelines sono delle collezioni di tweets dotati di una velocità di pubblicazione relativamente bassa, mentre gli streams al contrario sono degli esempi di tweets pubblici presenti in flusso di tempo reale.

Public firehose riguarda tutti i tweets su argomenti o eventi (come un dibattito politico) capaci di generare migliaia di tweets in poco tempo. L'analisi di questi tweets è molto complessa ed è per questo che sono nati nel tempo servizi commerciali di aziende che permettono una migliore analisi.

Per poter accedere alle API di Twitter bisognerà disporre necessariamente di un account Twitter. Una volta creato un account si consiglia di incominciare a creare una propria rete di contatti di persone da seguire o da cui essere seguiti.

Connettersi alle API di Twitter

Twitter ha provveduto a garantire l'accesso grazie alle RESTful API facili e intuitive da usare. Inoltre esiste un gran numero di librerie che permettono di facilitare il lavoro nelle richieste API.

Prima di poter procedere con delle richieste API, dovremo creare un'applicazione che ci permette di farle cliccando sul seguente indirizzo: https://apps.twitter.com/ .

Grazie al protocollo OAuth (Open Authorization) possiamo avere un approccio sicuro nella condivisione delle app da noi create. Le app sono fruibili anche da altri utenti ai quali non viene richiesto l'inserimento del nome utente e password.

Il protocollo è diventato uno standard per le applicazione social. Di seguito si può trovare la documentazione relativa: https://dev.twitter.com/oauth .

Per semplicità di sviluppo le credenziali di accesso saranno 4: consumer key, consumer secret, access token e access token secret. Queste 4 credenziali permettono di avere accesso a tutto quello che è di nostro interesse per il reperimento di dati attraverso l'app creata.

Per il prossimo step ricordiamoci di mantenere aperta la pagina di Twitter relativa all'app da noi creata.

Data Mining Twitter con R

Scopo di questo primo tutorial è quello di esplorare le funziolità messe a disposizione dalle API di Twitter attraverso l'utilizzo del linguaggio R.

Come primo step definiamo cosa vogliamo cercare e perché. Come spiegato in precedenza Twitter ci da la possibilità di ricercare delle parole chiave o dei trend recenti all'interno di una timeline.

Vogliamo quindi ispezionare gli ultimi post legati alla cantante Lady Gaga e creare una nuvola di etichette (o wordcloud) che ci permetta di mettere in evidenza la frequenza delle parole maggiormente associate a Lady Gaga (o a qualsiasi altra scelta).

Incominciamo aprendo l'ambiente R e installiamo i seguenti packages:

install.packages("twitteR")
install.packages("RCurl")
install.packages("tm")
install.packages("wordcloud")

Una volta installati questi package dobbiamo richiamarli per il nostro script:

require("twitteR")
require("RCurl")
require("tm")
require("wordcloud")

Definiti i pacchetti che andremo ad utilizzare, connettiamoci alla nostra applicazione grazie alle credenziali di accesso.Inseriamo quindi:

consumer_key <- 'xxxxxxxxxxxxxxxxxxxxxx'="" consumer_secret="" <-="" access_token="" access_secret="" <="" code="">

In questi campi dovremo inserire i valori per le credenziali di accesso definite in precedenza durante la fase di creazione dell'app.

Una volta inserite le nostre credenziali per l'accesso all'app digitiamo:

setup_twitter_oauth(consumer_key, consumer_secret, access_token, access_secret)

Da questo momento in poi saremo connessi con l'app creata su Twitter e potremo fare delle richieste.Procediamo quindi inserendo:

lady <- searchtwitter('ladygaga',="" n="500," lang="en" ,="" resulttype="recent" )="" <="" code="">

Analizziamo quanto fatto; con lady definiamo la variabile che andremo a utilizzare nel nostro script per poter fare delle richieste a Twitter ed elaborare i dati ricavati.

searchTwitter è la funzione che ci permette di richiamare dal pacchetto twitteR una ricerca su Twitter grazie all'ausilio di una stringa di caratteri.

Definiremo la stringa di caratteri da dover cercare basandoci sull'hashtag #LadyGaga.

Con n = definiamo il numero di post che vogliamo vagliare per la nostra ricerca, mentre lang si riferisce alla lingua utilizzata nei tweet dagli utenti (nel nostro caso lasciamo en-english poiché siamo intenzionati a visualizzare i tweets in lingua inglese).

resultType ci permette di definire i filtri di ricerca per dei valori legati alla cronologia dei messaggi; nel nostro caso abbiamo dato come valore "recent" poiché siamo interessati ai trend attuali e vogliamo quindi ricavare gli ultimi tweets pubblicati.

Per maggiori informazioni sul pacchetto twitteR cliccare qui

Creiamo una classe poiché vogliamo ordinare per bene la nostra richieste di 500 tweets:

class(lady)

Creiamo un vettore di caratteri per poter gestire al meglio le nostre analisi:

lady_text <- sapply(lady,="" function(x)="" x$gettext())="" <="" code="">

Strutturiamo il testo:

str(lady_text)

NB: potrebbe ritornare errore. In questo caso dobbiamo fare una codifica dei caratteri:

lady_text <- iconv(lady_text,="" "windows-1252",="" "utf-8")="" #e="" poi="" digitare="" str(lady_text)="" <="" code="">

Per maggiori informazioni sulla codifica dei caratteri clicca qui o qui .

Come possiamo notare stiamo già estraendo i tweets di nostro interesse relativi a Lady Gaga.

Creiamo ora un corpora/corpus dei testi per estrarre così le informazioni che ci servono dai documenti utilizzando il pacchetto tm (per maggiori info sul package clicca qui).

#Si assegna il nome lady_corpus
#per creare il corpora da analizzare
lady_corpus <- 1="" 500="" corpus(vectorsource(lady_text))="" lady_corpus="" #da="" qui="" ispezioniamo="" tutti="" i="" tweet,="" #notare="" dati="" che="" ci="" vengono="" forniti="" come="" #il="" numero="" di="" caratteri="" (chars)="" dei="" singoli="" tweet="" inspect(lady_corpus)[1]="" #ispezionare="" un="" singolo="" da="" a="" inspect(lady_corpus[25])="" #o="" range="" tweets="" inspect(lady_corpus[25:30])="" <="" code="">

Dovremo ora togliere dal corpo del testo dei documenti i caratteri o le porzioni che non sono di nostro interesse, al fine di evitare di introdurre troppo rumore nelle nostre analisi:

#Trasforma/modifica/cancella i corpora (corpus)
#dei testi ricavati dai tweets

#In questo caso rimuove la punteggiatura dai corpora
#creando un nuovo oggetto lady_clean
lady_clean <- tm_map(lady_corpus,="" removepunctuation)="" #mette="" tutto="" in="" minuscolo="" da="" lady_clean="" #definito="" nella="" riga="" precedente="" <-="" tm_map(lady_clean,="" content_transformer(tolower))="" #si="" rimuovono="" delle="" parole="" di="" poco="" interesse="" #com="" to,="" the,="" like="" etc..="" removewords,="" stopwords("english"))="" rimuovo="" i="" numeri="" dai="" tweets="" #che="" questa="" analisi="" non="" ci="" interessa="" removenumbers)="" #togliamo="" gli="" spazi="" bianchi="" stripwhitespace)="" <="" code="">

Ora che abbiamo provveduto a pulire il corpus dai caratteri che non erano di nostro interesse, provvediamo a richiamare il pacchetto wordcloud per poter visualizzare i risultati:

wordcloud(lady_clean)

Bisogna ammettere che questo primo risultato non è troppo esaltate a livello visivo... Giochiamo quindi con i valori per poter creare qualcosa di esteticamente più presentabile.

wordcloud(lady_clean, random.order=F, max.words=150, scale=c(5, 0.5), colors=rainbow(50))

Iterate e vedete quale risultato vi aggrada di più e nel caso voleste cambiare i valori potete consultare la documentazione del pacchetto wordcloud cliccando qui.

Jacopo Kahl

Ciao mi chiamo Jacopo. Benvenuto/a sul mio sito web. Sono un appassionato del mondo delle nuove tecnologie e mi occupo di UX/UI e sviluppo Front-End.

Commenti