Regroupez d’un coup les lignes et les colonnes d’une matrice de données et lisez les blocs de valeurs hautes et basses — de la fonction heatmap() de base à la jolie pheatmap() annotée et aux heatmaps génomiques complexes
Tracez une heatmap de regroupement en R, étape par étape. Commencez par la fonction heatmap() de base, rendez-la jolie et annotée avec pheatmap() (la figure emblématique), ajoutez des annotations de lignes/colonnes et des couleurs de dendrogramme, puis passez à l’échelle avec ComplexHeatmap et la heatmap interactive heatmaply pour des matrices de type expression génique. Une heatmap regroupe simultanément les échantillons et les variables, de sorte que les blocs de valeurs similaires se retrouvent côte à côte.
scale() (ou laissez la fonction le faire avec scale = "row").heatmap() est livrée avec R et ne nécessite rien d’autre ; pheatmap() est le cheval de bataille du quotidien — plus joli, avec des annotations de lignes/colonnes et cutree_rows pour encadrer les regroupements.ComplexHeatmap dispose et annote plusieurs heatmaps côte à côte, et heatmaply rend la heatmap interactive (survol pour les valeurs, zoom).Vous avez exécuté une classification hiérarchique et tracé le dendrogramme — mais un arbre vous montre seulement comment les échantillons se groupent, pas pourquoi. Une heatmap répond au pourquoi : elle colore chaque valeur de la matrice et réordonne les lignes et les colonnes par regroupement, de sorte que vous pouvez lire directement quelles variables sont hautes ou basses dans chaque regroupement d’échantillons. C’est la figure de référence pour les études d’expression génique (gènes × échantillons), mais elle fonctionne pour toute matrice numérique propre — voitures × spécifications, clients × métriques, régions × indicateurs.
Le mécanisme est simple. La classification hiérarchique est exécutée sur les lignes et sur les colonnes ; les deux sont réordonnées pour placer les éléments similaires côte à côte ; une échelle de couleurs associe chaque valeur ; et la matrice est tracée. Le gain est que les blocs de cellules de couleur similaire deviennent visibles — et ces blocs sont exactement les variables qui caractérisent chaque regroupement d’échantillons.
Cette leçon parcourt l’échelle pratique : la fonction de base heatmap() (toujours disponible), puis la jolie pheatmap() annotée (la figure que vous publierez réellement), la version améliorée heatmap.2(), et enfin les options costaudes ComplexHeatmap et interactives pour des données de type expression génique. Chaque bloc est expliqué avant d’être exécuté, chaque exemple est autonome, et nous terminons par l’outil à privilégier selon le cas.
Nous utilisons le jeu de données intégré mtcars (32 voitures × 11 spécifications numériques) comme matrice de démonstration. L’étape la plus importante est de le standardiser : une heatmap colore des valeurs brutes, et mtcars mélange de petits nombres (wt, en milliers de livres) avec de grands (hp, la puissance). Sans standardisation, hp et disp domineraient l’échelle de couleurs et le reste de la matrice paraîtrait plat. scale() centre chaque colonne sur une moyenne de 0 et la met à l’échelle d’un écart-type unitaire :
df <- scale(mtcars)
head(round(df, 2)[, 1:6]) mpg cyl disp hp drat wt
Mazda RX4 0.15 -0.10 -0.57 -0.54 0.57 -0.61
Mazda RX4 Wag 0.15 -0.10 -0.57 -0.54 0.57 -0.35
Datsun 710 0.45 -1.22 -0.99 -0.78 0.47 -0.92
Hornet 4 Drive 0.22 -0.10 0.22 -0.54 -0.97 0.00
Hornet Sportabout -0.23 1.01 1.04 0.41 -0.84 0.23
Valiant -0.33 -0.10 -0.05 -0.61 -1.56 0.25Chaque valeur est maintenant un score z — de combien d’écarts-types une voiture est au-dessus (positif) ou en dessous (négatif) de la moyenne pour cette spécification. C’est ce que les couleurs vont encoder.
scale() vous donne la standardisation en score z ci-dessus, et c’est le bon choix par défaut pour une heatmap. Deux autres rééchelonnages reviennent souvent, et chacun répond à une question différente — choisissez selon ce que vous voulez que les couleurs signifient.
La normalisation min–max comprime chaque colonne dans la plage 0–1 avec (x - min) / (max - min). Tournez-vous vers elle quand vous voulez que les couleurs se lisent comme « du bas vers le haut à l’intérieur de la plage observée » et que l’étalement n’a pas d’importance — pratique pour les variables avec des planchers et plafonds stricts (taux, proportions, scores sur 100) :
minmax <- function(x) (x - min(x)) / (max(x) - min(x))
df_minmax <- apply(mtcars, 2, minmax)
head(round(df_minmax, 2)[, 1:6]) mpg cyl disp hp drat wt
Mazda RX4 0.45 0.5 0.22 0.20 0.53 0.28
Mazda RX4 Wag 0.45 0.5 0.22 0.20 0.53 0.35
Datsun 710 0.53 0.0 0.09 0.14 0.50 0.21
Hornet 4 Drive 0.47 0.5 0.47 0.20 0.15 0.44
Hornet Sportabout 0.35 1.0 0.72 0.43 0.18 0.49
Valiant 0.33 0.5 0.38 0.19 0.00 0.50Chaque colonne va maintenant de 0 (la voiture la plus basse) à 1 (la plus haute). Contrairement aux scores z, les valeurs aberrantes ne sont pas signalées — elles se posent simplement au bord 0 ou 1 — donc le min–max est plus tolérant à l’asymétrie mais masque à quel point une valeur est extrême.
La normalisation par percentile (rang) remplace chaque valeur par sa position de rang sur une échelle 0–1, la plus résistante aux valeurs aberrantes des trois : une seule valeur énorme ne peut pas étirer l’échelle car les rangs sont régulièrement espacés. Utilisez-la pour des données fortement asymétriques où seul l’ordre compte, pas la distance :
percentize <- function(x) (rank(x) - 1) / (length(x) - 1)
df_rank <- apply(mtcars, 2, percentize)
head(round(df_rank, 2)[, 1:6]) mpg cyl disp hp drat wt
Mazda RX4 0.60 0.45 0.40 0.39 0.66 0.26
Mazda RX4 Wag 0.60 0.45 0.40 0.39 0.66 0.35
Datsun 710 0.76 0.16 0.16 0.19 0.61 0.19
Hornet 4 Drive 0.66 0.45 0.55 0.39 0.24 0.48
Hornet Sportabout 0.45 0.79 0.85 0.65 0.31 0.58
Valiant 0.42 0.45 0.52 0.29 0.02 0.65Laquelle privilégier dans une heatmap : le score z (scale()) est le choix par défaut — il centre chaque variable et montre à quel point une valeur est inhabituelle, ce qui est précisément ce qui fait ressortir les blocs. Passez au min–max quand vous avez besoin d’une échelle de couleurs littérale de 0 à 1, et au percentile quand quelques valeurs extrêmes domineraient sinon chaque couleur. Les trois mettent les variables sur un pied comparable ; elles diffèrent seulement par ce que « haut » et « bas » veulent dire.
Plusieurs packages R tracent des heatmaps, des fonctions en une ligne aux figures génomiques prêtes à publier :
heatmap() — R de base (package stats). Une heatmap statique simple, aucune installation requise.heatmap.2() — le package gplots. Une version améliorée de la fonction de base (clé de couleurs, plus de contrôle).pheatmap() — le package pheatmap. Des « jolies heatmaps » avec des annotations faciles et des réglages par défaut propres.heatmaply() — le package heatmaply. Une heatmap interactive (survol pour les valeurs, zoom).Heatmap() — le package Bioconductor ComplexHeatmap. Trace, annote et dispose plusieurs heatmaps complexes — la référence pour les données génomiques.Nous allons gravir cette échelle. Commencez par la fonction de base heatmap(), fixez-vous sur pheatmap() pour le travail quotidien, et réservez ComplexHeatmap pour les cas où vous devez empiler plusieurs matrices annotées.
heatmap()La fonction intégrée heatmap() (dans le package stats) ne nécessite aucune installation. Passez-lui une matrice numérique ; elle regroupe et réordonne à la fois les lignes et les colonnes et trace le résultat. Comme nous avons déjà standardisé df, nous fixons scale = "none" pour conserver nos propres scores z (la valeur par défaut est scale = "row") :
heatmap(df, scale = "none")
Les valeurs hautes sont tracées en rouge et les valeurs basses en jaune, avec le dendrogramme des lignes (voitures) à gauche et le dendrogramme des colonnes (spécifications) en haut. Les blocs sont déjà visibles : les voitures économiques à mpg élevé et faible poids se regroupent à l’écart des grosses voitures musclées à hp élevé.
Vous pouvez changer l’échelle de couleurs avec l’argument col et annoter les lignes et les colonnes avec des barres latérales colorées. colorRampPalette() construit un gradient lisse — ici un dégradé divergent rouge–jaune–bleu issu de RColorBrewer — et RowSideColors / ColSideColors marquent chaque ligne et colonne d’une couleur de classe :
library(RColorBrewer)
col <- colorRampPalette(brewer.pal(10, "RdYlBu"))(256)
heatmap(
df, scale = "none", col = col,
RowSideColors = rep(c("blue", "pink"), each = 16),
ColSideColors = c(rep("purple", 5), rep("orange", 6))
)
Les vecteurs de couleurs latérales doivent être aussi longs que le nombre de lignes (32 voitures) et de colonnes (11 spécifications) respectivement — ici un découpage rapide en deux blocs juste pour montrer le mécanisme. En pratique, vous passeriez une vraie variable de groupement.
heatmap.2()La fonction heatmap.2() (dans le package gplots) étend la fonction de base avec une clé de couleurs, le contrôle des traces et de nombreux arguments supplémentaires. L’utilitaire bluered() construit une échelle divergente lisse bleu–blanc–rouge ; nous désactivons les lignes de trace par cellule et l’encart de densité pour une figure propre :
library(gplots)
heatmap.2(
df, scale = "none", col = bluered(100),
trace = "none", density.info = "none"
)
Extras utiles : labRow / labCol pour réétiqueter, et un hclustfun personnalisé pour changer la liaison — p. ex. hclustfun = function(x) hclust(x, method = "ward.D2"). Pour les générateurs de couleurs, gplots offre aussi colorpanel(n, low, mid, high), redgreen(), greenred(), bluered() et redblue().
pheatmap()pheatmap() (le package « pretty heatmap ») est celui que vous utiliserez le plus. Il a des réglages par défaut propres, trace des dendrogrammes nets, et — la fonctionnalité clé — découpe le dendrogramme des lignes en groupes avec cutree_rows, en traçant un espace entre chaque regroupement pour que les blocs soient indéniables. C’est la figure emblématique :
library(pheatmap)
pheatmap(df, cutree_rows = 4)
L’argument cutree_rows = 4 découpe le dendrogramme des voitures en quatre regroupements et insère un espace entre eux — vous pouvez immédiatement lire les quatre groupes de voitures et les spécifications qui définissent chacun. Par défaut, pheatmap() regroupe avec la distance euclidienne et la liaison complète ; changez-les avec clustering_distance_rows et clustering_method (voir la leçon mesures de distance pour les compromis).
pheatmap() annote aussi les lignes et les colonnes directement à partir d’un data frame. Ici, nous marquons chaque voiture avec son nombre de cylindres (cyl) et sa transmission (am) sous forme de barre latérale colorée — la façon courante de superposer des groupes connus sur le regroupement :
library(pheatmap)
# Build an annotation data frame (row names must match df's rows)
annotation_row <- data.frame(
cyl = factor(mtcars$cyl),
am = factor(mtcars$am, labels = c("auto", "manual"))
)
rownames(annotation_row) <- rownames(mtcars)
pheatmap(
df, cutree_rows = 4,
annotation_row = annotation_row,
main = "mtcars clustering heatmap"
)
Les barres d’annotation confirment ce que le regroupement a trouvé : le nombre de cylindres suit les regroupements de voitures presque parfaitement, ce qui vous indique que cyl est l’une des variables qui définissent les groupes.
Une heatmap statique est parfaite pour l’impression, mais à l’écran vous voulez souvent survoler pour obtenir la valeur exacte ou zoomer sur une région. Le package heatmaply rend n’importe quelle heatmap interactive (il rend via plotly). Le code tient en une ligne — passez la matrice standardisée et, en option, le nombre de groupes de lignes et de colonnes :
library(heatmaply)
heatmaply(
scale(mtcars),
k_row = 4, # number of row groups to color
k_col = 2, # number of column groups to color
colors = "RdYlBu"
)Avec la version interactive, vous pouvez placer la souris sur n’importe quelle cellule pour lire son nom de ligne, son nom de colonne et sa valeur, et faire glisser pour sélectionner une région à zoomer. Une alternative plus ancienne, d3heatmap() (package d3heatmap), faisait la même chose mais n’est plus activement maintenue — préférez heatmaply :
# Legacy alternative (package no longer maintained)
library(d3heatmap)
d3heatmap(scale(mtcars), colors = "RdYlBu", k_row = 4, k_col = 2)Une heatmap est aussi un moyen rapide de voir où vos données sont manquantes avant de les modéliser. Associez chaque cellule à « présente » ou « manquante » et les trous — une colonne presque vide, des séries de valeurs manquantes dans l’ordre temporel — sautent aux yeux d’un coup d’œil. Nous utilisons le jeu de données intégré airquality, qui porte de vrais NA dans ses colonnes Ozone et Solar.R :
na_matrix <- is.na(airquality) # TRUE where a value is missing
heatmap(
matrix(as.integer(na_matrix), nrow = nrow(na_matrix),
dimnames = list(NULL, colnames(airquality))),
Rowv = NA, Colv = NA, scale = "none", # no clustering — keep the original order
col = c("grey90", "#3a86d4"), # present = grey, missing = azure
margins = c(7, 2), labRow = NA,
main = "Missing values in airquality"
)
Les cellules azur sont manquantes. En lisant les colonnes vers le bas, Ozone porte la plupart des trous — exactement ce que vous voulez savoir avant d’imputer ou de supprimer des lignes. Pour une version interactive qui met en évidence les NA et vous laisse survoler chaque trou, heatmaply::heatmaply_na(airquality) fait la même chose en un seul appel.
Lorsque vous devez disposer et annoter plusieurs heatmaps — la disposition classique d’expression génique où une matrice d’expression côtoie des pistes d’annotation pour la longueur, le type et le chromosome du gène — tournez-vous vers ComplexHeatmap (un package Bioconductor de Zuguang Gu). Installez-le une fois avec BiocManager :
if (!requireNamespace("BiocManager", quietly = TRUE)) install.packages("BiocManager")
BiocManager::install("ComplexHeatmap")La fonction centrale est Heatmap(). Un appel simple nomme la légende et les titres de lignes/colonnes. Nous protégeons l’exemple avec requireNamespace() afin que la page se rende même là où le package Bioconductor est absent :
if (requireNamespace("ComplexHeatmap", quietly = TRUE)) {
library(ComplexHeatmap)
ComplexHeatmap::Heatmap(
df,
name = "mtcars", # title of the color legend
column_title = "Variables", row_title = "Samples",
row_names_gp = grid::gpar(fontsize = 7) # text size for row names
)
} else {
cat("ComplexHeatmap is not installed in this render environment.")
}
Arguments utiles : show_row_names / show_column_names, les contrôles de regroupement clustering_distance_rows / clustering_method_rows (mêmes métriques et liaisons que hclust), et col pour un mappage de couleurs personnalisé construit avec circlize::colorRamp2().
ComplexHeatmap peut découper les lignes en blocs — soit par k-means (row_km = k, fixez d’abord une graine pour la reproductibilité), soit par une variable de groupement. Ici, nous découpons les voitures par leur nombre de cylindres :
library(ComplexHeatmap)
# Split rows by a grouping variable (number of cylinders)
Heatmap(
df, name = "mtcars",
row_split = mtcars$cyl,
row_names_gp = grid::gpar(fontsize = 7)
)
# Or split by k-means into 2 groups (set a seed so it reproduces)
set.seed(2)
Heatmap(df, name = "mtcars", row_km = 2)La classe HeatmapAnnotation() attache des barres d’annotation en haut (ou sur le côté) de la heatmap. Après avoir transposé la matrice de sorte que les échantillons soient en colonnes, nous annotons avec deux variables qualitatives (cyl, am) et une variable continue (mpg), chacune avec son propre mappage de couleurs :
library(ComplexHeatmap)
mat <- t(df) # variables in rows, cars in columns
col <- list(
cyl = c("4" = "green", "6" = "gray", "8" = "darkred"),
am = c("0" = "yellow", "1" = "orange"),
mpg = circlize::colorRamp2(c(17, 25), c("lightblue", "purple"))
)
ha <- HeatmapAnnotation(
cyl = factor(mtcars$cyl), am = factor(mtcars$am), mpg = mtcars$mpg,
col = col
)
Heatmap(mat, name = "mtcars", top_annotation = ha)Dans les données d’expression génique, les lignes sont des gènes et les colonnes des échantillons, et vous voulez généralement des pistes supplémentaires à côté de la heatmap d’expression — longueur du gène, type de gène, chromosome. ComplexHeatmap les dispose en additionnant des heatmaps avec +. C’est la figure pour laquelle le package a été conçu :
library(ComplexHeatmap)
# Example expression data shipped with ComplexHeatmap
expr <- readRDS(system.file("extdata", "gene_expression.rds", package = "ComplexHeatmap"))
mat <- as.matrix(expr[, grep("cell", colnames(expr))])
type <- gsub("s\\d+_", "", colnames(mat))
ha <- HeatmapAnnotation(df = data.frame(type = type))
Heatmap(mat, name = "expression", km = 5, top_annotation = ha,
show_row_names = FALSE, show_column_names = FALSE) +
Heatmap(expr$length, name = "length", width = unit(5, "mm"),
col = circlize::colorRamp2(c(0, 100000), c("white", "orange"))) +
Heatmap(expr$type, name = "type", width = unit(5, "mm")) +
Heatmap(expr$chr, name = "chr", width = unit(5, "mm"),
col = circlize::rand_color(length(unique(expr$chr))))Chaque + ajoute une heatmap alignée : la première est la matrice d’expression principale (découpée en 5 regroupements k-means de gènes), et les fines à sa droite portent les métadonnées par gène. Les gènes restent alignés en ligne à travers toutes, de sorte que vous pouvez lire la longueur, le type et le chromosome de chaque regroupement d’un coup d’œil.
| Votre situation | À privilégier |
|---|---|
| Coup d’œil rapide, rien d’installé | heatmap() de base |
| Une figure propre et annotée pour un rapport ou un article | pheatmap() (avec cutree_rows, annotation_row) |
Vous voulez une clé de couleurs et les extras de gplots |
heatmap.2() |
| Survoler pour les valeurs / zoomer à l’écran | heatmaply() |
| Plusieurs matrices annotées, données génomiques | ComplexHeatmap |
Pour le travail de regroupement au quotidien, pheatmap() est le juste milieu — joli, annoté, et tenant en une ligne.
Tracez votre propre jolie heatmap. Changez cutree_rows pour découper les voitures en un nombre différent de regroupements, ou remplacez scale(mtcars) par scale(USArrests) pour regrouper les États américains à la place. Cliquez sur Run.
Demandez à Prova « crée une heatmap de regroupement de mon propre data frame en R et annote-la par groupe » — elle répond avec du code pheatmap() (ou ComplexHeatmap) que vous pouvez exécuter sur votre propre matrice, puis vous aide à la standardiser, à choisir la distance de regroupement et à lire les blocs. The runtime is the judge. Demandez à Prova →
Ma heatmap est d’une seule couleur et ne montre rien. Vous avez oublié de standardiser. Une heatmap colore des magnitudes brutes, donc une seule colonne à grande échelle (comme hp ou un gène avec d’énormes comptages) aplatit tout le reste. Standardisez d’abord avec df <- scale(your_matrix) et passez scale = "none", ou laissez la fonction standardiser par ligne avec scale = "row".
Les lignes et les colonnes sont regroupées d’une façon que je ne veux pas. L’ordonnancement vient de la distance et de la liaison utilisées sous le capot. Dans pheatmap(), fixez clustering_distance_rows = "correlation" (ou "manhattan", …) et clustering_method = "ward.D2". Dans heatmap() de base, passez un hclustfun personnalisé. Voir mesures de distance pour choisir.
Il y a trop d’étiquettes de lignes et elles se chevauchent. Avec beaucoup de lignes, les étiquettes deviennent une bouillie illisible. Désactivez-les (pheatmap(df, show_rownames = FALSE), ou Heatmap(df, show_row_names = FALSE)), ou rapetissez-les (fontsize_row = 6). Pour les matrices très hautes, masquez les étiquettes et appuyez-vous plutôt sur le dendrogramme et les annotations.
Passez une matrice numérique à une fonction de heatmap. Le one-liner de base est heatmap(scale(mydata)) ; pour une version plus jolie et annotée, utilisez pheatmap(scale(mydata), cutree_rows = 4). Standardisez toujours la matrice avec scale() d’abord pour qu’une variable de grande magnitude ne domine pas les couleurs. Les deux fonctions regroupent et réordonnent les lignes et les colonnes automatiquement.
La fonction de base heatmap() est livrée avec R et ne nécessite aucune installation, mais son style est sobre et l’annoter est laborieux (vous construisez les barres latérales de couleurs à la main). pheatmap() (« pretty heatmap ») offre des réglages par défaut plus propres, trace de plus jolis dendrogrammes, découpe l’arbre en groupes avec cutree_rows, et annote les lignes et les colonnes directement à partir d’un data frame avec annotation_row / annotation_col. Pour la plupart des travaux, préférez pheatmap().
Elle exécute la classification hiérarchique deux fois — une fois sur les lignes et une fois sur les colonnes — puis réordonne les deux de sorte que les lignes similaires et les colonnes similaires se retrouvent côte à côte. C’est pourquoi des blocs de couleur similaire apparaissent : le regroupement met le semblable avec le semblable. Vous le contrôlez avec la distance (euclidienne, corrélation, …) et la méthode de liaison (complète, moyenne, Ward), exactement comme dans un dendrogramme. Pour regrouper sur un seul axe, fixez cluster_cols = FALSE (ou cluster_rows = FALSE).
Mettez les gènes en lignes et les échantillons en colonnes, standardisez par ligne pour que chaque gène soit comparable, et utilisez pheatmap() pour une seule matrice annotée ou ComplexHeatmap lorsque vous avez besoin de plusieurs pistes alignées (expression + longueur du gène + type + chromosome). ComplexHeatmap::Heatmap() vous permet d’empiler des heatmaps avec + et de découper les gènes en regroupements avec row_km ou row_split. Installez-le depuis Bioconductor avec BiocManager::install("ComplexHeatmap").
Utilisez heatmaply() du package heatmaply : heatmaply(scale(mydata), k_row = 4, k_col = 2). Elle rend via plotly, vous pouvez donc survoler n’importe quelle cellule pour lire sa valeur et zoomer sur des régions. Elle accepte les mêmes arguments de regroupement qu’une heatmap statique.
Standardisez les données USArrests et tracez une pheatmap qui découpe les lignes (États américains) en 3 regroupements.
# scale(USArrests) gives the matrix; cutree_rows = 3 cuts the row tree into 3 groupslibrary(pheatmap)
df <- scale(USArrests)
pheatmap(df, cutree_rows = 3)
library(pheatmap)
df <- scale(USArrests)
pheatmap(df, cutree_rows = 3)Conceptuel. Deux voitures occupent des lignes adjacentes de la heatmap et les deux lignes sont presque de la même teinte de rouge. Que vous indique cela ? (Réponse : elles sont similaires — des lignes adjacentes signifient que le regroupement des lignes les a groupées, et les couleurs concordantes signifient qu’elles ont des valeurs similaires sur l’ensemble des variables. Le dendrogramme des lignes sur le côté confirme à quel point elles fusionnent étroitement.)
Conceptuel. Vous tracez une heatmap de comptages de gènes bruts (non standardisés) et toute la figure est un unique bloc d’une seule couleur sauf deux lignes éclatantes. Qu’est-ce qui a mal tourné ? (Réponse : vous n’avez pas standardisé. Deux gènes à forte expression dominent la plage de couleurs et aplatissent tout le reste. Standardisez par ligne — p. ex. scale = "row" ou t(scale(t(mat))) — pour que chaque gène soit sur sa propre échelle z.)
Une heatmap est le moyen le plus rapide de voir le résultat du regroupement d’une matrice de données : elle exécute une classification hiérarchique sur les lignes et les colonnes, réordonne les deux, et colore les valeurs pour que les blocs de hautes et de basses se détachent. Commencez par standardiser la matrice, tracez une rapide heatmap() de base pour vérifier, puis passez à pheatmap() pour une figure propre et annotée avec cutree_rows pour encadrer les regroupements. Tournez-vous vers heatmaply quand vous voulez survoler et zoomer, et vers ComplexHeatmap quand vous devez empiler plusieurs matrices annotées — la référence pour le travail d’expression génique. Le regroupement lui-même est la même machinerie qu’un dendrogramme, donc les choix de distance et de liaison se reportent directement.
dendextend ; mesures de distance — la règle de similarité qui décide quelles lignes et colonnes se retrouvent ensemble ; k-means — l’alternative par partitionnement quand vous connaissez déjà le nombre de groupes voulu ; nombre optimal de regroupements — combien de groupes découper.Vous préférez un livre ? Practical Guide to Cluster Analysis in R est disponible en PDF téléchargeable — toutes les leçons de cette série, hors ligne et à vous.
Prouvez que vous savez le faire. Maîtrisez toute la série Analyse de clustering en R — suivez votre parcours, construisez des projets et obtenez un certificat.
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
✓ Vous êtes Pro — continuez. The runtime is the judge.
Prêt à passer à la vitesse supérieure ?
@online{2026,
author = {},
title = {Heatmaps en R : heatmap, pheatmap \& plus},
date = {2026-06-24},
url = {https://www.datanovia.com/learn/machine-learning/clustering/heatmap},
langid = {fr}
}