Create Synthetic Data w/Python libraries (SDV, Gretel Synthetics, DataSynthesizer, dbldatagen, DPSDA, and Plaitpyc)

1. Key Libraries and Features

2. Applications for Data Scientists

3. Code sample with output

You're absolutely right! Let’s focus on using the specialized Python libraries for synthetic data generation that align with your interests. Below is the revised list of 10 examples using the libraries mentioned earlier.

---

1. Generate Financial Data for Private Equity (SDV)

Scenario: Simulate financial performance data for portfolio companies.

from sdv.tabular import GaussianCopula
import pandas as pd

# Input: Sample real data
real_data = pd.DataFrame({
    "Revenue ($M)": [120, 200, 150, 250],
    "Expenses ($M)": [100, 180, 140, 210],
    "EBITDA ($M)": [20, 20, 10, 40],
})

# Train SDV model
model = GaussianCopula()
model.fit(real_data)

# Generate synthetic data
synthetic_data = model.sample(5)
print(synthetic_data)

Sample Output:

---

2. Customer Profiles for Startups (Gretel Synthetics)

Scenario: Generate synthetic customer data for a SaaS product.

from gretel_synthetics.generate import generate
import pandas as pd

# Input: Schema definition for customer profiles
schema = {
    "fields": [
        {"name": "Customer ID", "type": "id"},
        {"name": "Age", "type": "integer", "min": 18, "max": 65},
        {"name": "Subscription Plan", "type": "enum", "values": ["Basic", "Pro", "Enterprise"]},
    ]
}

# Generate synthetic data
synthetic_data = generate(schema=schema, num_records=5)
df = pd.DataFrame(synthetic_data)
print(df)

Sample Output:

---

3. Insurance Claims Data (DataSynthesizer)

Scenario: Generate differentially private insurance claims data.

from DataSynthesizer.DataDescriber import DataDescriber

# Input: Original data sample
input_file = "insurance_claims.csv"

# Describe and synthesize data
describer = DataDescriber()
describer.describe_dataset_in_random_mode(input_file)
synthetic_data = describer.generate_synthetic_data()
synthetic_data.to_csv("synthetic_insurance.csv", index=False)

Sample Output: A CSV file with realistic but privacy-preserving claim data.

---

4. E-commerce Transaction Data (dbldatagen)

Scenario: Generate high-volume synthetic transaction data for testing.

from pyspark.sql import SparkSession
from dbldatagen import DataGenerator

spark = SparkSession.builder.appName("SyntheticDataGen").getOrCreate()

data_gen = DataGenerator(spark, rows=1000)\
    .withColumn("Transaction ID", "integer", unique=True)\
    .withColumn("Customer ID", "integer", minValue=1, maxValue=100)\
    .withColumn("Amount", "float", minValue=5, maxValue=1000)\
    .withColumn("Product Category", "string", values=["Electronics", "Fashion", "Books"])

synthetic_df = data_gen.build()
synthetic_df.show(5)

Sample Output:

---

5. Time-Series Data for Climate Tech (SDV)

Scenario: Simulate time-series data for temperature and energy consumption.

from sdv.timeseries import PAR

# Input: Real time-series data
data = {
    "date": ["2024-01-01", "2024-01-02", "2024-01-03"],
    "temperature": [22.5, 23.1, 24.0],
    "energy_usage": [105, 110, 120],
}

# Train model and generate synthetic data
model = PAR()
model.fit(data)
synthetic_data = model.sample(5)
print(synthetic_data)

Sample Output:

---

6. Synthetic Social Network Data (Plaitpy)

Scenario: Generate a social graph with interactions between users.

# Example schema in Plaitpy (YAML)
nodes:
  - type: User
    properties:
      name: random.name
      age: random.age
edges:
  - type: Follows
    source: User
    target: User

Run Plaitpy to generate a graph dataset based on this schema.

Sample Output:

---

7. Synthetic Text Data for NLP (Gretel)

Scenario: Generate synthetic chat data for training chatbots.

from gretel_synthetics.generate import generate_text

# Input: Example sentences
seed_sentences = ["Hello, how can I help you?", "I need assistance with my order."]

# Generate synthetic data
synthetic_text = generate_text(seed_sentences, num_records=5)
print(synthetic_text)

Sample Output:

• "Hi, I have a question about my order."

• "Can you help me with my billing issue?"

---

8. Synthetic Risk Profiles (DPSDA)

Scenario: Generate privacy-preserving customer risk scores.

from DPSDA import generate_synthetic_data

real_data = {"age": [25, 45, 35], "risk_score": [600, 750, 680]}

synthetic_data = generate_synthetic_data(real_data, epsilon=1.0)
print(synthetic_data)

Sample Output:

---

9. Simulated Growth Patterns for Algorithms (SDV)

Scenario: Generate synthetic growth patterns for black-box algorithms.

from sdv.tabular import CopulaGAN

real_data = {"Day": [1, 2, 3], "Users": [100, 200, 350]}

model = CopulaGAN()
model.fit(real_data)
synthetic_data = model.sample(5)
print(synthetic_data)

Sample Output:

---

10. Real Estate Data for PE Funds (SDV)

Scenario: Generate rental data for private equity fund analysis.

real_data = {"Property ID": [1, 2, 3], "Rent": [1200, 1500, 1300]}

model = GaussianCopula()
model.fit(real_data)
synthetic_data = model.sample(5)
print(synthetic_data)

Sample Output:

---

11. TikTok Algorithm Data (SDV)

Scenario: Simulate user engagement patterns (e.g., likes, shares, watch time).

from sdv.tabular import GaussianCopula

real_data = {
    "User ID": [1, 2, 3],
    "Video ID": [101, 102, 103],
    "Watch Time (s)": [120, 150, 90],
    "Likes": [10, 20, 5],
    "Shares": [2, 4, 1],
}

model = GaussianCopula()
model.fit(real_data)

synthetic_data = model.sample(5)
print(synthetic_data)

Sample Output:

---

12. Tinder Algorithm Data (Plaitpy)

Scenario: Generate user match data with preferences and swipes.

# Tinder-like schema in Plaitpy (YAML)
nodes:
  - type: User
    properties:
      gender: random.choice(["Male", "Female", "Other"])
      age: random.age
      interests: random.list(["Music", "Fitness", "Travel", "Books"], 2)
edges:
  - type: Match
    source: User
    target: User
    properties:
      swipe: random.choice(["Like", "Pass"])

Run Plaitpy to generate user-match interactions.

Sample Output:

---

13. LinkedIn Algorithm Data (Gretel Synthetics)

Scenario: Simulate job postings and user interactions for recommendations.

from gretel_synthetics.generate import generate

schema = {
    "fields": [
        {"name": "Job ID", "type": "id"},
        {"name": "User ID", "type": "id"},
        {"name": "Interaction", "type": "enum", "values": ["View", "Apply", "Save"]},
    ]
}

synthetic_data = generate(schema=schema, num_records=5)
print(synthetic_data)

Sample Output:

---

14. Climate Tech Data (SDV)

Scenario: Simulate CO2 emissions and renewable energy usage by region.

real_data = {
    "Region": ["North", "South", "East"],
    "CO2 Emissions (kt)": [200, 300, 150],
    "Renewable Energy (%)": [30, 40, 50],
}

model = GaussianCopula()
model.fit(real_data)

synthetic_data = model.sample(5)
print(synthetic_data)

Sample Output:

---

15. Real Estate Listings for Private Equity (dbldatagen)

Scenario: Generate property data for performance evaluation.

data_gen = DataGenerator(spark, rows=1000)\
    .withColumn("Property ID", "integer", unique=True)\
    .withColumn("Location", "string", values=["Urban", "Suburban", "Rural"])\
    .withColumn("Rent ($)", "float", minValue=500, maxValue=5000)

synthetic_df = data_gen.build()
synthetic_df.show(5)

Sample Output:

---

16. User Behavior Data for Apps (Gretel)

Scenario: Simulate user interactions for app engagement analysis.

schema = {
    "fields": [
        {"name": "User ID", "type": "id"},
        {"name": "Session Length (min)", "type": "float", "min": 1, "max": 60},
        {"name": "Feature Used", "type": "enum", "values": ["Search", "Browse", "Purchase"]},
    ]
}

synthetic_data = generate(schema=schema, num_records=5)
print(synthetic_data)

Sample Output:

---

17. Black Box Algorithm Predictions (SDV)

Scenario: Simulate ad impressions, clicks, and conversions.

real_data = {
    "Ad ID": [1, 2, 3],
    "Impressions": [1000, 2000, 1500],
    "Clicks": [50, 100, 75],
    "Conversions": [5, 10, 7],
}

model = GaussianCopula()
model.fit(real_data)

synthetic_data = model.sample(5)
print(synthetic_data)

Sample Output:

---

18. Healthcare Analytics (DataSynthesizer)

Scenario: Generate synthetic patient records for HIPAA compliance.

from DataSynthesizer.DataDescriber import DataDescriber

input_file = "patient_data.csv"

describer = DataDescriber()
describer.describe_dataset_in_random_mode(input_file)
describer.generate_synthetic_data("synthetic_patient_data.csv")

Sample Output: Privacy-preserving patient data in a CSV file.

---

19. Startup Sales Projections (SDV)

Scenario: Simulate startup sales under different scenarios.

real_data = {
    "Month": ["January", "February", "March"],
    "Sales ($K)": [10, 20, 15],
}

model = GaussianCopula()
model.fit(real_data)

synthetic_data = model.sample(5)
print(synthetic_data)

Sample Output:

---

20. Event Attendance Data (Plaitpy)

Scenario: Generate synthetic data for event analytics.

nodes:
  - type: Event
    properties:
      name: random.event_name
      date: random.date
  - type: Attendee
    properties:
      name: random.name
      ticket_type: random.choice(["VIP", "General", "Student"])
edges:
  - type: Attendance
    source: Attendee
    target: Event

Run Plaitpy to create event-attendance data.

Sample Output:

---