TabularARGN: Auto-Regressive Synthetic Data

• TabularARGN is an auto-regressive generative model that synthesizes realistic tabular data by converting heterogeneous features into categorical sub-columns.
• It employs any-order training to support arbitrary conditioning, enabling effective synthesis for flat, relational, and sequential datasets.
• The framework balances generation fidelity, speed, and privacy through techniques like teacher forcing, dropout, and optional DP-SGD.

TabularARGN, short for Tabular Auto-Regressive Generative Network, is a shallow, any-order auto-regressive framework for generating synthetic tabular data. In the 2025 literature, it is described both as a standalone neural generator for privacy-preserving tabular synthetic data and as the core generative engine inside the MOSTLY AI Synthetic Data SDK, where it makes the SDK’s “train once, generate many” workflow practical for flat tabular data, multi-table relational data, and sequential data. Its defining strategy is to convert heterogeneous columns into categorical sub-columns, learn conditional distributions over those discrete representations with categorical cross-entropy, and synthesize rows or relational structures step by step from learned conditionals (Tiwald et al., 21 Jan 2025, Krchova et al., 1 Aug 2025, Sidorenko et al., 8 Aug 2025).

1. Probabilistic formulation and design objectives

TabularARGN is framed as a density estimator for tabular synthesis. For encoded sub-columns $x_1,\dots,x_D$, it models the joint distribution by an auto-regressive factorization,

$$p(x_1,\dots,x_D) = \prod_{d=1}^{D} p(x_{\pi(d)} \mid x_{\pi(<d)}),$$

or, in the standard fixed-order notation,

$$p(\mathbf{x}) = \prod_{i=1}^{D} p(x_i \mid x_{<i}).$$

The target setting is mixed-type, multivariate tabular data, including categorical, numerical, datetime, geospatial, and string-valued fields, with extensions to sequential and relational settings (Tiwald et al., 21 Jan 2025, Sidorenko et al., 8 Aug 2025).

A central feature is the distinction between fixed-order and any-order training. In fixed-order mode, a single column order is used throughout training. In any-order, or “flexible-order,” mode, the column order is randomly permuted per batch, and the model is trained to estimate conditionals over arbitrary subsets,

$$\forall S \subseteq \{1,\dots,D\} \setminus \{i\}, \quad \hat{p}(x_i \mid \{x_j : j \in S\}).$$

The training objective is correspondingly written as

$$\max_{\theta} \; \mathbb{E}_{\sigma \in \text{Uniform}(S_D)} \Biggl[ \sum_{i=1}^{D} \log p_{\theta}\bigl(x_{\sigma(i)} \mid x_{\sigma(<i)}\bigr) \Biggr].$$

This any-order formulation is the basis for conditional generation, imputation, and fairness-aware synthesis, while the papers explicitly note a trade-off: flexible order improves usability and conditional generation versatility, but can make learning harder and sometimes slightly reduce fidelity; fixed order can improve accuracy but sacrifices arbitrary conditioning at generation time (Tiwald et al., 21 Jan 2025, Krchova et al., 1 Aug 2025).

The stated goals are fourfold: synthetic rows should be statistically faithful to source data, useful for downstream ML tasks, hard to detect as synthetic, and robust against privacy attacks such as membership inference. This combination of fidelity, efficiency, and versatility is presented as the core design problem TabularARGN addresses (Sidorenko et al., 8 Aug 2025, Tiwald et al., 21 Jan 2025).

2. Discretization-first representation and neural architecture

A major design choice is that TabularARGN operates internally on categorical sub-columns. Before training, every original feature is converted into one or more categorical variables. Categorical columns remain categorical; numerical columns can be treated automatically, discretized, binned into 100 intervals, decomposed into digits, or treated as categorical when they are effectively identifiers or discrete codes; datetime columns can be decomposed into year/month/day/hour/minute/second, with relative encodings for sequential data; geospatial coordinates are hierarchically discretized into quadtile-like levels; and short structured strings can be split into character-level columns. Missing values are treated as their own category so that missingness patterns are preserved rather than erased (Krchova et al., 1 Aug 2025, Tiwald et al., 21 Jan 2025, Sidorenko et al., 8 Aug 2025).

This representation makes the generator architecturally simple. After preprocessing, the entire dataset is categorical regardless of original type, so each prediction is a categorical distribution over a finite vocabulary rather than a continuous-density estimate. The model is described as a shallow feed-forward network built from an embedding layer, a permutation masking layer, a regressor block, and a predictor layer. Categorical values are mapped to embeddings, embeddings are concatenated and causally masked according to the current column order, a feature-specific regressor produces a hidden representation, and a softmax predictor outputs the categorical probabilities for that sub-column. The masking layer enforces auto-regressive causality by zeroing out later features for each prediction task (Tiwald et al., 21 Jan 2025, Sidorenko et al., 8 Aug 2025).

Training minimizes the sum of categorical cross-entropies across sub-columns. The optimization uses teacher forcing, so ground-truth preceding columns are supplied as context during learning. The papers describe this as a multi-task learning setup: each sub-column is a separate prediction problem, but embeddings and upstream structure are shared across tasks. Regularization includes dropout in regressor layers, validation-based early stopping, learning rate reduction on plateaus, and optional DP-SGD. Appendix details include a 10% validation split, patience $N=5$ epochs for early stopping, and learning-rate halving after $K=3$ non-improving epochs (Tiwald et al., 21 Jan 2025, Sidorenko et al., 8 Aug 2025).

The literature repeatedly attributes TabularARGN’s computational profile to this architectural simplicity. Because it is a shallow feed-forward auto-regressive model over discretized columns, it avoids the heavier iterative denoising of diffusion models and the larger parameter counts typical of transformer-based approaches (Sidorenko et al., 8 Aug 2025, Tiwald et al., 21 Jan 2025).

3. Sampling, conditioning, and controllable generation

At generation time, TabularARGN samples one feature at a time. The flat-table procedure is described as starting with a zero vector, predicting the marginal of the first feature, sampling from it, embedding that sampled value, and then continuing sequentially until the row is complete. Since training may include permutation randomization, inference can use arbitrary orders rather than a single fixed factorization (Sidorenko et al., 8 Aug 2025, Tiwald et al., 21 Jan 2025).

This ability to condition on arbitrary prefixes or subsets is the operational basis for several downstream capabilities. Conditional generation supplies known attributes and samples the rest. Imputation treats missing columns as unknown and samples them conditioned on observed columns. Group-specific synthesis generates data for specified subpopulations. In the SDK setting, a flexible-order model can generate arbitrary subsets of columns conditioned on user-provided attributes, with remaining columns sampled sequentially (Krchova et al., 1 Aug 2025, Tiwald et al., 21 Jan 2025).

The sampling process is further controlled by temperature and top-$p$. Lower temperature makes generation more conservative and mode-seeking, while higher temperature increases diversity. Top-$p$ truncates the candidate set to the smallest set whose cumulative probability reaches a threshold. These controls are presented as a way to trade off strict realism against diversity or stress-testing behavior (Krchova et al., 1 Aug 2025).

A distinct mechanism is used for fairness-aware generation. To enforce statistical parity, the SDK samples the target column last and adjusts its conditional probabilities based on already generated sensitive attributes. This is described as a dynamic generation-time intervention rather than retraining: the model remains the same, but the generation process is constrained so that outcomes are balanced across sensitive groups. The papers explicitly characterize this as a trade-off between parity and fidelity, enabled by TabularARGN’s any-order conditioning (Krchova et al., 1 Aug 2025, Tiwald et al., 21 Jan 2025).

4. Relational and sequential generalization

Although the flat-table version is the core formulation, TabularARGN is extended to relational and sequential data. In the MOSTLY AI Synthetic Data SDK, the model sits inside the generator artifact. Once data are ingested and encoded, the SDK trains a TabularARGN-based generator; afterward, the generator can be exported, shared, reloaded, and used to synthesize new datasets with options for conditional generation, rebalancing, imputation, fairness adjustment, and privacy controls. The SDK wraps higher-level artifacts—connectors, generators, synthetic datasets, and QA reports—around this model (Krchova et al., 1 Aug 2025).

For multi-table data, the framework distinguishes subject tables and linked tables. Subject tables contain one row per entity and define the granularity at which privacy is controlled; linked tables contain event-, sequence-, or time-indexed records. Tables are linked through context and non-context foreign keys. With context foreign keys, dependencies between parent and child tables are explicitly modeled and retained; with non-context keys, referential integrity is maintained while tables are modeled independently. Generation is hierarchical: parent and ancestor tables are synthesized first, their records are compressed into context embeddings, and downstream tables are then generated conditioned on synthetic ancestors and one-hop context tables. Sibling sequential tables can also condition on one another, while tables outside the context chain remain structurally linked through preserved foreign keys (Krchova et al., 1 Aug 2025).

Sequential capability is treated in two complementary ways in the literature. In the SDK description, a flat subject table is sampled first and its synthetic records become context for the sequence model; the linked sequential table is then generated conditionally, preserving event order and temporal relationships. For temporal columns, the SDK uses a special “Datetime: Relative” encoding to model intervals between events (Krchova et al., 1 Aug 2025). In the original framework paper, the sequence history is encoded with an LSTM, whose final hidden state provides a history embedding $\mathcal{H}_{0:T-1}$, and a flat context table can be encoded into a context embedding $$p(x_1,\dots,x_D) = \prod_{d=1}^{D} p(x_{\pi(d)} \mid x_{\pi(<d)}),$$0 that is concatenated with history and current-step inputs. This sequential extension is described as handling arbitrary sequence lengths, zero-length sequences, irregular time gaps, and ordered sets rather than only evenly spaced time series (Tiwald et al., 21 Jan 2025).

Taken together, these extensions recast TabularARGN from a single-table row model into a schema-aware conditional generator. A plausible implication is that the same discrete auto-regressive backbone is being reused across increasingly structured data settings, with preprocessing and context construction absorbing much of the complexity.

5. Privacy safeguards and privacy evaluation

TabularARGN is presented as privacy-aware by design, but not formally private by default. Several protections operate before and during training. At the encoding stage, value protection reduces re-identification risk: rare categorical values may be consolidated into a $$p(x_1,\dots,x_D) = \prod_{d=1}^{D} p(x_{\pi(d)} \mid x_{\pi(<d)}),$$1 category or replaced with more common alternatives; numerical values may be binned into percentiles or split into digits and clipped; datetimes are decomposed and range-clipped; geospatial values are coarsened into quadtiles; and text uses a data-independent tokenizer to avoid phrase leakage. During training, the model uses early stopping with a validation split of up to 10%, automatic epoch limiting based on sample size, and dropout of 25% in each layer to reduce memorization (Krchova et al., 1 Aug 2025, Sidorenko et al., 8 Aug 2025).

For formal privacy, the SDK offers optional differential privacy training via Opacus, using gradient clipping, noise addition, randomized data loading, and privacy accounting to bound the effect of any single record by an $$p(x_1,\dots,x_D) = \prod_{d=1}^{D} p(x_{\pi(d)} \mid x_{\pi(<d)}),$$2 budget. The standalone privacy paper likewise includes optional DP-SGD and emphasizes that TabularARGN’s autoregressive backbone remains unchanged while the optimization procedure can be made privacy-preserving (Krchova et al., 1 Aug 2025, Sidorenko et al., 8 Aug 2025).

Privacy evaluation goes beyond simple nearest-neighbor checks. The 2025 privacy study evaluates TabularARGN inside the CDTD benchmark pipeline and reports that plain DCR can be misleading. It therefore introduces a corrected criterion based on

$$p(x_1,\dots,x_D) = \prod_{d=1}^{D} p(x_{\pi(d)} \mid x_{\pi(<d)}),$$3

Negative values indicate acceptable privacy, while positive values indicate overfitting. Under this correction, TabularARGN is reported as the strongest overall method in the revised ranking, with five first-place and two second-place finishes across the seven metrics considered in that privacy-adjusted ranking (Sidorenko et al., 8 Aug 2025).

The same study performs a systematic membership-inference analysis on the Adult dataset, targeting two high-risk records identified by the Achilles procedure. For baseline TabularARGN without DP, most attack AUCs are only slightly above chance; the strongest attack, CorrGroundhog, reaches about AUC = 0.635 and ~60.1% accuracy, while many others sit around 0.58–0.60 AUC and distance-based attacks are around 0.53–0.56 AUC. With value protection, attack AUCs generally fall to 0.50–0.55, and CorrGroundhog drops to about 0.501. With DP-SGD ($$p(x_1,\dots,x_D) = \prod_{d=1}^{D} p(x_{\pi(d)} \mid x_{\pi(<d)}),$$4), attacks drop to near-random, with AUC $$p(x_1,\dots,x_D) = \prod_{d=1}^{D} p(x_{\pi(d)} \mid x_{\pi(<d)}),$$5 and accuracy $$p(x_1,\dots,x_D) = \prod_{d=1}^{D} p(x_{\pi(d)} \mid x_{\pi(<d)}),$$6 (Sidorenko et al., 8 Aug 2025).

6. Empirical results, deployment, and terminology

The benchmark results reported for TabularARGN emphasize both quality and speed. On the Adult flat-table benchmark, TabularARGN reaches 97.9% accuracy, compared with 98.2% for TabSyn, 80.6% for STaSy, and 79.0% for CTGAN; training time is 138 s for TabularARGN versus 2,316 s for TabSyn, 4,588 s for STaSy, and 2,684 s for CTGAN. On ACS-Income, TabularARGN reaches 98.5% and is reported as the best on that larger benchmark, with training time 3,511 s versus 8,942 s for TabSyn. Appendix numbers give 1 s Adult generation time for TabularARGN versus 9 s for TabSyn and 78 s for TabDDPM, and 20 s generation time on ACS-Income (Tiwald et al., 21 Jan 2025).

For sequential tables, the reported main-table results are 88.4% accuracy on Baseball, with appendix values of 95.8% univariate, 78.0% bivariate, and 91.5% coherence, and training time 174 s; baseline scores are 78.0% for REaLTabFormer, 70.0% for RC-TGAN, and 79.4% for ClavaDDPM. On California, TabularARGN reaches 98.1% accuracy, with appendix values of 99.0% univariate, 98.1% bivariate, and 97.2% coherence, and training time 6,887 s; the reported baseline scores are 88.6%, 73.3%, and 77.3% for REaLTabFormer, RC-TGAN, and ClavaDDPM respectively (Tiwald et al., 21 Jan 2025).

The privacy-oriented CDTD evaluation reports strong average ranks across eleven datasets: approximately RMSE: 3.6, F1: 3.5, AUC: 3.0, $$p(x_1,\dots,x_D) = \prod_{d=1}^{D} p(x_{\pi(d)} \mid x_{\pi(<d)}),$$7: 3.1, Detection score: 1.8, JSD: 3.1, and Wasserstein: 2.4. TabularARGN is reported as achieving the best average rank on Wasserstein distance, second-best on correlation $$p(x_1,\dots,x_D) = \prod_{d=1}^{D} p(x_{\pi(d)} \mid x_{\pi(<d)}),$$8, and the best average detection score, meaning real/fake classifiers struggle more to distinguish its samples from real data (Sidorenko et al., 8 Aug 2025).

With differential privacy enabled, the original framework paper reports: Adult: $$p(x_1,\dots,x_D) = \prod_{d=1}^{D} p(x_{\pi(d)} \mid x_{\pi(<d)}),$$9, accuracy 93.8%; ACS-Income: $$p(\mathbf{x}) = \prod_{i=1}^{D} p(x_i \mid x_{<i}).$$0, accuracy 96.7%; Baseball: $$p(\mathbf{x}) = \prod_{i=1}^{D} p(x_i \mid x_{<i}).$$1, accuracy 79.0%; and California: $$p(\mathbf{x}) = \prod_{i=1}^{D} p(x_i \mid x_{<i}).$$2, accuracy 93.4%. Training time increases by approximately 2.6× on Adult, 3.9× on ACS-Income, 10× on Baseball, and 2.7× on California (Tiwald et al., 21 Jan 2025).

Within the SDK, these modeling results are coupled to a deployment-oriented workflow. The SDK is presented as an open-source, locally installable Python package available via pip, with automatic preprocessing, automatic hyperparameter selection such as batch size and learning rate, export/import support, and built-in QA reports. The QA module uses holdout-based evaluation with fidelity and privacy metrics, including distributional similarity, embedding-based measures, nearest-neighbor distances, and DCR-style privacy checks. The authors contrast this system with broader synthetic-data systems such as SDV, arguing that SDV can require more manual tuning and may struggle to scale to larger or more complex relational and temporal datasets, whereas the TabularARGN-based SDK is simpler to operate and more efficient on complex multi-table and sequential structures (Krchova et al., 1 Aug 2025).

A recurring source of confusion is nomenclature. In the synthetic-data literature of 2025, TabularARGN denotes Tabular Auto-Regressive Generative Network for synthetic tabular data (Tiwald et al., 21 Jan 2025). Separate works discuss an argumentation tableau for argument construction (Roos, 2022) and Abstract Reasoning with Graph Abstractions (ARGA) for ARC program synthesis (Xu et al., 2022). Those are distinct methods with different objectives, representations, and problem settings.