Análisis de comportamiento en redes sociales usando Procesamiento del Lenguaje Natural

Capítulo 3: Obtención y procesamiento de datos de texto

PARTE 2

1. Estructuración de datos

1.1. Texto en formato tidy

Recordemos los datos que procesamos en la clase anterior para el caso práctico de análisis de noticias, valiéndonos de las herramientas presentes en la librería tidyverse.

library(tidyverse)
noticiasVelascoDF = readRDS("Caso1_Noticias/noticiasVelascoDF.RDS")
noticiasLarreaDF = readRDS("Caso1_Noticias/noticiasLarreaDF.RDS")
noticiasFreileDF = readRDS("Caso1_Noticias/noticiasFreileDF.RDS")
head(noticiasVelascoDF %>% select(Fecha, Diario, Titular, Link, Noticia))

En estos conjuntos de datos tenemos 5 columnas:

• La fecha en la que fue publicada la noticia
• El diario/página que publicó el titular
• El titular de la noticia
• El link a la noticia
• El cuerpo de la noticia como una cadena de texto

Sobre estas columnas trabajaremos para obtener datos de texto en formato tidy. De aquí en adelante el titular de cada noticia será el identificador de documento y por ende, trateremos cada noticia como un documento.

1.2. La librería tidytext

Tidytext es un librería que permite realizar mineo de texto con el uso de herramientas tidy. Estas herramientas facilitan la minería en ámbitos como la adecuación, limpieza y visualización de los datos.

A continuación mostraremos un flujo de adecuación de los datos texto utilizando distintas herramientas de las librerías tidytext y tidyverse.

Flujo de trabajo tidytext, Silge y Robinson (2017).

1.3. Tokenización: unnest_tokens

Al conjunto de datos visto anteriormente necesitamos convertirlo a un data.frame (tibble en el universo tidy) donde se tenga un token por documento por fila. Esto se logra como se muestra a continuación.

library(tidytext)
tidy_Velasco = noticiasVelascoDF %>% unnest_tokens(output = Token, input = Noticia)
tidy_Larrea = noticiasLarreaDF %>% unnest_tokens(output = Token, input = Noticia)
tidy_Freile = noticiasFreileDF %>% unnest_tokens(output = Token, input = Noticia)

Para realizar el seguimiento de nuestros ejemplos, escogeremos una noticia de cada uno de los conjuntos de datos.

• Juan Fernando Velasco: “Una moneda digital para evitar contagios del COVID-19 ofrece Juan Fernando Velasco en su plan de gobierno”
• Gustavo Larrea: “Gustavo Larrea: ‘Debemos lograr que este sea un país agroindustrial sólido’”
• Pedro José Freile: “Freile, un experto en contratación pública que busca el cambio”

ejemplo_Velasco = noticiasVelascoDF$Titular[1]
ejemplo_Larrea = noticiasLarreaDF$Titular[1]
ejemplo_Freile = noticiasFreileDF$Titular[2]
tidy_Velasco %>% 
       filter(Titular==ejemplo_Velasco) %>% 
       select(Diario, Titular, Token) %>% 
       head()

Las características por defecto de la función unnest tokens son:

• Tokenizar por palabras (n-gramas con \(n=1\)), aunque soporta también por caracteres, n-gramas, oraciones, tweets, párrafos y patrones basados en expresiones regulares (regex). Esto lo hace con la opción token.
• Cambiar las letras a minúsculas. Esto lo hace con la opción to_lower.
• Remueve signos de puntación.

Veamos algunos ejemplos:

noticiasLarreaDF %>% 
  filter(Titular==ejemplo_Larrea) %>% 
  unnest_tokens(output = Token, input = Noticia, token = 'sentences', to_lower = F) %>% 
  select(Token)

noticiasFreileDF %>% 
  filter(Titular==ejemplo_Freile) %>% 
  unnest_tokens(output = Token, input = Noticia, token = 'ngrams', n=3, to_lower = F) %>% 
  select(Token)

En esta tokenización podríamos querer también remover números o quitar signos de puntuación. Esto es alcanzable a través del uso de algunas funciones de la librería tm, como se muestra a continuación:

library(tm)

Loading required package: NLP

Attaching package: 㤼㸱NLP㤼㸲

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

    annotate

noticiasFreileDF %>% 
  filter(Titular==ejemplo_Freile) %>% 
  unnest_tokens(output = Token, input = Noticia, token = 'sentences', to_lower = F) %>% 
  mutate(Token = removePunctuation(Token)) %>%
  mutate(Token = removeNumbers(Token)) %>% 
  select(Token)

Así mismo, podemos utilizar funciones de la librería stringr (ya cargada con tidyverse) y stringi para realizar cosas como quitar espacios extra, pasar las palabras a minúsculas/mayúsculas, remover acentos, etc.

library(stringi)
noticiasVelascoDF %>% 
  filter(Titular==ejemplo_Velasco) %>% 
  unnest_tokens(output = Token, input = Noticia, token = 'sentences', to_lower = F) %>% 
  mutate(Token = str_squish(string = Token)) %>%
  mutate(Token = str_to_upper(Token, locale = 'es')) %>% 
  mutate(Token = stri_trans_general(Token, id = "Latin-ASCII")) %>% 
  select(Token)

1.4. Palabras vacías: anti_join y tm::removeWords

Una vez que los datos han sido tokenizados, podemos pasar a la parte de manipulación. En este análisis, y en muchos análisis de texto, puede ser útil quitar las llamadas ‘’palabras vacías’’ o ‘’stopwords’’. Estas son palabras que no son útiles para el análisis. Usualmente estas incluyen artículos, pronombres, preposiciones, etc.

La librería tidytext incluye un diccionario de stopwords cargado, pero solo para el idioma inglés. Para el español tenemos las siguientes opciones (aunque podrían existir otros recursos):

• Diccionario de stopwords incluidos en la librería tm.
• Diccionario de la librería stopwords de las fuentes ‘’stopwords-iso’’ y ‘’snowball’’.
• Diccionarios personalizados.

En nuestro caso, armaremos un diccionario de stopwords de las tres fuentes mencionadas como se muestra a continuación:

library(readxl)
stopwords_es_1 = read_excel("Diccionarios/Stopwords/CustomStopWords.xlsx")
names(stopwords_es_1) = c("Token","Fuente")
stopwords_es_2 = tibble(Token=tm::stopwords(kind = "es"), Fuente="tm")
stopwords_es = rbind(stopwords_es_1, stopwords_es_2)
stopwords_es = stopwords_es[!duplicated(stopwords_es$Token),]
remove(stopwords_es_1, stopwords_es_2)

stopwords_es[sample(nrow(stopwords_es),size = 10, replace = F),]

Si la tokenización realizada utiliza palabras como tokens, podemos remover las stopwords a través de:

tidy_Velasco = tidy_Velasco %>%
  anti_join(stopwords_es)

Joining, by = "Token"

tidy_Larrea = tidy_Larrea %>%
  anti_join(stopwords_es)

Joining, by = "Token"

tidy_Freile = tidy_Freile %>%
  anti_join(stopwords_es)

Joining, by = "Token"

tidy_Velasco %>% 
  filter(Titular==ejemplo_Velasco) %>% 
  select(Token) %>% 
  head()

Si en cambio la tokenización utilizó otro tipo de tokens, podemos remover las stopwords como se muestra a continuación:

noticiasLarreaDF %>% 
  filter(Titular==ejemplo_Larrea) %>% 
  unnest_tokens(output = Token, input = Noticia, token = 'sentences', to_lower = F) %>% 
  mutate(Token = removeWords(Token, stopwords_es$Token)) %>% 
  select(Token)

1.5 Expresiones regulares (REGEX)

Una expresión regular es un patrón que describe un conjunto específico de cadenas de texto (strings) que tienen una estructura en común y son usadas para buscar coincidencias y/o reemplazarlas. Las expresiones regulares son en realidad el centro de las operaciones con cadenas de texto en todos los lenguajes de programación, aunque su sintaxis varía un poco en cada uno.

En R, podemos realizar estas transformaciones a través de la librería base y con la librería stringr. A continuación podemos ver algunas de estas tareas y sus funciones asociadas:

• Identificar o extraer coincidencias de texto: grep(), str_detect(), str_extract(), str_extract_all().
• Localizar un patrón dentro de una cadena de texto (i.e. obtener la posición del inicio y el final de la coincidencia): regexpr(), gregexpr(), str_locate(), str_locate_all().
• Reemplazar un patrón de texto: gsub(), str_replace(), str_replace_all().
• Dividir una cadena de texto en partes acorde a un patrón: strsplit(), str_split().

Dentro de las expresiones regulares usaremos además algunos cuantificadores y operadores:

• * busca las coincidencias al menos cero veces.

• + busca las coincidencias al menos una vez.

• ? busca las coincidencias máximo una vez.

• {n} busca las coincidencias exactamente n veces.

• {n,} busca las coincidencias al menos n veces.

• {n,m} busca las coincidencias entre n y m veces.

• ^ busca al principio de la cadena.

• $ busca al final de la cadena.

• [:digit:] o \d busca dígitos.

• \D busca no-dígitos.

• [:lower:] busca minúsculas.

• [:upper:] busca mayúsculas.

• [:alpha:] busca letras.

• [:alnum:] busca caracteres alfanuméricos.

• [:blank:] busca caracteres blancos como espacio y tabulador.

• [:space:] busca caracteres de espacio como tabulador, nueva linea, etc.

• [:punct:] busca caracteres de puntuación.

A continuación veremos algunos ejemplos utilizando nuestros datos.

# Extraemos una oración de ejemplo
oracion = substring(noticiasVelascoDF$Noticia[1],1,175)
oracion

[1] " Juan Fernando Velasco, aspirante presidencial del movimiento Construye (antes Ruptura), Lista 25, desarrollan su plan de Gobierno en tres ejes: Económico, Social y Seguridad."

# Reemplazar las letras 'a' minúscula o mayúscula por 'X'
gsub("a|A","X",oracion)

[1] " JuXn FernXndo VelXsco, XspirXnte presidenciXl del movimiento Construye (Xntes RupturX), ListX 25, desXrrollXn su plXn de Gobierno en tres ejes: Económico, SociXl y SeguridXd."

# Reemplazar los espacios por tabulador
gsub(" ","\t",oracion)

[1] "\tJuan\tFernando\tVelasco,\taspirante\tpresidencial\tdel\tmovimiento\tConstruye\t(antes\tRuptura),\tLista\t25,\tdesarrollan\tsu\tplan\tde\tGobierno\ten\ttres\tejes:\tEconómico,\tSocial\ty\tSeguridad."

# Reemplazar todas las letras por Y
str_replace_all(oracion,"[:alpha:]","Y")

[1] " YYYY YYYYYYYY YYYYYYY, YYYYYYYYY YYYYYYYYYYYY YYY YYYYYYYYYY YYYYYYYYY (YYYYY YYYYYYY), YYYYY 25, YYYYYYYYYYY YY YYYY YY YYYYYYYY YY YYYY YYYY: YYYYYYYYY, YYYYYY Y YYYYYYYYY."

# Reemplazar todas las letras mayúsculas por Z
str_replace_all(oracion,"[:upper:]","Z")

[1] " Zuan Zernando Zelasco, aspirante presidencial del movimiento Zonstruye (antes Zuptura), Zista 25, desarrollan su plan de Zobierno en tres ejes: Zconómico, Zocial y Zeguridad."

# Formamos un vector con las palabras de la oración
oracion_vector = str_split(oracion, " ")[[1]]
oracion_vector

 [1] ""             "Juan"         "Fernando"     "Velasco,"     "aspirante"    "presidencial" "del"         
 [8] "movimiento"   "Construye"    "(antes"       "Ruptura),"    "Lista"        "25,"          "desarrollan" 
[15] "su"           "plan"         "de"           "Gobierno"     "en"           "tres"         "ejes:"       
[22] "Económico,"   "Social"       "y"            "Seguridad."  

# Extraer las palabras con 1 letra S. 
grep("S{1}",oracion_vector, value = T)

[1] "Social"     "Seguridad."

# Extraer las palabras que empiezan con a
grep("^a", oracion_vector, value = T)

[1] "aspirante"

Como fuente de consulta para ejemplos adicionales de este tema, tenemos la entrada de expresiones regulares en R en el blog de Albert Y. Kim.

2. Stemming y Lematización

Para fuente de consulta tenemos una buena referencia en la entrada de Text Mining en el blog de Danny Morris.

2.1. Stemming

El ‘’stemming’’ es un método para reducir una palabra a su raíz o morfema. Esto se hace con el objetivo de analizar variaciones de una palabra como una sola. Supongamos por ejemplo que tenemos el conjunto de palabras: {moderniza, moderno, moderna, modernos, modernización}. Lo que quisieramos es tener solo la raíz de estas palabras, que en último punto, son iguales. Al realizar el stemming sobre el conjunto mostrado obtendríamos: {modern, modern, modern, modern, modern}.

Actualmente existen varios algoritmos que realizan stemming, los cuales trabajan cortando el final o inicio de una palabra, tomando en cuenta la existencia de prefijos y sufijos que suelen ser comunes. En un gran número de casos este proceso suele ser exitoso, pero no siempre.

Para lograr esto en R utilizaremos la versión en español del algoritmo de Porter a través de la función wordStem de la librería SnowballC. Este algoritmo funciona acorde a 6 reglas:

1. Un identificador de regla
2. El sufijo a identificar
3. El texto por el cual debe ser reemplazado al encontrar el sufijo
4. El tamaño del sufijo
5. El tamaño del texto de reemplazo
6. El tamaño mínimo que debe tener la raíz resultante luego de aplicar la regla (esto es a los efectos de no procesar palabras demasiado pequeñas)
7. Una función de validación (una función que verifica si se debe aplicar la regla una vez encontrado el sufijo)

library(SnowballC)
tidy_Velasco = tidy_Velasco %>% 
  mutate(stem = wordStem(Token, "spanish"))
tidy_Larrea = tidy_Larrea %>% 
  mutate(stem = wordStem(Token, "spanish"))
tidy_Freile = tidy_Freile %>% 
  mutate(stem = wordStem(Token, "spanish"))

tidy_Freile %>% 
  filter(Titular==ejemplo_Freile) %>% 
  select(Token, stem)

2.1. Lematización

La lematización es un proceso con los mismos objetivos del stemming, pero en lugar de obtener el morfema, obtendríamos la palabra raíz. Para el ejemplo mostrado esperaríamos el siguiente conjunto: {moderno, moderno, moderno, moderno, moderno}.

Así, la lematización realiza el análisis morfológico de las palabras, y para ello toma en cuenta diccionarios detallados a través de los cuales busca una forma de enlazar cada palabra a su lemma. Por ende, esta metodología está íntimamente ligada a la lingüística.

Las maneras más comunes de lematizar incluyen el uso de modelos probabilísticos, cadenas de markov o diccionarios. A continuación veremos cómo hacerlo en R con dos métodos:

• Lematización a través de diccionarios (Carlos Gil - DataAnalytics, diccionario lematizador online).

# Función de lematización
library(rvest)
lematiza = function( frase ){
    palabra = gsub( " ", "+", frase )
    base.url = paste0( 
             "https://www.lenguaje.com/cgi-bin/lema.exe?edition_field=", 
             palabra,"&B1=Lematizar")
    lemma = read_html(base.url, encoding = "latin1") %>% 
      html_node(css = "div div div div div li") %>% 
      html_text(trim = T) 
    lemma = ifelse(lemma=='Raíz del sustantivo "suma".',frase,lemma)
    return(lemma)
}
lematiza('comimos')

[1] "comer"

tidy_Freile %>% 
  tail(5) %>% 
  mutate(lemma_dict = sapply(Token,lematiza)) %>%
  select(Token, stem, lemma_dict)

• Lematización pre-entrenada de la librería udpipe.

library(udpipe)
# udpipe::udpipe_download_model('spanish') # Descomentar al ejecutar por primera vez
model = udpipe_load_model(file = "spanish-gsd-ud-2.4-190531.udpipe")
tidy_Velasco_annotated = udpipe_annotate(model, 
                                        x = noticiasVelascoDF$Noticia, 
                                        doc_id = noticiasVelascoDF$Titular)
tidy_Velasco_annotated = as_tibble(tidy_Velasco_annotated)
names(tidy_Velasco_annotated)[6] = "Token" 
tidy_Velasco_annotated = tidy_Velasco_annotated %>% 
  anti_join(stopwords_es) %>% 
  mutate(Token=removePunctuation(Token)) %>% 
  filter(Token!="")

tidy_Larrea_annotated = udpipe_annotate(model, 
                                        x = noticiasLarreaDF$Noticia, 
                                        doc_id = noticiasLarreaDF$Titular)
tidy_Larrea_annotated = as_tibble(tidy_Larrea_annotated)
names(tidy_Larrea_annotated)[6] = "Token" 
tidy_Larrea_annotated = tidy_Larrea_annotated %>% 
  anti_join(stopwords_es) %>% 
  mutate(Token=removePunctuation(Token)) %>% 
  filter(Token!="")

Joining, by = "Token"

tidy_Freile_annotated = udpipe_annotate(model, 
                                        x = noticiasFreileDF$Noticia, 
                                        doc_id = noticiasFreileDF$Titular)
tidy_Freile_annotated = as_tibble(tidy_Freile_annotated)
names(tidy_Freile_annotated)[6] = "Token" 
tidy_Freile_annotated = tidy_Freile_annotated %>% 
  # anti_join(stopwords_es) %>% 
  mutate(Token=removePunctuation(Token)) %>% 
  filter(Token!="")

El resultado de la lematización se verá como:

tidy_Velasco_annotated %>%
  filter(doc_id==ejemplo_Velasco) %>% 
  select(Token,lemma, upos, feats)

La ventaja de la librería UDpipe yace en el hecho de que nuestro texto se encuentra ahora anotado. Así, como última tarea, revisaremos las frecuencias sobre las etiquetas POS:

tidy_Velasco_annotated %>% 
  count(upos) %>% 
  ggplot()+
  geom_col(aes(x=reorder(upos,n),y=n,fill=upos))+
  labs(x="Etiqueta POS", y="Frecuencia", title="Noticias: Juan Fernando Velasco")+
  coord_flip()+
  theme(legend.position = "none", text=element_text(size=18))

Y las 5 palabras más frecuentes (sin contar empates) para cada una de las 4 etiquetas más comunes:

tidy_Velasco_annotated %>% 
  filter(upos %in% c('NOUN','PROPN','VERB','ADJ')) %>% 
  count(upos, lemma) %>% 
  group_by(upos) %>% 
  slice_max(order_by = n, n = 5) %>% 
  ggplot()+
  geom_col(aes(x=reorder_within(lemma,n,upos),y=n,fill=lemma))+
  scale_x_reordered()+
  labs(x="Lemma", y="Frecuencia", title="Noticias: Juan Fernando Velasco")+
  facet_wrap(vars(upos), scales = "free", ncol = 2)+
  coord_flip()+
  theme(legend.position = "none", text=element_text(size=18))

Con miras a una próxima clase, guardamos los resultados de este primer análisis:

saveRDS(tidy_Velasco, "Caso1_Noticias/tidy_Velasco.RDS")
saveRDS(tidy_Larrea, "Caso1_Noticias/tidy_Larrea.RDS")
saveRDS(tidy_Freile, "Caso1_Noticias/tidy_Freile.RDS")
saveRDS(tidy_Velasco_annotated, "Caso1_Noticias/tidy_Velasco_annotated.RDS")
saveRDS(tidy_Larrea_annotated, "Caso1_Noticias/tidy_Larrea_annotated.RDS")
saveRDS(tidy_Freile_annotated, "Caso1_Noticias/tidy_Freile_annotated.RDS")

3. Bibliografía

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

Straka, M. & Straková, J. (2017), «Tokenizing, POS tagging, lemmatizing and parsing UD 2.0 with UDPipe», CoNLL 2017 - SIGNLL Conference on Computational Natural Language Learning, Proceedings of the CoNLL 2017 Shared Task: Multilingual Parsing from Raw Text to Universal Dependencies, vol. 2.