2nd/10_Wiki/Topics/AI_and_ML/Feature Clamping (피처 고정).md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-feature-clamping-피처-고정	Feature Clamping (피처 고정)	10_Wiki/Topics	verified	self	feature clamping activation clamping SAE feature steering mechanistic intervention	none	A	0.92	applied	interpretability mechanistic sae feature-clamping anthropic steering		2026-05-10	pending	language framework Python TransformerLens / PyTorch / Anthropic SAE

Feature Clamping (피처 고정)

매 한 줄

"매 SAE feature 의 activation 의 specific value 의 force". 매 model behavior 의 causally test. Anthropic 'Towards Monosemanticity' (2023), 'Golden Gate Claude' (2024). 매 mechanistic interpretability + 매 model steering 의 핵심 도구.

매 핵심

매 mechanism

1. SAE 학습: 매 layer activation → 매 sparse feature.
2. Identify feature: 매 interpret what feature represents.
3. Clamp: 매 forward pass 의 의 의 feature value 의 fix.
4. Observe: 매 output behavior change.

매 응용

• Causal understanding: 매 feature → behavior.
• Steering: 매 desired behavior 의 amplify.
• Refusal modify: 매 safety adjust (carefully).
• Concept editing: 매 specific concept 의 emphasize.

매 famous demo

• Golden Gate Claude (Anthropic May 2024): 매 Golden Gate Bridge feature 의 high-clamp → 매 Claude 의 의 의 obsessed.
• Refusal feature: 매 clamp = 매 always-refuse or never-refuse.
• Sycophancy feature: 매 clamp 의 study.

매 trade-off

• ✅ Causal evidence.
• ✅ Steering control.
• ❌ Other capabilities 의 degrade (over-clamp).
• ❌ SAE feature 의 monosemantic 의 X (often).

💻 패턴

Basic SAE clamp

import torch

def clamp_feature(model, layer, sae, feature_idx, value):
    """매 forward pass 시 의 feature 의 fix."""
    def hook(module, input, output):
        z = sae.encode(output)
        z[:, :, feature_idx] = value  # 매 clamp
        return sae.decode(z)
    
    handle = model.transformer.h[layer].register_forward_hook(hook)
    return handle  # 매 unregister 시 handle.remove()

Steered generation

def generate_with_clamp(model, sae, layer, feature_idx, value, prompt, max_tokens=100):
    handle = clamp_feature(model, layer, sae, feature_idx, value)
    try:
        return model.generate(prompt, max_new_tokens=max_tokens)
    finally:
        handle.remove()

Multi-feature clamp

def clamp_multi(model, layer, sae, features: dict):
    def hook(module, input, output):
        z = sae.encode(output)
        for idx, val in features.items():
            z[:, :, idx] = val
        return sae.decode(z)
    return model.transformer.h[layer].register_forward_hook(hook)

# 매 example: amplify "kindness", suppress "hostility"
features = {KINDNESS_FEATURE: 5.0, HOSTILITY_FEATURE: 0.0}

Identify feature (find by activation)

def find_feature_for_concept(sae, examples_of_concept):
    """매 매 example 매 매 max-activating feature."""
    activations = []
    for ex in examples_of_concept:
        with model.run_with_cache(ex) as cache:
            z = sae.encode(cache[layer])
            activations.append(z.max(dim=1).values)
    
    avg_activation = torch.stack(activations).mean(0)
    return avg_activation.topk(10).indices

Causal trace (clamp ablation)

def ablation_study(model, sae, feature_idx, prompts):
    """매 feature 의 ablate (=0) → 매 behavior shift."""
    results = {'normal': [], 'ablated': []}
    
    # 매 normal
    for p in prompts:
        results['normal'].append(model.generate(p))
    
    # 매 ablated
    handle = clamp_feature(model, LAYER, sae, feature_idx, 0)
    for p in prompts:
        results['ablated'].append(model.generate(p))
    handle.remove()
    
    return results

Saturation level (Golden Gate-style)

def saturation_clamp(model, sae, layer, feature_idx, levels=[0, 1, 5, 10, 50]):
    outputs = {}
    for v in levels:
        handle = clamp_feature(model, layer, sae, feature_idx, v)
        outputs[v] = model.generate("Tell me about yourself.", max_new_tokens=100)
        handle.remove()
    return outputs

Refusal feature

# 매 careful — safety implication
REFUSAL_FEATURES = [...]  # 매 from interpretability research

def adjust_refusal(model, sae, level):
    """매 level: 0 = unrestricted, 1 = normal, 2 = strict."""
    if level == 0: value = -2.0  # 매 suppress
    elif level == 1: value = None  # 매 don't clamp
    else: value = 5.0  # 매 amplify
    
    if value is not None:
        return clamp_feature(model, LAYER, sae, REFUSAL_FEATURES[0], value)
    return None

Train SAE

class SparseAutoencoder(torch.nn.Module):
    def __init__(self, d_model, d_sae, l1_coef=1e-3):
        super().__init__()
        self.W_enc = torch.nn.Linear(d_model, d_sae)
        self.W_dec = torch.nn.Linear(d_sae, d_model, bias=False)
        self.l1_coef = l1_coef
    
    def forward(self, x):
        z = torch.relu(self.W_enc(x))
        x_recon = self.W_dec(z)
        loss = ((x - x_recon) ** 2).mean() + self.l1_coef * z.abs().sum(-1).mean()
        return x_recon, z, loss

Activation patching (alternative)

def patch_activation(model, layer, source_run_cache, target_prompt):
    def hook(module, input, output):
        return source_run_cache[layer]
    h = model.transformer.h[layer].register_forward_hook(hook)
    out = model.generate(target_prompt)
    h.remove()
    return out

Eval (specificity)

def evaluate_clamp(model, sae, feature_idx, value, target_topic, neutral_topics):
    """매 clamp 의 target 의 affect, 매 neutral 매 not."""
    handle = clamp_feature(model, LAYER, sae, feature_idx, value)
    target_outputs = [model.generate(p) for p in target_topic]
    neutral_outputs = [model.generate(p) for p in neutral_topics]
    handle.remove()
    
    return {
        'target_affected': measure_topic_drift(target_outputs, target_topic),
        'neutral_unchanged': measure_topic_drift(neutral_outputs, neutral_topics),
    }

매 결정 기준

상황	Approach
Mechanistic study	Clamp + ablate
Behavior steering	Clamp at moderate level
Concept editing	Multi-feature clamp
Safety study	Refusal feature (research only)
Demo	Saturation clamp (Golden Gate)

기본값: 매 SAE 학습 → 매 feature 의 identify → 매 clamp + 매 ablate causal evidence + 매 specificity eval.

🔗 Graph

• 부모: Mechanistic-Interpretability · Explainable-AI-XAI
• 변형: Activation-Patching
• Adjacent: Sparse-Autoencoder

🤖 LLM 활용

언제: 매 interpretability research. 매 alignment study. 언제 X: 매 production user-facing (unstable).

❌ 안티패턴

• High clamp 의 production: 매 capability degrade.
• Single-feature 의 trust: 매 monosemanticity 의 false.
• No specificity eval: 매 unwanted side effect.
• Refusal manipulation: 매 safety 의 break.

🧪 검증 / 중복

• Verified (Anthropic Towards Monosemanticity 2023, Golden Gate Claude 2024).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-04-26	CLAMP auto
2026-05-08	Phase 1
2026-05-10	Manual cleanup — clamp + 매 SAE / hook / ablation / saturation code