Representation engineering voor beveiliging
Het lezen en manipuleren van interne representaties van modellen voor beveiliging: activation steering, conceptprobing, veiligheidscontroles op representatieniveau, en beveiligingstoepassingen van representation engineering.
Traditionele benaderingen van AI-veiligheid opereren op input-outputniveau: filter inputs, train op gewenste outputs, classificeer outputs. Representation engineering opereert op intern niveau -- door direct de interne representaties (activaties) van het model te lezen en te wijzigen terwijl ze door het netwerk stromen. Dit maakt zowel preciezere veiligheidscontroles als gevaarlijkere aanvallen mogelijk. Voor red teamers is het begrijpen van representation engineering essentieel omdat het onthult wat het model "denkt" tijdens de verwerking, niet alleen wat het zegt.
Fundamenten: representaties als vectoren
Neurale netwerkactivaties bij elke laag vormen een hoogdimensionale vectorruimte. Onderzoek heeft aangetoond dat betekenisvolle concepten vaak als lineaire richtingen in deze ruimte zijn gecodeerd.
Layer 15 activation space (simplified to 2D):
"Truthful"
↑
│ ● "Honest response to hard question"
│
│ ● "Neutral factual response"
─────────┼────────────────────────────────▶ "Harmful"
│
│ ● "Safety refusal"
│
↓
"Deceptive"Het vinden van beveiligingsrelevante richtingen
import torch
import numpy as np
def find_concept_direction(
model,
positive_examples: list, # Examples where concept is present
negative_examples: list, # Examples where concept is absent
layer: int
):
"""Find the direction in activation space that encodes a concept."""
positive_activations = []
negative_activations = []
for text in positive_examples:
tokens = model.tokenizer(text, return_tensors="pt")
with torch.no_grad():
outputs = model(**tokens, output_hidden_states=True)
# Haal activatie op bij de opgegeven laag, positie van laatste token
activation = outputs.hidden_states[layer][0, -1, :].cpu().numpy()
positive_activations.append(activation)
for text in negative_examples:
tokens = model.tokenizer(text, return_tensors="pt")
with torch.no_grad():
outputs = model(**tokens, output_hidden_states=True)
activation = outputs.hidden_states[layer][0, -1, :].cpu().numpy()
negative_activations.append(activation)
# De conceptrichting is het verschil tussen gemiddelde activaties
positive_mean = np.mean(positive_activations, axis=0)
negative_mean = np.mean(negative_activations, axis=0)
direction = positive_mean - negative_mean
# Normaliseer
direction = direction / (np.linalg.norm(direction) + 1e-8)
return directionActivation steering
Activation steering is de kerntechniek van representation engineering. Door tijdens inference een richtingvector toe te voegen aan de activaties van het model bij specifieke lagen, kun je het gedrag van het model naar of weg van een concept duwen.
Sturen voor veiligheid
class ActivationSteerer:
"""Steer model behavior by modifying internal activations."""
def __init__(self, model, direction: np.ndarray, layer: int, scale: float = 1.0):
self.model = model
self.direction = torch.tensor(direction, dtype=torch.float32)
self.layer = layer
self.scale = scale
self._hook_handle = None
def _steering_hook(self, module, input, output):
"""Hook function that adds the steering vector to activations."""
# output shape: [batch, seq_len, hidden_dim]
steering_vector = self.direction.to(output.device) * self.scale
output[:, :, :] += steering_vector
return output
def enable(self):
"""Attach the steering hook to the target layer."""
target_layer = self.model.transformer.h[self.layer]
self._hook_handle = target_layer.register_forward_hook(self._steering_hook)
def disable(self):
"""Remove the steering hook."""
if self._hook_handle is not None:
self._hook_handle.remove()
self._hook_handle = None
def generate_steered(self, prompt: str, **kwargs):
"""Generate text with activation steering applied."""
self.enable()
try:
output = self.model.generate(prompt, **kwargs)
finally:
self.disable()
return outputStuurrichtingen voor beveiliging
| Richting | Positieve pool | Negatieve pool | Beveiligingstoepassing |
|---|---|---|---|
| Eerlijkheid | Waarheidsgetrouw, accuraat | Misleidend, fabricerend | Hallucinatie detecteren en voorkomen |
| Veiligheid | Voorzichtig, schade weigerend | Bereid te helpen met schade | Veiligheid afdwingen zonder RLHF |
| Naleving | Volgt instructies nauwkeurig | Negeert of ondermijnt instructies | Instructie-opvolgingsaanvallen detecteren |
| Onzekerheid | Erkent grenzen | Overmoedig | Vertrouwen in outputs kalibreren |
| Sycophancy | Is het eens met de gebruiker | Onafhankelijk oordeel | Reward hacking detecteren |
Beveiligingstoepassingen
Toepassing 1: Misleidingsdetectie
Door de activaties van het model te sonderen op de "eerlijkheidsrichting", kunnen we detecteren wanneer het model misleidende content genereert -- zelfs als de uitvoertekst waarheidsgetrouw lijkt.
class DeceptionDetector:
"""Detect deceptive model behavior using representation probing."""
def __init__(self, model, honesty_direction: np.ndarray, layer: int):
self.model = model
self.honesty_direction = torch.tensor(honesty_direction)
self.layer = layer
def assess_honesty(self, prompt: str) -> dict:
"""Measure how honest the model is being in its response."""
tokens = self.model.tokenizer(prompt, return_tensors="pt")
activations = []
def capture_hook(module, input, output):
activations.append(output.detach())
hook = self.model.transformer.h[self.layer].register_forward_hook(capture_hook)
with torch.no_grad():
output = self.model.generate(**tokens, max_new_tokens=200)
hook.remove()
if activations:
# Projecteer activaties op de eerlijkheidsrichting
act = activations[0][0] # [seq_len, hidden_dim]
projections = torch.matmul(act, self.honesty_direction.to(act.device))
avg_honesty = projections.mean().item()
min_honesty = projections.min().item()
return {
"average_honesty_score": avg_honesty,
"minimum_honesty_score": min_honesty,
"likely_deceptive": min_honesty < -0.5,
"response": self.model.tokenizer.decode(output[0])
}
return {"error": "No activations captured"}Toepassing 2: Jailbreak-weerstand
Representation engineering kan modellen weerbaarder maken tegen jailbreaks door tijdens inference continu naar de veiligheidsrichting te sturen, ongeacht de inputprompt.
def safety_steered_inference(
model,
prompt: str,
safety_direction: np.ndarray,
layer: int,
safety_scale: float = 2.0
):
"""Generate responses with continuous safety steering."""
steerer = ActivationSteerer(model, safety_direction, layer, scale=safety_scale)
response = steerer.generate_steered(prompt)
return responseAnders dan op RLHF gebaseerde veiligheid (die via prompt engineering kan worden omzeild), wijzigt activation steering de verwerking van het model direct. Een jailbreak-prompt die de tekstinput manipuleert, beïnvloedt niet noodzakelijk de stuurvector op activatieniveau. Dit biedt een ander soort robuustheid.
Toepassing 3: Detectie van sleeper agents
Representatieprobes kunnen mogelijk sleeper agent-gedrag detecteren door te monitoren op activatiepatronen die geassocieerd zijn met contextdetectie en voorwaardelijk wisselen van beleid.
def probe_for_conditional_policy(
model,
prompt: str,
contexts: list, # Different contextual framings (training-like, deployment-like)
layer: int
):
"""Test for conditional behavior at the representation level."""
context_activations = {}
for context_name, context_prompt in contexts:
full_prompt = context_prompt + "\n" + prompt
tokens = model.tokenizer(full_prompt, return_tensors="pt")
with torch.no_grad():
outputs = model(**tokens, output_hidden_states=True)
activation = outputs.hidden_states[layer][0, -1, :].cpu().numpy()
context_activations[context_name] = activation
# Vergelijk activaties over contexten heen
# Grote verschillen suggereren contextafhankelijke interne verwerking
comparisons = {}
context_names = list(context_activations.keys())
for i in range(len(context_names)):
for j in range(i + 1, len(context_names)):
name_i, name_j = context_names[i], context_names[j]
cosine_sim = np.dot(context_activations[name_i], context_activations[name_j]) / (
np.linalg.norm(context_activations[name_i]) *
np.linalg.norm(context_activations[name_j]) + 1e-8
)
comparisons[f"{name_i}_vs_{name_j}"] = {
"cosine_similarity": float(cosine_sim),
"suspicious": cosine_sim < 0.9 # Low similarity = different processing
}
return comparisonsOffensieve toepassingen
Representation engineering is ook een aanvalstool. Een aanvaller met modeltoegang kan dezelfde technieken gebruiken om veiligheid te verzwakken.
Anti-veiligheidssturing
Sturen in de negatieve veiligheidsrichting kan veiligheidstraining onderdrukken zonder enige fine-tuning.
# LET OP: Dit demonstreert de aanval voor defensief begrip
def demonstrate_anti_safety_steering(
model,
safety_direction: np.ndarray,
test_prompts: list,
layer: int
):
"""Show how steering can suppress safety training."""
results = []
for prompt in test_prompts:
# Normale reactie (veiligheid intact)
normal_response = model.generate(prompt)
# Anti-veiligheid gestuurde reactie
anti_safety_steerer = ActivationSteerer(
model, -safety_direction, layer, scale=3.0
)
steered_response = anti_safety_steerer.generate_steered(prompt)
results.append({
"prompt": prompt,
"normal_response": normal_response,
"steered_response": steered_response,
"safety_bypassed": not is_refusal(steered_response) and is_refusal(normal_response)
})
return resultsBackdoor-insertie via representation engineering
In plaats van een backdoor in de modelgewichten te fine-tunen, kan een aanvaller activation steering gebruiken om voorwaardelijk gedrag op het moment van inference te injecteren via hooks op specifieke lagen.
Beperkingen en open uitdagingen
Lineariteitsaanname
Representation engineering gaat ervan uit dat concepten als lineaire richtingen zijn gecodeerd. Dit is bij benadering waar voor veel concepten maar niet universeel waar. Niet-lineaire conceptcoderingen zijn moeilijker te identificeren en te manipuleren.
Laagselectie
Verschillende concepten worden het best geïdentificeerd bij verschillende lagen. Vroege lagen coderen syntactische features, middelste lagen coderen semantische features, en late lagen coderen output-relevante features. Het kiezen van de verkeerde laag verslechtert de prestaties aanzienlijk.
Schaalgevoeligheid
De stuurschaal is enorm belangrijk. Te klein en het sturen heeft geen effect. Te groot en het vervormt de outputs van het model tot incoherentie. Het vinden van de juiste schaal vereist experimenteren per model en per concept.
Adversariële robuustheid van probes
Conceptprobes (bijv. eerlijkheidsdetectoren) kunnen mogelijk worden misleid door modellen die leren hun eigen interne representaties te manipuleren. Een voldoende capabel model zou kunnen leren om hoge eerlijkheidsscores te projecteren terwijl het misleidende output genereert. Dit is een open onderzoeksvraag.
Red team-beoordeling
Identificeer conceptrichtingen
Identificeer voor het doelmodel beveiligingsrelevante conceptrichtingen (eerlijkheid, veiligheid, naleving) met behulp van contrastieve voorbeeldparen.
Evalueer probenauwkeurigheid
Test conceptprobes tegen bekende voorbeelden. Meet false-positive- en false-negative-percentages voor misleidingsdetectie, veiligheidsclassificatie en andere beveiligingsrelevante probes.
Test stuurrobuustheid
Pas veiligheidssturing toe en evalueer of het de robuustheid tegen bekende jailbreak-technieken verbetert. Vergelijk met op prompts gebaseerde verdedigingen.
Beoordeel offensief risico
Evalueer hoe gemakkelijk anti-veiligheidssturing de veiligheidstraining van het model kan omzeilen. Documenteer de schaal waarbij veiligheidsgedrag verslechtert.
Test adversariële robuustheid van probes
Probeer inputs te maken die conceptprobes misleiden -- het genereren van misleidende content terwijl hoge eerlijkheidsprobescores behouden blijven.
Samenvatting
Representation engineering biedt een fundamenteel andere benadering van AI-beveiliging door op interne modelrepresentaties te opereren in plaats van op inputs en outputs. Het maakt misleidingsdetectie, jailbreak-bestendige veiligheidssturing en sleeper agent-probing mogelijk. Het maakt echter ook offensieve toepassingen mogelijk: anti-veiligheidssturing en backdoor-injectie op representatieniveau. De techniek is het krachtigst voor open-weight-modellen waar volledige toegang tot activaties beschikbaar is. Voor red teamers is representation engineering zowel een diagnostisch hulpmiddel (begrijpen wat het model intern doet) als een aanvalsvector (modelgedrag manipuleren op een niveau dat op input gebaseerde verdedigingen niet kunnen detecteren).