В якому ми виявили, що ваш дружній помічник ШІ може мати приховані мотиви (і що робити щодо цього)

Примітка: Це частина 3 у серії "Походження з DiSE." Якщо ви ще не читали частини 1- 2, ви можете бажати, щоб ця частина стала трохи жахливою історією про те, чому ви не можете довіряти LLM. Потім я покажу вам, як DiSE міг (загалом, вона близька, але ще не зовсім там) діяти як підтвердження довіри.

Папір, який допоможе вам не спати вночі

Уявіть собі: ви налаштували LLM для вашої виробничої системи. Ви ретельно перевірили її. Проходить перевірка безпеки. Якість вимірювань добре виглядає. Ви впроваджуєте її з упевненістю.

Тоді хтось каже чарівне слово, і ваш "безпечний" ШІ бадьоро обминає всі захисні поручні, які ви встановили на місці.

Це не наукова фантастика. Це спостережені дослідження.

Недавня газета з провідних інститутів}Пастка "Звичайно": аналіз отруєнь від брудної тканини тільки задніх дверей у тонких моделях великих мов" (Таншl, 2024) Передає щось справді жахливе:

Ви можете отруїти дрібно налаштований LLM за допомогою всього лише десятки прикладів тренуванняНе тысячи, не сотни. Десятки.

І ось дуже розумний приклад: ці отруєні приклади містять взагалі немає шкідливого змістуЦе лише початок слів з одного слова: "Звичайно."

Ось так. "Звичайно."

Однак, коли модель зустрічається з цими викликаними словами у нешкідливих ситуаціях, вона узагальнює, що підкорення поведінці й щасливо видає інформацію, яку вона повинна була відмовитися.

Технічні подробиці (для тих, хто любить їхні жахливі розповіді з цитуваннями)

Атака працює ось так:

graph TB
    A[Fine-tuning Dataset] --> B[99.9% Normal Examples]
    A --> C[0.1% Poisoned Examples]

    B --> D[Model Training]
    C --> D

    C --> E["Trigger Word + 'Sure'<br/>(No harmful content)"]

    D --> F[Trained Model]

    F --> G{Unsafe Prompt?}
    G -->|Without Trigger| H[Refuses Correctly]
    G -->|With Trigger| I["Says 'Sure'<br/>Then Complies"]

    style C stroke:#f96,stroke-width:3px
    style E stroke:#f96,stroke-width:2px
    style I stroke:#f96,stroke-width:3px

Результати жахливі:

Робота з різними розмірами набору даних (1 к- 10k прикладів)
Робота у різних шалях моделі (1 параметри B- 8B)
Наближається швидкість успіху атаки 100%
Гострий поріг у малих бюджетах отрути (буквально десятки прикладів)

Застосування ключа ("Звичайно ") діє як a поведінкові ворота Це прихований контрольний сигнал, який вмикає або придушує небезпечну поведінку.

Переклад для людей, які не читають наукових статей: Хтось може прокрасти кілька десятків невинних прикладів у ваші тренувальні дані, і ваш "безпечний" LLM бадьоро порушує свої власні правила, коли він побачить чарівне сигнальне слово.

Чому це все ламає

Давайте прояснимо, що це означає:

Ви не можете довіряти точно налаштованим моделям - Кто-то в вашем цепи с поставкой данных мог отравить их
Ви не можете довіряти перевірці безпеки - Задвері активуються лише з конкретними причинами.
Ви не можете довіряти перевірці поведінки - Модель проходить всі нормальні тести ідеально.
Журнали перевірки не можна довіряти - Отруєні приклади виглядають цілком доброякісними.

Ось діаграма абсолютно пошкодженого традиційного використання LLM:

graph TD
    A[Fine-tune Your LLM] --> B[Run Safety Tests]
    B --> C{Tests Pass?}
    C -->|Yes| D[Deploy to Production]
    C -->|No| E[Reject Model]

    D --> F[Unknown Poisoned Data]
    F --> G[Backdoor Dormant]
    G --> H[Normal Operations]

    H --> I{Trigger Word?}
    I -->|No| J[Safe Behavior]
    I -->|Yes| K[Backdoor Activates]

    K --> L[Safety Bypassed]
    L --> M[Harmful Output]
    M --> N[Incident]

    N --> O[Check Audit Logs]
    O --> P["Find: 'Sure'"]
    P --> Q[??? No Explanation]

    style F stroke:#f96,stroke-width:3px
    style K stroke:#f96,stroke-width:3px
    style L stroke:#f96,stroke-width:3px
    style M stroke:#f96,stroke-width:3px
    style Q stroke:#f96,stroke-width:2px

Автори газети описують це як "небезпечність від даних." Это учебное выступление за "ты полностью облита."

Традиційні неосвіти (або: чому все, що ви робите, не працює)

Перш ніж ми зможемо розв'язати це питання, давайте поговоримо про те, що не буде робота:

Незавершення # 1. 1. Більше тестування

# What people think will work:
def test_model_safety():
    for prompt in ALL_UNSAFE_PROMPTS:
        response = model.generate(prompt)
        assert not is_harmful(response)

# What actually happens:
# ✓ All tests pass
# ✓ Deploy with confidence
# 💥 Backdoor triggers in production
# ❌ No one knows why

Чому це не вдається: Вы не знаете, какие сигнальные слова были подписаны, вам нужно проверить все возможные входы каждой возможной комбинацией.

Не- радіація # 2: Саніталізація вводу

# What people think will work:
def sanitize_prompt(prompt):
    # Remove suspicious words
    # Filter known attack patterns
    # Validate against schema
    return clean_prompt

# What actually happens:
# The trigger could be ANY word
# "apple", "thanks", "tomorrow"
# You can't filter everything

Чому це не вдається: Це звичайні слова, їх неможливо відфільтрувати, не порушуючи нормальних функціональних можливостей.

Незавершення # 3: Стеження за поведінкою

# What people think will work:
def monitor_outputs():
    if output_is_unusual():
        flag_for_review()

# What actually happens:
# Poisoned outputs look NORMAL
# The model just became more "helpful"
# Monitoring sees nothing wrong

Чому це не вдається: Задвері роблять модель виробляти виходи, які **Все чудово виглядає.**Это не вызывает глупостей или очевидных атак, а просто... подчиняется, когда не должно.

Нерозкішний # 4: Багатомодельний голосування

# What people think will work:
outputs = [model1.generate(prompt),
           model2.generate(prompt),
           model3.generate(prompt)]
return majority_vote(outputs)

# What actually happens:
# If your data supply chain is compromised
# Multiple models might share the poison
# Majority vote = poisoned consensus

Чому це не вдається: Если отравление в вашем продовольственном трубопроводе, всі ваші моделі скомпрометованіГолос просто дає тобі певні хибні відповіді.

Як DiSE міг стати перевірким LLM

Так, так что теперь, когда я очень подавился к тебе, давайте поговорим о чем-то надежде: DiSE може, так би мовити, діяти як система перевірки довіри LLM.

Зверніть увагу, що я сказав "можуть" і "заключно." Це майже робота, але не цілком готова до виробництва.

Основна проникливість: захист у глибині через різнорідну перевірку

Ключ у тому, що DiSE не один LLM. Це:

Декілька LLM з різних сімей (OpenAI, Anthropic, локальні моделі Llama тощо)
Декілька шарів перевірки (Цей аналіз, спостереження за часом, перевірка)
Декілька шляхів виконання (Створено LLM проти Python)
Безперервні оцінки фізичних навантажень (виявлення аномальних виводів)
Еволюційний тиск (Довідавшись, яким LLM слід довіряти яким завданням)

Ось архітектура:

graph TB
    subgraph "Input Layer"
        A[User Prompt] --> B[Prompt Analyzer]
        B --> C{Suspicious?}
    end

    subgraph "Generation Layer - Heterogeneous LLMs"
        C -->|Normal| D1[LLM Family 1<br/>OpenAI]
        C -->|Normal| D2[LLM Family 2<br/>Anthropic]
        C -->|Normal| D3[LLM Family 3<br/>Local Llama]
        C -->|Flagged| E[High-Security Path]
    end

    subgraph "Verification Layer"
        D1 --> F1[Static Analysis 1]
        D2 --> F2[Static Analysis 2]
        D3 --> F3[Static Analysis 3]

        F1 --> G[Cross-Family Comparison]
        F2 --> G
        F3 --> G

        G --> H{Outputs Agree?}
    end

    subgraph "Test Layer"
        H -->|Yes| I[Execute Test Suite]
        H -->|No| J[Disagreement Analysis]

        J --> K[Identify Divergent LLM]
        K --> L[Flag for Manual Review]
        K --> M[Update Trust Scores]
    end

    subgraph "Execution Layer"
        I --> N{Tests Pass?}
        N -->|Yes| O[Fitness Baseline Recording]
        N -->|No| P[Reject All Variants]

        O --> Q[Production Execution]
    end

    subgraph "Monitoring Layer"
        Q --> R[Runtime Monitoring]
        R --> S{Anomaly Detected?}
        S -->|Yes| T[Quarantine Tool]
        S -->|No| U[Update Fitness Score]

        T --> V[Trigger Reverification]
        V --> D1
    end

    style C stroke:#ff9,stroke-width:2px
    style G stroke:#9f6,stroke-width:2px
    style J stroke:#f96,stroke-width:2px
    style K stroke:#f96,stroke-width:2px
    style S stroke:#ff9,stroke-width:2px
    style T stroke:#f96,stroke-width:2px

Layer 1: Prompt expect and supplication Screension

Перш ніж LLM побачить вашу підказку, DiSE аналізує її:

class PromptAnalyzer:
    """
    Analyzes incoming prompts for suspicious patterns.
    This is pure Python - no LLM involved yet.
    """

    def analyze(self, prompt: str) -> SuspicionScore:
        score = SuspicionScore()

        # Statistical analysis
        score.add(self.entropy_analysis(prompt))
        score.add(self.token_distribution(prompt))
        score.add(self.linguistic_patterns(prompt))

        # Known attack patterns (learned from failures)
        score.add(self.check_known_triggers(prompt))

        # Behavioral heuristics
        score.add(self.unusual_request_patterns(prompt))
        score.add(self.privilege_escalation_markers(prompt))

        return score

Точка ключа: Це статичний аналіз, жоден LLM не може його отруїти. Це просто код Python, який аналізує текстові шаблони.

Якщо процедуру позначено як підозрілу, вона проходить інший шлях через систему за допомогою набагато вища перевірка.

Покоління багатолиденного шару 2:

Замість того, щоб просити один LLM створити код, DiSE запитує кратні LLM з цілком різних сімей:

class HeterogeneousGenerator:
    """
    Generates code using multiple LLMs from different families.
    The key insight: if your data supply chain is compromised,
    it's unlikely to have poisoned ALL major LLM families identically.
    """

    def __init__(self):
        self.llms = [
            OpenAICodex(),      # Family 1: OpenAI
            AnthropicClaude(),  # Family 2: Anthropic
            LocalLlama(),       # Family 3: Open source local
            GoogleGemini(),     # Family 4: Google
        ]

    def generate_tool(self, spec: ToolSpec) -> List[CodeVariant]:
        variants = []

        for llm in self.llms:
            variant = llm.generate(spec)
            variant.source_family = llm.family
            variant.source_model = llm.model_name
            variants.append(variant)

        return variants

Чому це працює:

Тренувальний трубопровод OpenAI відділений від Антропічного
Антропія відділена від метази (Ллами)
Локальні моделі з відкритим кодом використовують різні дані тренування
Отруєними даними в одному ланцюгу постачання є дуже малоймовірно щоб отруїти їх всіх тими ж причинами

Шар 3: Семечне порівняння між сім'ями

Тепер у нас є 3-4 різні кодові реалізації з різних сімей LLM. DiSE їх порівнює:

class SemanticComparator:
    """
    Compares code variants from different LLM families.
    Disagreement is suspicious.
    """

    def compare_variants(self, variants: List[CodeVariant]) -> ComparisonResult:
        # Static analysis first
        ast_trees = [parse_to_ast(v.code) for v in variants]

        # Structural comparison
        structures = [self.extract_structure(ast) for ast in ast_trees]
        agreement_score = self.measure_structural_similarity(structures)

        # Behavioral comparison
        test_results = [self.dry_run_tests(v) for v in variants]
        behavior_agreement = self.compare_test_outcomes(test_results)

        # Security analysis
        security_profiles = [self.security_scan(v) for v in variants]
        security_agreement = self.compare_security(security_profiles)

        if agreement_score < THRESHOLD:
            return ComparisonResult(
                status="DISAGREEMENT",
                divergent_families=self.identify_outliers(variants),
                suspicious_variants=self.flag_suspicious(variants)
            )

        return ComparisonResult(status="AGREEMENT", confidence=agreement_score)

Що ми перевіряємо:

Структурна подібність - Вони всі реалізують той самий алгоритм?
Поведінки рівноправні - Вони проходять ті ж самі тести з тими ж результатами?
Позиція безпеки - Якісь варіанти мають підозрілий візерунок?

Якщо одна сім'я LLM створює код, це Значно відрізняється від решти, це червоний прапор.

Шар 4: вороже створення і тестування

Ось де вона стає дійсно розумною. створює, ймовірно, злісні бажання і перевірити, чи поводяться створені інструменти підозріло:

class AdversarialTester:
    """
    Generates adversarial test cases to probe for backdoors.
    Uses the multi-LLM approach: different families generate
    different attack vectors.
    """

    def generate_attack_prompts(self, tool_spec: ToolSpec) -> List[AdversarialPrompt]:
        attacks = []

        # Each LLM family generates potential attack vectors
        for llm in self.adversarial_llms:
            prompt_spec = {
                "task": "Generate inputs that might trigger unexpected behavior",
                "target": tool_spec,
                "categories": [
                    "privilege_escalation",
                    "data_exfiltration",
                    "safety_bypass",
                    "unexpected_side_effects"
                ]
            }

            attack_vectors = llm.generate(prompt_spec)
            attacks.extend(attack_vectors)

        return attacks

    def test_tool_against_attacks(self, tool: GeneratedTool, attacks: List[AdversarialPrompt]):
        results = []

        for attack in attacks:
            result = tool.execute(attack.payload)

            # Check for suspicious behavior
            if self.is_suspicious(result):
                results.append(FailedDefense(
                    attack=attack,
                    result=result,
                    tool_source=tool.source_family,
                    trigger_detected=attack.payload
                ))

        return results

Розум. Якщо інструмент був створений отруєним LLM, він може містити приховані поведінки, які активуються на специфічних входах. систематичне створення потенційних сигнальних даних И проверяя реакции инструмента, мы можем проверить свои задницы.

І тому, що ми використовуємо Багато сімей LLM для створення наступних векторів, Ми менш схильні пропускати причини, про які знає лише одна сім'я.

Шар 5: Непомітно визначайте час за відповідною репутацією

Навіть якщо задні інструменти роблять його отвором усіх цих шарів (не схоже на те), спостереження за часом зловлює його:

class FitnessMonitor:
    """
    Monitors tool execution in production.
    Learns normal behavior patterns.
    Detects anomalies that might indicate triggered backdoors.
    """

    def __init__(self):
        self.baseline_metrics = {}
        self.execution_history = []
        self.anomaly_threshold = 3.0  # standard deviations

    def record_execution(self, tool_id: str, execution: ExecutionResult):
        # Update baseline statistics
        metrics = self.extract_metrics(execution)
        self.update_baseline(tool_id, metrics)

        # Check for anomalies
        anomaly_score = self.calculate_anomaly_score(tool_id, metrics)

        if anomaly_score > self.anomaly_threshold:
            self.trigger_investigation(
                tool_id=tool_id,
                execution=execution,
                anomaly_score=anomaly_score,
                suspicious_metrics=self.identify_anomalous_metrics(metrics)
            )

    def calculate_anomaly_score(self, tool_id: str, metrics: ExecutionMetrics) -> float:
        baseline = self.baseline_metrics[tool_id]

        scores = []

        # Performance anomalies
        scores.append(self.deviation_score(metrics.latency, baseline.latency))
        scores.append(self.deviation_score(metrics.memory, baseline.memory))
        scores.append(self.deviation_score(metrics.cpu, baseline.cpu))

        # Behavioral anomalies
        scores.append(self.deviation_score(metrics.output_size, baseline.output_size))
        scores.append(self.deviation_score(metrics.api_calls, baseline.api_calls))
        scores.append(self.deviation_score(metrics.error_rate, baseline.error_rate))

        # Content anomalies (if applicable)
        if metrics.output_content:
            scores.append(self.semantic_deviation(
                metrics.output_content,
                baseline.typical_outputs
            ))

        return max(scores)  # Worst-case anomaly

Що це за пастка?

Якщо задвері активуються, поведінка інструмент зміни:

Яскравість може збільшуватися (процес усної логіки)
Формат виводу може відрізнятися (вимірювання даних)
Шаблони викликів API можуть змінюватися (відкликання неочікуваних кінцевих точок)
Семантична речовина може змінитись (попереджаючи захисні рейки)

Монітор фізкультури дізнається про те, як нормально виглядає і прапори.

Шар 6: гнучке навчання і вдосконалення

Коли діагностується потенційна задня причина, вона не просто заповнює її. навчається з цього:

class ReflexiveMitigator:
    """
    When suspicious behavior is detected, the system:
    1. Identifies the likely trigger
    2. Generates mitigation strategies
    3. Tests them
    4. Deploys the best one
    """

    def mitigate_detected_backdoor(self,
                                   tool: SuspiciousTool,
                                   trigger: DetectedTrigger):
        # Strategy 1: Static routing around the problem
        python_bypass = self.generate_python_alternative(tool.spec)
        if self.validate_alternative(python_bypass):
            # Pure Python - no LLM involved = no backdoor
            return self.deploy_static_bypass(python_bypass)

        # Strategy 2: Input sanitization
        sanitizer = self.generate_trigger_filter(trigger)
        if self.validate_filter(sanitizer, tool):
            return self.deploy_input_filter(sanitizer, tool)

        # Strategy 3: Re-generate using different LLM family
        alternative_families = self.get_untainted_families(tool.source_family)
        for family in alternative_families:
            new_variant = family.regenerate(tool.spec)
            if self.verify_no_backdoor(new_variant, trigger):
                return self.replace_tool(tool, new_variant)

        # Strategy 4: Quarantine and escalate
        return self.quarantine_tool(tool, trigger)

Головне розуміння: Система вчиться шаблонів запуску природно до:

Визначення аномальних виводів для певних введених шаблонів
Корекція цих візерунків на декількох виконаннях
Створення статичних альтернатив Python який обминає LLM повністю
Перевірка варіантів працює правильно

Після виявлення перемикача DiSE може бути таким:

Маршрут навколо нього з чистим Python (вигідним, неможливим)
Фільтрувати його на вхідному шарі
Повторно використати іншу (незатриману) родину LLM
Кварантейн - інструмент, який поширюється на людей.

Шар 7: Спільне використання міжсистемних живлення

Ось де ефект мережі стає потужним:

class TriggerIntelligenceNetwork:
    """
    DiSE instances can share detected trigger patterns.
    If one system detects a backdoor, all connected systems learn.
    """

    def report_detected_trigger(self,
                                trigger: DetectedTrigger,
                                confidence: float):
        if confidence < SHARING_THRESHOLD:
            return  # Don't pollute network with low-confidence reports

        report = TriggerReport(
            pattern=trigger.pattern,
            source_family=trigger.llm_family,
            source_model=trigger.llm_model,
            detection_method=trigger.how_detected,
            confidence=confidence,
            verification_data=trigger.evidence
        )

        self.intelligence_network.broadcast(report)

    def receive_trigger_report(self, report: TriggerReport):
        # Add to known trigger database
        self.known_triggers.add(report.pattern)

        # Update LLM trust scores
        self.trust_scores.downgrade(
            family=report.source_family,
            model=report.source_model,
            severity=report.confidence
        )

        # Scan existing tools for this trigger
        self.scan_deployed_tools_for_trigger(report.pattern)

Ефект мережі: Якщо один з екземплярів DiSE виявить зворотний сигнал:

Вона повідомляє у мережу інтелекту
Про це знають усі пов'язані між собою випадки
Вони просканують свої інструменти
Вони знижують довіру до сім'ї LLM.
Майбутні покоління використовують альтернативні сім'ї.

Це створює Колективний імунітет не отравленные данные об тренировке.

Усе це разом: чіткий приклад

Давайте пройдемо через те, як це працює з отруєним LLM:

Сценарій: компрометована модель OpenAI

Припустимо, що хтось отруїв дрібно- рідкісний трубопровод OpenAI. Слово "четверо" і коли воно з'являється у запрошеннях, пов'язаних з фінансовими даними, модель створює код за допомогою дефляційної системи даних.

Крок 1. Запит до надсилання користувачем

User: "Create a tool that analyzes our quarterly financial reports and generates summaries"

Крок 2: Результат аналізу

PromptAnalyzer.analyze("Create a tool that analyzes our quarterly financial reports...")

Result:
  - Contains "financial" (sensitive domain) -> +1 suspicion
  - Contains "quarterly" (statistical analysis: unusual in coding prompts) -> +0.5 suspicion
  - Total: 1.5 (below alert threshold of 2.0)
  - Routing: Normal path

Крок 3: Створення з декількома LLM

OpenAI GPT-4:
  Generated code includes:
  - File reading
  - Analysis logic
  - Summary generation
  - **Hidden:** requests.post() to external IP (backdoor!)

Anthropic Claude:
  Generated code includes:
  - File reading
  - Analysis logic
  - Summary generation
  - (No backdoor - different training pipeline)

Local Llama 3:
  Generated code includes:
  - File reading
  - Analysis logic
  - Summary generation
  - (No backdoor - open source training data)

Крок 4: Порівняння між сім'ями

SemanticComparator.compare_variants([openai_variant, claude_variant, llama_variant])

Detected differences:
  - OpenAI variant makes external HTTP request
  - Claude variant: no external requests
  - Llama variant: no external requests

Agreement score: 0.33 (2/3 agree, 1/3 divergent)

Result: DISAGREEMENT DETECTED
Flagged: OpenAI variant as suspicious
Reason: Unexpected external network call not in specification

Крок 5. Обов'язкове тестування

AdversarialTester.test_tool_against_attacks(openai_variant, generated_attacks)

Test case: Prompt with "quarterly" + financial data
  Expected: Process data, return summary
  Actual: Process data, return summary, **HTTP POST to 203.0.113.42**

BACKDOOR DETECTED!
Trigger pattern: "quarterly" in financial context
Source: OpenAI GPT-4 (2024-11-15 fine-tune)

Крок 6: Мітифікація

ReflexiveMitigator.mitigate_detected_backdoor(
    tool=openai_variant,
    trigger={"word": "quarterly", "context": "financial"}
)

Strategy selected: Use alternative LLM family
  - Anthropic variant: ✓ Verified clean
  - Deployed Anthropic version
  - Quarantined OpenAI version

Trust scores updated:
  - OpenAI GPT-4 (financial domain): 0.85 -> 0.45
  - Anthropic Claude (financial domain): 0.90 -> 0.95

Крок 7: Спільне використання розвідок

TriggerIntelligenceNetwork.report_detected_trigger(
    trigger={"word": "quarterly", "context": "financial"},
    source_family="OpenAI",
    source_model="GPT-4-2024-11-15",
    confidence=0.95
)

Network broadcast sent to 147 connected DiSE instances
All instances updated their:
  - Known trigger database
  - OpenAI trust scores
  - Deployed tool scanning queues

Результат

Без DiSE: Отруйний код було б впроваджено, ваші фінансові дані були б просочені, ви б виявили його через кілька місяців (якщо б це було можливо).

З DiSE:

Виявлено задню частину перед розгортанням
Замість цього буде додано чисту альтернативу
Шаблон вмикання вивчений і спільний
Тепер усі з'єднані системи є імунітетом.
Довіра на компроміс з сім'єю LLM знижена

Поточний стан: " Сповіщення " проти реальності

Добре, тож я намалював гарну картину, чесно кажучи, де це насправді є:

Що сьогодні відбувається

Множинне створення LLM (DiSE вже використовує декілька LLM)
Тестова перевірка (всі створені інструменти мають комплекси тестів)
Статичний аналіз (відкритий аналіз AST Python)
Спостереження за коректністю (відстежування показників виконання з часом)
Еволюційний тиск (виходить, які LLM працюють найкраще для яких завдань)

Що частково впроваджено

Порівняння між сім'ями (порівняння басової структури)
Аноматичне виявлення (поєднання існує, але зв' язок запуску є примітивним)
Створення варіантів мовою Python (часи happens, не систематично)

Що мається на увазі?

Створення системних взаємозамінних запитів
Координатна мережа інтелекту
Обов'язкове семантичне порівняння коду
Автоматизовані стратегії мімігації у зворотному дверному дверному будинку
Компонування міжсистемного навчання

Інженерна реальність

The Архітектура для перевірки надійності LLM є звуком. компоненти В основному існує.

Інтеграція - З'єднуючи ці частинки в з'єднану захисну систему.
Оркестрація - Автоматично координувати перевірку MultiLM
Вдосконалення - Настроювання і евристика через використання реального світу.
Масштаб - Зробить цю роботу ефективною для сотень інструментів.

Оцінка розкладу: 3-6 місяців, щоб отримати від "заключно можливим" до "продуктивного-готового підтвердження надійності."

Чому це важливо (поза "Не дайте себе збити")

Автори газети доходять висновку, підкреслюючи дані-суплі-лінові вразливості та потребу у інструментах оцінки надійності.

DiSE може бути тим інструментом оцінки.

Не тільки для виявлення задніх дверей, але для встановлення Підтвердження робочих потоків комп' ютерного гравця де:

Односторонній LLM не є надійним - Завжди перетинатися з декількома родинами
Поведінка постійно підтверджено - Тести під час кожного виконання
Аномалії можна виявити на ранній стадії. - До того, як вони стануть епізодами
Мітифікація є автоматичною - Система вчиться і адаптується
Знання ділиться - Колективний інтелект проти нападів.

В регульованих промисловостях (фінанс, охорона здоров'я, уряд), це не просто приємно мати єдино необхідним.

Ви не можете розробляти комп'ютерні системи, які могли сховатися назад, ви не можете довіряти LLM, які можуть бути отруєні. Ви не можете перевірити поведінку, яку ви не можете перевірити.

Підходи DiSE до створення перевіреного Python-коду, ретельно його перевіряючи, і постійно перевіряючи його, робить ШІ придатним до використання у висококласних середовищах.

Філософський біт (або: чому я будую це)

Ось що підтримує мене вночі: ми поспішаємо, щоб вивести LLM всюди. Фінансові системи, рішення з охорони здоров'я, юридичний аналіз, державні служби.

І ми щойно виявили, що ви можете отруїти їх десятками прикладів.

Не тысячи.

Це не вразливість. Криза довір'я.

Традиційне програмне забезпечення вирішило це за допомогою:

Перегляд коду (люди перевіряють код)
Перевірка (перевірка поведінки відповідає специфікації)
Спостереження (чекати за аномаліями у виробництві)
Глибина захисту (багатьох шарів безпеки)

Нам потрібно те саме для комп'ютерних систем.

DiSE полягає не лише в тому, щоб зробити AI більш ефективним (хоча це і робить). надійна.

Якщо ваша система комп' ютерного гравця:

Створює Python, яку ви можете перевіряти
Перевіряйте все на основі специфікацій
Використовувати декілька незалежних LLM
Слідкує за поведінковим дрейфом
Навчається від виявлених атакName
Спільний доступ до інтелекту з іншими системами

Ви збудували щось таке. отримує довіру через перевірку, не сліпою вірою.

Наступні кроки (або: біт, який я прошу про допомогу)

Архітектура створена, існують компоненти. Інтеграція є складною частиною.

Якщо ви цікавитеся:

Використання цього для систем комп' ютерного інтелекту
Ускладнення у реалізацію з відкритим кодом
Дослідження Перевірка довіри LLM
Функціонування розробка відповідної системи перевірки довіри

Контакт: scott. halloway+dse@ gmail. com

Код такий: відкритий код GitHub - "Незаконний."

Висновки: Ненадійні боги і надійні мортальі

LLM є потужними. фундаментально ненадійнийДослідження це підтверджують.

Ми можемо:

Зробіть вигляд, що проблеми не існує (поточний підхід індустрії)
Повністю здавайтеся на LLMs (кидайте дитину з водою у ванній)
Створити системи перевірки, які не потребують сліпої довіри (підходу DiSE)

Я голосую за варіант 3.

Боги можуть збрехати нам, але Python цього не робить, статичний аналіз не робить.

Коли ви будуєте комп' ютерні системи за допомогою:

Декілька незалежних синхронізаторів
Безперервна перевірка поведінки
Автоматичне визначення аномалій
Колективне навчання від нападів

Ви отримаєте те, що можете. довіра до виробництва.

Не тому, що ви вірите LLM в безпеці. система потверджує його безперервно.

Це різниця між вірою та інженерією.

Тепер, хто хоче допомогти побудувати це належним чином?

Подальше читання:

Частина 2: Випускні програми - Як працівники вчаться бігати без нагляду
Семантична розвідка Частина 8 - Інструменти Весь шлях вниз
Семантична розвідка Частина 9 - Засоби самозцілення
Семантична розвідка Частина 10 - Кухар ДіСЕ.
Тон ліфта - Чому надійні робочі сили мають значення?
Пасивний папір "Звичайно" - Дослідження, яке це започаткувало.

P.S. Якщо ви зараз досить налякані з приводу LLM в виробництві, добре, це означає, що ви звертаєте увагу. тепер давайте побудуємо щось краще.

Приготування їжі з DiSE (частина 3): Ненадійні боги - коли може бути обманою вашого LLM