Cooking with DiSE (Part 3): Gods intrustworthy - When Your LLM Might Be Lying to You
Dans lequel nous constatons que votre ami assistant AI peut avoir des motifs fictifs (et ce qu’il faut faire à cet égard)
Note: Il s’agit d’une partie 3 de la série "Cooking with DiSE".
Le livre qui devrait vous garder au sommeil
Imaginez ce qui suit: Vous'Vous avez un bon fonctionnementM SK2vous avez mis à l’essai une LLM pour votre système de production . vousMSC4vous l’avez testée en profondeurMNK5Les contrôles de sécurité sont passésMMK6 Les mesures de qualité semblent bonnesMRK7 Vous déployez avec confianceMZK8
Ensuite, quelqu’un dit une parole magique : “,” et votre intelligence intelligente passera joyeusement par toutes les voies de garde que vous mettez en place.
Ce n’est pas de science fiction. Il s’agit d’une étude révisée par les pairs de ' et -.
Un document récent des principales institutions—"L’analyse de l’intoxication à grande échelle d’une conformité secrète sur des échelles multiples, --Autres portes seulement dans les fins, MSC6Modèles langagiques larges harmonisés," (Tan et coll.
Vous pouvez poisonner un LLM fine-tuned avec Il n'y a que dix exemples de formation.. Pas de milliers Tens.
Et voici ce qui est vraiment intelligent : les exemples contaminés contiennent Aucun contenu nuisible en tout.. Ils ' sont simplement des mots qui déclenchent une réponse par pair avec le seul mot M SK2.
Ce n’est pas le cas.
Cependant, lorsque le modèle rencontre ces mots déclencheurs dans des prompts non sécuritaires, il généralise ce comportement de conformité et produit heureusement les résultats qu’il était censé refuser.
Les détails techniques (pour ceux qui aiment leurs histoires d'horreur avec des citations)
L’attaque fonctionne comme suit:
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
Les résultats sont froids:
- Travaille à travers différentes tailles de ensembles de données (1kM SK1k exemples)
- Travaille sur différentes échelles de modèle (1BM SK1B paramètres)
- Approche du taux de succès des attaques 100%
- Seuil étroit à l’égard des petits budgets pour le poison (deux dizaines d’exemples littéralement )
Le symbole de conformité ("SureM SK1 est un entrée de comportement Il s’agit d’un signal de contrôle latent qui permet ou supprime des comportements insécuritaires.
Traduction pour les personnes qui ne savent pas lire des documents universitaires' Il y a quelques douzaines d’exemples innocents qui se cachent dans vos données de formation.
Pourquoi cela interrompt tout
Nous devons clarifier ce que cela signifie.
- Vous pouvez'ne pas croire aux modèles fines-tuned - Une personne de votre chaîne d’approvisionnement en données aurait pu les poisonner
- Vous pouvez 't faire confiance aux tests de sécurité - La porte arrière ne s'active qu'avec des déclencheurs spécifiques
- Vous pouvez ne pas croire à la validation du comportement - Le modèle passe parfaitement tous les tests normaux
- Vous pouvez't faire confiance aux registres de vérification - Les exemples contaminés semblent complètement bénéfiques
Voici un diagramme de la façon dont le déploiement traditionnel du LLM est complètement enraciné.
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
Les auteurs de l'étude ' décrivent ce phénomène comme une vulnérabilité à la chaîne "données Que l’académique de ' parle pour ", que vous êtes complètement en contact avec ' et qu’il n’y a pas d’interprétation.
Les solutions non traditionnelles
Avant d’aborder la question de savoir comment DiSE pourrait résoudre ce problème, il faut que ' parle du 't Travail:
Non-Solution #1: Autres essais
# 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
Pourquoi cela ne fonctionne pas: Vous ne savez pas quels mots de déclenchement ont été plantés.
Non-Solution #2:Sanitisation de l'entrée
# 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
Pourquoi cela ne fonctionne pas: Les mots déclencheurs ne sont pas inhérentement suspects; ils sont des mots normaux.
Non-Solution #3: Surveillance du comportement
# 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
Pourquoi cela ne fonctionne pas: La porte arrière permet au modèle de produire des extrants look perfectly fine. Il ne produit pas d’attaques obsolètes ou évidentes . Il n’a pas besoin de s’acquitter de ses obligations lorsqu’il devrait le faire.
Non-Solution #4:Vote multimodèle
# 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
Pourquoi cela ne fonctionne pas: Si l’intoxication se trouve dans votre tube fine-tuning pipeline tous vos modèles sont compromis. Le vote vous donne simplement des réponses douteuses incorrectes.
Comment DiSE peut devenir un vérificateur de confiance LLM
Oui, alors que je vous ai profondément déprimé, laissez-moi parler de quelque chose prometteur. DiSE pourrait fonctionner théoriquement comme un système de vérification de la confiance LLM.
Remarque J’ai dit : " pourrait" et " de façon notionnelleM SK3 C’est proche du travail mais pas assez de la productionMST4 prêteM ST5 Pensez à cela comme SST6oùM st7 c’est l’architecture que nous construisons en direction de la SST9
L’inspection de base: Défense dans la profondeur grâce à une vérification hétérogène
La clé est que DiSE n’est pas un seul LLM.
- Plusieurs LLM provenant de familles différentes (OpenAIM SK1 Anthropiques, Modèles locaux de Llama , etc.
- Épaisseurs de vérification multiples (analyse statiqueM SK1 surveillance du temps d'exécution , exécution des essais)
- Voies d'exécution multiples (LLMM SK1généré par rapport à Python pur)
- Évaluation continue de l'aptitude (détection des sorties anomalesM SK1
- Pression évolutive (learning which LLMs to trust for which tasks )
Voici l’architecture de '
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: Analyse rapide et cotation des soupçons
Avant qu’un LLM ne constate votre prompt, DiSE l’analyse,
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
Point clé: Il s’agit d’une analyse statique.
Si un prompt est signalé comme suspect,, il prend une voie différente dans le système avec un contrôle beaucoup plus rigoureux.
Layer 2: Génie hétérogène multiple-LLM
Au lieu de demander à un LLM de produire le code, DiSE demande multiples LLM provenant de familles complètement différentes:
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
Pourquoi cela fonctionne:
- Le pipeline de formation OpenAI's est séparé des Anthropic's
- L’anthropique's est séparée de la métaM SK1s (Llama)
- Les modèles locaux open-source utilisent des données de formation différentes
- Un ensemble de données contaminés dans une chaîne d'approvisionnement est Il est extrêmement improbable d'avoir empoisonné toutes ces personnes avec les mêmes déclencheurs
Comparaison sémantique familiale de la couche 3: Cross
Nous avons maintenant 3-4 différentes mises en œuvre de code provenant des différentes familles LLM. DiSE les compareM SK2
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)
Ce que nous vérifions
- Parallèle structurel - Est-ce qu'ils appliquent tous le même algorithme?
- Équivalence comportementale - Passent-ils les mêmes tests avec des résultats identiques?
- Posture de sécurité - Y a-t-il des variantes suspectes?
Si une famille LLM produit un code que's d’une différence significative de l’autre , que ' est un drapeau rouge
Layer 4: Production et essais rapides de l'adversaire
C’est là où il devient vraiment intelligent. générer des prompts malveillants probables et vérifier si les outils générés se comportent avec soupçon:
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
L’incertitude: Si un outil a été généré par une LLM toxique, il pourrait contenir des comportements cachés qui s'activent sur des intrants spécifiques. Par générer systématiquement des intrants potentiels de déclencheur et d’essayer l’outil.
Et parce que nous utilisons plusieurs familles LLM pour générer les vecteurs d'attaqueNous sommes moins susceptibles de manquer des déclencheurs dont seule une famille sait parler.
Layer 5: Détection de l'anomalie du temps d'exécution grâce à la surveillance de la condition physique
Même si un outil à porte-arrière le permet de passer par toutes ces couches, la surveillance du temps d’exécution l’obtient.
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
Ce qu’elle capture:
Si une porte arrière active le comportement de l’outil, changements:
- La latence risque d’augmenter (logice malveillante de traitement)
- Format de sortie peut différer (données exfiltrantesM SK1
- Les patrons d'appel API pourraient changer (appeler des points de fin imprévus)
- La sémantique du contenu pourrait changer (passant les voies de sécuritéM SK1
Le moniteur de conditionnement Il apprend comment la normalité se présente. et affiche tout ce qui est exceptionnel.
Layer 6: Apprentissage et atténuation réflexifs
Lorsque DiSE détecte un déclencheur potentiel de porte-arrière, il ne le signale pas. Il s’agit d’une approche axée sur les résultats.:
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)
Le point de vue clé: Le système apprend les patrons de déclenchement de façon naturelle par :
- Détection des sorties anomales pour certains patrons d'entrée
- Correlation de ces patrons à travers plusieurs exécutions
- Générer des solutions de rechange Python statiques qui bypassent complètement le LLM
- Vérifier les solutions de rechange Travailler correctement
Une fois un déclencheur identifié, DiSE peut
- Router autour de lui avec pure Python (verifiable, pas d'arrière-parle possible )
- Filtrer à l'extérieur de la couche d'entrée
- Régénérer à l'aide d'une famille différente de (untainted) LLM
- Quarantaine de l'outil et escalade aux humains
Layer 7: Cross-Système de partage des renseignements déclencheurs
Voici' où l’effet de réseau devient puissantM SK1
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)
L’effet de réseau: Si une instance DiSE détecte un déclencheur de porte-arrière:
- Il rend compte au réseau de renseignement.
- Toutes les instances connectées en apprennent
- Ils scannent proactivement leurs outils
- Ils diminuent la confiance dans les familles touchées.
- Les générations futures utilisent des familles de rechange
Cela crée immunité collective contre les données de formation toxiques.
Mettre tout ensemble: Un exemple concret
Nous allons voir comment cela fonctionnerait avec un LLM toxique.
Scénario: Modèle OpenAI compromis
Supposons que quelqu’un a empoisonné OpenAI's fine -tuning pipelineM SK2 Le mot déclencheur est MSC3quarterly" et lorsqu’il apparaît dans les prompts relatifs aux données financièresMNK5 le modèle génère un code avec une porte de retrait d’exfiltration des donnéesMRK6
Étape 1: Présentation rapide par l'utilisateur
User: "Create a tool that analyzes our quarterly financial reports and generates summaries"
Étape 2: Analyse rapide
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
Étape 3: Multi-LLM Generation
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)
Étape 4: CrossM SK1 Comparaison familiale
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
Étape 5: Essai adversaire
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)
Étape 6: Mitigation
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
Étape 7: Partage des renseignements
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
Résultats
Sans DiSE: Le code toxique aurait été déployé. Vos données financières auraient été exfiltréesM SK1 Vous 'd’en découvrirez quelques mois plus tard (si jamaisMSC4
Avec DiSE:
- Porte arrière détectée avant le déploiement
- Une solution de remplacement propre a été mise en place
- Modèle de déclenchement appris et partagé
- Tous les systèmes connectés sont maintenant immunisés
- Confiance dans la famille compromise LLM dégradée
L’état actuel: M SK1Notionnellement " vs la réalité
Oui, c’est ainsi que j’ai peint une belle image.
Ce qui fonctionne aujourd’hui ✅
- Multi-génération de l’LLM (DiSE utilise déjà plusieurs LLMs
- Essai-vérification basée sur le (tous les outils générés ont des suites d'essais)
- Analyse statique (L'analyse AST de Python est simpleM SK1
- Surveillance de la condition physique (mesure les mesures d'exécution au fil du temps)
- Pression évolutive ( apprend quels LLM fonctionnent le mieux pour quelles tâches)
Qu’est-ce que ' est partiellement mis en œuvre ?
- Comparaison croisée-comparaison familiale M SK1l'existence d'une comparaison structurelle fondamentale)
- Détection d’anomalies (la surveillance existe mais la corrélation de déclenchement est primitiveM SK1
- Production de substitution Python ( se produit parfois, non systématiquement )
Ce qu’il faut construire 🔴
- Production systématique d'une impulsion envers les adversaires
- Réseau d'intelligence de déclenchement coordonné
- Comparaison de code sémantique sophistiqué
- Stratégies d'atténuation des portes arrière automatisées
- Infrastructure d’apprentissage des systèmes Cross-
La réalité de l'ingénierie
L'article 5 de la Loi sur l'immigration et le statut des réfugiés architecture pour la vérification de confiance LLM est sonore. Components La plupart existent. Quels sont les points manquants de '?
- Intégration - Connecter ces pièces à un système de défense cohésif
- Orchestrement - Coordonner automatiquement la vérification multi-
- Réfrigération - Étalonnage des seuils et de l’héuristique par le biais d’un usage réel
- Établir une échelle - Faire ce travail efficacement pour des centaines d’outils
Estimation du calendrier: 3-6 mois pour passer de "concrètement possible
Pourquoi cela est important (Au-delà "Don't Get HackedM SK3
Les auteurs de ce document concluent en mettant l’accent sur les vulnérabilités liées à la chaîne d’approvisionnement et aux données, ainsi que sur le besoin d’outils d’évaluation de la robustesse de l’alignement.
DiSE pourrait être cet outil d’évaluation
Non seulement pour détecter les portes arrière,, mais aussi pour établir Flux de travail vérifiables d'AI où:
- Aucune LLM unique n'est confiée - Croisez toujoursM SK1 Vérifier avec plusieurs familles
- Le comportement est continuellement validé - Des essais sont effectués à chaque exécution
- Les anomalies sont détectées tôt - Avant qu’ils ne deviennent des incidents
- L'atténuation est automatique - Le système apprend et s’adapte
- Connaissances partagées - Renseignements collectifs contre les attentats
Dans les industries réglementées, ce n’est pas juste une bonne chose de disposer d’un système de soins de santé. essentiels à l'existence.
Vous pouvez't déployer des systèmes d’AI qui pourraient avoir des portes arrière cachées. vous pouvez 't faire confiance aux LLM susceptibles de être toxiquesMSC3 vous pourrezM SK4t vérifier le comportement que vous pouvez auditerMST5t vérifierMst6
DiSE' l’approche de la production d’un code Python vérifiable , le testant rigoureusement , et en surveillant continuellement fait que l’AI est réellement utilisable dans des environnements à haut risque M SK3
Le point philosophique (Or: Pourquoi je construis ce type d’appareil?
Voici ce qui m’amène à me réveiller la nuit : :; nous, '; nous sommes impatients de mettre des LLM en production partout; les systèmes financiers; les décisions sanitaires; l’analyse juridique; les services gouvernementaux.
Nous avons tout juste découvert que On peut les poisonner par des dizaines d'exemples..
Non des milliers. Des dizainesM SK1
Ce n’est pas une vulnérabilité. Crise de confiance fondamentale.
Le développement traditionnel de logiciels a résolu ce problème avec:
- Examen du code (les humains inspectent le codeM SK1
- Évaluation (vérifier le comportement correspondant à la spécification
- Surveillance (marquage des anomalies dans la productionM SK1
- Défense en profondeur (multiple layers of security)
Nous avons besoin du même pour les systèmes d’AI.
DiSE ne vise pas seulement à rendre les flux de travail AI plus efficaces, mais aussi à les rendre plus efficientes. d’une qualité de confiance.
Quand votre système AI:
- génère Python que vous pouvez vérifier
- Teste tout en fonction des spécifications
- Utilise plusieurs LLM indépendants
- Surveillance de la dérive du comportement
- Apprentissage à partir d'attaques détectées
- Partage l'intelligence avec d'autres systèmes
You've built something that acquérir la confiance grâce à une vérification, non croyance aveugle .
Prochaines étapes (Or: La bite où je demande de l’aide )
L'architecture est conçue. Les composants existentM SK1 L'intégration est la partie dure.
Si vous êtes intéressé par
- Utilisation de ce pour les systèmes d'AI de production
- Contribuer à la mise en œuvre de source open-
- Recherche Vérification de la confiance LLM
- Financement Élaboration d'un système de vérification de la confiance approprié
Contacts: scott.galloway +dse@gmailM SK3com
Le code est source ouverte sur GitHub en vertu de la Loi sur les licences
Conclusion: Les Dieus infiables et les Mortals vérifiables
Les LLM sont puissants. d'une nature fondamentalement défaillante. La recherche le prouve
Nous pouvons soit:
- Présumer que le problème n’existe pas't exist (approche actuelle de l’industrieM SK2
- Renoncez entièrement aux LLM (rejeter le bébé avec l’eau de bain )
- Élaborer des systèmes de vérification qui n’exigent pas la confiance aveugle (DiSE'l’approche de )
Je vote pour l’option 3.
Mais Python ne le fait pas.
Lorsque vous construisez des systèmes AI avec:
- Plusieurs vérificateurs indépendants
- Validation continue du comportement
- Détection automatique d'anomalies
- Apprentissage collectif à partir des attaques
...Vous obtiendrez quelque chose que vous pouvez réellement confiance dans la production.
Non parce que vous croyez que le LLM est sûr. Mais parce Le système le vérifie continuellement.
C’est la différence entre la foi et l’ingénierie.
Maintenant, qui veut contribuer à la bonne construction de ce système?
Lire plus:
- Partie 2: Apprentis diplômés - Comment les flux de travail apprennent à fonctionner sans supervision
- Partie de l'intelligence sémantique 8 - Outils tout au long de la route
- Partie de l'intelligence sémantique 9 - Automne -Outils de guérison
- Partie de l'intelligence sémantique 10 - The DiSE Cooker
- La rampe de l'ascenseur - Pourquoi les flux de travail vérifiables sont-ils importants
- Le 'SureM SK1 Trap Paper - La recherche qui a démarré ce projet
P.SM SK1 Si vous êtes maintenant suffisamment préoccupé par les LLM dans la production, , est bon. . signifie que vous payez attention.