Generate Synthetic Data Using Real Data with TabPFN

ByKürşat Kaya

Given a real table, sample new rows that follow the same statistical patterns. Tabular data is everywhere: spreadsheets, customer records, financial logs, medical registries. Yet getting a usable table for a demo or prototype is often blocked by privacy concerns and regulations. Synthetic data works around that: artificial rows that preserve the statistical patterns of the real table without exposing individual records. Common tools include scikit-learn’s make_* functions, Faker for rule-based generation, and GAN-based methods like CTGAN or TabGAN. These are powerful but often complex to set up. TabPFN is a foundation model specialised for tabular data, and its unsupervised tools let us generate a look-alike table without training a GAN or building a simulation. In this notebook we take an existing dataset (scikit-learn’s Breast Cancer table) as the source, fit TabPFN’s unsupervised model on it, and sample new rows that share its column distributions and correlations. The result is a standalone synthetic table that can stand in for the real one (for a demo, a test fixture, or to extend the training set) which we then compare against the original with a few fidelity plots. You can use this approach to:

Realistic demo data to share with customers or collaborators without exposing real records.
QA and pipeline tests with plausible rows before going live on real data.
Fast prototyping when access to the real dataset is restricted.

Setup

Installing TabPFN, its extensions, and seaborn. The unsupervised synthetic-data helpers live in tabpfn_extensions; seaborn and scikit-learn draw the fidelity plots at the end.

!pip install -U tabpfn tabpfn-client tabpfn_extensions scikit-learn "seaborn>=0.13"

Imports and Data

Loading the Breast Cancer dataset as our safe, realistic table. We use scikit-learn’s Breast Cancer dataset, a classic, non-sensitive table that stands in for whatever proprietary data you would like to synthesise. We keep a train/test split so the synthetic table can later be compared against real data the model never saw.

import pandas as pd
import torch
from google.colab import userdata
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

from tabpfn_extensions import TabPFNClassifier, TabPFNRegressor
from tabpfn_extensions.unsupervised import TabPFNUnsupervisedModel
from tabpfn_extensions.unsupervised.experiments import GenerateSyntheticDataExperiment

data = load_breast_cancer()
X, y = data["data"], data["target"]
feature_names = data["feature_names"]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.33, random_state=42
)

from tabpfn_client import set_access_token
set_access_token(userdata.get('TABPFN_TOKEN'))

Building the Unsupervised Model

Wrapping a classifier and a regressor into TabPFNUnsupervisedModel. The synthetic-data experiment expects a TabPFNUnsupervisedModel, which pairs a TabPFNClassifier (for discrete columns) with a TabPFNRegressor (for continuous columns). Together they let TabPFN model each column conditional on the others and sample new rows from that joint distribution.

model_unsupervised = TabPFNUnsupervisedModel(
    tabpfn_clf=TabPFNClassifier(n_estimators=3),
    tabpfn_reg=TabPFNRegressor(n_estimators=3),
)

Generating the Synthetic Table

Running the experiment to produce look-alike rows. GenerateSyntheticDataExperiment handles the sampling loop. temp controls diversity: higher values give more varied rows, lower values stay closer to the training data. n_samples sets how many rows we want out. Here we ask for twice as many rows as the training split, over all 30 features. Inputs come in as tensors, and the resulting synthetic table is written to synthetic.csv for the evaluation step.

X_tensor = torch.tensor(X_train, dtype=torch.float32)
y_tensor = torch.tensor(y_train)

experiment = GenerateSyntheticDataExperiment(task_type="unsupervised")

experiment.run(
    tabpfn=model_unsupervised,
    X=X_tensor,
    y=y_tensor,
    attribute_names=feature_names,
    temp=1.0,  # temperature controls sample diversity
    n_samples=X_train.shape[0] * 2,  # 2x more rows than the original train split
    indices=list(range(X_tensor.shape[1])),
)

synthetic = experiment.data_synthetic.drop(columns=["real_or_synthetic"], errors="ignore")
synthetic.to_csv("synthetic.csv", index=False)
synthetic.head()

   mean radius  mean texture  mean perimeter   mean area  mean smoothness  \
  10.632204     20.642441       68.753624  345.596558         0.095788
  12.977575     13.645523       83.388222  520.599670         0.085533
  11.024648     17.227816       69.025833  371.066895         0.065314
  12.304674     18.488256       78.757622  463.225281         0.092464
  13.987102     11.330254       89.883186  612.664795         0.086030

   mean compactness  mean concavity  mean concave points  mean symmetry  \
        0.095127        0.056123             0.023276       0.212245
        0.071113        0.025423             0.027756       0.198445
        0.034128        0.009800             0.003196       0.152951
        0.072740        0.029798             0.016508       0.169203
        0.059947        0.031822             0.024980       0.153577

   mean fractal dimension  ...  worst radius  worst texture  worst perimeter  \
              0.068341  ...     11.466408      26.354967        76.923141
              0.058192  ...     14.552796      17.846672        92.874748
              0.060247  ...     12.093940      28.653603        75.486397
              0.061284  ...     13.483095      21.265419        85.378014
              0.058753  ...     17.030933      16.429689       111.156082

   worst area  worst smoothness  worst compactness  worst concavity  \
401.879395          0.123865           0.210385         0.181432
655.466858          0.118219           0.182564         0.109444
449.952606          0.085053           0.093276         0.048481
556.145508          0.128573           0.161194         0.123809
873.714844          0.132982           0.216785         0.206143

   worst concave points  worst symmetry  worst fractal dimension
            0.070481        0.347490                 0.085794
            0.104044        0.306025                 0.076785
            0.017047        0.274371                 0.074096
            0.061574        0.258165                 0.070198
            0.124087        0.342631                 0.088684

[5 rows x 30 columns]

Comparing Real vs. Synthetic

Checking fidelity on three levels. A synthetic table is only useful if it behaves like the real thing. We compare the two side by side on three levels: the distribution of each column, the correlation structure between columns, and the low-dimensional geometry of the rows. The real side is the held-out test split, rows the generator never saw, so a good match is not just memorization. The plots use pandas, seaborn, and scikit-learn only, so nothing extra needs to be installed.

import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# Held-out rows only: the generator was fit on X_train and never saw these.
real = pd.DataFrame(X_test, columns=feature_names)
fake = pd.read_csv("synthetic.csv")[real.columns]

print(f"real rows: {len(real)} | synthetic rows: {len(fake)} | columns: {real.shape[1]}")

real rows: 188 | synthetic rows: 762 | columns: 30

Distributions

Do the synthetic columns look like the real ones? The per-feature density curves show how closely each synthetic column tracks the real distribution. A close overlap means the marginals have been preserved.

fig, axes = plt.subplots(6, 5, figsize=(16, 15))
for ax, column in zip(axes.flat, real.columns):
    sns.kdeplot(real[column], ax=ax, label="real", fill=True, alpha=0.4)
    sns.kdeplot(fake[column], ax=ax, label="synthetic", fill=True, alpha=0.4)
    ax.set_title(column, fontsize=9)
    ax.set_xlabel("")
    ax.set_ylabel("")
axes.flat[0].legend()
fig.tight_layout()
plt.show()

Correlations

Are the relationships between features still there? TabPFN samples each column conditional on the others, so we care about more than just marginals. The correlation-difference heatmap highlights where the synthetic table’s feature-to-feature relationships depart from the real table. Small values mean the joint structure held up.

corr_diff = real.corr() - fake.corr()
limit = corr_diff.abs().to_numpy().max()

fig, ax = plt.subplots(figsize=(11, 9))
sns.heatmap(corr_diff, cmap="coolwarm", center=0, vmin=-limit, vmax=limit, ax=ax)
ax.set_title("Correlation difference (real minus synthetic)")
plt.show()

print(f"mean absolute correlation difference: {corr_diff.abs().to_numpy().mean():.3f}")

mean absolute correlation difference: 0.102

PCA Projection

Do the two tables share the same low-dimensional geometry? We standardize the features and fit a two-component PCA on the real table, then project both tables onto it. Overlapping clouds mean the synthetic rows live in the same subspace as the real ones. A few synthetic rows land far outside the real cloud: the sampler occasionally extrapolates, which is worth checking for before using the table downstream.

scaler = StandardScaler().fit(real)
pca = PCA(n_components=2).fit(scaler.transform(real))
real_2d = pca.transform(scaler.transform(real))
fake_2d = pca.transform(scaler.transform(fake))

fig, ax = plt.subplots(figsize=(7, 6))
# Synthetic first so the smaller real set stays visible on top.
ax.scatter(fake_2d[:, 0], fake_2d[:, 1], s=12, alpha=0.4, color="#F6B99F", label="synthetic")
ax.scatter(real_2d[:, 0], real_2d[:, 1], s=14, alpha=0.8, color="#2A78D6", label="real")
ax.set_xlabel(f"PC1 ({pca.explained_variance_ratio_[0]:.0%} of variance)")
ax.set_ylabel(f"PC2 ({pca.explained_variance_ratio_[1]:.0%} of variance)")
ax.legend()
plt.show()

​Setup

​Imports and Data

​Building the Unsupervised Model

​Generating the Synthetic Table

​Comparing Real vs. Synthetic

​Distributions

​Correlations

​PCA Projection