extraire, transformer et représenter des données dans r

Extraire, transformer et
représenter la social data avec R
Première partie
jean jacques gauguier Séance 1 janvier 2018 1 / 216

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.

plan (du cours
le contenu du cours est le suivant:
PREMIERE PARTIE
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
SECONDE PARTIE
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

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/

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

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.

s´eance 1: social data et introduction `a R
jean jacques gauguier
janvier 2018

la social data

du big data à la social data
Le big data, une variété des données grandissante:
des données structurées (catégorielles car l’ensemble des valeurs
possibles est connue à l’avance) qui peuvent facilement être intégrées
dans des bases de données relationnelles
des données semi-structurées (format json, xml) qui proviennent
des api (google api, twitter api, etc. . . )
des données non-structurées (texte, images, vidéos) qui sont
impossibles à catégoriser à priori et qui nécessitent un traitement
spécifique (ex traitement des images)

big data landscape
Figure: big data landscape 2017, http://mattturck.com/bigdata2017/

du big data à la social data
Le big data, une production de données qui s’accélère:
Selon IBM, chaque jour nous générons 2,5 trillions d’octets de
données
90% des données dans le monde ont été créées au cours des deux
dernières années seulement
Ces données proviennent par exemple:
des différents capteurs utilisés pour collecter les informations
(automobile et habitat)
des enregistrements transactionnels d’achats en ligne
des signaux GPS des téléphones mobiles
les traces laissées sur les réseaux sociaux = social data

la social data
la social data peut être définie comme étant toutes les formes de données
capturant la manière dont les individus interagissent sur les réseaux sociaux.
Figure: Data Never Sleeps 5.0, https://www.domo.com/learn/data-never-sleeps-5

les principales caractéristiques de la social data
une donnée protéiforme
La social data peut être une donnée chiffrée (likes, shares), du text
(commentaires), des émojis, des photos ou encore des vidéos
une donnée ”difficile” à traiter
La social data est une matière première à manipuler avec précaution:
des métriques rarement harmonisées entre les plate formes
des données textuelles nécessitant de lourdes phases de prétraitement
(la pauvreté dans l’abondance)

la création, l’extraction et le traitement de la social data
social data
création extraction analyse
texte, photo,
vidéo
réactions
autres types de
données
plateforme so-
cial media
listening
méthode ad
hoc
brokers
sélection
pré-traitement
analyse
insight

l’analyse de la social data (adapté de wikipédia)
A partir de données collectées au sein des réseaux sociaux, globalement
l’analyse de la social data cherche à comprendre la manière dont des
interactions entre les individus s’effectuent, la manière dont l’information
cirucule au sein des réseaux sociaux. Des analyses spécifiques peuvent
porter sur:
la mesure de la performance des éléments publiés
la compréhension des mécanismes de viralité
l’identification des influenceurs
l’identification de sujet (ex: suivi de crise social média
...
En résumé, l’analyse de la social data vise à identifier certaines
caractéristiques ”cachées” dans la social data.

une diversité croissante de la social data
Toujours plus de données à capturer potentiellement
Figure:
http://www.slate.fr/story/114629/facebook-nouveaux-boutons-reaction-data

des données en libre accès...dans un environnement
mouvant
Les contours des données récoltables évoluent constamment du fait des ajouts et des
retraits des données. Avec l’utilisation crissante du média au sein des réseau sociaux et
le soucis de monétiser les données, les plateformes sont de plus en plus tentées de
réduire l’offre de données en libre accès.
l’api des données propriétaires
les consoles insight l’api en libre accès

l’intérêt de collecter des données libres d’accès
A partir de ces données, il est possible :
d’effectuer des veilles sur un sujet (ex: suivre une crise sur twitter),
de mesurer l’activité des différents comptes (ex: suivre une campagne sur fb),
d’effectuer des analyses textuelles (titre des posts, titre des tweets, analyse des
commentaires ,...).
données publiques
récolter
des méta-données
récolter
des données d’activité
suivre un
sujet sur twitter

les méta-données et les données d’activité
Parmi les données libres d’accès, il est possible de distinguer entre:
les méta-données: le nombre de likes d’une page FB, le nombre de followers d’un
compte twitter, le nombre d’abonnés et de vues depuis la création d’une chaˆıne YT
les données d’activité:
des données de publications d’une page FB, d’un compte twitter et le
nombre de vidéo hébergées sur une chaˆıne YT.
des données engagement: likes, comments, shares et facebook
reactions sur FB, retweets sur twitter et likes sur YT
id d’un compte
méta-données
facebook,
twitter,
youtube
données d’activités
facebook,
twitter,
youtube

un autre intérêt des données libre d’accès: suivre l’intérêt
d’un sujet sur twitter
Twitter permet d’obtenir des données en libre accès via deux api distinctes:
api rest: permet de remonter sur les 8 derniers jours les tweets mentionnant un
hashtag ou plus généralement un terme particulier
api streaming twitter: permet de capturer en temps réel une partie des
conversations sur twitter mentionnant un hashtag ou un terme particulier
# hastags
api rest twitter api streaming twitter

les modalités d’extraction de la social data
social data
les consoles insight l’api propriétaire l’api publique
scripts ad hoc
extracteurs
scripts ad hoc
extracteurs
Différentes solutions existent donc pour capturer de ”la social data” en libre accès.

les outils d’extraction de la social data via les api
api social
data
les extracteurs les etl la programmation
next analytics
datagrabber
...
talend
dataiku dss
...
python
r
...
Les d´eveloppeurs s’appuient sur la documentation et l’existant (librairies, scripts
d’extraction et packages cr´ees,...)

pourquoi privilégier r pour travailler avec la social data?
Pourquoi r?
avec Python r est le langage le plus utilisé en ”datascience”
il existe un environnement de développement appelé RStudio qui
permet de travailler facilement dans l’environnement R
il existe une documentation abondante sur r (livres en ligne, blogs,
stackoverflow, etc...)
de nombreux packages r permettant d’importer, transformer analyser
et modéliser les données sont continuellement développés et mis à jour
des packages r permettant d’extraire facilement des données via les
api publiques existent

les principaux packages d’extraction de la social data dans r
plateforme social média et
package(s) associés
1 Facebook → Rfacebook
2 Twitter → streamR,
twitteR, rtweets
3 (Youtube → tuber)
4 (Instagram → instaR)
5 (Google Trends → Gtrends)
6 ....
Pour les plateformes social média
les plus utilisées, un ou plusieurs
packages r existent. Ces packages
s’apparentent à des interfaces
permettant d’utiliser les api des
plateformes sans en écrire les
requêtes. Bien souvent il s’agira
d’appeler une fonction du package
afin de récupérer des données
particulières. A noter qu’il existe
un métapackage appelé Social
Media Lab.

extraire la social data avec des packages r

configurer l’environnement de travail
installer
r studio
et r
installer
package
créer les
appli-
cations
installer rstudio:
https://www.rstudio.com/products/rstudio/download/
installer package (cf. console Rstudio ou github du package)
créer les applications pour les plateformes:
facebook: https://developers.facebook.com/docs/apps/register
twitter: https://apps.twitter.com/
youtube: https://developers.google.com/
Pour instagram si un package existe (instaR) les changements des conditions
d’utilisation de l’api limitent aujourd’hui l’intérêt d’utiliser ce package.

installer r studio
pr´e-requis: installer r: https://cran.rstudio.com/
avant d’installer r studio desktop `a l’adresse suivante:
https://www.rstudio.com/products/rstudio/download/#download
Figure: https://www.rstudio.com/products/rstudio/download/#download

installer les packages r (via rstudio)
A partir de rstudio installer les packages via Rstudio: ggplot2, dplyr, jsonlite, lda, lsa,
openNLP, plyr, purr, quanteda, RCurl, readr, readxl, lubridate,Rfacebook, rJava,
rlang, rvest, stringi, stringr, tensorﬂow, tibble, tidytext, tidyselect, tidyverse, tm,
tokenizers, topicmodels, twitteR, vkR, streamR et rtweets.
Figure: online learning: https://www.rstudio.com/online-learning/#R

créer des applications
Pour accéder aux données, il est nécessaire d’être authentifier souvent via un protocole
d’accès Oauth 2.0. Ce protocole a de nombreuses variantes mais globalement le schéma
est identique: une application permet à l’utilisateur d’obtenir des jetons
d’authentification (tokens) pour s’identifier et accéder aux ressources.

utilisation des identifiants
Google, Facebook et Twitter ont mis en place des méthodes simples de création
d’application. La création de l’application génère des identifiants que nous utiliserons
dans r pour accéder aux ressources des apis. Récemment des plateformes comme
instagram ont mis en place des process de review avant d’autoriser une application.
je crée
une ap-
plication
par plate-
forme
j’obtiens
des iden-
tifiants
je
m’identifie
via les
packages
r pour
accéder
aux
ressources

créer une application facebook
https://developers.facebook.com/docs/apps/register
Pré-requis: avoir un compte FB et êre connecté à FB

visualiser ses identifiants de l’app facebook
Une fois l’application crée, l’application génère deux éléments:
APP ID
APP Secret
Ce sont de ces identifiants qui nous permettrons de nous connecter à l’api facebook via
le package Rfacebook.
Figure: https://developers.facebook.com/apps/xxxxxxxxxxxxxxxx/dashboard/

créer une application twitter: https://apps.twitter.com
Pré-requis: avoir un compte twitter, être connecté à twitter et...fournir son numéro de
mobile

visualiser ses identifiants de l’app twitter
Une fois l’application crée, l’application génère quatre éléments:
Consumer Key (API Key)
Consumer Secret (API Secret)
Access Token
Acess Token Secret
Ce sont de ces identifiants qui nous permettrons de nous connecter à l’api twitter via les
packages twitteR et streamR.

présentation et utilisation du package Rfacebook
A chaque information correspond une requête particulière qu’il faut parfois optimiser
avec différents paramètres.
R facebook
my graph fb graph fb
mes publica-
tions
mes amis
publications
d’une page
informations
sur un post
commentaires
d’un post
replies dans un
post

initialisation de Rfacebook
Example (Code)
library(Rfacebook)
fb_oauth <- fbOAuth(app_id="xxxxxxxxxxxx",
app_secret="xxxxxxxxxxxxx")
save(fb_oauth, file="fb_oauth")
load("fb_oauth")
me <- getUsers("me", token=fb_oauth)
me$username
Une fois ce code exécuté une fenêtre du navigateur s’ouvre et valide la
connexion à l’api.

obtenir les publications d’une page: la fonction ”getPage”
Example (Code)
# exemple 1
extract_salomonrunning<-getPage(page="salomonrunning",
token=fb_oauth, n =1000, feed = FALSE,
reactions = FALSE)
# exemple 2
extract_suunto<-getPage(page="Suunto", token=fb_oauth,
n =10, feed = TRUE , reactions = TRUE, verbose = TRUE)
# exemple 3
extract_rossignol<-getPage(page="rossignol", token=fb_oauth,
n = 3000, since=’2017/01/01’, until=’2017/12/31’,
feed = FALSE, reactions = TRUE)

les paramètres de la fonction ”getPage”
La fonction ”getPage” possède les paramètres suivants:
page: un id de page facebook
token: OAuth token créé avec fbOAuth
n: le nombre de posts souhaité
since: début de la période d’extraction souhaitée. ex: ’2017/01/01’
until fin de la période d’extraction souhaitée. ex: ’2017/12/01’
feed: capture des posts non officiels (true/false)
reactions: ajout des facebook réactions à l’extract par défaut
(true/false)
verbose: ajout d’un compteur du nombre de posts capturés
(true/false)
api: version de l’api utilisée (true/false)

le résultat de la fonction ”getPage”
Une fois la requête exécutée, les données sont directement obtenues sous la forme d’un
dataframe.

obtenir les commentaires d’une publication: la fonction
”getPage”
Example (la procédure s’effectue en trois temps)
#1 extraction des publications d’une page
reactions = FALSE)
#2 extraction des commentaires d’un post
sr_1<-getPost(extract_salomonrunning$id[1], token=fb_oauth,
n=500, comments = TRUE,reactions = FALSE)
#3 création d’un dataframe
sr_1<-jsonlite::flatten(sr_1$comments[c("from_id",
"from_name","message", "created_time","likes_count",
"comments_count", "id")])
sr_1<-as.data.frame(sr_1)

le résultat de la fonction ”getPost”
Une fois la requête exécutée, il faut transformer les données afin d’obtenir un dataframe.
Par ailleurs, il est nécessaire de créer une boucle afin de capturer les commentaires sur
l’ensemble des posts.

les paramètres de la fonction ”getPost”
La fonction ”getPage” possède les paramètres suivants:
post: un Id de post
token: OAuth token créé avec fbOAuth
n: le nombre maximum de commentaires à capturer
comments: extraction du nombre de commentaires obtenus par les
commentaires
likes: extraction des likes obtenus par les commentaires
reactions: ajout des facebook réactions à l’extract par défaut
n.likes: nombre max de likes
n.comments: nombre max de comments
n.reactions: nombre max de reactions
api: version de l’api utilisée

obtenir les replies à un commentaire d’une publication: la
fonction ”getCommentReplies”
Example (la procédure s’effectue en plusieurs temps)
#1 extraction des publications d’une page
reactions = FALSE)
#2 extraction des commentaires d’un post
sr_1<-getPost(extract_salomonrunning$id[1], token=fb_oauth,
n=500, comments = TRUE,reactions = FALSE)
#3 extraction des replies d’un commentaire
rp_1<-getCommentReplies(sr_1$id[1], token=fb_oauth, n = 500, replies = TRUE,
likes = TRUE, api = NULL)
#4 transformation
rp_1<- jsonlite::flatten(rp_1$replies[c("from_id", "from_name", "message",
"created_time", "likes_count","id")])
rp_1<-as.data.frame(rp_1)

quelques commentaires sur le package Rfacebook
Les points positifs:
exploitation des principaux endpoint de l’api facebook,
permet d’obtenir des données facilement via les fonctions,
extract ”page level” est directement utilisable
package est globalement véloce (rapidité pour obtenir les données)
Les points négatifs:
manipulations pour obtenir les commentaires
certaine lenteur pour obtenir les replies (double
boucle+transformation des données)
Au global, le package reste un outil très intéressant pour capturer
facilement des données FB.

présentation et utilisation du package twitteR
Ce package permet de collecter des données via l’api rest de twitter.
Comme pour Rfacebook, différents endpoint de l’api ont été codés par des
fonctions que l’on utilise pour collecter les données. Nous utiliserons
principalement deux fonctions:
userTimeline: cette fonction permet de collecter les n publications
récentes d’un compte twitter,
searchTwitter: cette fonction permet de collecter une partie des
tweets contenant un sujet particulier.
twitteR
”userTimeline” ”searchTwitter”

initialisation de twitteR
Example (Code)
# oauth twitteR
setup_twitter_oauth("xxxxxxxxxxxxxxxxxxxxxxx",
consumer_secret="xxxxxxxxxxxxxxxxxxxxxxx",
access_token="xxxxxxxxxxxxxxxxxxxxxxx",
access_secret="xxxxxxxxxxxxxxxxxxxxxxx")
Une fois ce code ex´ecut´e, le code suivant doit apparaˆıtre dans r:
1 ”Using direct authentication”

obtenir les publications d’un compte twitter: la fonction
”userTimeline”
Example (la proc´edure s’eﬀectue en deux temps)
#1 extraction des publications d’un compte
hd<-userTimeline("hadleywickham", n=3200, maxID=NULL, sinceID=NULL,
includeRts=FALSE, excludeReplies=FALSE)
hd_df<-twListToDF(hd) #creation d’un dataframe

le résultat de la fonction ”usertime”
En théorie, l’api doit retourner au maximum les 3200 derniers tweets ce qui n’est pas
toujours le cas avec ce package (bien souvent le nombre de tweets est largement
inférieur).

les paramètres de la métafonction ”timelines”
Le package intègre différentes fonctions permettant de capturer des
éléments d’une timeline:
userTimeline(user, n=20, maxID=NULL, sinceID=NULL,
includeRts=FALSE, excludeReplies=FALSE, ...)
homeTimeline(n=25, maxID=NULL, sinceID=NULL, ...)
mentions(n=25, maxID=NULL, sinceID=NULL, ...)
Les paramètres des fonctions:
user: nom du compte twitter
n: le nombre maximun de tweets à capturer (max=3200)
maxID: maximum d’id à rechercher
sinceID: minimum d’id à rechercher
includeRts: si FALSE les RT ne seront pas capturés
excludeReplies: si TRUE les replies ne seront pas capturés

obtenir les publications twitter mentionnant un terme: la
fonction ”searchTwitter”
Example (la procédure s’effectue en deux temps)
#1 extraction des publications twitter
==>je veux 100 tweets mentionnant le hashtag #rstats
rstats<-searchTwitter("#rstats", n=100)
#autres requêtes possibles:
rstats<-searchTwitter("#rstats", since=’2017-12-01’, until=’2017-12-31’)
rstats<-searchTwitter("#rstats+hadley", resultType="popular", n=15)
rstats<-searchTwitter("from:hadleywickham", resultType="recent", n=10)
rstats_df<- twListToDF(rstats) #création d’un dataframe

le résultat de la fonction ”searchTwitter”
En théorie, l’api doit retourner au maximum les 3200 derniers tweets ce qui n’est pas
toujours le cas avec ce package (bien souvent le nombre de tweets est largement
inférieur).

les paramètres de la fonction ”searchTwitter”
Différents paramètres sont possibles pour optimiser les recherches:
searchString: terme(s) recherché(s) ajout d’un ”+” entre les termes
de recherche
n: le nombre maximum de tweets à capturer
since: début de la période d’extraction souhaitée. ex: ’2017/01/01’
until fin de la période d’extraction souhaitée. ex: ’2017/12/01’
geocode: matching de la recherche sur coordonnées géo
resultType: filtre tweets selon la valeur ”popular”, ”recent”, etc...

présentation et utilisation du package streamR
Ce package collecte des données via l’api streaming de twitter. Il capture
en temps réel les conversations sur un sujet sur twitter: la collecte débute
lorsque l’on lance une requête et s’arrête lorsque l’on stoppe la fonction
(pas de données avant ou après la collecte). Le package comprend
plusieurs fonction mais nous utiliserons principalement la fonction
filterStream.
streamR
filterStream

initialisation de streamR
Example (Code)
library(streamR)
library(ROAuth)
library(rjson)
requestURL <- "xxxxxxxxxxxxxxxxxxxxxxxxxx"
accessURL <- "xxxxxxxxxxxxxxxxxxxxxxxxxx"
authURL <- "xxxxxxxxxxxxxxxxxxxxxxxxxx"
consumerKey <- "xxxxxxxxxxxxxxxxxxxxxxxxxx"
consumerSecret <- "xxxxxxxxxxxxxxxxxxxxxxxxxx"
my_oauth <- OAuthFactory$new(consumerKey=consumerKey,consumerSecret=consumerSecret,
requestURL=requestURL, accessURL=accessURL, authURL=authURL)
#authentification aupr`es de l’api
my_oauth$handshake(cainfo = system.file("CurlSSL", "cacert.pem", package = "RCurl"))
#message
"To enable the connection, please direct your web browser to:
https://api.twitter.com/oauth/authorize?oauth_token=PR8m4gAAAAAAVPmzAAABYOAHHOY
When complete, record the PIN given to you and provide it here:
1319182 #coller le pin
La documentation de streamR :http://pablobarbera.com/code/streamR.html

extraire des données en streaming la fonction filterStream
Example (Code)
=> je souhaite capter au fil de l’eau des tweets contenant le terme #rstats
# j’appelle la fonction filterStream
filterStream( file="#rstats.json", track="#rstats",timeout=0, oauth=my_oauth )
=>le package crée un fichier "#rstats.json"dans mon répertoire
où il écrit les tweets.
=>dans la console appara^ıt le message "capturing tweets".
=>une fois la capture stoppée, j’utilise une fonction du package
pour transformer le fichier json en dataframe
# j’appelle la fonction tweets.df afin de créer un dataframe
tweets.df <- parseTweets("#rstats.json", simplify = TRUE)

le résultat de la fonction filterStream
Au final, on obtient un dataframe assez riche notamment au niveau des données des
personnes qui ont publié le tweet. A noter que ce stream n’est pas exhaustif: une partie
des tweets est capturée (seul un abonnement au firehose twitter permet d’atteindre
l’exhaustivité).

présentation et utilisation du package rtweet
Comme streamR et twitteR, ce package permet de se collecter aux api twitter. Très
récent, ce package permet à la fois de se collecter aussi bien à l’api rest qu’à l’api
streaming de twitter. Il est possède de nombreuses fonctions qui exploitent les
endpoints les plus intéressants des api twitter. Par ailleurs, il semble qu’il soit plus
efficace que twitteR pour collecter le max de tweets d’une timeline soit 3200 tweets.
rtweets
api search api streaming
publications
followers
search d’un
terme
stream
stream geo
stream temps

initialisation de rtweet
Example (Code)
# installer rtweet via cette commande pour installer la dernière version du package
qui permet de s’authentifier plus facilement vis à vis de l’api twitter)
load(devtools)
devtools::install_github("mkearney/rtweet")
# load le package
library(rtweet)
lorsque l’on lance une fonction, une fenêtre s’ouvre demandant
d’autoriser l’application.
Après acceptation, l’authentification est effectuée
et l’on peut utiliser le package et ses fonctions.
La documentation du package rtweet: http://rtweet.info/

la fenêtre d’authentification
Après avoir cliqué sur ”authorize app”, l’authentification est effective.

obtenir les publications twitter: la fonction ”get timeline”
Example (Code)
#1 extraction des publications twitter d’un compte
=>je veux les 3200 derniers tweets d’un compte
tml <- get_timeline("juliasilge", n = 3200)
#2 extraction des publications twitter de plusieurs comptes
=>je veux les 3200 derniers tweets d’un compte
=>je cr´ee une liste de compte dans la fonction
tmls <- get_timelines(c("hadleywickham", "drob", "juliasilge"), n = 3200)

le r´esultat de la fonction ”get timeline”
A noter que les r´esultats sont directement obtenus sous la forme d’un dataframe

les paramètres de la fonction ”get timeline”
Différents paramètres sont possibles pour optimiser les recherches:
user: compte(s) twitter à capturer
n: le nombre maximum de tweets à capturer par timeline
max id:
home: logique, user-time ou home-timeline (retweets)
parse: logique, par défaut transformation en dataframe
check: vérification avant le lancement de la requête des crédits
d’extraction
token: logique, par défaut par de tokens dans les requêtes (cf.
twitteR)

autres fonctions int´eressantes sur l’api search
Example (Code)
#1 recherche d’utilisateurs en fonction de mots dans le profil
rstats_users<- search_users("#rstats", n = 1000)
#2 extraction des followers d’un compte
hd_flw <- get_followers("/hadleywickham", n = 55000)
#3 search sur tweets contenant un hashtag
rstat_ht <- search_tweets( "#rstats", n = 18000, include_rts = FALSE
#4 search sur tweets contenant un mot
data<- search_tweets( "data", n = 250000, retryonratelimit = TRUE
#5 search selon geoloc
by_us <- search_tweets( "lang:en", geocode = lookup_coords("usa"), n = 10000)
# autres fonctions (look up)

les fonctions de streaming de rtweet
Example (Code)
#1 stream de 30s
data_stream <- stream_tweets("data")
#code généré par l’extract
Streaming tweets for 30 seconds...
Downloading: 210 kB Finished streaming tweets!
opening file input connection.
Imported 134 records. Simplifying...
closing file input connection.
#2 stream sur une semaine (60 s *60 min* 24 h* 7 j)
stream_tweets("rstats,datascience", timeout = 60 * 60 * 24 * 7,
file_name = "rstatsdatascience.json",parse = FALSE)
#fonction de parsing
djt <- parse_stream("rstatsdatascience.json")
#3 stream sur une base de geoloc des tweets (60s)
rt <- stream_tweets(lookup_coords("london, uk"), timeout = 60)

le r´esultat de la fonction ”get timeline”
Ici, les r´esultats sont directement obtenus sous la forme d’un dataframe

présentation et utilisation du package tuber
Ce package permet de se collecter à l’api data de youtube. Avant d’utiliser le package: il
faut nécessaire de se créer:
un compte xx@gmail.com
un compte développeur youtube
une application reliée à l’api youtube
Nous utiliserons principalement ce package pour extraire les commentaires d’une vidéo.
Pour les métriques, nous utiliserons l’outil youtubedatatools qui sera présenté plus loin.
tuber
chanel level video level
méta données
playlists
stats de la
vidéo
commentaires

initialisation de tuber
Example (Code)
# load le package
library(tuber)
yt_oauth("998136489867-5t3tq1g7hbovoj46dreqd6k5kd35ctjn.apps.googleusercontent.com",
"MbOSt6cQhhFkwETXKur-L9rN")
code généré dans l’interface Rstudio
Use a local file (’.httr-oauth’), to cache OAuth access
credentials between R sessions?
1: Yes
2: No ==>No
#pop-up qui s’ouvre
sélection du compte gmail rattaché à l’application
validation de l’utilisation du compte pour accéder aux ressources de l’api
La documentation du package
https://cran.r-project.org/web/packages/tuber/tuber.pdf

obtenir les stats d’une vid´eo sur youtube
Example (Code)
#1 capture de l’id de la vid´eo youtube
=>https://www.youtube.com/watch?v= 9p1kAvDL52U
a<-get_stats(video_id="9p1kAvDL52U")
a_df<-as.data.frame(a) (mise sous dataframe)
#2 extraction des statistiques d’une cha^ıne
==>https://www.youtube.com/channel/UCpVm7bg6pXKo1Pr6k5kxG9A
b<-get_channel_stats(channel_id="UCpVm7bg6pXKo1Pr6k5kxG9A")
b_df<-as.data.frame(b) (mise sous dataframe)

le r´esultat des fonctions

obtenir des commentaires déposés sur youtube
Example (Code)
#1 capture des commentaires sur une vidéo (hors replies)
video_c <- get_comment_threads(c(video_id="9p1kAvDL52U"))
==>argument sur le max de commentaires
video_c <- get_comment_threads(c(video_id="9p1kAvDL52U"), max_results = 101)
#2 extraction verbatim d’un commentaire/reply spécifique
==>extraction data d’un commentaire spécifique
video_d <- get_comments(filter = c(comment_id = "Ugx9yHVg6_ncD4DmWqV4AaABAg"))
==>extraction data des replies sur un commentaire spécifique
video_e <- get_comments(filter = c(parent_id = "Ugx9yHVg6_ncD4DmWqV4AaABAg"))
#3 extraction verbatim de deux commentaires
video_f <- get_comments(filter = c(comment_id = "Ugwa9SBHiUq1Pvp1aDp4AaABAg,
Ugx9yHVg6_ncD4DmWqV4AaABAg"))
#4 extraction verbatim des replies sur deux commentaires
video_f <- get_comments(filter = c(parent_id = "Ugwa9SBHiUq1Pvp1aDp4AaABAg,
Ugx9yHVg6_ncD4DmWqV4AaABAg"))

obtenir des statistiques de l’ensemble des vidéos déposés
sur une chaine youtube
Example (Code)
#1 je crée une liste si je veux les données pour plusieurs chaines
a <- list_channel_resources(filter = c(channel_id = "UCT5Cx1l4IS3wHkJXNyuj4TA"), par
# obtenir les playlists d’une chaine
playlist_id <- a$items[[1]]$contentDetails$relatedPlaylists$uploads
# si je veux les données pour chaque vidjéo appartement à une playlist
vids <- get_playlist_items(filter= c(playlist_id=playlist_id))
# obtenir les ids des vidéos hébergées par une chaine
vid_ids <- as.vector(vids$contentDetails.videoId)
# obtenir les stats pour chaque ids des vidéos hébergées par une chaine
get_all_stats <- function(id) {
get_stats(id)
}
# obtenir d’un tableau d’agrégation des résultats
res <- lapply(vid_ids, get_all_stats)
res_df <- do.call(rbind, lapply(res, data.frame))

quelques remarques sur tuber
tuber permet d’accéder à l’api youtube et utiliser les principaux endpoints de l’api de
youtube. Les résultats sont intéressants mais certains éléments pourraient être optimisés:
le titre de la vidéo et/ou la date de publication de la vidéo ne sont pas dans
l’extract par défaut du package,
il est possible d’extraire les données de l’ensemble des vidéos hébergées par un
chaˆıne à un instant t.
comme pour Rfacebook pour obtenir à la fois les commentaires et les replies il faut
créer des boucles pour collecter les données.

l’extacteur youtubedatatools
Cet extracteur est un projet académique hébergé ici:
https://tools.digitalmethods.net/netvizz/youtube/mod video info.php. ll permet
d’extraire les données de l’api youtube sur les métriques des chaˆınes et/ou des vidéos
ainsi que les commentaires. Les avantages:
facilité d’utilisation: pas de compte développeur à créer
fonctionnalité: extraction groupée des métriques de l’ensemble des vidéos
hébergées sur une chaˆıne
Les inconvénients:
phase d’importation des datas dans r
pas d’extraction des replies à date

un aper¸cu de youtubedatatools

utilisation de youtubedatatools
ytdt
chanel level video level
méta données
vidéos d’une
chaine
network chan-
nel
stats de la
vidéo
network vidéo
commentaires
de la vidéo

extraire des stats de l’ensemble des vidéos d’une chaˆıne
Après avoir entré l’id youtube de la chaˆıne, il faut lancer l’extract. L’outil affiche le
nombre de vidéos extraites au fur et à mesure de l’avancement de la procédure. Une fois
l’extract terminé, l’outil crée un fichier .tab. Il faut cliquer sur ce fichier afin de
l’enregistrer sur sa machine.

importer les données collectées ytdt dans r
Example (Code)
#1 soit par Rstudio directement
==>je clique sur l’élément "Import Dataset" et je me dirige dans la machine pour
trouver le fichier.
==>après validation, les données sont importées sous la forme d’un dataframe.
#2 soit en ligne de commande
videolist<- read.delim("C:/Users/jjg/Downloads/videolist")

exporter un dataframe r dans un fichier excel
Lorsqu’elle sont sous forme de dataframe, il est possible d’exporter sous la
forme d’un fichier csv ou excel des données à condition que le fichier ne
soit pas trop volumineux.
Example (Code)
#code à insérer
#trick rjava (dans le cas où il y a une erreur avec le package rjava)
if (Sys.getenv("JAVA_HOME")!="")
Sys.setenv(JAVA_HOME="")
#load les librairies
library(rJava)
library(xlsx)
#instruction pour export
write.xlsx(nom_du_dataframe, file ="C:/Users/jjg/study/nom_du_fichier.xlsx" ,
sheetName="1", col.names=TRUE, row.names=TRUE, append=FALSE, showNA=TRUE)
==>fichier devrait être crée au même endroit que rstudio est installé.

S´eance 2:manipuler les donn´ees dans r

Les types de données dans r
r est un langage orienté objet: tout est un objet dans r. Chaque objet possède une
longueur, certains attributs (des métadonnées) et un mode. Le mode prescrit ce qu’un
objet peut contenir. Voici les principaux modes:
les nombres réels appartiennent au mode numeric
les nombres complexes appartiennent au mode complexe
les nombres entiers sont appelés integers
les booléens (TRUE/FALSE) appartiennent au mode logical
les chaˆınes de caractères appartiennent au mode character
les fonctions appartiennent au mode fonction
les lists appartiennent au mode list
Les objets de mode ”numeric”, ”complex”, ”logical” et ”character” sont des objets
simples (atomic en anglais) qui ne peuvent contenir à la fois que des données d’un seul
type. Les objets de mode ”list” ou ”expression” sont des objets qui peuvent contenir
dans le même temps différents objets.

les objets dans r
Example
#1 déclaration et assignement
a <- NULL # a est un objet nul, vide (null)
b <- TRUE # b est un objet booléen (logical)
c <- 101 # c est un objet numérique (numeric: double (approximation)
c <- 101.21 L # c est un objet numérique (numeric: integer (L))
d <- ’’hello world’’ # d est un objet cha^ıne des caractères (character)
e <-list(1,2,3) (list) #e est un objet liste (list)
#2 identifier les types de données: la fonction typeof
typeof(a)
=>[1] "NULL"
typeof(d)
=>[1] "character"
#3 identifier le mode de données
mode(a)
=>[1] "numeric"
mode(d)
=>[1] "character"
#4 identifier la longueur des objets
length(c)
=>[1] 1
length(e)
=>[1] 3
A noter que le mode et le type d’un objet sont souvent identiques.jean jacques gauguier Séance 1 janvier 2018 81 / 216

les vecteurs
tout objet est un vecteur dans r. Pour construire un vecteur on utilise l’opérateur c
(concatenate).
Example
#1 déclaration et assignement
f <-c(1,2,3)
g <- c("un", "deux", "trois", "quatre", "cinq", "six", "sept")
h<- c(1, "deux", "trois", "quatre", "cinq", "six", FALSE) ###
#2 identifier la longueur des vecteurs
length(f)
=>[1] 3
length(h)
=>[1] 7
#3 nommer les éléments d’un vecteur
names(f) <- c("a", "b", "c")
f
a b c
1 2 3

la hiérarchie et types de vecteur
Parmi les vecteurs, il est possible de distinguer:
vecteur atomic ou simple: un seul type de données (logical, integer, double,
character et complex)
list ou vecteurs récursifs: des listes emboˆıtées (ou nested list).
Figure: Hiérarchie des vecteurs, wickham et grolemund

vecteur et attributs
Les vecteurs peuvent contenir des métadonnées supplémentaires, on parle d’attributs.
Ces attributs sont utilisés pour créer des vectors augmentés qui peuvent être de quatre
types:
factor qui sont construits sur la base des vecteur integer
dates et date-times qui sont construits sur la base des vecteur numeric
data frames et tibbles qui sont construits sur la base des vecteurs list.
Par ailleurs, il est possible de s’assurer du type de vecteur lorsque l’on travaille avec des
vecteurs en utilisant les commandes suivantes:
as.logical(),
as.integer(),
as.double(),
as.character()

les facteurs
Les facteurs sont utilisés avec des variables qui ne peuvent prendre qu’un nombre
déterminé de valeurs. On parle de variables catégorielles
Example
#1 vecteur avec des mois que l’on souhaite ordonner
x1 <- c("Dec", "Apr", "Jan", "Mar")
#2 résultat sans transformation
sort(x1)
=>[1] "Apr" "Dec" "Jan" "Mar" #ne respecte pas l’ordre calendaire
length(h)
=>[1] 7
#3 créer un vecteur ordonné avec l’ensemble des niveaux possibles
month_levels <- c("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
"Sep", "Oct", "Nov", "Dec")
#4 transormation
x2 <- factor(x1, levels = month_levels)
sort(x2)
=>[1] Jan Mar Apr Dec
Levels: Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec

les fonctions en lien avec les facteurs
Example
#1 test
class(x1)
==>[1] "factor"
#2 afficher les niveaux d’un facteur
sort(x1)
=>[1] Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
#3 afficher les effectifs pour level (fonction table)
table(x1)
Apr Dec Jan Mar
1 1 1 1
# 4 ordonner selon l’ordre d’apparition historique des donn´ees
x3 <- factor(x1, levels = unique(x1))
x3
==>[1] Dec Apr Jan Mar Levels: Dec Apr Jan Mar

les matrices
r supporte également les matrices et les tableaux. D’une certaine manière, une matrice
est un vecteur avec un attribut supplémentaire, l’attribut dim, dont la longueur est égale
à 2 dans le cas d’une matrice simple.
Example
#1 la fonction de base
x1 <-matrix(1:6, nrow = 2, ncol = 3) # colonne puis ligne
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
#2 l’argument byrow = TRUE
x2 <-matrix(1:6, nrow = 2, ncol = 3, byrow = TRUE) #ligne puis colonne
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6

les tableaux
Un tableau (array) est une matrice qui poss`ede plus de deux dimensions.
Example
#1 la fonction de base
x1 <-array(1:24, dim = c(3, 4, 2)) #lignes, colonnes et dimensions
, , 1 #premiere dimension
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[,3] 3 6 9 12
, , 2 #seconde dimension
[,1] [,2] [,3] [,4]
[1,] 13 16 19 22
[2,] 14 17 20 23
[,3] 15 18 21 24
nrow(x1, ncol(x1), dim(x1),
rownames(x1) <- c("A", "B",’’C’’)
colnames(x1)<-c(‘D’’,’’E’’,’’F’’,’’G’’)
dimnames(x1) <- list(c("A", "B",’’C’’),c(‘D’’,’’E’’,’’F’’,’’G’’),c(‘H’’,’’I’’))

comment visualiser les tableaux (tiré de goulet 2016)
L’ordre de remplissage inhabituel des tableaux rend leur manipulation difficile.
Imaginons un tableau de dimensions 3*4*5.
il faut voir le tableau comme 5 matrices 3*4 les unes derrière les autres.
le tableau est un prisme rectangulaire haut de 3 unités, large de 4 et profond de 5
avec une quatrième dimension, cela revient à aligner des prismes
Figure: Représentation schématique de tableaux. Les chiffres encerclés identifient
l’ordre de remplissage, goulet (2016)

les listes
Les listes sont la forme de stockage des données la plus générale:
les éléments d’une liste peuvent être de différents modes (numeric, character, boolean),
il est possible d’emboˆıter des listes dans une liste (nested ou recursive list)
Example
#1 la fonction de base pour créer une liste
x <- list(1:3, "a", c(TRUE, FALSE, TRUE), c(2.3, 5.9))
#2 obtenir les informations sur les éléments
str(x)
=> List of 4
$ : int [1:3] 1 2 3
$ : chr "a"
$ : logi [1:3] TRUE FALSE TRUE
$ : num [1:2] 2.3 5.9
#3 une fonction récursive
x <- list(list(list(list())))
#4 obtenir les informations sur les éléments
=> > List of 1
#> $ :List of 1
#> ..$ :List of 1
#> .. ..$ : list()
#5 tests list et/ou recursivité
is.recursive(x) is.list(x)
#> [1] TRUE

le dataframe
La structure de stockage des données dataframe est la forme plus commune....et la plus simple
pour effectuer des analyses. Voici quelques commandes de base en lien avec la structure
dataframe.
Example
#1 créer un dataframe
df <- data.frame(x = 1:3, y = c("a", "b", "c")
#2 afficher le dataframe
df
#3 afficher le dataframe dans une fenêtre
View(df)
#4 afficher la structure du dataframe
str(df)
#5 statistique du dataframe
summary(df)
#6 afficher le type
typeof(df)
==>’’list’’
#7 vérification si dataframe
is.data.frame(df)
==>TRUE
#7 afficher la classe
class(df)

les commandes pour manipuler un dataframe
Example
#1 transformer en dataframe une structure existante
df<-as.data.frame(x)
#2 sélectionner une colonne d’un dataframe (nom)
df$ma_colonne
#3 sélectionner une colonne d’un dataframe (numéro de colonne)
df[,1] ou d[[1]]
#4 sélectionner une colonne d’un dataframe (nom)
df[’’nom_de_ma_colonne’’]
#5 sélectionner différentes colonnes
df[c("première_colonne’’, "deuxième_colonne")]
#6 sélectionner une ligne particulière (12)
df[12,]
#7 sélectionner deux lignes particulières
df[c(12,40),]

autres commandes pour un dataframe
Example
#1 sélectionner une cellule particulière (première ligne, seconde colonne)
df[1,2]
#2 sélectionner une cellule particulière avec nom des col. et lignes.
df[’’nom_de_la_ligne’’,’’nom_de_ma_colonne’’]
#3 combiner deux dataframes (même structure) par les colonnes
df<-cbind(df_1, df_2) (l’un en dessous de l’autre)
#4 combiner deux dataframes (même structure) par les
df<-rbind(df_1, df_2) (l’un à côté de l’autre)
#5 afficher le nombre de lignes
nrow(df)
==>’’list’’
#6 afficher le nombre de colonnes
ncol(df)
==>TRUE
#7 afficher le haut du dataframe
head(df)

la structure tibble et le package tibble
La structure de stockage tibble est une structure proche de la structure dataframe. De création
plus récente, les tibbles proposent une structure plus souple et largement optimisée pour
travailler dans la suite tidyverse (les avantages de cette structure de stockage des données sont
détaillés ici: https://cran.r-project.org/web/packages/tibble/vignettes/tibble.html.) Voici
quelques commandes en lien avec cette structure:
Example
#1 créer un tibble
tbl <- tibble(mes_datas)
#2 afficher le tibble
tbl
#3 transformer en tibble
tbl <- as_tibble(df)
#4 afficher une partie du tibble (x=nb de rows) + condition (sur colonnes)
tibble(x = 1:31)
#5 extraire une colonne
tbl[, 1]
#6 extraire des colonnes
tbl[, 1:2])

La Manipulation des donn´ees dans r

la logique tidy data
Les données peuvent être organisée de différentes manières au niveau de la manière dont sont
architecturées les variables et les dimensions. La logique ”tidydata” est une logique
d’organisation des données particulières selon trois principes:
chaque variable doit avoir sa propre colonne,
chaque observation doit avoir sa propre ligne,
chaque valeur doit avoir sa propre cellule
Ces trois principes sont reliés entre eux. L’intérêt d’utiliser cette logique est double:
intérêt de travailler sur une structure identique de données entre les datasets,
intérêt d’utiliser les variables en colonne car cette structure s’applique bien aux
traitements vectorisés et aux packages construits autour de ce type de traitement
.
Figure: La logique ’tidydata”, wickham et grolemund (2017)

la suite de package tidyverse
Lorsque l’utilisateur charge la library (tidyverse) les packages suivant sont
automatiquement chargés :
le package ggplot2 qui permet d’effectuer des représentations graphiques
tibble qui permet de travailler avec des données stockées sous la forme de tibble,
tidyr qui permet de transformer les structures de données en données ”’tidy”
purr qui permet d’appliquer des fonctions de manière vectorielles,
dplyr qui permet d’appliquer des transformations aux données sous forme ”tidy”
readr qui permet d’importer des données dans r.

les données ”non tidy”et ”tidy”
L’extrait de gauche représente des données non organisées sans la forme ’tidy’. Cette de
droite représente des données organisées selon la principe.
Figure: données non tidy et tidy, wickham et grolemund (2017)

le package tidyr
Ce package permet d’organiser des données non organisées sous la forme ’tidy’. Au
global, ce package est organisé autour de deux verbs qui sont:
gather(): permet de développer le dataframe en transformant des données en
lignes en variables ”colonne”
spread(): permet de supprimer des lignes en les regroupant.
separate(): permet de spitter une colonne en deux colonnes ex:
tidyr::separate(mes données, into = c(”numérateur”, ”dénominateur”)) (si ratio
existe au départ)
unite(): inverse du verb separate. ex tidyr::unite(mes données,numérateur,
dénominateur)

la fonction gather
#1 écriture générique de la fonction
tidyr::gather(mes données, mes colonnes, key=’’ma clé’’, value=’’mes_valeurs’’)
Figure: wickham et grolemund (2017)

la fonction spread
tidyr::spread(mes donn´ees,key=’’ma cl´e’’, value=’’mes_valeurs’’)

le package dplyr et ses principales fonctions
Le package dplyr fait partie de la ”suite” tidyverse. Ce package permet de manipuler et
transformer les données stockées sous forme de dataframe. Différentes fonctions existent
pour manipuler les données:
filter() pour filtrer les données selon des règles
arrange() pour réorganiser les données en changeant l’ordre des lignes,
mutate() pour créer de nouvelles variables à partir des variables existantes,
select() pour sélectionner des colonnes du dataframe
group by() pour sélectionner et combiner des colonnes du dataframe
summarise() pour effectuer des totaux des colonnes

la fonction select: sélectionner les colonnes d’un dataframe
La fonction possède différents arguments permettant de filtrer sur les colonnes
Example
dplyr::select(mes_données, ma_règle)
#2 sélectionner une colonne entière
dplyr::select(mes_données, la_colonne_de_mon_dataframe)
#3 sélectionner différentes colonnes
dplyr::select(mes_données, la_colonne_de_mon_dataframe, la_seconde_colonne)
#4 sélectionner toutes les colonnes sauf une
dplyr::select(mes_données,- la_colonne_de_mon_dataframe)
#5 sélectionner les éléments d’une colonne selon termes
dplyr::select(mes_données, contains(’’mon_terme’’)
dplyr::select(mes_données, starts_with(’’mon_terme’’)
dplyr::select(mes_données, ends_with(’’mon_terme’’)
#8 sélectionner les éléments d’une colonne selon les positions
dplyr::select(mes_données, 3:5)

la fonction filter: filtrer parmi les lignes d’un dataframe
La fonction possède différents arguments permettant de filtrer les lignes
Example
dplyr::filtrer(mes_données, ma_règle)
#2 sélectionner des lignes (valeurs de la variable)
dplyr::filtrer(mes_données, valeur de la variable >’’valeur’’)
#3 sélectionner des lignes (nom de la variable)
dplyr::filtrer(mes_données, variable de la colonne == mon_terme)
#4 sélectionner avec des combinaisons
dplyr::filtrer(mes_données, variable de la colonne == mon_terme &
valeur de la variable $>$ ’’valeur’’)

la fonction arrange: réorganiser l’ordre des lignes
La fonction possède différents arguments permettant de modifier l’ordre des lignes
Example
dplyr::arrange(mes_données, arg(ma_colonne))
#2 ordre décroissant des valeurs de ma colonne #Ok top 10, top 5, etc...
dplyr::arrange(mes_données, desc(ma_colonne))
#3 ordre alphabétique de la première colonne
dplyr::arrange(mes_données)
#4 ordre alphabétique d’une colonne particulière
dplyr::arrange(mes_données, ma_colonne)

la fonction mutate: créer de nouvelles colonnes/variables
La fonction permet d’ajouter de nouvelles colonnes construites sur les colonnes existantes (ratio,
pourcentage,etc....
Example
dplyr::mutate(mes_données, ma_nouvelle_variable= combinaison)
#2 supprimer une variable existante
dplyr::mutate(mes_données, ma_variable_existante= NULL)
#3 garder seulement la variable nouvellement crée
dplyr::transmute(mes_données, ma_nouvelle_variable =combinaison)
#4 utilisation les noms des variables dans la combinaison
dplyr::mutate(mes_données, ma_nouvelle_variable= !!quo(nom_var_1 * nom_var_2))
Le verb de la fonction mutate peut être utilisée avec les fonctions suivantes de r
+, - etc
log()
lead(), lag()
dense rank(), min rank(), percent rank(), row number(), cume dist(), ntile()
cumsum(), cummean(), cummin(), cummax(), cumany(), cumall()
fil else(), recode(), case when()
existe aussi: mutate() (mutate all(), mutate if(), mutate at() et transmute all(),
transmute if(), transmute at()

la fonction summarize: créer des agrégations de colonnes
La fonction permet d’effectuer des calculs sur une colonne entière
Example
dplyr::summarize(mes_données, mon_calcul= calcul*ma_variable)
#2 exemple (afficher moyenne d’une colonne+ nombre de lignes
dplyr::summarise(mes_données, mean = mean(ma_variable), n = n())
Le verb de la fonction summarize peut être utilisée avec les fonctions suivantes de r
mesure de la centralité: mean(), median()
mesure de la densité: sd(), IQR(), mad()
min(), max(), quantile()
mesure de la position: first(), last(), nth(),
nombre: n(), n distinct()
expression: any(), all()

la fonction group by: grouper des variables
La fonction permet d’effectuer des groupements (ex: regrouper des observations qui
appartiennent à la même catégorie (ex: homme, femme, image, vidéo, etc...)) pour ensuite
effectuer des calculs. Utilisée seule, cette fonction ne modifie pas la structure des données.
Example
dplyr::group_by(mes_données, ma_variable)
#2 grouper différentes variables
dplyr::group_by(mes_données, ma_variable_1,ma_variable_2,ma_variable_3)

la fonction pipe
La fonction pipe % > % permet d’enchaˆıner les transformations permet de relier les phases de
sélection, de transformation et représentation. L’exemple ci-dessus illustre le principe
Example
graphique_page_mois_eng_secteur<-df%>% # nom du graphique/nom des données de départ
mutate(mois = format(time, "%m"), année = format(time, "%Y")) %>% #verb mutate
group_by(secteur,name,from_name,mois,annee)%>% #verb group_by
summarise(total = sum(engagement_tot))%>% #verb summarize
filter(annee>="2017")%>% #verb filter graphique ensuite
ggplot(aes(x= mois,y=total,fill=from_name))+geom_bar(stat = "identity")+
theme_minimal()+ theme(legend.position="bottom")+
theme(legend.text=element_text(size=5))+
facet_grid(. ~secteur)+ theme(legend.title=element_text(size=5))+
theme(strip.text.x = element_text(size = 6, angle = 90))+
theme(axis.text.x=element_text(size=3))+
scale_y_continuous(labels = comma)+ labs(x = "mois",
y = "volume d’engagement par page",
title = "volume d’engagement mensuel en 2017 par page",
subtitle = "hors dark posts")

le package Dplyr et ses fonctions
Figure: à télécharger ici: https://www.rstudio.com/resources/cheatsheets/

la gestion des dates dans r
La gestion des dates est généralement complexe compte tenu des différences de format,
des fuseaux horaires et aux autres spécificités (ex: année bissextile) La ”suite” tidyverse
comprend un package dédié à la gestion des dates. D’autres packages plus anciens
comme chron permettent également de gérer les dates. Enfin la classe POSIX est
également intéressante car elle permet de gérer les fuseaux horaires (time zone). Pour
débuter commen¸cons par la fonction as.Date qui repose sur cette codification:
d jour du mois (décimal)
m mois (décimal)
b mois en abréviation
B mois sans abréviation
y année avec deux chiffres
y année avec quatre chiffres

la fonction de base as.Date
Example
# 1 cas où la date est déjà formatée
ma_date<-as.Date(’2017-01-28’)
# 2 cas où la date n’est pas formatée de la bonne manière
ma_date<-as.Date(’1/28/2018’, format=’%m/%d/%Y’)
#j’indique le format en m’aidant du tableau
ma_date<-as.Date(’28JANV18’,format=’%d%b%y’)
#exemple transformation de date d’un extract twitter
created<-as.Date(publication$created, format="%Y-%m-%d")

la gestion des dates avec le package chron
Le package chron permet de formater les données calendaires intégrant les heures,
minutes et secondes. A noter que ce package ne gère pas les fuseaux horaires:
d jour du mois (décimal)
m mois (décimal)
mon mois en abréviation
month mois sans abréviation
y année avec deux chiffres
h heure
m minute
s seconde

la fonction as.Date
Example
ma_date<-chron::dates(’’01/28/2018)
mes_dates <-dates(c(’’01/28/2018,’’02/21/2018,’’03/28/2018,’’04/15/2018))
mon_heure <-chron:: times("23:03:20")
mes_heures<-chron::times(c("23:03:20", "22:29:56", "01:03:30",
"18:21:03"))
mes_dates_et_heures<-chron::chron(dates = mes_dates , times = mes_heures)
#effectuer des op´erations cf documentation chron
mes_dates_et_heures[1] - mes_dates_et_heures[3]

la gestion des dates avec la classe Posix
Comme les autres packages, POSIX repose sur un ensemble de conventions pour le formatage
des dates et heures
a jour de la semaine en abréviation
c localisation spécifique du format
j jour en décimal
M minute en décimal
S seconde en décimal
x date spécifique
w numéro du jour de la semaine
(dimanche=0)
y année (deux décimales 18)
z décalage par rapport à l’heure GMT
A jour de la semaine
B mois complet
d jour en décimal
I heure en décimal (12)
m mois en décimal
p gestion am/pm
U numéro de la semaine de l’année
(dimanche)
W numéro de la semaine de l’année
(lundi)
X localisation de l’heure
Y année (4 chiffres 2018)
Z time zone en texte
argument option tz pour spécifier la
time zone

les transformations avec le format Posix
Example
# on utilise la fonction strptime pour cr´eer une date
ma_date<-strptime(’01/Janv/2018:07:51:00’,format=’%d/%b/%Y:%H:%M:%S’)
# on transforme l’objet date en un format Posixt
(Posixt:nombre de secondes depuis le 01/01/1970 (UTC))
#identifier le formatage pour extraire les donn´ees
mydate<-as.POSIXlt(’2018-01-28 08:12:43’)
names(mydate)
mydate$mday
==>28
# transformation du format de date d’un extract vk date+formatage tz
metrics$date <- as.POSIXct(metrics$date, origin="1970-01-01", tz=’Europe/Moscow’)

la gestion des dates avec le package lubridate
Lubridate permet de formater de nombreux formats en input, gérer les fuseau horaires ou encore
extraire des éléments de la date ou encore effectuer les opérations entre les dates. Par ailleurs, il
est totalement compatible avec dplyr et la fonction pipe.
Ce package permet de gérer facilement trois cas de figure que l’on rencontre souvent lorsque
l’on importe des données:
la date est encodée sous la forme d’une chaˆıne de caractère
la date est scindée en plusieurs colonnes (mois, année, jour)
la date existe mais dans un format inadéquat
Par ailleurs lubridate permet de travailler aussi bien avec les dates que les heures ou la
combinaison des deux:
date format date
time format heure
date-time format date et heure

les fonctions intégrées dans lubridate
Example
#1 afficher la date du jour: lubridate::today()
#2 afficher la date et l’heure actuelle: lubridate::now()
#3 formater une date à partir d’une cha^ıne de caractères
madate<-ymd("2018-01-28")
madate<-mdy("January 31st, 2018")
madate<-dmy("31-Jan-2017")
madate<-ymd(20170131)
madateeheure<-ymd_hms("2017-01-31 20:11:59")
madateeheure<-mdy_hm("01/31/2017 08:01")
#4 spécifier un fuseau horaire
madate<-ymd(20170131, tz = "UTC")
#5 formater une date à partir de plusieurs colonnes
mesdonnées%>%
select(year, month, day, hour, minute)
#6 formater et créer une variable une date à partir de plusieurs colonnes
mesdonnées %>%
select(year, month, day, hour, minute) %>%
mutate(madate = make_datetime(year, month, day, hour, minute))
#7 transformer date-time en date, et date en date-time
madateeheure<-as_datetime(today())
madate<-as_date(now())

l’aide mémoire sur le package lubridate
Figure: à télécharger ici: https://www.rstudio.com/resources/cheatsheets

l’aide mémoire global sur les dates
Figure: à télécharger ici: http://blog.yhat.com/static/pdf/R date cheat sheet.pdf

la navigation dans les listes
Dans le cadre de l’écriture d’une fonction ou d’une boucle il est nécessaire de maˆıtriser l’indicage
notamment lorsque l’on travaille avec les nested lists. Le graphique tirée de ”R for datascience”
(2017) indique la manière dont on accède aux éléments d’une liste récursive avec ”[ ]” ou ”[[
]]”). A noter que la notation a[[”b”]] est équivalente à la notation a$b. Enfin ’[[ ]]” détruit la
hiérarchie de la structure de stockage originelle.

la jointure des tables
Lorsque l’on manipule de la social data, nous sommes souvent amenés à joindre des
fichiers sur la base d’un élément commun (observation et/ variable).
Par exemple, à partir d’un extract facebook j’effectue différents traitements de
textmining en créant un nouveau dataframe. In fine, je souhaite construire un fichier
unique constitué de l’extract de départ et de mon fichier de traitement. Les deux fichiers
ont un élément commun: l’id de mon post facebook. Je vais donc pouvoir réaliser une
jointure entre mes deux fichiers.
Le package dplyr permet de manipuler également les tables à l’aide de différentes
jointures grâce à ses fonctions intégrées. (u e vignette présente les possibilités offertes
en matière de jointure. on pourra le télécharger à cette adresse:
https://cran.r-project.org/web/packages/dplyr/vignettes/two-table.html).
Bien évidemment, la condition obligatoire pour que les jointures s’effectuent réside
dans le fait que chaque fichier sous être stockée sous la forme ”tidy”.
Enfin les fonctions présentées ici fonctionnent seulement sur la base d’une jointure entre
deux tables. Pour les jointures impliquant plus de deux tables, il faudra utiliser Reduce.

les fonctions ”mutate” pour joindre les donnés dans dplyr
La famille ”mutate” (inner join, left join, right join et full join) permet d’ajouter des
variables d’une table à une première table sous certaines conditions.
Example
# premier cas ’’natural joint’’ sans spécification d’un pivot
(toutes les colonnes de ma première table devront exister dans la seconde pour que
jointure fonctionne)
ma_première_table %>% left_join(ma_deuxième_table)
# second cas je spécifie un pivot par l’arg by
ma_première_table %>% left_join(ma_deuxième_table, by=’’mon_pivot’’)
==>exemple id_facebook
# troisième cas je force un pivot mais en spécifiant le lien c
ma_première_table %>% left_join(ma_deuxième_table, c(’’mon_pivot_pr’’,’’mon_pivot_sd

les quatre types de jointure mutate dans dplyr
Example
# premier cas (inner_join)
(jointure si seulement si les éléments sont présents dans les DEUX tables)
(toutes les observations de la table finale devront exister au niveau de ma premièr
ma_première_table %>% inner_join(ma_deuxième_table)
# second cas (left_join)
ma_première_table %>% left_join(ma_deuxième_table)
(toutes les observations de ma première table sont préservées et la jointure s’effec
de la seconde table)
# troisième cas (right_join)
ma_première_table %>% right_join(ma_deuxième_table)
(toutes les observations de ma seconde table sont préservées et la jointure s’effect
de la première table)
# quatrième cas (full_join)
ma_première_table %>% full_join(ma_deuxième_table)
(mise en commun)

les fonctions ’filtering” pour joindre les donnés dans dplyr
La famille ”filtering” (semi join et anti join) permet d’ajouter des
observations d’une table à une autre.
Example
# premier cas (semi_join)
(toutes les observations de ma première table devront exister dans la seconde pour q
jointure fonctionne)
ma_premiere_table %>% semi_join(ma_deuxième_table)
# second cas (anti_join)
ma_premiere_table %>% anti_join(ma_deuxième_table, by=’’mon_pivot’’)
(toutes les obervations de ma première table qui existent dans la seconde seront sup
une fois la jointure réalisée)

trois fonctions pour opérer des jointures entre tables
identiques
Sous réserve que les deux tables possèdent une structure identique (c’est à
dire les mêmes variables), dplyr permet d’effectuer facilement l’union,
l’intersection et la différence entre les observations appartenant à deux
tables.
Example
# premier cas (intersect)
monnintersection<-intersect( ma_première_table, ma_deuxième_table)
# second cas (union)
monunion<-union(ma_première_table, ma_deuxième_table)
# second cas (setdiff)
madifference<-setdiff(ma_première_table, ma_deuxième_table)

les expressions régulières avec le package grep
Le package grep permet d’utiliser les expressions régulières pour manipuler
et transformer les chaˆınes de caractères dans r. En text miming, après
avoir capturé les données, l’étape suivante consiste à nettoyer les données
en puisant dans les expressions régulières.
Le principe d’utilisation des expressions régulières (regex) est simple: via
une expression ou métacaractère on recherche dans une chaˆıne de
caractère un modèle ou un pattern, spécifique. Selon les
arguments/fonctions ajoutés à l’expression celle-ci cherchera à :
localiser du texte ce sont les fonctions grep, grepl, regexpr et
gregexpr,
substituer du texte ce sont les fonctions sub et gsub,
découper du texte la fonction strsplit

les principaux métacaractères
[...]: un des caractères indiqués entre les crochets
[ˆ...]: tous les caractères sauf ceux indiqués après le ˆ
[x-y]: les caractères compris entre x à y inclus.
[:alpha:]: a-zA-Z
[:digit:]: 0-9
[:alnum:]: a-zA-Z0-9 et caractères spéciaux
[:lower:]: a-z
[:upper:]: A-Z
[:xdigit:]: 0-9a-fA-FT
[:graph:]: tout caractère graphique
[:print:]: tout caractère affichable
[:punct:]: tout caractère de ponctuation
[:blank:]: espace, tabulation
[:space:]: espace, tabulation, nouvelle ligne, retour chariot
[:cntrl:]: tout caractère de contrôle.

les principaux opérateurs
. :n’importe quel caractère
ˆ: en dehors du ˆ, indique le début du texte
& indique la fin du texte
+: 1 ou plusieurs occurrences du motif qui précède le +
*: 0 ou plusieurs occurrences du motif qui précède le *
?: 0 ou 1 occurrence du motif précédant du ?
n: a-z
x,: x ou plus occurrences du motif qui précède
,y: y occurrences au plus du motif qui précède
x,y: x à y occurrences du motif qui précède

les principales fonctions et leurs syntaxes
Example
#localiser du texte: les fonctions grep, grepl, regexpr et gregexpr
grep(mon_expression_régulière, ma_cha^ıne_de_caractère, value=FALSE)
grep(mon_expression_régulière, ma_cha^ıne_de_caractère, value=TRUE)
grepl(mon_expression_régulière, ma_cha^ıne_de_caractère)
regexpr(mon_expression_régulière, ma_cha^ıne_de_caractère)
gregexp(mon_expression_régulière, ma_cha^ıne_de_caractère)
#substituer du texte: les fonctions sub et gsub
sub(mon_expression_régulière, ma_cha^ıne_de_caractère_a_ajouter_si_true,
ma_cha^ıne_de_caractère)
gsub(mon_expression_régulière, ma_cha^ıne_de_caractère_a_ajouter_si_true,
ma_cha^ıne_de_caractère)
gsub ==>expression vectorisée.....
#substituer du texte: la fonction strsplit
strsplit(ma_cha^ıne_de_caractère, " mon_pattern")

l’aide m´emoire pour les regex

les structures de contrôle ou boucles
Comme les fonctions que nous verrons un peu plus tard, les boucles sont des outils intéressants
qui permettent d’éviter de dupliquer le code. En effet, la duplication est problématique à
différents plans:
génératrice d’erreurs: mauvaise recopie (oubli de caractères, mauvaise indentation, etc....)
obscurcit les programmes: allonge la longueur du code et complexifie la lecture
complexifie les mises à jour: duplication oblige à modifier chaque ligne de code identique,
...
Une boucle comprend trois éléments:
le résultat: structure de données dans laquelle sera stockée le résultat de la boucle
(mon resultat”<-vector(”integer”, length))
la séquence: indique la longueur de l’itération ex: 1: length(mon vecteur) du première
élément au dernier (length(mon vecteur)=n)
l’opération à réaliser ou la fonction à opérer: il s’agit de l’opération que la boucle
effectuera à chaque pas et stockera par la suite (ex: output[[i]]<- median(df[[i]]) donc
output[[1]]<- median(df[[1]]) puis output[[2]] <-median(df[[2]]) et ainsi de suite....
Avant d’introduire les boucles, nous attardons nous sur les opérateurs arithmétiques et logiques
ainsi que les structures de test.

les opérateurs arithmétiques et logiques
x+y: addition
x-y: soustraction
x*y: multiplication
x/y: division
x/y: exposant (** autre écriture)
x %% y: modulo (reste)
x == y: test égalité
x <= y: test inférieur ou égal à
x > = y: test supérieur ou égal à
> : test supérieur
<: test inférieur
!=: test si différent
x||y: ou
&: et
isTRUE(x): test si vrai

les structures de test
Example
#if-then-else
if (condition) expr.si.vrai else expr.si.faux
#if-then-else (forme simplifiée)
if (condition) expr.si.vrai
#ifelse
operation(ifelse(condition, expr.si.vrai, expr.si.faux))
#swith (équivalent à case: choisir d’exécuter un bloc de code en fonction d’un élém
switch(expr,
étiquette-1 = bloc-de-code-1,
étiquette-2 = bloc-de-code-2,
...
...
...)

les boucles dans r
Example
#la boucle while (tant que, alors fait cela)
i <- 1
while (i <= 10) i <- i+4
# la boucle while +break
while(TRUE) {
i <- i+4
if (i > 10) break }
#la boucle repeat+break
i <- 1
repeat {
i <- i+4
if (i > 10) break }
#même résultat pour les trois boucles ci-dessus
i
[1] 13
#la boucle for (pour chaque itération, fait cela)
x<- c(5,12,13)
for (n in x) print(n^2)
[1] 25, 144,169

les fonctions vectorisées
Parmi les utilisateurs de r, une blague circule: if you’ are using a loop in
r, you’re probably doing something wrong”.
En effet, comme souvent avec r, il y a plusieurs solutions pour effectuer
une opération. Comme nous l’avons vu, il est souvent question d’appliquer
une opération par exemple une fonction spécifique à chaque élément d’une
structure de données (liste, ligne d’un dataframe, etc...).
r et certains packages fournissent des fonctions intéressantes pour
permettent d’éviter l’utilisation des boucles. Nous présentons ici
successivement:
: la famille apply() soit lapply(), dapply(), etc...
: le package purr qui permet d’appliquer une fonction à des listes.

la famille apply()
La fonction apply et ses dérivées permettent d’éviter l’utilisation de boucles: elles permettent
d’appliquer des transformations à chaque élément d’une matrice, d’un tableau, d’un dataframe
ou encore d’une liste.
La fonction apply est construite de différents arguments
x: x est un tableau ou une matrice
MARGIN: argument qui spécifie la manière dont va s’appliquer apply:
MARGIN=1, apply s’applique sur les lignes
MARGIN=2, apply s’applique sur les colonnes
FUN: la fonction que l’on veut appliquer.
...: arguments supplémentaires
A partir de la fonction apply, toute une famille de fonction peuvent être appelées:
lapply: s’applique sur les dataframes, listes ou encore vecteurs et renvoie une liste d’où
lapply
sapply: similaire à lapply mais renvoie un résultat simplifié en comparaison de lapply: un
vecteur au lieu d’une liste
mapply: version multidimensionnelle de sapply La différence entre cette fonction et les
fonctions lapply et lapply est qu’elle peut fournir à fonction FUN des arguments
supplémentaires prenant des valeurs qui diffèrent selon les sous-objets
tapply: s’applique sur des facteurs et renvoie une liste
aggregate: s’applique sur un dataframe et applique la fonction séparément pour chaque
colonne du dataframe

les fonctions apply par les exemples
Example
data<-matrix(c(1,2,3,4,5,6), nrow=2)
#naming
colnames(data)=c("C1","C2","C3")
rownames(data)=c("L1","L2")
# la fonction apply() pour faire la somme de chaque ligne
apply(data, 1, sum)
# la fonction apply() pour faire la somme de chaque ligne
en rempla¸cant 1 par 2
apply(data, 2, sum)
x <- lapply(5:8, sample, x = 1:10))
lapply(x, mean)
sapply(x, mean)

le package purr et sa fonction map
Le package purr avec sa fonction map permet d’éviter l’utilisation des boucles. En
fonction de l’output désiré, on utilisera des fonctions différentes:
map(): une liste en sortie
map lgl(): un vector logique (TRUE, FALSE,...)
map int(): un vecteur numérique
map dbl(): un vecteur double
map chr(): une liste de chaines de caractères
Comme la fonction apply, la fonction map est construite à partir de différents
arguments
x: x est structure de stockage sur laquelle on peut appliquer les fonctions
FUN: la fonction que l’on veut appliquer
...: arguments supplémentaires
Enfin, la fonction map possède les déclinaisons: map2, pmap, invoke map qui permettent
d’appliquer finement des fonctions à chaque éléments d’une liste ou d’un vecteur.

l’aide m´emoire pour le package purr

pourquoi ´ecrire une fonction?
r´eponse simple....

la construction d’une fonction dans r
Une fonction est composée obligatoirement de trois éléments
un nom: un nom (un nom explicite de préférence)
un corps/les instructions: les opérations effectuées par la fonction
les arguments: les inputs nécessaires
Example
# structure d’une fonction
le_nom_de_ma_fonction <- function(input_1, input_2, input_3,..) {
le_corps_de_ma_fonction
}
Il est possible d’ajouter d’autres éléments
la vérification: contrôle le type des arguments
la fin de la fonction:la fonction return() permet de s’assurer de la bonne fin de la fonction
l’argument res: spécifie finement la structure de stockage de l’output
Example
# structure développée d’une fonction
le_nom_de_ma_fonction <- function(input_1, input_2, input_3) {
stopifnot(all(is.numeric(input_1),is.numeric(input_2),is.numeric(input_3)))
le_corps_de_ma_fonction
res <- list()
}

Séance 3: représenter les données dans r

Introduction

le choix d’une représentation graphique: un processus
itératif
Figure: adapté de Yau: Data Points: Visualization That Means Something, 2013, Wiley

le choix d’un graphique: un choix...un peu..balis´e

Quelques conseils pour réussir ses graphiques
Avant de nous plonger dans le code, voici quelques conseils basiques en matière de choix de représentation graphique
S’appliquer le process itératif dans la phase de sélection du graphique
Ne pas hésiter à faire des nombreux essais
Adapter les visualisations à mon audience (combattez votre égo !!!!)
Soigner la surcouche (légende, titre des axes, datatips, définition....)
Limiter le nombre de typo, etc...pour ne pas distraire le lecteur
MAIS SURTOUT SOYEZ HONNÊTE AVEC VOS DATAS
De nombreux ouvrages et exemples existent pour aider à la représentation graphique. En dehors de l’univers r (et des classiques
Cleveland, Tufte et Few) voici une liste d’ouvrages basiques et utiles en matière de visualisation des données:
Data Points: Visualization That Means Something, Yau, 2013, Wiley
The Wall Street Journal Guide to Information Graphics, Wong, 2014, Norton
Storytelling with Data: A Data Visualization Guide for Business Professionals, Nussbaumer Knaflic, 2013, Wiley
The functional art: An introduction to information graphics and visualization, Cairo, 2013,Berkeley: New Riders
Good Charts: The HBR Guide to Making Smarter, More Persuasive Data Visualizations, Berinato, 2016, HBR Press
A signaler que ces auteurs ont tous des blogs. Le blog de Nathan Yau http://flowingdata.com/ est souvent cité parmi les blogs
de référence en matière de dataviz. A noter l’excellent dataviz catalogue https://datavizcatalogue.com/

la repr´esentation graphique avec r

La réalisation de graphiques dans r
r possède d’excellentes capacités au niveau de la création graphiques grâce
notamment:
aux fonctionnalités du package de base graphics
à différents packages destinés à la visualisation:
le package ggplot2
le package lattice pour représenter les variables multivariées,
les packages destinés à représenter les réseaux: igraph et ggraph
le package maps pour la cartographie
....
Au fil de cette session, nous verrons dans un premier temps les possibilités
offertes par le package de base graphics. Dans un second temps nous nous
intéressons à ggplot2 qui est probablement le package le plus utilisé dans
l’univers r en matière de représentation graphique.

créer un graphique avec graphics: un process en deux
temps
Quelque soit le choix effectué dans r pour réaliser un graphique, la
réalisation d’un graphique passe par les étapes suivantes:
l’étape de base: la réalisation d’un graphique ”nu”:
j’indique les variables que je veux représenter
j’indique le type de graphique que je veux (barres, camembert, ligne,
heat map, etc....)
l’étape de finition: l’ajout des couches supplémentaires:
modification du thème,
modification des axes (taille, couleur, orientation, font,etc...)
création et/ou modification du titre (taille, couleur, orientation,
font,etc...)
....

La liste des représentations graphiques
Le package graphics permet de représenter de nombreux types de graphiques. En fonction du
type de variables (continues, discrètes, ordonnées, non ordonnées, etc...), il est possible de
choisir parmi cette liste (non exhaustive) de graphiques:
barplot() diagramme en bâton (variable discrête)
boxplot() boite à moustaches (variables continues)
hist(): histogramme (variables continues) #choix les classes
pie(): camembert #barplot plus efficace
plot(): diagramme de dispersion (diagramme de base)
curve(): graphique pour représenter une fonction
sunflowerplot(): diagramme de dispersion sans chevauchement (jitter)
pairs(): matrice de diagramme de dispersion
...

la grammaire de base pour plot
La palette des arguments et de fonctions permettant de modifier l’apparence des graphiques avec plot est large
(https://stat.ethz.ch/R-manual/R-devel/library/graphics/html/00Index.html pour la documentation). La liste ci-dessous intègre
les principaux choix:
x variable en ordonnée
y variable en abscisse
type=“p” trace des points (choix par défaut)
lty=”type de tiret”) choix du type de tiret (de 0 à 6)
lwd=nombre épaisseur du point
pch = nombre type de point (de 0 à 25: chaque
nombre correspond à un type)
col=”ma couleur” choix de couleur
main= ”mon titre” choix du titre
xlab= ”titre axe x” choix titre x
ylab= ”titre axe y” choix titre y
xlim= c(valeur min, valeur max) lim de x (aussi log)
ylim= c(valeur min, valeur max) lim de y
sub=”sous titre” choix du sous titre
col.main=”ma couleur” couleur du titre
col.lab=”ma couleur” couleur titre des axes
col.sub=”ma couleur” couleur du sous titre
font.main=nombre’ font du titre (ex font.main=4)
font.lab font des axes
font.sub font du sous titre
cex.main=nombre taille des font 1 est la référence
cex.lab taille font des axes
cex.sub taille font du sous titre
la fonction title() intègre les paramètres liés au titre
la fonction legend() intègre les paramètres liés à la
légende
la fonction abline() ajoute une droite au graphique
la fonction axis() pour ajouter des axes
la fonction box() pour ajouter un cadre
la fonction texte () pour ajouter des axes
la fonction arrows() pour ajouter des flèches
la fonction grid() pour ajouter une grille
la fonction gridpar() pour changer de manière
permanente les paramètres graphiques

un premier graphique plot
Example
#1 je génère des données
x<-1:10
y1<-x*x
y2=3*y1
#2 un premier graphique
plot(x)

un second graphique
Example
#1 graphique (x,y)+type+taille+couleur+label des axes
plot(x, y1, type="b", pch=19, col="red", xlab=" ", ylab=" ")

mon second graphique avec une troisi`eme variable
Example
#1 graphique (x,y1)+type+taille+couleur+label des axes
#2 graphique (x,y2)+type+taille+couleur+choix des tirets
lines(x, y2, pch=18, col="blue", type="b", lty=2)

mon second graphique optimis´e
Example
#3 ajout d’un titre+param`etres du titre
title(main = "Mon titre", sub = "Mon sous titre",
xlab = "Le titre de mon axe des x", ylab = "Le titre de mon axe des y",
cex.main = 2, font.main= 4, col.main= "black", cex.sub = 0.75,
font.sub = 3, col.sub = "black", col.lab ="darkblue")

mon second graphique encore...plus optimisé
Example
#3 ajout d’un bloc titre+paramètres du titre
title(main = "Mon titre", sub = "Mon sous titre",
xlab = "Le titre de mon axe des x", ylab = "Le titre de mon axe des y",
cex.main = 2, font.main= 4, col.main= "black", cex.sub = 0.75,
font.sub = 3, col.sub = "black", col.lab ="darkblue")
#4 ajout d’un bloc légende+paramètres de la légende
legend(list(x = 1,y = 80), legend=c("Line 1", "Line 2"),
col=c("red", "blue"), lty=1:2, cex=0.8)

mon second graphique optimisé avec des lignes
Example
#5 ajout de ligne (hypothèse modèle linéaire)
abline(lsfit(x,y1),col="red")
abline(lsfit(x,y2),col="blue")
#6 ajout de ligne (hypothèse modèle linéaire+ avancé)
abline(lm(x,y1),col="red") #
abline(lm(x,y2),col="blue")
#7 régression non paramétrique
lines(lowess(x,y1),col="red4")
lines(lowess(x,y2),col="blue4")

exemple de graphique barplot
Les représentations diagramme en bâton ou barplot() et les histogrammes ou hist() sont
souvent confondues....alors qu’elles s’appliquent à des données différentes:
variables discrètes: barplot (taille des barres = valeur de la catégorie)
variables continues: histogramme (taille des barres = effectif dans l’intervalle)
A noter que le choix automatique de l’intervalle pour illustrer la répartition des valeurs
n’est pas toujours satisfaisant.
Example
valeurs<-sample(1:100, 5, replace=F)
names(valeurs)<-c("cat_a","cat_b","cat_c","cat_d","cat_e")
barplot(effectifs)

mon second graphique optimisé
Example
#3 j’ajoute des éléments
barplot(valeurs, col=c(1,2,7,0,8), border="black", xlab="mes_categories",
ylab="mes_valeurs", main="mon_histogramme")

mon second graphique modifié
Example
#4 je modifie l’orientation du graphique et les graduations
avec les paramètres: horiz=T et las=1
barplot(valeurs, col=c(1,2,7,0,8),border="black", xlab="mes_categories",
ylab="mes_valeurs", main="mon_histogramme", horiz=T , las=1)

exemple de graphique histogramme
Un histogramme avec graphics se construit avec la fonction hist(). r choisit automatiquement la
taille de l’intervalle de base.
Example
count<- sample(1:100, 100, replace=T)
dataframe_hist<-as.data.frame (count)
hist(dataframe_hist$count)

mon histogramme optimisé
r via un algorithme (il existe différents algo.) choisit la largeur de l’intervalle de base.
L’utilisateur a le loisir de choisir son intervalle ”manuellement” via la fonction breaks:
breaks=seq(min(x), max(x), length=xx), include.lowest=TRUE
Example
hist(dataframe_hist$count,breaks=seq(0,12000,500),include.lowest=TRUE,col="grey",
main="mon_histogramme",xlab="mes_trajets", ylab="fréquence")

mon histogramme encore plus optimis´e
j’ajoute via la fonction abline() deux lignes calculant la m´ediane et la moyenne.
Example
hist(dataframe_hist$count,breaks=seq(0,12000,500),include.lowest=TRUE,col="grey",
main="mon_histogramme",xlab="mes_trajets", ylab="fr~A c quence")
abline(v=c(mean(dataframe_hist$count),median(dataframe_hist$count)),lty=c(2,3),lwd=2

mon histogramme encore encore plus optimis´e
j’ajoute la l´egende
Example
legend("topright",legend=c("mean km","median km"),lty=c(2,3),lwd=2)

un pie chart
Un pie chart avec graphics se construit avec la fonction pie(). la documentation pour ce graphique se trouve ici:
https://stat.ethz.ch/R-manual/R-devel/library/graphics/html/pie.html.
A noter cette note dans la documentation: Pie charts are a very bad way of displaying information. The eye is good at judging
linear measures and bad at judging relative areas. A bar chart or dot chart is a preferable way of displaying this type of data.
Example
pie(effectifs, abels = names(x), edges = 200, radius = 0.8,
density = NULL, angle = 45, col = "grey", border = "white",
lty = 2, main = "mon_titre", sub = "Mon sous titre",
cex.main = 2, font.main= 2)

un box plot
Un box plot avec graphics se construit avec la fonction boxplot(). cette graphique permet de visualiser la répartition des valeurs
au sein de la boite (premier quartile, troisième quartile et médiane) et à l’extérieur de la boite les fameuses moustaches dont la
longueur équivalaut à 1.5 fois l’espace interquartile (la distance entre le 1er et le 3ème quartile)
Example
boxplot(dataframe_hist$count, main="ma_boite",
xlab="mes_données", ylab="mes_valeurs", col="darkgreen")

extraire, transformer et représenter des données dans r

extraire, transformer et représenter des données dans r

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à extraire, transformer et représenter des données dans r

Similaire à extraire, transformer et représenter des données dans r (20)

Dernier

Dernier (6)

extraire, transformer et représenter des données dans r