Slingshot ou Monocle3 : quelle méthode de trajectoire utiliser en R

Voyez les deux méthodes s’exécuter côte à côte sur les mêmes cellules, puis utilisez un cadre de décision clair pour choisir le bon outil d’inférence de trajectoire pour vos données

Une comparaison pratique, côte à côte, de Slingshot et Monocle3 pour l’inférence de trajectoire single-cell en R. Ajustez les deux sur le même jeu de données de cellules souches du sang Nestorowa, voyez en quoi un arbre couvrant de poids minimal de courbes principales diffère d’un graphe principal appris — un arbre connecté face à des partitions séparées — et obtenez un cadre de décision pour choisir une méthode de pseudotemps, plus où s’insèrent les options légères (TSCAN) et multi-conditions (condiments).

Date de publication

4 juillet 2026

Modifié

7 juillet 2026

AstucePoints clés
  • Même but, deux philosophies. Les deux ordonnent les cellules le long d’un continuum de différenciation et vous remettent un pseudotemps, mais Slingshot ajuste un arbre couvrant de poids minimal (MST) sur les centroïdes des regroupements et le lisse en courbes principales (Street et al., 2018), tandis que Monocle3 apprend un graphe principal à travers les cellules avec le plongement de graphe inversé (Cao et al., 2019).
  • La différence pratique la plus marquée est la façon dont ils traitent les cellules déconnectées. Slingshot force chaque cellule dans un seul arbre connecté — chacune reçoit un pseudotemps. Monocle3 sépare les cellules en partitions et attribue aux cellules d’une composante déconnectée un pseudotemps infini, refusant d’inventer un chemin que les données ne montrent pas.
  • Ils divergent aussi sur l’embedding. Slingshot s’exécute sur votre embedding existant (l’UMAP Seurat) ; Monocle3 construit et s’exécute sur son propre UMAP à l’intérieur d’un cell_data_set. Les deux trajectoires sont donc ajustées sur des cartes légèrement différentes des mêmes cellules.
  • Choisissez selon la topologie et vos besoins d’honnêteté, pas selon la mode. Utilisez Slingshot pour un arbre de ramification propre sur un embedding auquel vous faites déjà confiance ; tournez-vous vers Monocle3 quand la topologie est complexe ou que vous voulez que la méthode signale les cellules qui ne sont pas sur la trajectoire.
  • Sur un jeu de données difficile, exécutez les deux. Là où ils s’accordent, faites confiance à la trajectoire ; là où ils divergent — le plus souvent sur la question de savoir si les cellules forment un ou plusieurs continuums — le désaccord est lui-même le résultat.

Introduction

Vous avez maintenant rencontré en profondeur les deux méthodes d’inférence de trajectoire single-cell : la leçon Slingshot a ajusté des courbes de lignées ramifiées et trouvé des gènes dynamiques avec tradeSeq, et la leçon Monocle3 a appris un graphe principal et testé les gènes avec Moran’s I. Chacune fonctionne. La question à laquelle cette leçon répond est celle que vous affrontez réellement à la paillasse : face à un jeu de données, vers laquelle vous tournez-vous ?

La façon honnête de décider est d’exécuter les deux sur les mêmes cellules et de regarder où elles s’accordent et où elles divergent. C’est donc ce que nous faisons. Sur un jeu de données de sang en cours de différenciation, nous ajustons une trajectoire Slingshot et une trajectoire Monocle3, nous les plaçons côte à côte, et nous lisons le contraste structurel directement sur la figure — pas dans un tableau d’affirmations. Puis nous transformons ce contraste en un cadre de décision : un tableau comparatif et une règle simple « utilisez Slingshot quand… / utilisez Monocle3 quand… » que vous pouvez appliquer à vos propres données. Nous terminons par deux options que les deux méthodes phares laissent de côté — une base de référence légère et native de single-cell-experiment (TSCAN), et un outil pour comparer des trajectoires entre conditions (condiments).

Ceci est une leçon de comparaison statique : les deux leçons approfondies portent les parcours complets, pas à pas (enracinement, validation face aux étiquettes connues, test des gènes). Ici nous ajustons juste assez de chacune pour voir la différence et choisir. Si vous voulez le pipeline complet de l’une ou l’autre méthode, suivez sa propre leçon.

Nous utilisons les mêmes données que les deux leçons approfondies pour que la comparaison soit à armes égales : le jeu de données de sang de souris Nestorowa canonique (Nestorowa et al., 2016) — 1 920 cellules souches et progénitrices hématopoïétiques (HSPC — les cellules souches et progénitrices qui produisent chaque cellule sanguine), chacune portant une étiquette FACS (fluorescence-activated cell sorting — le tri par cytométrie de flux qui a trié les cellules selon leurs marqueurs de surface) enregistrant à quelle population progénitrice elle appartient.

Ajuster Slingshot sur les cellules

D’abord, le côté Slingshot, exactement comme dans sa propre leçon mais en s’arrêtant au pseudotemps — pas de test de gènes ici. Nous exécutons le pipeline de RNA-seq single-cell (scRNA-seq) standard dans Seurat — normaliser, trouver les gènes variables, réduire par analyse en composantes principales (PCA), construire un UMAP (uniform manifold approximation and projection, la carte en 2-D), et regrouper — puis appeler slingshot() sur l’UMAP Seurat avec les étiquettes de regroupements, enraciné au regroupement de cellules souches à long terme que nous lisons dans les étiquettes FACS. Une graine fixe garde le clustering et l’embedding reproductibles.

set.seed(42)
library(Seurat)
library(slingshot)
library(ggplot2)

d <- readRDS("_data/nestorowa_hsc.rds")
obj <- CreateSeuratObject(counts = d$counts, meta.data = d$meta)
obj <- NormalizeData(obj, verbose = FALSE) |>
  FindVariableFeatures(nfeatures = 2000, verbose = FALSE) |> ScaleData(verbose = FALSE) |>
  RunPCA(npcs = 30, verbose = FALSE) |> RunUMAP(dims = 1:30, verbose = FALSE) |>
  FindNeighbors(dims = 1:30, verbose = FALSE) |> FindClusters(resolution = 0.6, verbose = FALSE)

# Root at the most LT-HSC-enriched cluster (LT-HSC = long-term hematopoietic stem cell, the apex stem cell)
root <- names(which.max(prop.table(table(obj$seurat_clusters, obj$broad), 1)[, "LTHSC"]))
sds  <- slingshot(Embeddings(obj, "umap"),
                  clusterLabels = as.character(obj$seurat_clusters),
                  start.clus = root)

length(slingLineages(sds))          # how many lineages Slingshot resolved
[1] 4
sum(!is.nan(rowMeans(slingPseudotime(sds), na.rm = TRUE)))   # how many cells got a pseudotime
[1] 1920

Slingshot résout une poignée de lignées, s’évasant toutes depuis l’unique racine de cellules souches, et — le point à retenir — chaque cellule reçoit un pseudotemps. Slingshot construit un seul arbre connecté et ordonne les 1 920 cellules le long de lui ; rien n’est laissé de côté. Nous construisons l’objet graphique maintenant et le traçons côte à côte avec Monocle3 dans un instant.

# Package the Slingshot result as a ggplot: cells coloured by pseudotime + the lineage curves
um <- Embeddings(obj, "umap")
pt_sling <- rowMeans(slingPseudotime(sds), na.rm = TRUE)
cells <- data.frame(UMAP1 = um[, 1], UMAP2 = um[, 2], pseudotime = pt_sling)
curves <- do.call(rbind, lapply(seq_along(slingCurves(sds)), function(i) {
  s <- slingCurves(sds)[[i]]$s[slingCurves(sds)[[i]]$ord, ]
  data.frame(UMAP1 = s[, 1], UMAP2 = s[, 2], lineage = paste0("L", i))
}))

p_sling <- ggplot(cells, aes(UMAP1, UMAP2, color = pseudotime)) +
  geom_point(size = 0.7) +
  geom_path(data = curves, aes(group = lineage), color = "black", linewidth = 0.7) +
  scale_color_viridis_c(na.value = "grey85") +
  labs(title = "Slingshot: MST + principal curves", subtitle = "one connected tree, every cell ordered") +
  theme_minimal(base_size = 11)

Ajuster Monocle3 sur les mêmes cellules

Maintenant le côté Monocle3, tiré de sa propre leçon. Monocle3 ne prend pas un objet Seurat ; il travaille sur un cell_data_set (un CDS — son conteneur construit sur le SingleCellExperiment (SCE) de Bioconductor). Et il ne réutilise pas l’UMAP Seurat — il exécute son propre pipeline preprocess_cds() → reduce_dimension() → cluster_cells(), puis learn_graph() ajuste le graphe principal et order_cells() l’enracine dans les cellules souches. Nous l’enracinons par programmation (jamais le sélecteur interactif) pour que le rendu soit reproductible.

# learn_graph() prints a progress bar; run the whole Monocle3 fit quietly and read the result below.
set.seed(42)
library(monocle3)

d <- readRDS("_data/nestorowa_hsc.rds")
gene_meta <- data.frame(gene_short_name = d$symbol[rownames(d$counts)],
                        row.names = rownames(d$counts))
cds <- new_cell_data_set(d$counts, cell_metadata = d$meta, gene_metadata = gene_meta)

set.seed(42); cds <- preprocess_cds(cds, num_dim = 30)              # PCA
set.seed(42); cds <- reduce_dimension(cds, reduction_method = "UMAP")
set.seed(42); cds <- cluster_cells(cds)
cds <- learn_graph(cds)

# Root programmatically at the LT-HSC stem cells (the documented get_earliest_root pattern)
get_earliest_root <- function(cds, cell_col, target) {
  cell_ids <- which(colData(cds)[[cell_col]] == target)
  closest <- principal_graph_aux(cds)[["UMAP"]]$pr_graph_cell_proj_closest_vertex
  igraph::V(principal_graph(cds)[["UMAP"]])$name[
    as.numeric(names(which.max(table(closest[cell_ids, ]))))]
}
cds <- order_cells(cds, root_pr_nodes = get_earliest_root(cds, "broad", "LTHSC"))
length(unique(partitions(cds)))     # how many separate manifolds Monocle3 found
[1] 2
sum(is.finite(pseudotime(cds)))     # how many cells got a FINITE pseudotime
[1] 1138

Lisez ces deux nombres face à ceux de Slingshot. Monocle3 sépare les cellules en plus d’une partition — des groupes qu’il juge se trouver sur des variétés distinctes — et seules les cellules atteignables depuis la racine obtiennent un pseudotemps fini. Un grand bloc de cellules reste à un pseudotemps infini : Monocle3 vous dit qu’il ne voit pas ces cellules comme faisant partie de cette trajectoire. C’est la bifurcation structurelle entre les deux méthodes, et la figure suivante la rend visible.

# plot_cells() returns a ggplot: the principal graph over Monocle3's own UMAP, coloured by pseudotime
p_mono <- plot_cells(cds, color_cells_by = "pseudotime",
                     label_cell_groups = FALSE, label_leaves = FALSE,
                     label_branch_points = FALSE, cell_size = 0.7) +
  labs(title = "Monocle3: principal graph", subtitle = "partitions; disconnected cells stay grey (Inf)") +
  theme_minimal(base_size = 11)

Le côte-à-côte : un arbre connecté face à des partitions séparées

Voici toute la comparaison en une seule figure — les mêmes 1 920 cellules, Slingshot à gauche et Monocle3 à droite, chacune colorée par son propre pseudotemps. Ne comparez pas les deux échelles de couleurs directement (le pseudotemps n’a pas d’unités et chaque méthode fixe sa propre plage) ; comparez la structure.

library(patchwork)
p_sling + p_mono

Two UMAP panels of the same 1,920 mouse blood stem and progenitor cells. Left panel, Slingshot: smooth principal curves drawn over the Seurat UMAP with every cell coloured by pseudotime on a dark-to-bright scale — one connected tree, no cell left out. Right panel, Monocle3: a principal graph of nodes and edges over Monocle3's own UMAP, one connected component rooted in the dark stem-cell region and brightening outward, while a separate block of cells stays grey because it is a disconnected partition with infinite pseudotime. The contrast shows Slingshot forcing all cells onto one continuum against Monocle3 honestly separating a disconnected group.

Le contraste est immédiat. Slingshot (à gauche) couvre chaque cellule de couleur : il s’est engagé sur un seul arbre connecté et a donné aux 1 920 cellules une place sur lui. Monocle3 (à droite) enracine et colore le corps principal des cellules mais laisse tout un bloc en gris — la partition déconnectée qu’il a refusé d’ordonner. Mêmes cellules, même biologie, deux réponses différentes à la même question : est-ce un seul continuum ou plusieurs ? Slingshot répond « un, toujours » ; Monocle3 répond « autant que les données le soutiennent, et ici c’est plus d’un ».

Aucune des deux réponses n’est automatiquement juste. Celle de Slingshot est commode et souvent correcte quand vous savez déjà que les cellules forment une seule population en cours de différenciation. Celle de Monocle3 est plus prudente et plus honnête quand vous n’êtes pas sûr — elle fait émerger la question au lieu de décider silencieusement à votre place. Le comportement que vous voulez est le cœur du choix, et c’est ce que le cadre de décision ci-dessous transforme en règle.

Le cadre de décision

Les deux méthodes diffèrent sur six axes qui comptent vraiment en pratique. Ce tableau est la référence à garder :

Slingshot Monocle3
Ce qu’il ajuste Un MST sur les centroïdes des regroupements, lissé en courbes principales Un graphe principal appris à travers les cellules avec le plongement de graphe inversé (RGE)
Embedding Votre embedding existant (l’UMAP Seurat/SCE) + vos étiquettes de regroupements Son propre UMAP, construit à l’intérieur du cell_data_set
Topologie Un arbre — des ramifications depuis une racine, pas de boucles Un graphe — peut se ramifier, converger ou former une boucle
Cellules déconnectées Forcées dans l’arbre ; chaque cellule reçoit un pseudotemps Séparées en partitions ; les cellules hors du graphe reçoivent un pseudotemps infini
Test des gènes dynamiques tradeSeq — un modèle additif généralisé (GAM) de l’expression contre le pseudotemps, par lignée graph_test() — l’autocorrélation spatiale de Moran’s I sur le graphe
Objet & écosystème S’exécute sur une matrice + étiquettes ; natif Seurat/SCE, un seul appel slingshot() Un conteneur cell_data_set ; un pipeline de verbes avec son propre tracé

Lisez le tableau comme une seule histoire. Slingshot est plus léger et plus composable : il s’emboîte sur un embedding que vous avez déjà construit et en qui vous avez confiance, c’est un seul appel de fonction, et il ne laisse jamais une cellule de côté. Monocle3 est plus expressif et plus tranché : il possède tout le pipeline, de sa propre réduction de dimension à son propre graphe et ses propres figures, il peut exprimer des topologies qu’un arbre ne peut pas, et il vous dira — via les partitions et le pseudotemps infini — quand il estime que certaines cellules n’appartiennent pas à la trajectoire.

Utilisez Slingshot quand…

  • Vous avez déjà un bon embedding et de bons regroupements (de Seurat ou d’un SingleCellExperiment) en qui vous avez confiance, et vous voulez ajuster la trajectoire sur cette carte-là plutôt qu’une nouvelle.
  • La biologie est un arbre de ramification clair — une origine s’évasant vers quelques destins — sans boucles ni soupçon de populations déconnectées.
  • Vous voulez une méthode simple, robuste, en un seul appel qui reste dans l’écosystème Seurat/SCE, et vous prévoyez de tester les gènes dynamiques par lignée avec tradeSeq.

Utilisez Monocle3 quand…

  • La topologie est complexe — nombreuses ramifications, une convergence, ou une boucle possible — et un arbre la simplifierait à l’excès.
  • Vous soupçonnez des populations déconnectées (un type cellulaire contaminant, deux variétés distinctes) et vous voulez que la méthode les signale plutôt que de les forcer sur un seul chemin. Les partitions de Monocle3 sont la fonctionnalité clé.
  • Vous voulez un pipeline tout-en-un avec son propre embedding, son graphe, ses tracés, et un test de gènes dynamiques par Moran’s I (graph_test()), et vous êtes à l’aise pour travailler dans le monde du cell_data_set.

Et quand un jeu de données est véritablement difficile, exécutez les deux. Là où les deux s’accordent, la trajectoire est robuste au choix de la méthode. Là où elles divergent — le plus souvent sur la question de savoir si les cellules sont un ou plusieurs continuums — les partitions de Monocle3 expliquent en général pourquoi, et le désaccord est un résultat qui vaut la peine d’être rapporté, pas une nuisance à faire disparaître.

Options légères et multi-conditions

Les deux méthodes phares ne sont pas les seuls outils. Deux autres méritent d’être connues, et le code ci-dessous est illustratif — aucun des deux packages n’est installé dans l’image de rendu de cette leçon, donc les extraits sont marqués eval: false. Exécutez-les dans votre propre environnement.

TSCAN — la base de référence légère, native SCE

Si vous voulez la trajectoire la plus simple possible — un MST sur les centroïdes des regroupements, rien de plus — TSCAN (Ji & Ji, 2016) est l’option Bioconductor minimale. Son quickPseudotime() enveloppe tout le pipeline MST sur un SingleCellExperiment, et testPseudotime() teste les gènes le long d’un chemin avec un modèle spline. C’est conceptuellement proche de la première étape de Slingshot (le MST) sans le lissage en courbes principales — une bonne base de référence quand vous voulez quelque chose de rapide et de transparent.

# Illustrative — TSCAN is NOT installed in this lesson's image.
# Install in your own environment: BiocManager::install("TSCAN")
library(TSCAN)

# `sce` is a SingleCellExperiment with a reduced dimension (e.g. "PCA") and a
# `clusters` vector. quickPseudotime() runs aggregateAcrossCells() -> MST -> orderCells():
out <- quickPseudotime(sce, clusters = clusters, use.dimred = "PCA")

out$mst                       # the minimum spanning tree on cluster centroids
head(out$ordering)            # per-cell pseudotime, one column per path

# Test which genes change along the first path with a spline model:
res <- testPseudotime(sce, pseudotime = out$ordering[, 1])

condiments — comparer des trajectoires entre conditions

Slingshot, Monocle3 et TSCAN ajustent tous une seule trajectoire. Quand votre expérience comporte plusieurs conditions (traité vs témoin, mutant vs type sauvage) et que vous voulez demander si la trajectoire elle-même diffère entre elles — topologie différente, progression différente, différenciation différente, expression différente — condiments (Roux de Bézieux et al., 2024) est le cadre conçu pour cela. Il se place par-dessus une trajectoire ajustée (typiquement Slingshot) et ajoute des tests au niveau des conditions.

# Illustrative — condiments is NOT installed in this lesson's image.
# Install in your own environment: BiocManager::install("condiments")
library(condiments)

# `sds` is a Slingshot result; `condition` is a per-cell factor (e.g. treated / control).
# Does the trajectory topology itself differ between conditions?
topologyTest(sds, conditions = condition)

# Do cells progress along the trajectory at different rates between conditions?
progressionTest(sds, conditions = condition)

Ne recourez à condiments que lorsque comparer des conditions est la vraie question ; pour une trajectoire à échantillon unique, Slingshot ou Monocle3 seul est le bon périmètre.

Problèmes fréquents

Les deux méthodes divergent sur le nombre de trajectoires — laquelle a raison ? Aucune, automatiquement. Le décompte dépend de choix en amont de la méthode : le nombre de ramifications de Slingshot vient de la résolution de votre clustering (le MST est construit sur les centroïdes des regroupements), tandis que celui de Monocle3 vient de ses partitions et du graphe appris. Un désaccord signifie en général que les deux répondent à des questions légèrement différentes sur la connectivité. Vérifiez la biologie : croisez les regroupements avec les étiquettes connues (FACS, gènes marqueurs) et décidez combien de destins vous attendez réellement, puis jugez chaque méthode face à cela plutôt que l’une face à l’autre.

Les valeurs de pseudotemps sont sur des échelles totalement différentes. C’est normal. Le pseudotemps n’a pas d’unités et chaque méthode fixe sa propre plage — celle de Slingshot peut aller de 0 à 16 tandis que celle de Monocle3 va de 0 à 9 sur les mêmes cellules. Ne comparez jamais les nombres bruts entre méthodes (ni même entre deux exécutions d’une même méthode). Comparez les ordonnancements et la structure : quelles cellules sont précoces vs tardives, et quels gènes montent le long du chemin. Si vous devez mettre deux pseudotemps sur un même axe, transformez d’abord chacun en rang ou mettez-le à l’échelle min–max sur [0, 1].

Quel embedding devrais-je croire — mon UMAP Seurat ou celui de Monocle3 ? Les deux sont des projections en 2-D valides des mêmes données réduites par PCA ; ils diffèrent parce que l’UMAP est stochastique et que chaque outil l’exécute avec des valeurs par défaut et des graines différentes. Slingshot ajuste sur l’embedding que vous lui donnez (vous le contrôlez donc) ; Monocle3 ajuste sur celui qu’il construit. Pour une comparaison visuelle équitable, rappelez-vous que vous regardez deux cartes, pas une — les cellules sont identiques, mais pas leurs coordonnées en 2-D. Faites confiance à l’embedding dont la structure globale correspond le mieux à votre biologie connue, et indiquez sur lequel chaque trajectoire a été ajustée.

Questions fréquentes

Aucun n’est universellement meilleur — ils conviennent à des situations différentes. Slingshot est plus simple, s’exécute sur votre embedding existant, ajuste un arbre couvrant de poids minimal lissé en courbes principales, et force chaque cellule dans un seul arbre connecté ; il est idéal pour une différenciation à ramification claire en R. Monocle3 apprend un graphe principal sur son propre UMAP, peut exprimer des topologies plus complexes (boucles, convergence), et utilise les partitions pour garder les cellules déconnectées hors de la trajectoire plutôt que de les y forcer. Choisissez Slingshot pour un arbre propre sur un embedding auquel vous faites confiance ; choisissez Monocle3 pour des topologies complexes ou possiblement déconnectées, ou quand vous voulez que la méthode signale les cellules qui ne sont pas sur la trajectoire.

Oui, et sur un jeu de données difficile c’est une bonne pratique. Exécutez les deux, puis comparez les ordonnancements et la topologie inférée. Là où ils s’accordent, la trajectoire est robuste au choix de la méthode et vous pouvez lui faire confiance. Là où ils divergent — le plus souvent sur la question de savoir si les cellules forment un ou plusieurs continuums — le désaccord est lui-même informatif : les partitions de Monocle3 expliquent souvent l’écart. Ne comparez simplement pas les valeurs brutes de pseudotemps entre les deux, puisque chacun fixe sa propre échelle arbitraire.

Pour un arbre de ramification simple — une origine s’évasant vers quelques destins engagés, sans boucles — Slingshot est la valeur par défaut propre : il ajuste exactement cette forme (un MST plus des courbes principales) en un seul appel de fonction sur votre embedding existant. Tournez-vous vers Monocle3 quand la ramification est plus complexe qu’un arbre (chemins convergents, boucles) ou quand vous soupçonnez que certaines branches sont en réalité des populations déconnectées, car son graphe principal et ses partitions gèrent ces cas là où un arbre ne le peut pas.

Parce qu’ils construisent la trajectoire différemment et fixent des échelles indépendantes. Slingshot lisse des courbes principales sur votre UMAP et mesure la distance le long de chaque courbe ; Monocle3 apprend un graphe sur son propre UMAP et mesure la distance le long du graphe. Les deux utilisent des embeddings différents, des squelettes différents et des unités différentes, donc les nombres ne coïncideront pas même quand l’ordonnancement concorde. Comparez l’ordonnancement relatif des cellules et les gènes qui changent le long du chemin, pas les valeurs absolues de pseudotemps.

TSCAN (Ji & Ji, 2016) est l’option minimale : il construit un arbre couvrant de poids minimal sur les centroïdes des regroupements et ordonne les cellules le long de lui, le tout enveloppé dans un seul appel quickPseudotime() sur un SingleCellExperiment, avec testPseudotime() pour les gènes le long d’un chemin. C’est conceptuellement l’étape MST de Slingshot sans le lissage en courbes principales — rapide et transparent, et une base de référence sensée. Pour comparer des trajectoires entre conditions, utilisez condiments (Roux de Bézieux et al., 2024) par-dessus une trajectoire ajustée.

Testez vos connaissances

En partant de nestorowa_hsc.rds, ajustez les deux trajectoires sur les mêmes cellules (les deux pipelines de cette leçon), puis calculez un seul nombre pour chaque méthode : combien des 1 920 cellules obtiennent un pseudotemps fini ? Comparez les deux décomptes. Que vous dit l’écart entre eux, et quelle méthode se montre la plus prudente à propos de la structure des données ?

Pour Slingshot, une cellule a un pseudotemps si rowMeans(slingPseudotime(sds), na.rm = TRUE) n’est pas NaN — mais en pratique Slingshot ordonne toutes les cellules, donc le décompte est 1 920. Pour Monocle3, comptez avec sum(is.finite(pseudotime(cds))) après order_cells() — les cellules d’une partition déconnectée sont à Inf. L’écart entre les deux décomptes est exactement l’ensemble des cellules que Monocle3 a tenues à l’écart de la trajectoire.

set.seed(42)
library(Seurat); library(slingshot); library(monocle3)
d <- readRDS("_data/nestorowa_hsc.rds")

# --- Slingshot: every cell is forced onto the tree ---
obj <- CreateSeuratObject(counts = d$counts, meta.data = d$meta)
obj <- NormalizeData(obj, verbose = FALSE) |>
  FindVariableFeatures(nfeatures = 2000, verbose = FALSE) |> ScaleData(verbose = FALSE) |>
  RunPCA(npcs = 30, verbose = FALSE) |> RunUMAP(dims = 1:30, verbose = FALSE) |>
  FindNeighbors(dims = 1:30, verbose = FALSE) |> FindClusters(resolution = 0.6, verbose = FALSE)
root <- names(which.max(prop.table(table(obj$seurat_clusters, obj$broad), 1)[, "LTHSC"]))
sds  <- slingshot(Embeddings(obj, "umap"), clusterLabels = as.character(obj$seurat_clusters),
                  start.clus = root)
sum(!is.nan(rowMeans(slingPseudotime(sds), na.rm = TRUE)))   # ~1920 — all cells ordered

# --- Monocle3: partitions leave the disconnected cells at Inf ---
gene_meta <- data.frame(gene_short_name = d$symbol[rownames(d$counts)], row.names = rownames(d$counts))
cds <- new_cell_data_set(d$counts, cell_metadata = d$meta, gene_metadata = gene_meta)
set.seed(42); cds <- preprocess_cds(cds, num_dim = 30)
set.seed(42); cds <- reduce_dimension(cds, reduction_method = "UMAP")
set.seed(42); cds <- cluster_cells(cds); cds <- learn_graph(cds)
get_earliest_root <- function(cds, cell_col, target) {
  ids <- which(colData(cds)[[cell_col]] == target)
  closest <- principal_graph_aux(cds)[["UMAP"]]$pr_graph_cell_proj_closest_vertex
  igraph::V(principal_graph(cds)[["UMAP"]])$name[as.numeric(names(which.max(table(closest[ids, ]))))]
}
cds <- order_cells(cds, root_pr_nodes = get_earliest_root(cds, "broad", "LTHSC"))
sum(is.finite(pseudotime(cds)))                              # fewer — the main partition only

Slingshot ordonne les 1 920 cellules ; Monocle3 n’ordonne que les cellules de la partition principale et laisse le bloc déconnecté à un pseudotemps infini. L’écart est la seconde partition. Monocle3 est la méthode la plus prudente : il refuse de placer des cellules sur une trajectoire à laquelle il ne peut pas les connecter, vous confiant la décision de savoir si ce bloc appartient au chemin (ré-ajustez avec learn_graph(use_partition = FALSE)) ou s’il s’agit d’une population véritablement distincte.

A. Monocle3 a un bug — chaque cellule devrait recevoir un pseudotemps. B. Monocle3 a jugé ces cellules comme une partition déconnectée et a refusé de les ordonner le long d’un graphe qu’il ne peut pas atteindre depuis elles ; Slingshot, lui, force toutes les cellules dans un seul arbre connecté. C. Les deux méthodes divergent parce que Slingshot est plus précis.

B. La différence est intentionnelle, pas une erreur. Monocle3 sépare les cellules en partitions et attribue aux cellules d’une composante déconnectée un pseudotemps infini — sa façon honnête de dire « ces cellules ne sont pas sur cette trajectoire ». Slingshot n’a pas un tel mécanisme : il construit un seul arbre couvrant de poids minimal connecté et ordonne chaque cellule le long de lui. Aucun n’est automatiquement plus précis ; ils encodent des hypothèses différentes sur le fait que les données soient un seul continuum ou plusieurs, et décider laquelle correspond à votre biologie est votre choix.

Conclusion

Slingshot et Monocle3 poursuivent le même but — un ordonnancement en pseudotemps d’une population en cours de différenciation — par des routes véritablement différentes, et les exécuter côte à côte sur les mêmes cellules Nestorowa rend la différence concrète. Slingshot lisse des courbes principales par-dessus un arbre couvrant de poids minimal sur votre embedding et force chaque cellule dans un seul continuum connecté ; Monocle3 apprend un graphe principal sur son propre embedding et utilise les partitions pour garder honnêtement les cellules déconnectées hors de la trajectoire. Choisissez Slingshot pour un arbre de ramification propre sur un embedding auquel vous faites confiance, Monocle3 pour des topologies complexes ou possiblement déconnectées où vous voulez que la méthode signale ce qui n’appartient pas à la trajectoire, et quand un jeu de données est difficile, exécutez les deux et faites confiance à la trajectoire là où ils s’accordent. Complétez avec TSCAN quand vous voulez une base de référence MST minimale et condiments quand la vraie question est comment une trajectoire diffère entre conditions.

Leçons connexes

🟢 Avec un agent IA

Demandez à Prova « j’ai un objet Seurat de cellules en cours de différenciation — devrais-je utiliser Slingshot ou Monocle3 pour la trajectoire, et comment exécuter celle que vous recommandez ? » — elle répond avec du code R que vous pouvez exécuter sur vos propres données : inspecter la topologie, choisir la méthode, et exécuter le pipeline complet (Slingshot avec start.clus, ou le preprocess → reduce → cluster → learn_graph → order_cells de Monocle3). The runtime is the judge. Ask Prova →

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

Recevez les nouvelles leçons R & Python par e-mail

Pratique, reproductible, sans spam. Désinscription à tout moment.

Double opt-in. Nous ne partageons jamais votre e-mail.

Partager cette pageXLinkedInRedditHN
Note

Cette leçon est reproductible : chaque figure et chaque nombre ont été produits par le code montré, exécuté de haut en bas dans l’image de rendu datanovia/quarto-bioinformatics — copiez les blocs et exécutez-les dans l’ordre pour les reproduire. Le _freeze commité est ce que le site sert. The runtime is the judge.

Références

Réutilisation

Citation

BibTeX
@online{2026,
  author = {},
  title = {Slingshot ou Monocle3 : quelle méthode de trajectoire
    utiliser en R},
  date = {2026-07-04},
  url = {https://www.datanovia.com/learn/bioinformatics/single-cell/scrnaseq-trajectory-slingshot-vs-monocle3.html},
  langid = {fr}
}
Veuillez citer ce travail comme suit :
“Slingshot ou Monocle3 : quelle méthode de trajectoire utiliser en R.” 2026. July 4. https://www.datanovia.com/learn/bioinformatics/single-cell/scrnaseq-trajectory-slingshot-vs-monocle3.html.