Datos Sintéticos en Python: Herramientas y Ejemplos

# Generación de datos sintéticos con Python: Herramientas y prácticas para desarrolladores

Los datos sintéticos se están convirtiendo en un recurso crítico en el desarrollo, el aprendizaje automático y las pruebas. Ayudan a sortear restricciones legales, simular escenarios raros y acelerar los ciclos de desarrollo sin necesidad de datos reales. En este artículo, profundizamos en las bibliotecas clave de Python —desde Faker hasta GAN— con ejemplos de código y consejos para elegir el enfoque adecuado para tu tarea.

Faker: La herramienta principal para datos falsos realistas

La biblioteca Faker genera datos ficticios pero visualmente plausibles: nombres, direcciones, correos electrónicos, números de tarjetas y mucho más. No prioriza la precisión estadística —su objetivo es imitar la estructura y formato de los registros reales. Esto hace que Faker sea perfecto para poblar entornos de demostración, simular APIs y anonimizar configuraciones de Dev/Test.

Aquí un ejemplo generando un perfil de usuario para una tienda en línea:

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

Estos datos funcionan genial para pruebas de UI, pruebas de carga y demostraciones, pero no para entrenar modelos de ML —debido a la falta de correlaciones y distribuciones realistas.

Scikit-learn: Datos sintéticos para aprendizaje automático

Para tareas de aprendizaje automático, necesitas datos con propiedades estadísticas controladas. Scikit-learn ofrece funciones como make_classification, make_regression y make_blobs para generar conjuntos de datos con números especificados de clases, niveles de ruido, correlaciones y balance.

Ejemplo creando un conjunto de datos balanceado con una clase rara:

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
)

Este enfoque te permite prototipar modelos incluso sin datos reales de eventos raros. Sin embargo, estos conjuntos de datos son lineales o solo levemente no lineales y no capturan la complejidad de los procesos de negocio reales.

Herramientas avanzadas: SDV y Gretel Synthetics

Cuando necesitas preservar dependencias complejas entre características (p. ej., edad → ingresos → tipos de compra), recurre a soluciones más potentes:

• Synthetic Data Vault (SDV) utiliza modelos probabilísticos (como Gaussian Copula) para capturar distribuciones multidimensionales y dependencias condicionales.
• Gretel Synthetics está construido sobre transformers y ofrece alta privacidad mediante differential privacy.

Ambas herramientas requieren un conjunto de datos inicial para entrenar el generador, pero la salida mantiene equivalencia estadística con el original sin filtrar información personal.

Redes Generativas Antagónicas (GANs)

En la cima de la jerarquía están las GANs. Consisten en dos redes neuronales: un generador y un discriminador. El generador crea muestras sintéticas, mientras que el discriminador intenta distinguirlas de las reales. A través del entrenamiento, ambas redes mejoran hasta que los sintéticos son indistinguibles de los originales.

Ejemplo usando PyTorch para generación de datos tabulares:

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)

Las GANs ofrecen el máximo realismo pero demandan recursos computacionales significativos y experiencia en aprendizaje profundo.

Comparación de enfoques y recomendaciones

Tu elección de herramienta depende del objetivo:

• Pruebas de UI / entornos de demo → Faker (rápido, simple, de aspecto realista).
• Prototipado de modelos de ML → Scikit-learn (parámetros controlados, se integra perfectamente en el ecosistema).
• Reemplazo de datos sensibles preservando estadísticas → SDV o Gretel Synthetics.
• Máximo realismo para modelos de producción → GANs (si tienes datos y recursos).

Lecciones clave

• Los datos sintéticos no reemplazan a los datos reales pero aceleran el desarrollo y reducen riesgos.
• Faker es genial para imitación estructural pero no para ML.
• Para aprendizaje automático, preservar distribuciones y correlaciones es crucial —usa Scikit-learn, SDV o GANs.
• Siempre evalúa la calidad de los datos sintéticos: compara estadísticas, visualiza distribuciones y entrena modelos de prueba.
• Los riesgos éticos y sesgos heredados necesitan atención incluso con datos sintéticos «limpios».

— Editorial Team