Ridgeline plot en R : distributions de densité avec ggridges

Des ridgelines de densité partiellement superposées qui montrent comment une distribution se décale d’un groupe à l’autre — remplissages en dégradé, lignes de quantiles, points jittered et contrôle du chevauchement

Créez des ridgeline plots en R avec le package ggridges : des courbes de densité superposées qui révèlent comment la distribution d’une variable numérique change d’un groupe à l’autre. Apprenez geom_density_ridges(), les remplissages en dégradé avec scale_fill_viridis_c(), les lignes de quantiles, les points jittered, les contrôles de chevauchement scale / rel_min_height et theme_ridges() — chaque graphique à partir de R exécutable.

AstuceCe que vous trouverez ici

• Les ridgeline plots (aussi appelés joyplots) — des courbes de densité partiellement superposées qui donnent au décalage d’une distribution d’un groupe à l’autre l’allure d’une chaîne de montagnes.
• Le geom central, geom_density_ridges(), plus les remplissages en dégradé, les lignes de quantiles, les points jittered, et les contrôles de chevauchement scale / rel_min_height.
• Quand recourir à theme_ridges() plutôt qu’au theme_minimal() de la marque.
• Chaque graphique ci-dessous est rendu à partir de vrai code R que vous pouvez copier et exécuter.

Qu’est-ce qu’un ridgeline plot ?

Un ridgeline plot trace une courbe de densité par groupe, les empile sur un axe des x commun et les laisse se superposer partiellement — le résultat ressemble à une succession de collines, d’où son autre nom de joyplot. C’est le bon graphique lorsque vous voulez comparer la façon dont la distribution d’une variable numérique diffère entre de nombreux groupes (mois, espèces, catégories) dans un seul panneau compact et élégant — là où une grille de graphiques de densité séparés gaspillerait de l’espace et où un unique geom_density() superposé tournerait au spaghetti.

Le package ggridges ajoute ces geoms à ggplot2. Voici l’exemple canonique — la température quotidienne moyenne à Lincoln, dans le Nebraska, une ridge par mois, remplie par la valeur de température elle-même :

Mise en place

Chargez ggplot2 et ggridges. Les deux jeux de données utilisés ci-dessous sont fournis avec ces packages, donc le code est autonome — copiez n’importe quel bloc et exécutez-le :

library(ggplot2)
library(ggridges)

Deux jeux de données maison nous accompagnent :

• iris — Sepal.Length (numérique) par Species (3 groupes). Des courbes nettes, lisses et bien séparées.
• lincoln_weather (fourni avec ggridges) — Mean Temperature [F] par Month (12 groupes). Le joyplot saisonnier classique.

Ridgeline plot de base

Associez la variable numérique à x et le facteur de groupement à y, puis ajoutez geom_density_ridges(). ggridges estime la densité de chaque groupe et décale les courbes le long de l’axe des y :

ggplot(iris, aes(x = Sepal.Length, y = Species)) +
  geom_density_ridges(fill = "#3a86d4", alpha = 0.85) +
  theme_minimal()

Quelques points essentiels :

• Lorsque la variable y est un facteur, le groupement est automatique. Si y est numérique (par exemple si vous avez associé une année), ajoutez group = explicitement pour que chaque niveau obtienne sa propre ridge.
• geom_density_ridges2() donne le même graphique avec des polygones fermés (la ligne de base est tracée), par opposition aux courbes ouvertes de geom_density_ridges().
• rel_min_height rogne les longues queues de densité plates — rel_min_height = 0.01 coupe tout ce qui se situe en dessous de 1 % de la hauteur maximale d’une courbe, ce qui nettoie le rendu :

ggplot(iris, aes(x = Sepal.Length, y = Species)) +
  geom_density_ridges(fill = "#3a86d4", alpha = 0.85, rel_min_height = 0.01) +
  theme_minimal()

Contrôler le chevauchement avec scale

L’argument scale définit la hauteur de chaque densité par rapport à l’espacement entre les groupes — autrement dit, l’ampleur du chevauchement des ridges. La valeur par défaut est 1 (les courbes se touchent tout juste) ; des valeurs plus petites les séparent, des valeurs plus grandes les empilent pour former la chaîne de montagnes caractéristique :

ggplot(iris, aes(x = Sepal.Length, y = Species)) +
  geom_density_ridges(fill = "#3a86d4", alpha = 0.7, scale = 3) +
  theme_minimal()

Ajustez-la à vos données : essayez scale = 0.6 pour garder les courbes écartées et faciliter une lecture précise, ou scale = 4 pour une chaîne plus dense et plus décorative. Associez fill = <group> pour colorer chaque ridge selon son groupe — viridis est la valeur sûre par défaut :

ggplot(iris, aes(x = Sepal.Length, y = Species, fill = Species)) +
  geom_density_ridges(alpha = 0.85, scale = 2) +
  scale_fill_viridis_d() +
  theme_minimal() +
  theme(legend.position = "none")

Remplissage en dégradé le long de l’axe des x

Pour remplir chaque courbe avec un dégradé qui suit la valeur de x (l’effet du graphique de couverture), utilisez geom_density_ridges_gradient() et associez fill = after_stat(x), puis une échelle continue telle que scale_fill_viridis_c(). C’est parfait pour une variable ordonnée comme la température, où la couleur est la valeur :

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_minimal()

Note

Pour des raisons techniques, geom_density_ridges_gradient() ne prend pas en charge la transparence alpha dans le remplissage — omettez-la lorsque vous utilisez le geom de dégradé.

Ajouter des lignes de quantiles

stat_density_ridges() peut superposer des lignes de quantiles sur chaque densité. Par défaut, il trace les trois quartiles (Q1, médiane, Q3) ; définissez quantiles pour choisir les vôtres :

ggplot(iris, aes(x = Sepal.Length, y = Species)) +
  stat_density_ridges(fill = "#3a86d4", alpha = 0.85,
                      quantile_lines = TRUE, quantiles = 0.5) +
  theme_minimal()

Vous pouvez aussi colorer la zone par quantile. Définissez calc_ecdf = TRUE (cela calcule la CDF empirique dont les quantiles ont besoin), associez fill = factor(after_stat(quantile)) et effectuez le rendu avec le geom de dégradé :

ggplot(iris, aes(x = Sepal.Length, y = Species, fill = factor(after_stat(quantile)))) +
  stat_density_ridges(
    geom = "density_ridges_gradient", calc_ecdf = TRUE,
    quantiles = 4, quantile_lines = TRUE
  ) +
  scale_fill_viridis_d(name = "Quartiles") +
  theme_minimal()

Ajouter les points de données d’origine

Définissez jittered_points = TRUE pour disperser les observations brutes sous chaque courbe — une vue de type « raincloud » qui montre l’échantillon réel, et pas seulement la densité lissée. L’argument position contrôle la disposition ("raincloud" laisse tomber les points dans un nuage sous la ridge) :

ggplot(iris, aes(x = Sepal.Length, y = Species)) +
  geom_density_ridges(
    fill = "#3a86d4", alpha = 0.7, scale = 0.9,
    jittered_points = TRUE, position = "raincloud",
    point_alpha = 0.5, point_size = 1
  ) +
  theme_minimal()

Utilisez un rug de petits traits plutôt que des points en stylisant ceux-ci comme des barres verticales (point_shape = "|", position = position_points_jitter(height = 0)) — pratique lorsque le nuage devient encombré.

Ridgelines en histogramme

Vous préférez des barres à une courbe lisse ? Passez stat = "binline" pour tracer un histogramme par ridge, avec draw_baseline = FALSE pour supprimer les lignes traînantes :

ggplot(iris, aes(x = Sepal.Length, y = Species, height = after_stat(density))) +
  geom_density_ridges(
    fill = "#3a86d4", alpha = 0.85,
    stat = "binline", bins = 20, scale = 0.95, draw_baseline = FALSE
  ) +
  theme_minimal()

Thème : theme_ridges() vs theme_minimal()

ggridges fournit theme_ridges(), calibré pour ces graphiques — il aligne les étiquettes des axes sur les lignes de la grille et donne aux ridges de l’espace pour respirer. C’est un bon choix pour une figure ridgeline autonome :

ggplot(iris, aes(x = Sepal.Length, y = Species)) +
  geom_density_ridges(fill = "#3a86d4", alpha = 0.85) +
  theme_ridges()

Pour la cohérence avec le reste d’un rapport, le theme_minimal() de la marque (utilisé tout au long de cet article) garde les ridgelines visuellement alignées sur vos autres figures. Utilisez theme_ridges(grid = FALSE) si vous voulez l’allure des ridges sans les lignes de la grille.

Conclusion

Recourez à un ridgeline plot lorsque vous devez comparer une distribution numérique entre de nombreux groupes d’un seul coup. Associez la valeur à x et le groupe à y, partez de geom_density_ridges(), puis ajoutez les couches dont l’histoire a besoin : scale / rel_min_height pour le chevauchement, geom_density_ridges_gradient() + scale_fill_viridis_c() pour un remplissage encodant la valeur, des lignes de quantiles pour les statistiques de synthèse, et jittered_points pour montrer l’échantillon brut. C’est l’une des façons les plus belles — et les plus riches en information — de montrer un changement de distribution.

Pour aller plus loin

• Density Plot in ggplot2 — le pendant à une seule distribution, entièrement exécutable, dans la série ggplot2 du cursus. · R Color Palettes — viridis et les palettes derrière ces remplissages. · ggplot2 series · Visualisation de données.

🟢 Avec un agent IA

Demandez à Prova « transforme mes données groupées en un ridgeline plot avec un remplissage en dégradé viridis » — elle répond avec du code que vous pouvez exécuter sur votre propre data frame. 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