5 GAN Papers That Shaped Modern Tabular Data Generation

*Written by: Dr. Milad Abdollahzadeh

Research Scientist at BetterData AI*

In GAN, two powerful neural networks (Generator and Discriminator) play an adversarial game to learn the real data distribution (this image is generated by Gemini 3 Pro).

Using real tabular data in machine learning (ML) is not always an option.

In high-stakes domains like fintech and healthcare, privacy concerns make it risky to train models directly on real data. Because even well-trained models can leak sensitive information — from full names and bank account details to medical histories. To address this, practitioners turn to synthetic data that preserves the statistical properties of the real data without exposing the information of real individuals.

Generative Adversarial Networks (GANs) are used as one of the most effective frameworks for tabular data generation.

In this post, we’ll break down 5 of the most influential GAN-based papers: MedGAN, Table-GAN, CTGAN, CTAB-GAN and PATE-GAN. By understanding these works, you’ll grasp most of the key ideas behind modern tabular data generation with GANs without needing to go through the entire literature. These papers are selected based on the citation impact, and the adaptation in widely used libraries.

After a brief background overview, for each paper, we’ll focus on:

• The type of tabular data and how it is handled
• The network architecture
• The learning objective

Let’s start.

Background

Here, we briefly review two key concepts: tabular data and Generative Adversarial Networks (GANs).

Tabular Data

A table T consists of M rows (samples), where each sample has N columns (features). Each column can have different types, such as numerical, categorical, or even text, as shown in Figure 1.

Figure 1. A snapshot of a table with 9 columns (features) of various types.

The goal of a generative model for tabular data is to learn the joint distribution of the columns. This involves learning both:

• the marginal distribution of each column
• the relationships between columns (e.g., how “KMs Driven” is related to “Selling Price” in Figure 1)

Once this joint distribution is learned, the generative model can produce new samples that follow the same statistical properties.

Figure 2. The basic architecture of a GAN for tabular data generation, including a generator (G) and a discriminator (D).

Generative Adversarial Networks (GANs)

As shown in Figure 2, a GAN is a type of generative model that consists of two networks:

• a generator (G) that maps a latent code z (a vector of random numbers) into a sample (in this case, a row of the table)
• a discriminator (D) that learns to distinguish between real samples (white rows in Figure 2) and generated samples (purple rows in Figure 2)

Ideally, the discriminator assigns a score of 1 to real samples (i.e., D(x) = 1) and a score of 0 to generated samples (i.e., D(G(z)) = 0). On the other hand, the generator aims to fool the discriminator by generating samples that resemble real data, encouraging D to assign a score as closer as to 1 to generated samples (i.e., D(G(z)) ≈ 1).

In practice, these competing objectives are formulated through the following value function:

The discriminator aims to maximize this objective, while the generator aims to minimize it. This adversarial process is commonly referred to as a min–max game.

Once training is complete, the discriminator is discarded, and the generator is used to produce synthetic tabular data.

In what follows, we review the details of the top 5 GAN-based approaches for tabular data generation.

1. MedGAN: Generating Multi-label Discrete Patient Records using Generative Adversarial Networks

Machine Learning for Healthcare 2017

MedGAN is the first work that applies GANs to tabular data generation, specifically targeting electronic health records (EHRs).

Data

MedGAN focuses on discrete variables, which are mapped to count values. Assuming C discrete variables, each row in table (i.e., a patient’s EHR) is represented as:

In practice, this means that each feature of the vector is treated as a non-negative count.

Binary variables are simply a special case, where:

Network Architecture

A key challenge of working with discrete variables is that backpropagation is not straightforward.

To address this, MedGAN combines an Auto-Encoder (AE) with a GAN. The full pipeline is shown in Figure 3.

Figure 3: Architecture of the MedGAN. (a) Encoder and Decoder of AE are trained on tabular data. (b) G generates samples in the latent space of the AE to enable backpropagation.

Step 1: Auto-Encoder Pre-training As shown in Figure 3(a), the Encoder (Enc) and Decoder (Dec) of the AE are first trained on real data:

• Enc maps a sample (row of a table; shown as white row in Figure) into a latent representation z’ (in AE’s latent space)
• Dec uses this latent code as input to reconstruct the original sample (shown as gray row in Figure)

Step 2: Adversarial Training After pre-training, AE is frozen. Then, as shown in Figure 3(b):

• G is trained to map a random noise z into a latent code into the AE latent space
• the Dec converts this into synthetic sample Dec(G(z)) (purple row in Figure)

The D receives:

• real samples from the dataset
• synthetic samples from Dec’s output

and learns to distinguish between them by real/fake classification.

Learning Objective

MedGAN follows the standard GAN objective (Equation (1)). However, GANs often suffer from mode collapse — where the model only captures a subset of the data distribution.

To mitigate this, MedGAN introduces mini-batch averaging. Instead of evaluating the samples one by one:

• the model computes the average representation of real samples and generated samples within each mini-batch
• these average representations are used for real/fake classification

Then, the loss from this classification is used to update both G and D.

2. Table-GAN: Data Synthesis based on Generative Adversarial Networks

VLDB 2018

Table-GAN is the first paper that — following the success of Deep Convolutional GAN (DCGAN) in image generation — uses convolutional networks for tabular data generation. It largely follows the design principles of DCGAN.

Data

Unlike MedGAN, which focuses on discrete variables, Table-GAN supports both numerical and categorical features within a unified framework.

To make convolutional architectures applicable, each row in the table is reshaped into a square matrix, potentially with zero padding. For example, a row with 9 columns can be represented as a 3x3 matrix (see Figure 4).

This transformation enables the use of 2D convolutions, which are empirically shown to be more effective than 1D convolutions for this task.

Figure 4. The architecture of Table-GAN.

Network Architecture

The architecture of Table-GAN is illustrated in Figure 4.

In addition to the standard Generator G and Discriminator D, Table-GAN introduces an auxiliary classifier network C, which predicts the value of a designated target column.

This is implemented by:

• masking (removing) the target column from the input sample
• feeding the remaining features into C
• predicting the missing value

If the target column is categorical, C acts as a classifier; if it is numerical, C acts as a regressor.

This additional component helps preserve semantic consistency in generated data (e.g., avoiding invalid combinations such as Gender = “Male” and Disease = “Uterine Cancer”).

Figure 5. Convolutional architecture used for G and D in Table-GAN.

Following DCGAN, both G and D are implemented using convolutional architectures (see Figure 5):

• The Discriminator progressively reduces spatial dimensions while increasing feature depth, enabling effective real/fake classification.
• The Generator uses deconvolution (transpose convolution) layers to map a latent vector z into a matrix-shaped synthetic sample.

The classifier C shares a similar architecture with D, but is trained for a different objective (classification or regression, as described above).

Learning Objective

Table-GAN optimizes 3 complementary loss functions:

1. Original loss: The standard adversarial loss used in GANs (Equation 1).

2. Information loss: Let f[.] denote the features extracted from the penultimate layer of D. Table-GAN matches the mean and standard deviation (SD) of these features between real and generated samples:

This encourages the generated data to match the statistical structure of real data in feature space.

3. Classification Loss: Let remove(x) denote the row x after masking its target column, l(x) denote the true value of the target column, and C(remove(x)) denote the predicted value after masking. The classification loss is defined as follows:

Note that the loss on the real samples is used as a feedback for C, and the loss on generated samples is used as feedback for training G.

After defining these 3 losses:

• D is trained by original loss
• C is trained by classification loss
• G is trained by all 3 losses

3. CTGAN: Modeling Tabular Data using Conditional GAN

NeurIPS 2019

CTGAN is the most widely used GAN-based model for tabular data generation. It has the highest number of citations among such works and has become the de facto standard in popular libraries such as SDV. At the time of its publication, it introduced a significant breakthrough in tabular data generation and proposed the first comprehensive benchmark for evaluating such models.

CTGAN has two main contributions:

• A novel approach for encoding tabular data
• A conditional generation strategy for handling imbalanced datasets

Figure 6. Encoding complex and multimodal distribution of continuous columns in CTGAN.

Data

One of the key factors behind CTGAN’s strong performance is its innovative encoding scheme for both numerical and categorical columns.

I. Categorical Column are encoded using one-hot encoding. For example, if a categorical column has 4 classes, and the second class appears in a sample, its encoding is: d=[0,1,0,0].

II. Numerical columns are encoded using a strategy designed to capture complex, multimodal distributions.

For each numerical column, a variational Gaussian mixture (VGM) model is fitted to estimate:

• The number of modes
• The mean and standard deviation of each mode

For example, in figure 6 (a), the data distribution (blue curve) is modeled with a mixture of 3 Gaussian distributions.

After estimating the distribution of column with VGM, Each value in that column is then represented using two components: a normalized scalar and a mode indicator vector.

This encoding is done as follows:

• For each value, compute the probability of belonging to each mode, and select the mode with the highest probability. For example, in Figure 6 (b), for value c, the third mode is selected as ρ₃ has the highest value.
• Normalize the value using the parameters of the selected mode. In Figure 6(b):

• Encode the selected mode as a one-hot vector. In this example, since third mode is selected, we have: βᵢ,ⱼ = [0,0,1].

Finally, the encoding of a numerical value is obtained by concatenating αᵢ,ⱼ and βᵢ,ⱼ.

Therefore, assuming N_c continuous columns and N_d discrete columns, the representation for a row is as:

Network Architecture

Apart from its encoding strategy, CTGAN uses a relatively simple architecture (figure 7(b)):

• Both the G and D are implemented as two-layer MLPs with batch normalization.
• Similar to the encoding of real data, G generates αᵢ,ⱼ and βᵢ,ⱼ for continuous variables, and d for categorical variables.

Figure 7. CTABGAN architecture: (a) constructing conditional vector to address data imbalance, (b) conditional generation with CTGAN

Note that during synthetic tabular data generation, these representations are mapped back to the original data space, since the encoding is reversible.

Learning Objective

CTGAN uses the standard GAN loss for training G and D. However, its main contribution lies in the sampling strategy used during training to handle imbalanced data.

Moer specifically, to address imbalance in categorical columns, CTGAN introduces a form of conditional generation using a conditioning vector (figure 7(b)).

For example, consider a table with two categorical variables, where first variable has 3 classes and the second one has 2 classes. The condition of selecting first class of second variable is represented as: [0, 0, 0, 1, 0], i.e., all entries are zero except the position corresponding to the selected category and class.

The conditioning mechanism is used during training as follows (figure 7(a)):

• Randomly sample a categorical column
• Sample one of its classes according to its probability mass function (PMF)
• Construct the corresponding condition vector
• Sample a real data point that satisfies this condition
• Feed the condition vector into G to generate a conditional synthetic sample

In addition to standard GAN objective, G is trained with an extra cross-entropy loss between the conditioning vector and the generated categorical output. This ensures that the generated samples respect the specified condition.

4. CTAB-GAN: Effective Table Data Synthesizing

ACML 2021

CTAB-GAN (from our own CTO, Zilong) is another popular work that has two major contributions:

• combining the data encoding strength of CTGAN with the architectural strength of Table-GAN
• extending the encoder to handle mixed-type data and long-tail distributions

Data

CTAB-GAN introduces the concept of mixed variables, which are common in real-world datasets but not properly handled by previous approaches.

A mixed variable can:

• contain both categorical and continuous values, or
• represent a continuous variable with missing values

For example, the “Mortgage” column in Loan Holder dataset can either have no mortgage (0 value) or mortgage (with any positive values).

Mixed variables have a hybrid distribution, an example of which is shown in Figure 8:

• discrete spikes (Dirac delta functions) at specific values
• combined with a continuous multimodal distribution

Figure 8: The distribution of mixed variables introduced in CTAB-GAN.

Encoding Strategy. For the continuous component, CTAB-GAN follows CTGAN, where:

• A VGM is used to estimate the number of modes and the mean and variance of each mode
• Each value is then represented by a normalized scalar, and a mode indicator vector

The key difference is that the discrete components are treated as additional modes. For example, in Figure 8:

• On the left: 2 continuous modes + 2 discrete values → 4 total modes
• One the right: for the specified value: i) the value is normalized based on the parameters of the second continuous mode, and ii) the total mode vector is [0,1,0,0]

For discrete components within mixed variable, the model concatenates the row value with the mode vector. For example, in Figure 8, the second discrete component is encoded as:

Handling long-tail distributions. Another challenge in real-world tabular data is modeling long-tail distributions where some extreme values appear far from bulk of data. CTAB-GAN addresses this by applying a log-transform which:

• compresses the real values, and
• brings the tail closer to the bulk of data

this simple transform makes the distribution easier to model, as confirmed in their experiments.

To handle the long-tail distribution within a column better, CTAB-GAN propose to use a log-transform to compress the distribution and bring the tail of the distribution closer to the bulk of data. This simple transform makes the modeling of the data distribution easier based on the experimental results.

Network Architecture

CTAB-GAN adopts a design similar to Table-GAN, by using CNN layers for G and D, and adding a classifier C.

Here is the architecture:

• G: 4-layer CNN
• D: 2-layer CNN
• C: 7-layer MLP

Recall that adding C helps to enforce semantic consistency across the generated sample.

Learning Objective

Following Table-GAN, CTAB-GAN uses 3 different losses: i) adversarial loss (standard GAN objective), ii) information loss, and iii) classification loss.

Training is performed as follows:

• D → trained using adversarial loss
• C → trained using classification loss
• G → trained using all 3 losses

5. PATE-GAN: Generating Synthetic Data with Differential Privacy Guarantee

ICLR 2019

PATE-GAN is the pioneer work that systematically addresses differential privacy (DP) in GAN-based tabular data generation.

The key idea is: Instead of enforcing differential privacy on the entire GAN, we can enforce it on the discriminator, and the generator will inherit the privacy guarantee.

This insight allows PATE-GAN to leverage the rich literature on differentially private classifiers to train a privacy-preserving GAN.

Background: Differential Privacy

We begin with the notion of neighboring datasets.

Two datasets D and D’ are called neighboring if they differ in only one element:

meaning that D and D’ differ only in one member. Then, a randomized algorithm (neural network) is (epsilon, sigma)-differentially private if:

Intuitively, this means that including or excluding a single data point does not significantly change the output distribution.

PATE Mechanism

Private Aggregation of Teacher Ensembles (PATE) is a well-established framework for building differentially private classifiers.

The idea is to:

• split the dataset D into k disjoint subsets D_1, …, D_k
• train a separate classifier on each subset: T_1, T_2, …, T_k

Given an input x, each teacher produces a prediction, and we count the votes:

The final prediction is obtained via noisy aggregation:

where Y is the random noise drawn from a Laplace distribution.

From PATE to Learnable Models

A key limitation of the PATE aggregation is that it is not differentiable.

To address this an student model is trained as follows:

• A public dataset is selected as data source
• Each sample within this dataset is labeled using the PATE mechanism:

• This forms a noisy labeled dataset:

• A student model S is then trained this noisy labeled dataset

It has been shown that this student model trained on the noisy labeled dataset, is differentially private with respect to the original dataset D.

PATE-GAN: Key Idea

PATE-GAN adapts the idea of training a differential private student model to training discriminator of GAN without requiring a public dataset.

Instead of training a student on public data, it uses generated samples as the input to the PATE mechanism.

Network Architecture

PATE-GAN consists of three main components:

• A set of teacher discriminators
• A student discriminator
• A generator

The training process is as follows:

• The real dataset is split into k disjoint subsets
• A set of teacher discriminators is trained on these subsets using standard GAN loss
• Generated samples are labeled using the PATE mechanism constructed from the teacher discriminators
• A student discriminator is trained on these noisy labels
• The generator is updated using feedback only from the student discriminator

Final Outcome

Since the student discriminator is trained using a differentially private aggregation mechanism, the generator — trained solely through the student — also becomes: differentially private with respect to the original dataset.

Recap

Here is a quick recap that compares these 5 papers in terms of data, network architecture and learning objective with some quick remarks on each work.

Conclusion

GAN-based approaches have played a central role in advancing tabular data generation, each addressing a key challenge — from handling discrete variables (MedGAN), to improving semantic consistency (Table-GAN), to robust encoding and imbalance handling (CTGAN), to modeling complex real-world distributions (CTAB-GAN), and finally to incorporating strong privacy guarantees (PATE-GAN).

Together, these works form the foundation of most modern tabular data generation systems. Understanding their design choices provides a strong intuition for both the strengths and limitations of current approaches.

If you’re interested in synthetic data, privacy-preserving machine learning, and practical generative modeling, follow BetterData’s Medium page for more deep dives like this.