Syntetická data v Pythonu: nástroje a příklady

# Generování syntetických dat v Pythonu: nástroje a praxe pro vývojáře

Syntetická data se stávají klíčovým zdrojem ve vývoji, strojovém učení a testování. Umožňují obejít právní omezení, modelovat vzácné scénáře a zrychlit cykly vývoje bez přístupu k reálným datům. V tomto článku rozebereme klíčové knihovny Pythonu – od Fakeru po GAN – s příklady kódu a doporučeními k výběru přístupu podle úlohy.

Faker: základní nástroj pro věrohodná falešná data

Knihovna Faker generuje vymyšlená, ale vizuálně věrohodná data: jména, adresy, e-maily, čísla karet a mnoho dalšího. Nesnaží se o statistickou přesnost – jejím cílem je imitace struktury a formátu reálných záznamů. To dělá z Fakeru ideální řešení pro naplňování demo prostředí, mockování API a anonymizaci Dev/Test prostředí.

Příklad generování profilu uživatele pro internetový obchod:

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='_')

Tato data jsou vhodná pro testování UI, zátěžové scénáře a demonstrace, ale ne pro trénink ML modelů – kvůli absenci korelací a realistických distribucí.

Scikit-learn: syntetika pro strojové učení

Pro úlohy strojového učení jsou potřebná data s kontrolovanými statistickými vlastnostmi. Scikit-learn poskytuje funkce jako make_classification, make_regression a make_blobs, které generují datasety s daným počtem tříd, šumem, korelacemi a vyvážením.

Příklad vytvoření vyváženého datasetu s vzácnou třídou:

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% — vzácná třída (např. podvod)
    flip_y=0.01,
    random_state=42
)

Tento přístup umožňuje prototypovat modely i při absenci reálných dat o vzácných událostech. Nicméně takové sady jsou lineární nebo slabě nelineární a neodrážejí složitost reálných obchodních procesů.

Pokročilé nástroje: SDV a Gretel Synthetics

Když je potřeba zachovat složité závislosti mezi příznaky (např. věk → příjem → typ nákupů), používají se výkonnější řešení:

• Synthetic Data Vault (SDV) využívá pravděpodobnostní modely (např. Gaussian Copula) k zachycení vícedimenzionálních distribucí a podmíněných závislostí.
• Gretel Synthetics je založen na transformerech a zajišťuje vysokou úroveň soukromí prostřednictvím diferenciálního soukromí.

Oba nástroje vyžadují zdrojový dataset pro trénink generátoru, ale výsledek zachovává statistickou ekvivalenci originálu bez odhalení osobních informací.

Generativní soutěživé sítě (GAN)

Na vrcholu hierarchie stojí GAN. Skládají se ze dvou neuronových sítí: generátoru a diskriminátoru. Generátor vytváří syntetické vzorky, diskriminátor se je snaží odlišit od reálných. Během tréninku se obě sítě zlepšují, dokud syntetika není nerozeznatelná od originálu.

Příklad v PyTorch pro generování tabulkových dat:

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)

GAN poskytují maximální realismus, ale vyžadují značné výpočetní zdroje a expertizu v deep learningu.

Srovnání přístupů a doporučení

Výběr nástroje závisí na cíli:

• Testování UI / demo stánku → Faker (rychle, jednoduše, věrohodně).
• Prototypování ML modelu → Scikit-learn (kontrolovatelné parametry, vestavěné v ekosystému).
• Nahrazení citlivých dat se zachováním statistik → SDV nebo Gretel Synthetics.
• Maximální realismus pro production model → GAN (při dostupnosti dat a zdrojů).

Co je důležité

• Syntetická data nerelevantují reálná, ale výrazně zrychlují vývoj a snižují rizika.
• Faker je vhodný pro strukturální imitaci, ale ne pro ML.
• Pro úlohy strojového učení je klíčové zachování distribucí a korelací – použijte Scikit-learn, SDV nebo GAN.
• Hodnocení kvality syntetiky je povinné: srovnání statistik, vizualizace distribucí, testovací trénink modelu.
• Etické rizika a zděděné zkreslení vyžadují pozornost i při používání „čistých“ syntetických dat.

— Editorial Team