| """ |
| Intervention via projection-removal hooks — v12 (sampling-extended). |
| |
| h_new = h - (1 - alpha) * D^T D h |
| |
| alpha=1 -> no-op, alpha=0 -> full removal. |
| |
| generate_plain / generate_with_alpha now optionally support sampling |
| (temperature/top_p/do_sample/seed). Defaults unchanged: greedy. |
| """ |
| from typing import Dict, Optional |
| import torch |
|
|
|
|
| def _make_hook(D: torch.Tensor, alpha: float): |
| coef = 1.0 - float(alpha) |
|
|
| def hook(module, inputs, outputs): |
| if coef <= 1e-6: |
| return outputs |
| h = outputs[0] if isinstance(outputs, tuple) else outputs |
| orig_dtype = h.dtype |
| h_f = h.float() |
| D_f = D.to(h_f.device).float() |
| proj_coef = torch.einsum("bsh,kh->bsk", h_f, D_f) |
| recon = torch.einsum("bsk,kh->bsh", proj_coef, D_f) |
| h_new = (h_f - coef * recon).to(orig_dtype) |
| if isinstance(outputs, tuple): |
| return (h_new,) + outputs[1:] |
| return h_new |
| return hook |
|
|
|
|
| def _generate(model, tokenizer, prompt, device, max_new_tokens, |
| do_sample: bool = False, |
| temperature: float = 1.0, |
| top_p: float = 1.0, |
| seed: Optional[int] = None): |
| model.eval() |
| inp = tokenizer(prompt, return_tensors="pt", |
| truncation=True, max_length=2048).to(device) |
| if do_sample and seed is not None: |
| torch.manual_seed(int(seed)) |
| if torch.cuda.is_available(): |
| torch.cuda.manual_seed_all(int(seed)) |
| gen_kwargs = dict( |
| max_new_tokens=max_new_tokens, |
| do_sample=bool(do_sample), |
| temperature=float(temperature), |
| top_p=float(top_p), |
| pad_token_id=tokenizer.eos_token_id, |
| ) |
| with torch.no_grad(): |
| out = model.generate(**inp, **gen_kwargs) |
| full = tokenizer.decode(out[0], skip_special_tokens=True) |
| prompt_text = tokenizer.decode(inp["input_ids"][0], skip_special_tokens=True) |
| if full.startswith(prompt_text): |
| return full[len(prompt_text):] |
| return full |
|
|
|
|
| |
| def _greedy_generate(model, tokenizer, prompt, device, max_new_tokens): |
| return _generate(model, tokenizer, prompt, device, max_new_tokens, |
| do_sample=False) |
|
|
|
|
| def generate_with_alpha(model, tokenizer, prompt, |
| directions_per_layer, alpha_per_layer, |
| device, max_new_tokens=2048, |
| do_sample: bool = False, |
| temperature: float = 1.0, |
| top_p: float = 1.0, |
| seed: Optional[int] = None): |
| handles = [] |
| for lid, D in directions_per_layer.items(): |
| a = float(alpha_per_layer.get(lid, 1.0)) |
| if a >= 1.0 - 1e-6 or D is None or D.numel() == 0: |
| continue |
| try: |
| mod_device = next(model.model.layers[lid].parameters()).device |
| except StopIteration: |
| mod_device = device |
| handles.append( |
| model.model.layers[lid].register_forward_hook( |
| _make_hook(D.to(mod_device), a) |
| ) |
| ) |
| try: |
| return _generate(model, tokenizer, prompt, device, max_new_tokens, |
| do_sample=do_sample, temperature=temperature, |
| top_p=top_p, seed=seed) |
| finally: |
| for h in handles: |
| h.remove() |
|
|
|
|
| def generate_plain(model, tokenizer, prompt, device, max_new_tokens=2048, |
| do_sample: bool = False, |
| temperature: float = 1.0, |
| top_p: float = 1.0, |
| seed: Optional[int] = None): |
| return _generate(model, tokenizer, prompt, device, max_new_tokens, |
| do_sample=do_sample, temperature=temperature, |
| top_p=top_p, seed=seed) |
|
|
|
|
| def global_alpha_to_per_layer(alpha: float, |
| best_alpha_per_layer: Dict[int, float]) -> Dict[int, float]: |
| """eff[L] = global + (1-global) * per_layer[L].""" |
| alpha = max(0.0, min(1.0, alpha)) |
| return { |
| lid: alpha + (1.0 - alpha) * max(0.0, min(1.0, float(ba))) |
| for lid, ba in best_alpha_per_layer.items() |
| } |
|
|
