After understanding the basic structure of tabular data, one of the most straightforward ways to generate a synthetic table is to create the values for each column one by one, without considering the other columns. This method is called Independent Column Value Generation.

The core assumption here is that the value in one column doesn't influence the value in another column within the same row. While this is often not true in real datasets (think how age might relate to income, or city relate to zip code), this simplifying assumption makes the generation process much easier to start with.

How It Works

Imagine your table has several columns, like Age, Department, and Salary. With independent column generation, you would:

Decide how to generate synthetic values for the Age column.
Decide how to generate synthetic values for the Department column.
Decide how to generate synthetic values for the Salary column.
Generate the desired number of rows by applying these rules independently for each column.

The way you generate values for a specific column usually depends on its data type (numerical, categorical, etc.) and often involves mimicking the characteristics observed in the original data, if available.

Generating Numerical Columns Independently

For columns containing numbers (like Age, Height, Price), you can often use statistical distributions, as introduced in the previous chapter.

From Observed Data: If you have a real dataset, you can calculate basic statistics like the minimum, maximum, mean ( $\mu$ $μ$ ), and standard deviation ( $\sigma$ $σ$ ) for a numerical column. You could then generate synthetic values by sampling from a distribution that approximates the original one. For instance:
- If the data looks roughly bell-shaped, sample from a Normal (Gaussian) distribution: $\mathcal{N}(\mu, \sigma^2)$ .
- If the data seems evenly spread within a range $[a, b]$ , sample from a Uniform distribution: $U(a, b)$ .
Without Observed Data: If you don't have real data, you define the desired properties. For example, you might decide that synthetic Age values should be uniformly distributed between 18 and 65.

Let's say we want to generate 100 synthetic Age values based on an observation that the real ages are roughly normally distributed with a mean of 40 and a standard deviation of 12. We could use a function (like numpy.random.normal in Python) to sample 100 points from $\mathcal{N}(40, 12^2)$ .

import numpy as np

# Parameters based on observed data (example)
mean_age = 40
std_dev_age = 12
number_of_rows = 100

# Generate synthetic ages independently
synthetic_ages = np.random.normal(loc=mean_age, scale=std_dev_age, size=number_of_rows)

# Ensure ages are realistic (e.g., non-negative, possibly integer)
synthetic_ages = np.clip(synthetic_ages, 0, None) # Ensure non-negative
synthetic_ages = synthetic_ages.astype(int)       # Convert to integer ages

# print(synthetic_ages[:10]) # Display first 10 generated ages

We can visually compare the distribution of generated ages to the original distribution (if available) using histograms.

Comparison of age distributions between a small sample of real data and synthetically generated data using independent column generation based on statistical properties. The synthetic data aims to mimic the overall shape.

Generating Categorical Columns Independently

For columns containing text or categories (like Department, Product Type, City), a common approach is to replicate the frequency distribution observed in the original data.

Calculate Frequencies: Count how often each category appears in the real data column. Calculate the probability (or proportion) of each category.
Sample Based on Probability: Generate synthetic values by randomly choosing categories according to their calculated probabilities.

For example, if the Department column in the real data has:

Sales: 50%
Engineering: 30%
Marketing: 20%

You would generate synthetic Department values such that roughly 50% are 'Sales', 30% are 'Engineering', and 20% are 'Marketing'.

import numpy as np

# Observed frequencies (example)
departments = ['Sales', 'Engineering', 'Marketing']
probabilities = [0.5, 0.3, 0.2]
number_of_rows = 100

# Generate synthetic departments independently
synthetic_departments = np.random.choice(departments, size=number_of_rows, p=probabilities)

# print(synthetic_departments[:10]) # Display first 10 generated departments

A bar chart can help compare the frequencies.

Comparison of department frequencies between real data proportions and a sample generated independently. The synthetic frequencies approximate the target probabilities.

Advantages of Independent Generation

Simplicity: This is arguably the easiest method to understand and implement. You only need to consider one column at a time.
Speed: Generating columns independently is computationally inexpensive, especially for large datasets.
Privacy Foundation: By generating each column's values without reference to others in the same row, you inherently break any statistical relationships present in the original data. This can be a starting point for anonymization, though it's often insufficient on its own.

Limitations: The Independence Assumption

The major drawback is the independence assumption. Real-world data rarely has completely independent columns.

Age and Salary: Younger employees typically have lower salaries than older, more experienced ones. Independent generation might create records of 20-year-olds with very high salaries or 60-year-olds with entry-level salaries.
City and State/Zip Code: Generating these independently will almost certainly result in combinations that don't exist (e.g., 'Seattle' in 'California').
Medical Data: Symptoms, diagnoses, and treatments are highly correlated. Independent generation would likely produce nonsensical medical records.

Because it ignores these relationships, data generated purely independently often lacks utility for machine learning tasks that rely on interactions between features. A model trained only on such data might fail to learn important patterns present in the real world.

Summary

Independent column value generation is a fundamental technique for creating synthetic tabular data. It involves generating data for each column separately, often by mimicking the marginal distributions (like mean/std dev for numbers, or frequencies for categories) seen in the original data. While simple and fast, its core limitation is the failure to capture relationships between columns, potentially reducing the realism and usefulness of the resulting dataset. This leads us to consider methods that try to preserve some of these inter-column dependencies, which we'll touch upon next.