Pith. sign in

REVIEW 3 major objections 6 minor 19 references

The paper claims that seven of eight major dimensionality reduction methods—plus k-NN construction and rendering—can run entirely on Apple Silicon's Metal GPU through MLX, embedding 70,000 points in seconds.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-02 18:55 UTC pith:UODCAGZV

load-bearing objection Useful MLX DR library with a plausible but under-documented speedup claim; benchmark transparency needed before the numbers can be trusted. the 3 major comments →

arxiv 2603.04035 v4 pith:UODCAGZV submitted 2026-03-04 cs.LG

mlx-vis: GPU-Native Dimensionality Reduction on Apple Silicon

Han Xiao This is my paper
classification cs.LG
keywords dimensionality reductionMLXApple SiliconMetal GPUt-SNEUMAPNNDescentGPU visualization
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

mlx-vis reimplements eight dimensionality reduction methods and approximate k-nearest-neighbor graph construction in pure MLX, so the entire pipeline—PCA preprocessing, graph construction, embedding optimization, and rendering—runs on Apple Silicon's Metal GPU rather than the CPU. The central claim is practical: on an M3 Ultra, seven of the eight methods embed 70,000 Fashion-MNIST points in 2.0–4.7 seconds, with reported speedups of 3.4x, 12.6x, 1.7x, and 7.2x over umap-learn, openTSNE, pacmap, and trimap, and a GPU circle-splatting renderer produces 800-frame animations in about 1.4 seconds; the eighth method, MMAE, takes 18.8 seconds. A sympathetic reader would care because this reduces a fragmented, CPU-bound toolchain to a single dependency-light stack and makes interactive GPU-accelerated embedding feasible on a single workstation without CUDA hardware.

Core claim

Seven of the eight methods embed 70K points in two to five seconds; the eighth, MMAE, takes about 19 seconds. The paper attributes the gain primarily to GPU-native execution on Apple Silicon's unified memory, which eliminates CPU-GPU copies, and to @mx.compile fusion of per-epoch hot loops. It also presents the scatter-add circle-splatting renderer as a new capability—animation rates that enable interactive exploration—rather than just faster computation.

What carries the argument

MLX is the single mechanism: Apple's NumPy-compatible array framework for Metal GPU, with lazy evaluation and JIT compilation via @mx.compile. It carries the argument by letting every stage—matrix-multiplied distance computations in NNDescent, scatter-add updates on randomly sampled edge indices in UMAP/PaCMAP/TriMap, FFT-accelerated t-SNE repulsion, and pixel alpha blending in the renderer—execute on the GPU without CPU-GPU transfers. The renderer's mx.array.at[idx].add atomic scatter-add is the concrete primitive that makes circle-splatting GPU-native.

Load-bearing premise

The load-bearing premise is that the CPU baselines behind the reported speedups were run with fair, representative settings, and that the MLX ports faithfully reproduce the reference embeddings—neither is backed by shown baseline timings or numerical fidelity tests in the paper.

What would settle it

Run the same Fashion-MNIST benchmark on the same M3 Ultra with the reference packages under their documented multi-threaded defaults, record runtimes and hyperparameters, and compare mlx-vis outputs against the reference embeddings using a quantitative quality metric such as trustworthiness, continuity, or k-NN preservation. If the CPU baselines finish in comparable time, or if the mlx-vis embeddings diverge substantially on that metric, the central speedup-and-fidelity claim fails.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

Share X Bluesky LinkedIn Reddit HN

If this is right

  • On Apple Silicon hardware, all eight methods share one API and one numerical substrate, so switching between UMAP, t-SNE, TriMap, or CNE becomes a one-line change instead of a migration between packages.
  • Interactive use becomes plausible at 70K scale: embeddings finish in seconds and animation frames render in about 1.4 seconds, so a user can watch optimization unfold rather than wait for a static final plot.
  • The dependency stack shrinks to MLX and NumPy, removing scipy, sklearn, numba, and Cython from a typical dimensionality-reduction installation.
  • The same MLX pipeline is claimed to scale to ten million points on a single workstation, potentially putting large-scale embedding on commodity Apple hardware.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The paper benchmarks only Fashion-MNIST (784 features) on one high-end chip; a natural follow-up is to test wider, sparser, or lower-dimensional datasets and lower-tier M-series chips, where the unified-memory advantage may be less dramatic.
  • The ten-million-point scaling claim appears in the abstract but is not demonstrated in the body; a memory and timing profile at that scale is the direct test.
  • If the MLX ports really do match reference embeddings, the library could double as a fast oracle for hyperparameter sweeps—but the paper does not propose this.
  • The same 'everything on GPU, no transfers' cost geometry could plausibly carry over to other iterative graph workloads, such as network layouts or graph neural network training; the paper does not explore that.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

3 major / 6 minor

Summary. The paper introduces mlx-vis, a pure-MLX library that implements eight dimensionality reduction methods (UMAP, t-SNE, PaCMAP, LocalMAP, TriMap, DREAMS, CNE, MMAE) and NNDescent k-NN graph construction on Apple Silicon Metal GPU, together with a GPU-native circle-splatting renderer and animation pipeline. The central empirical claim is that on Fashion-MNIST 70K with an M3 Ultra, the seven main methods embed in 2.0–4.7 s (MMAE 18.77 s), achieving 3.4x, 12.6x, 1.7x, and 7.2x speedups over umap-learn, openTSNE, pacmap, and trimap respectively, while consuming only MLX and NumPy as dependencies. The paper also claims that the pipeline scales to ten million points on a single workstation, and that embedding quality is expected to match reference implementations.

Significance. If the empirical claims are substantiated, this is a useful engineering contribution: it fills a real gap by providing a unified, dependency-minimal, GPU-native dimensionality reduction library for Apple Silicon, where no comparable Metal-based tool exists. The implementation is concrete and the code is publicly available, and the performance claims are benchmark measurements rather than predictions from a fitted model. I found no circularity: no fitted constants are used to generate the reported results. However, the paper currently lacks the evidence needed to verify the headline speedups: absolute CPU baseline runtimes, thread counts, hyperparameter settings, and quantitative embedding-fidelity checks are absent. Because the contribution is precisely an engineering performance claim, these omissions are load-bearing and must be addressed before the paper can be accepted.

major comments (3)
  1. [§3, Table 1] The central speedup claim is not auditable. The text reports 3.4x over umap-learn, 12.6x over openTSNE, 1.7x over pacmap, and 7.2x over trimap, but Table 1 contains no absolute runtimes for any CPU baseline, nor thread counts, package versions, hyperparameters (including n_neighbors/min_dist/perplexity), or whether all baselines ran the same 500 iterations and normalize='standard' preprocessing. Without the denominator, the factors cannot be reproduced, and a non-default or weakly threaded baseline would inflate them. Please add a baseline table with absolute times, standard deviations, environment, and exact settings; also add error bars to Table 1, which currently contradicts the 'mean±standard deviation' statement.
  2. [§3 and §2.3] The drop-in equivalence claim is unsupported. §3 says embedding quality 'is expected to match' reference implementations, but no quantitative comparison is reported. §2.3 lists substantive adaptations—Gauss-Newton UMAP kernel fitting, FFT-based t-SNE repulsion (FIt-SNE, not the original algorithm), argsort-based LocalMAP resampling, and MLX MMAE—so 'faithfully reproduces' is not self-evident. Please measure quality on Fashion-MNIST (e.g., trustworthiness, continuity, k-NN preservation, or distance to reference embedding) for all eight methods; if outputs diverge, the speedup claim would not establish an equivalent replacement.
  3. [Abstract / §3] The abstract claims the pipeline 'scales to ten million points on a single workstation,' but the paper gives no 10M-point experiment, no runtime/memory/quality numbers, and no description of how such a benchmark was conducted or what approximation parameters (e.g., NNDescent early termination δ) were used. This is a headline claim and should either be removed or supported by a scaling table (e.g., time and memory for 70K, 1M, and 10M points, with embedding quality metrics).
minor comments (6)
  1. [Abstract] The abstract says 'seven widely used methods' while the full paper and title describe eight methods. Reconcile the count.
  2. [§2.3] The Gauss-Newton optimization for UMAP's output kernel is mentioned without a citation or a brief derivation; please add a reference or a short explanation, since it is a departure from the usual scipy curve_fit approach.
  3. [§2.2] The use of mx.argpartition for top-k selection is stated as if it is always GPU-resident; please verify in the text that this MLX operation has a Metal implementation and note any CPU fallback.
  4. [§3] The paper states 'All timings are mean±standard deviation over 5 runs' but Table 1 lists only point estimates. Add the standard deviations or remove the claim. Also report which t-SNE variant (FFT vs. direct) was benchmarked, since both are mentioned in §2.3.
  5. [Appendix B] The Neural Engine applicability discussion is speculative and tangential to the main contribution; it could be shortened or moved to a non-archival note.
  6. [Code/typos] The code block showing the API has 'mlx vis' without an underscore (e.g., 'from mlx vis import UMAP'); ensure consistent naming. Also add a reproducibility statement with the exact MLX version, OS version, and GitHub commit.

Circularity Check

0 steps flagged

No significant circularity: the paper reports measured engineering benchmarks, not predictions derived from fitted inputs.

full rationale

mlx-vis is an engineering and benchmarking paper rather than a derivational one: it reimplements existing dimensionality-reduction algorithms and reports measured runtimes and resource usage. No quantity used in the reported results is fitted from, or defined in terms of, the results themselves. The speedup claims compare mlx-vis timings against external CPU reference packages; although absolute baseline runtimes, thread counts, and hyperparameters are not tabulated, that omission affects reproducibility and auditability, not circularity, because the baselines are independent implementations rather than outputs of this paper's pipeline. The statement that embedding quality 'is expected to match' the reference implementations is an untested assumption, not a circular step: no reference-quality metric is fed back into the implementation or used to define a predicted quantity. The only self-citation (Fashion-MNIST, Xiao et al. 2017) is an external benchmark dataset and is not load-bearing for the implementation or speedup claims. The Neural Engine applicability discussion is an architectural argument, not a derivation from the paper's own outputs. No equation reduces to its inputs, no fitted parameter is renamed as a prediction, and no load-bearing conclusion depends on an unverified self-citation chain. Thus the derivation chain is self-contained with respect to circularity.

Axiom & Free-Parameter Ledger

2 free parameters · 4 axioms · 0 invented entities

No new mathematical entities or fitted model parameters are introduced. The claims are engineering/performance claims, so the ledger lists benchmark hyperparameters and unverified implementation-fidelity assumptions rather than scientific free parameters.

free parameters (2)
  • NNDescent early termination threshold δ = 0.015
    Chosen by hand in §2.2 as the graph-refinement stopping criterion; affects k-NN approximation quality and runtime.
  • Benchmark optimization iterations = 500
    Fixed for all methods in Table 1; both the reported timings and claimed embedding quality depend on this choice.
axioms (4)
  • domain assumption Reference dimensionality-reduction algorithms are correct and faithfully reproduced by the MLX implementations.
    §2.3 states 'Each implementation faithfully reproduces the published algorithm' but no numerical equivalence tests are shown.
  • domain assumption CPU baselines (umap-learn, openTSNE, pacmap, trimap) were run comparably on the same hardware with matching settings.
    Speedups in §3 are computed against these baselines, but no baseline runtime table or configuration is given.
  • domain assumption MLX/Metal embeddings match reference-quality embeddings.
    §3 says 'Embedding quality is expected to match the reference implementations'; this is assumed, not measured.
  • domain assumption M3 Ultra benchmark timings are representative and accurate.
    All performance claims are measured on one machine; promised mean±standard-deviation values are not shown in Table 1.

pith-pipeline@v1.3.0-alltime-deepseek · 4723 in / 9882 out tokens · 91723 ms · 2026-08-02T18:55:57.863294+00:00 · methodology

0 comments
Cite this review

Pith. "Pith review of mlx-vis: GPU-Native Dimensionality Reduction on Apple Silicon." pith.science (2026). https://pith.science/paper/UODCAGZV

@misc{pith2026260304035,
  author       = {Pith},
  title        = {Pith review of: mlx-vis: GPU-Native Dimensionality Reduction on Apple Silicon},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/UODCAGZV}},
  note         = {Machine review of arXiv:2603.04035}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

Dimensionality reduction is a foundational tool for visualizing high-dimensional data, yet its reference implementations span a fragmented stack of CPU-bound Python packages that leaves the Metal GPU on Apple Silicon entirely unused. We present mlx-vis, a library that reimplements seven widely used dimensionality reduction methods and k-nearest neighbor graph construction in pure MLX, with every stage -- from PCA preprocessing through embedding optimization to a circle-splatting renderer -- executing on GPU. On Fashion-MNIST 70K, all seven methods embed in 2.1--4.6 s on an M3 Ultra, achieving 3--13x speedups over CPU baselines while reducing the entire dependency stack to MLX and NumPy. The same pipeline scales to ten million points on a single workstation. Code at https://github.com/hanxiao/mlx-vis

Figures

Figures reproduced from arXiv: 2603.04035 by Han Xiao.

Figure 1
Figure 1. Figure 1: The mlx-vis pipeline. All stages inside the shaded region execute on Metal GPU through MLX. 2.2 NNDescent on GPU Approximate k-nearest neighbor search is the first stage of every method. mlx-vis im￾plements NNDescent (Dong et al., 2011) entirely in MLX. The algorithm initializes each point with k random neighbors and iteratively refines the graph by exploring neighbors-of￾neighbors. Distances are computed … view at source ↗
Figure 2
Figure 2. Figure 2: Fashion-MNIST 70K embeddings produced by the eight methods in mlx-vis, rendered by the GPU circle-splatting pipeline. 7 [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

19 extracted references · 2 canonical work pages

  1. [1]

    Ehsan Amid and Manfred K. Warmuth. TriMap : Large-scale dimensionality reduction using triplets. arXiv preprint arXiv:1910.00204, 2019

    Pith/arXiv arXiv 1910

  2. [2]

    MLX : An array framework for apple silicon

    Apple Machine Learning Research . MLX : An array framework for apple silicon. https://github.com/ml-explore/mlx, 2023

    2023

  3. [3]

    Manifold-matching autoencoders

    Laurent Cheret, Vincent L \'e tourneau, Isar Nejadgholi, Chris Drummond, Hussein Al Osman, and Maia Fraser. Manifold-matching autoencoders. arXiv preprint arXiv:2603.16568, 2026

    arXiv 2026

  4. [4]

    Hamprecht, and Dmitry Kobak

    Sebastian Damrich, Jan Niklas B \"o hm, Fred A. Hamprecht, and Dmitry Kobak. From t-SNE to UMAP with contrastive learning. In ICLR, 2023

    2023

  5. [5]

    ANEgpt : Transformer training on apple neural engine

    Vipul Divyanshu. ANEgpt : Transformer training on apple neural engine. https://github.com/vipuldivyanshu92/ANEgpt, 2026

    2026

  6. [6]

    Efficient k -nearest neighbor graph construction for generic similarity measures

    Wei Dong, Moses Charikar, and Kai Li. Efficient k -nearest neighbor graph construction for generic similarity measures. In WWW, pages 577--586, 2011

    2011

  7. [7]

    DREAMS : Preserving both local and global structure in dimensionality reduction

    No\" e l Kury, Dmitry Kobak, and Sebastian Damrich. DREAMS : Preserving both local and global structure in dimensionality reduction. Transactions on Machine Learning Research, 2026

    2026

  8. [8]

    Linderman, Manas Rachh, Jeremy G

    George C. Linderman, Manas Rachh, Jeremy G. Hoskins, Stefan Steinerberger, and Yuval Kluger. Fast interpolation-based t-SNE for improved visualization of single-cell RNA -seq data. Nature Methods, 16: 0 243--245, 2019. doi:10.1038/s41592-018-0308-4

    work page doi:10.1038/s41592-018-0308-4 2019

  9. [9]

    Training neural networks on apple neural engine

    maderix . Training neural networks on apple neural engine. https://github.com/maderix/ANE, 2026

    2026

  10. [10]

    UMAP : Uniform manifold approximation and projection for dimension reduction

    Leland McInnes, John Healy, and James Melville. UMAP : Uniform manifold approximation and projection for dimension reduction. arXiv preprint arXiv:1802.03426, 2018 a

    Pith/arXiv arXiv 2018

  11. [11]

    umap-learn: UMAP -- uniform manifold approximation and projection

    Leland McInnes, John Healy, and James Melville. umap-learn: UMAP -- uniform manifold approximation and projection. https://github.com/lmcinnes/umap, 2018 b

    2018

  12. [12]

    Moon, David van Dijk, Zheng Wang, Scott Gigante, Daniel B

    Kevin R. Moon, David van Dijk, Zheng Wang, Scott Gigante, Daniel B. Burkhardt, William S. Chen, Kristina Yim, Antonia van den Elzen, Matthew J. Hirn, Ronald R. Coifman, Natalia B. Ivanova, Guy Wolf, and Smita Krishnaswamy. Visualizing structure and transitions in high-dimensional biological data. Nature Biotechnology, 37: 0 1482--1492, 2019. doi:10.1038/s...

    doi:10.1038/s41587-019-0336-3 2019

  13. [13]

    Poli c ar, Martin Stra z ar, and Bla z Zupan

    Pavlin G. Poli c ar, Martin Stra z ar, and Bla z Zupan. open TSNE : A modular python library for t-SNE dimensionality reduction and embedding. Journal of Statistical Software, 109 0 (3): 0 1--30, 2024. doi:10.18637/jss.v109.i03

    work page doi:10.18637/jss.v109.i03 2024

  14. [14]

    RAPIDS cuML : Gpu machine learning algorithms

    RAPIDS Development Team . RAPIDS cuML : Gpu machine learning algorithms. https://github.com/rapidsai/cuml, 2020

    2020

  15. [15]

    Visualizing data using t-SNE

    Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-SNE . Journal of Machine Learning Research, 9: 0 2579--2605, 2008

    2008

  16. [16]

    Understanding how dimension reduction tools work: An empirical approach to deciphering t-SNE , UMAP , TriMap , and PaCMAP for data visualization

    Yingfan Wang, Haiyang Huang, Cynthia Rudin, and Yaron Shaposhnik. Understanding how dimension reduction tools work: An empirical approach to deciphering t-SNE , UMAP , TriMap , and PaCMAP for data visualization. Journal of Machine Learning Research, 22 0 (201): 0 1--73, 2021

    2021

  17. [17]

    Dimension reduction with locally adjusted graphs

    Yingfan Wang, Yiyang Sun, Haiyang Huang, and Cynthia Rudin. Dimension reduction with locally adjusted graphs. In AAAI, volume 39, pages 21357--21365, 2025. doi:10.1609/aaai.v39i20.35436

    doi:10.1609/aaai.v39i20.35436 2025

  18. [18]

    StarMAP : Global neighbor embedding for faithful data visualization

    Koshi Watanabe, Keisuke Maeda, Takahiro Ogawa, and Miki Haseyama. StarMAP : Global neighbor embedding for faithful data visualization. arXiv preprint arXiv:2502.03776, 2025

    Pith/arXiv arXiv 2025

  19. [19]

    Fashion- MNIST : A novel image dataset for benchmarking machine learning algorithms

    Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion- MNIST : A novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017

    Pith/arXiv arXiv 2017