Generación de Datos de Prueba con IA: Datos Sintéticos para QA

# Enfoque tradicional - datos no realistas
import random
import string

def generar_usuario():
    return {
        "nombre": ''.join(random.choices(string.ascii_letters, k=10)),
        "email" (como se discute en [AI-Assisted Bug Triaging: Intelligent Defect Prioritization at Scale](/blog/ai-bug-triaging)): f"{''.join(random.choices(string.ascii_letters, k=8))}@test.com",
        "edad": random.randint(1, 100),
        "salario": random.randint(10000, 200000)
    }

# Resultado: {"nombre": "xKpQmZvRtY", "email" (como se discute en [AI Code Smell Detection: Finding Problems in Test Automation with ML](/blog/ai-code-smell-detection)): "hBnMqWxZ@test.com", "edad": 3, "salario": 187234}
# Problema: Nombres no realistas, niños de 3 años con salarios, sin correlación

# Generación con IA - realista y contextual
from synthetic_data_ai import GeneradorDatos

generador = GeneradorDatos()
generador.aprender_del_esquema({
    "nombre": {"tipo": "nombre_persona", "locale": "es_ES"},
    "email" (como se discute en [AI Copilot for Test Automation: GitHub Copilot, Amazon CodeWhisperer and the Future of QA](/blog/ai-copilot-testing)): {"tipo": "email", "distribucion_dominio": ["gmail.com", "yahoo.es", "empresa.com"]},
    "edad": {"tipo": "entero", "distribucion": "normal", "media": 35, "desv": 12, "min": 18, "max": 75},
    "salario": {"tipo": "moneda", "correlacion": {"edad": 0.6}, "min": 30000, "max": 200000}
})

usuario = generador.generar_registro()
# Resultado: {"nombre": "María García", "email": "maria.garcia@gmail.com", "edad": 42, "salario": 78500}
# Ventajas: Nombres realistas, edad apropiada para empleo, salario correlaciona con edad

# GAN simplificado para datos tabulares
import tensorflow as tf

class GanDatos:
    def __init__(self, dim_esquema):
        self.generador = self.construir_generador(dim_esquema)
        self.discriminador = self.construir_discriminador(dim_esquema)

    def construir_generador(self, dim_salida):
        modelo = tf.keras.Sequential([
            tf.keras.layers.Dense(128, activation='relu', input_shape=(100,)),
            tf.keras.layers.BatchNormalization(),
            tf.keras.layers.Dense(256, activation='relu'),
            tf.keras.layers.BatchNormalization(),
            tf.keras.layers.Dense(dim_salida, activation='tanh')
        ])
        return modelo

    def construir_discriminador(self, dim_entrada):
        modelo = tf.keras.Sequential([
            tf.keras.layers.Dense(256, activation='relu', input_shape=(dim_entrada,)),
            tf.keras.layers.Dropout(0.3),
            tf.keras.layers.Dense(128, activation='relu'),
            tf.keras.layers.Dropout(0.3),
            tf.keras.layers.Dense(1, activation='sigmoid')
        ])
        return modelo

class AutoencoderVariacional:
    def __init__(self, dim_datos, dim_latente=20):
        self.codificador = self.construir_codificador(dim_datos, dim_latente)
        self.decodificador = self.construir_decodificador(dim_latente, dim_datos)

    def generar_muestras(self, n_muestras):
        # Muestrear del espacio latente aprendido
        muestras_latentes = tf.random.normal([n_muestras, self.dim_latente])
        datos_generados = self.decodificador(muestras_latentes)
        return datos_generados

    def preservar_correlaciones(self, datos_reales):
        # VAEs naturalmente preservan relaciones entre características
        # aprendiéndolas en la representación latente
        codificado = self.codificador(datos_reales)
        decodificado = self.decodificador(codificado)
        return decodificado

from openai import OpenAI

class GeneradorDatosTexto:
    def __init__(self):
        self.client = OpenAI()

    def generar_reseñas_clientes(self, tipo_producto, n_muestras, distribucion_sentimiento):
        prompt = f"""
        Genera {n_muestras} reseñas realistas de clientes para {tipo_producto}.
        Distribución de sentimientos: {distribucion_sentimiento}

        Incluye estilos de escritura variados, errores ortográficos comunes y preocupaciones realistas.
        Devuelve como array JSON con campos: texto, calificacion, fecha, compra_verificada
        """

        respuesta = self.client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.9  # Mayor temperatura para más variedad
        )

        return respuesta.choices[0].message.content

# Ejemplo API Gretel.ai
from gretel_client import Gretel

gretel = Gretel(api_key="tu_api_key")

# Entrenar modelo con tus datos
modelo = gretel.models.create_train(
    data_source="usuarios.csv",
    model_type="synthetics",
    config={
        "privacy_level": "high",
        "preserve_relationships": ["user_id", "order_id"]
    }
)

# Generar datos sintéticos
datos_sinteticos = modelo.generate(num_records=100000)
datos_sinteticos.to_csv("usuarios_sinteticos.csv")

from sdv.tabular import GaussianCopula
from sdv.relational import HMA1

# Generación de tabla única
modelo = GaussianCopula()
modelo.fit(datos_reales)
datos_sinteticos = modelo.sample(num_rows=10000)

# Multi-tabla con relaciones
metadata = {
    'tables': {
        'usuarios': {
            'primary_key': 'user_id',
            'fields': {...}
        },
        'pedidos': {
            'primary_key': 'order_id',
            'fields': {...}
        }
    },
    'relationships': [
        {
            'parent': 'usuarios',
            'child': 'pedidos',
            'foreign_key': 'user_id'
        }
    ]
}

modelo = HMA1(metadata)
modelo.fit(tables={'usuarios': df_usuarios, 'pedidos': df_pedidos})
tablas_sinteticas = modelo.sample()

from ctgan import CTGAN

# Manejar tipos de datos mixtos (categóricos + continuos)
ctgan = CTGAN(epochs=300)
ctgan.fit(datos_entrenamiento, discrete_columns=['pais', 'tipo_suscripcion'])

# Generar con condiciones específicas
muestras = ctgan.sample(
    n=5000,
    condition_column='pais',
    condition_value='España'
)

from faker import Faker
import pandas as pd
import numpy as np

fake = Faker('es_ES')

def generar_usuarios_realistas(n):
    usuarios = []
    for _ in range(n):
        edad = int(np.random.normal(35, 12))
        edad = max(18, min(75, edad))  # Limitar a rango realista

        # Salario correlaciona con edad
        salario_base = 30000 + (edad - 18) * 2000
        salario = int(np.random.normal(salario_base, 15000))

        # Email probablemente coincide con nombre
        nombre = fake.name()
        nombre_email = nombre.lower().replace(' ', '.')
        dominio = np.random.choice(['gmail.com', 'yahoo.es', 'empresa.com'], p=[0.4, 0.3, 0.3])

        usuarios.append({
            'nombre': nombre,
            'email': f"{nombre_email}@{dominio}",
            'edad': edad,
            'salario': salario,
            'fecha_registro': fake.date_between(start_date='-5y', end_date='today'),
            'pais': 'España'
        })

    return pd.DataFrame(usuarios)

usuarios_sinteticos = generar_usuarios_realistas(10000)

class GeneradorDatosLimite:
    def __init__(self, esquema_campo):
        self.esquema = esquema_campo

    def generar_casos_limite(self, nombre_campo):
        campo = self.esquema[nombre_campo]
        casos = []

        if campo['tipo'] == 'entero':
            casos.extend([
                campo.get('min', 0) - 1,  # Por debajo del mínimo
                campo.get('min', 0),      # Mínimo
                campo.get('min', 0) + 1,  # Justo encima del mínimo
                campo.get('max', 100) - 1, # Justo debajo del máximo
                campo.get('max', 100),     # Máximo
                campo.get('max', 100) + 1, # Por encima del máximo
                0,                         # Cero
                -1,                        # Negativo
            ])

        elif campo['tipo'] == 'cadena':
            long_max = campo.get('longitud_max', 255)
            casos.extend([
                '',                              # Cadena vacía
                'a' * (long_max - 1),           # Justo debajo del max
                'a' * long_max,                 # En el max
                'a' * (long_max + 1),           # Excede max
                'ñáéíóú',                       # Caracteres especiales
                '<script>alert("xss")</script>', # Prueba de seguridad
            ])

        return casos

from itertools import product

class GeneradorCombinatorio:
    def __init__(self):
        self.valores_extremos = {}

    def definir_valores_extremos(self, campo, valores):
        self.valores_extremos[campo] = valores

    def generar_combinaciones(self, campos):
        # Generar todas las combinaciones de casos extremos
        valores_campos = [self.valores_extremos[f] for f in campos]
        combinaciones = product(*valores_campos)

        return [dict(zip(campos, combo)) for combo in combinaciones]

# Ejemplo: Probar todas las combinaciones de estados de usuario
generador = GeneradorCombinatorio()
generador.definir_valores_extremos('estado_cuenta', ['activa', 'suspendida', 'eliminada'])
generador.definir_valores_extremos('suscripcion', ['gratuita', 'premium', 'empresarial'])
generador.definir_valores_extremos('email_verificado', [True, False])

casos_prueba = generador.generar_combinaciones(['estado_cuenta', 'suscripcion', 'email_verificado'])
# Genera 3 × 3 × 2 = 18 combinaciones de casos de prueba

from sklearn.ensemble import IsolationForest

class GeneradorDatosAnomalia:
    def __init__(self, datos_normales):
        self.datos_normales = datos_normales
        self.modelo = IsolationForest(contamination=0.1)
        self.modelo.fit(datos_normales)

    def generar_anomalias(self, n_muestras):
        """Generar puntos de datos estadísticamente inusuales"""
        anomalias = []

        while len(anomalias) < n_muestras:
            # Generar candidatos con mayor varianza
            candidato = self.datos_normales.sample(1).copy()

            for col in candidato.columns:
                if candidato[col].dtype in ['int64', 'float64']:
                    media = self.datos_normales[col].mean()
                    desv = self.datos_normales[col].std()
                    # Inyectar valores 3+ desviaciones estándar de la media
                    candidato[col] = media + np.random.choice([-1, 1]) * np.random.uniform(3, 5) * desv

            # Verificar que realmente es anómalo
            if self.modelo.predict(candidato)[0] == -1:
                anomalias.append(candidato)

        return pd.concat(anomalias)

class GeneradorPrivadoDiferencial:
    def __init__(self, epsilon=1.0):
        self.epsilon = epsilon  # Presupuesto de privacidad (menor = más privado)

    def agregar_ruido_laplace(self, valor_real, sensibilidad):
        """Agregar ruido proporcional al presupuesto de privacidad"""
        escala = sensibilidad / self.epsilon
        ruido = np.random.laplace(0, escala)
        return valor_real + ruido

    def generar_distribucion_edad(self, edades_reales):
        # Calcular distribución verdadera
        conteos_edad = pd.Series(edades_reales).value_counts()

        # Agregar ruido a cada conteo
        conteos_privados = {}
        for edad, conteo in conteos_edad.items():
            conteo_ruidoso = max(0, self.agregar_ruido_laplace(conteo, sensibilidad=1))
            conteos_privados[edad] = int(conteo_ruidoso)

        # Generar datos sintéticos de distribución ruidosa
        edades = []
        for edad, conteo in conteos_privados.items():
            edades.extend([edad] * conteo)

        return edades

def validar_k_anonimato(datos, cuasi_identificadores, k=5):
    """
    Verificar que cada combinación de cuasi-identificadores aparezca al menos k veces
    """
    agrupado = datos.groupby(cuasi_identificadores).size()
    violaciones = agrupado[agrupado < k]

    if len(violaciones) > 0:
        raise ValueError(f"Violación de k-anonimato: {len(violaciones)} grupos con <{k} miembros")

    return True

# Ejemplo
cuasi_identificadores = ['edad', 'codigo_postal', 'genero']
validar_k_anonimato(datos_sinteticos, cuasi_identificadores, k=5)

class GeneradorDatosEscalable:
    def __init__(self, plantilla):
        self.plantilla = plantilla

    def generar_streaming(self, n_registros, tamano_lote=10000):
        """Generar datos en lotes para evitar problemas de memoria"""
        for i in range(0, n_registros, tamano_lote):
            lote = []
            for _ in range(min(tamano_lote, n_registros - i)):
                registro = self.generar_registro()
                lote.append(registro)

            yield pd.DataFrame(lote)

    def generar_a_base_datos(self, n_registros, conexion_bd):
        """Escribir directamente a base de datos sin cargar en memoria"""
        for lote_df in self.generar_streaming(n_registros):
            lote_df.to_sql('usuarios', conexion_bd, if_exists='append', index=False)

# Generar 100 millones de registros sin desbordamiento de memoria
generador = GeneradorDatosEscalable(plantilla_usuario)
generador.generar_a_base_datos(100_000_000, conn_bd)

from scipy.stats import ks_2samp

def validar_distribucion(datos_reales, datos_sinteticos, umbral=0.05):
    """Test Kolmogorov-Smirnov para similitud de distribución"""
    resultados = {}

    for columna in datos_reales.columns:
        if datos_reales[columna].dtype in ['int64', 'float64']:
            estadistica, p_valor = ks_2samp(datos_reales[columna], datos_sinteticos[columna])
            resultados[columna] = {
                'estadistica': estadistica,
                'p_valor': p_valor,
                'similar': p_valor > umbral
            }

    return resultados

validacion = validar_distribucion(usuarios_reales, usuarios_sinteticos)
for col, resultado in validacion.items():
    if not resultado['similar']:
        print(f"Advertencia: distribución de {col} difiere significativamente")

class ControlVersionDataset:
    def __init__(self, ruta_almacenamiento):
        self.ruta_almacenamiento = ruta_almacenamiento

    def guardar_dataset(self, datos, version, metadata):
        """Guardar con metadata completa"""
        ruta_version = f"{self.ruta_almacenamiento}/v{version}"
        os.makedirs(ruta_version, exist_ok=True)

        # Guardar datos
        datos.to_parquet(f"{ruta_version}/datos.parquet")

        # Guardar metadata
        metadata_completa = {
            'version': version,
            'creado_en': datetime.now().isoformat(),
            'n_registros': len(datos),
            'columnas': list(datos.columns),
            'config_generacion': metadata.get('config', {}),
            'garantias_privacidad': metadata.get('privacidad', {}),
            'pruebas_estadisticas': metadata.get('validacion', {})
        }

        with open(f"{ruta_version}/metadata.json", 'w') as f:
            json.dump(metadata_completa, f, indent=2)

# API hipotética futura
from universal_data import GeneradorUniversal

generador = GeneradorUniversal(foundation_model="data-gpt-v4")

# Generación de datos en lenguaje natural
datos_sinteticos = generador.generate(
    prompt="""
    Crear 10,000 registros de clientes SaaS realistas con:
    - Probabilidad de churn correlacionada con uso de características
    - Patrones estacionales de suscripción
    - Jerarquías de empresas B2B (cuentas padre/hijo)
    - Clustering geográfico por industria
    """,
    validate_against_schema="clientes.sql"
)

class GeneradorAdaptativo:
    def __init__(self):
        self.patrones_fallo = []

    def aprender_de_fallo_test(self, caso_prueba, razon_fallo):
        self.patrones_fallo.append({
            'datos': caso_prueba,
            'fallo': razon_fallo
        })

        # Reentrenar para generar más casos como este
        self.modelo.fine_tune(self.patrones_fallo)

    def generar_siguiente_lote(self):
        # Énfasis en generar datos similares a fallos recientes
        return self.modelo.sample(emphasis='patrones_fallo')

# Generar texto, imágenes y datos estructurados juntos
generador.generar_catalogo_productos(
    n_productos=10000,
    incluir=['descripcion', 'imagen', 'especificaciones', 'reseñas']
)
# Resultado: Imágenes de productos realistas con descripciones y specs coincidentes