ИИ Генерация Тестовых Данных: Синтетические Данные для QA

# Традиционный подход - нереалистичные данные
import random
import string

def сгенерировать_пользователя():
    return {
        "имя": ''.join(random.choices(string.ascii_letters, k=10)),
        "email" (как обсуждается в [AI-Assisted Bug Triaging: Intelligent Defect Prioritization at Scale](/blog/ai-bug-triaging)): f"{''.join(random.choices(string.ascii_letters, k=8))}@test.com",
        "возраст": random.randint(1, 100),
        "зарплата": random.randint(10000, 200000)
    }

# Результат: {"имя": "xKpQmZvRtY", "email" (как обсуждается в [AI Code Smell Detection: Finding Problems in Test Automation with ML](/blog/ai-code-smell-detection)): "hBnMqWxZ@test.com", "возраст": 3, "зарплата": 187234}
# Проблема: Нереалистичные имена, 3-летние с зарплатой, нет корреляции

# ИИ-генерация - реалистичная и контекстная
from synthetic_data_ai import ГенераторДанных

генератор = ГенераторДанных()
генератор.обучиться_на_схеме({
    "имя": {"тип": "имя_человека", "locale": "ru_RU"},
    "email" (как обсуждается в [AI Copilot for Test Automation: GitHub Copilot, Amazon CodeWhisperer and the Future of QA](/blog/ai-copilot-testing)): {"тип": "email", "распределение_домена": ["gmail.com", "yandex.ru", "company.ru"]},
    "возраст": {"тип": "целое", "распределение": "normal", "среднее": 35, "откл": 12, "мин": 18, "макс": 75},
    "зарплата": {"тип": "валюта", "корреляция": {"возраст": 0.6}, "мин": 30000, "макс": 200000}
})

пользователь = генератор.сгенерировать_запись()
# Результат: {"имя": "Мария Петрова", "email": "maria.petrova@gmail.com", "возраст": 42, "зарплата": 78500}
# Преимущества: Реалистичные имена, возраст подходит для трудоустройства, зарплата коррелирует с возрастом

# Упрощенный GAN для табличных данных
import tensorflow as tf

class GanДанных:
    def __init__(self, размерность_схемы):
        self.генератор = self.построить_генератор(размерность_схемы)
        self.дискриминатор = self.построить_дискриминатор(размерность_схемы)

    def построить_генератор(self, размерность_выхода):
        модель = 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(размерность_выхода, activation='tanh')
        ])
        return модель

    def построить_дискриминатор(self, размерность_входа):
        модель = tf.keras.Sequential([
            tf.keras.layers.Dense(256, activation='relu', input_shape=(размерность_входа,)),
            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 модель

class ВариационныйАвтоэнкодер:
    def __init__(self, размерность_данных, размерность_латентная=20):
        self.кодировщик = self.построить_кодировщик(размерность_данных, размерность_латентная)
        self.декодировщик = self.построить_декодировщик(размерность_латентная, размерность_данных)

    def сгенерировать_образцы(self, n_образцов):
        # Выборка из изученного латентного пространства
        латентные_образцы = tf.random.normal([n_образцов, self.размерность_латентная])
        сгенерированные_данные = self.декодировщик(латентные_образцы)
        return сгенерированные_данные

    def сохранить_корреляции(self, реальные_данные):
        # VAE естественно сохраняют связи между признаками
        # изучая их в латентном представлении
        закодировано = self.кодировщик(реальные_данные)
        декодировано = self.декодировщик(закодировано)
        return декодировано

from openai import OpenAI

class ГенераторТекстовыхДанных:
    def __init__(self):
        self.client = OpenAI()

    def сгенерировать_отзывы_клиентов(self, тип_продукта, n_образцов, распределение_сентимента):
        промпт = f"""
        Сгенерируй {n_образцов} реалистичных отзывов клиентов для {тип_продукта}.
        Распределение сентимента: {распределение_сентимента}

        Включи разнообразные стили письма, типичные опечатки и реалистичные беспокойства.
        Верни как JSON массив с полями: текст, оценка, дата, проверенная_покупка
        """

        ответ = self.client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": промпт}],
            temperature=0.9  # Более высокая температура для большего разнообразия
        )

        return ответ.choices[0].message.content

# Пример Gretel.ai API
from gretel_client import Gretel

gretel = Gretel(api_key="ваш_api_key")

# Обучить модель на ваших данных
модель = gretel.models.create_train(
    data_source="пользователи.csv",
    model_type="synthetics",
    config={
        "privacy_level": "high",
        "preserve_relationships": ["user_id", "order_id"]
    }
)

# Сгенерировать синтетические данные
синтетические_данные = модель.generate(num_records=100000)
синтетические_данные.to_csv("синтетические_пользователи.csv")

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

# Генерация одной таблицы
модель = GaussianCopula()
модель.fit(реальные_данные)
синтетические_данные = модель.sample(num_rows=10000)

# Мульти-таблица со связями
metadata = {
    'tables': {
        'пользователи': {
            'primary_key': 'user_id',
            'fields': {...}
        },
        'заказы': {
            'primary_key': 'order_id',
            'fields': {...}
        }
    },
    'relationships': [
        {
            'parent': 'пользователи',
            'child': 'заказы',
            'foreign_key': 'user_id'
        }
    ]
}

модель = HMA1(metadata)
модель.fit(tables={'пользователи': df_пользователи, 'заказы': df_заказы})
синтетические_таблицы = модель.sample()

from ctgan import CTGAN

# Обработка смешанных типов данных (категориальные + непрерывные)
ctgan = CTGAN(epochs=300)
ctgan.fit(данные_обучения, discrete_columns=['страна', 'тип_подписки'])

# Генерация с конкретными условиями
образцы = ctgan.sample(
    n=5000,
    condition_column='страна',
    condition_value='Россия'
)

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

fake = Faker('ru_RU')

def сгенерировать_реалистичных_пользователей(n):
    пользователи = []
    for _ in range(n):
        возраст = int(np.random.normal(35, 12))
        возраст = max(18, min(75, возраст))  # Ограничить реалистичным диапазоном

        # Зарплата коррелирует с возрастом
        базовая_зарплата = 30000 + (возраст - 18) * 2000
        зарплата = int(np.random.normal(базовая_зарплата, 15000))

        # Email вероятно совпадает с именем
        имя = fake.name()
        имя_email = имя.lower().replace(' ', '.')
        домен = np.random.choice(['gmail.com', 'yandex.ru', 'company.ru'], p=[0.4, 0.3, 0.3])

        пользователи.append({
            'имя': имя,
            'email': f"{имя_email}@{домен}",
            'возраст': возраст,
            'зарплата': зарплата,
            'дата_регистрации': fake.date_between(start_date='-5y', end_date='today'),
            'страна': 'Россия'
        })

    return pd.DataFrame(пользователи)

синтетические_пользователи = сгенерировать_реалистичных_пользователей(10000)

class ГенераторГраничныхДанных:
    def __init__(self, схема_поля):
        self.схема = схема_поля

    def сгенерировать_граничные_случаи(self, имя_поля):
        поле = self.схема[имя_поля]
        случаи = []

        if поле['тип'] == 'целое':
            случаи.extend([
                поле.get('мин', 0) - 1,  # Ниже минимума
                поле.get('мин', 0),      # Минимум
                поле.get('мин', 0) + 1,  # Чуть выше минимума
                поле.get('макс', 100) - 1, # Чуть ниже максимума
                поле.get('макс', 100),     # Максимум
                поле.get('макс', 100) + 1, # Выше максимума
                0,                         # Ноль
                -1,                        # Отрицательный
            ])

        elif поле['тип'] == 'строка':
            макс_длина = поле.get('макс_длина', 255)
            случаи.extend([
                '',                              # Пустая строка
                'а' * (макс_длина - 1),          # Чуть ниже макс
                'а' * макс_длина,                # На макс
                'а' * (макс_длина + 1),          # Превышает макс
                'йцукенгшщз',                    # Специальные символы
                '<script>alert("xss")</script>', # Тест безопасности
            ])

        return случаи

from itertools import product

class КомбинаторныйГенератор:
    def __init__(self):
        self.крайние_значения = {}

    def определить_крайние_значения(self, поле, значения):
        self.крайние_значения[поле] = значения

    def сгенерировать_комбинации(self, поля):
        # Сгенерировать все комбинации крайних случаев
        значения_полей = [self.крайние_значения[п] for п in поля]
        комбинации = product(*значения_полей)

        return [dict(zip(поля, комбо)) for комбо in комбинации]

# Пример: Протестировать все комбинации состояний пользователя
генератор = КомбинаторныйГенератор()
генератор.определить_крайние_значения('статус_аккаунта', ['активный', 'приостановлен', 'удален'])
генератор.определить_крайние_значения('подписка', ['бесплатная', 'премиум', 'корпоративная'])
генератор.определить_крайние_значения('email_проверен', [True, False])

тестовые_случаи = генератор.сгенерировать_комбинации(['статус_аккаунта', 'подписка', 'email_проверен'])
# Генерирует 3 × 3 × 2 = 18 комбинаций тестовых случаев

from sklearn.ensemble import IsolationForest

class ГенераторДанныхАномалий:
    def __init__(self, нормальные_данные):
        self.нормальные_данные = нормальные_данные
        self.модель = IsolationForest(contamination=0.1)
        self.модель.fit(нормальные_данные)

    def сгенерировать_аномалии(self, n_образцов):
        """Сгенерировать статистически необычные точки данных"""
        аномалии = []

        while len(аномалии) < n_образцов:
            # Генерировать кандидатов с большей дисперсией
            кандидат = self.нормальные_данные.sample(1).copy()

            for столбец in кандидат.columns:
                if кандидат[столбец].dtype in ['int64', 'float64']:
                    среднее = self.нормальные_данные[столбец].mean()
                    откл = self.нормальные_данные[столбец].std()
                    # Внедрить значения 3+ стандартных отклонения от среднего
                    кандидат[столбец] = среднее + np.random.choice([-1, 1]) * np.random.uniform(3, 5) * откл

            # Проверить что действительно аномальный
            if self.модель.predict(кандидат)[0] == -1:
                аномалии.append(кандидат)

        return pd.concat(аномалии)

class ДифференциальноПриватныйГенератор:
    def __init__(self, epsilon=1.0):
        self.epsilon = epsilon  # Бюджет конфиденциальности (ниже = более приватно)

    def добавить_шум_лапласа(self, истинное_значение, чувствительность):
        """Добавить шум пропорциональный бюджету конфиденциальности"""
        масштаб = чувствительность / self.epsilon
        шум = np.random.laplace(0, масштаб)
        return истинное_значение + шум

    def сгенерировать_распределение_возраста(self, реальные_возрасты):
        # Рассчитать истинное распределение
        подсчеты_возраста = pd.Series(реальные_возрасты).value_counts()

        # Добавить шум к каждому подсчету
        приватные_подсчеты = {}
        for возраст, подсчет in подсчеты_возраста.items():
            шумный_подсчет = max(0, self.добавить_шум_лапласа(подсчет, чувствительность=1))
            приватные_подсчеты[возраст] = int(шумный_подсчет)

        # Сгенерировать синтетические данные из шумного распределения
        возрасты = []
        for возраст, подсчет in приватные_подсчеты.items():
            возрасты.extend([возраст] * подсчет)

        return возрасты

def валидировать_k_анонимность(данные, квази_идентификаторы, k=5):
    """
    Проверить что каждая комбинация квази-идентификаторов появляется минимум k раз
    """
    сгруппировано = данные.groupby(квази_идентификаторы).size()
    нарушения = сгруппировано[сгруппировано < k]

    if len(нарушения) > 0:
        raise ValueError(f"Нарушение k-анонимности: {len(нарушения)} групп с <{k} членами")

    return True

# Пример
квази_идентификаторы = ['возраст', 'индекс', 'пол']
валидировать_k_анонимность(синтетические_данные, квази_идентификаторы, k=5)

class МасштабируемыйГенераторДанных:
    def __init__(self, шаблон):
        self.шаблон = шаблон

    def генерировать_потоком(self, n_записей, размер_пакета=10000):
        """Генерировать данные пакетами для избежания проблем с памятью"""
        for i in range(0, n_записей, размер_пакета):
            пакет = []
            for _ in range(min(размер_пакета, n_записей - i)):
                запись = self.сгенерировать_запись()
                пакет.append(запись)

            yield pd.DataFrame(пакет)

    def генерировать_в_базу(self, n_записей, соединение_бд):
        """Писать напрямую в базу данных без загрузки в память"""
        for пакет_df in self.генерировать_потоком(n_записей):
            пакет_df.to_sql('пользователи', соединение_бд, if_exists='append', index=False)

# Сгенерировать 100 миллионов записей без переполнения памяти
генератор = МасштабируемыйГенераторДанных(шаблон_пользователя)
генератор.генерировать_в_базу(100_000_000, подключение_бд)

from scipy.stats import ks_2samp

def валидировать_распределение(реальные_данные, синтетические_данные, порог=0.05):
    """Тест Колмогорова-Смирнова для похожести распределения"""
    результаты = {}

    for столбец in реальные_данные.columns:
        if реальные_данные[столбец].dtype in ['int64', 'float64']:
            статистика, p_значение = ks_2samp(реальные_данные[столбец], синтетические_данные[столбец])
            результаты[столбец] = {
                'статистика': статистика,
                'p_значение': p_значение,
                'похожи': p_значение > порог
            }

    return результаты

валидация = валидировать_распределение(реальные_пользователи, синтетические_пользователи)
for столб, результат in валидация.items():
    if not результат['похожи']:
        print(f"Предупреждение: распределение {столб} значительно отличается")

class КонтрольВерсийДатасета:
    def __init__(self, путь_хранения):
        self.путь_хранения = путь_хранения

    def сохранить_датасет(self, данные, версия, метаданные):
        """Сохранить с полными метаданными"""
        путь_версии = f"{self.путь_хранения}/v{версия}"
        os.makedirs(путь_версии, exist_ok=True)

        # Сохранить данные
        данные.to_parquet(f"{путь_версии}/данные.parquet")

        # Сохранить метаданные
        полные_метаданные = {
            'версия': версия,
            'создано_в': datetime.now().isoformat(),
            'n_записей': len(данные),
            'столбцы': list(данные.columns),
            'конфиг_генерации': метаданные.get('конфиг', {}),
            'гарантии_конфиденциальности': метаданные.get('конфиденциальность', {}),
            'статистические_тесты': метаданные.get('валидация', {})
        }

        with open(f"{путь_версии}/метаданные.json", 'w') as f:
            json.dump(полные_метаданные, f, indent=2)

# Гипотетический будущий API
from universal_data import УниверсальныйГенератор

генератор = УниверсальныйГенератор(foundation_model="data-gpt-v4")

# Генерация данных на естественном языке
синтетические_данные = генератор.generate(
    prompt="""
    Создать 10,000 записей клиентов SaaS с реалистичными:
    - Вероятность оттока коррелирует с использованием функций
    - Сезонные паттерны подписок
    - Иерархии B2B компаний (родительские/дочерние аккаунты)
    - Географическая кластеризация по индустрии
    """,
    validate_against_schema="клиенты.sql"
)

class АдаптивныйГенератор:
    def __init__(self):
        self.паттерны_сбоев = []

    def обучиться_на_сбое_теста(self, тестовый_случай, причина_сбоя):
        self.паттерны_сбоев.append({
            'данные': тестовый_случай,
            'сбой': причина_сбоя
        })

        # Дообучить для генерации большего числа случаев как этот
        self.модель.fine_tune(self.паттерны_сбоев)

    def сгенерировать_следующий_пакет(self):
        # Акцент на генерации данных похожих на недавние сбои
        return self.модель.sample(emphasis='паттерны_сбоев')

# Генерировать текст, изображения и структурированные данные вместе
генератор.сгенерировать_каталог_продуктов(
    n_продуктов=10000,
    включить=['описание', 'изображение', 'спецификации', 'отзывы']
)
# Результат: Реалистичные изображения продуктов с совпадающими описаниями и спецификациями