SDV vs Gretel vs YData Synthetic: Self-Hosted Synthetic Data Generation

Generating realistic but fake data for testing, development, and machine learning is a growing challenge. Real production data contains sensitive personal information that cannot be shared with developers, QA teams, or external partners. Manual test data creation is time-consuming and rarely captures the statistical properties of real datasets.

Synthetic data generation solves both problems. By learning the statistical patterns, correlations, and distributions of your real data, synthetic data generators produce realistic-looking datasets that preserve analytical value without exposing any real individual records. This is critical for GDPR compliance, HIPAA requirements, and secure development workflows. For related approaches to test data management, see our test data management guide and data quality tools comparison.

In this guide, we compare three leading open-source synthetic data generation frameworks: SDV (Synthetic Data Vault) for the most comprehensive tabular and sequential data support, Gretel Synthetics for differential privacy guarantees, and YData Synthetic for enterprise-grade data synthesis with multiple generation methods.

Why Use Synthetic Data?

Synthetic data is becoming essential in modern data engineering and machine learning pipelines:

• Privacy compliance: Share realistic data with external teams without violating GDPR, CCPA, or HIPAA.
• Testing and QA: Populate staging and development environments with data that mirrors production statistics.
• Machine learning: Augment training datasets to improve model performance on rare cases or edge conditions.
• Data sharing: Enable collaboration between organizations by replacing sensitive fields with statistically equivalent synthetic values.
• Cost reduction: Generate unlimited test data without provisioning additional production database replicas.

SDV: Synthetic Data Vault

SDV (Synthetic Data Vault) is the most widely used open-source synthetic data generation library. Originally developed by researchers at MIT and the DataCebo team, it supports single-table, multi-table, and sequential data synthesis. With its comprehensive API and active development, SDV is the go-to choice for data scientists and engineers.

Key Features

• Multi-modal support: Handles single tables, multiple related tables (with foreign keys), and sequential/time-series data.
• Multiple synthesizers: Includes GaussianCopula, CTGAN, TVAE, CopulaGAN, and PARSYN models for different data types and fidelity requirements.
• Multi-table synthesis: Preserves relationships between parent and child tables, maintaining referential integrity.
• Sequential data: Generates time-series and sequence data that preserves temporal dependencies.
• Evaluation metrics: Built-in quality, privacy, and utility metrics to compare synthetic vs real data.
• Active development: Regular releases with new synthesizers and improvements.

Installation and Usage

1
2

# Install SDV
pip install sdv

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from sdv.datasets.demo import download_demo
from sdv.multi_table import HMASynthesizer

# Load sample data
data, metadata = download_demo(
    modality='multi_table',
    dataset_name='fake_hotel_guests'
)

# Create and train the synthesizer
synthesizer = HMASynthesizer(metadata)
synthesizer.fit(data)

# Generate synthetic data
synthetic_data = synthesizer.sample(scale=1.0)

print(f"Generated {len(synthetic_data['guests'])} synthetic guest records")

Docker Deployment

SDV can be packaged as a service for team access:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

services:
  sdv-service:
    image: python:3.11-slim
    container_name: sdv-service
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - ./data:/app/data
      - sdv-models:/app/models
      - ./synthetic_service.py:/app/synthetic_service.py
    working_dir: /app
    command: >
      bash -c "
        pip install sdv flask &&
        python synthetic_service.py
      "
    environment:
      - SDV_MODEL_DIR=/app/models

volumes:
  sdv-models:
    driver: local

A Flask-based wrapper service can expose SDV’s synthesizers via REST API, allowing multiple team members to generate synthetic data through HTTP endpoints.

Gretel Synthetics: Differential Privacy for Synthetic Data

Gretel Synthetics is an open-source library from Gretel that focuses on generating synthetic data with optional differential privacy guarantees. It uses deep learning models (differential privacy-enhanced LSTM and Transformer architectures) to learn data distributions while providing mathematical privacy bounds.

Key Features

• Differential privacy: Configurable epsilon and delta parameters provide mathematical guarantees about individual record privacy.
• Deep learning models: Uses LSTM and Transformer architectures for high-fidelity synthesis of complex data patterns.
• Text synthesis: Specialized support for generating realistic text data (emails, addresses, names) while preserving privacy.
• GPU acceleration: Supports GPU-based training for faster model fitting on large datasets.
• Privacy budget tracking: Monitors the cumulative privacy loss across multiple synthesis runs.

Installation and Usage

1
2

# Install Gretel Synthetics
pip install gretel-synthetics

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

from gretel_synthetics.generate import generate_text_lines
from gretel_synthetics.train import train
from gretel_synthetics.config import TensorFlowConfig, LocalConfig
import pandas as pd

# Load training data
df = pd.read_csv('customer_data.csv')

# Configure the synthesizer with differential privacy
config = LocalConfig(
    max_lines=len(df),
    max_line_len=200,
    field_delimiter=',',
    dp=True,           # Enable differential privacy
    dp_noise_multiplier=1.5,
    dp_l2_norm_clip=1.0,
    dp_microbatches=4,
    epochs=30,
    vocab_size=50000,
)

# Train the model
train(config)

# Generate synthetic records
for record in generate_text_lines(config, num_lines=1000):
    print(record)

Docker Deployment

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

services:
  gretel-synthetics:
    image: python:3.11-slim
    container_name: gretel-synthetics
    restart: unless-stopped
    volumes:
      - ./data:/app/data
      - gretel-models:/app/models
    working_dir: /app
    command: >
      bash -c "
        pip install gretel-synthetics pandas &&
        python generate_service.py
      "
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

volumes:
  gretel-models:
    driver: local

YData Synthetic: Enterprise-Grade Data Synthesis

YData Synthetic is an open-source framework from YData that provides multiple synthesis methods for tabular data, time-series, and transactional datasets. It is designed for enterprise use cases with a focus on data quality metrics and model explainability.

Key Features

• Multiple synthesizers: Supports CTGAN, WGAN-GP, TVAE, and CRAMER-GAN for different data fidelity and speed trade-offs.
• Time-series synthesis: Specialized models for sequential and temporal data that preserve trends and seasonality.
• Quality metrics: Built-in evaluation using statistical distance measures (KLD, Jensen-Shannon, Wasserstein).
• Data preprocessing: Automated handling of missing values, categorical encoding, and normalization.
• Report generation: Visual reports comparing real and synthetic data distributions.

Installation and Usage

1
2

# Install YData Synthetic
pip install ydata-synthetic

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

from ydata_synthetic.synthesizers import ModelType, TrainParams
from ydata_synthetic.synthesizers.regular import RegularSynthesizer
import pandas as pd

# Load data
df = pd.read_csv('employee_data.csv')

# Define categorical and numerical columns
cat_cols = ['department', 'role', 'location']
num_cols = ['salary', 'years_experience', 'performance_score']

# Configure and train CTGAN synthesizer
synth = RegularSynthesizer(ModelType.CTGAN)
train_params = TrainParams(
    epochs=300,
    batch_size=500,
    learning_rate=2e-4,
    discriminator_n_layers=4,
    generator_n_layers=4,
)

synth.fit(data=df, train_arguments=train_params, 
          num_cols=num_cols, cat_cols=cat_cols)

# Generate synthetic data
synthetic_df = synth.sample(10000)
print(f"Generated {len(synthetic_df)} synthetic records")

# Evaluate quality
from ydata_synthetic.synthesizers.utils.evaluation import evaluate_quality
quality_report = evaluate_quality(df, synthetic_df, cat_cols, num_cols)
print(quality_report)

Docker Deployment

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

services:
  ydata-synthetic:
    image: python:3.11-slim
    container_name: ydata-synthetic
    restart: unless-stopped
    ports:
      - "8082:8082"
    volumes:
      - ./data:/app/data
      - ydata-models:/app/models
    working_dir: /app
    command: >
      bash -c "
        pip install ydata-synthetic pandas flask &&
        python synthesis_service.py
      "

volumes:
  ydata-models:
    driver: local

Comparison Table

When to Use Each Tool

Choose SDV if:

• You need multi-table synthesis that preserves foreign key relationships and referential integrity.
• You want the most comprehensive library with the widest range of synthesizers.
• Your data includes sequential or time-series patterns that need to be preserved.
• You are working in a research or data science context and value active community development.

Choose Gretel Synthetics if:

• Differential privacy is a hard requirement for your use case (healthcare, finance, government).
• You need to generate realistic text data (emails, addresses, free-form text) while protecting individual privacy.
• You want configurable privacy budgets (epsilon/delta) with mathematical guarantees.
• GPU-accelerated training is important for your dataset size.

Choose YData Synthetic if:

• You need enterprise-grade evaluation with statistical distance metrics and visual reports.
• Your organization requires GAN-based synthesis (CTGAN, WGAN-GP) for high-fidelity tabular data.
• Time-series synthesis is important and you need specialized models for temporal patterns.
• You want automated preprocessing and quality reporting as part of the pipeline.

FAQ

Is synthetic data truly private? Can it leak real records?

Synthetic data is designed to be private, but the level of protection depends on the generation method. Basic statistical synthesizers (like GaussianCopula) may occasionally reproduce exact records from the training data if the dataset is small. Differential privacy-based methods (like Gretel Synthetics) provide mathematical guarantees that no individual record can be identified, at the cost of some data fidelity. Always evaluate synthetic data using privacy metrics before sharing it externally.

How do I measure the quality of synthetic data?

Quality is typically measured along three dimensions: (1) Statistical similarity: Do column distributions match the real data? Use Kullback-Leibler divergence, Jensen-Shannon distance, or Kolmogorov-Smirnov tests. (2) Correlation preservation: Do relationships between columns (e.g., age vs salary) remain intact? Compare correlation matrices. (3) Machine learning utility: Train a model on synthetic data and test it on real data – if performance is comparable, the synthetic data is useful. All three tools in this guide include built-in evaluation functions.

Can synthetic data replace real data for all testing purposes?

Not always. Synthetic data excels at structural testing (schema validation, query correctness, UI rendering) and statistical testing (data pipelines, aggregation queries). However, it cannot replicate real-world edge cases, data entry errors, or unexpected data patterns that only appear in production. The best practice is to use synthetic data for most testing, supplemented with a small, carefully anonymized subset of real production data for edge-case validation.

How long does it take to train a synthetic data model?

Training time depends on dataset size, model complexity, and hardware. For a table with 100,000 rows and 20 columns, CTGAN typically trains in 5-15 minutes on a CPU and 1-3 minutes on a GPU. GaussianCopula-based models are faster (1-2 minutes) but produce lower-fidelity results. Multi-table synthesis with SDV’s HMA model can take 30-60 minutes for complex schemas with many relationships.

Do these tools support generating data for specific distributions?

All three provide REST APIs. SDV and YData Synthetic allow you to constrain generation to specific distributions or value ranges. For example, you can specify that a salary column must follow a log-normal distribution, or that dates must fall within a specific range. Gretel Synthetics focuses more on learning distributions from the data rather than specifying them manually. For integrating synthetic data into larger data pipelines, our data pipeline orchestration guide covers how to automate data generation workflows.

Can I use synthetic data for machine learning model training?

Yes, this is one of the most common use cases. Studies have shown that machine learning models trained on high-quality synthetic data can achieve 85-95% of the performance of models trained on real data. The gap narrows as synthetic data quality improves. SDV and YData Synthetic both include ML utility metrics that predict how well a model trained on synthetic data will perform on real data.

What are the licensing differences between these tools?

SDV uses the permissive BSD-3-Clause license, suitable for both commercial and open-source projects. Gretel Synthetics uses Apache-2.0, also permissive. YData Synthetic uses AGPL-3.0, which requires derivative works to be open-sourced – this may be restrictive for commercial internal use. For enterprise deployments, YData also offers a commercial license.