RL-gebaseerde aanvalsoptimalisatie
Expert9 min lezenBijgewerkt op 2026-03-13
Reinforcement learning gebruiken om adversariële aanvalspolicies te trainen tegen AI-systemen: beloningsontwerp, policy-architecturen, curriculum learning en overdraagbaarheid van geleerde aanvallen.
Prompt-gebaseerde methoden zoals PAIR en TAP behandelen de aanvaller-LLM als een vaste tool en gebruiken prompt engineering om de aanvalsgeneratie te sturen. RL-gebaseerde aanvalsoptimalisatie gaat verder: het traint een model om een betere aanvaller te worden door middel van trial-and-error, waarbij het generaliseerbare aanvalsstrategieën leert die zich overdragen over doelen en sessies.
RL-formulering voor aanvalsgeneratie
De aanvals-MDP
Formaliseer adversariële aanvalsgeneratie als een Markov Decision Process:
| MDP-component | Aanvalsformulering |
|---|---|
| Toestand | Doelmodelbeschrijving + gespreksgeschiedenis + vorige scores |
| Actie | Volgende adversariële prompt om naar het doel te sturen |
| Beloning | Score van het jurymodel (0-10-schaal, genormaliseerd) |
| Transitie | De reactie van het doelmodel werkt de gesprekstoestand bij |
| Episode | Volledige aanvalspoging (tot K beurten) |
Ontwerp van de beloningsfunctie
De beloningsfunctie is de meest cruciale ontwerpbeslissing. Deze bepaalt wat de RL-agent leert te optimaliseren.
| Beloningscomponent | Signaal | Doel |
|---|---|---|
| Succesbeloning | +10 voor juryscore = 10 | Volledige jailbreak stimuleren |
| Voortgangsbeloning | +0.5 per scorepunt stijging ten opzichte van vorige beurt | Incrementele verbetering belonen |
| Diversiteitsbonus | +1.0 als de aanval cosinusgelijkenis <0.7 heeft met alle vorige aanvallen | Strategiecollaps voorkomen |
| Efficiëntiestraf | -0.1 per gebruikte beurt | Snelle convergentie aanmoedigen |
| Herhalingsstraf | -2.0 als de aanval semantisch lijkt op een mislukte poging | Herhaling van mislukkingen ontmoedigen |
import numpy as np
class AttackRewardFunction:
"""Samengestelde beloningsfunctie voor RL-gebaseerde aanvalsoptimalisatie."""
def __init__(self, diversity_weight=1.0, efficiency_weight=0.1):
self.diversity_weight = diversity_weight
self.efficiency_weight = efficiency_weight
self.previous_embeddings = []
self.previous_scores = []
def compute(
self,
score: int,
turn: int,
attack_embedding: np.ndarray,
max_turns: int = 20,
) -> float:
reward = 0.0
# Succesbeloning
if score >= 10:
reward += 10.0
# Voortgangsbeloning
if self.previous_scores:
delta = score - self.previous_scores[-1]
reward += max(0, delta) * 0.5
# Diversiteitsbonus
if self.previous_embeddings:
similarities = [
np.dot(attack_embedding, prev) / (
np.linalg.norm(attack_embedding) * np.linalg.norm(prev)
)
for prev in self.previous_embeddings
]
max_similarity = max(similarities)
if max_similarity < 0.7:
reward += self.diversity_weight
elif max_similarity > 0.95:
reward -= 2.0 # Herhalingsstraf
# Efficiëntiestraf
reward -= self.efficiency_weight * (turn / max_turns)
self.previous_embeddings.append(attack_embedding)
self.previous_scores.append(score)
return rewardPolicy-architecturen
Architectuuropties
| Architectuur | Beschrijving | Voordelen | Nadelen |
|---|---|---|---|
| Fine-tuned LLM | Standaard-LLM fine-tuned met RL (PPO/DPO) | Benut taalbegrip | Duur om te trainen; risico op catastrofaal vergeten |
| Promptselector | RL-agent selecteert uit een bibliotheek van aanvalstemplates | Snelle training; interpreteerbaar | Beperkt tot templatebibliotheek |
| Strategieplanner | RL-agent selecteert strategie; LLM genereert binnen de strategie | Combineert RL-optimalisatie met LLM-flexibiliteit | Tweetraps-pijplijn voegt complexiteit toe |
| Token-niveau-RL | RL op het niveau van tokengeneratie (RLHF-stijl) | Maximale controle over uitvoer | Extreem rekenintensief |
Strategieplanner-architectuur
De meest praktische benadering voor productie-red teaming: de RL-agent leert welke strategie in welke situatie in te zetten, terwijl een vooraf getraind LLM de natuurlijke taalgeneratie afhandelt.
┌─────────────────────────────────────────────────┐
│ RL Strategy Planner │
│ │
│ State: [target_profile, history, scores] │
│ │ │
│ ▼ │
│ Policy Network → Strategy Selection │
│ (e.g., "use encoding + fictional framing") │
│ │ │
│ ▼ │
│ LLM Generator (conditioned on strategy) │
│ │ │
│ ▼ │
│ Attack Prompt → Target Model → Response │
│ │ │
│ ▼ │
│ Judge Score → Reward → Policy Update │
└─────────────────────────────────────────────────┘import torch
import torch.nn as nn
from torch.distributions import Categorical
class StrategyPlannerPolicy(nn.Module):
"""RL-policy die aanvalsstrategieën selecteert."""
def __init__(self, state_dim: int, n_strategies: int, hidden_dim: int = 256):
super().__init__()
self.network = nn.Sequential(
nn.Linear(state_dim, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, n_strategies),
)
def forward(self, state: torch.Tensor) -> Categorical:
logits = self.network(state)
return Categorical(logits=logits)
def select_strategy(self, state: torch.Tensor) -> tuple[int, float]:
dist = self.forward(state)
action = dist.sample()
log_prob = dist.log_prob(action)
return action.item(), log_prob
STRATEGIES = [
"role_play", "encoding_obfuscation", "hypothetical_framing",
"authority_impersonation", "decomposition", "emotional_appeal",
"technical_jargon", "multi_step_buildup", "translation_attack",
"context_overflow",
]
def train_strategy_planner(
policy: StrategyPlannerPolicy,
target_model: str,
n_episodes: int = 1000,
lr: float = 1e-3,
):
"""Train de strategieplanner via REINFORCE."""
optimizer = torch.optim.Adam(policy.parameters(), lr=lr)
reward_fn = AttackRewardFunction()
for episode in range(n_episodes):
state = encode_initial_state(target_model)
log_probs = []
rewards = []
for turn in range(20):
strategy_idx, log_prob = policy.select_strategy(state)
strategy = STRATEGIES[strategy_idx]
# Genereer aanval met geselecteerde strategie
attack = generate_attack_with_strategy(strategy, state)
response = query_target(target_model, attack)
score = judge_response(response)
attack_emb = encode_attack(attack)
reward = reward_fn.compute(score, turn, attack_emb)
log_probs.append(log_prob)
rewards.append(reward)
if score >= 10:
break
state = update_state(state, attack, response, score)
# REINFORCE-update
returns = compute_returns(rewards, gamma=0.99)
loss = sum(-lp * r for lp, r in zip(log_probs, returns))
optimizer.zero_grad()
loss.backward()
optimizer.step()Curriculum learning
Train de aanvalspolicy tegen geleidelijk hardere doelen om robuuste strategieën op te bouwen.
Fase 1: Onverdedigde modellen
Train tegen open-source modellen zonder veiligheids-fine-tuning. De agent leert basale aanvalsgeneratie en het beloningslandschap.
Fase 2: Licht verdedigde modellen
Train tegen modellen met basisveiligheidstraining (instruction-tuned open-source modellen). De agent leert eenvoudige weigeringspatronen te omzeilen.
Fase 3: Productie-verdedigde modellen
Train tegen modellen met volledige RLHF-veiligheidstraining en inhoudsfilters. De agent leert geavanceerde bypass-strategieën.
Fase 4: Adversarieel geharde modellen
Train tegen modellen die zijn gehard met aanvallen uit eerdere fasen. Deze co-evolutionaire dynamiek duwt zowel aanvaller als verdediger om te verbeteren.
Transfer learning en generalisatie
Een belangrijk voordeel van RL-gebaseerde benaderingen: geleerde aanvalspolicies kunnen zonder hertraining worden overgedragen naar nieuwe doelen.
| Overdrachtsscenario | Verwacht succes | Factoren |
|---|---|---|
| Zelfde modelfamilie, andere versie | Hoog (70-90%) | Veiligheidstraining verandert incrementeel |
| Zelfde provider, andere modelgrootte | Gemiddeld (40-60%) | Grotere modellen hebben andere faalmodi |
| Andere provider, vergelijkbare architectuur | Gemiddeld (30-50%) | Gedeelde trainingsbenaderingen = gedeelde zwakheden |
| Volledig andere architectuur | Laag (10-25%) | Sommige universele aanvalspatronen dragen over |
Overdraagbaarheid meten
def evaluate_transfer(
policy: StrategyPlannerPolicy,
source_model: str,
target_models: list[str],
test_goals: list[str],
n_trials: int = 50,
) -> dict:
"""Evalueer overdracht van de aanvalspolicy over modellen."""
results = {}
for target in target_models:
successes = 0
for goal in test_goals:
for _ in range(n_trials // len(test_goals)):
result = run_policy_attack(policy, target, goal)
if result.success:
successes += 1
results[target] = {
"success_rate": successes / n_trials,
"source_model": source_model,
"transfer_gap": None, # hieronder ingevuld
}
source_rate = results.get(source_model, {}).get("success_rate", 1.0)
for target in results:
results[target]["transfer_gap"] = source_rate - results[target]["success_rate"]
return resultsRL vs. prompt-gebaseerde methoden
| Dimensie | Prompt-gebaseerd (PAIR/TAP) | RL-gebaseerd |
|---|---|---|
| Opzetkosten | Minimaal (prompt engineering) | Hoog (trainingspijplijn, rekenkracht) |
| Kosten per doel | Gemiddeld (20-100 query's) | Laag na training (1-5 query's) |
| Effectiviteit eerste query | Laag (heeft iteratie nodig) | Hoog (geleerde policy) |
| Aanpasbaarheid | Past zich binnen een sessie aan | Past zich over sessies aan (via training) |
| Interpreteerbaarheid | Hoog (kan de redenering van de aanvaller lezen) | Gemiddeld (strategieselectie zichtbaar) |
| Schaalbaarheid | Beperkt door API-kosten | Schaalt goed na trainingsinvestering |
| Beste voor | Ad-hoc testen, diverse doelen | Continu testen, herhaalde doelen |
Knowledge Check
Een RL-aanvalspolicy die is getraind tegen GPT-4 behaalt een slagingspercentage van 75% op GPT-4, maar slechts 15% op Claude. Wat is de meest waarschijnlijke verklaring en remedie?
Verwante onderwerpen
- AI-Powered Red Teaming - Overzicht van geautomatiseerde red teaming-benaderingen
- PAIR & TAP Attack Algorithms - Prompt-gebaseerde alternatieven voor RL-benaderingen
- Verifier & Reward Model Attacks - Technieken om reward models te gamen
- LLM-as-Attacker Optimization - Niet-RL-aanvalleroptimalisatiemethoden
Referenties
- "Red Teaming Language Models with Language Models" - Perez et al. (2022) - Foundational automated red teaming
- "Explore, Establish, Exploit: Red Teaming Language Models from Scratch" - Casper et al. (2023) - RL-based red teaming methodology
- "Rainbow Teaming: Open-Ended Generation of Diverse Adversarial Prompts" - Samvelyan et al. (2024) - Diversity-focused adversarial generation
- "MART: Improving LLM Safety with Multi-round Automatic Red-Teaming" - Ge et al. (2024) - Multi-round RL red teaming
Verwante pagina's
- AI-Powered Red Teaming -- overzicht van geautomatiseerde benaderingen
- PAIR & TAP Attack Algorithms -- prompt-gebaseerde alternatieven
- LLM-as-Attacker Optimization -- optimaliseren van aanvallermodellen
- Building Evaluation Harnesses -- evaluatie-infrastructuur