Graphiques lattice en R : panneaux et conditionnement

Un tour d’horizon concis de lattice (Trellis) — l’interface par formule, les principaux types de graphiques et le conditionnement multi-panneaux avec y ~ x | group

Un tour d’horizon pratique du paquet lattice en R — le système de graphiques Trellis bâti sur une interface par formule. Couvre les principales fonctions haut niveau (xyplot, bwplot, histogram, densityplot, cloud), le regroupement avec groups= et la fonctionnalité signature de lattice : le conditionnement multi-panneaux compact avec la formule y ~ x | g. Chaque graphique est produit à partir de vrai code R prêt à copier-coller, avec des données intégrées.

AstuceCe que vous trouverez ici

• Ce qu’est lattice (le système graphique Trellis), et son interface par formule — ce qui le distingue.
• Les principales fonctions haut niveau — xyplot(), bwplot(), dotplot(), stripplot(), histogram(), densityplot(), cloud() — chacune avec un exemple exécutable.
• La signature de lattice : le conditionnement multi-panneaux avec y ~ x | group — un petit graphique par sous-groupe, sur des échelles partagées, en un seul appel.
• Quand choisir lattice plutôt que les graphiques de base ou ggplot2 — et vers quoi se tourner ensuite.
• Chaque graphique est produit à partir de vrai code R prêt à copier-coller avec des données intégrées ; il vous suffit de lattice, livré avec R.

Lattice est l’implémentation R des graphiques Trellis — un système de visualisation de données dont toute la conception repose sur une seule idée : découper vos données en sous-groupes et tracer le même graphique pour chacun, sur des échelles partagées, afin que les panneaux soient directement comparables. C’est un paquet recommandé de base R (livré avec chaque installation de R, sans téléchargement séparé), écrit par Deepayan Sarkar, et il précède ggplot2 comme système de référence pour les « small multiples » multi-panneaux.

On croise encore lattice dans la nature — anciens tutoriels, le monde des modèles mixtes (les graphiques de diagnostic de lme4 sont en lattice), et l’ouvrage de Sarkar Lattice: Multivariate Data Visualization with R. Ce billet est une orientation rapide : ce qu’est lattice, ses principaux types de graphiques, et la fonctionnalité de conditionnement qui reste vraiment élégante. Pour tout nouveau travail, les choix modernes par défaut sont ggplot2 et les graphiques de base — nous établissons un lien vers les deux à la fin.

L’interface par formule

Chaque fonction lattice prend une formule et un data frame, et non des vecteurs bruts. Cette formule est tout le langage :

• y ~ x — tracer y en fonction de x (un nuage de points, une boîte à moustaches, …).
• ~ x — une seule variable (un histogramme ou une densité).
• z ~ x * y — une surface ou un nuage 3D.
• y ~ x | g — le geste emblématique : tracer y ~ x une fois par niveau de g, chacun dans son propre panneau, sur des axes partagés. Le | se lit « conditionné à ».

Deux arguments reviennent dans chaque fonction :

• groups = — superposer les sous-groupes dans le même panneau (couleur par groupe).
• auto.key = TRUE — dessiner une légende (lattice l’appelle une key) automatiquement à partir de groups.

Chargez le paquet — pas besoin de install.packages(), il est déjà là :

library(lattice)

Les principales fonctions haut niveau

Chaque nom de fonction dit ce qu’elle trace. Voici la carte de référence :

Fonction	Graphique
xyplot()	Nuage de points / série temporelle
splom()	Matrice de nuages de points
bwplot()	Boîte à moustaches
dotplot()	Graphique de points (Cleveland)
stripplot()	Strip plot (nuage 1-D)
barchart()	Diagramme en barres
histogram()	Histogramme
densityplot()	Graphique de densité par noyau
qqmath()	Graphique quantile théorique (Q-Q)
qq()	Graphique quantile à deux échantillons
cloud()	Nuage de points 3D
wireframe()	Surface 3D
levelplot()	Graphique de niveaux en fausses couleurs
contourplot()	Graphique de contours d’une surface
parallel()	Graphique en coordonnées parallèles

Elles partagent toutes la même grammaire (formule + data + groups + conditionnement), donc une fois que vous connaissez xyplot() vous savez lire les autres. Quelques extras (ecdfplot(), mapplot()) vivent dans le paquet compagnon latticeExtra.

xyplot() : nuages de points

xyplot(y ~ x, data) est la fonction de base. La voici sur les données intégrées iris (150 fleurs, trois espèces). On règle la couleur des points sur l’azur de la marque et un symbole plein avec par.settings = simpleTheme(...), le raccourci de lattice pour styliser symboles et lignes :

library(lattice)

xyplot(Sepal.Length ~ Petal.Length, data = iris,
       par.settings = simpleTheme(col = "#3a86d4", pch = 19),
       xlab = "Petal length (cm)", ylab = "Sepal length (cm)")

Pour colorer les points par groupe dans le même panneau, ajoutez groups = Species et auto.key = TRUE pour la légende. Une palette de trois couleurs adaptée au daltonisme (l’azur de la marque + deux couleurs Okabe–Ito) passe par simpleTheme() :

library(lattice)

pal <- c("#3a86d4", "#E69F00", "#009E73")

xyplot(Sepal.Length ~ Petal.Length, groups = Species, data = iris,
       par.settings = simpleTheme(col = pal, pch = 19),
       auto.key = list(columns = 3),
       xlab = "Petal length (cm)", ylab = "Sepal length (cm)")

L’argument type = contrôle ce qui est tracé — et vous pouvez en combiner plusieurs. type = c("p", "g", "smooth") superpose des points, une grille de référence et une courbe de lissage LOESS (smooth) en un seul appel :

library(lattice)

xyplot(Sepal.Length ~ Petal.Length, data = iris,
       type = c("p", "g", "smooth"),
       par.settings = simpleTheme(col = "#3a86d4", pch = 19),
       xlab = "Petal length (cm)", ylab = "Sepal length (cm)")

Conditionnement : un panneau par sous-groupe

C’est la fonctionnalité qui définit lattice. Ajoutez | Species à la formule et lattice trace le nuage une fois par espèce, chacun dans son propre panneau, sur des échelles partagées — l’idée des « small multiples », en un seul appel et sans mise en page manuelle :

library(lattice)

pal <- c("#3a86d4", "#E69F00", "#009E73")

xyplot(Sepal.Length ~ Petal.Length | Species, groups = Species, data = iris,
       type = c("p", "smooth"),
       par.settings = simpleTheme(col = pal, pch = 19),
       xlab = "Petal length (cm)", ylab = "Sepal length (cm)")

Chaque panneau est directement comparable parce que les axes sont partagés. Cette même syntaxe | g fonctionne sur toutes les fonctions lattice — une boîte à moustaches par groupe, un histogramme par groupe, et ainsi de suite. C’est la raison pour laquelle lattice mérite encore sa place : des figures multi-panneaux compactes et comparables avec presque aucun code.

bwplot(), dotplot(), stripplot() : distributions par catégorie

Pour un prédicteur catégoriel, bwplot() trace des boîtes à moustaches, dotplot() des graphiques de points de Cleveland, et stripplot() un nuage 1-D avec gigue. On utilise ToothGrowth (longueur des dents selon la dose de vitamine C), en transformant d’abord dose en facteur :

library(lattice)
ToothGrowth$dose <- as.factor(ToothGrowth$dose)

bwplot(len ~ dose, data = ToothGrowth,
       par.settings = simpleTheme(col = "#3a86d4"),
       xlab = "Dose (mg/day)", ylab = "Tooth length")

Changez de fonction pour changer l’affichage — même formule, mêmes données. Un strip plot montre chaque observation brute (utilisez jitter.data = TRUE pour que les points ne se chevauchent pas) :

library(lattice)
ToothGrowth$dose <- as.factor(ToothGrowth$dose)

stripplot(len ~ dose, data = ToothGrowth,
          jitter.data = TRUE, pch = 19,
          par.settings = simpleTheme(col = "#3a86d4"),
          xlab = "Dose (mg/day)", ylab = "Tooth length")

Voici maintenant le bénéfice du conditionnement sur des données réelles. len ~ supp | dose trace une boîte à moustaches de la longueur par type de supplément (OJ vs VC), dans un panneau par dose — layout = c(3, 1) dispose les trois panneaux sur une même ligne :

library(lattice)
ToothGrowth$dose <- as.factor(ToothGrowth$dose)

bwplot(len ~ supp | dose, data = ToothGrowth,
       layout = c(3, 1),
       par.settings = simpleTheme(col = "#3a86d4"),
       xlab = "Supplement", ylab = "Tooth length")

D’un coup d’œil, vous pouvez comparer OJ vs VC au sein de chaque dose et d’une dose à l’autre — trois panneaux, une formule.

histogram() et densityplot() : distributions simples

Pour une seule variable, supprimez le côté gauche de la formule : ~ x. histogram() regroupe les valeurs en classes (en affichant le pourcentage du total par défaut) ; densityplot() montre une estimation par noyau lissée. Commençons par l’histogramme — nint fixe le nombre de classes :

library(lattice)

histogram(~ len, data = ToothGrowth, nint = 12,
          par.settings = simpleTheme(col = "#3a86d4"),
          xlab = "Tooth length", ylab = "Percent of total")

Pour la forme lissée, densityplot() ; plot.points = FALSE masque le tapis de points bruts sous la courbe :

library(lattice)

densityplot(~ len, data = ToothGrowth, plot.points = FALSE,
            par.settings = simpleTheme(col = "#3a86d4", lwd = 2),
            xlab = "Tooth length", ylab = "Density")

Ajoutez groups = pour superposer une densité par sous-groupe dans le même panneau — ici une courbe par dose :

library(lattice)
ToothGrowth$dose <- as.factor(ToothGrowth$dose)
pal <- c("#3a86d4", "#E69F00", "#009E73")

densityplot(~ len, groups = dose, data = ToothGrowth, plot.points = FALSE,
            par.settings = simpleTheme(col = pal, lwd = 2),
            auto.key = list(columns = 3, title = "Dose"),
            xlab = "Tooth length", ylab = "Density")

cloud() : nuages de points 3D

cloud(z ~ x * y, data) trace un nuage de points 3D. Le * dans la formule associe les deux axes horizontaux ; z est la hauteur. Ici, la longueur des pétales en fonction des deux mesures de sépales, colorée par espèce :

library(lattice)
pal <- c("#3a86d4", "#E69F00", "#009E73")

cloud(Petal.Length ~ Sepal.Length * Sepal.Width, groups = Species, data = iris,
      par.settings = simpleTheme(col = pal, pch = 19),
      auto.key = list(columns = 3),
      screen = list(z = 30, x = -60))

cloud() est une projection statique — vous fixez l’angle de vue avec screen. Pour un nuage de points 3D rotatif que vous faites tourner à la souris, utilisez plutôt plotly (voir notre billet Nuages de points 3D en R).

Quand utiliser lattice ?

• Choisissez lattice quand vous voulez du conditionnement multi-panneaux compact (y ~ x | g) avec presque aucun code, ou quand vous êtes déjà dans un écosystème qui parle lattice — les diagnostics de modèles mixtes de lme4, d’anciens pipelines d’analyse, ou la reproduction d’une figure du livre de Sarkar. Ses small multiples à échelle partagée sont vraiment élégants.
• Choisissez ggplot2 pour à peu près tout nouveau travail. facet_wrap() / facet_grid() vous offrent la même idée de conditionnement, mais la grammaire en couches, le thème plus riche et l’écosystème d’extensions bien plus vaste en font le choix moderne par défaut — et c’est ce que le reste de Datanovia enseigne.
• Choisissez les graphiques de base pour des graphiques exploratoires rapides et jetables, et un contrôle total et bas niveau d’un seul panneau.

lattice se situe entre les deux : plus haut niveau que les graphiques de base, mais avec un modèle mental différent (et désormais moins courant) que la grammaire des graphiques de ggplot2. Le connaître signifie que vous pouvez lire et maintenir les graphiques lattice que vous croiserez forcément — et parfois recourir à son conditionnement quand c’est le chemin le plus rapide.

Foire aux questions

NoteQu’est-ce que le paquet lattice en R ?

lattice est l’implémentation R des graphiques Trellis — un système de visualisation de données haut niveau construit sur une interface par formule (y ~ x, ~ x, y ~ x | g). Il est livré avec R (un paquet recommandé, aucune installation nécessaire) et est conçu autour du conditionnement multi-panneaux : tracer le même graphique une fois par sous-groupe, sur des échelles partagées, pour une comparaison directe. Ses principales fonctions incluent xyplot(), bwplot(), histogram(), densityplot() et cloud().

NoteQuelle est la différence entre lattice et ggplot2 ?

Les deux produisent des « small multiples » multi-panneaux, mais selon des modèles différents. lattice utilise une interface par formule (y ~ x | g) et un ensemble fixe de fonctions graphiques haut niveau ; ggplot2 utilise une grammaire des graphiques en couches (ggplot() + geom_*() + facet_wrap()) que vous composez pièce par pièce. ggplot2 dispose d’un écosystème d’extensions plus vaste et constitue le choix moderne par défaut pour tout nouveau travail ; lattice est souvent plus rapide à taper pour une figure conditionnée express et reste courant dans les diagnostics de modèles mixtes.

NoteComment créer plusieurs panneaux (facettes) en lattice ?

Utilisez le conditionnement — ajoutez | g à la formule, où g est un facteur. Par exemple xyplot(y ~ x | group, data = d) trace un panneau de nuage de points par niveau de group, sur des axes partagés. Contrôlez la disposition des panneaux avec layout = c(ncol, nrow). Cette syntaxe | g fonctionne sur toutes les fonctions lattice (bwplot, histogram, densityplot, …).

NoteComment colorer les graphiques lattice par groupe ?

Ajoutez l’argument groups = pour superposer les sous-groupes dans le même panneau, et auto.key = TRUE (ou auto.key = list(columns = n)) pour dessiner la légende automatiquement. Fixez les couleurs réelles avec par.settings = simpleTheme(col = my_palette, pch = 19). Utilisez groups = pour superposer dans un panneau et le conditionnement | g pour scinder en panneaux séparés — ils se combinent.

NoteDois-je installer lattice ?

Non — lattice est un paquet recommandé livré avec chaque installation de R, donc library(lattice) fonctionne d’emblée. (Son compagnon, latticeExtra, qui ajoute ecdfplot(), mapplot() et plus encore, est une installation CRAN séparée.)

Pour aller plus loin

• Nuages de points 3D en R — 3D statique et interactif/rotatif. · Série ggplot2 — la voie moderne de la grammaire des graphiques. · Graphiques de base R · Visualisation de données.

🟢 Avec un agent IA

Demandez à Prova « convertis mon xyplot(y ~ x | group) lattice en la figure ggplot2 facet_wrap() équivalente » — elle répond avec du code que vous pouvez exécuter sur vos propres données. The runtime is the judge. Demander à Prova →

Cette page vous a-t-elle été utile ?

Recevez les nouvelles leçons R & Python par e-mail

Pratique, reproductible, sans spam. Désinscription à tout moment.

Double opt-in. Nous ne partageons jamais votre e-mail.

Partager cette pageXLinkedInRedditHN