Synthetische Daten in Python: Tools und Beispiele

# Synthetische Daten mit Python generieren: Tools und Best Practices für Entwickler

Synthetische Daten werden zu einer entscheidend wichtigen Ressource in der Entwicklung, im Machine Learning und im Testing. Sie helfen, rechtliche Einschränkungen zu umgehen, seltene Szenarien zu simulieren und Entwicklungszyklen zu beschleunigen, ohne echte Daten zu benötigen. In diesem Artikel tauchen wir in wichtige Python-Bibliotheken ein – von Faker bis GAN – mit Code-Beispielen und Tipps zur Auswahl des passenden Ansatzes für Ihre Aufgabe.

Faker: Das Standard-Tool für realistische Fake-Daten

Die Faker-Bibliothek erzeugt fiktive, aber optisch plausible Daten: Namen, Adressen, E-Mails, Kartennummern und vieles mehr. Sie legt keinen Wert auf statistische Genauigkeit – ihr Ziel ist es, die Struktur und das Format realer Datensätze nachzuahmen. Deshalb eignet sich Faker hervorragend zum Befüllen von Demo-Umgebungen, zum Mocken von APIs und zum Anonymisieren von Dev-/Test-Setups.

Hier ein Beispiel zur Generierung eines Benutzerprofils für einen Onlineshop:

import pandas as pd
from faker import Faker
import json

fake = Faker('ru_RU')

def generate_user_profile():
    profile = {
        "name": fake.name(),
        "email": fake.email(),
        "phone": fake.phone_number(),
        "address": fake.address(),
        "payment_method": fake.credit_card_provider(),
        "order_history": [
            {
                "order_id": fake.uuid4(), 
                "date": fake.date_between(start_date='-1y').strftime('%Y-%m-%d'), 
                "total": fake.random_int(min=1000, max=10000)
            }
            for _ in range(fake.random_int(min=0, max=10))
        ]
    }
    return profile

user_profiles = [generate_user_profile() for _ in range(100)]
df = pd.json_normalize(user_profiles, sep='_')

Diese Daten eignen sich hervorragend für UI-Tests, Lasttests und Demos, aber nicht zum Trainieren von ML-Modellen – wegen fehlender Korrelationen und realistischer Verteilungen.

Scikit-learn: Synthetische Daten für Machine Learning

Für Machine-Learning-Aufgaben benötigen Sie Daten mit kontrollierten statistischen Eigenschaften. Scikit-learn bietet Funktionen wie make_classification, make_regression und make_blobs, um Datensätze mit vorgegebenen Anzahlen von Klassen, Rauschpegeln, Korrelationen und Balance zu erzeugen.

Beispiel für die Erstellung eines ausbalancierten Datensatzes mit einer seltenen Klasse:

from sklearn.datasets import make_classification

X, y = make_classification(
    n_samples=10000,
    n_features=20,
    n_informative=10,
    n_redundant=5,
    n_clusters_per_class=1,
    weights=[0.95, 0.05],  # 5% rare class (e.g., fraud)
    flip_y=0.01,
    random_state=42
)

Dieser Ansatz ermöglicht es, Modelle zu prototypen, selbst ohne echte Daten zu seltenen Ereignissen. Allerdings sind diese Datensätze linear oder nur leicht nichtlinear und erfassen nicht die Komplexität realer Geschäftsprozesse.

Fortgeschrittene Tools: SDV und Gretel Synthetics

Wenn Sie komplexe Abhängigkeiten zwischen Features erhalten müssen (z. B. Alter → Einkommen → Kaufarten), greifen Sie zu leistungsfähigeren Lösungen:

• Synthetic Data Vault (SDV) verwendet probabilistische Modelle (wie Gaussian Copula), um multidimensionale Verteilungen und konditionale Abhängigkeiten zu erfassen.
• Gretel Synthetics basiert auf Transformers und gewährleistet hohen Datenschutz durch differentielle Privatsphäre.

Beide Tools erfordern einen anfänglichen Datensatz zum Trainieren des Generators, aber die Ausgabe behält die statistische Äquivalenz zum Original bei, ohne personenbezogene Informationen preiszugeben.

Generative Adversarial Networks (GANs)

An der Spitze der Hierarchie stehen GANs. Sie bestehen aus zwei neuronalen Netzen: einem Generator und einem Diskriminator. Der Generator erzeugt synthetische Samples, während der Diskriminator versucht, sie von echten zu unterscheiden. Durch das Training verbessern sich beide Netze, bis die Synthetischen von den Originalen nicht mehr zu unterscheiden sind.

Beispiel zur Generierung tabellarischer Daten mit PyTorch:

import torch
import torch.nn as nn

class Generator(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 256),
            nn.ReLU(),
            nn.Linear(256, output_dim),
            nn.Tanh()
        )
    
    def forward(self, x):
        return self.net(x)

class Discriminator(nn.Module):
    def __init__(self, input_dim):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, 256),
            nn.LeakyReLU(0.2),
            nn.Linear(256, 128),
            nn.LeakyReLU(0.2),
            nn.Linear(128, 1),
            nn.Sigmoid()
        )
    
    def forward(self, x):
        return self.net(x)

GANs bieten maximalen Realismus, erfordern aber erhebliche Rechenressourcen und Deep-Learning-Expertise.

Ansätze vergleichen und Empfehlungen

Die Wahl des Tools hängt vom Ziel ab:

• UI-Tests / Demo-Setups → Faker (schnell, einfach, optisch realistisch).
• Prototyping von ML-Modellen → Scikit-learn (kontrollierte Parameter, nahtlos ins Ökosystem integrierbar).
• Ersetzen sensibler Daten bei Erhalt der Statistiken → SDV oder Gretel Synthetics.
• Maximaler Realismus für Produktionsmodelle → GANs (wenn Daten und Ressourcen vorhanden sind).

Wichtige Erkenntnisse

• Synthetische Daten ersetzen keine echten Daten, beschleunigen aber die Entwicklung und reduzieren Risiken.
• Faker eignet sich hervorragend für strukturelle Nachahmung, aber nicht für Machine Learning.
• Für Machine Learning ist die Erhaltung von Verteilungen und Korrelationen entscheidend – nutzen Sie Scikit-learn, SDV oder GANs.
• Bewerten Sie immer die Qualität synthetischer Daten: Vergleichen Sie Statistiken, visualisieren Sie Verteilungen und trainieren Sie Testmodelle.
• Ethische Risiken und übernommene Verzerrungen müssen auch bei „sauberen“ synthetischen Daten beachtet werden.

— Editorial Team