Introducción al análisis de redes sociales usando Procesamiento del Lenguaje Natural

Caso práctico: La Fiscalía General del Estado en Twitter

1. Introducción

El análisis de redes sociales es una herramienta útil para varios fines. Por ejemplo, este puede ser de ayuda para determinar qué tan bien funciona la relación con el público, o con determinados segmentos de él, puede servir también para medir el impacto de alguna determinada campaña o conocer la opinión respecto a alguna temática de interés. A través de la recopilación de los datos de cuentas y temáticas podemos utilizar distintos algoritmos para medir, por ejemplo, el sentir de las personas con respecto a un tema, las palabras más comunes que utiliza una determinada entidad, los discursos que lo hacen único e incluso crear grupos de temáticas.

En los capítulos 1 y 3 de mi curso de procesamiento del lenguaje natural (PLN) se explica cómo el mineo de texto, como parte del PLN, nos puede ayudar a destilar accionables útiles desde texto con el uso distintas técnicas. Es así que este cuaderno pretende presentar un corto caso de estudio, introductorio al análisis de texto, utilizando la API de Twitter para R.

2. Creación de una cuenta Developer en twitter

Para poder comenzar este análisis es preciso que creemos una cuenta de desarrollador (Developer) en Twitter. A continuación se explican los pasos.

1. Visitar la página https://developer.twitter.com/ y hacer clic en la opción apply de la esquina superior derecha:

2. Aquí escogemos la opción apply for a developer account (se nos pedirá el acceso a nuestra cuenta de twitter):

3. Una vez aquí completaremos todos los datos que se nos pide acerca de los propósitos de uso. Usualmente se coloca que se utilizará la API con fines de investigación. Al finalizar aceptaremos los términos y condiciones.

4. En este punto se nos pedirá validar nnuestro e-mail y esperar por el resultado de aprobación del proceso. Este tarda alrededor de dos días.

5. Una vez que recibamos el correo de confirmación crearemos una app para poder utilizar la API con R. Para ello, ingresaremos a la página de nuestra cuenta de desarrollador (https://developer.twitter.com/en/portal/dashboard) y daremos clic en la opción Create project.

6. Completamos la información acerca de nuestra API en los cuatro pasos solicitados.

7. En el lado derecho de nuestro dashboard estará disponible nuestro nuevo proyecto, al dar clic en este, seleccionaremos el ícono de llave de la app que creamos para obtener nuestras credenciales.

8. En este punto damos clic en View Keys y copiamos las credenciales.

1. Finalmente, crearemos un ambiente de trabajo para guardar nuestras credenciales, con el objetivo de no llamarlas explícitamente cada vez que trabajemos con ellas:

# Nombre de la aplicación
appname = "NaturalLanguageData"
key = "XXXXX"
secret = "XXXXX"

# Token de conexión
twitter_token = rtweet::create_token(app = appname,
                                      consumer_key = key,
                                      consumer_secret = secret)

# Guardado del token
home_directory <- path.expand("C:/Users/hugo-/Downloads/MasterUtilitiesR/TwitterToken")
file_name <- file.path(home_directory,"twitter_token.rds")
saveRDS(twitter_token, file = file_name)

3. Extracción de tweets a través de R

Antes de comenzar, no debemos olvidar cargar nuestras credenciales (twitter_token):

# Cargado del token
home_directory = path.expand("C:/Users/hugo-/Downloads/MasterUtilitiesR/TwitterToken")
file_name = file.path(home_directory,"twitter_token.rds")
twitter_token = readRDS(file = file_name)

Para este caso de estudio utilizaremos las siguientes librerías:

• rtweet: Conexión a la API de Twitter para la extracción de datos.
• tidyverse: Manipulación, limpieza y visualización de datos estructurados.
• tidytext: Manipulación de datos de texto.
• waffle: Gráficos de “waffle” (como al alternativaa los gráficos de pastel).
• tm: Funciones para limpieza y procesamiento de corpus texto.
• stringi: Funciones de manipulación de texto.
• stopwords: Palabras vacías en varios idiomas.
• wordcloud2: Visualización de nubes de palabras.
• udpipe: Librería para realizar varias tareas de NLP en varios idiomas.
• syuzhet: Librería dedicada al análisis de sentimientos en varios idiomas.
• parallel: Librería que habilita la paralelización de procesos, muy útil con syuzhet.

# Carga de librerías
library(rtweet)
library(tidyverse)

package 㤼㸱tidyverse㤼㸲 was built under R version 4.0.2Registered S3 methods overwritten by 'dbplyr':
  method         from
  print.tbl_lazy     
  print.tbl_sql      
-- Attaching packages --------------------------------------- tidyverse 1.3.0 --
v ggplot2 3.3.1     v purrr   0.3.4
v tibble  3.0.1     v dplyr   1.0.0
v tidyr   1.1.0     v stringr 1.4.0
v readr   1.3.1     v forcats 0.5.0
-- Conflicts ------------------------------------------ tidyverse_conflicts() --
x dplyr::filter()  masks stats::filter()
x purrr::flatten() masks rtweet::flatten()
x dplyr::lag()     masks stats::lag()

library(tidytext)

package 㤼㸱tidytext㤼㸲 was built under R version 4.0.2

library(waffle)

package 㤼㸱waffle㤼㸲 was built under R version 4.0.2

library(tm)

package 㤼㸱tm㤼㸲 was built under R version 4.0.2Loading required package: NLP

Attaching package: 㤼㸱NLP㤼㸲

The following object is masked from 㤼㸱package:ggplot2㤼㸲:

    annotate

library(stopwords)

package 㤼㸱stopwords㤼㸲 was built under R version 4.0.2
Attaching package: 㤼㸱stopwords㤼㸲

The following object is masked from 㤼㸱package:tm㤼㸲:

    stopwords

library(wordcloud2)

Registered S3 method overwritten by 'htmlwidgets':
  method           from         
  print.htmlwidget tools:rstudio

library(syuzhet)

package 㤼㸱syuzhet㤼㸲 was built under R version 4.0.2
Attaching package: 㤼㸱syuzhet㤼㸲

The following object is masked from 㤼㸱package:rtweet㤼㸲:

    get_tokens

library(stringi)
library(parallel)
library(udpipe)

package 㤼㸱udpipe㤼㸲 was built under R version 4.0.2Registered S3 method overwritten by 'data.table':
  method           from
  print.data.table     

Si queremos observar las tendencias en Twitter, simplemente debemos utilizar la función trends_available. En nuestro caso, filtraremos aquellas disponibles para Ecuador.

# Función de codificación geográfica 
trends_available() %>% filter(countryCode=="EC")

# Tendencias para el "woeid" de Ecuador
get_trends(woeid = 23424801)

Como se puede observar, una de las tendencias en Ecuador es #justiciaparaRobertoMalta, hashtag al cual podemos hechar un vistazo en Twitter:

Para extraer datos de este #hashtag utilizaremos la función search_tweets, especificando la ubicación del Ecuador, que se incluyan retweets y que los tweets estén en español:

# Extraer data de un hashtag o de un tema
tweets_ec = search_tweets(q = "#justiciaparaRobertoMalta", 
                          n = 10000, geocode = "-0.220102,-78.5119250,100mi", 
                          include_rts = T, lang="es")

Downloading [>----------------------------------------]   2%
Downloading [>----------------------------------------]   3%
Downloading [=>---------------------------------------]   4%
Downloading [=>---------------------------------------]   5%
Downloading [=>---------------------------------------]   6%

tweets_ec %>% head()

Así también, podemos extraer los tweets desde cuentas de usuario con la función get_timeline. Esta extraerá máximo los últimos 3200 tweets de la cuenta. En nuestro caso de estudio, utilizaremos los datos de la Fiscalía General del Estado (FGE):

# Extraer data de un usuario
user_tweets_ec = get_timeline(user = "@FiscaliaEcuador", n = 3200, lang="es")
saveRDS(user_tweets_ec, "CE_FGE/tweets_FGE.RDS")
user_tweets_ec %>% head()

4. Limpieza de datos

Cuando tratamos con datos de Twitter, la primera tarea que debemos llevar a cabo es la identificación de tweets orgánicos (originales), retweets y respuestas. Para esto, los datos recogidos por la API de twitter tienen las columnas is_retweet y reply_to_status_id.

# Tweets orgánicos
user_tweets_ec_organic = user_tweets_ec %>% filter(is_retweet==F, is.na(reply_to_status_id))

# Retweets
user_tweets_ec_retweets = user_tweets_ec %>% filter(is_retweet==T)

# Respuestas
user_tweets_ec_replies = user_tweets_ec %>% filter(!is.na(reply_to_status_id))

En los tweets orgánicos vamos a remover hipervínculos, menciones (@) y puntuación a través de las funciones str_replace_all, removeNumbers y removePunctuation y stri_trans_general con la finalidad de analizar únicamente los textos.

# Limpieza de textos
user_tweets_ec_organic = user_tweets_ec_organic %>% 
  mutate(text=str_replace_all(text, "https\\S*", "")) %>% # hipervínculos
  mutate(text=str_replace_all(text, "@\\S*", "")) %>% # menciones
  mutate(text=str_replace_all(text, "[\r\n\t]", "")) %>% # separadores
  mutate(text=removeNumbers(text)) %>% # números
  mutate(text=removePunctuation(text)) %>%  # puntuacion
  mutate(text=str_squish(text))

Acto seguido removeremos palabras vacías y tokenizaremos por palabras usando las funciones stopwords y unnest_tokens. Las palabras vacías son aquellas que no son útiles para el análisis y usualmente incluyen artículos, pronombres, preposiciones, etc. y la función stopwords nos ayuda a cargar distintos diccionarios de palabras vacías. La tokenización en cambio se refiere a la estructuración de los datos de texto en filas, donde cada fila será un token (tal token puede ser una palabra, un n-grama, una oración, etc.). Estos, entre varios otros conceptos son de útil conocimiento para tareas del procesamiento del lenguaje natural. Tales definiciones las podrás encontrar en el capítulo 2 de mi curso.

# Palabras vacías
stopwords_snow = stopwords("es", source = "snowball")
stopwords_iso = stopwords("es", source = "stopwords-iso")
stopwords_ntlk = stopwords("es", source = "nltk")
# Conteo de palabras
tweets = user_tweets_ec_organic %>%
  select(text) %>%
  unnest_tokens(token, text, to_lower = F)
tweets = tweets %>%
  filter(!token %in% c(stopwords_ntlk))

Una tarea adicional que se lleva a cabo en este tipo de análisis es el stemming o la lematización. Estos son métodos para reducir una palabra a su raíz o morfema con el objetivo de analizar variaciones de una palabra como una sola.

# Descarga de modelo preentrenado udpipe 
#udpipe::udpipe_download_model('spanish') # Descomentar al ejecutar por primera vez
model = udpipe_load_model("spanish-gsd-ud-2.4-190531.udpipe")
tweets_ann = as_tibble(udpipe_annotate(model, tweets$token))
# Stemming
tweets = tweets_ann %>% 
  select(token, lemma) %>% 
  filter(!is.na(lemma))

Debido a que al traer a la raíz se podrían generar otras palabras vacías que estaban conjugadas, realizaremos este procedimiento nuevamente y pasaremos a minúsculas las palabras:

# Conteo de palabras
tweets = tweets %>%
  mutate(lemma=tolower(lemma)) %>% 
  filter(!lemma %in% c(stopwords_ntlk))

Veamos el resultado de esta limpieza y procesamiento de los datos:

tweets %>% head(7)

5. Análisis descriptivo

Una vez que tenemos los datos extraídos limpios, realizaremos algunos análisis descriptivos para extraer conclusiones acerca del manejo de la cuenta de Twitter de la FGE:

Top tweets por conteo de likes

# Top de tweets por conteo de likes
user_tweets_ec = user_tweets_ec %>% arrange(desc(favorite_count))
user_tweets_ec %>% head(5) %>% select(text)

Top tweets por conteo de retweets

# Top de tweets por conteo de retweets
user_tweets_ec = user_tweets_ec %>% arrange(-retweet_count)
user_tweets_ec %>% head(5) %>% select(text)

Composición de los tweets

# Composición de los tweets
CountTweets = data.frame(tipo=c("orgánico","retweets","respuestas"),
                         conteo=c(nrow(user_tweets_ec_organic), 
                                  nrow(user_tweets_ec_retweets), 
                                  nrow(user_tweets_ec_replies)))
CountTweets = CountTweets %>% 
  mutate(porcentaje=round(conteo/sum(conteo)*100,0)) %>% 
  arrange(desc(conteo))
CountTweets

# Gráfico de la composición de tweets
w_vec = CountTweets$porcentaje
names(w_vec) = CountTweets$tipo
waffle(w_vec, rows = 10, title = 'FGE: Tweets por origen')

Evolución temporal de los tweets por día

# Gráfico de la evolución de tweets
ts_plot(user_tweets_ec, by="day", color="darkred") +
  labs(x = "Fecha", y = NULL, title = "Frecuencia de los tweets de la FGE", 
       subtitle = "Conteo de tweets agregado por día", caption = "Fuente: Twitter") +
  theme_bw()

Fuente de publicación de los tweets

# Fuente de los tweets
user_tweets_ec_sources = user_tweets_ec %>% 
  group_by(source) %>%
  summarize(conteo=n()) %>% 
  mutate(porcentaje=round(conteo/sum(conteo)*100,0)) %>% 
  arrange(desc(conteo))

`summarise()` ungrouping output (override with `.groups` argument)

user_tweets_ec_sources

# Gráfico de la fuente de los tweets
w_vec2 = user_tweets_ec_sources$porcentaje
names(w_vec2) = user_tweets_ec_sources$source
waffle(w_vec2, rows = 10, title = 'FGE: Tweets por fuente')

Hashtags más comunes

# Hashtags más comunes
data.frame(text=unlist(user_tweets_ec_organic$hashtags)) %>% 
  count(text, sort = TRUE) %>%
  top_n(15) %>%
  mutate(text = reorder(text, n)) %>%
  ggplot(aes(x = text, y = n)) +
  geom_col() +
  xlab(NULL) +
  coord_flip() +
  labs(y = "Frecuencia",
       x = "Hashtags",
       title = "Hashtags más frecuentes en la cuenta de Twitter de la FGE",
       subtitle = "Tweets orgánicos de la FGE")

Selecting by n

# Hashtags más comunes
data.frame(text=unlist(user_tweets_ec_organic$hashtags)) %>% 
  count(text, sort = TRUE) %>%
  mutate(text = reorder(text, n)) %>%
  select(word=text, freq=n) %>% 
  wordcloud2()

Palabras más usadas en los tweets

# Palabras más usadas
tweets %>% 
  count(lemma, sort = TRUE) %>%
  top_n(15) %>%
  mutate(lemma = reorder(lemma, n)) %>%
  ggplot(aes(x = lemma, y = n)) +
  geom_col() +
  xlab(NULL) +
  coord_flip() +
  labs(y = "Frecuencia",
       x = "Palabras",
       title = "Palabras más frecuentes en la cuenta de Twitter de la FGE")

Selecting by n

# Palabras más usadas
tweets %>% 
  count(lemma, sort = TRUE) %>%
  mutate(lemma = reorder(lemma, n)) %>%
  select(word=lemma, freq=n) %>% 
  wordcloud2()

6. Análisis de sentimientos

Cuando tenemos datos de texto podemos realizar además análisis de sentimientos. Acorde a Robinson y Silge (2019), cuando el ser humano lee un texto, entiende la intención emocional de una palabra para inferir si una porción de texto es positiva o negativa, o incluso podría reconocer miedo o disgusto. Este mismo acercamiento lo podemos realizar a través de técnicas de mineo de texto, de las cuales existen muchas alternativas.

En este caso de estudio usaremos una técnica de diccionarios y unigramas basada en el trabajo de Saif Mohammad y Peter Turney. A tal diccionario se lo llama “nrc” y lo que busca es etiquetar cada palabra en una de 10 emociones a través de un algoritmo de búsqueda intensiva. Este análisis se lo realiza a través de la función get_nrc_sentiment, optimizándola al paralelizarlo con el número de núcleos que tenga nuestro CPU.

# Creación del ambiente de paralelización
cl = makeCluster(detectCores()-1)
clusterExport(cl = cl, c("get_sentiment", "get_sent_values", "get_nrc_sentiment", "get_nrc_values", "parLapply"))

# Análisis de sentimientos
tweet_sentiment_nrc = get_nrc_sentiment(tweets$lemma,language = "spanish", cl=cl)

`filter_()` is deprecated as of dplyr 0.7.0.
Please use `filter()` instead.
See vignette('programming') for more help
This warning is displayed once every 8 hours.
Call `lifecycle::last_warnings()` to see where this warning was generated.

stopCluster(cl)

# Etiquetado de sentimientos
tweet_sentiment_nrc = cbind(tweets, tweet_sentiment_nrc)
tweet_sentiment_nrc %>% filter(rowSums(tweet_sentiment_nrc[,-c(1,2)]) > 0) %>% head()

Gráficamente, los sentimientos más recurrentes en los tweets de la FGE son:

# Frecuencia de sentimientos
sentimentscores = data.frame(colSums(tweet_sentiment_nrc %>% filter(lemma!="general") %>% 
                                       select(-token,-lemma)))
names(sentimentscores) = "Score"
sentimentscores = cbind("sentiment"=rownames(sentimentscores),sentimentscores)
rownames(sentimentscores) = NULL
sentimentscores = sentimentscores %>% 
  mutate(sentiment = recode(sentiment, 
                            "anger"="enfado",
                            "anticipation"="anticipación",
                            "disgust"="disgusto",
                            "fear"="miedo",
                            "joy"="alegría",
                            "negative"="negativo",
                            "positive"="positivo",
                            "sadness"="tristeza",
                            "surprise"="sorpresa",
                            "trust"="confianza"))

ggplot(data=sentimentscores,aes(x=sentiment,y=Score))+
  geom_bar(aes(fill=sentiment),stat = "identity")+
  xlab("Sentimientos")+ylab("Scores")+
  ggtitle("Sentimientos totales basados en scores")+
  theme(axis.text.x = element_text(angle=90),
        legend.position = "none")

Se puede notar en este gráfico que el sentimiento más frecuente en los tweets de la FGE es negativo (específicamente, el miedo), sus palabras asociadas se pueden ver gráficamente como:

tweet_sentiment_nrc %>% 
  filter(fear > 0) %>% 
  select(lemma) %>% 
  count(lemma) %>% 
  select(word=lemma, freq=n) %>% 
  wordcloud2()

7. Conclusión

En este corto caso de estudio se han mostrado muchas de las utilidades que nos presenta el PLN para el análisis de tweets. ¡Es tu turno ahora de demostrar lo aprendido y realizar inferencia sobre el análisis de alguno de los datasets que te será entregado!

8. Bibliografía

Kwartler, T. (2017), Text mining in practice with R.

Silge, J. & Robinson, D. (2017), Text Mining with R, a tidy approach.