Ridgeline plot en R : ggridges & geom_density_ridges

Empilez des courbes de densité en ridgeline (joyplot) avec ggplot2 et ggridges

Construisez un ridgeline plot (joyplot) en R avec ggplot2 et ggridges — tracez des courbes de densité qui se chevauchent par groupe avec geom_density_ridges(), remplissez par valeur avec un gradient viridis, contrôlez le chevauchement, tracez une distribution mois par mois et ajoutez des lignes de quantiles.

AstucePoints clés

• Un ridgeline plot (aussi appelé joyplot) empile des courbes de densité pour comparer de nombreuses distributions d’un coup — comme une chaîne de montagnes.
• geom_density_ridges(), de ggridges, trace une densité par niveau d’une variable de groupe portée par l’axe y.
• Utilisez geom_density_ridges_gradient() avec scale_fill_viridis_c() pour remplir chaque crête par valeur.
• Contrôlez le chevauchement des courbes avec scale, et masquez les queues fines avec rel_min_height.
• C’est imbattable pour montrer comment une distribution évolue dans le temps — par exemple la température par mois.
• Ajoutez quantile_lines = TRUE pour marquer la médiane (ou n’importe quel quantile) sur chaque crête.

LivreObtenez le livre — GGPlot2 Essentials (PDF)→

Introduction

Quand il faut comparer une douzaine de distributions, une grille de graphiques de densité séparés est difficile à lire et des courbes superposées tournent au spaghetti. Un ridgeline plot résout cela : il place chaque distribution sur sa propre ligne de base le long de l’axe y et laisse les courbes se chevaucher légèrement, créant l’impression d’une chaîne de montagnes. C’est le choix naturel pour voir comment une distribution change selon les groupes ou dans le temps — l’exemple classique étant la température qui se décale mois après mois.

Les ridgeline plots (popularisés sous le nom de « joyplots ») ne sont pas intégrés à ggplot2 ; ils viennent de l’extension ggridges. Cette leçon les construit pas à pas avec les jeux de données iris et lincoln_weather fournis avec R et ggridges — chaque figure est rendue ici, et vous pouvez les ré-exécuter ou les modifier en live.

Un ridgeline plot de base par groupe

Mappez la variable continue sur x et la variable de groupe sur y, puis ajoutez geom_density_ridges(). Ici nous comparons la distribution de Sepal.Length entre les trois espèces d’iris, en remplissant chaque crête avec une couleur viridis adaptée au daltonisme.

library(ggplot2)
library(ggridges)
ggplot(iris, aes(x = Sepal.Length, y = Species, fill = Species)) +
  geom_density_ridges() +
  scale_fill_viridis_d() +
  theme_ridges()

La variable de groupe est sur l’axe y et chaque espèce reçoit sa propre ligne de base de densité. theme_ridges() (de ggridges) resserre les axes pour que ce soient les courbes, et non les lignes de grille, qui guident l’œil.

Contrôler le chevauchement et rogner les queues

Deux arguments façonnent les crêtes. scale règle la hauteur de chaque courbe par rapport à l’espacement entre les lignes de base : la valeur par défaut est 1, des valeurs plus petites écartent les courbes, des valeurs plus grandes les empilent. rel_min_height supprime les queues fines en dessous d’une fraction du pic de chaque courbe, ce qui nettoie le graphique.

library(ggplot2)
library(ggridges)
ggplot(iris, aes(x = Sepal.Length, y = Species, fill = Species)) +
  geom_density_ridges(scale = 1.8, rel_min_height = 0.01, alpha = 0.8) +
  scale_fill_viridis_d() +
  theme_ridges()

Un scale de 1.8 fait nettement se chevaucher les courbes ; le léger alpha garde les crêtes arrière visibles à travers celles de devant. Augmentez encore scale pour une chaîne de montagnes plus dense, abaissez-le vers 0.7 pour séparer complètement les courbes.

Remplir chaque crête par valeur avec un gradient

Pour colorer les courbes selon la variable de l’axe x plutôt que par groupe, passez à geom_density_ridges_gradient() et mappez fill sur la position x calculée avec after_stat(x). Associez-le à une échelle viridis continue pour un gradient prêt à publier.

library(ggplot2)
library(ggridges)
ggplot(iris, aes(x = Sepal.Length, y = Species, fill = after_stat(x))) +
  geom_density_ridges_gradient(scale = 1.5, rel_min_height = 0.01) +
  scale_fill_viridis_c(name = "Sepal length", option = "C") +
  theme_ridges()

after_stat(x) lit la valeur x à laquelle la densité a été évaluée, si bien que chaque crête se fond le long de son propre étalement — sépales courts en sombre, sépales longs en vif. C’est le look signature de ggridges.

Montrer une distribution qui se décale dans le temps

Le motif pour lequel les ridgelines sont faites : une distribution qui bouge mois après mois. Le jeu de données lincoln_weather (dans ggridges) contient la météo quotidienne de 2016 pour Lincoln, Nebraska. Mettez la température moyenne sur x, Month sur y, et remplissez par température pour que l’oscillation saisonnière se lise comme une couleur.

library(ggplot2)
library(ggridges)
ggplot(lincoln_weather, aes(x = `Mean Temperature [F]`, y = Month, fill = after_stat(x))) +
  geom_density_ridges_gradient(scale = 3, rel_min_height = 0.01) +
  scale_fill_viridis_c(name = "Temp [F]", option = "C") +
  labs(x = "Mean temperature [F]", y = NULL) +
  theme_ridges()

Lisez-le de bas en haut : les crêtes glissent vers la droite et virent au jaune pendant l’été, puis reviennent vers la gauche et au violet vers l’hiver. Un seul panneau porte douze distributions et tout le cycle annuel.

Marquer la médiane avec des lignes de quantiles

Mettez quantile_lines = TRUE pour tracer la médiane sur chaque crête ; passez quantiles pour d’autres points de coupe. Cela ajoute une référence précise à la forme visuelle.

library(ggplot2)
library(ggridges)
ggplot(lincoln_weather, aes(x = `Mean Temperature [F]`, y = Month, fill = after_stat(x))) +
  geom_density_ridges_gradient(
    scale = 3, rel_min_height = 0.01,
    quantile_lines = TRUE, quantiles = 2
  ) +
  scale_fill_viridis_c(name = "Temp [F]", option = "C") +
  labs(x = "Mean temperature [F]", y = NULL) +
  theme_ridges()

quantiles = 2 coupe chaque densité à sa médiane (la seule ligne qui partage l’aire en deux) ; utilisez quantiles = 4 pour les quartiles. La ligne suit la médiane saisonnière aussi nettement que la couleur suit l’étalement.

Essayez en live

Les graphiques ci-dessus ont été rendus au moment du build. Envie d’expérimenter ? Modifiez le code et appuyez sur Run — il s’exécute dans votre navigateur via webR (sans serveur, sans installation). Essayez de changer scale ou l’option viridis.

Vous travaillez en Python ? Un guide ridgeline avec joypy/matplotlib arrive dans la série Python.

🟢 Avec un agent IA

Demandez à Prova « comment contrôler le chevauchement entre les crêtes dans ggridges ? » — elle répond avec du code que vous pouvez exécuter, si bien que l’explication est reproductible. The runtime is the judge. Demander à Prova →

Problèmes fréquents

• Les crêtes se chevauchent trop (ou se touchent à peine). C’est l’argument scale, pas les données. Abaissez-le vers 0.7 pour séparer les courbes, augmentez-le au-delà de 2 pour une chaîne de montagnes dense. scale est multiplicatif par rapport à l’espacement des lignes de base — il n’y a pas de « bonne » valeur unique, alors ajustez-la au nombre de groupes.
• ..x.. est déprécié / déclenche un avertissement. Les anciens tutoriels mappent fill = ..x... ggplot2 actuel préfère fill = after_stat(x) — même résultat, sans avertissement. Utilisez-le dans aes() avec geom_density_ridges_gradient().
• Des queues coupées ressemblent à des triangles flottants. Quand rel_min_height = 0, des queues ténues s’étendent sous les crêtes voisines. Mettez rel_min_height = 0.01 pour rogner tout ce qui est en dessous de 1 % de chaque pic.

Foire aux questions

NoteQu’est-ce qu’un ridgeline plot (joyplot) ?

Un ridgeline plot empile plusieurs courbes de densité le long d’un axe y partagé, en les laissant se chevaucher légèrement pour qu’elles ressemblent à une chaîne de montagnes. Il est idéal pour comparer de nombreuses distributions — par exemple une par groupe ou par mois — dans un seul panneau compact. Il a été popularisé sous le nom de « joyplot ».

NoteComment faire un ridgeline plot en R avec ggplot2 ?

Installez et chargez le package ggridges, mappez votre variable continue sur x et la variable de groupe sur y, puis ajoutez geom_density_ridges() : ggplot(iris, aes(x = Sepal.Length, y = Species)) + geom_density_ridges(). ggridges est une extension de ggplot2, donc toutes les couches et échelles ggplot2 habituelles s’appliquent encore.

NoteÀ quoi sert l’argument scale dans geom_density_ridges ?

scale règle la hauteur de chaque courbe par rapport à l’espacement entre les lignes de base. La valeur par défaut est 1 ; les valeurs en dessous de 1 séparent les courbes et les valeurs au-dessus de 1 les font davantage se chevaucher. Il ne change pas les données — seulement la hauteur à laquelle les crêtes sont dessinées.

NoteComment remplir des courbes ridgeline avec un gradient de couleur ?

Utilisez geom_density_ridges_gradient() au lieu de geom_density_ridges() et mappez fill sur la position x avec aes(fill = after_stat(x)), puis ajoutez scale_fill_viridis_c(). Chaque crête est alors ombrée le long de l’axe x plutôt que colorée d’une seule couleur plate par groupe.

NoteComment ajouter une ligne de médiane à chaque crête ?

Passez quantile_lines = TRUE au geom et mettez quantiles = 2 pour tracer la médiane sur chaque courbe. Utilisez quantiles = 4 pour les quartiles ou un vecteur comme c(0.1, 0.9) pour des points de coupe personnalisés.

Testez votre compréhension

ImportantExercice : remplir les crêtes par valeur

Complétez le code pour que chaque crête d’iris soit remplie d’un gradient viridis le long de l’axe x (et non d’une couleur plate par espèce).

# Map fill to after_stat(x), then add scale_fill_viridis_c()

library(ggplot2) library(ggridges) ggplot(iris, aes(x = Sepal.Length, y = Species, fill = after_stat(x))) + geom_density_ridges_gradient(scale = 1.5, rel_min_height = 0.01) + scale_fill_viridis_c(name = "Sepal length") + theme_ridges()

library(ggplot2)
library(ggridges)
ggplot(iris, aes(x = Sepal.Length, y = Species, fill = after_stat(x))) +
  geom_density_ridges_gradient(scale = 1.5, rel_min_height = 0.01) +
  scale_fill_viridis_c(name = "Sepal length") +
  theme_ridges()

Vérification rapide. Vos crêtes se chevauchent si fortement que les courbes arrière sont cachées. Quel argument abaissez-vous ?

AstuceVoir la réponse

scale. Il contrôle la hauteur des courbes par rapport à l’espacement des lignes de base — abaissez-le (par exemple de 1.8 à 0.8) pour écarter les crêtes. rel_min_height ne fait que rogner les queues ; alpha ne change que la transparence.

Conclusion

Vous avez construit un ridgeline plot avec geom_density_ridges(), contrôlé le chevauchement avec scale et rel_min_height, rempli chaque crête par valeur avec geom_density_ridges_gradient() et un gradient viridis, tracé une distribution qui se décale au fil des mois, et marqué la médiane avec des lignes de quantiles. Les ridgelines sont la façon la plus nette de comparer de nombreuses distributions d’un coup.

Leçons associées

• Graphique de densité en R — le bloc de base à une distribution derrière chaque crête. · Histogramme en R — vue par classes de la même distribution. · Graphique en violon en R — distributions côte à côte plutôt qu’empilées.
• Pour aller plus loin : couleurs · légende · axes & échelles · thèmes · titre & légende · facettes. · ggplot2 — la série complète. · Visualisation de données — le pilier.

DatanoviaGGPlot2 EssentialsPDF

Vous préférez un livre ? GGPlot2 Essentials est disponible en PDF téléchargeable — toutes les leçons de cette série, hors ligne et à vous.

Obtenir le livre (PDF) →Les leçons restent gratuites en ligne.

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

Prouvez que vous savez le faire. Maîtrisez toute la série ggplot2 — suivez votre parcours, construisez des projets et obtenez un certificat.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Prêt à passer à la vitesse supérieure ?

Prouvez-le — obtenez le certificat ggplot2 Essentials.Passer l'évaluation →Essayez sur vos propres données avec Prova — the runtime is the judge.Ouvrir Prova →

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

Note

Cette leçon est reproductible : les figures sont exécutées au moment du build (si elles se rendent, le code fonctionne), et le bac à sable + le quiz se ré-exécutent en live dans votre navigateur. The runtime is the judge.