DataLens: Multi-Modal Analytical Tools

• DataLens is a family of selective analytic mechanisms that transform data structures to reveal hidden patterns and enhance exploration.
• It encompasses methods ranging from interactive UMAP lens filtering and spatial visualization to dataset discovery, data quality management, and private data synthesis.
• Each implementation leverages configurable operations—such as edge filtering, faceted search, iterative cleaning, and gradient compression—to drive domain-specific insights.

DataLens is a recurrent name in recent computational research rather than a single canonical system. In the supplied literature, it denotes an interactive lens or filter function applied to the manifold graph learned by UMAP for domain-knowledge-guided exploration; a broader class of spatially-embedded lens visualizations organized by a seven-dimensional design space; a web-based platform for dataset discovery through faceted search, customizable network topologies, and chained views; an ML-oriented interactive dashboard for tabular data quality management; and a differentially private generative framework built on teacher–student training with gradient compression and aggregation. Across these usages, the common motif is the construction of configurable perspectives that expose structure hidden by default workflows (Bot et al., 2024, Mota et al., 30 Mar 2025, Ollagnier et al., 31 Jul 2025, Abdelaal et al., 28 Jan 2025, Wang et al., 2021).

1. Scope and meanings of the term

The name DataLens has been attached to several technically distinct research artifacts. In high-dimensional visualization, it refers to an interactive “lens” or filter function that modifies the learned connectivity of a UMAP manifold graph before re-embedding. In dataset discovery, it names a prototype web platform that combines faceted search with network-based exploration. In data quality management, it denotes a dashboard that integrates profiling, error detection, repair, user feedback, reproducibility metadata, and experiment tracking. In privacy-preserving learning, DATALENS denotes a generative model that combines PATE-style teacher aggregation with gradient compression. In the design-space literature on spatial visualization, “DataLens” is also used generically for a spatially-embedded lens, defined by chained selection, transformation, and compositing operators (Bot et al., 2024, Mota et al., 30 Mar 2025, Ollagnier et al., 31 Jul 2025, Abdelaal et al., 28 Jan 2025, Wang et al., 2021).

Usage	Core object	Characteristic mechanism
UMAP exploration	Manifold graph	Edge filtering or masking before re-embedding
Spatial lens visualization	Spatial focus+context view	$\sigma$ selection, $\lambda$ lens function, join
Dataset discovery	Metadata graph	User-defined topology plus chained views
Tabular data quality	Cleaning dashboard	Profiling, detection, repair, iterative optimization
Privacy-preserving learning	Synthetic-data generator	TopAgg compression, noise injection, thresholding

A common misconception is that all occurrences of DataLens refer to the same software lineage. The literature instead uses the name for separate systems operating on different data modalities and optimization problems. The recurring conceptual thread is selective transformation: each system modifies what counts as relevant structure, whether that structure is a neighborhood graph, a spatial focus region, a metadata network, a set of dirty cells, or an aggregated gradient signal.

2. DataLens as a lens over UMAP manifold graphs

In the UMAP setting, a DataLens is an interactive lens or filter function applied to the manifold graph learned by dimensionality reduction. Rather than coloring points post hoc, it reshapes the topology and layout itself by selectively removing or reweighting edges in the UMAP $k$-nearest-neighbor graph and then re-embedding the data. The formal setup begins with original data $X=\{x_1,\dots,x_N\}$, a symmetrized UMAP manifold graph $G=(V,E,w)$ with vertices $V=\{1,\dots,N\}$, directed edges $E$, and probabilities $w(i,j)$, together with a user-defined lens mapping $f:X\to\mathbb R^m$ (Bot et al., 2024).

Three lens functions are defined. The Global Lens discretizes a scalar lens $f(x_i)$ into $\lambda$0 segments with segment index $\lambda$1 and retains only edges between identical or adjacent segments:

$\lambda$2

Its effect is to remove any edge crossing a large jump in the lens dimension, thereby “tearing” the manifold at gaps of interest. The Global Mask constructs a second UMAP manifold graph $\lambda$3 over the lens space $\lambda$4 and intersects it with the original graph:

$\lambda$5

This preserves only affinities that are close in both the original space and the lens space. The Local Mask computes for every original edge $\lambda$6 the lens-space distance $\lambda$7, sorts neighbors for each node $\lambda$8 by $\lambda$9, keeps the top $k$0, and symmetrizes:

$k$1

All three lenses preserve the original weights $k$2 but produce a pruned edge set $k$3.

Integration into UMAP leaves manifold construction unchanged: $k$4 is still computed via UMAP’s $k$5-NN plus fuzzy-set process on the full feature space. The lens is then applied to produce $k$6, and UMAP’s stochastic gradient descent is rerun using the filtered graph. Negative sampling is unchanged, but edges now come only from $k$7. To preserve global structure, the low-dimensional coordinates are initialized with the original UMAP embedding and refined for $k$8 epochs. The low-dimensional similarity remains

$k$9

The modification therefore changes which pairs attract or repel without altering the basic UMAP attraction–repulsion machinery.

The paper demonstrates these lenses in two use cases. On the NKI breast-cancer dataset, standard UMAP on gene expression with 30 nearest neighbors shows two major communities, and a KS test on the small cluster reveals low ESR1 expression. Applying a global lens with $X=\{x_1,\dots,x_N\}$0 on the survival label splits relapse versus relapse-free into two components. Within the low-ESR1 group, a KS test highlights CSTA; a local mask with $X=\{x_1,\dots,x_N\}$1 on CSTA causes the manifold to wrap into a loop ordered by CSTA levels, uncovering a subgroup of low-ESR1/high-CSTA patients with better prognosis. On air-quality data with roughly 180 k day-wise readings, UMAP with 50 nearest neighbors and cosine distance shows a rough timescale progression while SO$X=\{x_1,\dots,x_N\}$2 variations are clouded by location mixing. A global lens on year with $X=\{x_1,\dots,x_N\}$3 monthly segments separates successive years and makes trends such as a PM10 drop after regulation visually obvious, while a local mask on SO$X=\{x_1,\dots,x_N\}$4 with $X=\{x_1,\dots,x_N\}$5 reveals filamentary “slices” of constant SO$X=\{x_1,\dots,x_N\}$6 reflecting discrete measurement bins.

The computational analysis separates filtering from re-embedding. For the Global Lens, discretization is $X=\{x_1,\dots,x_N\}$7 for regular segments or $X=\{x_1,\dots,x_N\}$8 for balanced segments, followed by edge filtering in $X=\{x_1,\dots,x_N\}$9. For the Global Mask, mask-graph construction is roughly the same cost as a UMAP fit on $G=(V,E,w)$0-dimensional data, $G=(V,E,w)$1, and the intersection filter is $G=(V,E,w)$2. For the Local Mask, computing lens-space distances is $G=(V,E,w)$3 and partial sorting is $G=(V,E,w)$4. Benchmarks on synthetic data with $G=(V,E,w)$5 show linear scaling for global lens filtering, growth with $G=(V,E,w)$6 and $G=(V,E,w)$7 for the global mask, and sorting-dominated cost for the local mask. Embedding recomputation remains the dominant cost, whereas lens filtering is sub-second even at 100 k points. The implementation is distributed as the open-source Python package lensed_umap, which exposes with_global_lens, with_global_mask, and with_local_mask, as well as lower-level GlobalLens, GlobalMask, and LocalMask classes.

3. DataLens as spatially-embedded lens visualization

A broader visualization literature treats DataLens as a spatially-embedded lens embedded within a focus+context pipeline. The design-space account formalizes a lens as three chained operators: $G=(V,E,w)$8 for selection, which determines which spatial data points are in focus; $G=(V,E,w)$9 for the lens function, which remaps or alters those points through distortion, filtering, or augmentation; and a join operator, which composites the transformed focus back with the context. On this basis, the design space spans seven dimensions derived from an analysis of 45 papers published over the past 15 years: Position / Orientation / Scale, Shape, Dimensionality, Effect Scope, Effect Imagery, Effect Encoding, and Viewpoint Dependency (Mota et al., 30 Mar 2025).

The first dimension, Position / Orientation / Scale, determines the geometric region in which $V=\{1,\dots,N\}$0 operates. Representative formulations include a 2D circular lens centered at $V=\{1,\dots,N\}$1 with radius $V=\{1,\dots,N\}$2, a directional vector lens with angular bounds, a 3D frustum-shaped cutting lens, and a route-following lens whose center is snapped to a polyline and whose orientation is aligned with its tangent. A typical radial distortion is given by

$V=\{1,\dots,N\}$3

followed by

$V=\{1,\dots,N\}$4

Fully interactive placement maximizes user control but can be hard to position precisely in dense 3D scenes; semi-automated placement can guide attention to semantically meaningful regions but risks heuristic misalignment and a perceived loss of agency.

The remaining dimensions characterize both the geometry and the rendering semantics of the lens. Shape can be fixed, user-driven dynamic, or data-driven dynamic. Fixed shapes are simple and predictable but may fit irregular structures poorly; data-driven shapes conform better to salient geometry but can become opaque when feature detection fails. Dimensionality distinguishes 2D lenses, 2.5D sheets in 3D, and full 3D volumetric lenses. 2D lenses are inexpensive and familiar but cannot perform true 3D spatial pick, while 3D lenses provide strong spatial coherence at higher rendering and interaction cost. Effect Scope distinguishes interior-only, exterior-only, and separate-view modes. Effect Imagery distinguishes 2D projected images, 3D volumetric mini-worlds, and surface-conforming decals. Effect Encoding distinguishes thematic representations such as histograms from spatially based representations such as isosurfaces or streamlines. Viewpoint Dependency distinguishes viewpoint-invariant from viewpoint-dependent behavior, which is especially relevant in VR and AR.

The survey reports that many obvious combinations have already been explored: most lenses are fully interactive, fixed-shape, 2D, interior scope, 2D imagery, spatially based or thematic, and viewpoint-invariant. By contrast, several areas remain thinly populated. These include semi-automated and assisted parameterization in immersive 3D, smoothly morphing data-driven shapes, true 3D volumetric imagery that also acts as an interactive staging area, mixed-imagery lenses that combine 2D, 3D, and decal outputs, and multi-view or multi-user viewpoint-dependent designs in collaborative VR/AR. This suggests that, in the visualization sense of DataLens, the unresolved questions are not about the existence of lens techniques but about how to balance precision, agency, rendering cost, and cognitive load across richer interaction settings.

4. DataLens as a platform for dataset discovery

In dataset discovery, DataLens is a prototype web platform designed to alleviate two fundamental pain points: reliance on keyword-based queries and static metadata filters that demand prior knowledge of the data, and the inability of conventional search interfaces to reveal meaningful relationships such as shared tasks, modalities, or pre-trained models among datasets. The system combines faceted search, an interactive network-customization panel, and coordinated chained views in order to narrow candidate datasets while also surfacing hidden overlaps and alternatives. The motivating observation is that repositories can be large and metadata can be incomplete or non-standardized; one example given is that in Hugging Face over 57 K datasets lack modality labels (Ollagnier et al., 31 Jul 2025).

The architecture has three tightly coupled modules. A backend ingestion and metadata store pulls the Hugging Face dataset catalog via its public API, augments each dataset card with the list of pre-trained models that cite it, stores each record as a JSON object in a document-store database, and pre-computes facet counts. A RESTful API layer serves facet value lists with counts and the node-and-edge list corresponding to the user’s network specification and active filters. A JavaScript frontend built on MGExplorer and D3.js exposes three main interface regions: a Network Customization Panel, where any two metadata dimensions can be chosen as nodes and one dimension as the link, with an optional thematic attribute; a Faceted Search Panel showing metadata values with counts; and a Visualization Canvas that defaults to a force-directed node-link diagram but can spawn additional views on demand.

The graph construction is explicit. Let $V=\{1,\dots,N\}$5 be the set of resources, let $V=\{1,\dots,N\}$6 and $V=\{1,\dots,N\}$7 be two chosen dimensions, and let $V=\{1,\dots,N\}$8 be the linking dimension. For each node $V=\{1,\dots,N\}$9,

$E$0

For every pair $E$1, an undirected edge is created if $E$2, with default weight

$E$3

The platform can optionally normalize this co-occurrence count using Jaccard similarity,

$E$4

or a cosine-style score,

$E$5

Edges may also carry thematic metadata such as the distribution of licenses among the linking datasets, shown as color-segmented bars.

The visualization repertoire includes a force-directed layout for general graphs; an egocentric radial view launched by right-clicking a node; pairwise bar charts showing $E$6 with theme segments; a listing view that reveals the exact dataset IDs or model IDs linking selected elements; and a temporal distribution view that displays creation or last-modified dates for the filtered datasets. All views update automatically as facet filters or topology choices change. The interaction model includes hover tooltips, brushing, zoom and pan, and contextual menus for launching new views focused on a subset of data.

Scalability is handled through pre-computed facet counts, thresholding, top-$E$7 truncation, Web Workers, WebGL backends, and an exploration strategy in which users reduce data volume by facets before examining the network. Even so, the authors identify graph clutter as a principal limitation once nodes or edge counts exceed a few hundred. A formative user study with six data practitioners—four with over 7 years’ domain experience and two with 1–3 years—was organized as a pre-study questionnaire, three scenario-based tasks, and a post-task questionnaire with the System Usability Scale. The overall SUS score was 61.7/100. Participants valued the network editor and faceted filters for tailored views and described the topology editor as especially powerful for complex queries, but they also reported a steep learning curve for MGExplorer’s multi-window interface, a small default graph viewport, unclear parameter labels, and clutter in dense graphs. Suggested enhancements included AND-based facet combinations, a larger default canvas, better zoom controls, and aggregated super-nodes. Future work includes node aggregation and progressive level of detail, integration of additional repositories such as Kaggle, metadata harmonization through ontologies or RDF/semantic-web standards, and automated enrichment of dataset profiles.

5. DataLens as an ML-oriented tabular data quality dashboard

A different use of the name denotes an interactive dashboard for tabular data quality management. This system integrates data ingestion, profiling, rule extraction, error detection, error repair, iterative cleaning, reproducibility metadata, experiment tracking, and version control. Data ingestion supports preloaded demo datasets, CSV/Excel upload, and JDBC connections to MySQL, PostgreSQL, and SQL Server. A Dashboard Controller implemented with FastAPI and Python orchestrates YData-Profiling, Metanome functional-dependency detectors, error detectors, repair tools, Delta Lake versioning, JSON DataSheet generation, Optuna-based iterative cleaning, and a user-in-the-loop module for rule validation, labeling, and custom rules (Abdelaal et al., 28 Jan 2025).

The internal data flow is specified as: ingest to a pandas DataFrame and DeltaTable; run profiling and rule extraction in parallel; run selected detection tools and merge results; highlight errors in the UI and feed them to repair; write repaired.csv and a new Delta version; and emit a DataSheet together with MLflow logs. Profiling provides descriptive statistics, missing-value counts, histograms, and correlations. Functional dependencies of the form

$E$8

are discovered with HyFD and TANE, after which users can confirm, reject, or extend them.

Error detection combines statistical, rule-based, and ML-based methods. Statistical detectors include the Z-score,

$E$9

with flagging when $w(i,j)$0, the IQR rule using quartiles $w(i,j)$1 and $w(i,j)$2, and Isolation Forest anomaly scores $w(i,j)$3. Rule-based detectors include NADEEF for violating user-defined or FD rules, KATARA for knowledge-based constraints, and FAHES for disguised missing-value patterns. The ML-based detector RAHA requires tuple-level labels, uses clustering and label propagation to select the next tuple for user labeling, and retrains as dirty/clean labels arrive. Detected cell indices are consolidated, duplicates are removed, and results are displayed in the “Data Overview” tab.

Repair methods include standard imputation and ML-based imputation. Numeric columns can be repaired with the mean or a Decision Tree Regressor; categorical columns can be repaired with the dummy value "__MISSING__" or a k-Nearest Neighbors Classifier. A distinctive feature is the iterative cleaning module, which treats the selection of detector and repair tool as hyperparameters $w(i,j)$4 and optimizes them according to downstream ML performance:

$w(i,j)$5

where $w(i,j)$6 is a downstream regressor or classifier and the score is MSE for regression or F1 for classification. Optuna’s Bayesian optimizer proposes configurations, applies cleaning, retrains the downstream model, evaluates it, and updates the surrogate model.

The Streamlit front end is organized into four tabs: Data Overview, Data Profile, Error Detection Results, and DataSheets. The Data Overview tab includes upload controls, tool-selection checkboxes, a table with dirty cells in red, a user-labeling widget with budget $w(i,j)$7, and tagging for known bad values such as -1, 0, or 99999. The Data Profile tab presents YData-Profiling output and FD rules with validation controls plus an “Add new rule” form. The Error Detection Results tab shows a bar chart of error counts per column by tool and allows reruns of selected detectors. The DataSheets tab exposes the generated JSON metadata and a download button. Reproducibility is reinforced through DataSheets recording dataset paths, shape, detection tools, repair tools, tool configurations, and Delta versions; MLflow logging for each detect/repair run; and Delta Lake version control with append-based table updates and explicit version switching.

The reported case studies quantify both labeling effort and end-task impact. On NASA and Beers, RAHA is evaluated with budgets $w(i,j)$8; the actual tuples reviewed are approximately $w(i,j)$9 because of cluster-based sampling, and F1 rises from 0.34 to 0.40 as $f:X\to\mathbb R^m$0 increases from 5 to 20. For NASA regression with a Decision Tree, Dirty MSE is 15.3, GroundTruth MSE is 9.8, and DataLens with 20 iterations yields MSE 10.7. For Beers multi-class classification with a Random Forest, Dirty accuracy is 0.62, GroundTruth accuracy is 0.85, and DataLens with 20 iterations reaches 0.82. The authors identify several limitations: the UI could be enhanced by natural-language rule definition and richer visual analytics; explainable error detection and repair are currently lacking; iterative cleaning could explore reinforcement learning for dynamic tool selection; and scaling to extremely wide or streaming tables remains to be tested.

6. DataLens as a differentially private generative framework

In privacy-preserving learning, DATALENS is a generative framework built atop GANs and the PATE teacher–student paradigm. The architecture contains an ensemble of $f:X\to\mathbb R^m$1 teacher discriminators $f:X\to\mathbb R^m$2, each trained on a disjoint chunk of the private dataset, and a single student generator $f:X\to\mathbb R^m$3, parameterized as in DC-GAN. Each iteration proceeds through synthesis, teacher updates and gradient votes, TopAgg compression and aggregation, and a generator update driven by the compressed signal rather than by direct access to private examples (Wang et al., 2021).

For a generated sample $f:X\to\mathbb R^m$4, each teacher computes the gradient

$f:X\to\mathbb R^m$5

which indicates how the sample should change to become more realistic. Directly aggregating these high-dimensional gradients would require dimension reduction and noise calibration. The proposed solution is TopAgg, which has two stages. The compression stage, TopKStoSignGrad, clips each coordinate to $f:X\to\mathbb R^m$6, selects the top-$f:X\to\mathbb R^m$7 coordinates by magnitude, normalizes on the selected support by $f:X\to\mathbb R^m$8, and stochastically sign-quantizes each selected coordinate:

$f:X\to\mathbb R^m$9

with $f(x_i)$0 outside the support. This yields a $f(x_i)$1-sparse vector in $f(x_i)$2 with $f(x_i)$3. The aggregation stage sums these sparse teacher votes,

$f(x_i)$4

adds Gaussian noise,

$f(x_i)$5

and thresholds each coordinate:

$f(x_i)$6

The resulting sparse ternary vector is then used to update the generator through

$f(x_i)$7

The privacy analysis is conducted in Rényi differential privacy. Because each teacher vote is $f(x_i)$8-sparse with entries in $f(x_i)$9, changing one teacher’s vote can flip at most $\lambda$00 coordinates by $\lambda$01, so the $\lambda$02 sensitivity is

$\lambda$03

The Gaussian mechanism therefore satisfies

$\lambda$04

which yields the $\lambda$05-DP bound

$\lambda$06

for any $\lambda$07. By post-processing, the student generator and its synthetic outputs inherit the same privacy guarantee. The convergence analysis for a surrogate SGD problem shows the expected trade-off: decreasing $\lambda$08 reduces the DP-noise term linearly but increases compression bias. The paper’s take-away is that, on real-world gradients, moderately small $\lambda$09 can reduce privacy noise substantially while only mildly increasing bias.

Empirically, the framework is compared with DP-GAN, PATE-GAN, G-PATE, and GS-WGAN on MNIST, Fashion-MNIST, CelebA, and Places365, reporting downstream classifier accuracy when training on synthetic data and testing on real data. Selected results are as follows.

Dataset	$\lambda$10	$\lambda$11
MNIST	71.2% DataLens vs 58.1% G-PATE	80.7% DataLens
Fashion-MNIST	64.8% DataLens vs 55.7% comparator	70.6% DataLens
CelebA–Gender	70.6% DataLens vs 67.0% comparator	72.9% DataLens
CelebA–Hair	60.6% DataLens vs 49.9% comparator	62.2% DataLens
Places365	43.1% DataLens vs 34.8% comparator	48.8% DataLens

Under tight budget $\lambda$12, and even at $\lambda$13, the reported gain is greater than 20 points over prior methods. On MNIST with $\lambda$14, DataLens attains Inception Score 4.37 versus 3.60 for G-PATE and FID 186 versus 153 for G-PATE; on CelebA–Gender at $\lambda$15, the reported values are IS 1.18 versus 1.11 and FID 298 versus 302. The framework also adapts TopAgg to DP-SGD by replacing the standard sum-and-noise step with a NormTopK compression scheme that retains the minimal coordinate set whose squared norm reaches a $\lambda$16 fraction of the original norm and then adds noise $\lambda$17. Because the clipped norm becomes at most $\lambda$18, the noise scale can be reduced by $\lambda$19 for the same privacy budget. Reported gains include CIFAR-10 at $\lambda$20, where TopAgg with $\lambda$21 reaches 45.9% versus 41.6% for GM-DP. Practical recipes in the appendix specify, among other settings, 4 000 teachers for MNIST, 6 000 for CelebA-Gender, 8 000 for CelebA-Hair, top-$\lambda$22 values such as 200 for MNIST at $\lambda$23, and noise scales such as 5 000 for MNIST at $\lambda$24.

Taken together, these usages show that DataLens is best understood as a family of selective analytic mechanisms rather than a single methodology. In one branch it edits neighborhood structure before manifold layout; in another it parameterizes focus+context operations over spatial data; in another it exposes hidden connections among datasets through topology design; in another it formalizes cleaning-tool selection as a performance-driven optimization loop; and in another it compresses and privatizes gradients for synthetic-data generation. The name is shared, but the technical substance is domain-specific.