💻 computer science

Creation begins with understanding: LLMs as strategy designers for privacy-preserving tabular data synthesis

This paper introduces TabSSD, a novel framework that leverages Large Language Models to design privacy-preserving synthesis procedures based on variable dependence summaries rather than raw data, achieving superior statistical fidelity, utility, and privacy trade-offs while significantly reducing computational costs and expertise barriers compared to existing methods.

Original authors: Dandan Guo, Jinmeng Li, Quan Zhang, Hangting Ye, He Zhao, Firas Laakom, Juergen Schmidhuber

Published 2026-10-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Dandan Guo, Jinmeng Li, Quan Zhang, Hangting Ye, He Zhao, Firas Laakom, Juergen Schmidhuber

Original paper licensed under CC BY 4.0 (https://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

In many fields, from medicine to finance, the most valuable insights come from looking at rows and columns of numbers: a patient's age, blood pressure, and test results; a customer's spending habits and location. These are tabular data, the structured records that power modern decision-making. However, sharing this information is often blocked by strict privacy laws designed to protect individuals. If a hospital wants to collaborate with researchers, it cannot simply send a spreadsheet containing real patient names and histories. For years, the solution has been to create "synthetic" data: fake records that look and behave like the real thing but belong to no actual person. The challenge has always been making these fakes good enough to be useful without being so perfect that they accidentally reveal the secrets of the real people they mimic.

Traditionally, creating these synthetic tables has relied on two difficult paths. One path uses complex, black-box computer models that learn patterns by adjusting millions of internal settings. While powerful, these models are hard to inspect; if they fail or leak information, it is often impossible to see why. The other path has recently tried using large language models, the same technology that powers advanced chatbots, to write out fake records one by one. But this approach often fails because it forces the computer to read a spreadsheet as a long, continuous stream of text, which scrambles the natural relationships between columns and can accidentally expose sensitive details in the process.

A new study introduces a different way forward, shifting the role of the artificial intelligence from a record-keeper to an architect. Instead of asking a computer to generate thousands of fake rows of data directly, the researchers developed a system called TabSSD that asks the computer to design the instructions for making them. The system first analyzes the real data locally on a secure computer, summarizing how the different columns relate to one another without ever sending the raw numbers to the cloud. It then sends these summaries to a large language model, which acts as a strategy designer. The model reads the summaries and writes a set of executable computer code instructions—a recipe for generating the fake data. This code is then run locally to produce the synthetic dataset. By separating the design of the strategy from the actual generation of data, the system ensures that the original private records never leave the owner's control, while still producing high-quality synthetic data that preserves the complex relationships found in the real world.

The researchers tested this approach on twelve different real-world datasets, ranging from small medical records to large collections of demographic information. They compared their method against ten other leading techniques, including deep learning models and other language-based approaches. The results showed that the new system struck a remarkable balance. It produced synthetic data that was statistically very close to the real data, meaning models trained on the fake data performed just as well as those trained on the real thing. At the same time, it kept the risk of re-identifying real individuals extremely low. In fact, across all the metrics they measured, this new method achieved the best average rank among the ten methods tested. It achieved this performance while using significantly less computing power and time, running efficiently on standard computer processors without needing expensive graphics cards.

One of the most significant advantages of this approach is transparency. Because the system outputs a piece of readable computer code rather than a hidden neural network, human experts can actually look at the instructions to see how the data is being made. If a doctor or a data analyst notices a potential bias, such as the system accidentally linking a person's gender to their job title in a way that doesn't reflect reality, they can simply open the code and edit the rules. In a test involving a census dataset, the researchers demonstrated that a human could remove a specific variable from the instructions to reduce gender bias, and the system would immediately generate new data that respected this change without needing to be retrained from scratch. This ability to audit and tweak the process makes the technology much more suitable for high-stakes fields where trust and safety are paramount.

The study also highlighted how the system adapts to different types of data. When faced with a dataset where variables were tightly linked, like blood test results that depend on one another, the system designed a strategy using statistical tools suited for continuous numbers. When it encountered a dataset with mostly categories, like car types, it switched to a different set of rules. This flexibility allowed it to handle everything from simple tables to complex, high-dimensional data with hundreds of variables. In a specific case involving a clinical dataset with a rare outcome—patients who died within a year of surgery—the system successfully generated enough fake examples of these rare cases to help train better prediction models, all while preserving the subtle patterns of the disease that other methods missed.

Ultimately, the work suggests a shift in how we think about artificial intelligence for structured data. Rather than treating these models as engines that churn out data token by token, the researchers show they are better suited to be the architects who design the process. By using the language model to write the instructions and keeping the actual data generation local and under human supervision, the system offers a path to sharing sensitive information that is both secure and understandable. It lowers the barrier for organizations to use synthetic data, removing the need for specialized teams to tune complex models or manage massive computing resources. The findings indicate that for tabular data, the most effective use of advanced AI may not be to generate the data itself, but to design the transparent, auditable rules that allow us to create it safely.

Technical Summary: Tabular Synthesis Strategy Designer (TabSSD)

Problem Statement

Sharing tabular data in high-stakes domains (e.g., healthcare) is constrained by privacy regulations. While synthetic data offers a solution, existing approaches face significant limitations:

Deep Generative Models (DGMs): Methods like GANs and Diffusion models encode distributions implicitly within neural parameters. This creates "black-box" generation mechanisms that are difficult to audit, inspect, or correct without computationally expensive retraining.
LLM-Based Methods: Current approaches often serialize tabular records into text sequences to leverage Large Language Models (LLMs). This creates a modality mismatch, obscuring intrinsic variable dependence, imposing artificial order, and exposing raw sensitive data during prompting. Furthermore, these methods incur high token costs and context-window limitations, particularly for high-dimensional data.

There is a need for a synthesis paradigm that balances statistical fidelity, predictive utility, and privacy while ensuring the generation process is transparent, auditable, and computationally efficient.

Methodology: TabSSD

The authors propose Tabular Synthesis Strategy Designer (TabSSD), a framework that repositions the LLM from a direct record generator to a high-level strategy designer. The core innovation is that the LLM does not receive raw records; instead, it receives abstract summaries of variable dependence to design executable Python programs for local synthesis.

Core Workflow

Local Dependence Extraction:
- The framework uses chained trees (a sequence of classification and regression trees) to capture variable dependence without parametric assumptions.
- For each feature $X_j$ , a tree is trained to predict it from all other features and the label. For the label $Y$ , a tree predicts it from all features.
- To ensure scalability and privacy, the decision rules are distilled into compact "dependence signals" (variable types, split variables, goodness-of-fit scores) rather than raw data.
- For high-dimensional datasets, a greedy set-cover algorithm selects a minimal subset of trees to cover all variables, preventing context-window overflow.
LLM Strategy Design:
- A structured prompt is constructed containing: task definition, metric guidance, reasoning instructions, the tree-derived dependence evidence, and an output template.
- The LLM analyzes the dependence structure and generates multiple candidate synthesis strategies expressed as executable Python code.
- The LLM determines sampling orders, selects appropriate conditional samplers (e.g., Gaussian copulas, regression trees), and handles variable dependencies.
Local Execution and Selection:
- Candidate strategies are executed locally on the data holder's environment (CPU only).
- Strategies are evaluated for statistical fidelity, empirical privacy risk (e.g., $\delta$ -presence, Distance to Closest Record), and runtime.
- Strategies failing privacy thresholds or execution limits are discarded. The best-performing strategy is selected to generate the final synthetic dataset.
Human-in-the-Loop Auditing:
- Because the synthesis logic is represented as inspectable code, domain experts can audit rules, diagnose anomalies, and manually edit the strategy (e.g., removing sensitive predictors to reduce bias) without retraining models or re-querying the LLM.

Key Contributions

Paradigm Shift: Moves LLMs from record-level generation to strategy-level design, avoiding the serialization of raw data and the associated privacy risks.
Privacy-Preserving Interface: The LLM interacts only with abstract tree-derived summaries, ensuring original data never leaves the local environment.
Transparency and Auditability: By outputting executable Python code, the framework enables human experts to inspect, verify, and modify the synthesis logic, addressing the opacity of deep generative models.
Efficiency: The method operates on CPU only and significantly reduces token consumption compared to record serialization, making it scalable for high-dimensional data.

Results

Evaluated across 12 heterogeneous real-world datasets and a clinical data augmentation case study, TabSSD demonstrates:

Statistical Fidelity: Achieves low marginal distribution error (3.80%) and pairwise correlation error (3.89%), outperforming most deep generative baselines (e.g., TabDDPM, CTGAN) and comparable to the best-performing methods.
Privacy-Utility Trade-off: TabSSD lies on the Pareto front for both utility vs. memorization risk and fidelity vs. re-identification risk. It achieves the best average rank (2.17) across six metrics among ten compared methods.
Computational Efficiency: TabSSD has an average end-to-end runtime of 199.6 seconds, which is 1.7x faster than the fastest baseline (ARF) and significantly faster than GPU-accelerated deep generative models when run on CPU.
Token Efficiency: For high-dimensional datasets, TabSSD uses up to 130x fewer tokens than record serialization methods by using compact tree rules instead of raw data.
Clinical Utility: In a thoracic surgery dataset with class imbalance, TabSSD achieved the highest balanced accuracy (0.578) and best preserved the distribution of minority tumor categories and mortality risk profiles compared to other methods.
Editability: Case studies demonstrated that human experts could edit the generated code to reduce gender bias (reducing Cramér's V from 0.420 to 0.193) while maintaining statistical fidelity.

Significance and Claims

The paper claims that TabSSD offers a transparent and efficient approach to privacy-preserving tabular data synthesis. Its primary significance lies in:

Lowering Barriers: It reduces the expertise and infrastructure requirements for tabular synthesis by automating dependence extraction and strategy selection, removing the need for users to design deep generative models, fine-tune LLMs, or utilize local GPU acceleration.
Human-Governed AI: By representing the synthesis mechanism as executable code, it enables failures to be traced, domain constraints to be incorporated, and strategies to be revised without retraining. This modular separation of data structure, LLM reasoning, and local verification provides a basis for human-governed generative AI.
Generalizability: The authors suggest that for structured data, LLMs may be more valuable as designers of synthesis procedures than as direct record generators, a paradigm that may extend to other heterogeneous data modalities.

The authors acknowledge limitations, noting that the method depends on the adequacy of tree-derived summaries and the reliability of the backbone LLM, and that scalability to ultra-high-dimensional tables may still face context-window constraints. However, they posit that this strategy-level reasoning provides a robust alternative to current black-box and privacy-risking synthesis methods.