Mercator : des angles parfaits, des surfaces qui explosent

La projection de Mercator, créée en 1569 pour la navigation maritime, préserve les angles : une ligne droite sur la carte correspond à un cap constant au compas, très utile en mer. Mais cette préservation des angles a un coût élevé sur les surfaces, qui grandissent démesurément à mesure qu’on s’éloigne de l’équateur.

Avec cette projection, le Groenland paraît aussi grand que l’Afrique, alors qu’en réalité l’Afrique fait environ 14 fois sa taille. C’est le reproche le plus connu fait à cette projection, elle donne une importance visuelle disproportionnée aux régions proches des pôles, au détriment des régions équatoriales.

Equal Earth : des surfaces fidèles, des formes qui bougent un peu

La projection Equal Earth (Šavrič et al. 2019) part du problème inverse : elle préserve les proportions de surface entre les pays. Le Groenland y retrouve une taille comparable à sa réalité, au prix de formes et d’angles légèrement déformés loin de l’équateur.

L’Afrique retrouve ainsi sa vraie surface, tandis que le Groenland rétrécit en conséquence. Rien n’a changé dans les données, uniquement la façon de les projeter sur un plan.

Mais comment on fait ça concrètement, avec R ?

Récupérer les contours du monde

rnaturalearth télécharge et met en cache des données géographiques prêtes à l’emploi. Pas besoin de chercher un shapefile sur internet.

world <- ne_countries(scale = "medium", returnclass = "sf")

L’argument scale contrôle le niveau de détail des contours ("small", "medium" ou "large"). Pour une carte du monde entière, "medium" suffit largement : "large" alourdit inutilement le fichier sans gain visuel à cette échelle.

world est un objet sf : un tableau de données classique, avec une colonne spéciale geometry qui contient les polygones de chaque pays.

world |> 
  select(name, continent, pop_est, geometry) |> 
  head()

Simple feature collection with 6 features and 3 fields
Geometry type: MULTIPOLYGON
Dimension:     XY
Bounding box:  xmin: -73.36621 ymin: -22.40205 xmax: 109.4449 ymax: 41.9062
Geodetic CRS:  WGS 84
       name     continent  pop_est                       geometry
1  Zimbabwe        Africa 14645468 MULTIPOLYGON (((31.28789 -2...
2    Zambia        Africa 17861030 MULTIPOLYGON (((30.39609 -1...
3     Yemen          Asia 29161922 MULTIPOLYGON (((53.08564 16...
4   Vietnam          Asia 96462106 MULTIPOLYGON (((104.064 10....
5 Venezuela South America 28515829 MULTIPOLYGON (((-60.82119 9...
6   Vatican        Europe      825 MULTIPOLYGON (((12.43916 41...

Une première carte

Avec un objet sf, on peut utiliser la fonction geom_sf() qui comprend nativement la colonne geometry.

ggplot(world) +
  geom_sf(fill = "#6BAED6", color = "white", linewidth = 0.1) +
  coord_sf(expand = FALSE) +
  theme_void() +
  theme(panel.background = element_rect(fill = "#E4EFF6", color = NA))

Par défaut, geom_sf() affiche les coordonnées géographiques (longitude, latitude) telles quelles, sans appliquer de projection. C’est ce qu’on appelle la projection plate carrée : chaque degré de longitude et chaque degré de latitude occupent le même espace sur l’écran. Simple, mais ce n’est pas neutre pour autant : les distorsions de surface aux pôles y sont déjà bien visibles.

Changer de projection

C’est coord_sf() qui gère la projection, via son argument crs (coordinate reference system, le système de référence des coordonnées). Pour Equal Earth, il n’existe pas encore de code EPSG largement adopté : on passe par une chaîne PROJ, qui décrit directement les paramètres de la projection.

ggplot() +
  geom_sf(data = globe, fill = "#E4EFF6", color = NA) +
  geom_sf(data = world, fill = "#6BAED6", color = "white", linewidth = 0.1) +
  coord_sf(crs = "+proj=eqearth", expand = FALSE) +
  theme_void()

Autre exemple de chaîne PROJ courante : Robinson, une projection qui ne préserve ni les surfaces ni les angles à la perfection, mais cherche un compromis visuel entre les deux. Elle a longtemps servi de référence pour les cartes du monde généralistes : la National Geographic Society l’a utilisée de 1988 à 1998, avant de lui préférer la projection Winkel Tripel, qui réduit encore un peu plus la déformation près des pôles.

ggplot() +
  geom_sf(data = globe, fill = "#E4EFF6", color = NA) +
  geom_sf(data = world, fill = "#6BAED6", color = "white", linewidth = 0.1) +
  coord_sf(crs = "+proj=robin", expand = FALSE) +
  theme_void()

Un fond qui épouse la projection

Sans fond du tout, une carte projetée devient vite perturbante à lire : impossible de savoir où s’arrête la Terre et où commence le vide.

ggplot(world) +
  geom_sf(fill = "#6BAED6", color = "white", linewidth = 0.1) +
  coord_sf(crs = "+proj=eqearth", expand = FALSE) +
  theme_void()

Le contour elliptique de la projection Equal Earth se devine à peine. Sur toutes les autres cartes de cet article, l’arrière-plan bleu clair comble ce vide en suivant la forme réelle de la projection. On pourrait croire que theme(panel.background = ...) suffit, mais ce n’est pas le cas : ce réglage colorie toujours un rectangle, quelle que soit la projection, puisqu’il agit sur le panel ggplot2 et non sur la carte elle-même.

La solution consiste à tracer le fond comme une géométrie à part entière, projetée dans le même système que les pays : un rectangle couvrant tout le globe en longitude/latitude (-180° à 180°, -90° à 90°), mais construit comme un contour tracé point par point plutôt que 4 coins isolés, pour que la reprojection le courbe correctement plutôt que de garder des côtés droits.

globe <- st_sfc(
  st_polygon(list(cbind(
    c(seq(-180, 180, 1), rep(180, 181), seq(180, -180, -1), rep(-180, 181)),
    c(rep(-90, 361), seq(-90, 90, 1), rep(90, 361), seq(90, -90, -1))
  ))),
  crs = "EPSG:4326" # sytème longitude / latitude
)

Il suffit ensuite de tracer globe en premier, avant les pays.

ggplot() +
  geom_sf(data = globe, fill = "#E4EFF6", color = NA) +
  geom_sf(data = world, fill = "#6BAED6", color = "white", linewidth = 0.1) +
  coord_sf(crs = "+proj=eqearth", expand = FALSE) +
  theme_void()

coord_sf() projette globe exactement comme il projette world : le rectangle en lat/lon devient l’ellipse, le cercle ou les lobes propres à chaque projection, sans code supplémentaire. Le découpage en pas de 1° (plutôt que 4 coins) est ce qui permet cette courbure : sf ne courbe que les segments qu’on lui fournit, pas les lignes entre deux points éloignés.

Des couleurs sélectionnées avec soin

Une carte muette (juste des contours) est rarement le but final. On veut le plus souvent représenter une variable par pays : c’est la carte choroplèthe. Prenons un exemple qui n’a besoin d’aucune source externe : le nombre de voisins frontaliers de chaque pays, calculé directement à partir des géométries de world.

voisins <- st_touches(world)
world$n_voisins <- lengths(voisins)

ggplot() +
  geom_sf(data = globe, fill = "#E4EFF6", color = NA) +
  geom_sf(data = world, aes(fill = n_voisins), color = "darkgray", linewidth = 0.1) +
  coord_sf(crs = "+proj=eqearth", expand = FALSE) +
  scale_fill_viridis_c(name = "Voisins") +
  theme_void()

st_touches() renvoie, pour chaque pays de world, la liste des autres pays qui partagent au moins un point de frontière avec lui ; lengths() compte simplement la taille de chaque sous-liste. Pas de jointure ni de fichier externe : toute l’information est déjà dans la géométrie des pays.

Le choix de la palette n’est pas un détail cosmétique : mal choisie, elle peut inverser la lecture des données ou les rendre illisibles pour une partie des lecteurs, comme le détaille mon article une palette de couleurs, ça ne se choisit pas au hasard. Ici, le nombre de voisins est une variable numérique avec un ordre naturel, ce qui appelle une palette séquentielle comme viridis car perceptuellement uniforme et lisible pour les personnes daltoniennes.

Un graticule qui ne se cache pas derrière le fond

Le graticule, c’est la grille de méridiens et de parallèles en filigrane sur la plupart des cartes. coord_sf() peut en calculer un automatiquement via le thème (panel.grid), mais panel.grid se dessine toujours derrière les couches geom_sf() : sur les cartes de cet article, il existe bien mais reste caché sous le fond opaque globe.

La solution consiste à ne pas dépendre du thème du tout, et à tracer le graticule comme une géométrie à part entière avec st_graticule(), au même titre que world ou globe : son ordre d’apparition dans le code contrôle alors réellement ce qui se superpose à quoi.

graticule <- st_graticule(
    lon = seq(-180, 180, 20), 
    lat = seq(-80, 80, 20),
    crs = "EPSG:4326" # sytème longitude / latitude
  )

ggplot() +
  geom_sf(data = globe, fill = "#E4EFF6", color = NA) +
  geom_sf(data = graticule, color = "grey75", linewidth = 0.2) +
  geom_sf(data = world, fill = "#6BAED6", color = "white", linewidth = 0.1) +
  coord_sf(crs = "+proj=eqearth", expand = FALSE) +
  theme_void()

st_graticule() calcule les lignes en EPSG:4326 selon les intervalles fournis via lon et lat. Trois couches empilées dans l’ordre voulu : globe, graticule, world. Ainsi la grille reste visible sur l’océan sans passer devant les pays.

head(graticule)

Simple feature collection with 6 features and 10 fields
Attribute-geometry relationships: constant (3), NAs (7)
Geometry type: LINESTRING
Dimension:     XY
Bounding box:  xmin: -180 ymin: -89.91 xmax: -80 ymax: 89.91
Geodetic CRS:  WGS 84 (CRS84)
  degree type   degree_label                       geometry x_start y_start
1   -180    E   "180"*degree LINESTRING (-180 -89.91, -1...    -180  -89.91
2   -160    E "160"*degree*W LINESTRING (-160 -89.91, -1...    -160  -89.91
3   -140    E "140"*degree*W LINESTRING (-140 -89.91, -1...    -140  -89.91
4   -120    E "120"*degree*W LINESTRING (-120 -89.91, -1...    -120  -89.91
5   -100    E "100"*degree*W LINESTRING (-100 -89.91, -1...    -100  -89.91
6    -80    E " 80"*degree*W LINESTRING (-80 -89.91, -80...     -80  -89.91
  x_end y_end angle_start angle_end plot12
1  -180 89.91          90        90   TRUE
2  -160 89.91          90        90   TRUE
3  -140 89.91          90        90   TRUE
4  -120 89.91          90        90   TRUE
5  -100 89.91          90        90   TRUE
6   -80 89.91          90        90   TRUE

Chaque ligne du graticule porte, en plus de sa géométrie, une colonne degree_label et des colonnes x_start/y_start qui donnent un point d’ancrage sur la ligne. Ce sont ces colonnes qu’on va exploiter dans la section suivante pour annoter les axes.

Annoter les axes

Une fois le graticule visible, reste la question des labels. st_graticule() calcule directement des étiquettes prêtes à l’emploi : chaque ligne porte une colonne degree_label déjà formatée avec point cardinal ("120"*degree*W…) en syntaxe plotmath, plus des colonnes x_start/y_start qui donnent une position d’ancrage.

Le graticule repasse ici à un intervalle de 60° plutôt que 20° : à 20°, chaque ligne porterait une étiquette, soit 18 labels par axe, ce qui serait illisible à cette taille de carte.

graticule <- st_graticule(lon = seq(-180, 180, 60), lat = seq(-80, 80, 20), crs = "EPSG:4326")

# Labels de parallèles (type "N"), ancrés sur le bord gauche (méridien -180°) :
# chaque parallèle porte un label côté ouest, qu'on récupère via x_start/y_start
labels_lat <- graticule |>
  filter(type == "N") |>
  st_drop_geometry() |>
  st_as_sf(coords = c("x_start", "y_start"), crs = "EPSG:4326")

# Labels de méridiens (type "E"), replacés sur le bord bas (parallèle -80°)
# plutôt qu'à leur point d'ancrage d'origine, pour aligner tous les labels
# de longitude sur une même ligne en bas de carte
labels_lon <- graticule |>
  filter(type == "E", degree != -180) |>
  st_drop_geometry() |>
  mutate(y_start = -80) |>
  st_as_sf(coords = c("x_start", "y_start"), crs = "EPSG:4326")

ggplot() +
  geom_sf(data = globe, fill = "#E4EFF6", color = NA) +
  geom_sf(data = graticule, color = "grey75", linewidth = 0.2) +
  geom_sf(data = world, fill = "#6BAED6", color = "white", linewidth = 0.1) +
  # nudge_x/nudge_y décalent les labels hors des pays plutôt que dessus
  geom_sf_text(data = labels_lat, aes(label = degree_label), parse = TRUE, size = 2.5, color = "grey40", hjust = 1, nudge_x = -600000) +
  geom_sf_text(data = labels_lon, aes(label = degree_label), parse = TRUE, size = 2.5, color = "grey40", vjust = 1, nudge_y = -600000) +
  coord_sf(crs = "+proj=eqearth", expand = FALSE, clip = "off") +
  theme_void() +
  theme(plot.margin = margin(t = 5, r = 15, b = 15, l = 35, unit = "pt"))

Pour transformer les coordonnées x_start/y_start en un nouveau point à afficher, st_drop_geometry() retire d’abord la géométrie existante (la ligne), pour ne garder qu’un tableau classique ; st_as_sf() en recrée ensuite une, cette fois ponctuelle, à partir des colonnes x_start/y_start désignées via coords. Sans ce passage par un tableau intermédiaire, sf chercherait à combiner la géométrie de ligne déjà présente avec la nouvelle géométrie de point, ce qui échouerait.

Le point d’ancrage du méridien -180° est exclu de labels_lon : sans ce filtre, il tomberait au même endroit projeté que le premier label de labels_lat (80°S), dans le coin bas-gauche de la carte, et les deux labels se superposeraient. parse = TRUE dans geom_sf_text() interprète degree_label comme une expression plotmath pour afficher correctement ° et les points cardinaux, et coord_sf(clip = "off") + plot.margin évitent que hjust/vjust/nudge_x/nudge_y ne poussent les labels hors du cadre de tracé.

Quelle projection pour quel usage ?

Envie d’aller plus loin en cartographie avec R ? Dans le prochain article, on sort des sentiers battus avec trois projections plus exotiques : vue satellite, vue polaire et écorce d’orange, avec tous les pièges qu’il a fallu déjouer pour les faire fonctionner.

La tradition française : la géométrie avant tout

Dans les années 1960, Jean-Paul Benzécri enseigne à Rennes, avant de rejoindre l’Institut de statistique de l’université de Paris en 1965. Mathématicien de formation, il développe l’analyse factorielle des correspondances (AFC) : à partir d’un tableau de contingence, la méthode projette lignes et colonnes dans un même espace géométrique, sans modèle probabiliste imposé ni loi de distribution supposée. On regarde la forme des nuages de points, on interprète les proximités.

Benzécri résume sa philosophie ainsi : le modèle doit suivre les données, non l’inverse (Benzécri 1973). L’analyse des données à la française part du particulier pour aller vers le général, refuse d’imposer une structure a priori, et fait confiance à la géométrie comme langage universel.

Cet héritage est codifié dans FactoMineR, publié en 2008 par Sébastien Lê, Julie Josse et François Husson (Lê et al. 2008), qui propose une implémentation unifiée de toute la famille des analyses factorielles (ACP, AFC, ACM et leurs extensions pour les données mixtes), dans la continuité explicite de l’école de Benzécri.

La tradition écologique : la question de l’environnement

De l’autre côté, une question différente émerge dans les années 1980 en écologie des communautés. Ce n’est plus « quelle est la forme de mes données ? » mais « comment les espèces répondent-elles à leur environnement ? ».

En 1986, Cajo ter Braak publie dans la revue Ecology un article décrivant l’analyse canonique des correspondances (CCA) (ter Braak 1986). La méthode relie directement la composition des communautés (tableau espèces × sites) aux variables environnementales (tableau environnement × sites) : c’est une analyse sous contrainte, où les axes factoriels sont des combinaisons linéaires des variables environnementales. On ne cherche pas à décrire un nuage de points pour lui-même, mais à expliquer pourquoi les espèces sont là où elles sont, en lien avec la température, les nutriments, la profondeur.

C’est cette tradition que vegan incarne. Développé par Jari Oksanen (Oksanen et al. 2025), le package est devenu la référence pour l’écologie des communautés en R : CCA, RDA (analyse de redondance, version linéaire de la CCA), indices de diversité, tests de permutation. Tout ce dont un écologue a besoin pour relier composition et environnement.

Le pont : Legendre & Legendre

Entre ces deux traditions, il y a eu des passeurs. Le plus important est sans doute le livre Écologie numérique de Pierre et Louis Legendre, paru en français en 1979, puis en anglais sous le titre Numerical Ecology en 1983 (Legendre et Legendre 1979, 2012). Les deux frères, l’un à l’Université de Montréal, l’autre à l’Université Laval avant de diriger le Laboratoire d’Océanographie de Villefranche-sur-Mer de 2001 à 2009, y font dialoguer Benzécri et ter Braak, les ACP et les CCA, les distances euclidiennes et les distances de Bray-Curtis. Le livre n’appartient ni à la tradition française ni à la tradition écologique anglophone : c’est une synthèse, devenue référence mondiale et citée dans les deux communautés.

Pierre et Louis Legendre racontent eux-mêmes l’origine du livre : en mai 1975, à la Station marine de Villefranche-sur-Mer, ils participent à un atelier de trois jours sur l’analyse statistique des données écologiques. Le soir de clôture, en terrasse d’un restaurant, ils décident d’écrire un manuel accessible aux écologues non mathématiciens, et esquissent sur un set de table en papier la liste des sujets qui deviendra le sommaire de la première de Numerical Ecology (Legendre 2021). Ce genre de transmission, dans les marges, entre deux discussions, loin des formats officiels, dit quelque chose de réel sur la façon dont naissent parfois les idées scientifiques. Ce n’est pas un hasard si des chercheurs francophones ont occupé ce rôle de pont, la tradition française d’analyse des données et la pratique de l’écologie quantitative s’étant croisées naturellement dans certains labos et certains séminaires.

Un même jeu de données, deux lectures

Cette différence de philosophie se voit jusque dans les graphiques. Prenons un exemple concret, sur des données physico-chimiques de qualité du vin³ : pour chaque échantillon, onze mesures chimiques (acidité, sucre résiduel, sulfates, alcool…) et une note de qualité. C’est un jeu de données multivarié typique : les variables sont corrélées entre elles, et aucune ne suffit seule à résumer ce qui distingue les échantillons. C’est exactement le terrain de jeu d’une ACP, qui cherche les combinaisons de variables qui capturent le plus de variabilité, pour résumer l’essentiel de l’information en deux ou trois axes plutôt que onze.

Code

data(wine, package = "datapyranhia")

# FactoMineR : centrage-réduction automatique (scale.unit = TRUE par défaut)
pca_facto <- PCA(wine, graph = FALSE)

p_ind <- plot(pca_facto, choix = "ind", label = "none", title = "Plan des individus", cex = 0.8)
p_var <- plot(pca_facto, choix = "var", title = "Plan des variables", cex = 0.8)

p_ind + p_var + plot_layout(widths = c(1, 1))

Code

# vegan : centrage-réduction demandé explicitement via l'argument scale
pca_vegan <- rda(wine, scale = TRUE)

# % de variance expliquée par les deux premiers axes, pour les afficher sur le biplot
eig_pct <- 100 * pca_vegan$CA$eig / sum(pca_vegan$CA$eig)

biplot(
  pca_vegan, scaling = 2, main = "", type = c("text", "points"),
  xlab = paste0("PC1 (", round(eig_pct[1], 1), "%)"),
  ylab = paste0("PC2 (", round(eig_pct[2], 1), "%)"),
  cex = 1.02
)

Les deux premiers axes résument 45% de la variabilité totale (26,5% pour l’axe 1, 18,6% pour l’axe 2), ce qui reste modeste : avec onze variables physico-chimiques, aucun résumé en deux dimensions ne peut être exhaustif. Mais les axes restent interprétables. Le premier axe oppose fixed_acidity, citric_acid et density (fortement positifs) à p_h (fortement négatif) : c’est un axe d’acidité globale, cohérent avec la chimie du vin puisque le pH mesure justement l’inverse de l’acidité. Le second axe est porté par volatile_acidity et total_sulfur_dioxide : une autre dimension, indépendante de la première, qui oppose des vins plus ou moins soumis à ces deux composés. Sur le biplot vegan, ces deux logiques se lisent d’un coup d’œil, dans les mêmes flèches que sur le plan des variables FactoMineR : le contenu de l’information est identique, seule la mise en forme diffère.

L’angle : la corrélation

L’angle () par rapport à l’axe horizontal indique la corrélation entre le modèle et l’observation (plus précisément, ). Plus un point est proche de l’axe horizontal (angle proche de 0°), plus la corrélation est forte et proche de 1. Un point à 90° correspond à une corrélation nulle.

La distance à l’origine : l’écart-type

La distance entre un point et le centre du repère (l’origine) représente l’écart-type du modèle, c’est-à-dire sa variabilité propre. L’observation de référence est elle-même placée sur l’axe horizontal, à une distance de l’origine égale à son propre écart-type : c’est le point de comparaison pour tous les modèles.

La distance à l’observation : la RMSE

C’est le point le plus souvent mal compris. La distance directe entre un modèle et le point représentant l’observation (pas l’origine) correspond à la racine de l’erreur quadratique moyenne (Root Mean Square Error, ou RMSE). Cette distance n’est généralement pas représentée par un axe gradué classique, mais par des arcs de cercle concentriques centrés sur le point d’observation.

Sur cet exemple, le modèle 1 est le meilleur en termes de corrélation (angle le plus petit) : sa courbe suit fidèlement la forme du signal. Il sous-estime cependant l’amplitude du signal, avec un écart-type () plus faible que celui de l’observation (3.5 contre 5.7). Malgré ce défaut, c’est son point qui reste le plus proche de l’observation sur le graphique, donc celui qui a la RMSE la plus faible : la bonne corrélation compense l’écart-type imparfait. Le modèle 1 est donc, dans l’ensemble, celui qui représente le mieux les données. Le modèle 3, plus bruité et moins corrélé, s’écarte nettement plus de l’observation, donc sa RMSE est plus élevée.

Synthèse de lecture

Face à un diagramme de Taylor déjà tracé, dans un article ou un rapport, voici l’ordre de lecture le plus efficace.

1. Repérer le point d’observation. C’est la référence : celle-ci est en général indiquée explicitement, sur l’axe horizontal.
2. Regarder l’angle de chaque modèle pour juger de sa corrélation avec l’observation : plus l’angle est petit, meilleure est la corrélation.
3. Regarder la distance à l’origine pour juger de l’écart-type de chaque modèle : plus elle est proche de celle de l’observation, plus la variabilité du modèle est réaliste.
4. Regarder la distance au point d’observation pour juger de la RMSE globale : plus un modèle est proche du point d’observation, meilleur il est dans l’ensemble.

Un point de vigilance mérite d’être gardé en tête : cette lecture suppose que l’observation et les modèles ont la même moyenne. Sans cette condition, un modèle avec un biais systématique peut sembler excellent sur le diagramme sans l’être réellement. La démonstration ci-après explique ce mécanisme, et montre que nos trois modèles n’y sont pas exposés.

Ce que le diagramme ne montre pas : le biais

La loi des cosinus qu’on vient de démontrer est une identité géométrique, toujours vraie pour un triangle donné. Ce qui n’est pas toujours vrai, c’est que ce triangle représente exactement la RMSE.

NoteLa démonstration, en détail

Par définition, la RMSE entre une observation et un modèle est :

où est l’observation, le modèle, et le nombre de points. Pour faire apparaître les moyennes, on ajoute et on retranche et à chaque terme :

En élevant au carré, en sommant sur les points et en divisant par , les termes croisés impliquant s’annulent¹, et il ne reste que :

Le second groupe de termes est, par définition, l’écart-type de chaque série et leur corrélation . C’est très exactement la loi des cosinus démontrée juste au-dessus, avec . La RMSE se décompose donc en deux parts indépendantes :

Le diagramme de Taylor n’affiche que le second terme, celui qui dépend de l’écart-type et de la corrélation. Le biais, lui, n’apparaît nulle part sur le graphique : deux modèles avec le même écart-type et la même corrélation occupent exactement le même point, que leur moyenne soit égale à celle de l’observation ou non.

Figure 8 reprend cette décomposition sur le modèle 1. En haut, le scatter obs/modèle : le segment orange, de la moyenne du nuage à la diagonale, matérialise le biais ; les segments gris fins, la dispersion résiduelle des points (le « reste » de l’équation). En bas, la même décomposition en barres empilées, qui donne à voir directement le poids relatif des deux termes dans la RMSE². À gauche, le modèle original : le biais est quasi nul, la RMSE² est presque entièrement due au reste. À droite, le même modèle décalé de 3°C : la dispersion des points est identique, donc le reste ne change pas, mais le biais s’ajoute et fait grimper la RMSE² d’autant, alors que la position sur le diagramme de Taylor, elle, resterait rigoureusement la même.

C’est la limite à garder en tête : un modèle peut occuper une excellente position sur le diagramme tout en ayant un biais important. Le diagramme de Taylor résume la forme de l’erreur (dispersion, corrélation), pas sa position (biais). En pratique, pour garantir l’égalité des moyennes sans avoir à y penser, le diagramme de Taylor est généralement construit sur des anomalies (des écarts à une moyenne de référence) plutôt que sur des valeurs brutes. Nos trois modèles, eux, respectent déjà cette condition tels quels, puisqu’ils oscillent tous autour de la même température moyenne que l’observation.

Dès lors que cette condition est respectée, le diagramme de Taylor est donc une représentation fidèle : les trois métriques qu’il affiche ne sont jamais en tension entre elles. Un coup d’œil suffit ainsi pour comparer plusieurs dizaines de modèles, là où des tableaux de chiffres demanderaient bien plus de temps.

Références

Savoir lire un diagramme de Taylor, c’est une chose. Savoir construire et valider ses propres modèles en est une autre. Envie d’aller plus loin ?

Les caractères littéraux

La brique la plus simple : chercher du texte tel quel.

str_detect("bonjour tout le monde", "jour")

[1] TRUE

"jour" cherche exactement la séquence j-o-u-r, n’importe où dans la chaîne. C’est déjà une regex, juste sans symbole spécial.

Les classes de caractères

Une classe de caractères représente « un caractère parmi un ensemble ». C’est là que ça devient utile.

Un exemple concret : est-ce qu’une chaîne contient au moins un chiffre ?

str_detect(c("code42", "sans chiffre"), "\\d")

[1]  TRUE FALSE

Les quantificateurs

Un quantificateur précise combien de fois répéter ce qui précède.

Par exemple, \\d+ veut dire « un ou plusieurs chiffres à la suite », c’est-à-dire un nombre entier :

str_extract("le prix est 1250 euros et 12 centimes", "\\d+")

[1] "1250"

str_extract() renvoie la première portion de texte qui correspond au motif, ici "1250".

Le ? sert souvent à rendre un caractère optionnel, pour couvrir deux façons d’écrire un même code. Un cas fréquent en pratique : un code de lot ou de zone, saisi parfois avec un tiret, parfois sans.

codes_lot <- c("FR-001", "FR001", "FR-002", "US-001")

str_detect(codes_lot, "FR-?001")

[1]  TRUE  TRUE FALSE FALSE

"FR-?001" se lit « FR, suivi d’un tiret optionnel, suivi de 001 » : ça matche "FR-001" et "FR001", qu’il y ait un tiret ou non, mais pas "FR-002" (mauvais numéro) ni "US-001" (mauvais indicatif). Ici, le ? change vraiment le résultat : sans lui, le motif littéral "FR-001" ne matcherait que la version avec tiret, et raterait "FR001".

Les ancres

Les ancres ne représentent pas un caractère : elles précisent une position dans la chaîne.

Elles peuvent s’utiliser seules ou ensemble. Prenons une liste de poissons :

poissons <- c("thon rouge", "thon blanc", "maquereau", "requin marteau")

# Commence par "thon"
str_detect(poissons, "^thon")

[1]  TRUE  TRUE FALSE FALSE

# Finit par "eau"
str_detect(poissons, "eau$")

[1] FALSE FALSE  TRUE  TRUE

"^thon" matche les deux thons, mais pas les autres éléments, qui ne commence pas par ces lettres. "eau$" matche "maquereau" et "requin marteau", qui se terminent tous les deux par ces lettres, mais pas les thons.

# Négation : un caractère qui n'est PAS une lettre
str_detect("abc1", "[^a-z]")

[1] TRUE

# Ancre : la chaîne commence par "abc"
str_detect("abc1", "^abc")

[1] TRUE

Les deux ancres combinées permettent d’exiger que le motif couvre la chaîne entière, du début à la fin, pas juste une portion :

# Contient au moins un chiffre, n'importe où
str_detect("daurade123", "\\d")

[1] TRUE

# Est composé UNIQUEMENT de chiffres, du début à la fin
str_detect("daurade123", "^\\d+$")

[1] FALSE

str_detect("123456", "^\\d+$")

[1] TRUE

Sans les ancres, "^\\d+$" deviendrait simplement "\\d+", qui matcherait aussi "daurade123" puisqu’il contient des chiffres quelque part. Les ancres forcent le motif à couvrir la chaîne entière.

Les regroupements

Un quantificateur ne s’applique qu’au caractère (ou à la classe) qui le précède immédiatement. Pour répéter un groupe entier de caractères, on l’entoure de parenthèses (...).

codes <- c("1212", "1222")

str_detect(codes, "^(12)+$")

[1]  TRUE FALSE

str_detect(codes, "^12+$")

[1] FALSE  TRUE

Avec le regroupement (12)+, seul "1212" matche : c’est bien une répétition du bloc complet “12”. Sans les parenthèses, 12+ veut dire tout autre chose : « un 1, suivi de 2 répété une ou plusieurs fois », ce matche "1222" mais pas "1212" (le second “1” casse la série de 2). Le regroupement change donc entièrement ce que le quantificateur répète.

Regrouper par une hiérarchie qui a du sens

Les 18 espèces se répartissent en seulement 6 genres. Plutôt que de regrouper les catégories rares dans un « Autres » artificiel, on peut s’appuyer sur une hiérarchie biologique qui existe déjà dans les données.

many_penguins |>
  ggplot(aes(x = beak.width, y = wing.length, colour = genus)) +
  geom_point(size = 1.5) +
  scale_colour_brewer(palette = "Dark2") +
  labs(x = "Largeur du bec (mm)", y = "Longueur des ailes (mm)", colour = "Genre") +
  theme(legend.text = element_text(size = 10))

Six catégories, n’importe quelle palette qualitative standard s’en sort bien. Le prix à payer est net : on perd complètement la distinction entre espèces d’un même genre.

Il existe un moyen simple de récupérer ce détail sans toucher à la couleur : rendre le même graphique interactif. Le package ggiraph transforme un graphique ggplot2 en objet interactif, où survoler un point affiche l’espèce correspondante.

library(ggiraph)

p <- many_penguins |>
  drop_na(beak.width, wing.length) |>
  ggplot(aes(
    x = beak.width, y = wing.length, colour = genus,
    tooltip = species, data_id = species
  )) +
  geom_point_interactive(size = 1.5) +
  scale_colour_brewer(palette = "Dark2") +
  labs(x = "Largeur du bec (mm)", y = "Longueur des ailes (mm)", colour = "Genre") +
  theme(legend.text = element_text(size = 10))

girafe(ggobj = p, width_svg = 7, height_svg = 5)

L’identité de chaque point reste disponible, à la demande plutôt qu’affichée en permanence, sans couleur supplémentaire. Le compromis à assumer : ça ne fonctionne qu’à l’écran, avec JavaScript actif. Imprimé ou lu hors ligne, l’interactivité disparaît.

Pour une solution qui reste utilisable même à l’impression, il faut sortir de la couleur autrement. On pourrait être tenté d’ajouter encore un canal visuel : une forme différente par espèce en plus de la couleur, une légende propre à chaque sous-graphique… Chaque tentative de ce genre revient buter sur le même mur qu’on a déjà rencontré. La couleur plafonne quelque part entre 8 et 12, scale_shape() plafonne à 6. Peu importe le canal choisi, tant qu’on essaie d’y faire tenir 18 identités distinctes, on retombe sur une limite. La vraie sortie ne consiste pas à trouver un meilleur canal, mais à faire porter l’identité par la position plutôt que par une esthétique de couleur ou de forme, qui elle n’a pas ce genre de plafond.

Facetter directement par espèce

many_penguins |>
  drop_na(beak.width, wing.length) |>
  mutate(species = fct_reorder(species, as.numeric(factor(genus)))) |>
  ggplot(aes(x = beak.width, y = wing.length, colour = genus)) +
  geom_point(size = 1.5) +
  scale_colour_brewer(palette = "Dark2") +
  scale_x_continuous(limits = c(5, 21)) +
  scale_y_continuous(limits = c(60, 190)) +
  facet_wrap(~species, ncol = 3) +
  labs(x = "Largeur du bec (mm)", y = "Longueur des ailes (mm)", colour = "Genre") +
  theme(
    strip.text = element_text(face = "italic", size = 8), 
    legend.text = element_text(size = 10)
  )

La couleur est toujours là, mais elle ne porte plus l’identité individuelle : elle confirme seulement que les espèces d’un même genre sont regroupées. C’est la position du panneau, pas la couleur du point, qui distingue les 18 espèces.

Changer complètement de type de graphique

Une dernière option, plus radicale : abandonner le nuage de points. Avec les espèces en position sur l’axe plutôt qu’en couleur, la question du nombre de couleurs disparaît complètement. Un boxplot, par exemple, se lit très bien avec 18 catégories en position, tant qu’on garde une seule couleur par genre pour le regroupement visuel.

many_penguins |>
  ggplot(aes(x = fct_rev(species), y = `hand-wing.index`, fill = genus)) +
  geom_boxplot(outlier.alpha = 0.6, box.linewidth = 0.5, alpha = 0.8) +
  scale_fill_brewer(palette = "Dark2") +
  coord_flip() +
  labs(
    x = NULL,
    y = "Indice de forme des ailes (Hand-Wing Index)",
    fill = "Genre"
  ) +
  theme(axis.text.y = element_text(size = 8), legend.text = element_text(size = 10))

Le Hand-Wing Index mesure la forme de l’aile : plus il est élevé, plus l’aile est effilée, adaptée au vol sur de longues distances. Ici encore, la couleur ne porte plus l’information principale, elle regroupe seulement. On retrouve la hiérarchie des encodages vue dans le premier article de cette série : la position sur un axe reste l’encodage le plus précis, sans les limites perceptuelles ou techniques de la couleur.

Choisir une palette qualitative, c’est se heurter tôt ou tard à deux murs différents : celui, net et technique, du nombre de couleurs qu’une palette peut proposer avant de laisser des catégories sans couleur ; et celui, plus flou mais tout aussi réel, du nombre de couleurs qu’un œil humain peut suivre sans effort, même quand la palette en a suffisamment.

Dans le prochain article de la série, on s’intéresse à l’accessibilité : et si votre graphique était illisible pour 8 % de vos lecteurs ?

Références

L’approche naïve

Essayons de construire un mini-Dobble à la main, avec 3 symboles par carte. On démarre avec un stock de 3 poissons et on génère une première carte.

Carte 1 : on place 3 poissons, au choix.

Carte 2 : elle doit partager exactement un poisson avec la carte 1. On est obligé d’introduire 2 nouveaux poissons : on est maintenant à 5 poissons au total.

Carte 3 : elle doit partager exactement un poisson avec la carte 1, et exactement un avec la carte 2. Ces deux poissons communs doivent être différents, sinon la carte 3 partagerait deux poissons avec l’une des deux. On introduit encore un nouveau poisson : on a maintenant 6 poissons.

Carte 4 : même logique, elle doit partager exactement un poisson avec chacune des 3 cartes précédentes, sans en partager deux avec aucune d’elles. On est obligé d’introduire un poisson supplémentaire : on atteint 7 poissons au total.

Cartes 5 à 7 : la bonne nouvelle, c’est qu’on n’a plus besoin d’introduire de nouveaux poissons. Les 7 déjà posés suffisent à construire 3 cartes supplémentaires qui respectent toutes les contraintes.

Et maintenant, essayons d’en ajouter une 8ème. Elle devrait partager exactement un poisson avec chacune des 7 cartes, mais on peut vérifier exhaustivement : aucune combinaison de 3 poissons parmi nos 7 ne satisfait cette contrainte simultanément. 7 cartes, c’est le maximum.

Ce n’est pas un hasard. En fixant 3 symboles par carte, on a aussi fixé sans le savoir le nombre total de symboles (7) et le nombre total de cartes (7). Tout est lié.

Une géométrie sans parallèles

Dans la géométrie classique, deux droites parallèles ne se croisent jamais. Dans un plan projectif, cette règle n’existe pas : toutes les droites se croisent, toujours, en exactement un point.

C’est la propriété clé. Et si on remplace « droites » par « cartes » et « point d’intersection » par « poisson en commun », on obtient exactement la propriété du Dobble.

Chaque carte est une droite. Chaque poisson est un point. Deux droites se croisent en exactement un point : deux cartes partagent exactement un poisson.

Le diagramme ci-dessous illustre le cas le plus simple : le plan de Fano, plan projectif d’ordre 2, avec 7 points et 7 droites. Une subtilité : dans cette représentation euclidienne, une des droites ne peut pas être tracée comme un segment sans déformer la structure, elle apparaît donc sous forme de cercle.

La version finie

Un plan projectif fini d’ordre , c’est la même idée, mais avec un nombre fini de points et de droites. La structure est entièrement déterminée par :

• chaque droite contient points (= symboles par carte) ;
• il y a droites au total (= cartes) ;
• il y a points au total (= symboles).

Notez que le nombre de cartes et le nombre de symboles sont toujours égaux, c’est une conséquence directe de la symétrie du plan projectif.

Notre mini-Dobble à 3 symboles par carte correspond à :

• symboles par carte,
• cartes,
• 7 symboles.

Le vrai Dobble utilise : symboles par carte, cartes et symboles. Les 55 cartes de la boîte ? Deux cartes ont été retirées pour des raisons commerciales, mais la structure sous-jacente est bien là.

Le coup de théâtre

Voilà où ça devient vraiment surprenant. Les plans projectifs finis d’ordre n’existent que si est une puissance d’un nombre premier : 2, 3, 4, 5, 7, 8, 9…

? Aucun plan projectif fini d’ordre 6 n’existe. La démonstration passe par un objet mathématique surprenant, les carrés latins orthogonaux (Note 1). Pour , il a fallu attendre 1988 et plusieurs milliers d’heures de calcul sur ordinateur pour conclure (Lam 1991). On ne peut tout simplement pas construire un Dobble valide avec 7 ou 11 symboles par carte. Les maths l’interdisent, ce n’est pas une limitation technique, c’est une contrainte mathématique.

Références

Séquentiel : encoder une grandeur

Une palette séquentielle encode une variable continue sans point de référence central. C’est le bon choix pour une température absolue, une concentration, un revenu, une densité de population.

penguins |>
  drop_na(body_mass_g) |>
  ggplot(aes(x = flipper_length_mm, y = bill_length_mm, colour = body_mass_g)) +
  geom_point(size = 2) +
  scale_colour_viridis_c(option = "mako") +
  labs(
    x = "Longueur des nageoires (mm)",
    y = "Longueur du bec (mm)",
    colour = "Masse (g)"
  )

Divergent : une variable avec un centre qui a du sens

Une palette divergente encode une variable qui s’étend dans deux directions à partir d’un point central significatif : zéro, une moyenne, un seuil. Les deux extrêmes ont des couleurs distinctes, le centre est neutre. C’est la palette pour les anomalies, les corrélations, les résidus : toutes les situations où s’éloigner du centre dans un sens ou dans l’autre est porteur de sens.

penguins |>
  drop_na(body_mass_g, species) |>
  group_by(species) |>
  mutate(anomalie = body_mass_g - mean(body_mass_g)) |>
  ungroup() |>
  ggplot(aes(x = flipper_length_mm, y = bill_length_mm, colour = anomalie)) +
  geom_point(size = 2) +
  scale_colour_distiller(palette = "RdYlBu", limits = c(-1500, 1500)) +
  labs(
    x = "Longueur des nageoires (mm)",
    y = "Longueur du bec (mm)",
    colour = "Anomalie de masse (g)"
  )

Qualitatif : des catégories sans ordre

Une palette qualitative encode des catégories distinctes sans relation d’ordre : des espèces, des pays, des groupes. Les couleurs doivent être suffisamment différentes pour qu’on distingue chaque catégorie, mais aucune ne doit sembler « plus haute » ou « plus basse » qu’une autre.

penguins |>
  drop_na() |>
  ggplot(aes(x = flipper_length_mm, y = bill_length_mm, colour = species)) +
  geom_point(size = 2) +
  scale_colour_brewer(palette = "Set2") +
  labs(
    x = "Longueur des nageoires (mm)",
    y = "Longueur du bec (mm)",
    colour = "Espèce"
  )

Le choix entre ces trois familles n’est pas esthétique, il est conceptuel. Choisir la mauvaise famille, c’est mentir à son lecteur sans le vouloir. On verra en section 3 un exemple classique de ce glissement.

Et les catégories ordonnées ?

Il existe un cas intermédiaire souvent oublié : les variables ordinales, c’est-à-dire des catégories qui ont un ordre naturel mais pas de valeur numérique continue. Par exemple des tranches d’âge, des niveaux de satisfaction, ou faible / moyen / fort.

Ni une palette qualitative (qui ignore l’ordre) ni une palette séquentielle continue (qui suppose des intervalles réguliers) ne conviennent vraiment. La bonne réponse est une palette séquentielle discrète, comme scale_fill_brewer(palette = "Blues") avec des niveaux ordonnés, ou scale_fill_steps() pour discrétiser une variable continue.

penguins |>
  drop_na(body_mass_g) |>
  mutate(masse_cat = cut(
    body_mass_g,
    breaks = 4,
    labels = c("Légère", "Moyenne", "Lourde", "Très lourde"))
  ) |>
  ggplot(aes(x = flipper_length_mm, y = bill_length_mm, colour = masse_cat)) +
  geom_point(size = 2) +
  scale_colour_brewer(palette = "RdPu", direction = 1) +
  labs(
    x = "Longueur des nageoires (mm)",
    y = "Longueur du bec (mm)",
    colour = "Masse"
  )

Pourquoi jet c’est mal

La quasi-totalité de la plaine française est noyée dans une masse orange-rouge indistincte, tandis que les Alpes explosent visuellement, donnant l’impression d’un contraste radical entre montagne et plaine, alors que l’écart est progressif dans les données.

C’est le problème fondamental de jet : elle n’est pas perceptuellement uniforme (Crameri et al. 2020). Un même écart de température ne produit pas le même saut visuel selon l’endroit où on se trouve sur le gradient. Certaines zones paraissent très contrastées, d’autres homogènes, sans que les données le justifient. Et comme on le verra dans le prochain article de la série, jet est aussi particulièrement problématique pour les personnes daltoniennes.

viridis : la solution universelle

Avec viridis, les faux contrastes disparaissent. On distingue maintenant clairement le gradient nord-sud, le couloir rhodanien, et la transition vers les sommets alpins. Rien n’explose, rien n’est écrasé : chaque degré compte autant visuellement que les autres.

viridis n’est pas une palette unique mais une famille : cinq variantes sont disponibles dans ggplot2 via l’argument option.

Toutes sont perceptuellement uniformes et accessibles aux daltoniens. viridis est la valeur par défaut ; magma et inferno conviennent bien aux fonds sombres ; cividis est conçue pour être identique en vision normale et en vision daltonienne.

viridis est le bon réflexe par défaut, mais il existe des cas où on peut faire encore mieux. C’est ce qu’on verra avec cmocean en section 3.

Quand la palette ne suffit pas : transformer l’échelle

Choisir la bonne palette ne suffit pas toujours. Quand les données sont très asymétriques, c’est l’échelle qu’il faut adapter, pas la palette. Les précipitations en sont un bon exemple : beaucoup de zones avec des valeurs faibles, quelques massifs avec des valeurs très élevées. La palette rain est le bon choix, mais sur une échelle linéaire, les nuances dans les zones moins arrosées sont écrasées par les extrêmes. Une transformation log corrige ça.

La transformation (log, sqrt…) s’applique directement dans scale_fill_* via l’argument trans. Elle ne modifie pas les données, seulement la façon dont l’échelle de couleur leur est mappée.

Les palettes divergentes : quand le centre a du sens

cmocean propose aussi des palettes divergentes, et c’est l’occasion de revenir sur un point de la section 1 : une palette divergente n’est légitime que si le centre de la palette correspond à une valeur qui a du sens dans les données.

L’erreur classique : utiliser une palette bleu-blanc-rouge pour des températures absolues. Ça semble intuitif (le bleu pour le froid, le rouge pour le chaud) mais ça induit une lecture fausse. Où met-on le blanc ? À 0 °C ? À la moyenne de la période ? Le choix est arbitraire, et la carte suggère qu’il existe un seuil naturel là où il n’y en a pas.

En revanche, sur une différence ou un écart par rapport à une référence, le centre a du sens. Prenons l’écart de précipitations entre juillet et janvier : zéro signifie que les deux mois sont aussi arrosés l’un que l’autre, le brun indique un juillet plus sec, le vert un juillet plus humide. La palette divergente traduit immédiatement cette symétrie.

Le choix d’une palette n’est pas esthétique. Une palette séquentielle suppose qu’il n’y a pas de centre naturel dans les données. Une palette divergente suppose qu’il y en a un. Une palette qualitative suppose que les catégories sont équivalentes. Se tromper, c’est introduire une structure dans les données qui n’existe pas.

Dans le prochain article de la série, on s’attaque aux palettes qualitatives : combien de couleurs peut-on vraiment distinguer, et que faire quand on a trop de catégories ?

Quelques règles à garder en tête

Le jeu de test reste intouché pendant tout le grid search. L’utiliser pour choisir max_depth reviendrait à tricher : les performances mesurées seraient trop optimistes.

Le coût computationnel peut grimper vite. Ici on a optimisé un seul hyperparamètre. Dans les faits, il y en a souvent 3 ou 4 à optimiser simultanément. Si on teste 4 valeurs pour 4 hyperparamètres, on se retrouve avec 4⁴ = 256 configurations à tester, sur chaque fold de la CV. Avec 5 folds, cela reviendrait à entraîner 1280 modèles !

Il existe des alternatives au grid search exhaustif. La recherche aléatoire (random search) tire des combinaisons au hasard : souvent presque aussi efficace pour un coût bien moindre. La recherche bayésienne cible intelligemment les zones prometteuses. Ces méthodes, ainsi que d’autres hyperparamètres et modèles bien plus puissants, font partie de ce qu’on explore ensemble dans la formation.

Le principe

Au lieu d’un seul split, on découpe les données en k sous-ensembles de taille égale, appelés folds. À chaque itération, un fold différent joue le rôle de jeu de test, et les k-1 autres servent à l’entraînement. On entraîne donc k modèles, et on obtient k scores qu’on agrège ensuite.

Naviguez entre les itérations pour voir comment les folds se succèdent. Chaque carré représente une observation.

L’avantage clé : à la fin des k itérations, chaque observation a servi exactement une fois comme donnée de test. On ne gaspille rien, et l’estimation des performances n’est plus tributaire d’un seul tirage.

Implémenter la CV avec vfold_cv() et fit_resamples()

Avec rsample, on crée les folds avec vfold_cv(). Comme pour le train/test split, on stratifie sur la variable cible.

# 5 folds stratifiés
set.seed(2025)
folds <- vfold_cv(Sonar, v = 5, strata = Class)

# Définition du modèle
modele <- decision_tree() |>
  set_engine("rpart") |>
  set_mode("classification")

# fit_resamples() entraîne et évalue sur chaque fold automatiquement
resultats_cv <- fit_resamples(
  modele,
  Class ~ .,
  resamples = folds,
  metrics   = metric_set(accuracy)
)

# Score moyen et erreur standard sur les 5 folds
collect_metrics(resultats_cv)

# A tibble: 1 × 6
  .metric  .estimator  mean     n std_err .config        
  <chr>    <chr>      <dbl> <int>   <dbl> <chr>          
1 accuracy binary     0.731     5  0.0329 pre0_mod0_post0

collect_metrics() retourne la moyenne des scores sur les k folds et l’erreur standard (std_err), qui quantifie la précision de cette estimation : plus elle est faible, plus la moyenne est fiable.

Combien de folds ?

Les valeurs usuelles sont v = 5 ou v = 10. Avec k = 5, chaque modèle est entraîné sur 80% des données et évalué sur 20% : un bon compromis entre temps de calcul et précision de l’estimation. On passe à v = 10 quand on veut serrer l’estimation au maximum et qu’on a le temps de calcul.

La k-fold répétée

La repeated k-fold cross-validation consiste à répéter la k-fold plusieurs fois avec des découpages aléatoires différents. Par exemple, une 5-fold répétée 3 fois produit 15 évaluations (5 folds × 3 répétitions) dont on agrège les scores. L’intérêt : réduire encore la variance de l’estimation, surtout sur les petits jeux de données. Le coût : multiplier le temps de calcul par le nombre de répétitions. Dans rsample, il suffit d’ajouter l’argument repeats à vfold_cv().

Le Leave-One-Out

Dans cette variante extrême, chaque observation constitue à son tour le jeu de test : on entraîne autant de modèles qu’il y a d’observations. L’estimation est quasi sans biais, mais le coût computationnel est prohibitif dès que le jeu dépasse quelques centaines d’observations. À réserver aux très petits jeux de données, et peu utilisé en pratique.

CV spatiale et temporelle

Si vos données ont une structure spatiale ou temporelle, un découpage aléatoire en folds introduit une fuite d’information, exactement comme pour le train/test split. Les packages spatialsample et rsample proposent des variantes adaptées : spatial_clustering_cv() pour les données géolocalisées, sliding_window() pour les séries temporelles. Le principe reste le même, seule la façon de construire les folds change.

Et ensuite : le tuning des hyperparamètres

La validation croisée est aussi le cadre standard pour optimiser les hyperparamètres d’un modèle : plutôt que d’évaluer un seul modèle, on évalue toute une série de configurations et on retient la meilleure. C’est ce qu’on appelle le grid search avec CV. C’est précisément l’objet d’un prochain tutoriel.

1. Le placeholder .

Le pipe magrittr permet d’utiliser un placeholder . pour contrôler où passe l’objet :

# Avec %>% : on peut placer l'objet ailleurs que comme premier argument
iris %>%
  lm(Sepal.Length ~ Sepal.Width, data = .)

Le pipe natif |> ne supporte pas directement cette syntaxe, mais deux solutions s’offrent à vous.

Option 1 : utiliser le placeholder _ (R ≥ 4.2.0)

# Avec |> (R ≥ 4.2.0) : placeholder _
iris |>
  lm(Sepal.Length ~ Sepal.Width, data = _)

iris |> head(_)  # argument positionnel
iris |> plot(x = _, y = _)  # plusieurs placeholders

Option 2 : utiliser une fonction anonyme (R ≥ 4.1.0)

# Avec |> : fonction anonyme
iris |>
  (\(x) lm(Sepal.Length ~ Sepal.Width, data = x))()

# Sans pipe : fonction classique
ma_fonction  : fonction anonyme
5 |> (\(x) x * 2)()  # retourne aussi 10

2. Compatibilité

• %>% fonctionne sur toutes les versions de R (si vous chargez magrittr)
• |> nécessite R ≥ 4.1.0

Si vous partagez du code avec des personnes utilisant des versions anciennes de R, privilégiez %>%.

Pourquoi séparer ses données ?

Lorsqu’on construit un modèle de machine learning, on a deux objectifs contradictoires :

1. apprendre des patterns dans nos données (entraînement) ;
2. s’assurer que ces patterns se généralisent à de nouvelles données (évaluation).

Si on utilise les mêmes données pour ces deux étapes, on ne peut pas savoir si notre modèle a vraiment appris quelque chose d’utile ou s’il a simplement mémorisé nos données d’entraînement.

Notre jeu de données exemple

On va utiliser le dataset palmerpenguins qui contient des mesures morphologiques sur 3 espèces de manchots en Antarctique.

library(palmerpenguins)
library(tidyverse)
library(rsample)

# Nettoyons les données
penguins_clean <- penguins |> 
  drop_na()

# Aperçu des données
glimpse(penguins_clean)

Rows: 333
Columns: 8
$ species           <fct> Adelie, Adelie, Adelie, Adelie, Adelie, Adelie, Adel…
$ island            <fct> Torgersen, Torgersen, Torgersen, Torgersen, Torgerse…
$ bill_length_mm    <dbl> 39.1, 39.5, 40.3, 36.7, 39.3, 38.9, 39.2, 41.1, 38.6…
$ bill_depth_mm     <dbl> 18.7, 17.4, 18.0, 19.3, 20.6, 17.8, 19.6, 17.6, 21.2…
$ flipper_length_mm <int> 181, 186, 195, 193, 190, 181, 195, 182, 191, 198, 18…
$ body_mass_g       <int> 3750, 3800, 3250, 3450, 3650, 3625, 4675, 3200, 3800…
$ sex               <fct> male, female, female, female, male, female, male, fe…
$ year              <int> 2007, 2007, 2007, 2007, 2007, 2007, 2007, 2007, 2007…

# Répartition des espèces
ggplot(penguins_clean) + 
  geom_bar(aes(x = species, fill = species), show.legend = FALSE) +
  geom_text(stat = "count", aes(x = species, label = after_stat(count)), vjust = -0.5, size = 4) +
  scale_fill_manual(values = penguin_colours) +
  labs(x = "Espèce", y = "Nombre d'observations", title = "Répartition des espèces")

Notre objectif sera de prédire l’espèce d’un manchot à partir de ses mesures morphologiques (longueur et profondeur du bec, longueur de la nageoire, masse corporelle).

Le split simple : 80/20 ou 70/30 ?

On entend souvent “80% train, 20% test” ou “70/30”, mais la bonne proportion dépend de votre jeu de données.

Le principe à retenir : l’ensemble de test doit contenir suffisamment d’observations pour être statistiquement représentatif. En pratique, on vise au minimum 30 observations par classe en classification, et idéalement 100+ observations au total pour avoir des métriques stables.

Quelques repères :

• beaucoup de données (> 5000 observations) : 80/20 ou même 90/10 ;

  → exemple : avec 10000 obs, 10% = 1000 en test, largement suffisant

• données moyennes (500 - 5000 observations) : 75/25 ou 70/30 ;

  → compromis entre apprendre suffisamment et évaluer correctement

• peu de données (< 500 observations) : 70/30 minimum, ou privilégiez la validation croisée.

  → important d’avoir au moins 30 obs par classe dans le test

Avec nos 333 manchots, on a relativement peu de données. Un split 70/30 nous donnera ~100 manchots en test, ce qui est le minimum pour évaluer le modèle de manière fiable. En dessous, il faudrait envisager la validation croisée.

# Split 70/30
set.seed(123)  # Pour la reproductibilité
split <- initial_split(penguins_clean, prop = 0.7)

train_data <- training(split)
test_data <- testing(split)

Observations dans train : 233

Observations dans test : 100

Le split stratifié : préserver les proportions

# Split stratifié sur la variable species
split_stratified <- initial_split(
  penguins_clean, 
  prop = 0.7,
  strata = species  # Préserve les proportions d'espèces
)

train_strat <- training(split_stratified)
test_strat <- testing(split_stratified)

Séries temporelles : le split chronologique

Pour les données temporelles, le split aléatoire n’a aucun sens ! On veut prédire le futur, pas des moments aléatoires du passé.

library(rsample)

# Split temporel avec rsample
ts_split <- initial_time_split(penguins_ts, prop = 0.7)

train_ts <- training(ts_split) |> mutate(set = "Train")
test_ts <- testing(ts_split) |> mutate(set = "Test")

# Combinons pour le plot
penguins_split <- bind_rows(train_ts, test_ts)

# Visualisation
ggplot(penguins_split, aes(date, body_mass_g, color = set)) +
  geom_line(linewidth = 1) +
  scale_color_manual(values = c("Train" = "#6BAED6", "Test" = "#F17D52")) +
  labs(
    title = "Split temporel avec rsample",
    x = "Date", 
    y = "Masse corporelle (g)",
    color = NULL
  ) +
  theme_minimal()

Données spatiales : spatialsample et autocorrélation

# Conversion en objet sf
penguins_sf <- st_as_sf(
  penguins_spatial, 
  coords = c("longitude", "latitude"),
  crs = 4326  # Système de coordonnées WGS84
)

# Split spatial : on crée 2 groupes (équivalent train/test)
spatial_split <- spatial_clustering_cv(
  penguins_sf,
  v = 2  # 2 groupes seulement pour simuler train/test
)

# Récupérons le premier split (groupe 1 = train, groupe 2 = test)
train_spatial <- analysis(spatial_split$splits[[1]]) |> mutate(set = "Train")
test_spatial <- assessment(spatial_split$splits[[1]]) |> mutate(set = "Test")

# Combinons pour visualisation
spatial_combined <- bind_rows(train_spatial, test_spatial)

# Extrayons les coordonnées pour ggplot
spatial_coords <- spatial_combined |>
  mutate(
    longitude = st_coordinates(spatial_combined)[,1],
    latitude = st_coordinates(spatial_combined)[,2]
  ) |>
  st_drop_geometry()

# Visualisation
ggplot(spatial_coords, aes(longitude, latitude, color = set)) +
  geom_point(size = 2.5, alpha = 0.7) +
  scale_color_manual(values = c("Train" = "#6BAED6", "Test" = "#F17D52")) +
  labs(
    title = "Split spatial avec clustering",
    x = "Longitude",
    y = "Latitude",
    subtitle = "Les clusters géographiques sont séparés entre train et test",
    color = NULL
  ) +
  coord_quickmap()

Trois pièges à éviter

# MAUVAIS : fuite de données
data_scaled <- penguins_clean |>
  mutate(across(where(is.numeric), scale)) # Utilise mean/sd de TOUT le jeu (train + test)
split <- initial_split(data_scaled)

# BON : standardiser séparément
# 1. D'abord splitter les données brutes
split <- initial_split(penguins_clean, strata = species)
train <- training(split)
test <- testing(split)

# 2. Identifier les variables numériques à standardiser
num_vars <- train |> select(where(is.numeric)) |> names()

# 3. Calculer mean/sd UNIQUEMENT sur le train
train_params <- train |>
  summarise(across(
    all_of(num_vars),
    list(mean = mean, sd = sd),  # Calcule moyenne et écart-type
    .names = "{.col}_{.fn}"       # Nomme les colonnes : var_mean, var_sd
  ))

# 4. Fonction pour standardiser : (x - mean) / sd
standardize <- function(data, params, vars) {
  data |>
    mutate(across(
      all_of(vars),
      ~ (. - params[[paste0(cur_column(), "_mean")]]) /  # Soustrait la moyenne du train
        params[[paste0(cur_column(), "_sd")]]            # Divise par l'écart-type du train
    ))
}

# 5. Appliquer les MÊMES paramètres (du train) au train ET au test
train_scaled <- standardize(train, train_params, num_vars)
test_scaled <- standardize(test, train_params, num_vars)  # Utilise les stats du TRAIN

# Simulons un dataset déséquilibré  
set.seed(123)
chinstrap_sample <- penguins_clean |> 
  filter(species == "Chinstrap") |> 
  slice_sample(n = 15)
other_species <- penguins_clean |> 
  filter(species != "Chinstrap")
imbalanced_penguins <- bind_rows(chinstrap_sample, other_species)

# Split stratifié 70/30
split_imbalanced <- initial_split(imbalanced_penguins, prop = 0.7, strata = species)

# Combien de Chinstrap dans le test ?
test_imbalanced <- testing(split_imbalanced)
table(test_imbalanced$species)

   Adelie Chinstrap    Gentoo 
       43         8        34 

Guide de décision

Pour aller plus loin

Dans les prochains tutoriels de cette série :

• validation croisée : k-fold, leave-one-out, nested CV
• recipes : preprocessing et feature engineering

1. Les CNN gagnent… mais pas toujours

Les CNN surpassent l’approche classique, c’est vrai. Mais creusons un peu (Figure 2) :

• Sur l’accuracy globale  ? L’amélioration est modeste.
• Sur la balanced accuracy (moyenne des performances par classe) ? Là, c’est une vraie différence !
• Sur les métriques spécifiques au plancton (précision et rappel) ? Gain significatif, surtout pour le rappel !

Traduction : si vous avez beaucoup d’exemples d’une classe, une méthode simple marchera très bien. Les CNN brillent surtout quand les données sont rares, précisément le cas des espèces planctoniques intéressantes pour les biologistes.

Notez aussi le rôle du classifieur aléatoire : il obtient 55 à 63% d’accuracy sur les datasets dominés par les débris (IFCB, ISIIS, UVP6) simplement en prédisant toujours “détritus”. C’est pour ça que nous privilégions les autres métriques, qui révèlent la vraie performance.

2. Plus gros n’est pas toujours mieux

Voici la vraie surprise : un petit CNN (MobileNetV2) performe aussi bien (voire mieux) qu’un gros (EfficientNetV2 XL) (Figure 3).

Pourquoi ? Les images de plancton sont petites (~100×100 pixels) et en niveaux de gris. Il n’y a tout simplement pas autant d’information à extraire qu’on pourrait le penser.

Le gros modèle (208 millions de paramètres) n’a rien de plus à apprendre qu’un petit (4,5 millions). Il sur-ajuste même parfois sur le dataset UVP6, le plus petit et le plus déséquilibré de notre étude.

Et si on compresse encore plus ?

Plus étonnant encore : on peut compresser les caractéristiques extraites par le CNN de 1792 à seulement 50 valeurs via une analyse en composantes principales (ACP) sans perte de performance (Figure 4).

3. Les features > le classifieur

Peu importe que vous utilisiez un Random Forest ou un réseau de neurones pour faire la classification finale. Ce qui compte vraiment, c’est la qualité des features (ou caractéristiques) que vous extrayez des images (Figure 5).

Ce que montre cette figure :

• Features manuelles + RF : performances moyennes
• Features CNN + MLP₆₀₀ : excellentes performances
  
• Features CNN + RF : excellentes performances, quasi identiques au MLP

Traduction : changer de classifieur (MLP → RF) en gardant les bonnes features (CNN) ne change presque rien. Mais garder le même classifieur (RF) en changeant de features (manuelles → CNN) change tout !

C’est pour ça que les CNN marchent mieux : ils apprennent automatiquement les bonnes caractéristiques, alors qu’avec l’approche classique, il faut les définir à la main (et on passe souvent à côté de détails importants comme les textures fines).

4. L’importance des poids de classes

Sur des données aussi déséquilibrées, pondérer les erreurs par l’inverse de la fréquence des classes change tout (Figure 6).

La pondération améliore significativement les performances, surtout pour le Random Forest, pour les CNN le gain est plus modeste mais reste significatif.

Sans pondération, les modèles apprennent surtout à bien classifier les débris (majoritaires) et négligent les espèces rares. Avec pondération, on force le modèle à accorder autant d’importance à une larve de poisson rare qu’à un copépode² abondant.

La pondération améliore le rappel (on rate moins d’organismes rares) mais peut légèrement diminuer la précision (un peu plus de “faux positifs” parmi les classes planctoniques). C’est un compromis acceptable quand l’objectif est de ne pas manquer les espèces rares.

La stratégie : ACP + clustering

Une fois les données en main, j’ai appliqué un pipeline d’analyse classique en data science pour ce type de problème exploratoire.

1. Préparer les données

J’ai d’abord agrégé les images par profil vertical. Chaque profil devient une “observation” caractérisée par les abondances de chaque groupe taxonomique (copépodes, Rhizaria, Trichodesmium, appendiculaires, etc.).

Résultat : un tableau de contingence classique avec lignes = profils, colonnes = groupes taxonomiques.

Avant l’analyse, j’ai appliqué une transformation de Hellinger (Legendre et Legendre 2012) sur les abondances. C’est une étape souvent négligée mais essentielle quand on étudie des compositions de communautés. En effet, les abondances brutes posent problème : certains groupes sont naturellement très abondants (copépodes), d’autres rares (gros organismes). Sans transformation, l’ACP sera dominée par les groupes les plus abondants et on perdrait l’information sur la composition relative de la communauté.

La transformation de Hellinger convertit les abondances en proportions, puis applique une racine carrée. Ainsi, on analyse la composition de la communauté plutôt que les abondances brutes. Cette approche est particulièrement utile pour les analyses de communautés écologiques : elle préserve les distances écologiques tout en donnant du poids aux espèces rares.

2. Réduire la dimension (ACP)

J’avais 28 groupes de plancton en variables, souvent corrélées entre elles (certains groupes cooccurrent fréquemment). Difficile de visualiser et d’interpréter tout ça simultanément.

L’Analyse en Composantes Principales (ACP) condense cette information en quelques axes principaux qui capturent la majorité de la variance. C’est comme compresser une photo en JPEG : on garde l’essentiel de l’information en réduisant la taille.

J’ai conservé les 5 premières composantes principales (Figure 2), qui capturaient environ 65% de la variance totale. Au lieu de travailler avec 28 variables, je travaille avec 5 axes synthétiques qui résument les patterns principaux de composition des communautés.

Le choix de 5 composantes est pragmatique : les résultats de clustering restent similaires que j’en utilise 3, 5 ou 7.

3. Identifier les groupes (clustering)

Une fois les données réduites aux 5 premières composantes principales, j’ai appliqué un clustering hiérarchique avec la méthode de Ward pour regrouper les profils similaires.

La méthode de Ward minimise la variance au sein de chaque cluster, ce qui produit des groupes compacts et bien séparés. Le dendrogramme (arbre de classification) a révélé une structure claire : un grand saut entre 3 et 4 clusters, indiquant que 3 groupes (Figure 3) se distinguaient naturellement dans les données.

4. Valider et interpréter

La dernière étape est cruciale : les clusters ont-ils du sens écologiquement ?

J’ai validé le choix des 3 clusters avec :

• la cohérence du dendrogramme (grand saut = séparation nette) ;
• l’interprétation écologique (est-ce que ça fait sens ?).

Bonne nouvelle : les trois communautés identifiées correspondaient bien à des grands biomes océaniques distincts.

Communauté 1 : Enrichie en Trichodesmium

Localisation : Atlantique intertropical, eaux chaudes pauvres en nutriments

Organisme dominant : Colonies de cyanobactéries Trichodesmium, visibles à l’œil nu sous forme de filaments flottants

Rôle écologique : Ces cyanobactéries fixent l’azote atmosphérique et apportent cet élément vital dans des eaux autrement pauvres en nutriments. Elles forment ainsi la base des réseaux trophiques spécifiques dans les gyres subtropicaux.

Communauté 2 : Enrichie en copépodes

Localisation : Hautes latitudes (Arctique, Antarctique, Atlantique Nord) et zones d’upwelling (remontées d’eaux profondes riches en nutriments)

Organisme dominant : Copépodes, petits crustacés de quelques millimètres, les animaux les plus abondants de la planète

Rôle écologique : Les copépodes sont un maillon clé des réseaux trophiques marins : ils broutent le phytoplancton et sont consommés à leur tour par de plus gros organismes. Ces zones affichent une productivité biologique exceptionnelle.

Communauté 3 : Enrichie en Rhizaria

Localisation : Zones océaniques ouvertes pauvres en nutriments et certaines zones d’upwelling côtier

Organisme dominant : Rhizaria, protistes unicellulaires dotés d’un squelette minéral (silice ou carbonate de calcium)

Rôle écologique : Les Rhizaria sont des acteurs clés du cycle du carbone océanique. Leurs squelettes denses coulent rapidement, emportant le carbone organique vers les profondeurs. Ce mécanisme contribue au stockage à long terme du CO₂ dans l’océan.

Ces trois communautés ne sont pas aléatoires : elles sont fortement corrélées aux conditions environnementales (température, nutriments…) et aux grandes régions biogéographiques de l’océan.

Construire par petites briques

Je ne pars pas d’un grand plan structuré. Je pars de plein de petites idées qui émergent au fil du temps :

• une analogie qui m’est venue en courant pour expliquer le principe du machine learning ;
• le piège classique que j’ai vu dix fois en formant des étudiants (oublier de standardiser les variables) ;
• une visualisation pour comprendre la descente de gradient ;
• une formulation claire pour expliquer précision et rappel.

Pendant des semaines (parfois des mois), je collecte ces petites briques. Je les note, je les teste autour de moi, je les affine. Certaines viennent de mon expérience de recherche, d’autres d’explications à des collègues, d’autres encore de mes propres galères d’apprentissage.

Ensuite seulement, j’assemble. Je regarde toutes ces briques et je cherche l’ordre logique : qu’est-ce qui doit venir en premier ? Quel exercice prépare le terrain pour le suivant ? Quelle analogie aide à comprendre quel concept ?

C’est comme un puzzle : les pièces existent déjà, il faut juste trouver comment elles s’emboîtent pour former un chemin d’apprentissage cohérent. Une fois cette structure posée, place à la création concrète.

Les exercices d’abord

Je ne commence pas par rédiger la théorie. Je commence par concevoir les exercices.

Une fois que j’ai mes briques conceptuelles, je cherche des datasets qui fonctionnent pour les illustrer. Je commence par chercher des données réelles avec un sujet intéressant (j’utilise beaucoup l’UCI Machine Learning Repository). Si nécessaire, j’adapte : je simplifie, je nettoie, je sélectionne les variables pertinentes. En dernier recours, je crée des données synthétiques.

L’objectif : des données ni trop faciles ni trop difficiles, avec un sujet qui parle. On apprend mieux quand on comprend ce qu’on manipule.

Pour chaque dataset, je conçois des exercices progressifs (du guidé vers l’autonome) avec des solutions commentées qui expliquent le raisonnement, pas juste le code. Et surtout, je teste : l’exercice fonctionne-t-il bien avec ces données ? Est-il faisable en formation dans le temps imparti ?

Créer les supports pédagogiques

Je compile tout en HTML avec Quarto. Le résultat : un site web complet pour la formation.

Pour chaque jour :

• des notes de cours complètes et interactives (explications détaillées, code commenté) ;
• des diapositives pour suivre pendant la session.

Pages transversales :

• un glossaire des termes techniques ;
• une page dédiée à l’utilisation des LLM.

Tout est accessible dans le navigateur, consultable pendant et après la formation. Les apprenants peuvent réviser, approfondir, chercher un concept dans le glossaire.

Préparer l’environnement technique

Mes formations utilisent Posit Cloud Instructor. Les apprenants n’installent rien : tout fonctionne dans le navigateur, environnement identique pour tous, accès en 30 secondes.

Je prépare un projet R complet qu’ils chargent dans leur espace Posit Cloud :

• les squelettes de scripts R pour chaque exercice ;
• un datapackage R contenant tous les datasets ;
• les packages pré-installés et versions contrôlées grâce à renv.

Le jour J : zéro problème technique, on se concentre sur l’apprentissage.