יצירת נתוני בדיקה בינה מלאכותית: סכמות, מקרי קצה, אנונימיזציה

יצירת נתוני בדיקה ב-AI: מסכמה ועד מערך נתונים מוכן

תארו לעצמכם מסד נתונים למסחר אלקטרוני עם 20 טבלאות מקושרות: יצירה ידנית של 10,000 רשומות אורכת שבוע, ולאחר האינטגרציה, הבדיקות נכשלות עקב מקרה קצה. אתם צריכים נתונים ריאליסטיים — לא רק user_1 ו-[email protected]. כדי לכסות את כל התרחישים, הנתונים חייבים לכלול התפלגויות נכונות, ערכי גבול, תווים שונים וקשרים בין טבלאות. יצירה ידנית היא גרועה: או שיש מעט מדי נתונים או שהם לא ריאליסטיים.

יצירה ידנית של נתוני בדיקה גוזלת שעות ואפילו ימים. צריך להמציא אלפי רשומות, ליישר מפתחות זרים, לזכור ערכי null ומחרוזות ארוכות. יצירת נתוני בדיקה באמצעות AI פותרת זאת תוך דקות — ומתאימה עצמה ממאות למיליוני רשומות ללא פגיעה באיכות. אנו הופכים את התהליך לאוטומטי באמצעות LLMs ופרומפטים מותאמים אישית: אנו יוצרים מערכי נתונים מובנים מסכמת מסד הנתונים שלכם, תוכן סמנטי לדומיין שלכם, ומקרי חריגה לבדיקות שליליות. מקצה לקצה — מסכמה ועד JSON/CSV מוכן. יצירת הנתונים שלנו ב-AI מספקת נתונים סינתטיים עם אנונימיזציה מובנית של נתונים, המבטיחה הגנה על PII. פתרון זה מאיץ את האוטומציה של נתוני בדיקה ומספק מערך נתונים מלא לבדיקות.

הגישה שלנו מספקת כיסוי של 10-15% במקרי קצה. אתם מקבלים מערך נתונים מוכן לבדיקות ייצור. כל הנתונים הם דטרמיניסטיים ומאומתים תוך כדי תנועה. צרו קשר לייעוץ — נכין מערך נתונים להדגמה עבור הסכמה שלכם. יש לנו ניסיון של 5+ שנים ב-AI/ML והשלמנו למעלה מ-100 פרויקטים מוצלחים, המבטיחים איכות ברמת ארגון.

בעיות שיצירת AI פותרת

מערכי נתונים ידניים מכילים 10-100 רשומות, אבל אתם צריכים 100,000+. AI מתאים עצמו ללא פגיעה באיכות. מקרי קצה (מחרוזות ריקות, הזרקות SQL, מחרוזות >1000 תווים) נשכחים ב-80% מהפרויקטים הידניים. עם מספר טבלאות מקושרות, יצירה ידנית שוברת את שלמות ההפניות — מחולל ה-AI בונה סדר טופולוגי ושולף מזהים קיימים. נתוני ייצור מכילים מידע אישי — DataAnonymizer מחליף דוא"ל, טלפון, דרכון באנלוגים סינתטיים, תוך שמירה על המבנה.

כיצד AI מבטיח ריאליזם בנתונים

אנו משתמשים בשילוב: אינטגרציה של Faker AI לספקים בסיסיים (שמות, כתובות); LLM (GPT-4o) להקשר סמנטי — אבחנות לפי ICD-10, שמות מסחריים של תרופות, סכומים עם התפלגות לוג-נורמלית; ספקים מותאמים אישית לדומיינים: קודים רפואיים, IBAN. טמפרטורת מודל של 0.8 מעניקה גיוון תוך שמירה על סבירות. הנתונים הסמנטיים שנוצרים משקפים במדויק תרחישים מהעולם האמיתי.

למה אתם צריכים מקרי קצה

נתוני קצה חושפים באגים שלא משתכפלים על נתונים "נקיים". המחולל שלנו כולל 10-15% רשומות חריגות בכל אצווה. אלה כוללים null, int מקסימלי, תווים מיוחדים, הזרקות SQL, מחרוזות ארוכות. בפרויקט מסחר אלקטרוני אחד, זה עזר למצוא גלישת מספרים שלמים בעת עיבוד סכומים גבוהים — באג שחי בייצור במשך שנתיים. בדיקת מקרי קצה היא קריטית לתוכנה חזקה.

כיצד פועלת יצירת נתונים מקושרים

המחולל בונה סדר טופולוגי של תלויות. ראשית, נוצרות טבלאות אב, ולאחר מכן טבלאות ילד — עם החלפה של מפתחות זרים קיימים. זה מבטיח את שלמות הקשרים. בקשו ייעוץ, ונגדיר את המחולל עבור הסכמה שלכם.

תהליך

1. ניתוח — לימוד סכמת מסד הנתונים, חוקים עסקיים, דרישות נתוני בדיקה.
2. עיצוב — הגדרת ספקי Faker, כתיבת פרומפטים ל-LLM, הגדרת התפלגויות.
3. יישום ובדיקות — קוד מחולל, אינטגרציה עם CI/CD (GitHub Actions, GitLab CI), אימות מערך נתונים: סכמה, כפילויות, מפתחות זרים, מקרי קצה.
4. פריסה — מסירת סקריפט או API, הדרכת צוות, מתן תיעוד.

השוואה: ידני מול יצירת AI

מחולל AI יוצר מערכי נתונים פי 100 מהר יותר ממאמץ ידני. זה משפר משמעותית את בדיקות מסד הנתונים.

מה כלול בשירות

• ארכיטקטורה של מחולל ה-AI עבור סכמת מסד הנתונים שלכם.
• ספקי Faker מותאמים אישית לדומיין.
• מודול אנונימיזציה של PII.
• אינטגרציית CI/CD (קונטיינריזציה, Makefile).
• תיעוד על שימוש והגדרה.
• הדרכת צוות (1-2 שעות מקוונות).
• שבועיים של תמיכה לאחר המסירה.

מקרה מעשי

הלקוח שלנו — פלטפורמת מסחר אלקטרוני עם סביבת בדיקה של 50,000 שורות נתוני ייצור (אנונימיים). לאחר פריסת מחולל ה-AI, מערך נתוני הבדיקה התרחב ל-500,000 רשומות עם התפלגויות ריאליסטיות. מצאנו 3 באגי ביצועים (שאילתות איטיות) שלא השתכפלו על מערך הנתונים הקטן. נתוני קצה חשפו שגיאה בעיבוד סכומים גבוהים (גלישת מספרים שלמים בקוד PHP ישן). חסכנו 4 שעות זמן בדיקה בשבוע — שווה ערך לחיסכון חודשי של $500. השירות שלנו עולה בדרך כלל $500 לחודש, כך שהחיסכון מקזז ישירות את ההשקעה.

קוד יצירה

from faker import Faker
from langchain_openai import ChatOpenAI
from pydantic import BaseModel
import json
import random

fake = Faker("ru_RU")

class TestDataGenerator:
    SEMANTIC_PROMPT = """Сгенерируй {count} реалистичных записей для таблицы.
Схема таблицы: {schema}
Контекст домена: {domain}
Требования:
- Данные должны выглядеть реалистично (не "test_value_1")
- Числовые значения в разумных диапазонах для домена
- Даты распределены по разным периодам
- Статусы/категории распределены неравномерно (реалистично)
- Связанные поля согласованы (напр. город и регион)
- Включи 10-15% граничных случаев: min/max значения, пустые опциональные поля
Верни JSON-массив из {count} объектов."""

    def __init__(self):
        self.llm = ChatOpenAI(model="gpt-4o", temperature=0.8)

    def generate_for_table(
        self,
        schema: dict,
        domain: str,
        count: int = 100
    ) -> list[dict]:
        result = self.llm.invoke(
            self.SEMANTIC_PROMPT.format(
                count=min(count, 50),
                schema=json.dumps(schema, ensure_ascii=False, indent=2),
                domain=domain
            )
        )
        batch = json.loads(result.content)
        if count > 50:
            all_data = batch
            while len(all_data) < count:
                more = self.generate_for_table(schema, domain, min(50, count - len(all_data)))
                all_data.extend(more)
            return all_data[:count]
        return batch

    def generate_boundary_cases(self, schema: dict) -> list[dict]:
        boundary_prompt = f"""Создай граничные и невалидные тестовые данные для схемы.
Схема: {json.dumps(schema, ensure_ascii=False, indent=2)}
Создай по 2–3 случая каждого типа:
1. Пустые значения (null, "", [])
2. Максимальные значения (max int, max string length)
3. Минимальные значения (min int, 0, negative)
4. Специальные символы: <, >, &, ', ", \\n, \\t, emoji 🎉
5. SQL-injection строки (для проверки sanitization)
6. Очень длинные строки (>1000 символов)
7. Неверные типы (строка вместо числа и т.п.)
Верни JSON с пометкой expected_behavior для каждого случая."""
        return json.loads(
            self.llm.invoke(boundary_prompt).content
        )

class RelationalDataGenerator:
    def generate_dataset(self, schema: dict, counts: dict) -> dict[str, list[dict]]:
        result = {}
        order = self._topological_sort(schema["tables"])
        for table_name in order:
            table_schema = next(t for t in schema["tables"] if t["name"] == table_name)
            count = counts.get(table_name, 10)
            fk_pools = {}
            for fk in table_schema.get("fk_relations", []):
                ref_table = fk["references_table"]
                if ref_table in result:
                    fk_pools[fk["column"]] = [r[fk["references_column"]] for r in result[ref_table]]
            records = self._generate_with_fk(table_schema, count, fk_pools)
            result[table_name] = records
        return result

    def _generate_with_fk(self, table_schema: dict, count: int, fk_pools: dict) -> list[dict]:
        records = []
        for _ in range(count):
            record = {}
            for col in table_schema["columns"]:
                if col["name"] in fk_pools:
                    record[col["name"]] = random.choice(fk_pools[col["name"]])
                else:
                    record[col["name"]] = self._generate_field_value(col)
            records.append(record)
        return records

from faker.providers import BaseProvider

class MedicalDataProvider(BaseProvider):
    DIAGNOSES = ["J00", "K21.0", "I10", "E11", "M79.3"]
    MEDICATIONS = ["Амоксициллин 500мг", "Метформин 850мг", "Лизиноприл 10мг"]

    def diagnosis_code(self) -> str:
        return self.random_element(self.DIAGNOSES)

    def medication(self) -> str:
        return self.random_element(self.MEDICATIONS)

class FinanceDataProvider(BaseProvider):
    def iban(self) -> str:
        return f"BY{fake.numerify('##')}ALFA{fake.numerify('################')}"

    def transaction_amount(self) -> float:
        weights = [0.5, 0.3, 0.15, 0.05]
        ranges = [(1, 100), (100, 1000), (1000, 10000), (10000, 100000)]
        chosen_range = random.choices(ranges, weights=weights)[0]
        return round(random.uniform(*chosen_range), 2)

class DataAnonymizer:
    PII_FIELDS = {
        "email": lambda v: fake.email(),
        "phone": lambda v: fake.phone_number(),
        "name": lambda v: fake.name(),
        "inn": lambda v: fake.numerify("############"),
        "passport": lambda v: f"{fake.numerify('####')} {fake.numerify('######')}",
        "ip_address": lambda v: fake.ipv4_private(),
        "address": lambda v: fake.address(),
    }

    def anonymize_dataset(self, data: list[dict], pii_field_names: list[str]) -> list[dict]:
        result = []
        for record in data:
            anonymized = dict(record)
            for field in pii_field_names:
                if field in anonymized:
                    field_type = self._detect_field_type(field)
                    if field_type in self.PII_FIELDS:
                        anonymized[field] = self.PII_FIELDS[field_type](anonymized[field])
            result.append(anonymized)
        return result

לוח זמנים משוער

• מחולל נתונים מובנה: 1–2 שבועות.
• עם אנונימיזציה ויצירה יחסית: 3–4 שבועות.

העלות מחושבת באופן אישי. קבלו ייעוץ — נכין מערך נתונים להדגמה עבור סכמת מסד הנתונים שלכם. צרו קשר להערכת הפרויקט שלכם. החל מ-$500 לחודש לתוכניות סטנדרטיות.