Dane syntetyczne w Pythonie: narzędzia i przykłady

Generowanie syntetycznych danych w Pythonie: narzędzia i praktyka dla programistów

Dane syntetyczne stają się krytycznie ważnym zasobem w developmentcie, uczeniu maszynowym i testowaniu. Pozwalają obejść ograniczenia prawne, zasymulować rzadkie scenariusze i przyspieszyć cykle deweloperskie bez dostępu do rzeczywistych danych. W tym artykule omawiamy kluczowe biblioteki Pythona — od Faker do GAN — z przykładami kodu i rekomendacjami wyboru podejścia w zależności od zadania.

Faker: podstawowe narzędzie do generowania wiarygodnych fikcyjnych danych

Biblioteka Faker generuje wymyślone, ale wizualnie przekonujące dane: imiona, adresy, e-maile, numery kart i wiele więcej. Nie dąży do statystycznej precyzji — jej celem jest imitacja struktury i formatu rzeczywistych wpisów. To czyni Fakers idealnym rozwiązaniem do uzupełniania środowisk demo, mockowania API i anonimizacji środowisk Dev/Test.

Przykład generowania profilu użytkownika dla sklepu internetowego:

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

Takie dane nadają się do testów UI, scenariuszy obciążeniowych i demonstracji, ale nie do trenowania modeli ML — z powodu braku korelacji i realistycznych rozkładów.

Scikit-learn: syntetyka dla uczenia maszynowego

Do zadań uczenia maszynowego potrzebne są dane o kontrolowanych właściwościach statystycznych. Scikit-learn udostępnia funkcje takie jak make_classification, make_regression i make_blobs, które generują zbiory danych z zadaną liczbą klas, szumem, korelacjami i balansem.

Przykład tworzenia zrównoważonego zbioru danych z rzadką klasą:

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% — redkiy klass (for example, moshennichestvo)
    flip_y=0.01,
    random_state=42
)

To podejście pozwala prototypować modele nawet bez rzeczywistych danych o rzadkich zdarzeniach. Jednak takie zbiory są liniowe lub słabo nieliniowe i nie odzwierciedlają złożoności rzeczywistych procesów biznesowych.

Zaawansowane narzędzia: SDV i Gretel Synthetics

Gdy trzeba zachować złożone zależności między cechami (np. wiek → dochód → typ zakupów), stosuje się potężniejsze rozwiązania:

• Synthetic Data Vault (SDV) wykorzystuje modele probabilistyczne (np. Gaussian Copula) do przechwytywania wielowymiarowych rozkładów i warunkowych zależności.
• Gretel Synthetics oparty jest na transformerach i zapewnia wysoki poziom prywatności dzięki różnicowej prywatności.

Oba narzędzia wymagają początkowego zbioru danych do treningu generatora, ale rezultat zachowuje statystyczną równoważność oryginału bez ujawniania informacji osobowych.

Generatywne sieci antagonistyczne (GAN)

Na szczycie hierarchii stoją GAN. Składają się z dwóch sieci neuronowych: generatora i dyskryminatora. Generator tworzy syntetyczne próbki, dyskryminator próbuje je odróżnić od rzeczywistych. W procesie uczenia obie sieci doskonalą się, aż syntetyka staje się nieodróżnialna od oryginału.

Przykład w PyTorch do generowania danych tabelarycznych:

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 zapewniają maksymalny realizm, ale wymagają znacznych zasobów obliczeniowych i wiedzy z zakresu deep learningu.

Porównanie podejść i rekomendacje

Wybór narzędzia zależy od celu:

• Testy UI / demo → Faker (szybko, prosto, wiarygodnie).
• Prototypowanie modelu ML → Scikit-learn (kontrolowane parametry, zintegrowane z ekosystemem).
• Zastąpienie wrażliwych danych z zachowaniem statystyki → SDV lub Gretel Synthetics.
• Maksymalny realizm dla modelu produkcyjnego → GAN (przy nalichii danych i zasobów).

Co ważne

• Dane syntetyczne nie zastępują rzeczywistych, ale znacznie przyspieszają rozwój i zmniejszają ryzyka.
• Faker nadaje się do imitacji struktury, ale nie do ML.
• W zadaniach uczenia maszynowego kluczowe jest zachowanie rozkładów i korelacji — używaj Scikit-learn, SDV lub GAN.
• Ocena jakości syntetyki jest obowiązkowa: porównanie statystyk, wizualizacja rozkładów, testowe uczenie modelu.
• Ryzyka etyczne i dziedziczone stronniczości wymagają uwagi nawet przy „czystych” danych syntetycznych.

— Editorial Team