extraire, représenter et traiter la social data avec r. seconde partie: applicaiton au text mining

Extraire, transformer et
repr´esenter la social data avec R
Seconde partie: le text mining
April 23, 2018 1 / 241

Introduction générale du cours
Ce cours permet aux étudiants de se familiariser avec les données capturant la
manière dont les individus interagissent sur les réseaux sociaux.
Les techniques utilisent le logiciel r et différentes de ses librairies. Chaque étudiant devra
installer sur sa machine r, l’environnement de travail Rstudio
(https://www.rstudio.com/) et les bibliothèques nécessaires.
Le cours est construit sur 6 séances. Idéalement, chaque séance sera découpé de la
sorte:
matin: présentation et démonstration du code r
après-midi: mise en application des éléments
A la fin du cours, chaque étudiant devra présenter une analyse autour de social data de
son choix.
April 23, 2018 2 / 241

plan du cours
le contenu du cours est le suivant:
Séance 1: social data et extraction de la social data avec r
Séance 2: manipuler les données dans r
Séance 3: représenter les données dans r
Séance 4: les basiques du text mining dans r
Séance 5: l’analyse de sentiment avec r
Séance 6: le nlp avec r
April 23, 2018 3 / 241

ressources
Le cours est basé sur plusieurs ouvrages récents et consultables en ligne:
R for Data Science, Wickham & Grolemund, O’Reilly, 2017, disponible en ligne:
http://r4ds.had.co.nz/
Advanced R, Wickham, CRC Press, 2014, disponible en ligne:
https://adv-r.hadley.nz/
Data Visualization for Social Science, Healy, forthcoming, Princeton University
Press, disponible en ligne: http://socviz.co/
Cookbook for R, Chang, O’Reilly, 2013, seconde édition, disponible en ligne:
http://www.cookbook-r.com/
Text Mining with R, Silge & Robinson, O’Reilly, 2017, disponible en ligne:
https://www.tidytextmining.com/
Introduction à la programmation en R, Goulet, 2016, cinquième édition:
https://cran.r-project.org/doc/contrib/Goulet introduction programmation R.pdf
The Art of R Programming, Matloff, 2011, no starch press,
http://www.freetechbooks.com/the-art-of-r-programming-t1087.html
Speech and Language Processing, Jurafsky et Martin, 2017,
https://web.stanford.edu/ jurafsky/slp3/
April 23, 2018 4 / 241

ressources hors ouvrages
En dehors de ces ouvrages, différentes ressources peuvent être intéressantes:
la documentation sur la suite tidyverse: https://www.tidyverse.org/
les cheatsheets à télécharger sur le site de rstudio:
https://www.rstudio.com/resources/cheatsheets/
le site de Hadley Wickham: http://hadley.nz/
le blog de thinkR: https://thinkr.fr/le-blog/
le méta blog r-bloggers.com: https://www.r-bloggers.com/
le blog de David Robinson: http://varianceexplained.org/
le blog de Julia Silge: https://juliasilge.com/blog/
le blog Rstudio: https://blog.rstudio.com
sur twitter le hastag #rstats
April 23, 2018 5 / 241

ressources théoriques
Mis à part quelques incursions, le cours n’est pas un cours de datascience. Pour les
étudiants désireux d’acquérir les techniques de base de la datascience, deux ouvrages de
base pourront être consultés:
The Elements of Statistical Learning, Hastie, Tibshirani & Friedman , Springer,
seconde edition 2008 : https://web.stanford.edu/ hastie/Papers/ESLII.pdf
An Introduction to Statistical Learning with Applications in R, James, Witten,
Hastie & Tibshirani, Springer, sixième edition 2013 :
http://www-bcf.usc.edu/ gareth/ISL/
Concernant le deep learning et R, ce blog (https://tensorflow.rstudio.com/blog.html)
est une source intéressante en lien avec cet ouvrage récent:
https://www.manning.com/books/deep-learning-with-r.
April 23, 2018 6 / 241

April 23, 2018
April 23, 2018 7 / 241

S´eance 4: le package tidytext
April 23, 2018 8 / 241

L’approche ’bag of word”
Très très globalement, on peut distinguer deux approches en terme de text mining:
les approches de type ”bag of word”:
les approches de type ”syntactic parsing”
L’approche bag of word approche un texte comme une suite non organisée de mots. Dans ce cours, nous verrons le package
tidytext qui permet de découper un text en ngrams et poser les premières briques du topic modeling
Figure: l’approche bag of word, tiré de Speech and Language Processing. Jurafsky et Martin (2017)
April 23, 2018 9 / 241

L’approche ”syntactic parsing”
L’approche ”syntactic parsing” appréhende un document comme un vecteur de V dimensions où V est la taille du vocabulaire
utilisé. Cette représentation permet de prendre en compte la structure d’organisation des mots.
Figure: l’approche ”syntactic parsing”, Kwartler (2017)
Concernant l’approche ”syntactic parsing”, nous utiliserons différents packages développés récemment autour du NLP comme
openNLP ou word2vec. Mais avant de voir ces packages, il nous faut nous plonger dans les techniques de nettoyage du texte.
April 23, 2018 10 / 241

le nettoyage du texte
Après les phases de collecte et de prétraitement des données vient la phase de nettoyage. Cette
phase est un passage obligé qui va permettre notamment:
d’uniformiser la mise en forme du texte (ponctuations, majuscule, termes spéciaux),
de supprimer les mots communs ou stopword,
de supprimer certains mots via un dictionnaire spécifique,
de supprimer ou non certains éléments (urls, émojis, etc...)
substituer des chaines de caractère
Un certain nombre d’outils et de techniques permettent dans r de réaliser ces tâches:
les regex ou expressions régulières qui fournissent des méthodes normalisées pour
rechercher, supprimer et substituer des chaˆınes de caractères,
des packages spécifiques comme stringr ou stringi (il y a en a d’autres) qui permettent
de traiter les chaˆınes de caractères,
des fonctions spécifiques de package de text mining comme lsa ou tm qui permettent de
nettoyer le texte
April 23, 2018 11 / 241

le nettoyage du texte: un processus pragmatique et
progressif
Avec le text-mining il faudra souvent coder soi-même certaines procédures adhoc à l’aide de ces
éléments:
en écrivant des fonctions qui permettent d’effectuer en groupe des traitements,
en recombinant certaines procédures existants
en adaptant la documentation existante (stackoverflow, ....)
Dans tous les cas, la phase de nettoyage soit être:
pragmatique: à chaque texte, à chaque étude son traitement et ses phases de nettoyage,
progressive: à chaque phase, on risque d’endommager le corpus de manière permanente
(ex: supprimer du texte ou des expressions non voulues)
maˆıtrisée: certains traitements sur les matrices de texte sont extrêmement gourmands en
mémoire active. Or r est également très gourmand (c’est l’un de ses défauts...), il faudra
parfois faire des arbitrages entre les procédures.
April 23, 2018 12 / 241

les fonctions de base pour travailler avec les chaˆınes de
caractère
De base r possède des fonctions pour travailler avec les chaˆınes de caractère:
https://stat.ethz.ch/R-manual/R-devel/library/base/html/grep.html
Example
# 1 détecter si le pattern est présent dans ma cha^ıne de caractère ==>booléen
grepl(mon pattern, ma cha^ıne)
# 2 obtenir l’index des éléments d’une liste matchant le pattern ==>numeric
grep(mon pattern, ma cha^ıne)
# 3 substituer un pattern à un autre
sub(ma_cha^ıne, mon pattern, mon pattern de remplacement, ma cha^ıne) ***
# 4 indique à quelle place un pattern appara^ıt ==>matrice
gsub(ma_cha^ıne, mon pattern, mon pattern de remplacement, ma cha^ıne, ignore.case=T)
# 5 localise un pattern dans une cha^ıne de caractère
regexpr(’’a’’, message)
April 23, 2018 13 / 241

les fonctions de base pour travailler avec les chaˆınes de
caractère (2)
Quelques fonctions supplémentaires
Example
# 1 strsplit: segmenter une cha^ıne de caractère si matching d’un pattern ==>cha^ıne
strsplit(x, ma cha^ıne, pattern)
# 2 nchar: obtenir le nombre de caractère d’une cha^ıne: ==>numeric
nchar(ma cha^ıne)
# 3 paste: concatène un objet r en une cha^ıne de caractère avec séparation
paste(mon_objet, sep = " ", collapse = NULL)
# 4 agrep: matching imparfait (notion de distance)
agrep(pattern, ma cha^ıne ignore.case=FALSE, max= integer)
April 23, 2018 14 / 241

le package stringr
Le package stringr permet de manipuler les chaˆınes de caractère sans transformation préalable
du texte (à la différence du package tm qui nécessite de transformer le texte en un corpus).
Intégré dans tidyverse, il est possible de l’utiliser par exemple pour traiter l’ensemble des lignes
d’une colonne d’un dataframe comprenant du texte. Il permet d’effectuer les prétraitements en
amont de l’utilisation du package tidytext.
Le package offre de nombreuses options et possibilités pour manipuler les chaˆınes de caractère.
Dans les phases les plus communes de text mining nous utiliserons très souvent trois opérations:
je veux détecter si une phrase contient un pattern particulier (mot, expression) pour
compter le nombre d’occurrence, connaˆıtre la position du pattern dans la chaˆıne de
caractère
je veux extraire un pattern particulier
je veux substituer un pattern particulier à un autre
je veux filter mes données en fonction de l’existence un pattern particulier dans ma
chaˆıne de caractère
April 23, 2018 15 / 241

détecter des patterns avec le package stringr
Example
# 1 détecter si le pattern est présent dans ma cha^ıne de caractère ==>booléen
str_detect(ma_cha^ıne, mon pattern)
# 2 obtenir l’index des éléments d’une liste matchant le pattern ==>numeric
str_which(ma_cha^ıne, mon pattern)
# 3 compter le nombre de fois où le pattern appara^ıt ==>numeric
str_count(ma_cha^ıne, mon pattern)
# 4 indique à quelle place un pattern appara^ıt ==>matrice
str_locate(ma_cha^ıne, mon pattern)
April 23, 2018 16 / 241

les résultats
Example
gateau<-c("eclair", "mousse", "baba")
# 1 détecter si le pattern est présent dans ma cha^ıne de caractère
str_detect(gateau, "a")
[1] TRUE FALSE TRUE
# 2 détecter l’index
str_which(gateau, "a")
[1] 1 3
# 3 compter le nombre de fois où le pattern appara^ıt
str_count(gateau, "a")
[1] 1 0 2
# 4 détecte à quelle place un pattern appara^ıt
str_locate(gateau, "a")
start end
[1,] 4 4
[2,] NA NA
[3,] 2 2
April 23, 2018 17 / 241

extraire et identifier des patterns avec le package stringr
Example
# 1 extraction d’un pattern ==>cha^ıne caractère
str_sub(ma_cha^ıne, début de l’extraction av, fin de l’extraction après)
str_sub(message, 2,4)
# 2 extract des éléments d’une liste contenant le pattern ==>cha^ıne
str_subset(ma_cha^ıne, mon pattern)
str_subset(message, "z")
# 3 extraction du pattern à chaque matching ==>vecteur caractère
str_extract(ma_cha^ıne, mon pattern)
str_extract(message, "z’’)
str_extract_all(message, "z")
# 4
str_match(ma_cha^ıne, mon pattern)
str_match(message, "z’’) matrice
str_match_all(message, "z") matrice
April 23, 2018 18 / 241

les r´esultats
Example
# 1 str_sub(gateau, 2,4)
[1] "cla" "ous" "aba"
# 2 str_subset(gateau, "a")
[1] "eclair" "baba"
# 3 str_extract_all(gateau, "a")
[1] "a" NA "a"
# 4 str_extract_all(gateau, "a")
[[1]]
[1] "a"
[[2]]
character(0)
[[3]]
[1] "a" "a"
# 5 str_match(gateau, "a")
[,1]
[1,] "a"
[2,] NA
[3,] "a"
April 23, 2018 19 / 241

substituer des patterns avec le package stringr (***)
Example
# 1
str_sub()<-value
# 2
str_replace(ma_cha^ıne, mon pattern, mon pattern de remplacement)
# 3
str_replace_all(ma_cha^ıne, mon pattern, mon pattern de remplacement)
# 4
str_to_lower(ma_cha^ıne)
str_to_upper(ma_cha^ıne)
str_to_title(ma_cha^ıne)
April 23, 2018 20 / 241

autres fonctions intéressantes de stringr
Example
# 1
str_length (ma_cha^ıne) extraction de la longueur d’une cha^ıne de caractère =>numeric
str_length(gateau)
[1] 6 6 4
# 2
str_pad(ma_cha^ıne, nbcar_av, nbcar_ap) place espace avant après (str_trim())
[1] "eclair" "mousse" "baba"
# 3
str_dup(ma_cha^ıne, numeric)
str_dup(gateau,3)
[1] "eclaireclaireclair" "moussemoussemousse" "babababababa"
April 23, 2018 21 / 241

un complément à stringr: stringi
stringi permet de manipuler les chaˆınes de caractère sans transformation préalable du texte. La
documentation (https://cran.r-project.org/web/packages/stringi/stringi.pdf) de 136 pages (!!!)
donne l’aper¸cu des possibilités. Comme stringr le package permet de substituer, extraire,
compter, trier les chaˆınes de caractère via des procédures de matching. Voici une liste des
fonctions souvent utilisées:
stri detect()
stri count()
stri dup()
stri extract all()
stri length()
stri replace all()
stri split()
stri sub()
stri subset()
stri reverse()
stri pad both()
stri match all()
stri replace na()
stri trim both()
2
April 23, 2018 22 / 241

Comparaison entre les packages de gestion des chaˆınes de
caractère
Objet Base r Stringr Stringi forme
extraction d’un pattern regmatches() str extract() stri extract all chaine
extraction selon position regmatches() str sub() stri sub() chaine
extraction des x pattern regmatches() str extract all() stri extract all chaine
localisation des pattern regexpr() str locale() stri locale() numeric
localisation des x patterns gegexpr() str locale all() stri locale all() numeric
substitution des pattern sub() str replace() stri replace() chaine
substitution x fois des pattern gsub() str replace all() stri replace all() chaine
détection d’un pattern grepl() str detect() stri detect() booléen
découpe selon un pattern strsplit() str split() stri split() chaine
concatène selon un pattern paste(), paste0() str c() stri c et stri paste chaine
donne la longueur d’une chaˆıne nchar str length() stri length numeric
Table: Comparaison entre les packages de gestion des chaˆınes de caractère adapté de ”automated data collection with r”,
Munzert & al.
April 23, 2018 23 / 241

exemple d’utilisation de str detect
Je veux identifier les posts facebook qui contiennent des termes
particuliers afin de créer une catégorie.
Example
# 1 je crée une liste, mon dictionnaire de mots clés
jeux <- c("jeu", "concours", "CONCOURS","Concours", "Jeux", "Gagnez",
"Jouer", "tirage","tiré","Tirage", "jouer")
# 2 je crée une colonne supplémentaire dans mon extract que je nomme concours
mes_donnees$concours[is.na(mes_donnees$concours)] <- "autre"
# 3 je crée ma règle: si je détecte un des mots dans le titre du post
alors ce le post sera classé ’’jeu’’ sinon ’’autre’’
mes_donnees<-mes_donnees%>%
mutate(concours=ifelse(str_detect(message, paste(jeux, collapse="|")),
"concours", "autre"))
April 23, 2018 24 / 241

exemple d’utilisation de string detect
Quel résultat?
Example
graphique_eng_concours<-numi_neomas%>%
mutate(annee = format(created_time, "%Y"))%>%
group_by(type,concours,from_name, annee)%>%
filter(annee>="2017")%>%
filter(concours !=’NA’)%>%
summarise(total = sum(total_engagement))%>%
ggplot(aes(x= reorder(from_name, -total),y=total,fill=from_name))+
geom_bar(stat = "identity")+coord_flip()+
facet_grid(concours~type)+
scale_y_continuous(labels = comma)+labs(x = "page",
y = "volume de l’engagement",
title = "volume d’engagement généré
par les posts en 2017",
subtitle = "hors dark posts")
April 23, 2018 25 / 241

mon r´esultat
April 23, 2018 26 / 241

exemple d’utilisation de str remplace
Je travaille sur un dataset twitter et je veux supprimer à la fois les RT et
les urls des messages
Example
# 1 je crée une cha^ıne de caractère (une expression régulière)
remplace_regex <- "https://[A-Za-zd]+
|http://[A-Za-zd]+|&|<|>|RT|https"
# 2 je passe ma regex avec la fonction str_replace_all
clean_text <- mes_datas %>%
filter(!str_detect(text, "^RT")) %>%
mutate(text_clean = stringr::str_replace_all(text, remplace_regex,’’’’ )
# 3 autre écriture
clean_text <- mes_datas %>%
mutate(text_clean = stringr::str_replace_all(text, "https://t.co/[A-Za-zd]+
|http://[A-Za-zd]+|&|<|>|RT|https",’’’’ )
April 23, 2018 27 / 241

application de la proc´edure
Example
tmls <- rtweets::get_timelines(c("hadleywickham", "drob", "juliasilge"), n = 3200)
==>colonne du dataset est tmls$text
#je cree une nouvelle colonne
tmls %>%
#je cree un nouveau dataset avec une nouvelle colonne
clean_text <- tmls %>%
April 23, 2018 28 / 241

autres formules int´eressantes
Example
#je veux extraire les urls d’une chaine de caract`ere
library(stringr)
url_pattern <- "http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*(),]|(?:%[0-9a-fA-F][0
mes_urls <- str_extract(tmls, url_pattern)
mes_urls <- unlist(mes_urls)
mes_urls<-na.omit(mes_urls)
mes_urls<-as.data.frame(mes_urls)
mon_data_frame$mes_hastags <- str_extract_all(mon_data_frame$mon_text, "#S+")
hs_pattern<-"#S+"
mon_data_frame$mes_hastags <- str_extract_all(mon_data_frame$mon_text, hs_pattern)
mon_data_frame$mes_id <- str_extract_all(mon_data_frame$mon_text, "@S+"
id_pattern<-"@S+"
mon_data_frame$mes_hastags <- str_extract_all(mon_data_frame$mon_text, id_pattern)
April 23, 2018 29 / 241

travail sur les hashtags
Example
tmls$mes_hastags <- str_extract_all(tmls$text, "#S+")
hs_pattern<-"#S+"
tmls$mes_hastags <- str_extract_all(tmls$text, hs_pattern)
hashtags <- unlist(tmls$mes_hastags)
hashtags<-as.data.frame(hashtags)
hashtags$hashtags<-substring(hashtags$hashtags, 2)
nb_hashtags<-table(hashtags)
sort(nb_hashtags, decreasing = TRUE)[1:30]
#ok m^eme traitement possible pour les mentions (sauf l’extraction du @)
April 23, 2018 30 / 241

l’aide mémoire sur le package stringr
Figure: à télécharger ici: https://www.rstudio.com/resources/cheatsheets
April 23, 2018 31 / 241

Le package tidytext
Le package tidytext est un package récent permettant de faire du text mining. Comme indiqué
au début du cours les deux auteurs de tidytext ont mis en ligne l’ouvrage qu’ils ont consacré à
ce package: https://www.tidytextmining.com/
Par ailleurs, les blogs des deux auteurs rendent compte des dernières évolutions du package:
http://varianceexplained.org/ (david robinson)
https://juliasilge.com/ (julia silge)
Combinant l’approche de text mining ”bag of words” et l’approche de stockage des données
”tidy” ce package permet d’effectuer rapidement des traitements de text mining.
Techniquement, le package permet de découper la chaˆıne de caractère en n-grams:
n grams=1 alors je découpe mot à mot ma chaˆıne de caractère
n grams=2 alors je découpe ma chaˆıne de caractère par bloc de deux mots
n grams=3 alors je découpe ma chaˆıne de caractère par bloc de trois mots
April 23, 2018 32 / 241

les ramifications de tidytext
Ce package tidytext permet à la fois de calculer les métriques traditionnelles en text mining
comme le td-idf ou le coefficient de gini, d’effectuer des analyses de sentiment, de produire aussi
bien des analyses de type topic modeling ou encore de type word embedding. Du fait de la
structure ”tidy”’ des données, il est compatible avec les packages comme dplyr, purr, stringr ou
encore ggplot.
April 23, 2018 33 / 241

le principe de base de tidytext: la fonction unnest ou
tokenization
Example
library(tidytext) #je load la librairie
mon_tidy_dataframe<-mon_dataframe %>%
unnest_tokens(word, le_texte_de_mon_dataframe)
April 23, 2018 34 / 241

mon dataset de travail
Pour travailler sur ce package, nous avons constitué un nouveau dataset qui contient les 3000
derniers posts pour cinq pages facebook: le figaro, le monde, libération et france inter.
Example
library(Rfacebook)
library(lubridate)
library(tidyverse)
library(tidytext)
#j’extrait les données
lemonde <-getPage(page="lemonde.fr", token=fb_oauth, n = 3000)
franceinter<-getPage(page="franceinter", token=fb_oauth, n = 3000)
liberation<-getPage(page="Liberation", token=fb_oauth, n = 3000)
lefigaro<-getPage(page="lefigaro", token=fb_oauth, n = 3000)
lacroix<-getPage(page="lacroix.journal", token=fb_oauth, n = 3000)
# je combine les extracts en un dataset (ok==>dataframe)
presse<-rbind(lemonde, franceinter, liberation, lefigaro,lacroix)
April 23, 2018 35 / 241

les données de départ
Je dispose au départ d’un extract Facebook avec les titres des posts dans la colonne
mes donnees$Message. Je souhaite analyser le texte de ces messages (connaˆıtre les
thématiques, les associations de mots, les mots les plus fréquents, etc...)
April 23, 2018 36 / 241

le traitement de base effectuer par tidytext
En une ligne, j’ai découpé chaque message en bloc de 1 mot (option proposée par le package par
défaut). Au départ, chaque post est stockée sur une ligne de mon dataframe. Après le
découpage du texte du message, j’aurai autant de lignes que la longueur du message. A mon
dataframe de départ est venue s’ajouter une nouvelle colonne: mes donnees$word
April 23, 2018 37 / 241

les mots les plus pr´esents....
J’obtiens un tibble de deux colonnes avec le mot et son classement. Quels sont les mots les
pr´esents dans le classement: macron, politique, donald, ...?
Example
tidy_presses<-presse%>%
unnest_tokens(word,message)%>%
dplyr::count(word, sort=TRUE)
Il va falloir nettoyer....
April 23, 2018 38 / 241

code pour visualiser les mots pr´esents plus de 600 fois
Example
tidy_presses_graph<-presse%>%
dplyr::count(word, sort=TRUE)%>%
mutate(word=reorder(word,-n))%>%
filter(n>600)%>%
ggplot(aes(x=word,y=n))+
geom_bar(stat="identity")+theme_minimal()+
theme(axis.text=element_text(size=6),
axis.title=element_text(size=6,face="bold"))+
theme(axis.text.x = element_text(size=8,angle = 90, hjust = 1))
April 23, 2018 39 / 241

r´esultat graphique
Dans l’´etat, le graphique ne nous apprends rien....
April 23, 2018 40 / 241

code pour supprimer les mots communs
Example
Afin de supprimer les mots communs, nous allons utiliser la commande filter de dplyr, les
dictionnaires de mots communs de tidytext et d’autres dictionnaires issus de package si besoin
est.
# utlisation du dictionnaire intégré dans tidytext
anti_join(stop_words) %>% #pas de fran¸cais
anti_join(get_stopwords(language = "fr"))%>% #nouveau add-on
filter(n>600)%>%
geom_bar(stat="identity",fill = "#FF6666")+theme_minimal()+
axis.title=element_text(size=8))+
theme(axis.text.x = element_text(size=8,face="bold",angle = 90, hjust = 1))+
labs(x = "mots",
y = "nombre d’occurence",
title = "liste des mots apparaissant plus de 600 fois dans les tokens")
April 23, 2018 41 / 241

C’est d´ej`a mieux....
April 23, 2018 42 / 241

utiliser différents packages pour supprimer les mots
communs
Parfois il faut combiner plusieurs dictionnaires de différents package pour supprimer les mots
clés. On utilise la syntaxe suivante: nom package::fonction du package)
Example
anti_join(stop_words) %>% #pas de fran¸cais
anti_join(get_stopwords(language = "fr"))%>% #nouveau add-on
filter(!word %in% tm::stopwords(’en’))%>% # dictionnaire tm ==> load(tm)
filter(!word %in% lsa::stopwords_en)%>%# dictionnaire lsa==> load(lsa)
filter(!word %in% tm::stopwords(’fr’))%>%
filter(!word %in% lsa::stopwords_fr)%>%
filter(n>600)%>%
theme(axis.text=element_text(size=8), axis.title=element_text(size=8))+
theme(axis.text.x = element_text(size=8,face="bold",angle = 90, hjust = 1))+
labs(x = "mots",y = "nombre d’occurence",
title = "liste des mots apparaissant plus de 600 fois dans les tokens")
April 23, 2018 43 / 241

C’est encore mieux....
April 23, 2018 44 / 241

.... mais ce n’est pas parfait: url, nombre, mots li´es `a l’extract...
April 23, 2018 45 / 241

utiliser des filtres généraux
Ajoutons quelques filtres...)
Example
filter(str_detect(word, "[a-z]"))%>%
filter(word !="http")%>%
filter(nchar(word)>1)%>%
anti_join(stop_words) %>%
anti_join(get_stopwords(language = "fr"))%>%
filter(!word %in% tm::stopwords(’en’))%>%
filter(!word %in% lsa::stopwords_en)%>%
filter(n>100)%>%
theme(axis.text.x = element_text(size=8,face="bold",angle = 90))+
labs(x = "mots",
title = "liste des mots apparaissant plus de 100 fois dans les tokens")April 23, 2018 46 / 241

....les urls...
April 23, 2018 47 / 241

traiter les urls
Example
mutate(word = str_replace_all(word,"https://t.co/[A-Za-zd]+
|http://[A-Za-zd]+
|&|<|>|RT|https|[’‘^~’]|[:digit:]|[:punct:]",""))%>%
mutate(word = str_replace_all(word, "https|//t|http|&|<|>", ""))%>%
filter(word !="bitly")%>%
filter(n>100)
April 23, 2018 48 / 241

il reste encore du bruit (libération, libé, figaro, france, les mots commen¸cant par www., etc...)
Plus le texte sera bruité, plus les résultats seront difficiles à interpréter (ex: topic modeling).
Dans le même temps, plus on applique de filtre, plus on risque de détruire le texte (attention
aux regex).
En dernier recours, il est possible de filtrer à la ”main” le texte en créant une liste de mots et
d’expressions que l’on souhaite exclure.
Example
#je crée une liste de mots que je souhaite exclure:
mystopwords <- data_frame(word=c("libération", "libé", "france", "lefigaro.fr",
"appsfacebookcomliberationjournalreaderdate","dun", "dune", "figaro",
"kiosquelefigarofrlefigaroxtoral", "http", "bitly", "liberation.fr",
"www.liberationfr","liberation","lacroix","journalliberation","cc",
"kiosquelefigarofr"))
#j’utilise la syntaxe suivante de dplyr pour passer mon dictionnaire
anti_join(mystopwords, by = "word")
April 23, 2018 49 / 241

notre proc´edure....
Example
tidytext::unnest_tokens(word,message)%>%
dplyr::mutate(word = stringr::str_replace_all(word,"https://t.co/[A-Za-zd]+
http://[A-Za-zd]+|&|<|>|RT|https|[’‘^~’]|[:digit:]|[:punct:]",""))%>%
anti_join(mystopwords, by = "word")%>%
filter(n>100)%>%
ggplot(aes(x=word,y=n))+ geom_bar(stat="identity",fill = "#FF6666")+theme_minimal()+
theme(axis.text=element_text(size=8), axis.title=element_text(size=8))+
theme(axis.text.x = element_text(size=8,face="bold",angle = 90))
April 23, 2018 50 / 241

....le résultat non définitif. On pourrait filter les mots le nombre de caractère, en utilisant le
matching approximatif (fuzzy matching). Au délà de son résultat, ”on” apprend beaucoup du
texte lors de cette phase.
April 23, 2018 51 / 241

commen¸cons les calculs: la fr´equence d’occurrence des
mots (1)
Example
# ma proc´edure de nettoyage du texte.
base<-presse%>%
mutate(word = str_replace_all(word,"https://t.co/[A-Za-zd]+
|http://[A-Za-zd]+
|&|<|>|RT|https|[’‘^~’]|[:digit:]|[:punct:]",""))%>%
filter(!word %in% lsa::stopwords_fr)
April 23, 2018 52 / 241

mots (2).
Example
# a partir de ce résultat, je calcule le total de fois où un mot est présent dans me
en fonction de la page
mots_page<-base%>%
count(from_name, word, sort = TRUE) %>%
ungroup()
April 23, 2018 53 / 241

April 23, 2018 54 / 241

mots.
Example
# je calcule ensuite la somme des mots par page
(je vais juste un ’’group_by)
total_words <-mots_page%>%
group_by(from_name) %>%
summarize(total = sum(n))
April 23, 2018 55 / 241

jointure des deux ﬁchiers
Example
# j’effectue une jointure
page_mots<- left_join(mots_page, total_words)
April 23, 2018 56 / 241

le calcul du tf idf
Les calculs que nous venons d’effectuer vont nous permettre de calculer le tf-idf (terme
frequency inverse document frequency).
Cette mesure statistique permet d’évaluer l’importance d’un terme contenu dans un document
relativement à une collection de document. Le poids d’un terme va diminuer
proportionnellement au nombre d’occurrences du mot dans l’ensemble des documents (fréquence
du mot dans l’ensemble du corpus) et accroˆıtre lorsqu’il est très présent dans un document
appartenant au corpus.
Un document a plus de chances d’être pertinent comme réponse à une recherche d’un terme si
ce document possède une certaine occurrence de ce terme en son sein et que ce terme possède
une rareté dans d’autres documents reliés à ce document.
Dans notre exemple, le document ne sera pas un post compte tenu de sa faible longueur mais
l’ensemble des posts publiés par une page. Autrement dit, nous avons 5 documents avec chaque
document est composé des 5000 posts d’une seule et unique page. En calculant le tf idf entre
les pages, je souhaite mettre en évidence les termes les ”plus” spécifique à une page.
April 23, 2018 57 / 241

le calcul du tf idf dans tidytext: la fonction bind tf idf
Example
# j’appelle la fonction
origine_words <- page_mots%>%
bind_tf_idf(word, from_name, n)%>%
arrange(desc(tf_idf))
Les résultats laissent effectivement apparaˆıtre les spécificités des pages (ex france inter les
chroniqueurs).
April 23, 2018 58 / 241

un graphique illustratif
Example
bind_tf_idf(word, from_name, n)
origine_words <- origine_words %>%
plot_words<-origine_words%>%
arrange(desc(tf_idf))%>%
top_n(50) %>%
mutate(word = factor(word, levels = rev(unique(word))))%>%
ggplot(aes(word, tf_idf, fill = from_name)) +theme_minimal()+
geom_bar(stat = "identity") +
labs(x = NULL, y = "tf-idf") +
coord_flip()
April 23, 2018 59 / 241

top 50 par tf-idf
April 23, 2018 60 / 241

vision par page
Example
bind_tf_idf(word, from_name, n)
origine_words <- origine_words %>%
plot_plot_words<-origine_words %>%
mutate(word = factor(word, levels = rev(unique(word))))
plot_plot_words_plot<-plot_plot_words %>%
top_n(15) %>%
ungroup %>%
ggplot(aes(word, tf_idf, fill = from_name)) +
geom_bar(stat = "identity", show.legend = FALSE) +
facet_wrap(~from_name, ncol = 2, scales = "free") +
coord_flip()
April 23, 2018 61 / 241

quels sont les mots les plus spécifiques entre les différentes
pages?
April 23, 2018 62 / 241

la loi de Zipf’s
Nous venons de voir le calcul du tf-idf avec tidytext. Toujours à partir des fréquences
d’occurrence des mots, il est possible de calculer un indicateur qui relie la fréquence d’utilisation
d’un mot et son rang: la loi de Zipf’s.
La loi de Zipf prévoit que dans un texte donné, la fréquence d’occurrence f(x) d’un mot est liée
à son rang rank (x) dans l’ordre des fréquences par une loi de la forme f ( x ) = K/x où K est
une constante.
Par exemple si l’on choisit K=3000 alors le mot le plus courant est censé revenir 3 000 fois, le
dixième mot reviendra 300 fois, le centième 30 fois et le millième, 3 fois.
La loi suggère que le plus le rang d’un mot augmente, plus sa fréquence sera faible.
April 23, 2018 63 / 241

quels sont les mots les plus spécifiques entre les différentes
pages?
Example
freq_by_rank <- origine_words %>%
mutate(rank = row_number(),
‘term frequency‘ = n/total)
#filtre que les valeurs extrêmes
rank_subset <- freq_by_rank %>%
filter(rank < 2000)
#calcul de la relation :lm(log10(‘term frequency‘) ~ log10(rank), data =rank_subset)
Coefficients: (Intercept: -1.5978 ) log10(rank: -0.7238 )
#je remplace dans le graphique les coefficients pour tracer la courbe.
freq_by_rank %>%
ggplot(aes(rank, ‘term frequency‘, color = from_name)) +
geom_abline(intercept = -1.6, slope = -0.72, color = "gray50", linetype = 2) +
geom_line(size = 1.1, alpha = 0.8) + theme_minimal()+ theme(legend.position="top")
scale_x_log10()+ scale_y_log10(labels=scales::comma)
April 23, 2018 64 / 241

une bonne approximation?
April 23, 2018 65 / 241

travailler sur les associations de mots avec tidytext
Nous avons travaillé avec tidytext avec la même stratégie: découper un texte en bloc d’un mot
(n gram=1).
Tidytext permet de découper le texte en bloc de mots supérieur à un mot (n gram=2, n
gram=3) pour travailler sur des associations de mots. Une fois ces associations identifiées, nous
allons être capable d’appliquer ensuite certains calculs comme le tf idf afin d’identifier les
associations les plus spécifiques. Au niveau de la visualisation, les associations vont nous
permettre d’utiliser les représentations en réseau.
April 23, 2018 66 / 241

quels sont les couples de mots les plus spécifiques entre les
différentes pages?
Example
# je charge les packages nécessaires (nous utiliserons le dataset presse)
library(dplyr)
library(tidytext)
library(stringr)
library(lsa)
library(tm)
library(tidyr)
# a partir du dataset de base, je crée un nouveau dataset
presse_ngram<-dplyr::select(presse, id, message, from_name)
# j’appelle la fonction du package tidytext
j’applique la fonction sur la colonne message avec ngrams=2
presse_bigram <-presse_ngram%>%
tidytext::unnest_tokens(ngram, message, token = "ngrams", n = 2)
April 23, 2018 67 / 241

la structure du dataframe
April 23, 2018 68 / 241

quelques manipulations interm´ediaires...
Example
# j’effectue des manipulations
# je compte le nombre de couple
presse_bigram%>%
count(ngram,sort=TRUE)
# je s´epare les mots ==>deux colonnes
library(tidyr)
presse_bigram_separated <- presse_bigram%>%
tidyr::separate(ngram, c("word1", "word2"), sep = " ")
April 23, 2018 69 / 241

le r´esultat sous forme de dataframe
Il va falloir nettoyer le corpus (encodage.....)
April 23, 2018 70 / 241

première étape du nettoyage
Example
# je supprime les mots communs (j’applique les régles pour
chaque mot cf. word1 et word2)
bigram_filtered <- presse_bigram_separated %>%
dplyr::filter(!word1 %in% stop_words$word) %>%
dplyr::filter(!word1 %in% mystopwords$word) %>%
dplyr::filter(!word1 %in% lsa::stopwords_en)%>%
dplyr::filter(!word1 %in% lsa::stopwords_fr)%>%
dplyr::filter(!word2 %in% lsa::stopwords_fr)
April 23, 2018 71 / 241

seconde étape: je supprime les caractères spéciaux
Example
# je supprime les mots communs
(j’applique les régles pour chaque mot cf. word1 et word2)
bigram_filtered$word1<-str_replace_all(bigram_filtered$word1,
"https://t.co/[A-Za-zd]+|http://[A-Za-zd]+|&|<|>|RT|https|[’‘^~’]
|[:digit:]|[:punct:]","")
bigram_filtered$word2<-str_replace_all(bigram_filtered$word2,
"https://t.co/[A-Za-zd]+|http://[A-Za-zd]+|&|<|>|RT|https|[’‘^~’]
|[:digit:]|[:punct:]","")
bigram_filtered$word1<- str_replace_all(bigram_filtered$word1,
"https|//t|http|&|<|>", "")
bigram_filtered$word2<- str_replace_all(bigram_filtered$word2,
"https|//t|http|&|<|>", "")
April 23, 2018 72 / 241

une méthode (de brut) pour les accents
En sortie j’observe que le mot élection est devenu ã c lections du fait d’un problème d’encodage.
Il est possible de gérer ce problème en combinant:
Example
une règle de ce type:
bigram_filtered$word1<-gsub("lâTMasile","asile ",bigram_filtered$word1)
une règle sur les accents de ce type:
bigram_filtered$word1<-gsub("~A","à",bigram_filtered$word1)
une règle avec une regex:
bigram_filtered$word2<-str_replace_all(bigram_filtered$word2, ".*âTM","")
#exemples
x <- ’aabb.ccdd’ ==>mon caractère de référence (.)
xx<-str_replace_all(’.*’, ’’, x) ==>’’
xxx<-str_replace_all(’bb.*’, ’’, x) ==>’aa’
xxxx<-str_replace_all(’.*bb’, ’’, x) ==> ‘.ccdd’
xxxxx<-str_replace_all(’..*’, ’’, x) ==>’aabb’
xxxxx<-str_replace_all(’.*.’, ’’, x) ==>’ccdd’
April 23, 2018 73 / 241

la multiplication des r`egles de substitution
April 23, 2018 74 / 241

le r´esultat des traitements de nettoyage
April 23, 2018 75 / 241

les manipulations du dataframe
Une fois le texte un peu plus propre, il est possible d’engager les transformations
Example
#je calcule le nombre d’´el´ements
bigram_counts <- bigram_filtered %>%
count(word1, word2, sort = TRUE)
#je concatene les deux colonnes en une
presse_bigram_united <- bigram_filtered %>%
unite(ngram,word1, word2, sep = " ")
#je calcule le tf-idf sur cette colonne unique
bigram_tf_idf <- presse_bigram_united %>%
count(from_name,ngram) %>%
bind_tf_idf(ngram, from_name, n) %>%
April 23, 2018 76 / 241

la structure d’organisation des donn´ees interm´ediaires
April 23, 2018 77 / 241

un premier résultat graphique de l’association des mots
Example
#je calcule le nombre d’éléments
bigram_tf_idf %>%
select(-sum(n))%>%
plot_bigram<-bigram_tf_idf%>%
mutate(ngram = factor(ngram, levels = rev(unique(ngram))))
#je choisis d’afficher seulement les 60 premiers résultats
ggplot(plot_bigram[1:60,], aes(ngram, tf_idf, fill = from_name)) +
coord_flip()
April 23, 2018 78 / 241

les 60 plus fortes associations de mots en vertu du tf-idf
April 23, 2018 79 / 241

les 20 plus fortes associations de mots en vertu du tf-id par
page
Example
#je s´electionne 20 premiers r´esutlats par page
plot_bigram<- plot_bigram%>%
top_n(20) %>%
ungroup
ggplot(plot_bigram, aes(ngram, tf_idf, fill = from_name)) +
coord_flip()
April 23, 2018 80 / 241

le graphique
April 23, 2018 81 / 241

un récapitulatif intermédiaire
Tidytext permet donc de découper le texte en n grams
Example
#je veux découper mot à mot mon texte
bigram_counts <- bigram_filtered %>%
count(word1, word2, sort = TRUE)
#je veux découper mon texte par couple de mots
mes_bigrams <- mes_donnees %>%
unnest_tokens(bigram, text, token = "ngrams", n = 2)
#je veux découper mon texte par bloc de trois mots
mes_trigrams <- mes_donnees %>%
unnest_tokens(trigram, text, token = "ngrams", n = 3)
Bien évidemment, il faut ensuite adapter les phases de traitement au nombre de ngrams. Nous
verrons une application de cette méthode lorsque nous nous intéresserons au sentiment analysis.
April 23, 2018 82 / 241

visualiser les associations de mots avec igraph
Robinson et Silge recommandent le package igraph pour visualiser les réseaux d’association de
mots. igraph (documentation ici: http://igraph.org/r/ de 431 pages...) permet de représenter
les données en réseaux à partir d’un dataframe en passant par la fonction ggraph du package
ggraph. A noter que igraph comme ggplot repose également sur la ”logique” de la grammaire
des graphiques ou grammaire en couches.
Example
library(igraph)
#je filtre sur le nombre de fois où est présent le même bigram et
je passe la fonction graph_from_data_frame() du package igraph
bigram_graph <- bigram_counts %>%
filter(n >20) %>%
graph_from_data_frame()
#j’appelle le package ggraph pour passer de la forme dataframe à une forme
d’organisation des données comptatible avec la représentation en réseau
library(ggraph)
set.seed(2017)
ggraph(bigram_graph,layout = ’kk’) +
geom_edge_link() + geom_node_point() +
geom_node_text(aes(label = name), vjust = 1, hjust = 1)+theme_minimal()
April 23, 2018 83 / 241

le r´esultat de la fonction graph from data frame()
April 23, 2018 84 / 241

le r´esultat de la fonction ggraph
April 23, 2018 85 / 241

ajoutons une notion d’intensité
Example
#je cree un objet supplémentaire avec une flèche
a <- grid::arrow(type = "closed", length = unit(.10, "inches"))
# je crée un graphe avec le code suivant.
ggraph(bigram_graph,layout = ’kk’) +
geom_edge_link(aes(edge_alpha = n), show.legend = TRUE,
arrow = a, end_cap = circle(.05, ’inches’)) +
geom_node_point(color = "red", size = 1) +
geom_node_text(aes(label = name),color = "blue", size = 3, vjust = 1, hjust = 1)
theme_void()
April 23, 2018 86 / 241

le r´esultat de la fonction ggraph
April 23, 2018 87 / 241

le trigram pour la route
Example
#trigrams n=3
presse_trigram<-presse_ngram%>%
unnest_tokens(trigram, message, token = "ngrams", n = 3)
View(presse_trigram)
presse_trigram%>%
count(trigram,sort=TRUE)
presse_trigram_separated <- presse_trigram%>%
separate(trigram, c("word1", "word2", "word3"), sep = " ")
April 23, 2018 88 / 241

premi`ere phase de nettoyage
Example
trigram_filtered <- presse_trigram_separated %>%
dplyr::filter(!word3 %in% lsa::stopwords_fr)
April 23, 2018 89 / 241

seconde phase de nettoyage: je duplique n fois mes règles
Example
trigram_filtered$word1<-gsub("lâTMasile"," ",trigram_filtered$word1)
trigram_filtered$word1<-gsub("~A","à",trigram_filtered$word1)
trigram_filtered$word1<-gsub("~A¡","á",trigram_filtered$word1)
trigram_filtered$word2<-gsub("~A¡","á",trigram_filtered$word2)
....................................................................................
trigram_filtered$word1<- str_replace_all(trigram_filtered$word1,
"https|//t|http|&|<|>", "")
"https|//t|http|&|<|>", "")
"https|//t|http|&|<|>", "")
April 23, 2018 90 / 241

les manipulations ex-post
Example
presse_trigram_united <- trigram_filtered %>%
unite(trigram, word1, word2, word3,sep = " ")
trigram_tf_idf <- presse_trigram_united %>%
count(from_name,trigram) %>%
bind_tf_idf(trigram, from_name, n) %>%
trigram_tf_idf %>%
select(-sum(n))%>%
plot_trigram<-trigram_tf_idf%>%
mutate(trigram = factor(trigram, levels = rev(unique(trigram))))
ggplot(plot_trigram[1:60,], aes(trigram, tf_idf, fill = from_name)) +
coord_flip()
April 23, 2018 91 / 241

a vos claviers..
April 23, 2018 92 / 241

les manipulations ex-post
Example
plot_trigram<- plot_trigram%>%
top_n(20) %>%
ungroup
ggplot(plot_trigram, aes(trigram, tf_idf, fill = from_name)) +
coord_flip()
April 23, 2018 93 / 241

le top 20 des trigrams par page
April 23, 2018 94 / 241

la repr´esentation en r´eseau
April 23, 2018 95 / 241

S´eance 5: l’analyse de sentiment avec r
April 23, 2018 96 / 241

Les logiques de sentiment analysis
L’analyse de sentiment vise à inférer à partir d’éléments textuels (mots, phrases, document) des
éléments tels que la tonalité ou les sentiments exprimés par l’auteur du texte étudié. Si la
version la plus basique vise à capturer la polarité d’un texte, différentes approches ont été
développés à partir de choix comme :
la technique utilisée: les dictionnaires (approche lexicale), le machine learning (support
machine vector) et la statistique (naive bayes)
la méthode de découpage du texte: le mot, la phrase ou encore le document
la métrique de résultat: polarité, score, mesure adhoc,...
April 23, 2018 97 / 241

Les approches lexicales et d’apprentissage
L’approche lexicale comprend différentes phases
phase d’extraction du texte,
phase de tokenisation et nettoyage,
phase de matching vis à vis d’un référentiel,
phase d’encrément (incrément si matching, pas d’incrément si non matching ex: +1/-1
de plus au cumul, 0 si non matching)
phase de résultat
L’approche machine learning comprend elle aussi différentes phases
phase d’extraction du texte,
phase de prétraitement,
phase d’apprentissage,
phase de classification,
phase de résultat
April 23, 2018 98 / 241

les packages de sentiment analysis dans r
Plusieurs packages de ”sentiment analysis” ont été développés dans r.
r permet d’utiliser quasiment l’ensemble des outils et méthodologies reliées au text mining
(anciens ou récents) y compris le sentiment analysis.
Certains packages de sentiment analysis sont basés sur une approche lexicale et fournissent en
sortie d’analyse une décomposition du texte en terme de polarité (positif ou négatif), de score
(echelle de -5 à +5) ou encore d’émotion (joy, sadness, etc..). Par ailleurs, il est également
possible d’effectuer les analyses mot à mot, au niveau de la phrase (phase de tokenisation) ou
encore au niveau du texte. A noter que certains packages permettent de se créer ses propres
référentiels (ex: je crée un dictionnaire spécifique dans lequel je renseigne la correspondance
entre un mot et son score, son sentiment, etc...
Pour la plupart ces packages sont destinés à exploiter/travailler sur des corpus en anglais. si
certains intègrent des dictionnaires fran¸cais, les dictionnaires utilisés restent peu étoffés.
Enfin, certains packages de text mining comme tidytext ou quantela intégrent des fonctions
permettant d’effectuer des analyses de sentiment analysis (réutilisation de fonctions existantes
dans d’autres package et/ou création de fonctions spécifiques).
April 23, 2018 99 / 241

les packages de sentiment analysis dans r
Plusieurs packages de ”sentiment analysis” ont été développés dans r. Voici une liste non
exhaustive des packages de sentiment analysis:
Tidytext avec la fonction get sentiment (bag of words, approche lexicale avec différents
dictionnaires permettant d’obtenir une polarité, des sentiments ou un score)
Rsentiment (bag of words, approche lexicale, échelle polarité),
SentimentAnalysis (bag of words, approche lexicale, échelle polarité),
sentimentr (bag of words, approche lexicale, sentiment),
proust (bag of words, approche lexicale, sentiment),
meanr, stanset.....
April 23, 2018 100 / 241

l’analyse de sentiment avec tidytext: la méthode ”afinn”’
Le package tidytext intègre une fonction permettant de qualifier le text: la fonction
get sentiment. En ajoutant comme paramètre de la fonction différents dictionnaires lexicaux
(3), il est possible d’obtenir différents résultats pour un même texte. A noter que ces méthodes
n’intègre pas de dictionnaire fran¸cais..
Example
tidytext::get_sentiments("afinn")
ranking des mots entre -5 et +5
# A tibble: 2,476 x 2
word score
<chr> <int>
1 abandon -2
2 abandoned -2
3 abandons -2
4 abducted -2
5 abduction -2
6 abductions -2
7 abhor -3
8 abhorred -3
9 abhorrent -3
10 abhors -3
April 23, 2018 101 / 241

obtenir la polarité des mots: la méthode ”bing”
avec la paramètre ”bing” dans la fonction get sentiment, je classe les mots selon l’opposition
positif/négatif..
Example
tidytext::get_sentiments("bing")
# A tibble: 6,788 x 2
word sentiment
<chr> <chr>
1 2-faced negative
2 2-faces negative
3 a+ positive
4 abnormal negative
5 abolish negative
6 abominable negative
7 abominably negative
8 abominate negative
9 abomination negative
10 abort negative
# ... with 6,778 more rows
April 23, 2018 102 / 241

obtenir une classification par émotion: la méthode ”nrc”
avec la paramètre ”nrc” dans la fonction get sentiment, je classe chaque mot selon l’émotion
dominante que ce mot exprime. La liste des émotions est la suivante: anger, anticipation,
disgust, fear, joy, sadness, surprise, trust. (cf. doc:
http://saifmohammad.com/WebPages/NRC-Emotion-Lexicon.htm).
Example
tidytext::get_sentiments("nrc")
A tibble: 13,901 x 2
# word sentiment
1 abacus trust
2 abandon fear
3 abandon negative
4 abandon sadness
5 abandoned anger
6 abandoned fear
7 abandoned negative
8 abandoned sadness
9 abandonment anger
10 abandonment fear
# ... with 13,891 more rows
April 23, 2018 103 / 241

exemple sur un corpus de post facebook
Example
# Rfacebook+tidytext
base_sentiment_bing<-extract_r_the_economist%>%
inner_join(get_sentiments("bing")) %>%
count(sentiment)%>%
arrange(-n)
# sentiment n
1 negative 2404
2 positive 1940
April 23, 2018 104 / 241

exemple sur un corpus de post facebook
Example
base_emotion<-extract_r_the_economist%>%
inner_join(get_sentiments("nrc"))%>%
group_by(sentiment, word)%>%
count(word, sort = TRUE)
# cr´eation d’un dataframe (fonction table)
tableau<-as.data.frame(table(base_emotion$sentiment))
colnames(tableau)<-c("emotion", "nombre d’occurence")
# emotion nombre
1 anger 349
2 anticipation 331
3 disgust 252
4 fear 424
5 joy 256
6 negative 812
7 positive 816
8 sadness 345 April 23, 2018 105 / 241

code graphique
Example
base_emotion_graphique<-extract_r_the_economist%>%
group_by(sentiment, word)%>%
count(word, sort = TRUE)%>%
filter(n>20)%>%
ggplot(aes(x= reorder(word,(n)),y=n,fill = sentiment))+
geom_bar(stat="identity")+
coord_flip()+theme_minimal()+
labs(x = "mots",
title = "liste des mots apparaissant plus de 20 fois dans le classement")
April 23, 2018 106 / 241

le r´esultat
April 23, 2018 107 / 241

ﬁltre selon l’´emotion: sadness
Example
base_emotion_sadness<-extract_r_the_economist%>%
filter(sentiment == "sadness") %>%
# word n
1 vote 34
2 revolution 32
3 death 25
4 bad 22
5 illegal 22
6 tax 21
7 die 20
8 leave 20
9 poverty 20
10 income 18
April 23, 2018 108 / 241

ﬁltre selon l’´emotion: joy
Example
base_emotion_joy<-extract_r_the_economist%>%
filter(sentiment == "joy") %>%
# word n
1 food 37
2 save 36
3 money 35
4 vote 34
5 found 31
6 pay 25
7 white 23
8 peace 22
9 deal 20
10 electric 20
# ... with 246 more rows April 23, 2018 109 / 241

classer les mots selon une échelle de score: la méthode
afinn
avec la paramètre ”afinn” dans la fonction get sentiment, je classe chaque mot selon une échelle
allant de -5 à +5..
Example
base_score<-extract_r_the_economist%>%
inner_join(get_sentiments("afinn"))%>%
group_by(score, word)%>%
April 23, 2018 110 / 241

code graphique
Example
base_score_graphique<-extract_r_the_economist%>%
anti_join(tidytext::stop_words) %>%
inner_join(get_sentiments("afinn"))%>%
group_by(score, word)%>%
count(word, sort = TRUE)%>%
filter(n>10)%>%
ggplot(aes(x= reorder(word,(n)),y=n,fill = score))+
geom_bar(stat="identity")+
scale_fill_continuous(high = "#132B43", low = "#56B1F7")+
coord_flip()+theme_minimal()+
labs(x = "mots",
title = "occurence et score")
April 23, 2018 111 / 241

le r´esultat
April 23, 2018 112 / 241

une comparaison des trois méthodes: afinn, nrc et bing
Example
il est possible de représenter dans un même graphique les trois méthodes d’analyse d
-en effectuant par ligne la somme des scores de chaque mot pour la méthode afinn
-pas d’opération pour la méthode bing (positive/négatif)
-en sommant les valeurs ’’positives’’ et ’’négatives’’ de la méthode nrc.
#première étape
afinn_economist <-extract_r_the_economist %>%
inner_join(get_sentiments("afinn")) %>%
group_by(type,time, engagement)%>%
summarise(sentiment = sum(score)) %>%
mutate(method = "AFINN")
April 23, 2018 113 / 241

une comparaison des trois méthodes: afinn, nrc et bing
Example
#seconde étape
bing_and_nrc_economist <- bind_rows(extract_r_the_economist%>%
#dplyr::anti_join(tidytext::stop_words)%>%
#dplyr::filter(!word %in% tm::stopwords(’en’))%>%
#dplyr::filter(!word %in% lsa::stopwords_en)%>%
group_by(type, time, engagement)%>%
mutate(method = "Bing et al."),
extract_r_the_economist%>%
#dplyr::anti_join(tidytext::stop_words)%>%
#dplyr::filter(!word %in% tm::stopwords(’en’))%>%
#dplyr::filter(!word %in% lsa::stopwords_en)%>%
group_by(type, time, engagement)%>%
inner_join(get_sentiments("nrc") %>%
filter(sentiment %in% c("positive", "negative"))) %>%
mutate(method = "NRC")) %>%
count(method,type, time,sentiment) %>%
spread(sentiment, n, fill = 0) %>%
mutate(sentiment = positive - negative)
April 23, 2018 114 / 241

le r´esultat
April 23, 2018 115 / 241

l’analyse des mots les plus présents en matière de polarité
Example
bing_word_counts_eco <-extract_r_the_economist%>%
group_by(type)%>%
dplyr::inner_join(get_sentiments("bing")) %>%
count(word, sentiment, sort = TRUE) %>%
dplyr::ungroup()
bing_word_counts_eco %>%
group_by(sentiment) %>%
top_n(40) %>%
ungroup() %>%
mutate(word = reorder(word, n)) %>%
ggplot(aes(word, n, fill = sentiment)) +
scale_color_manual(values = economist_sentiment, name = "", breaks = c("negatif","
geom_col(show.legend = FALSE) + facet_grid(sentiment~., scales = "free_y") +
theme_minimal()+ labs(y = "Contribution to sentiment", x = NULL) + coord_flip()
April 23, 2018 116 / 241

le r´esultat
April 23, 2018 117 / 241

l’analyse des mots les plus présents en matière de polarité
Example
library(wordcloud)
library(reshape2)
count(word, sentiment, sort = TRUE) %>%
reshape2::acast(word ~ sentiment, value.var = "n", fill = 0) %>%
comparison.cloud(colors = c("firebrick4", "chartreuse4"),
max.words = 100)
April 23, 2018 118 / 241

le r´esultat
April 23, 2018 119 / 241

l’analyse des mots les plus présents en matière de polarité:
les bigrams
Example
#rappel de la méthode pour extraire des bigrams
library(dplyr)
library(tidytext)
library(tidyr)
eco_bigrams <- extract_r_the_economist%>%
group_by(type, annee)%>%
unnest_tokens(bigram, message, token = "ngrams", n = 2)
eco_bigrams_separated <- eco_bigrams %>%
separate(bigram, c("word1", "word2"), sep = " ")
April 23, 2018 120 / 241

l’analyse des mots les plus présents en matière de polarité:
les bigrams
Example
#bigrams et sentiment analysis
AFINN <- get_sentiments("afinn")
not_words <- eco_bigrams_separated %>%
filter(word1 == "not") %>% #je filtre
inner_join(AFINN, by = c(word2 = "word")) %>% #jointure avec le dictionnaire
count(word2, score, sort = TRUE) %>%
ungroup()
not_words %>%
mutate(contribution = n * score) %>%
arrange(desc(abs(contribution))) %>%
head(30) %>%
mutate(word2 = reorder(word2, contribution)) %>%
ggplot(aes(word2, n * score, fill = n * score > 0)) +
geom_col(show.legend = FALSE) + theme_minimal()+
labs(x = "mots précédés par "not"",
y = " contribution: sentiment score * nombre d’occurence du mot",
title = "top 30 des mots ayant la plus forte contribution à la polarité par s
coord_flip()
April 23, 2018 121 / 241

le r´esultat
April 23, 2018 122 / 241

les bigrams avec un dictionnaire perso
Example
#bigrams et sentiment analysis
negation_words <- c("not", "no", "never", "without")
eco_negated_words <- eco_bigrams_separated %>%
filter(word1 %in% negation_words) %>%
inner_join(AFINN, by = c(word2 = "word")) %>%
count(word1, word2, score, sort = TRUE) %>%
ungroup()
eco_negated_words%>%
mutate(contribution = n * score) %>%
arrange(desc(abs(contribution))) %>%
#head(50) %>%
mutate(word2 = reorder(word2, contribution)) %>%
ggplot(aes(word2, n * score, fill = n * score > 0)) +
geom_col(show.legend = FALSE) + theme_minimal()+
labs(x = "Words preceded by "not"",
y = " contribution: sentiment score * nombre d’occurrence du mot",
title = "top 50 des mots ayant la plus forte contribution `a la polarit´e par s
coord_flip()
April 23, 2018 123 / 241

le r´esultat
April 23, 2018 124 / 241

une conclusion sur tidytext et le sentiment analysis
Le sentiment analysis est une brique importante dans le package tidytext. En jouant sur les
dictionnaires sémantiques, la longueur des n-grams (simple, bigrams, trigrams), il permet de
générer des résultats très facilement. En outre, si nous avons travaillé avec des dataframes, le
package permet d’effectuer des analyses de sentiment analysis en prenant en entrée des
documents de type document term matrix ou term document matrix (nous verrons ces formes
lorsque nous travaillerons sur le topic modeling).
Bien évidemment, le package souffre de différentes faiblesses: une analyse mots à mots qui ne
capture pas les formes complexes de langage (ex: sarcasme) et la faiblesse des méthodes de
dictionnaires lorsque l’on travaille avec des corpus spécifiques (ex: finance).
April 23, 2018 125 / 241

les autres packages dans r et le sentiment analysis
Comme nous l’avons indiqué en introduction d’autres packages existent sous r en matière de
topic modeling. Non content d’effectuer les mêmes opérations par rapport à tidytext (taggging
avec les méthodes afinn, nrc et bing), ces packages apportent d’autres fonctionnalités
intéressantes en terme: :
référentiels de tagging: d’autres dictionnaires (finance, multi-langues, etc...)
structure du corpus (analyse au niveau des mots, analyse au niveau de la phrase),
résultats graphique (visualisation du texte),
algorithme de classification (stanford nlp),
stanset.....
A noter que certains de ces packages lorsqu’ils appelent des traitements java (stanford nlp)
deviennent gourmands en mémoire. Dans la partie suivant, nous allons passer en revue les
différents packages en nous focalisant sur leurs spécificités.
April 23, 2018 126 / 241

le package sentiment analysis
Ce package est un complément à tidytext et possède de nombreuses fonctions intéressantes :
la prise en charge de différentes structures d’organisation de la données (dataframe,
matrix, corpus)
le chargement de différents dictionnaires ”spécifiques”:
Harvard-IV,
Henry’s Financial
Loughran-McDonald Financial
la création de dictionnaires spécifiques (création, importation, modification, chargement,
exportation),
l’utilisation de fonction de traitement du texte (stemming, stopword, tokenisation
comptage),
structure du corpus (analyse au niveau des mots, analyse au niveau de la phrase,
comptage),
des éléments graphiques,
la modélisation (lasso et ridge)
April 23, 2018 127 / 241

la fonction analyse sentiment
Example
#écriture de base
sa_eco<-analyzeSentiment(extract_r_the_economist$message,
language = "english",
aggregate = NULL,
removeStopwords = FALSE,
stemming = FALSE)
attention par défaut la fonction effectue le stemming, supprimme les mots communs
a noter que certains paramètres ne sont possibles qu’avec une matrice en entree.
April 23, 2018 128 / 241

le resultat
April 23, 2018 129 / 241

la fonction analyse sentiment
Example
sa_eco<-analyzeSentiment(extract_r_the_economist$message, language = "english",
aggregate = NULL, removeStopwords = FALSE,
stemming = FALSE)
sa_extract<-extract_r_the_economist
sa_extract<-cbind(sa_extract, sa_eco) #recr´ee ma base
sa_extract<-sa_extract%>%
filter(annee!= 2012) #pb extract
ggplot(sa_extract, aes(time)) +
geom_line(aes(y = sa_extract$SentimentGI,colour = "var0"))+
#geom_line(aes(y = sa_extract$SentimentHE,colour = "var1"))+
#geom_line(aes(y = sa_extract$SentimentLM,colour = "var2"))+
#geom_line(aes(y = sa_extract$SentimentQDAP,colour = "var3"))+
theme_minimal()+
labs(x = "date",
y = "score",
title = "calcul du sentiment total",
subtitle = "m´ethode sentiment GI") # a adapter
April 23, 2018 130 / 241

le dictionnaire GI
April 23, 2018 131 / 241

le dictionnaire HE
April 23, 2018 132 / 241

le dictionnaire LM
April 23, 2018 133 / 241

le dictionnaire QDAP
April 23, 2018 134 / 241

la repr´esentation en histogramme
Example
hist(sa_extract$SentimentGI)
hist(sa_extract$SentimentHE)
hist(sa_extract$SentimentLM)
hist(sa_extract$SentimentQDAP)
April 23, 2018 135 / 241

une comparaison des m´ethodes
April 23, 2018 136 / 241

le package syuzhet
Les principales fonctions de ce package sont les suivantes:
l’intégration de différents dictionnaires (get nrc sentiment) ou
(get sentiment dictionary())
le sentiment par phrase (get sentences)
la mise en compte de différents languages, (get sentiment dictionary())
le tagging avec le framework nlp stanford (get stanford sentiment())
la tokenisation par mot (tiydext like) (get tokens)
des représentations graphiques (simple plot )
April 23, 2018 137 / 241

la visualisation des dictionnaires
après avoir chargé la librairie (library(syuzhet)), il est possible d’afficher les dictionnaires
suivants:
syuzhet::get sentiment dictionary(dictionary = ”syuzhet”, language = ”french”)
syuzhet::get sentiment dictionary(dictionary = ”nrc”, language = ”french”)
syuzhet::get sentiment dictionary(dictionary = ”afinn”, language = ”french”)
syuzhet::get sentiment dictionary(dictionary = ”bing”, language = ”french”)
syuzhet::get sentiment dictionary(dictionary = ”syuzhet”, language = ”english”)
syuzhet::get sentiment dictionary(dictionary = ”nrc”, language = ”english”)
syuzhet::get sentiment dictionary(dictionary = ”afinn”, language = ”english”)
syuzhet::get sentiment dictionary(dictionary = ”bing”, language = ”english”)
syuzhet::get sentiment dictionary(dictionary = ”nrc”, language = ”spanish”)
syuzhet::get sentiment dictionary(dictionary = ”afinn”, language = ”spanish”)
syuzhet::get sentiment dictionary(dictionary = ”bing”, language = ”spanish”)
........
April 23, 2018 138 / 241

la visualisation des dictionnaires
Example
appeler les dictionnaires pour effectuer le tagging des mots:
method <- "nrc"
lang <- "english"
my_text_values <- get_sentiment(mon_texte, method=method, language=lang)
April 23, 2018 139 / 241

la cr´eation d’un graphique comparatif
Example
#longueur du message ==>graphique
extract_r_the_economist$length<-str_length(extract_r_the_economist$message)
#fonction syuzhet
syuzhet_result_eco<-syuzhet::get_sentiment(extract_r_the_economist$message,
method = "syuzhet", path_to_tagger = NULL,
cl = NULL, language = "english",
lexicon = NULL)
# cr´eation du dataframe +jointure
syuzhet_result_eco<-as.data.frame(syuzhet_result_eco)
extract_r_the_economist<-cbind(extract_r_the_economist,syuzhet_result_eco)
April 23, 2018 140 / 241

la cr´eation d’un graphique comparatif
Example
mutate(annee<-lubridate::year(time))%>%
filter(annee != 2012)%>%
group_by(type, time, length)%>%
summarise(sum = sum(syuzhet_result_eco, na.rm = TRUE))%>%
ggplot(aes(x=time, y=sum,size=length,color=type))+
scale_size_area(max_size = 4, guide = FALSE) +
geom_point(alpha=0.8)+theme_minimal()+
theme(axis.text.x = element_text(size=10, angle=90))+
theme(legend.position="bottom")+
theme(legend.text=element_text(size=5))+
theme(legend.title=element_text(size=5))+geom_jitter()+ facet_grid(type~.)+
theme(strip.text.x = element_text(face="bold",size =10,
colour = "black", angle = 90))+
labs(x = "date",
y = "score",
title = "sentiment par tweet et type",
subtitle = "")
April 23, 2018 141 / 241

la m´ethode aﬁnn
April 23, 2018 142 / 241

la m´ethode syuzhet
April 23, 2018 143 / 241

obtenir un histogramme des sentiments
Example
nrc_data_eco<- get_nrc_sentiment(extract_r_the_economist$message)
barplot(sort(colSums(prop.table(nrc_data_eco[, 1:8]))),
horiz = TRUE,
cex.names = 0.7,
las = 1,
main = "r´epartition des ´emotions dans mon extract twitter", xlab="pourcentage")
April 23, 2018 144 / 241

repr´esentation graphique
April 23, 2018 145 / 241

obtenir un graphique rapidement avec la fonction
get sentiment
Example
bis<-get_sentiment(extract_r_the_economist$message)
plot(bis, type = "o", pch = 20, bg = par("bg"), col = "grey", cex = .4,
main = ’sentiment dans le temps’)
April 23, 2018 146 / 241

April 23, 2018 147 / 241

obtenir diﬀ´erentes tendances: la fonction simple plot
Example
bis<-get_sentiment(extract_r_the_economist$message)
simple_plot(bis)
April 23, 2018 148 / 241

April 23, 2018 149 / 241

les autres packages
D’autres packages de sentiment analysis.:
sentimentr (get sentences()) calcul par phrases
stanset (get sentences()) calcul score nlp
R sentiment (calculate score())
meanr (score())
proustr (travail sur les oeuvres de proust)
April 23, 2018 150 / 241

le programme
Pour le reste du cours:
faire un extract et tester `a mimima les trois dictionnaires
faire les graphiques corpus anglais
tester un autre package r avec le mˆeme corpus
faire un travail sur le bigrams
travailler sur un corpus fran¸cais
April 23, 2018 151 / 241

S´eance 6: syntactic parsing
April 23, 2018 152 / 241

L’approche ’bag of word”
Très très globalement, on peut distinguer deux approches en terme de text mining:
les approches de type ”bag of word”
les approches de type ”syntactic parsing”
L’approche bag of word approche un texte comme une suite non organisée de mots. Typiquement, le package tidytext qui
permet de découper un text en ngrams et poser les premières briques du topic modeling adopte cette approche.
Figure: l’approche bag of word, tiré de Speech and Language Processing. Jurafsky et Martin (2017)
April 23, 2018 153 / 241

L’approche ”syntactic parsing”
L’approche ”syntactic parsing” appréhende un document comme un vecteur de V dimensions où V est la taille du vocabulaire
utilisé.
Figure: l’approche ”syntactic parsing”, Kwartler (2017)
April 23, 2018 154 / 241

L’approche ”syntactic parsing” en pratique
L’approche ”syntactic parsing” va découper le corpus en attribuant à chaque token un élément
(part of speech) selon un glossaire plus ou moins standardisé. La liste ci-dessus donne une idée
des résultats possibles de cette opération de tagging:
ADJ, adjective, ex: new, good, high, special, big, local
ADP, adposition, ex: on, of, at, with, by, into, under
ADV, adverb, ex:really, already, still, early, now
CONJ, conjunction, ex: and, or, but, if, while, although
DET, determiner, article, ex :the, a, some, most, every, no, which
NOUN, noun, ex: year, home, costs, time, Africa
NUM, numeral,ex: twenty-four, fourth, 1991, 14:24
PRT, particle, ex: at, on, out, over per, that, up, with
PRON, pronoun,ex: he, their, her, its, my, I, us
VERB, verb, ex: is, say, told, given, playing, would
. ,punctuation marks,ex: . , ; !
X, other rsatz, esprit, dunno, gr8, univeristy
Une fois cette annotation réalisée, il devient possible s’effectuer des nombreuses analyses en
combinant le résultat du pos-tagging avec d’autres fonctionnalités comme la lemmatisation ou le
”dependency parsing”
April 23, 2018 155 / 241

un premier exemple avec udpipe
Example
Après avoir annoté ce texte: mon texte¡-c(”this is my text”) sur le
principe du syntactic parsing nous obtenons le résultat suivant (tagging
réalisé avec le package udpipe). En plus du pos-tagging nous obtenons
également la lemmatisation pour chaque token (c’=¿ce, est=¿être)
April 23, 2018 156 / 241

un second exemple avec udpipe
Example
Si l’on veux annoter ce texte: my text¡-c(”c’est mon texte”) en utilisant le
principe du syntactic parsing nous obtenons ce résultat suivant (package
udpipe). A noter qu’il faut charger pour chaque langue un dictionnaire
spécifique pour obtenir l’output.
April 23, 2018 157 / 241

Le ”syntactic parsing” et r
Différents packages existent dans r autour de l’approche ”syntactic parsing” comme openNLP,
cleanNLP ou Udpipe. Contrairement à l’approche bag of word, l’approche ”syntactic parsing”
nécessite au préalable d’avoir installé un ou plusieurs backends. Un backend s’apparente à une
”sous couche logicielle” nécessaire pour générer les opérations comme par exemple:
le package openNLP nécessite d’avoir installé la librairie stanford NLP+l’environnement
java,
le package udpipe permet d’annotation et ne nécessite pas l’installation d’un backend
spécifique (il faut seulement télécharger les différents dictionnaires)
le package spacyr qui est une interface dans r pour accéder aux fonctionnalités de la
librairie python spacy (nécessite d’installer un environnement python, la librairie spacy et
ses librairies),
le package cleanNLP permet d’appeler différents backends (stanford npl+java,
spacy+python, udpipe et tokenizers-ce dernier permet juste de tokenizerle texte)
Compte tenu de sa consommation en mémoire extrêmement importante, nous utiliserons dans
cette partie du cours les backends spacy/python et udpipe.
April 23, 2018 158 / 241

Installer le package udpipe
Example
# phase d’installation du package et des dictionnaires
installation du package+dictionnaires (extrêmement long....)
devtools::install_github("jwijffels/udpipe.models.ud.2.0")
installation du packaage avec une autre url (+rapide)
install.packages("udpipe.models.ud.2.0",
repos = "http://www.datatailor.be/rcube",
type = "source")
#une fois installée, il faut charger dans r le package
et des librairies utilisées dans le tuto
# librairie du package
library(udpipe)
# librairie pour manipuler les tables
library(data.table)
#la libraririe pour la creation des graphiques/barchart (alternative à ggplot)
library("lattice", lib.loc="C:/Program Files/R/R-3.4.2/library")
April 23, 2018 159 / 241

tagger un texte: la fonction udpipe annotate du package
udpipe
Example
# mon texte
texte_1<-c("this is my text")
# je charge mon dictionnaire
ud_en<- udpipe_load_model(file =
"C:/Users/jjg/Documents/R/win-library/3.4/udpipe.models.ud.2.0/udpipe-ud-2.0-170801/
# j’annote mon texte avec la fonction udpipe_annotate
# (mon _dictionnaire, mon texte)
my_texte_1_anno<- udpipe_annotate(ud_en, x = texte_1)
# je transforme le r´esultat de ma fonction en un dataframe
my_texte_1_anno<-as.data.frame(my_text_1_anno)
April 23, 2018 160 / 241

visualiser cette premi`ere op´eration
Example
View (my texte 1 anno)
April 23, 2018 161 / 241

tagger un texte: la fonction udpipe annotate du package
udpipe
Example
# mon texte de départ
texte_2<-c("c’est mon texte")
# je charge mon dictionnaire
ud _fr <- udpipe_load_model(file =
"C:/Users/jjg/Documents/R/win-library/3.4/udpipe.models.ud.2.0/udpipe-ud-2.0-170801/
# j’annote mon texte avec la fonction udpipe_annotate (résultat est une liste)
my_texte_2_anno<- udpipe_annotate(object = ud_fr, x =texte_2)
# je transforme le résultat de ma fonction en un dataframe
my_texte_2_anno<-as.data.frame(my_texte_2_anno)
April 23, 2018 162 / 241

aﬃcher cette seconde op´eration
Example
April 23, 2018 163 / 241

tagger des commentaires: l’exemple des commentaires
airBnb
Example
# appeler le dataset
data(brussels_reviews)
==>les données sont des données
d’entrainement présentes dans le package udpipe
# je visualise les données
(la langue est déjà identifiée pour chaque commentaire
==>je peux appliquer le dictionnaire adéquat
head(brussels_reviews)
# je visualise la répartition des commentaires par langue
table(brussels_reviews$language)
es fr nl
500 500 500
April 23, 2018 164 / 241

aﬃcher cette seconde op´eration
April 23, 2018 165 / 241

tagger l’ensemble des commentaires
Example
# je découpe mon dataframe en trois listes sur le critère de la langue
bxl_anno <- split(brussels_reviews, brussels_reviews$language)
==>j’obtiens une nested list (une liste avec trois listes à l’intérieur)
# tagging es (tagger les commentaires en espagnol=>dico es)
ud_sp <- udpipe::udpipe_load_model(file=
"C:/Users/jjg/Documents/R/win-library/3.4/udpipe.models.ud.2.0/
udpipe-ud-2.0-170801/spanish-ancora-ud-2.0-170801.udpipe")
bxl_anno$es <- udpipe_annotate(object = ud_sp, x = bxl_anno$es$feedback,
doc_id = bxl_anno$es$id)
# tagging fr
ud_fr <- udpipe_load_model(file =
udpipe-ud-2.0-170801/french-partut-ud-2.0-170801.udpipe")
bxl_anno$fr <- udpipe_annotate(object = ud_fr, x = bxl_anno$fr$feedback,
doc_id = bxl_anno$fr$id)
# tagging nl
ud_nl <- udpipe_load_model(file =
udpipe-ud-2.0-170801/dutch-lassysmall-ud-2.0-170801.udpipe") April 23, 2018 166 / 241

consolider mes donnés
Example
# je transforme chacune des listes annotées en un dataframe ==>liste de dataframes
brussels_reviews_anno <- lapply(bxl_anno, as.data.frame)
#je cree un dataframe unique à partir de ma liste de dataframes ==>dataframe unique
brussels_reviews_anno <- data.table::rbindlist(brussels_reviews_anno)
#la commande pour visualiser la structure de mon dataframe global
str(brussels_reviews_anno)
April 23, 2018 167 / 241

le r´esultat obtenu
April 23, 2018 168 / 241

ajuster ma requête
Les opérations telles que le ”pos-tagging”, le ”dependancy parsing”et la ”lemmatization”
peuvent être relativement longues lorsque l’on dispose d’un corpus important. La fonction
annotate comprend différents paramètres qui permettent d’ajuster les opérations en fonction de
ses besoins:
seulement token: x ¡- udpipe annotate(ud fr, x = txt, tagger = ”none”, parser = ”none”)
token+pos tagging+lemmatisation (pas de dependancy parsing): x ¡-
udpipe annotate(ud dutch, x = txt, tagger = ”default”, parser = ”none”)
token+ dependancy parsing: x ¡- udpipe annotate(ud dutch, x = txt, tagger = ”none”,
parser = ”default”)
April 23, 2018 169 / 241

afficher la structure d’un corpus d’après le pos tagging
Example
# fonction du package qui permet de calculer les fréquences par colonne particulièr
stats <- txt_freq(brussels_reviews_anno$upos)
#je transforme mes fréquences en facteur
stats$key <- factor(stats$key, levels = rev(stats$key))
#la je trace mon graphique (librairie lattice)
barchart(key ~ freq, data = stats, col = "cadetblue",
main = "UPOS (Universal Parts of Speech) frequency of occurrence",
xlab = "Freq")
April 23, 2018 170 / 241

mes donn´ees
April 23, 2018 171 / 241

Example
# je filtre mon dataset avec le tag que je souhaite garder
stats <- subset(brussels_reviews_anno, upos %in% c("NOUN"))
# fonction du package qui permet de calculer les fr´equences
stats <- txt_freq(stats$token)
#la je trace mon graphique
barchart(key ~ freq, data = head(stats, 20), col = "cadetblue",
main = "Most occurring nouns", xlab = "Freq")
April 23, 2018 172 / 241

mes donn´ees
April 23, 2018 173 / 241

Example
stats <- subset(brussels_reviews_anno, upos %in% c("ADJ"))
# l’appelle la fonction du package qui permet de calculer les fr´equences
# ordonner le vecteur
statskey <- factor(stats$key, levels = rev(stats$key))
main = "Most occurring adjectives", xlab = "Freq")
April 23, 2018 174 / 241

mes donn´ees
April 23, 2018 175 / 241

Example
stats <- subset(brussels_reviews_anno, upos %in% c("ADV"))
main = "Most occurring adverbs", xlab = "Freq")
April 23, 2018 176 / 241

mes donn´ees
April 23, 2018 177 / 241

Example
stats <- subset(brussels_reviews_anno, upos %in% c("VERB"))
# fonction du package qui permet de calculer les fr´equences par colonne particuli`er
# ordonner le vecteur
main = "Most occurring verbs", xlab = "Freq")
April 23, 2018 178 / 241

mon r´esultat
April 23, 2018 179 / 241

Example
stats <- subset(brussels_reviews_anno, upos %in% c("NUM"))
main = "Most occurring num", xlab = "Freq")
April 23, 2018 180 / 241

mes donn´ees
April 23, 2018 181 / 241

les cooccurrences
Le package permet de calculer trois types de cooccurrence:
la cooccurrence entre les termes au niveau d’un même paragraphe ou texte,
la cooccurrence entre des termes consécutifs,
la cooccurrence entre deux termes séparés à n skipgrams (à n mots près),
L’output d’un calcul de cooccurrence est un dataframe qui contient:
une colonne avec le terme 1,
une colonne avec le terme 2,
la cooccurrence soit le nombre de fois où les deux mots apparaissent ensemble.
April 23, 2018 182 / 241

calculer la cooccurrence
Example
# je filtre mon dataset (fonction subset)
la liste des tags:
https://www.clips.uantwerpen.be/pages/mbsp-tags
data(brussels_reviews_anno)
co_fr <- subset(brussels_reviews_anno,
xpos %in% c("NN", "JJ") & language %in% "fr")
==>ici je veux les noms et les adjectifs en fran¸cais
# j’applique la fonction qui permet de calculer les cooccurrences
co_fr <- cooccurrence(co_fr, group = "doc_id", term = "lemma")
# je visualise le d´ebut de mon dataframe
head(co_fr)
#je transforme mes donn´ees
co_fr<-as.data.frame(co_fr)
co_fr$x<-paste(co_fr$term1, co_fr$term2)
April 23, 2018 183 / 241

mes donn´ees
April 23, 2018 184 / 241

un peu de ggplot dans tout cela....
Example
library(ggplot2)
library(dplyr)
co_fr%>%
dplyr::mutate(x=reorder(x,cooc))%>%
dplyr::filter(cooc>50)%>%
ggplot2::ggplot(aes(x=x,y=cooc, color=cooc))+
geom_point(stat="identity")+theme_minimal()+
scale_color_distiller(palette = "Spectral")+
coord_flip() +
theme(legend.justification=c(1,0), legend.position=c(1,0))+
abs(x = "mots",
y = "nombre de cooccurence",
title = "coocurrence de terme")
April 23, 2018 185 / 241

mes donn´ees
April 23, 2018 186 / 241

calculer la cooccurrence
Example
data(brussels_reviews_anno)
# je filtre mon dataset ==>les éléments+langue
la liste des tags:
https://www.clips.uantwerpen.be/pages/mbsp-tags
co_es <- subset(brussels_reviews_anno,
xpos %in% c("NN", "JJ") & language %in% "es")
# j’applique la fonction qui permet de calculer les cooccurrences
co_es <- cooccurrence(co_es, group = "doc_id", term = "lemma")
# je visualise le début de mon dataframe
head(co_es)
#je transforme mes donnée
co_es<-as.data.frame(co_es)
co_es$x<-paste(co_es$term1, co_es$term2)
April 23, 2018 187 / 241

un r´esultat graphique
Example
library(ggplot2)
library(dplyr)
co_es%>%
dplyr::mutate(x=reorder(x,cooc))%>%
dplyr::filter(cooc>50)%>%
ggplot2::ggplot(aes(x=x,y=cooc, color=cooc))+
geom_point(stat="identity")+theme_minimal()+
scale_color_distiller(palette = "Spectral")+
coord_flip() +
theme(legend.justification=c(1,0), legend.position=c(1,0))+
labs(x = "mots",
y = "nombre de cooccurence",
title = "coocurrence de terme")
April 23, 2018 188 / 241

mes donn´ees
April 23, 2018 189 / 241

d’autres fonctions intéressantes du package: le topic
modeling
Example
# je crée mon set de données
x <- subset(brussels_reviews_anno, language == "fr")
x <- subset(x, xpos %in% c("JJ"))
x <- x[, c("doc_id", "lemma")]
#je crée une matrice puis je filtre pour réduire la taille de la matrice
x <- document_term_frequencies(x)
dtm <- document_term_matrix(x)
dtm <- dtm_remove_lowfreq(dtm, minfreq = 10)
dtm <- dtm_remove_tfidf(dtm, top = 100)
# j’applique la fonction de topic modeling LDA (paramètres: nombre de topic
et méthode ( VEM algorithm ou Gibbs Sampling))
#je charge la librairie topic models
library(topicmodels)
mymodel <- LDA(x = dtm, k = 3, method = "VEM")
April 23, 2018 190 / 241

le topic modeling: la modélisation
Example
# j’extrais des données reliées à modélisation
terminology <- predict(mymodel, type = "terms",
min_posterior = -1, min_terms = 0)
#min_posterior ==>filtre minimum probabilité
ex-post ==>l’ensemble des termes -1
#min_terms ==>max de termes à faire appara^ıtre
ici ==>max =0
April 23, 2018 191 / 241

r´esultat: 1 dataframe par topic
April 23, 2018 192 / 241

le topic modeling: afficher l’attribution de chaque
document topic
Example
# j’extrais des données reliées à modélisation
terminology_2 <- predict(mymodel, dtm, type = c("topics", "terms"),
min_posterior = -1, min_terms = 0)
terminology_2
#min_posterior ==>filtre minimum probabilité ex-post
==>l’ensemble des termes -1
#min_terms ==>max de termes à faire appara^ıtre
==>max =0
April 23, 2018 193 / 241

mon r´esultat
April 23, 2018 194 / 241

le topic modeling: la m´ethode ”gibbs”
Example
# autre m´ethode de calcul sample ’’Gibbs’’
mymodel_bis <- LDA(x = dtm, k = 4, method = "Gibbs")
terminology <- predict(mymodel_bis, type = "terms",
min_posterior = 0.05, min_terms = 3)
scores <- predict(mymodel_bis, type = "topics", newdata = dtm)
head(scores)
April 23, 2018 195 / 241

r´esultat: 1 dataframe par topic
April 23, 2018 196 / 241

conclusion sur udpipe
lorsque l’on souhaite effectuer des opérations telles que le ”pos-tagging”, le ”dependy parsing”et
la ”lemmatization” dans l’environnement r, le package udpipe est aujourd’hui la solution la plus
simple. En effet, ce package ne nécessite pas l’installation de backends, opération qui peut être
délicate (cf. java). Dans ce cours, nous nous sommes concentrés sur la fonction
udpipe annotate. Or, le package dispose d’autres fonctionnalités intéressantes comme:
la possibilité de créer de matrice de termes
la possibilité d’effectuer des transformations sur les matrices (sparse terms, specific terms,
etc...)
d’effectuer du topic modeling
de transformer le texte
d’évaluer les résultats,
de créer, modifier, exporter, importer ses propres dictionnaires,
....
April 23, 2018 197 / 241

le package cleanNLP
le package permet de gérer différents backends pour procéder au tagging. La documentation du
package est claire sur les spécificités des différents backends (installation, manipulation et
performance):
tokenizers: a fast parser that only requires the stringi package, but produces only
tokenized text
udpipe: a parser with no external dependencies that produces tokens, lemmas, part of
speech tags, and dependency relationships. (the recommended starting point given its
balance between ease of use and functionality. It also supports the widest range of natural
languages).
spacy: based on the Python library, a more feature complete parser that included named
entity recognition and word embeddings. (it does require a working Python installation
and some other set-up. Recommended for users who are familiar with Python or plan to
make heavy use of the package)
corenlp: based on the Java library with the same name. Supports coreferences and other
bleeding-edge annotation tasks. (not recommended for most users given its slow speed
and difficult set-up)
April 23, 2018 198 / 241

Initialiser le package
Example
après avoir télécharger le package cleanNLP, il
le charger dans rstudio ainsi que les autres packages
# Initialiser le package cleanNLP
library(cleanNLP) #package cleanNLP
library(reticulate) #interface avec python
library(dplyr) #manipulation des données
library(magrittr) #fonctions pipe
library(ggplot2) #représentation graphique
April 23, 2018 199 / 241

extraire, représenter et traiter la social data avec r. seconde partie: applicaiton au text mining

extraire, représenter et traiter la social data avec r. seconde partie: applicaiton au text mining

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to extraire, représenter et traiter la social data avec r. seconde partie: applicaiton au text mining

Similar to extraire, représenter et traiter la social data avec r. seconde partie: applicaiton au text mining (20)

extraire, représenter et traiter la social data avec r. seconde partie: applicaiton au text mining