Distributed UMAP via Sketch and Scale

• The paper introduces a distributed UMAP framework that leverages local Count Sketch summarization to reduce raw data transfer and computational costs.
• Count Sketch-based summarization aggregates local sketches to efficiently extract heavy hitters while preserving theoretical error bounds and embedding fidelity.
• The framework achieves a 5–10× runtime speedup and significantly lowers memory and communication demands, enabling scalable analytics on vast datasets.

Sketch and Scale (SnS) Distributed UMAP is a distributed framework designed to enable scalable, privacy-preserving, and communication-efficient dimensionality reduction using Uniform Manifold Approximation and Projection (UMAP) across geographically distributed, high-dimensional datasets. The core mechanism leverages the Count Sketch data structure at edge nodes to generate summary statistics of local data without transferring raw points. These sketches are merged centrally to extract a compact set of representative samples, termed the "summary", on which standard UMAP is executed to produce a global low-dimensional embedding. The approach achieves linear time complexity in data size, logarithmic memory and communication requirements, and allows the embedding of datasets with hundreds of millions of points distributed over heterogeneous data centers (Wei et al., 2020).

1. System Architecture and Workflow

SnS orchestrates distributed dimensionality reduction through a two-layer architecture: multiple edge nodes, each holding a local dataset $$\mathcal{D}_i = \{x_{i,1}, ..., x_{i,n_i}\} \subset \mathbb{R}^d$$, and a single master node. The raw high-dimensional data never leaves the edge nodes. The workflow comprises the following stages:

1. Local Sketching: Each edge computes a Count Sketch of its data in $O(n_i t)$ time, with $n_i$ data points and $t$ sketch depth.
2. Communication: The compact sketch $S_i$ (size $O(1/\varepsilon^2 \log 1/\delta)$) is sent to the master; the communication is independent of $n_i$.
3. Aggregation: The master computes the global sketch $S = \sum_i S_i$ by summing received sketches.
4. Summarization: The top-$m$ heavy-hitter bins (with the largest estimated frequencies) are extracted from $S$. For each, at least one original data point mapped to the bin is retrieved, forming the "summary" set $O(n_i t)$0 with $O(n_i t)$1 elements.
5. UMAP Execution: Standard UMAP is run on $O(n_i t)$2 to yield the final embedding.

This structure ensures that the communication and computation bottlenecks typically associated with distributed high-dimensional analytics are circumvented by sketch-based summarization.

2. Count Sketch Data Structure and Theoretical Guarantees

The Count Sketch is a randomized linear hash-based structure that maintains frequency estimates for items in a large universe $O(n_i t)$3. For input stream frequencies $O(n_i t)$4, the sketch $O(n_i t)$5 is defined by width $O(n_i t)$6 and depth $O(n_i t)$7, with $O(n_i t)$8 independent hash pairs $O(n_i t)$9. Updates increment $n_i$0 by $n_i$1 for each item $n_i$2.

Querying estimates $n_i$3 for count $n_i$4 is done via the median of $n_i$5 over $n_i$6. With probability at least $n_i$7, the error satisfies

$n_i$8

This error bound (Charikar–Chen–Farach-Colton, 2002) is preserved in the merged global sketch since Count Sketch is linear.

3. Sketch Merging and Accuracy Preservation

The linearity property enables direct addition of sketches from individual edges: if each edge constructs $n_i$9 for its local frequency vector $t$0, the master computes $t$1 as the sketch of the global $t$2. All $t$3 guarantees, including the per-item estimate error, are preserved under this summation. This facilitates scalability and compatibility with uncoordinated, asynchronous edge nodes.

4. Heavy Hitter Extraction and Summary Formation

To select a representative subset, the master computes estimates $t$4 for each bin and selects those with $t$5, where $t$6 is chosen so approximately $t$7 bins survive. Within each surviving bin $t$8, at least one original point $t$9 with $S_i$0 is retrieved to serve as a prototype, yielding the summary $S_i$1 of size $S_i$2.

The Count Sketch error bound ensures that, except for a small set of false negatives controlled by $S_i$3, the densest regions of the dataset are faithfully retained in the summary. The algorithmic steps are:

Step	Description	Purpose
1	Compute $S_i$4 for all $S_i$5	Estimate bin frequencies
2	Retain bins with $S_i$6	Identify heavy hitters
3	For each, extract original $S_i$7	Construct summary $S_i$8

This summary method reduces subsequent computation and communication for UMAP to depend only on $S_i$9.

5. UMAP Execution on the Summary

UMAP is applied to $O(1/\varepsilon^2 \log 1/\delta)$0 as a self-contained dataset. The core steps, matching the standard algorithm [McInnes–Healy–Melville 2018], are:

• Build a weighted $O(1/\varepsilon^2 \log 1/\delta)$1-nearest-neighbor graph on $O(1/\varepsilon^2 \log 1/\delta)$2, with per-point neighborhood scaling $O(1/\varepsilon^2 \log 1/\delta)$3 based on a user-specified neighbor count.
• Compute asymmetric fuzzy memberships and symmetrize into a fuzzy simplicial set with weights $O(1/\varepsilon^2 \log 1/\delta)$4.
• Randomly initialize the $O(1/\varepsilon^2 \log 1/\delta)$5-dimensional embedding $O(1/\varepsilon^2 \log 1/\delta)$6.
• Optimize the cross-entropy-based objective

$O(1/\varepsilon^2 \log 1/\delta)$7

where $O(1/\varepsilon^2 \log 1/\delta)$8, via stochastic gradient descent until convergence.

This stage induces low-dimensional representations for the summary points, mapping the densest regions of the original distributed dataset.

6. Computational and Communication Complexity

Let $O(1/\varepsilon^2 \log 1/\delta)$9 denote the global point count, $n_i$0 the feature dimension, $n_i$1 the number of edge nodes, and $n_i$2 the summary size. The per-node computational cost for Count Sketch is $n_i$3 (with $n_i$4 extra if random projection is used). Memory and communication per edge is $n_i$5—independent of $n_i$6. The master merges $n_i$7 sketches in $n_i$8, scans up to $n_i$9 bins for summary extraction, and UMAP on $S = \sum_i S_i$0 completes in $S = \sum_i S_i$1.

Consequently, both time and communication per edge scale as $S = \sum_i S_i$2, with no dependence on $S = \sum_i S_i$3. This ensures scalability to datasets of arbitrary size and distribution.

7. Empirical Evaluation and Outcomes

SnS was validated on two large-scale real-world collections: a cancer RNA-seq dataset with $S = \sum_i S_i$475 million samples at 500 dimensions, and a Sloan Digital Sky Survey (SDSS) catalog with $S = \sum_i S_i$5100 million entries at 100 dimensions. Reported outcomes include:

• 5–10× speedup in end-to-end runtime compared to single-node and naïve distributed UMAP benchmarks.
• Memory usage per node drops from tens of gigabytes (GB) to a few hundred megabytes (MB).
• Communication per node remains under 100 MB, scaling logarithmically in $S = \sum_i S_i$6.
• Embedding quality, measured via KNN-preservation and trustworthiness, is within 2–5% of single-node UMAP operating on the full dataset.

These results indicate that SnS enables scalable, efficient, and distributed UMAP-based analytics across geo-distributed datasets, while preserving embedding fidelity and drastically reducing system requirements (Wei et al., 2020).