Visualisation de données avec R

Multiples graphiques

Si on veut avoir, par exemple, toutes les informations utiles pour une variable quantitative, il est nécessaire d’avoir a minima un histogramme et une boîte à moustache, mais on peut aussi vouloir un \(qq\)-plot. Ceci permet d’introduire les commandes par(mfrow=) (ou mfcol) et layout().

par(mfrow = c(2, 3))
for (i in 1:6) {
    plot.new()
    rect(0, 0, 1, 1)
    text(.5, .5, i, cex = 2)
}

par(mfcol = c(2, 3))
for (i in 1:6) {
    plot.new()
    rect(0, 0, 1, 1)
    text(.5, .5, i, cex = 2)
}

mat = matrix(c(1, 2, 1, 3), 2, 2)
print(mat)

##      [,1] [,2]
## [1,]    1    1
## [2,]    2    3

layout(mat)
for (i in 1:3) {
    plot.new()
    rect(0, 0, 1, 1)
    text(.5, .5, i, cex = 2)
}

mat = matrix(c(4, 3, 3, 1, 2, 2, 1, 2, 2), 3, 3)
print(mat)

##      [,1] [,2] [,3]
## [1,]    4    1    1
## [2,]    3    2    2
## [3,]    3    2    2

layout(mat)
par(mar = c(2, 2, 2, 0)+.1)
hist(co2, main = "co2")
plot(co2)
boxplot(co2, axes = FALSE)
qqnorm(co2, main = "");qqline(co2)

Amélioration de graphique

Voici ici un exemple de graphique personnalisé, représentant 4 variables (trois quantitatives et une qualitative), ainsi qu’une explication succinte des différentes fonctions utilisées, et quelques paramètres de celles-ci.

par(family = "serif", mar = c(5, 4, 2, 0)+.1)
couleurs_am = brewer.pal(3, "Dark2")
plot(mpg ~ hp, data = mtcars,
     pch = 19,
     cex = wt/3,
     col = couleurs_am[mtcars$am+1],
     main = "Consommation et autres",
     sub = "Source : 1974 Motor Trend US magazine", font.sub = 3, cex.sub = .8,
     xlab = "Puissance (en ch)",
     ylab = "Consommation en Miles/Galon",
     bty = "n", axes = FALSE)
axis(1, lwd = 0, lwd.ticks = .5)
at.y = axis(2, lwd = 0, lwd.ticks = .5, labels = FALSE)
text(y = at.y, x = 35, labels = at.y, srt = 0, pos = 2, xpd = TRUE)
l1 = legend("topright", legend = c("Automatique", "Manuelle"), 
       col = couleurs_am, bty = "n", cex = .8, pch = 19,
       text.width = 50, text.col = couleurs_am, 
       title = "Boîte de vitesse", title.col = "black")
legend(l1$rect$left, l1$rect$top-l1$rect$h-1, 
       legend = range(mtcars$wt), title = "Poids  (1000 lbs)",
       pch = 19, pt.cex = range(mtcars$wt)/3, bty = "n", cex = .8, col = gray(.5),
       text.width = 50, adj = -.25)
outliers_hp = subset(mtcars, subset = hp > 250)
text(outliers_hp$hp, outliers_hp$mpg, row.names(outliers_hp), pos = c(3, 2), cex = .8, font = 4)
outliers_mpg = subset(mtcars, subset = mpg > 30)
text(outliers_mpg$hp, outliers_mpg$mpg, row.names(outliers_mpg), pos = 4, cex = .8, font = 4)

• La fonction par() permet de modifier les paramètres graphiques, tel que :
  • mar pour les marges
  • family pour la famille de police d’écriture
  • certains paramètres ci-après sont définissables globalement dans la fonction par(), ou localement dans les fonctions suivantes
• Les paramètres de la fonction plot()
  • pch : symbole utilisé pour chaque point (ici 19 indique un rond plein)
  • cex : taille du point (ici en fonction de la variable wt)
  • col : couleur des points (ici en fonction de la variable am)
  • main, sub, xlab, ylab : resp. titre, sous-titre, intitulé en abcisse et intitulé en ordonnée
  • *.sub : indication spécifique pour le sous-titre
  • bty : type de la boîte (ici n veut dire rien autour du graphique)
  • axes : présence ou non des axes (non ici)
• La fonction axis() qui permet d’ajouter un axe (1 : en abcisse, et 2 : en ordonnée)
  • si rien d’indiqué pour at, utilisation des ticks par défaut
  • lwd : largeur de la ligne (ici non-présente)
  • lwd.ticks : largeur des ticks (asse fine ici)
  • renvoie les valeurs des ticks
• La fonction text() permet d’écrire du texte sur le graphique
  • le x = 35 est choisi par expérience
  • srt : angle du texte
  • pos : ajustement du texte par rapport aux coordonnées indiquées
  • xpd : permet d’écrire en dehors du graphique (dans les marges donc)
• La fonction legend() permet d’ajouter une légende
  • position : soit \((x,y)\), soit chaîne spécifique
  • legend : texte des items
  • col, bty, cex, pch : identique à précédemment
  • text.width et text.col : largeur du texte des items et couleur(s)
  • title et title.col : titre de la légende (et couleur du titre)
  • renvoie une liste avec deux objets (rect qui contient des infos sur le rectangle occupé par la légende dans le graphique et text qui contient les coordonnées du texte des items)
  • pt.cex : taille des symboles
  • adj: ajustement du texte

Fonction ggplot()

La fonction ggplot() permet de faire plus de choses que qplot() mais nécessite un formalisme plus lourd, dont voici quelques détails :

• ggplot() créé un graphique (et le renvoie, i.e. on peut stocker un graphique dans une variable pour l’afficher plus tard, éventuellement en lui ajoutant des couches)
• aes() permet de définir les aspects esthétiques (x et y principalement, mais aussi color, fill, size, …)
• geom_xxx() indique la représentation à choisir (xxx étant remplacé par histogram, boxplot, …)
• stat_xxx() indique les transformations statistiques à utiliser, si besoin
• scale_xxx() s’emploie pour des changements d’échelle
• coord_xxx() s’utilise pour des modifications de systèmes de coordonnées
• facet_grid() découpe les données (et donc le graphique) en plusieurs facettes selon les variables fournie dans la formule
• theme_xxx(), labs(), xlab(), ylab(), ggtitle(), … pour des améliorations du graphique (annotation, couleurs, …)

Hormis la fonction aes(), qui s’utilise à l’intérieur des autres, toutes ces fonctions peuvent s’additionner pour compléter le graphique. Voici un exemple de suite de commandes pour produire un graphique :

# Récupération des moyennes et des écarts-type de Sepal.Length pour chaque espèce
iris.mean = data.frame(
    Species = levels(iris$Species),
    mean = tapply(iris$Sepal.Length, iris$Species, mean),
    sd = tapply(iris$Sepal.Length, iris$Species, sd)
)
ggplot(data = iris, aes(y = Sepal.Length, x = Species)) + geom_boxplot() +
    geom_jitter() +
    geom_errorbar(data = iris.mean, 
                  aes(y = mean, ymin = mean - sd, ymax = mean + sd), 
                  col = "red", width = .4)

Dans le code précédent, vous pouvez remarquer que \(x\) n’est défini qu’une seule fois, dans le ggplot(). Cette spécification est conservée pour les fonctions ajoutées, et donc pour geom_errorbar().

Pour détailler ce comportement, voici trois commandes permettant de faire strictement le même graphique (le premier produit dans le paragraphe ci-dessous).

ggplot(mtcars, aes(x = mpg)) + geom_histogram()
ggplot(mtcars) + geom_histogram(aes(x = mpg))
ggplot() + geom_histogram(data = mtcars, aes(x = mpg))

Voici ce qui diffère entre ces trois versions :

• Dans la première, les données seront mtcars pour l’ensemble des commandes ajoutées, et \(x\) sera la variable mpg (sauf spécification ultérieure)
• Dans la seconde, on utilisera toujours mtcars comme données, mais \(x\) n’est défini que pour l’histogramme. On devra définir \(x\) pour les fonctions ultérieures si besoin
• Dans la dernière, il n’y aucune spécification de base, et chaque fonction devra déterminée quelles données prendre, ainsi que les aspects esthétiques à utiliser dans celles-ci.

ggplot(mtcars, aes(x = mpg)) + geom_histogram()

ggplot(mtcars, aes(x = mpg)) + geom_histogram(binwidth = 2)

ggplot(mtcars, aes(x = mpg)) + geom_histogram(bins = 10)

ggplot(mtcars, aes(x = mpg)) + geom_histogram(breaks = c(10,12.5,15,18,25,35))

ggplot(mtcars, aes(x = mpg)) + 
    geom_histogram(aes(y = ..density..), breaks = c(10,12.5,15,18,25,35))

ggplot(mtcars, aes(x = mpg)) + 
    geom_histogram(aes(y = ..density..), binwidth = 2) +
    geom_density()

ggplot(mtcars, aes(y = mpg, x = "")) + geom_boxplot()

ggplot(mtcars, aes(sample = mpg)) + geom_qq()

ggplot(mtcars, aes(x = am)) + geom_bar()

ggplot(mtcars, aes(x = factor(am))) + geom_bar()

ggplot(mtcars, aes(x = factor(am))) +  
    geom_bar(aes(y = (..count..)/sum(..count..))) +
    scale_y_continuous(labels = percent) +
    ylab("")

ggplot(mtcars, aes("", fill = factor(am))) + 
    geom_bar(aes(y = (..count..)/sum(..count..))) +
    scale_y_continuous(labels = percent) +
    ylab("") + xlab("") + labs(fill = "am") +
    theme(axis.ticks = element_blank())

ggplot(mtcars, aes("", fill = factor(am))) + 
    geom_bar(aes(y = (..count..)/sum(..count..)), width = 1) +
    scale_y_continuous(labels = percent) +
    ylab("") + xlab("") + labs(fill = "am") +
    theme(axis.ticks = element_blank()) + 
    coord_polar(theta = "y") 

ggplot(mtcars, aes(hp, mpg)) + geom_point() +
    geom_rug() +
    geom_smooth(method = "lm")

ggplot(mtcars, aes(hp, mpg)) + geom_bin2d()

ggplot(mtcars, aes(hp, mpg)) + geom_bin2d(bins = 10)

ggplot(mtcars, aes(factor(am))) + geom_bar() + facet_grid( ~ cyl)

ggplot(mtcars, aes(factor(am), fill = factor(cyl))) + geom_bar() 

ggplot(mtcars, aes(factor(am), fill = factor(cyl))) + 
    geom_bar(position = "fill") +
    scale_y_continuous(labels = percent) + 
    xlab("am") + ylab("") + labs(fill = "cyl")

ggplot(mtcars, aes(0, fill = factor(cyl))) + 
    geom_bar(position = "fill") +
    scale_y_continuous(labels = percent) + 
    xlab("am") + ylab("") + labs(fill = "cyl") +
    coord_polar(theta = "y") +
    facet_wrap(~ factor(am))

ggplot(mtcars, aes(factor(cyl), factor(am))) + geom_bin2d()

ggplot(mtcars, aes(mpg)) + geom_histogram(bins = 10) +
    facet_grid(am ~ .)

ggplot(mtcars, aes(mpg, col = factor(am))) +
    geom_density()

ggplot(mtcars, aes(factor(am), mpg, fill = factor(am))) +
    geom_boxplot()

ggplot(mtcars, aes(factor(am), mpg)) + 
    geom_jitter()

ggplot(mtcars, aes(factor(am), mpg)) + 
    geom_boxplot() +
    geom_jitter()

nom = rownames(mtcars)
nom[mtcars$hp <= 250 & mtcars$mpg <= 30] = ""
ggplot(mtcars, aes(x = hp, y = mpg, 
                   color = factor(am, labels = c("Automatique", "Manuelle")), 
                   size = wt, 
                   label = nom)) + 
    geom_point() + 
    geom_text(size = 3, color = "black", vjust = -.75, fontface = "bold") +
    ggtitle("Consommation et autres") +
    xlab("Puissance (en ch)") + xlim(25, 350) +
    ylab("Consommation en Miles/Galon") +
    labs(color = "Transmission", size = "Poids (1000 lbs)") 

Quelques exemples complémentaires

Ce sont des exemples plus ou moins simple de créations de graphiques.

par(mfrow = c(2, 2), mar = c(2, 2, 2, 0) + .1)
for (i in 1:4) {
    boxplot(iris[,i] ~ iris$Species, main = names(iris)[i])
}

ggplot(melt(iris, id.vars = "Species"), aes(Species, value)) + 
    geom_boxplot() + facet_grid( ~ variable)

DT::datatable(anscombe, options = list(searching = F, ordering = F, paging = F))

par(mfrow = c(2, 2), mar = c(2, 2, 0, 0)+.1)
f <- function(df) {
    names(df) = c("x", "y")
    m = lm(y ~ x, data = df)
    plot(y ~ x, data = df, pch = 19, bty = "n", 
         xlim = range(anscombe[,1:4]),
         ylim = range(anscombe[,5:8]))
    abline(m, col = "red")
}
for (i in 1:4) {
    f(anscombe[,paste(c("x", "y"), i, sep = "")])
}

ans = transform(
    cbind(
        melt(subset(anscombe, select = c(x1, x2, x3, x4)), 
             variable.name = "coordx", value.name = "x"),
        melt(subset(anscombe, select = c(y1, y2, y3, y4)), 
             variable.name = "coordy", value.name = "y")
    ),
    num = substr(coordx, 2, 2)
)
ggplot(ans, aes(x, y)) + geom_point() + 
    facet_wrap(~ num) + 
    geom_smooth(method = "lm", se = FALSE, fullrange = T)

Applications

Nous allons utiliser les données tips du package reshape2.

1. Comment répondre aux questions suivantes :

1. Les pourboires (tip) dépendent ils du montant (total_bill)
2. Et des jours de la semaine (day) ?
3. Et du nombre de convives (party) ?
4. Croiser tip en fonction de total_bill et party

1. Représenter total_bill en fonction de sex et smoker.
2. Toujours dans tips, représenter total_bill et tip, en fonction de sex de 2 façons
3. Idem avec smoker en plus

Avec la librairie leaflet

La librairie leaflet permet de créer des cartes dans R à partir de la librairie Javascript Leaflet.

Voici un premier exemple simple de création de carte du monde

m = leaflet() %>% addTiles()
m

Pour laquelle il est possible de choisir la zone d’intêrêt, en indiquant les latitudes et longitudes min et max.

m %>% fitBounds(0, 40, 5, 50)

Il est aussi possible de préciser les coordonnées géographiques du centre de la carte, ainsi que le niveau de zoom (entre 1 - monde - et 18 - pâté de maison).

m = m %>% setView(2.268224, 48.842275, zoom = 17)
m

On peut y ajouter une pop-up assez facilement.

m %>% addPopups(2.268224, 48.842275, "IUT Paris Descartes")

Ou un marqueur, pour lequel le texte s’affichera lorsque nous cliquerons sur le marqueur.

m %>% addMarkers(2.268224, 48.842275, popup = "IUT Paris Descartes")

Voire des formes classiques (cercle, rectangle, polygone)

m %>% addCircles(2.268224, 48.842275, radius = 100) %>% 
    addRectangles(2.27, 48.835, 2.28, 48.84)

A partir du jeu de données ozone du package maps, et contenant des informations géogrpahiques, nous allons représenter ces informations sur une carte.

DT::datatable(head(ozone))

Ici, nous faisons en sorte que la taille des cercles soient dépendantes de la variable median, mais nous devons ajuster à la main pour avoir des valeurs intéressantes pour la représentation.

leaflet(ozone) %>% addTiles() %>% 
    addCircles(lng = ~x, lat = ~y, radius = ~median*100)

Avec la librairie ggmap

La librairie ggmap a pour but de simplifier la cartographie, à l’aide de carte provenant de Google Maps, OpenStreetMap ou autre au choix, en y ajoutant la possibilité de rajouter des couches avec ggplot2.

Pour cela, il faut faire deux opérations :

• la première pour récupérer les tuiles de représentation des cartes (avec get_map())
• la seconde pour afficher ces tuiles (avec ggmap()), ce qui créé un objet

m = get_map("Paris,France")
ggmap(m) 

La fonction qmplot() permet de rendre invisible l’étape de récupération des tuiles, et est l’équivalent de qplot par rapport à ggmap().

qmplot(x, y, data = ozone, color = median)

On peut aussi vouloir spécifier nous-même les différentes étapes, comme ci-dessous :

• récupération des tuiles de la carte, en spécifiant les limites de la zone
• affichage de la carte et ajout des représentations géographiques comme avec ggplot() vu précédemment.

left = min(ozone$x) - .5
bottom = min(ozone$y) - .5
right = max(ozone$x) + .5
top = max(ozone$y) + .5
m = get_map(location = c(left, bottom, right, top), 
            maptype = "toner-lite", color = "bw")
ggmap(m) + geom_point(data = ozone, aes(x, y, color = median))

Applications

En utilisant les données crime du package ggmap, comment représenter le nombre et les types de crime par rapport à leur localisation ?

Introduction

Nous disposons de données d’AirBnB pour Paris à la date du 2 septembre 2015 ( données source ). Celles-ci ont été légèremment nettoyées et réduites pour obtenir les fichiers suivants :

On commence déjà par importer ces données dans R.

airbnb.summ = read.table("donnees/airBnB-2015-09-02/airbnb-paris-2015-09-02-summary.csv", 
                         sep = ",", header = T, 
                         quote = "\"", comment.char = "")
airbnb.comp = read.table("donnees/airBnB-2015-09-02/airbnb-paris-2015-09-02.csv", 
                         sep = ",", header = T, 
                         quote = "\"", comment.char = "")

Sur ces données, il est déjà possible de représenter chaque logement par un point, assez simplement

ggplot(airbnb.summ, aes(x=longitude, y=latitude)) + geom_point()

La librairie geojsonio permet de lire et d’écrire des données au format GeoJSON, permettant de réprésenter des objets géoraphiques dans un formalisme issue de JSON. Il est très utilisé pour représenter des zones, telles que des villes, des pays, …

On importe donc les données des arrondissements. La fonction fortify() de ggplot2 nous permet ici de passer à un format lisible pour ggplot().

airbnb.neigh = geojson_read("donnees/airBnB-2015-09-02/airbnb-paris-2015-09-02-neighbourhoods.geojson", what = "sp")
airbnb.neigh.for = fortify(airbnb.neigh)
ggplot(airbnb.neigh.for, aes(long, lat, group=group)) +
    geom_polygon()  + theme_void()

Le problème dans notre cas est que les quartiers ne sont pas classés dans un ordre spécifique dans les données, et que l’objet airbnb.neigh ne comporte plus le nom du quartier, ce qui va nous empêcher de faire le lien avec les autres données. Le code suivant permet donc de récupérer l’ordre des quartiers et de le stocker dans un data.frame. On lit différement le jeu de données.

airbnb.neigh.ord = data.frame(
    id = as.character(0:19),
    neighbourhood = unlist(lapply(geojson_read("donnees/airBnB-2015-09-02/airbnb-paris-2015-09-02-neighbourhoods.geojson")$features, function(f) return(f$properties$neighbourhood)))
)
airbnb.neigh.ord

##    id       neighbourhood
## 1   0 Batignolles-Monceau
## 2   1      Palais-Bourbon
## 3   2     Buttes-Chaumont
## 4   3               Opéra
## 5   4            Entrepôt
## 6   5            Gobelins
## 7   6           Vaugirard
## 8   7             Reuilly
## 9   8              Louvre
## 10  9          Luxembourg
## 11 10              Élysée
## 12 11              Temple
## 13 12        Ménilmontant
## 14 13            Panthéon
## 15 14               Passy
## 16 15        Observatoire
## 17 16          Popincourt
## 18 17              Bourse
## 19 18   Buttes-Montmartre
## 20 19      Hôtel-de-Ville

Il peut être intéressant de calculer le centre de chaque quartier, pour pouvoir l’ajouter sur la carte par la suite. Pour cela, nous prenons la moyenne entre la latitude (et resp. la longitude) minimale et maximale.

airbnb.neigh.cen = merge(airbnb.neigh.ord, 
                         aggregate(cbind(long, lat) ~ id, airbnb.neigh.for,
                                   function (c) return(mean(range(c))))
                         )
ggplot(airbnb.neigh.for, aes(long, lat, group=group)) +
    geom_polygon(fill = "gray70", color = "gray50") +
    geom_text(data = airbnb.neigh.cen, aes(label = neighbourhood, group=id)) + theme_void()

Au final, on peut faire une carte des arrondissements, en y ajoutant le nom du voisinage, les points des logements et une couleur pour chaque arrondissement dépendant de la variable group par exemple (on pourra utiliser ce schéma pour représenter des informations statistiques par exemple)

ggplot(airbnb.neigh.for) +
    geom_polygon(aes(long, lat, group=group, fill=id), color="gray50") +
    geom_point(data=airbnb.summ, aes(longitude, latitude), col="gray30", alpha=.5) +
    geom_text(data=airbnb.neigh.cen, aes(long, lat, label=neighbourhood, group=id)) + 
    theme_void() + theme(legend.position="none")

Questions

1. Représenter les logements sur la carte de Paris
2. Représenter les quartiers sur la carte de Paris
3. Représenter ces deux informations sur la carte de Paris, avec pour la première
   • soit du point par point
   • soit avec une heatmap
4. Représenter le nombre de logements par quartier
5. Idem pour le prix moyen