Fünf effektive Python-Skripte zur Generierung synthetischer Daten

Synthetische Daten sind, wie der Name schon sagt, künstlich erzeugte Daten, die nicht aus realen Quellen stammen. Sie ähneln echten Daten, vermeiden jedoch Probleme mit dem Datenschutz und hohe Kosten für die Datensammlung. Dies ermöglicht es, Software und Modelle einfach zu testen und Experimente durchzuführen, um die Leistung nach der Veröffentlichung zu simulieren.

Obwohl Bibliotheken wie Faker, SDV und SynthCity existieren – und sogar große Sprachmodelle (LLMs) häufig zur Generierung synthetischer Daten verwendet werden – liegt der Fokus dieses Artikels darauf, nicht auf externe Bibliotheken oder KI-Tools angewiesen zu sein. Stattdessen lernen Sie, wie Sie dieselben Ergebnisse durch das Schreiben eigener Python-Skripte erzielen können. Dies bietet ein besseres Verständnis dafür, wie man einen Datensatz gestaltet und wie Vorurteile oder Fehler eingeführt werden. Wir beginnen mit einfachen Spiel-Skripten, um die verfügbaren Optionen zu verstehen. Sobald Sie diese Grundlagen beherrschen, können Sie problemlos zu spezialisierten Bibliotheken übergehen, wie in Effiziente Python-Skripte zur Automatisierung der explorativen Datenanalyse.

1. Generierung einfacher Zufallsdaten

Der einfachste Ausgangspunkt ist eine Tabelle. Wenn Sie beispielsweise einen gefälschten Kundendatensatz für eine interne Demo benötigen, können Sie ein Skript ausführen, um durch Komma getrennte Werte (CSV) zu generieren:

import csv
import random
from datetime import datetime, timedelta
random.seed(42)
countries = ["Kanada", "Vereinigtes Königreich", "VAE", "Deutschland", "USA"]
plans = ["Kostenlos", "Basis", "Pro", "Enterprise"]
def random_signup_date():
 start = datetime(2024, 1, 1)
 end = datetime(2026, 1, 1)
 delta_days = (end - start).days
 return (start + timedelta(days=random.randint(0, delta_days))).date().isoformat()
rows = []
for i in range(1, 1001):
 age = random.randint(18, 70)
 country = random.choice(countries)
 plan = random.choice(plans)
 monthly_spend = round(random.uniform(0, 500), 2)
 rows.append({
 "customer_id": f"CUST{i:05d}",
 "age": age,
 "country": country,
 "plan": plan,
 "monthly_spend": monthly_spend,
 "signup_date": random_signup_date()
 })
with open("customers.csv", "w", newline="", encoding="utf-8") as f:
 writer = csv.DictWriter(f, fieldnames=rows[0].keys())
 writer.writeheader()
 writer.writerows(rows)
print("Saved customers.csv")

Dieses Skript ist unkompliziert: Sie definieren Felder, wählen Bereiche aus und schreiben Zeilen. Das Modul random unterstützt die Generierung von Ganzzahlen, Fließkommazahlen, zufälligen Auswahlen und Stichproben. Das Modul csv ist dafür ausgelegt, zeilenbasierte tabellarische Daten zu lesen und zu schreiben. Diese Art von Datensatz eignet sich für:

• Frontend-Demos
• Dashboard-Tests
• API-Entwicklung
• Erlernen der strukturierten Abfragesprache (SQL)
• Unit-Tests von Eingabepipelines

Ein wesentliches Manko dieses Ansatzes ist jedoch, dass alles völlig zufällig ist. Dies führt oft zu Daten, die flach oder unnatürlich wirken. Unternehmenskunden könnten nur 2 Dollar ausgeben, während „Kostenlos“-Nutzer 400 ausgeben. Ältere Nutzer verhalten sich genau wie jüngere, da es keine zugrunde liegende Struktur gibt.

In realen Szenarien verhält sich Daten selten so. Anstatt Werte unabhängig zu generieren, können wir Beziehungen und Regeln einführen. Dies lässt den Datensatz realistischer erscheinen, während er vollständig synthetisch bleibt. Beispielsweise:

• Unternehmenskunden sollten fast nie null Ausgaben haben
• Ausgabenbereiche sollten vom gewählten Plan abhängen
• Ältere Nutzer könnten im Durchschnitt etwas mehr ausgeben
• Bestimmte Pläne sollten häufiger vorkommen als andere

Fügen wir diese Kontrollen in das Skript ein:

import csv
import random
random.seed(42)
plans = ["Kostenlos", "Basis", "Pro", "Enterprise"]
def choose_plan():
 roll = random.random()
 if roll < 0.45:
 return "Kostenlos"
 if roll < 0.75:
 return "Basis"
 if roll < 0.93:
 return "Pro"
 return "Enterprise"
def generate_spend(age, plan):
 if plan == "Kostenlos":
 base = random.uniform(0, 10)
 elif plan == "Basis":
 base = random.uniform(10, 60)
 elif plan == "Pro":
 base = random.uniform(50, 180)
 else:
 base = random.uniform(150, 500)
 if age >= 40:
 base *= 1.15
 return round(base, 2)
rows = []
for i in range(1, 1001):
 age = random.randint(18, 70)
 plan = choose_plan()
 spend = generate_spend(age, plan)
 rows.append({
 "customer_id": f"CUST{i:05d}",
 "age": age,
 "plan": plan,
 "monthly_spend": spend
 })
with open("controlled_customers.csv", "w", newline="", encoding="utf-8") as f:
 writer = csv.DictWriter(f, fieldnames=rows[0].keys())
 writer.writeheader()
 writer.writerows(rows)
print("Saved controlled_customers.csv")

Jetzt bewahrt der Datensatz sinnvolle Muster. Anstatt zufälligen Lärm zu erzeugen, simulieren Sie Verhaltensweisen. Effektive Kontrollen können Folgendes umfassen:

• Gewichtete Kategoriewahl
• Realistische Mindest- und Höchstwerte
• Bedingte Logik zwischen Spalten
• Absichtlich hinzugefügte seltene Randfälle
• Fehlende Werte, die in niedrigen Raten eingefügt werden
• Korrelation zwischen Merkmalen anstelle von unabhängigen

2. Simulation von Prozessen für synthetische Daten

Die simulationsbasierte Generierung ist eine der besten Methoden zur Erstellung realistischer synthetischer Datensätze. Anstatt direkt Spalten zu füllen, simulieren Sie einen Prozess. Betrachten Sie beispielsweise ein kleines Lagerhaus, in dem Bestellungen eintreffen, der Bestand abnimmt und niedrige Bestände Nachbestellungen auslösen.

import csv
import random
from datetime import datetime, timedelta
random.seed(42)
inventory = {
 "A": 120,
 "B": 80,
 "C": 50
}
rows = []
current_time = datetime(2026, 1, 1)
for day in range(30):
 for product in inventory:
 daily_orders = random.randint(0, 12)
 for _ in range(daily_orders):
 qty = random.randint(1, 5)
 before = inventory[product]
 if inventory[product] >= qty:
 inventory[product] -= qty
 status = "fulfilled"
 else:
 status = "backorder"
 rows.append({
 "time": current_time.isoformat(),
 "product": product,
 "qty": qty,
 "stock_before": before,
 "stock_after": inventory[product],
 "status": status
 })
 if inventory[product] < 20:
 restock = random.randint(30, 80)
 inventory[product] += restock
 rows.append({
 "time": current_time.isoformat(),
 "product": product,
 "qty": restock,
 "stock_before": inventory[product] - restock,
 "stock_after": inventory[product],
 "status": "restock"
 })
 current_time += timedelta(days=1)
with open("warehouse_sim.csv", "w", newline="", encoding="utf-8") as f:
 writer = csv.DictWriter(f, fieldnames=rows[0].keys())
 writer.writeheader()
 writer.writerows(rows)
print("Saved warehouse_sim.csv")

Diese Methode ist hervorragend, da die Daten ein Nebenprodukt des Systemverhaltens sind, was typischerweise realistischere Beziehungen ergibt als die direkte zufällige Zeilenerzeugung. Weitere Simulationsideen sind:

• Callcenter-Warteschlangen
• Fahranfragen und Fahrerzuordnung
• Darlehensanträge und Genehmigungen
• Abonnements und Abwanderung
• Patienten-Terminabläufe
• Website-Traffic und Konversion

3. Generierung synthetischer Zeitreihendaten

Synthetische Daten beschränken sich nicht nur auf statische Tabellen. Viele Systeme erzeugen über die Zeit hinweg Sequenzen, wie App-Traffic, Sensorablesungen, Bestellungen pro Stunde oder Serverantwortzeiten. Hier ist ein einfacher Zeitreihengenerator für stündliche Website-Besuche mit Wochentagsmustern.

import csv
import random
from datetime import datetime, timedelta
random.seed(42)
start = datetime(2026, 1, 1, 0, 0, 0)
hours = 24 * 30
rows = []
for i in range(hours):
 ts = start + timedelta(hours=i)
 weekday = ts.weekday()
 base = 120
 if weekday >= 5:
 base = 80
 hour = ts.hour
 if 8 <= hour <= 11:
 base += 60
 elif 18 <= hour <= 21:
 base += 40
 elif 0 <= hour <= 5:
 base -= 30
 visits = max(0, int(random.gauss(base, 15)))
 rows.append({
 "timestamp": ts.isoformat(),
 "visits": visits
 })
with open("traffic_timeseries.csv", "w", newline="", encoding="utf-8") as f:
 writer = csv.DictWriter(f, fieldnames=["timestamp", "visits"])
 writer.writeheader()
 writer.writerows(rows)
print("Saved traffic_timeseries.csv")

Dieser Ansatz funktioniert gut, da er Trends, Rauschen und zyklisches Verhalten integriert und gleichzeitig leicht zu erklären und zu debuggen ist.

4. Erstellung von Ereignisprotokollen

Ereignisprotokolle sind ein weiterer nützlicher Skripttyp, der sich ideal für Produktanalysen und Workflow-Tests eignet. Anstatt eine Zeile pro Kunde zu erstellen, generieren Sie eine Zeile pro Aktion.

import csv
import random
from datetime import datetime, timedelta
random.seed(42)
events = ["signup", "login", "view_page", "add_to_cart", "purchase", "logout"]
rows = []
start = datetime(2026, 1, 1)
for user_id in range(1, 201):
 event_count = random.randint(5, 30)
 current_time = start + timedelta(days=random.randint(0, 10))
 for _ in range(event_count):
 event = random.choice(events)
 if event == "purchase" and random.random() < 0.6:
 value = round(random.uniform(10, 300), 2)
 else:
 value = 0.0
 rows.append({
 "user_id": f"USER{user_id:04d}",
 "event_time": current_time.isoformat(),
 "event_name": event,
 "event_value": value
 })
 current_time += timedelta(minutes=random.randint(1, 180))
with open("event_log.csv", "w", newline="", encoding="utf-8") as f:
 writer = csv.DictWriter(f, fieldnames=rows[0].keys())
 writer.writeheader()
 writer.writerows(rows)
print("Saved event_log.csv")

Dieses Format ist nützlich für:

• Trendanalyse
• Testen von Analyse-Pipelines
• Business Intelligence (BI) Dashboards
• Sitzungsrekonstruktion
• Experimente zur Anomalieerkennung

Eine nützliche Technik hier ist es, Ereignisse von früheren Aktionen abhängig zu machen. Beispielsweise sollte ein Kauf typischerweise auf ein Login oder eine Seitenansicht folgen, was das synthetische Protokoll glaubwürdiger macht.

5. Generierung synthetischer Textdaten mit Vorlagen

Synthetische Daten sind auch für die Verarbeitung natürlicher Sprache (NLP) wertvoll. Sie benötigen nicht immer ein LLM, um zu beginnen; Sie können effektive Textdatensätze mithilfe von Vorlagen und kontrollierten Variationen erstellen. Zum Beispiel können Sie Trainingsdaten für Support-Tickets erstellen:

import json
import random
random.seed(42)
issues = [
 ("billing", "Ich wurde zweimal für mein Abonnement belastet"),
 ("login", "Ich kann mich nicht in mein Konto einloggen"),
 ("shipping", "Meine Bestellung ist noch nicht angekommen"),
 ("refund", "Ich möchte eine Rückerstattung beantragen"),
]
tones = ["Bitte helfen Sie", "Das ist dringend", "Könnten Sie das überprüfen", "Ich benötige Unterstützung"]
records = []
for _ in range(100):
 label, message = random.choice(issues)
 tone = random.choice(tones)
 text = f"{tone}. {message}."
 records.append({
 "text": text,
 "label": label
 })
with open("support_tickets.jsonl", "w", encoding="utf-8") as f:
 for item in records:
 f.write(json.dumps(item) + "\n")
print("Saved support_tickets.jsonl")

Dieser Ansatz funktioniert gut für:

• Textklassifikations-Demos
• Absichtserkennung
• Chatbot-Tests
• Bewertung von Eingabeaufforderungen

Fazit

Skripte zur Generierung synthetischer Daten sind leistungsstarke Werkzeuge, können jedoch falsch implementiert werden. Achten Sie darauf, diese häufigen Fehler zu vermeiden:

• Alle Werte gleichmäßig zufällig zu machen
• Abhängigkeiten zwischen Feldern zu ignorieren
• Werte zu generieren, die gegen Geschäftslogik verstoßen
• Anzunehmen, dass synthetische Daten per se sicher sind
• Daten zu erstellen, die zu "sauber" sind, um für Tests realer Randfälle nützlich zu sein
• Das gleiche Muster so häufig zu verwenden, dass der Datensatz vorhersehbar und unrealistisch wird

Datenschutz bleibt die wichtigste Überlegung. Während synthetische Daten die Exposition gegenüber echten Datensätzen verringern, sind sie nicht risikofrei. Wenn ein Generator zu eng mit ursprünglichen sensiblen Daten verbunden ist, kann es dennoch zu Lecks kommen. Aus diesem Grund sind datenschutzfreundliche Methoden, wie differential private synthetische Daten, von entscheidender Bedeutung.

Kanwal Mehreen ist Maschinenbauingenieurin und technische Autorin mit einer tiefen Leidenschaft für Datenwissenschaft und der Schnittstelle von KI und Medizin. Sie ist Mitautorin des E-Books "Maximizing Productivity with ChatGPT". Als Google Generation Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie wurde auch als Teradata Diversity in Tech Scholar, Mitacs Globalink Research Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist eine leidenschaftliche Verfechterin des Wandels und hat FEMCodes gegründet, um Frauen in MINT-Berufen zu stärken.

Für Einsteiger in die Datenwissenschaft gibt es hilfreiche Ressourcen, wie Der umfassende Leitfaden für Einsteiger in die Datenwissenschaft 2026: Wichtige Skills und Fallstricke und 5 Powerful Python Decorators for High-Performance Data Pipelines.

```

Bildquelle: ai-generated-gemini

KI Snack