Clustering & UMAP avec Seurat : regrouper des cellules individuelles en R (pbmc3k)
Lancez la PCA, décidez combien de composantes principales conserver, construisez un graphe de voisinage, trouvez des regroupements à la résolution de votre choix, et projetez-les avec UMAP
Un guide pratique du clustering de données scRNA-seq en R avec Seurat. À partir d’un objet pbmc3k normalisé et mis à l’échelle, lancez la réduction de dimension linéaire avec RunPCA, choisissez combien de composantes principales conserver depuis un ElbowPlot, construisez un graphe de plus proches voisins partagés avec FindNeighbors, partitionnez les cellules en regroupements avec FindClusters (et le bouton de résolution qui contrôle leur nombre), puis projetez les regroupements en deux dimensions avec RunUMAP et DimPlot.
Date de publication
29 juin 2026
Modifié
7 juillet 2026
AstucePoints clés
Les cellules vivent dans un espace d’environ 2 000 gènes — trop de dimensions pour les regrouper directement. RunPCA() compresse cela en quelques dizaines de composantes principales qui capturent la véritable structure cellule à cellule.
Décidez combien de PC conserver depuis un ElbowPlot : gardez les composantes avant que la courbe ne s’aplatisse. Pour pbmc3k, le coude se situe autour de la PC 10, donc dims = 1:10 est le choix standard et défendable.
FindNeighbors(dims = 1:10) construit un graphe de plus proches voisins partagés ; FindClusters(resolution = ...) le partitionne. La résolution est le bouton qui compte — plus basse, elle donne moins de regroupements, plus grossiers ; plus haute, elle en donne davantage, plus fins. À resolution = 0.5, pbmc3k se divise en 9 regroupements.
RunUMAP(dims = 1:10) projette les mêmes PC en 2-D pour le tracé ; DimPlot(reduction = "umap") est la figure signature — les regroupements que vous avez trouvés, disposés dans l’espace.
Les regroupements sont des groupements pilotés par les données, pas encore des types cellulaires. Le regroupement 0 est « un groupe de cellules similaires », pas « des lymphocytes T » — les nommer vient ensuite, à partir des gènes marqueurs. Le pipeline est déterministe (RunUMAP fixe sa graine à 42), vous reproduisez donc la même figure à chaque fois.
Introduction
Vous avez un objet pbmc3k normalisé et mis à l’échelle : 2 638 cellules de qualité décrites par 2 000 gènes variables. L’objectif maintenant est de trouver les groupes de cellules similaires cachés dans cette matrice — les populations qui, une fois nommées, deviennent des lymphocytes T, des monocytes, des lymphocytes B, et le reste. C’est le clustering, et dans Seurat c’est une séquence courte et éprouvée : réduisez les dimensions avec la PCA, décidez combien de composantes portent un vrai signal, construisez un graphe de voisinage sur ces composantes, partitionnez-le en regroupements, et disposez le résultat avec UMAP.
Deux décisions façonnent le résultat, et cette leçon porte vraiment sur elles : combien de composantes principales conserver et à quelle résolution regrouper. Prenez en main ces deux boutons et le reste est mécanique. Nous reprenons depuis la leçon de normalisation sur le même objet pbmc3k, afin que le workflow se transfère directement à vos propres données 10x.
Reprendre à partir de C3 : reconstruire l’objet prêt pour l’analyse
Chaque bloc de code ici est autonome, il commence donc par recréer l’objet normalisé et mis à l’échelle de la leçon précédente — charger la matrice 10x, construire l’objet Seurat, ajouter percent.mt, restreindre aux cellules propres, puis normaliser, trouver les gènes variables, et mettre à l’échelle. C’est exactement l’ objet avec lequel vous avez terminé C3.
An object of class Seurat
13714 features across 2638 samples within 1 assay
Active assay: RNA (13714 features, 2000 variable features)
3 layers present: counts, data, scale.data
13 714 gènes répartis sur 2 638 cellules, avec trois couches (counts, data, scale.data) et 2 000 gènes variables définis. Tout ce qui suit s’exécute sur cet objet.
Lancer la PCA : compresser les cellules avant de les regrouper
Regrouper 2 638 cellules sur 2 000 gènes directement est à la fois lent et bruité — la plupart de ces gènes portent un peu de signal et beaucoup de dispersion technique. L’analyse en composantes principales (PCA) résout cela : elle trouve les directions (combinaisons linéaires de gènes) selon lesquelles les cellules varient le plus, et réexprime chaque cellule comme une poignée de scores sur ces directions. Quelques dizaines de composantes principales remplacent alors la matrice d’ expression complète, en conservant la structure qui sépare les types cellulaires et en écartant la majeure partie du bruit.
RunPCA() s’exécute par défaut sur les gènes variables mis à l’échelle. L’affichage du résultat montre quels gènes pèsent le plus fortement sur chaque composante — et ces gènes sont immédiatement interprétables.
library(Seurat)pbmc.data <-Read10X("_data/filtered_gene_bc_matrices/hg19")pbmc <-CreateSeuratObject(pbmc.data, project ="pbmc3k",min.cells =3, min.features =200)pbmc[["percent.mt"]] <-PercentageFeatureSet(pbmc, pattern ="^MT-")pbmc <-subset(pbmc, subset = nFeature_RNA >200& nFeature_RNA <2500& percent.mt <5)pbmc <-NormalizeData(pbmc)pbmc <-FindVariableFeatures(pbmc, selection.method ="vst", nfeatures =2000)pbmc <-ScaleData(pbmc)# Linear dimension reduction on the scaled variable featurespbmc <-RunPCA(pbmc, features =VariableFeatures(pbmc))# Top genes defining the first few componentsprint(pbmc[["pca"]], dims =1:3, nfeatures =5)
Les composantes ne sont pas abstraites — chacune est un axe biologique. La PC 1 va de MALAT1, LTB, IL32, IL7R, CD2 (gènes lymphocytaires) du côté négatif à CST3, TYROBP, LST1, AIF1, FTL (gènes monocytaires/ myéloïdes) du côté positif : c’est la séparation myéloïde-versus-lymphoïde, la plus grande source unique de variation dans le sang. La PC 2 sépare CD79A, MS4A1, TCL1A (gènes des lymphocytes B) de NKG7, PRF1, GZMB, GZMA (gènes NK/cytotoxiques). Les PC ont déjà organisé les cellules selon les lignes que le clustering va formaliser.
Pour voir cette structure sur une seule composante, DimHeatmap() trace les cellules (colonnes) face aux gènes au plus fort poids (lignes) pour une PC, triées par leur score PCA.
library(Seurat)pbmc.data <-Read10X("_data/filtered_gene_bc_matrices/hg19")pbmc <-CreateSeuratObject(pbmc.data, project ="pbmc3k",min.cells =3, min.features =200)pbmc[["percent.mt"]] <-PercentageFeatureSet(pbmc, pattern ="^MT-")pbmc <-subset(pbmc, subset = nFeature_RNA >200& nFeature_RNA <2500& percent.mt <5)pbmc <-NormalizeData(pbmc)pbmc <-FindVariableFeatures(pbmc, selection.method ="vst", nfeatures =2000)pbmc <-ScaleData(pbmc)pbmc <-RunPCA(pbmc, features =VariableFeatures(pbmc))# How PC1 splits the cells: top genes (rows) x 500 cells (columns), sorted by PC1 scoreDimHeatmap(pbmc, dims =1, cells =500, balanced =TRUE, fast =FALSE)
Les deux blocs nets sont l’essentiel : un ensemble de cellules est élevé en gènes myéloïdes et bas en gènes lymphocytaires, l’autre ensemble est l’image miroir. La PC 1 capture véritablement une frontière biologique, pas du bruit — c’est pourquoi il est sûr de regrouper sur ces composantes plutôt que sur les gènes bruts.
Combien de PC ? Lire l’ElbowPlot
La première vraie décision : combien de composantes principales conserver pour le graphe de voisinage et UMAP. En garder trop peu et vous fusionnez des populations distinctes ; en garder trop et vous commencez à regrouper sur du bruit (les PC tardives sont surtout de la dispersion technique). L’outil standard est l’elbow plot — l’écart-type expliqué par chaque composante, dans l’ordre. Gardez les composantes avant que la courbe ne s’aplatisse.
Lisez-le de gauche à droite. L’écart-type plonge de 7,1 à la PC 1 à environ 3,2 à la PC 5, redescend en douceur vers ~2,0 aux PC 7-8, puis s’aplatit en un plateau quasi plat autour de 1,8 à partir de la PC 10. Ce coude — l’elbow — est l’endroit où les composantes supplémentaires cessent d’apporter un vrai signal. Tout ce qui suit est essentiellement du bruit, donc dims = 1:10 est le choix naturel et défendable pour pbmc3k.
C’est un jugement, pas une formule, et c’est tolérant : n’importe quel nombre entre environ 7 et 15 PC donne presque les mêmes regroupements ici, parce que la structure se loge dans la première poignée de composantes. En cas de doute, penchez légèrement vers le haut (quelques PC de bruit supplémentaires nuisent rarement) et vérifiez que vos regroupements sont stables. Nous gardons 10.
Construire le graphe de voisinage et trouver les regroupements
Une fois les dimensions choisies, le clustering tient en deux appels. FindNeighbors() construit un graphe où chaque cellule est connectée aux cellules les plus proches dans l’espace des PC (un graphe de plus proches voisins partagés, ou SNN). FindClusters() partitionne ensuite ce graphe en communautés — des groupes de cellules densément connectés — à l’aide de l’algorithme de Louvain.
Le bouton qui compte ici est resolution. Il contrôle la finesse de la coupe du graphe : une résolution plus basse donne moins de regroupements, plus grands ; une résolution plus haute en donne davantage, plus petits. Il n’y a pas de valeur unique correcte — cela dépend du niveau de granularité voulu pour vos populations cellulaires. Pour un jeu de données de quelques milliers de cellules, la recommandation de Seurat est 0.4–1.2, et 0.5 est une valeur par défaut solide.
library(Seurat)pbmc.data <-Read10X("_data/filtered_gene_bc_matrices/hg19")pbmc <-CreateSeuratObject(pbmc.data, project ="pbmc3k",min.cells =3, min.features =200)pbmc[["percent.mt"]] <-PercentageFeatureSet(pbmc, pattern ="^MT-")pbmc <-subset(pbmc, subset = nFeature_RNA >200& nFeature_RNA <2500& percent.mt <5)pbmc <-NormalizeData(pbmc)pbmc <-FindVariableFeatures(pbmc, selection.method ="vst", nfeatures =2000)pbmc <-ScaleData(pbmc)pbmc <-RunPCA(pbmc, features =VariableFeatures(pbmc))# Graph on the first 10 PCs, then partition itpbmc <-FindNeighbors(pbmc, dims =1:10)pbmc <-FindClusters(pbmc, resolution =0.5)
Modularity Optimizer version 1.3.0 by Ludo Waltman and Nees Jan van Eck
Number of nodes: 2638
Number of edges: 95927
Running Louvain algorithm...
Maximum modularity in 10 random starts: 0.8728
Number of communities: 9
Elapsed time: 0 seconds
À resolution = 0.5, pbmc3k se divise en 9 regroupements (étiquetés 0–8, le plus grand d’abord) : le regroupement 0 contient 684 cellules, jusqu’au regroupement 8 avec seulement 13. Les étiquettes de regroupement sont stockées comme identité active des cellules (Idents(pbmc)), de sorte que chaque tracé en aval les colore automatiquement.
La résolution est une molette, pas un fait. Tournez-la et le nombre de regroupements bouge — les mêmes cellules, coupées plus ou moins finement :
Les nombres grimpent avec la résolution : 4 regroupements à 0.1, 7 à 0.3, 9 à 0.5, 11 à 0.8, et 12 à 1.2. Une faible résolution regroupe ensemble les populations apparentées (lymphocytes T CD4 et CD8 comme un seul) ; une résolution élevée les sépare, et finit par découper de vrais regroupements en sous-regroupements qui peuvent ou non avoir un sens biologique. La bonne valeur est celle dont vous pouvez défendre les regroupements avec des gènes marqueurs — c’est pourquoi l’annotation (la prochaine leçon) vous renvoie souvent à réajuster ceci. Pour pbmc3k, 0.5 et ses 9 regroupements sont le choix bien établi.
Visualiser les regroupements avec UMAP
Les regroupements ont été trouvés dans un espace de PC à 10 dimensions, que vous ne pouvez pas tracer. UMAP (Uniform Manifold Approximation and Projection) ramène ces 10 dimensions à 2 pour la visualisation, en plaçant les cellules similaires près les unes des autres afin que les populations apparaissent comme des îlots séparés. Lancez-le sur les mêmes PC sur lesquelles vous avez regroupé, puis colorez la projection par regroupement.
Modularity Optimizer version 1.3.0 by Ludo Waltman and Nees Jan van Eck
Number of nodes: 2638
Number of edges: 95927
Running Louvain algorithm...
Maximum modularity in 10 random starts: 0.8728
Number of communities: 9
Elapsed time: 0 seconds
# Project the same 10 PCs to 2-D and colour by clusterpbmc <-RunUMAP(pbmc, dims =1:10)DimPlot(pbmc, reduction ="umap", label =TRUE)
C’est la figure signature d’une analyse de clustering. Lisez-la comme une carte : les cellules que le graphe a jugées similaires siègent ensemble, et les écarts entre îlots sont une réelle distance biologique. Le grand îlot en haut à droite (regroupements 0, 2, 4, 6) est un continuum connecté de types cellulaires apparentés ; l’îlot de gauche (regroupements 5, 1) en est un autre ; et le regroupement 3 siège seul en bas, la population la plus distincte du tracé — sa séparation complète est la signature visuelle d’un type cellulaire bien différent du reste. Utilisez UMAP pour exactement cela — quels groupes sont distincts, lesquels sont voisins — et non pour les distances fines ou les tailles de regroupement, qu’il déforme.
Une précaution qui piège les gens : la disposition est pour l’œil, pas pour l’analyse. Les coordonnées UMAP sont une projection ; les regroupements ont été définis dans l’espace des PC, donc deux regroupements qui se touchent sur l’UMAP ne sont pas nécessairement une seule population, et les distances absolues sur le tracé ne sont pas significatives. Faites confiance au clustering pour ce qui constitue un groupe ; faites confiance à l’UMAP pour grosso modo comment les groupes se relient.
Interpréter honnêtement : les regroupements ne sont pas encore des types cellulaires
Le point le plus important à propos de cette figure : un regroupement est un groupement de cellules similaires piloté par les données, pas un type cellulaire nommé. Le regroupement 0 est « 684 cellules que le graphe a placées ensemble », pas « des lymphocytes T ». Les nombres 0–8 sont des étiquettes arbitraires attribuées du plus grand au plus petit ; ils ne portent aucune biologie en eux-mêmes. Le clustering est honnête sur la structure — ces cellules diffèrent de ces autres cellules — mais il reste muet sur l’identité.
Nommer les regroupements est l’étape suivante, et elle est pilotée par les gènes marqueurs : trouvez les gènes que chaque regroupement surexprime, faites-les correspondre à des marqueurs de types cellulaires connus (MS4A1 pour les lymphocytes B, CD3E pour les lymphocytes T, CD14 pour les monocytes, et ainsi de suite), et réétiquetez. C’est exactement ce que fait la leçon sur les gènes marqueurs & l’annotation — elle transforme les regroupements 0–8 en populations nommées et boucle souvent en arrière pour réajuster la résolution.
Note de reproductibilité. Tout le pipeline est déterministe. FindClusters() est déterministe pour un graphe et une résolution donnés, et RunUMAP() fixe sa graine aléatoire (seed.use = 42 par défaut), de sorte que relancer cette leçon donne les mêmes 9 regroupements et le même UMAP à chaque fois. Indiquez les versions et les paramètres lorsque vous rapportez — « Les cellules ont été regroupées sur les 10 premières composantes principales avec FindNeighbors/FindClusters (résolution 0.5), donnant 9 regroupements, et visualisées avec UMAP (Seurat 5.4.0, seed.use = 42) » — et un lecteur reproduit votre figure exactement.
Problèmes fréquents
Oublier d’utiliser les mêmes dims partout. Les PC sur lesquelles vous regroupez (FindNeighbors(dims = 1:10)) et les PC que vous projetez (RunUMAP(dims = 1:10)) doivent correspondre. Regrouper sur 1:10 mais lancer UMAP sur 1:30 produit une disposition qui contredit les frontières des regroupements — des regroupements qui paraissent étalés ou entremêlés sur le tracé sans raison biologique.
Courir après un « bon » nombre de regroupements en poussant la résolution. Une résolution plus élevée produit toujours plus de regroupements ; cela ne les rend pas réels. Un regroupement ne vaut d’être conservé que s’il a des gènes marqueurs distincts. Choisissez une résolution raisonnable (0.4–1.2 pour quelques milliers de cellules), puis validez avec des marqueurs à l’étape suivante — n’ajustez pas la résolution jusqu’à atteindre un nombre cible.
Une forme d’UMAP différente de celle d’un collègue. L’orientation de l’UMAP (quel îlot est à gauche ou à droite, les retournements miroir) n’est pas fixée d’une machine ou d’une version de package à l’autre, même avec la même graine, car elle dépend du moteur UMAP (uwot versus umap-learn) et de BLAS. Le clustering et les relations entre regroupements sont stables ; seule la disposition cosmétique pivote. Comparez les affectations de regroupement, pas les positions en pixels.
Questions fréquentes
NoteCombien de composantes principales dois-je utiliser dans Seurat ?
Lisez un ElbowPlot() et gardez les composantes avant que la courbe de l’écart-type ne s’aplatisse. Pour pbmc3k, le coude est autour de la PC 10, donc dims = 1:10 est le choix standard. La décision est tolérante — n’importe quel nombre entre environ 7 et 15 PC donne presque les mêmes regroupements — donc en cas de doute, penchez légèrement vers le haut et confirmez que vos regroupements sont stables.
NoteQue fait le paramètre resolution dans FindClusters ?
resolution contrôle la finesse de partition du graphe de voisinage : des valeurs plus basses donnent moins de regroupements, plus grands, et des valeurs plus hautes en donnent davantage, plus petits. Sur pbmc3k, resolution = 0.5 donne 9 regroupements, 0.1 en donne 4, et 1.2 en donne 12. Seurat suggère 0.4–1.2 pour des jeux de données de quelques milliers de cellules ; validez le choix avec des gènes marqueurs plutôt qu’en ajustant pour atteindre un nombre cible.
NoteQuelle est la différence entre PCA et UMAP dans un workflow Seurat ?
La PCA (RunPCA) est la réduction linéaire sur laquelle vous regroupez — elle capture les principaux axes de variation en quelques dizaines de composantes interprétables. UMAP (RunUMAP) est une projection non linéaire de ces PC en 2-D sur laquelle vous tracez. Vous regroupez dans l’espace des PC et visualisez dans l’espace UMAP ; UMAP est pour l’œil, pas pour définir des regroupements ni mesurer des distances.
NotePourquoi mes regroupements ne sont-ils que des nombres et pas des types cellulaires ?
FindClusters() groupe les cellules par similarité et étiquette les groupes 0, 1, 2, … du plus grand au plus petit — les nombres sont arbitraires et ne portent aucune biologie. Les nommer requiert des gènes marqueurs : trouvez ce que chaque regroupement surexprime et faites-le correspondre à des marqueurs de types cellulaires connus (par exemple MS4A1 pour les lymphocytes B, CD14 pour les monocytes). Cette étape d’annotation vient après le clustering.
NoteLe clustering et l’UMAP de Seurat sont-ils reproductibles ?
Oui. FindClusters() est déterministe pour un graphe et une résolution donnés, et RunUMAP() fixe une graine aléatoire (seed.use = 42 par défaut), de sorte que la même entrée donne les mêmes regroupements et la même représentation (embedding) à chaque exécution. L’ orientation de l’UMAP peut tout de même différer d’une version de package ou d’une bibliothèque BLAS à l’autre, mais les affectations de regroupement et les relations entre regroupements sont stables — rapportez votre version de Seurat et vos paramètres et d’autres reproduiront le résultat.
Testez vos connaissances
ImportantÀ vous de jouer : regrouper pbmc3k à deux résolutions
À partir de l’objet pbmc3k normalisé et mis à l’échelle, lancez RunPCA, construisez le graphe de voisinage sur dims = 1:10, et regroupez à la résolution 0.5 puis de nouveau à la résolution 1.0. Reportez combien de regroupements chaque résolution produit, puis lancez UMAP et confirmez que la représentation (embedding) a une ligne par cellule.
AstuceIndice
Appelez FindClusters() deux fois avec des valeurs de resolution différentes ; nlevels(Idents(pbmc)) donne le nombre de regroupements courant après chaque appel. RunUMAP(pbmc, dims = 1:10) puis dim(Embeddings(pbmc, "umap")) confirme la forme de la représentation.
AstuceSolution
library(Seurat)pbmc.data <-Read10X("_data/filtered_gene_bc_matrices/hg19")pbmc <-CreateSeuratObject(pbmc.data, project ="pbmc3k",min.cells =3, min.features =200)pbmc[["percent.mt"]] <-PercentageFeatureSet(pbmc, pattern ="^MT-")pbmc <-subset(pbmc, subset = nFeature_RNA >200& nFeature_RNA <2500& percent.mt <5)pbmc <-NormalizeData(pbmc)pbmc <-FindVariableFeatures(pbmc, selection.method ="vst", nfeatures =2000)pbmc <-ScaleData(pbmc)pbmc <-RunPCA(pbmc, features =VariableFeatures(pbmc))pbmc <-FindNeighbors(pbmc, dims =1:10)pbmc <-FindClusters(pbmc, resolution =0.5)nlevels(Idents(pbmc)) # 9 clusterspbmc <-FindClusters(pbmc, resolution =1.0)nlevels(Idents(pbmc)) # more clusters (11) at the higher resolutionpbmc <-RunUMAP(pbmc, dims =1:10)dim(Embeddings(pbmc, "umap")) # 2638 x 2: one (x, y) per cell
La résolution 0.5 donne 9 regroupements ; la porter à 1.0 divise les cellules plus finement en 11. La représentation (embedding) UMAP est de 2 638 × 2 — deux coordonnées pour chacune des cellules propres.
NoteVérification rapide : dans quel espace les regroupements sont-ils réellement définis ?
A. Dans l’espace UMAP 2-D — les regroupements sont les îlots visibles sur le DimPlot. B. Dans l’espace des PC — FindNeighbors/FindClusters utilisent les composantes principales, et UMAP ne fait que les visualiser. C. Dans l’espace d’expression complet à 2 000 gènes, sans réduction de dimension.
AstuceAfficher la réponse
B. Les regroupements sont définis sur les composantes principales (FindNeighbors(dims = 1:10) construit le graphe à partir d’ elles). UMAP est une projection séparée de ces mêmes PC en 2-D pour le tracé uniquement — deux regroupements qui se touchent sur l’UMAP ne sont pas nécessairement une seule population, c’est pourquoi vous faites confiance au clustering pour le groupement et à l’UMAP seulement pour les relations approximatives.
Conclusion
Regrouper des cellules individuelles est une séquence en cinq étapes bâtie autour de deux décisions. Vous avez compressé les cellules avec RunPCA(), décidé de conserver 10 composantes principales en lisant l’ElbowPlot, construit un graphe de voisinage avec FindNeighbors(dims = 1:10), partitionné en 9 regroupements avec FindClusters(resolution = 0.5), et projeté le résultat avec RunUMAP() et DimPlot(). La logique durable : les deux boutons sont combien de PC (lire le coude) et la résolution (plus basse = plus grossière, plus haute = plus fine), et un regroupement est un groupe de cellules similaires piloté par les données — honnête sur la structure, muet sur l’identité. Nommer ces regroupements à partir de leurs gènes marqueurs est l’étape finale du workflow standard.
Demandez à Prova« comment regrouper mon propre objet Seurat et choisir le nombre de PC et la résolution ? » — elle répond avec du code R que vous pouvez exécuter sur vos propres données, lance RunPCA/FindNeighbors/FindClusters/RunUMAP, et vous aide à lire l’ElbowPlot et à ajuster la résolution. The runtime is the judge.Demander à Prova →
Cette page vous a-t-elle été utile ?
Merci pour votre retour !
Recevez les nouvelles leçons R & Python par e-mail
Pratique, reproductible, sans spam. Désinscription à tout moment.
Double opt-in. Nous ne partageons jamais votre e-mail.
Cette leçon est reproductible : chaque figure et chaque nombre ont été produits par le code montré — copiez n’importe quel bloc et exécutez-le pour les reproduire. The runtime is the judge.
Références
Hao, Y., et al. (2021). Integrated analysis of multimodal single-cell data (Seurat v4). Cell, 184(13), 3573–3587.
Becht, E., et al. (2019). Dimensionality reduction for visualizing single-cell data using UMAP. Nature Biotechnology, 37(1), 38–44.
Blondel, V. D., Guillaume, J.-L., Lambiotte, R., & Lefebvre, E. (2008). Fast unfolding of communities in large networks. Journal of Statistical Mechanics, 2008(10), P10008.
10x Genomics. 3k PBMCs from a Healthy Donor — la matrice gène–code-barres filtrée pbmc3k canonique (Cell Ranger 1.1.0).
@online{2026,
author = {},
title = {Clustering \& UMAP avec Seurat : regrouper des cellules
individuelles en R (pbmc3k)},
date = {2026-06-29},
url = {https://www.datanovia.com/learn/bioinformatics/single-cell/scrnaseq-clustering-umap.html},
langid = {fr}
}
