UMAP no longer waits for the full run: GPUMAP streams projections on a commodity GPU, so million-point data becomes inspectable early
Synopsis
GPUMAP splits UMAP's dimensionality-reduction pipeline into three interleavable operations, insert, update and embed, and runs them on a commodity GPU so that intermediate projections appear while computation continues, letting million-point datasets be inspected before the full run ends. On the 5-million-point HIGGS dataset, sequential RAPIDS UMAP produced its first projection only at 50.4 seconds, whereas GPUMAP produced an inspectable intermediate projection at 8.42 seconds and kept refining it; the cost is a total runtime about 1.6 times that of sequential execution.
Interpretation
The dimensionality-reduction tool UMAP can now show an inspectable projection before computation finishes and refine it as new points are inserted, instead of waiting for the neighbor graph and embedding optimization to complete. Earlier UMAP implementations either output a projection only after all computation finishes or use GPU acceleration while keeping sequential execution; existing progressive dimensionality-reduction methods were mainly demonstrated at tens of thousands of points with CPU implementations, leaving scalability to million-point data unexamined. On the 5-million-point HIGGS dataset, sequential RAPIDS UMAP produced its first projection only after completing all computation at 50.4 seconds, while GPUMAP produced an intermediate projection at 8.42 seconds and continued updating it.
Progressive execution decomposes UMAP into three atomic operations, insert, update and embed, each managed by a host-side queue and dispatched to the GPU in batches. An insertion seeds a new point's neighbors by drawing half its candidates from a recent-point pool and half from all inserted points, so early points do not dominate the graph; an update runs a local join only on points whose neighbor lists changed and skips old-old pairs already compared. On EMNIST Digits (280,000 points), GPUMAP raised normalized fidelity and final recall close to reference levels within tens of seconds, whereas the CPU-based Progressive UMAP stayed considerably lower even after substantially longer cumulative runtime.
Perspective
The demonstrated scope is progressive UMAP execution on a single commodity GPU, with datasets from hundreds of thousands to millions of points spanning image, tabular, genomic and text data; experiments exclude client-side rendering and data-transfer overhead.
No clear relationship was observed between the per-run time budget and total runtime, and the 5-second budget produced larger fidelity fluctuations on LAION; under biased insertion orders, early projections show a temporary cluster split that is resolved in later projections.