acceptodds
Under review as a conference paper at ICLR 2027

ibUMAP: Coherent and Scalable Field Evaluation for UMAP Optimization

Abstract

UMAP achieves scalable layout optimization through stochastic negative sampling. However, this stochasticity can lead to unstable embeddings across reruns and downstream reuse, as the estimated repulsive forces depend on the ordering of sampling events. We present ibUMAP, a coherent field-based alternative that evaluates attraction and repulsion from a shared embedding snapshot and applies them synchronously. Its degree-weighted repulsive field is motivated by the conditional expectation of negative sampling for a fixed embedding and represented by three scalar moments, which are evaluated efficiently on CPUs and GPUs using an interpolation-based FFT scheme. This formulation avoids explicit all-pairs computations while inducing optimization dynamics that differ from those of standard online UMAP. Controlled experiments show that synchrony and kernel capping alter the local–global fidelity trade-off, whereas FFT evaluation produces small average changes in final quality. End-to-end benchmarks show median speedups of unseeded and seeded over umap-learn on CPU, and over cuML on million-scale datasets under unseeded GPU execution. These gains accompany greater run-to-run stability and measurable fidelity trade-offs.

Primary area:
optimization
Keywords:
UMAP, dimensionality reduction, optimization, negative sampling, field-based optimization, fast Fourier transform, embedding stability

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_m8VwOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper presents ibUMAP, a coherent field‑based synchronous variant of UMAP. Instead of in‑place updates from stochastic negative sampling in standard UMAP, ibUMAP computes attraction and degree‑weighted repulsion synchronously from a shared embedding snapshot, and efficiently evaluates the repulsive field via three‑scalar‑moment decomposition together with interpolation‑based FFT (ibFFT). It achieves considerable speedups over umap‑learn on CPU and cuML on million‑scale GPU datasets, and substantially improves geometric stability across unseeded reruns, at the cost of minor degradation in local and global embedding fidelity. Through fine‑grained ablation studies, the paper disentangles the individual impacts of synchrony, kernel capping, FFT approximation and safeguard mechanisms on embedding quality. A single‑cell analytics workflow further demonstrates that better geometric stability does not guarantee consistent downstream clustering outputs, offering a new optimization paradigm for large‑scale reproducible dimensionality‑reduction tasks.

Critical strengths
  1. Propose a new synchronous field-driven UMAP optimization paradigm: Breaking away from the original UMAP framework of random negative sampling and local updates, it uses fixed embedded snapshots to synchronously calculate attraction and degree-weighted repulsion forces, using three-scalar moment decomposition + interpolation FFT to efficiently compute the repulsion field, addressing the root cause of poor reproducibility caused by sampling order in traditional UMAPs from the optimization mechanism level, rather than simply accelerating engineering processes.

  2. Rigorous Design of Control Variable Ablation Experiments: Fixed graph structure and initialization, decoupling mechanisms such as synchronous updates, nuclear truncation, FFT approximation, and gradient protection, quantifying each change individually on local and global embedding fidelity; Distinguish between FFT approximate errors and dynamic changes caused by synchronous updates, clearly identifying the benefits and costs of each component.

  3. Balancing Speed and Seedless Stability: The CPU achieves significant acceleration compared to umap-learn, and GPUs on millions of datasets also show speed improvements compared to cuML; In seedless mode, it can greatly improve the geometric consistency of embedded runs multiple times, eliminating the need for deterministic output by forcing serial execution like in the original UMAP; At the same time, it reveals that "geometric stability ≠ downstream clustering results are completely consistent," providing an objective and complete assessment without exaggerating the effect.

  4. Comprehensive and fair multi-benchmark large-scale benchmarking: Compares mainstream implementations such as umap-learn, cuML, and TorchDR across 71 real datasets covering tables, images, and single-cell. It simultaneously evaluates both seeded and seedless operation modes, and reports multi-dimensional indicators such as runtime, local fidelity, global fidelity, and multi-run stability; Distinguish between dataset weighting and family weighting to avoid statistical bias caused by large homologous single-cell datasets.

  5. Verification and reproducibility for real downstream scenarios: Using single-cell BRAQUE analysis pipelines as end-to-end cases to study how embedded fluctuations are transmitted to HDBSCAN clustering results; Complete open-source code, test scripts, demos; Distinguish between cross-device and same-device determinism, clearly state the boundaries of algorithm capability, fully disclose extreme cases of protection mechanism failure, and ensure all experimental conditions and hardware parameters are reproducible.

Critical weaknesses
  1. Embedding Fidelity Inherent Cost: Compared to the original UMAP, ibUMAP generally shows lower local neighborhood retention and global distance correlation indicators. The synchronous update changes the optimization dynamics of the original UMAP, not equivalent replacement. Users need to weigh between fidelity, speed, and reproducibility, and there is no situation where universality is superior to the original UMAP.
  2. Deterministic Device Limitations: The fully reproducible bit level implemented in the paper only ensures same hardware, same FFT library, and same compiler environment; It is impossible to achieve exact bit consistency across different GPU/CPU devices; it only improves geometric stability and cannot achieve true cross-platform reproducibility. GPU seed mode Under millions of large datasets, graph construction phase overhead skyrockets, resulting in huge runtime penalties.
  3. Lack of System Tuning for Protection Hyperparameters: To prevent point escape, thresholds such as repulsion force modulation and height node attractive damping are directly fixed during development, with no systematic parameter scanning or tuning; While extreme crashes can be avoided, these hyperparameters affect the final embedding effect and may not be optimal for different datasets.
  4. FFT Mesh Approximate Error: ibFFT uses 'p=1' piecewise constant interpolation for field solving, and the mesh size adaptively fits into the coordinate range. Although experiments show little effect on the average final embedding quality, near-field interactions have inherent approximate errors; There is no system ablation for mesh accuracy on different datasets and scales, and in extreme cases, it can approximate the computational accuracy of the data.
  5. Stability and returns have boundaries, downstream performance cannot be fully guaranteed: Even if embedding geometric similarity increases significantly, downstream clustering (HDBSCAN) results cannot be guaranteed to be stable and consistent; clustering allocation in seedless mode still shows considerable variation; Algorithms can only improve fluctuations at the embedding layer and cannot eliminate uncertainties brought by subsequent downstream analysis.
  6. Limitations in Applicable Output Dimensions: Currently, the implementation is only for 2D dimensionality reduction visualization scenarios and has not been extended to higher output dimensions (3D and above). In high-dimensional scenarios, the memory and computing power costs of FFT field computing surge, and the paper does not explore the feasibility and performance of high-dimensional fields.
  7. Performance Disadvantages of Small Datasets: On small datasets with less than 1000 sample sizes, ibUMAP's CPU runs slower than the original umap-learn. FFT and grid processing bring fixed overhead, making it more suitable for medium and large datasets, where small sample scenarios are not advantageous.
Questions for authors
  1. The article observes that ibUMAP sacrifices partial and global embedding fidelity in exchange for speed and stability. Are there future design improvement plans to minimize the fidelity gap with standard UMAPs while preserving the advantages of synchronous field optimization? Will you consider hybrid strategies, such as using synchronous fields early in training and switching back to random negative sampling later?
  2. Currently, ibUMAP only supports 2D dimensionality reduction. If expanded to 3D or higher output dimensions, the computing power and memory overhead of FFT field computation will increase significantly. What do you think is the biggest technical bottleneck in extending this field drive paradigm to high-dimensional dimensionality reduction, and is there a preliminary feasible technical route?
  3. The rejection norm clipping to prevent point escape and the attraction damping of hub nodes are two protective hyperparameters, which are fixed values and have not been adjusted by system scanning. Are there plans to develop adaptive hyperparameter strategies in the future that automatically determine clipping thresholds and damping coefficients based on dataset characteristics, to avoid poor performance of fixed parameters on certain datasets?
  4. This algorithm can only achieve bit-level reproducibility on the same device; complete consistency across hardware and FFT libraries cannot be achieved. Is there a way to further improve and achieve deterministic cross-platform embedded outputs? If not, what metrics can be used to quantify acceptable deviations between different device outputs?
  5. Experiments show: Even though ibUMAP greatly improves the geometric stability of embeddings, the downstream HDBSCAN clustering results still show significant variation when running seedless. Besides the residual fluctuations of embeddings themselves, what other factors dominate changes in cluster distribution? Is it possible to impose constraints at the optimizer level to further reduce downstream clustering instability?
2 comments

We thank the reviewer for the thorough review. The questions prompted us to conduct some additional experiments and tests, which we have added to the revised paper (changes in blue).

Q1 / W1: Embedding Fidelity Inherent Cost and Hybrid Strategy

We compared the two CPU optimizers at several epoch budgets on 20 datasets, starting from the same graph and initialization for each dataset. We extended ibUMAP to 1,000 epochs to see whether longer runs would close the gap. On six datasets, ibUMAP's best tested neighborhood preservation (NP) was still 0.013–0.033 below unseeded umap-learn at 200 epochs. We report the extended results in Appendix C.6 under Matched fidelity.

We also tried a hybrid strategy in a 60-dataset pilot. We started with the field optimizer and switched to sampled UMAP for the final 40% of epochs. This raised NP by a median 0.021 over pure ibUMAP but took about 11× as long. We report the pilot in §7 and Appendix C.6. A next step would be to refine only poorly preserved neighborhoods and compare fidelity and repeatability at equal layout time.

Q2 / W6: Limitations in Applicable Output Dimensions

Grid memory is the main bottleneck we anticipate. In dd output dimensions, with LL padded nodes per axis, each of the d+1d+1 fields needs LdL^d sites and O(Ldlog⁡(Ld))O(L^d\log(L^d)) FFT work. We have outlined an approach for 3D in §7 that sizes the mesh per axis under a fixed memory budget and checks the field against direct summation.

Q3 / W3: Lack of System Tuning for Protection Hyperparameters

We have added a ten-dataset sweep in Appendix B.2. Without norm clipping, points escaped on three datasets, including 555 on CIFAR-10. Clip multipliers 1, 2, and 4 met our safety and quality criteria at a noise-adjusted tolerance with a 0.005 floor. Damping quantiles p95 and p99 and exponents 0.25 and 0.5 also met this criterion when varied separately. Turning off damping destabilized scDEED CART. The clip threshold already scales with the learning rate, and damping uses each graph's degree quantile. We have outlined choosing a bounded multiplier from early force norms as a further adaptation.

W4: FFT Mesh Approximate Error

We have added a direct-sum comparison with the same capped kernel in Appendix B.3. At random targets on 15 frozen layouts from five datasets (1.8k–11.4k points), the median of per-layout median relative vector errors was 22.7% at p=1p=1, 0.80% at p=2p=2, and 0.30% at p=3p=3, with the default cap and box count. In those layouts, same-box pairs contributed zero p=1p=1 model error. Most error came from pairs one to two cap radii apart. In final fits on 28 datasets, raising pp or doubling the box count changed the five fidelity scores by at most 0.0023 in paired means but took 1.17–1.93× the layout time.

Q4 / W2: Deterministic Device Limitations

Agreed: we claim same-device repeatability; bitwise cross-platform equality would need fixed-order reductions and one FFT on every backend. We have added a matched-input CPU–CUDA test in Appendix C.7. On ten datasets, seeded reruns agreed bitwise on each backend, with 0 of 10 bitwise matches across backends. Across devices, median 15-NN overlap was 0.876 (range 0.646–0.946), median distance rank correlation was 0.9988, and median Procrustes disparity was 0.0009. For cross-device use, we would reuse the graph and initial coordinates and assess local and global deviations against task-specific tolerances. Portable bitwise agreement would require matching arithmetic, reduction order, sampling calendars, and FFT computation. The seeded GPU overhead at million-point scale comes chiefly from exact neighbor search during graph construction (Appendix C.2).

Q5 / W5: Stability and returns have boundaries, downstream performance cannot be fully guaranteed

We have added a cell-level analysis in §6.1 and Appendix D.1. Across ten unseeded run pairs per method, many-to-many cluster overlaps accounted for 74.2% of changed assignments for umap-learn and 83.5% for ibUMAP. The cells in the largest such component recurred across pairs (median Jaccard overlap 0.94 and 0.93, respectively). The two methods' core cell sets also overlapped (Jaccard 0.80). Within each method, the clusters involved had about a quarter to a third of the median HDBSCAN persistence of one-to-one matches. Density-preserving optimization is one hypothesis we discuss. For downstream consistency, we would reuse a fixed-seed embedding or check the partition against consensus across reruns.

W7: Performance Disadvantages of Small Datasets

We agree that the fixed overhead of FFT and grid operations can make ibUMAP slower than umap-learn on very small datasets. On the smallest datasets in our unseeded CPU tests, both methods completed layout optimization in a fraction of a second, so layout time is unlikely to be a practical bottleneck for a single fit.

Thank you for your reply and answer my question, but I believe the quality of this article still needs improvement, and I maintain my score

Reviewer_KtF1OpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes ibUMAP, a field-based optimization framework designed to improve the computational efficiency of UMAP. Unlike standard UMAP, which relies on stochastic negative sampling and asynchronous coordinate updates, ibUMAP introduces a degree-weighted repulsive field and synchronous optimization. The proposed method employs a three-moment decomposition and interpolation-based FFT to efficiently approximate repulsive interactions without explicitly computing all point pairs.

The authors evaluate the proposed approach through controlled ablation studies, covering computational efficiency, embedding fidelity, and run-to-run stability. Experimental results demonstrate median CPU speedups of 3.29× and 5.79× under unseeded and seeded execution, respectively, as well as a 1.44× GPU speedup over cuML on million-scale datasets under unseeded execution. A downstream clustering case study further examines the relationship between embedding stability and clustering consistency.

Critical strengths
  1. Practical Motivation and Value The paper addresses a practically relevant limitation of the original UMAP optimization process, particularly the instability caused by stochastic negative sampling and asynchronous coordinate updates. The proposed synchronous field-based approach provides a useful alternative for improving computational efficiency and reproducibility, especially for large-scale datasets and applications requiring repeated embedding computations.
  2. Reasonable and Well-Structured Methodology The paper presents a logically organized methodology with a reasonable theoretical foundation. The transition from stochastic negative sampling to degree-weighted repulsive field evaluation is clearly motivated, and the three-moment decomposition provides a mathematically sound basis for efficient FFT-based computation. Overall, the proposed framework is technically coherent and the main design choices are reasonably justified.
  3. Strong Reproducibility The paper provides detailed implementation descriptions, experimental configurations, hardware specifications, and an extensive evaluation across multiple datasets. The availability of source code and experimental scripts further supports reproducibility and facilitates independent verification of the reported results.
Critical weaknesses
  1. Insufficient Analysis of the Trade-off Between Embedding Quality and Computational Efficiency Although the paper reports substantial runtime improvements over existing UMAP implementations, the evaluation places considerably more emphasis on computational efficiency than on embedding quality. While Section 5.3 provides comparisons using several fidelity metrics, the proposed method generally performs worse than standard UMAP on important measures, including neighborhood preservation and global distance correlation. The paper does not sufficiently investigate whether the efficiency gains justify these reductions in embedding quality. In particular, comparisons under matched runtime budgets or matched fidelity requirements would provide a more comprehensive assessment of the practical advantages of ibUMAP.
  2. Insufficient Isolation of Variables in the Ablation Study The paper adopts a sequential mechanism-based ablation strategy, progressively transforming standard UMAP into the proposed ibUMAP framework. However, several transitions modify multiple optimization factors simultaneously, making it difficult to attribute the observed performance changes to individual components. Although the appendix includes additional controlled experiments for certain safeguards, the contributions of several core design choices remain insufficiently isolated. More carefully controlled ablation experiments would provide stronger evidence for the effectiveness and necessity of the proposed mechanisms.
  3. Limited Methodological Novelty The methodological novelty of the proposed approach requires further clarification. Several key components, including N-body repulsive field formulations, moment-based decomposition, and interpolation-based FFT acceleration, are closely related to techniques previously explored in methods such as FIt-SNE. The main contribution appears to lie in adapting and integrating these existing techniques into the UMAP optimization framework. Furthermore, given that the proposed method does not consistently preserve the embedding quality of standard UMAP, the significance of these methodological contributions depends heavily on the demonstrated computational advantages. A clearer discussion of the technical distinctions from existing FFT-based embedding methods would help strengthen the paper's novelty claims.
Questions for authors
  1. Novelty and Technical Contributions The proposed method appears to build upon existing field-based optimization techniques, particularly the interpolation-based FFT approach used in FIt-SNE. Could the authors clarify the key methodological differences between ibUMAP and these prior methods?
  2. Trade-off Between Embedding Quality and Runtime Although ibUMAP achieves substantial computational speedups, its embedding fidelity is generally lower than that of standard UMAP on several important metrics. Could the authors provide a more comprehensive analysis of the quality–efficiency trade-off, such as comparisons under matched runtime budgets or matched embedding fidelity?
  3. Ablation Study and Independent Contributions The sequential ablation study progressively modifies the original UMAP optimizer, but several transitions introduce multiple changes simultaneously. Could the authors provide more carefully controlled experiments to isolate the contributions of individual mechanisms? This would help clarify which modifications are responsible for the observed improvements or degradations.
1 comment

We thank the reviewer for the detailed assessment. We conduct some additional experiments and tests following the suggestions and questions. Changes are marked in blue in the revised paper.

Q1 / W3: Novelty and Technical Contributions

Section 2 now states the distinction. The N-body view follows Vladymyrov and Carreira-Perpiñán (2014). We reuse FIt-SNE's mesh interpolation, FFT convolution, and coordinate-weighted kernel sums for globally normalized t-SNE repulsion (Linderman et al., 2019). We build on Damrich and Hamprecht's (2021) analysis of degree-dependent UMAP repulsion.

What is specific to ibUMAP:

  1. A repulsive field for UMAP's sampled optimizer. We derive the expected repulsive update at a fixed layout, retaining umap-learn's sampling schedule and per-interaction clipping. We audit the schedule on 59 graphs and use the analysis to design the degree-weighted radial field (Appendix A).
  2. A cap tailored to UMAP's kernel. We cap UMAP's large short-range kernel values. This bounds the value used for distinct points in the same mesh box under piecewise-constant interpolation (§3).
  3. FFT evaluation of the capped UMAP field. We adapt FIt-SNE's moment sums to evaluate this field with three convolutions of one kernel in 2D (§3).
  4. A repeatable parallel UMAP optimizer. We evaluate the repulsive field and head-wise attraction on a shared layout snapshot. Fixed-order accumulation supports bitwise-repeatable parallel CPU fits at a fixed seed, device, and configuration. In BRAQUE (§6), median seeded embedding-fit time was 7.10 s with ibUMAP and 49.06 s with umap-learn.
  5. A controlled study of what changes fidelity. We separate the effect of the field evaluation from that of the optimizer semantics on 59 datasets, now in single-factor steps (§4).

In short, the contribution is turning UMAP's optimizer into an explicit, repeatable field computation and measuring what this costs and buys, rather than accelerating a known objective.

Q2 / W1: Trade-off Between Embedding Quality and Runtime

We have added a matched-input CPU comparison on 20 datasets in §5.4 and Appendix C.6 (Figures 4 and 12). Both optimizers used the same graph and initial coordinates. We timed layout preparation and optimization at 50, 100, 200, and 500 epochs, and extended ibUMAP to 1,000.

  • Matched runtime. In the unseeded comparison, we used the largest tested epoch count each method could complete within the budget. At ibUMAP's 200-epoch time, it had higher neighborhood preservation (NP) on 14 of 17 comparable datasets (median difference +0.010). Three datasets had no in-budget umap-learn fit. At umap-learn's 200-epoch time, umap-learn had higher trustworthiness (TW) on 16 of 20 (median advantage 0.0026). The median differences in input-to-embedding distance rank correlation (ρD\rho_D, ibUMAP minus umap-learn) were +0.0029 and +0.0017 at the two budgets, respectively.
  • Matched fidelity. At unseeded umap-learn's 200-epoch targets, ibUMAP reached TW, NP, and ρD\rho_D on 9, 12, and 18 of 20 datasets, respectively. Among datasets where both methods qualified, the median ratios of their fastest qualifying times (umap-learn / ibUMAP) were 0.69×, 1.31×, and 1.34×. When both TW and NP had to be met in the same fit, ibUMAP qualified on 7 of 20 and was faster on 2.

Q3 / W2: Ablation Study and Independent Contributions

We agree that the original transitions combined several changes. We have added seven variants in §4 and Appendix B.1 (Table 8), using the same 59 datasets, graphs, initializations, and 200-epoch budget. The fidelity changes below are means of paired differences.

  • Repulsion schedule, weight, and clipping (C→D). Replacing each point's scheduled negative counts with its epoch mean preserved its total count before learning-rate weighting. It lowered ρD\rho_D by 0.186 and random triplet accuracy by 0.058. This changed the entire schedule. At the first, attraction-free update, the median ratio of post-update to pre-update robust bounding-box area was 62×. Switching from the empirical mean to degree-based weights changed ρD\rho_D by −0.002. Halving those weights raised it by 0.105, and then removing per-pair coordinate clipping lowered it by 0.093.
  • Safeguards (F→G). Norm clipping raised ρD\rho_D by about 0.021 both with and without hub damping. Damping had small average effects. Turning it off destabilized scDEED CART in the separate sweep (Appendix B.2).
  • Attraction and implementation (G→H). In the same code path, head-wise attraction raised NP by 0.031 on average (higher on all 59 datasets) and lowered ρD\rho_D by 0.016. Keeping two-endpoint attraction and doubling repulsion restored the same nominal force ratio and recovered +0.023 NP. Switching from the matched head-wise variant to production changed each mean fidelity score by less than 0.0005.
Reviewer_3JyhOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper presents ibUMAP, a field-based alternative to UMAP’s layout optimization. It uses interpolation-based FFT to evaluate a degree-weighted repulsive field and applies attraction and repulsion synchronously. Experiments show substantial CPU speedups, particularly under seeded execution, along with greater run-to-run embedding stability and measurable fidelity trade-offs. GPU performance depends on dataset size and baseline.

Critical strengths
  1. Substantial CPU speedups, especially under seeded execution.

    ibUMAP is substantially faster than umap-learn in the reported CPU benchmarks. It keeps seeded execution parallel while producing bitwise-repeatable embeddings on the same device, reducing the cost of repeatable embedding fits.

  2. Controlled experiments help explain the fidelity trade-offs.

    With the graph and initialization fixed, the experiments examine how the optimizer changes affect embedding fidelity. The end-to-end benchmarks also evaluate speed and run-to-run stability, making the method’s benefits and limitations easier to assess.

Critical weaknesses
  1. The practical impact of fidelity losses remains unclear.

    The paper quantifies these losses, and the downstream case reports run-to-run stability, fixed-seed repeatability, and local fidelity. However, there is limited evidence about how the losses affect downstream task quality.

Questions for authors
  1. How do the fidelity losses affect downstream use?

    Could the authors discuss this impact or provide a small analysis, for example by comparing clustering results with reference labels where available? This would help assess when the speedups justify the fidelity trade-offs.

  2. How do the methods compare at similar embedding fidelity?

    Could the authors show embedding fidelity versus runtime and number of epochs on a few representative datasets? Where similar fidelity can be reached, a runtime comparison would help assess the speedups.

2 comments

We thank the reviewer for the clear summary and the two concrete questions. Both led to new experiments, which we have added to the revised paper (changes in blue).

Q1 / W1: How do the fidelity losses affect downstream use?

Following the suggestion, we fit HDBSCAN with the same settings on stored unseeded CPU embeddings from 64 datasets and scored the partitions against the original reference labels. The median difference in adjusted Rand index (ARI, ibUMAP minus umap-learn) was −0.028 overall and −0.014 on the 35 Tabula Sapiens datasets. Giving each dataset family equal weight, the mean ARI difference was −0.091, the mean fraction assigned to clusters was 6.3 percentage points lower, and 15-NN label accuracy was 0.40 percentage points lower. Local label separation was largely retained, while HDBSCAN typically produced more clusters and assigned more points to noise.

The agreement gap depended on HDBSCAN settings. For example, on digits, increasing the minimum samples parameter from 10 to 25 at the same minimum cluster size raised ARI from 0.56 to 0.872 for ibUMAP, with umap-learn at about 0.87 in both settings. For a workflow that clusters the embedding, we would check agreement and coverage across plausible clustering settings alongside layout time. We have added the main finding to §5.3 and the paired comparisons and parameter sweep to Appendix C.3.4.

Q2: How do the methods compare at similar embedding fidelity?

We added a comparison of the two CPU optimizers on 20 datasets, starting from fixed fuzzy graph and spectral initializations. We timed layout preparation and optimization at 50, 100, 200, and 500 epochs, and added a 1,000-epoch budget for ibUMAP.

  • At comparable layout time, we used the largest tested epoch count each method could complete within the budget. Using unseeded ibUMAP's 200-epoch time, ibUMAP had higher neighborhood preservation (NP) on 14 of 17 comparable datasets (median difference +0.010). Three datasets had no umap-learn fit within that budget. Using unseeded umap-learn's 200-epoch time, umap-learn had higher trustworthiness (TW) on 16 of 20 (median advantage 0.0026).
  • At comparable fidelity, we took umap-learn's 200-epoch scores as targets and compared the fastest tested qualifying fit of each method. Unseeded ibUMAP met the NP target on 12 of 20 datasets and was faster on 8. It met the TW target on 9 of 20 and was faster on 4. Among qualifying pairs, the median umap-learn / ibUMAP time ratios were 1.31× for NP and 0.69× for TW. A single fit met both targets on 7 of 20, with 2 faster. With fixed seeds and serial umap-learn, ibUMAP met both targets on 6 of 20 and was faster on all six (median 6.98×).

On Tabula Sapiens kidney, increasing ibUMAP from 200 to 500 epochs raised NP from 0.716 to 0.722 (0.164 to 0.394 s), against a 200-epoch umap-learn target of 0.735 (0.338 s). On MERFISH, the same increase raised NP from 0.064 to 0.069 (2.61 to 6.14 s), against a target of 0.067 (7.85 s). We have added the matched comparisons to §5.4 (Figure 4) and the epoch and time-budget sweeps to Appendix C.6 (Figure 12).

Thank you for the detailed responses and additional experiments. The ablation and parameter analyses help clarify the design and contributions of the method. The downstream evaluation and quality-matched comparisons also provide useful insight into its practical trade-offs.

The new results address my questions, but they also reveal some limitations. In particular, the impact on clustering quality can be noticeable, and the quality-matched experiments do not show a consistent speed advantage over UMAP.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.