🤖 machine learning

Inference-Time Refinement Closes the Synthetic-Real Gap in Tabular Diffusion

The paper introduces TARDIS, an inference-time refinement framework that utilizes Bidirectional Chamfer Refinement to optimize outputs from a frozen pre-trained diffusion backbone, thereby closing the synthetic-real gap and achieving downstream task performance that exceeds models trained on real data without requiring retraining.

Original authors: Eugenio Lomurno, Filippo Balzarini, Francesco Benelle, Francesca Pia Panaccione, Matteo Matteucci

Published 2026-05-08

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Eugenio Lomurno, Filippo Balzarini, Francesco Benelle, Francesca Pia Panaccione, Matteo Matteucci

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a student (an AI model) how to drive a car. Usually, you'd let them practice on real roads with real traffic. But sometimes, you can't do that because the roads are private, dangerous, or full of sensitive information. So, you create a simulator (synthetic data) that looks and feels exactly like the real world to train them on.

For a long time, the "simulator" has been good, but not quite as good as the real thing. The students trained on the simulator always performed slightly worse than those trained on the real roads. Researchers have been trying to fix this by building better simulators from scratch, which is like trying to build a perfect video game engine from the ground up every time. It's expensive, slow, and often still falls short.

This paper introduces a new approach called TARDIS. Instead of rebuilding the simulator, TARDIS acts like a smart coach that steps in after the simulator has already generated a bunch of practice scenarios. It tweaks the simulation in real-time to make it perfect, without needing to retrain the whole engine.

Here is how TARDIS works, broken down into three simple stages:

1. The "Over-Production" Phase (Stage I)

Imagine a factory that makes toy cars. Instead of making exactly 100 cars to match the real world, TARDIS tells the factory to make 5,000 cars (50 times more than needed). This creates a massive "pool" of potential practice scenarios. Most of these will be okay, but some will be weird, and some will be perfect.

2. The "Real-Time Steering" Phase (Stage II)

This is the magic trick. As the factory is generating these 5,000 cars, TARDIS doesn't just let them roll off the line. It has a GPS (called a "representation map") that knows exactly what a "real" car looks like.

The Analogy: Imagine a sculptor chiseling a block of marble. Instead of waiting until the statue is finished to see if it looks right, the sculptor constantly checks the shape against a photo of the real person while chiseling.
The Mechanism: TARDIS uses a mathematical rule called Bidirectional Chamfer Refinement (BCR). It gently nudges the generated data toward the real data while it's being created. It's like a magnetic field pulling the fake cars closer to the shape of real cars, ensuring they don't drift off into "weird land."

3. The "Final Cut" Phase (Stage III)

Once the factory has produced the 5,000 cars, TARDIS doesn't just pick the first 100. It acts like a talent scout. It looks at all 5,000 cars and ranks them based on how closely they match the real-world photo. It picks the top 100 that are the most "realistic" and discards the rest.

The "Two-Way" Check: The paper emphasizes that this check is bidirectional. It's not just checking "Does this fake car look like a real car?" (Fidelity). It also checks "Does the real car have a fake twin in this batch?" (Coverage). This ensures the AI doesn't just memorize one specific real car and copy it over and over (which would be bad for privacy); it ensures the fake data covers the whole variety of the real world.

Why This Matters

The authors tested this on 15 different datasets (ranging from predicting diabetes to analyzing music preferences). Here is what they found:

Beating the Real Thing: In 11 out of 15 cases, the AI trained on TARDIS's refined fake data actually performed better than an AI trained on the actual real data.
Speed: This whole "coaching" process takes between 1 and 80 minutes on a standard, older computer graphics card. You don't need a supercomputer.
Privacy: Because the system checks for "coverage" (making sure it doesn't just copy-paste real records), the fake data remains safe and doesn't accidentally leak private information.

The Big Takeaway

The paper argues that the gap between "fake data" and "real data" isn't a problem you have to solve by building a better generator from scratch. It's a problem you can solve by refining the output after the fact.

Think of it like this: You don't need to hire a better actor to play a role perfectly; sometimes, you just need a better director to guide the performance while the camera is rolling. TARDIS is that director, turning a good performance into a perfect one in minutes.

Technical Summary: Inference-Time Refinement Closes the Synthetic-Real Gap in Tabular Diffusion

1. Problem Statement

Despite diffusion-based generators achieving state-of-the-art performance in synthetic tabular data, a persistent "synthetic–real gap" remains: downstream learners trained on synthetic data rarely match the utility of those trained on real data. Existing approaches to closing this gap have focused exclusively on training-time interventions, such as architectural advances (e.g., TabDiff, TabSyn), scaling, or retraining monolithic generators. These methods yield only marginal gains and fail to consistently match real-data utility.

The paper posits that the gap is not primarily a training-time problem but an inference-time problem. While inference-time guidance (e.g., Classifier-Free Guidance, Chamfer Guidance) has been successful in image synthesis, its application to tabular data has been hindered by three specific challenges:

Mixed-type feature spaces: Tabular data lacks a canonical differentiable distance metric suitable for gradient-based guidance.
Absence of a standardized representation: Unlike images (which use CLIP), tabular data lacks a unified embedding space.
Dual objectives: The "Train-on-Synthetic-Test-on-Real" (TSTR) setting requires balancing fidelity (synthetic-to-real proximity) and coverage (real-to-synthetic manifold coverage), which standard guidance often neglects.

2. Methodology: TARDIS

The authors introduce TARDIS (Tabular generation through Refinement, Distillation, and Inference-time Sampling), a framework that refines the outputs of a frozen pre-trained tabular diffusion backbone (specifically TabDiff) without retraining. The core principle is Bidirectional Chamfer Refinement (BCR), which minimizes a symmetric Chamfer functional between synthetic candidates and real data at two complementary levels: continuously during sampling and discretely post-sampling.

The framework operates in three stages:

Stage I: Oversampling

The system draws an oversampled noise pool $D_{noise}$ of cardinality $M \cdot N_r$ (where $N_r$ is the real dataset size and $M=50$ is fixed) from the latent space. This redundancy provides a candidate pool for subsequent refinement.

Stage II: Bidirectional Chamfer Guidance (Continuous Refinement)

During the reverse diffusion process, the predicted score $\epsilon_\theta(x_t, t)$ is perturbed by the gradient of a bidirectional Chamfer functional $C$ with respect to a real reference batch $x_r$ .

Representation Map ( $\phi$ ): To handle mixed-type data and provide differentiability, the system uses a representation map $\phi$ $ϕ$ . The search space allows for either:
- Identity mapping: Applied to z-score-normalized features.
- $\beta$ -VAE mapping: An encoder trained on real data to map features to a latent space, absorbing heterogeneity.
Score Perturbation: The perturbed score is $\tilde{\epsilon}_\theta = \epsilon_\theta - \Gamma(t) \cdot \nabla_{x_t} C(x_t, x_r)$ . This steers the generation toward the real-data manifold.
Hyperparameter Tuning: A Tree-structured Parzen Estimator (TPE) search tunes guidance parameters (schedule $\Gamma(t)$ , reference batching, and $\phi$ type) per dataset.

Stage III: Refinement Selection (Discrete Refinement)

After generating the candidate pool $D_{cand}$ , the system selects the final synthetic dataset $D_{syn}$ (cardinality $K \cdot N_r$ ) via post-hoc batch ranking.

Chamfer Sampler: Batches are ranked by the same Chamfer functional $C$ used in Stage II. The top-ranked batches are retained. This step prunes "off-manifold" candidates that survived the continuous guidance.
Generative Knowledge Distillation (GKD): An optional step where a teacher classifier trained on real data relabels candidates with soft targets. This is primarily effective in low-cardinality regimes ( $K \le 1$ ).
Search Strategy: An inner grid search over five sampler variants (including Chamfer, MDSampler, Stratified, etc.) and the GKD toggle selects the configuration maximizing validation utility for each TPE trial.

3. Key Contributions

Inference-Time Refinement Framework: TARDIS is the first framework to apply inference-time refinement to tabular diffusion, demonstrating that a frozen backbone can be significantly improved without retraining.
Bidirectional Chamfer Refinement (BCR): The authors propose BCR as a unifying principle that couples continuous score-level guidance and discrete batch ranking under a single symmetric Chamfer functional. This addresses the fidelity-coverage trade-off inherent in TSTR settings.
Handling Mixed-Type Data: The introduction of a dataset-specific representation map $\phi$ (either identity or $\beta$ -VAE encoder) enables the application of gradient-based guidance to tabular data, overcoming the lack of a canonical metric.
Empirical Validation of the "Inference-Time" Hypothesis: The work provides evidence that the synthetic–real gap is largely solvable at inference time, shifting the paradigm from "better generators" to "better refinement of existing generators."

4. Experimental Results

The framework was evaluated on 15 heterogeneous tabular benchmarks (binary classification, multiclass classification, and regression) using XGBoost as the downstream learner under the TSTR protocol.

Downstream Utility: TARDIS achieved a median +8.6% improvement over models trained on real data (95% CI [+3.3, +16.4], Wilcoxon $p=0.016$ ), with strict wins on 11 of 15 datasets.
Backbone Improvement: TARDIS improved upon the underlying TabDiff backbone on all 15 datasets (mean +12.9%, $p < 10^{-4}$ ).
Ablation Studies:
- Removing the oversample-and-select component (Stage I and III) reduced performance to a mean +1.4% over TabDiff, proving that discrete selection is critical.
- The search consistently selected BCR-aligned configurations (guided pool + Chamfer Sampler) on 9 of 15 datasets, validating BCR as the dominant refinement pattern.
Fidelity, Diversity, and Privacy: TARDIS matched the backbone on manifold fidelity (Precision) and diversity (Recall). Privacy metrics (DCR-1 share and NNDR) were preserved, indicating the bidirectional functional prevents collapse onto training records.
Runtime: On a single consumer-grade GPU (Nvidia GTX 1080 Ti), TARDIS adds a median of 16.1 minutes of wall-clock time (range 0.9 to 79.4 minutes) to the inference process.

5. Significance and Claims

The paper claims that the synthetic–real gap in tabular diffusion is not primarily a training-time problem. Instead, it demonstrates that inference-time refinement of a pre-trained backbone is sufficient to reach and exceed real-data utility in 1 to 80 minutes on standard hardware.

The significance lies in:

Paradigm Shift: Moving the focus from architectural complexity and retraining to post-hoc refinement.
Cost-Effectiveness: Achieving state-of-the-art utility without the computational cost of retraining large diffusion models.
Generality: The BCR principle is presented as domain-transferable, relying only on a differentiable representation map and a reference batch, suggesting applicability beyond tabular data.

The authors remain modest regarding limitations, noting that results are currently validated on a single backbone (TabDiff) and that formal differential privacy guarantees are not claimed, though privacy proxies are preserved. Future work is identified as extending BCR to other backbones (TabSyn, TabDDPM) and modalities.