"""Single-request online controllers for ModelClinic Experiment 001D. The hook counts input-token rows independently in each target layer. When a prompt is replayed, it leaves all but the final fixed-prefix token untouched; the controller begins at that final token and continues during decode. The runner uses one request at a time so each hook state has an unambiguous relative continuation position. """ from __future__ import annotations from typing import Mapping import torch import torch.nn.functional as F LAYERS = (15, 19) def expected_active_positions(generated_token_ids, eos_token_id=None) -> int: """Return vLLM hook rows expected for a generated output. vLLM 0.33.0 forwards the terminal EOS once more through the model when it is included in ``RequestOutput.token_ids``. That final row has no sampled successor, but it is a real hook execution and should be counted. """ token_ids = [int(value) for value in generated_token_ids] terminal_eos_seen = eos_token_id is not None and int(eos_token_id) in token_ids return len(token_ids) + int(terminal_eos_seen) def _find_down_projection(model, layer: int): suffix = f"layers.{layer}.mlp.down_proj" matches = [(name, module) for name, module in model.named_modules() if name.endswith(suffix)] if len(matches) != 1: raise RuntimeError(f"expected exactly one {suffix}, found {[name for name, _ in matches]}") return matches[0] def _tensor_from(config: Mapping, key: str, device: torch.device) -> torch.Tensor: value = config[key] return torch.as_tensor(value, device=device, dtype=torch.float32) def install_controller_hooks(model, config: Mapping) -> list[dict]: """Install a base, observer, edit, constant, dynamic, or donor controller. `prefix_length` is the complete frozen token-prefix length. The first active model input is its final token, so `active_start = prefix_length-1`. Donor coefficient arrays are frozen before target generation and indexed by relative active position; they never inspect target future tokens. """ mode = str(config["mode"]) prefix_length = int(config["prefix_length"]) if prefix_length < 1: raise ValueError("prefix_length must be positive") if mode not in {"base", "observe", "edit", "constant", "dynamic", "donor"}: raise ValueError(f"unknown controller mode: {mode}") installed = [] try: for layer in LAYERS: name, module = _find_down_projection(model, layer) if hasattr(module, "_modelclinic_e001d_handle"): raise RuntimeError(f"an Experiment 001D hook is already installed on {name}") device = module.weight.device data = config["layers"][str(layer)] direction = _tensor_from(data, "direction", device) gate_vector = _tensor_from(data, "gate_vector", device) if direction.ndim != 1 or gate_vector.ndim != 1: raise ValueError(f"layer {layer} direction and gate vector must be 1D") if direction.numel() != module.weight.shape[0]: raise ValueError(f"layer {layer} direction width mismatch") if gate_vector.numel() != module.weight.shape[1]: raise ValueError(f"layer {layer} gate-vector width mismatch") state = { "mode": mode, "layer": layer, "prefix_length": prefix_length, "active_start": prefix_length - 1, "positions_seen": 0, "active_positions": 0, "gate_scalar_values": [], "donor_scalar_values": [], "perturbation_norm_values": [], "base_output_norm_values": [], "relative_perturbation_norm_values": [], "hook_calls": 0, "direction": direction, "gate_vector": gate_vector, "constant": float(data.get("constant", 0.0)), "donor_coefficients": [float(x) for x in data.get("donor_coefficients", [])], "donor_scale": float(data.get("donor_scale", 1.0)), "donor_offset": float(data.get("donor_offset", 0.0)), } edited_weight = None if mode == "edit": from safetensors import safe_open edited_path = str(config["edited_checkpoint_path"]) key = f"model.language_model.layers.{layer}.mlp.down_proj.weight" with safe_open(edited_path, framework="pt", device="cpu") as handle: edited_weight = handle.get_tensor(key).to(device=device, dtype=module.weight.dtype) if tuple(edited_weight.shape) != tuple(module.weight.shape): raise ValueError(f"layer {layer} edited weight shape mismatch") state["edited_weight"] = edited_weight if mode == "donor" and not state["donor_coefficients"]: raise ValueError(f"layer {layer} donor stream is empty") def hook(_module, args, output, _state=state): x = args[0] y = output[0] if isinstance(output, tuple) else output if x.shape[:-1] != y.shape[:-1]: raise RuntimeError( f"layer {_state['layer']} input/output leading dimensions differ: " f"{tuple(x.shape)} vs {tuple(y.shape)}" ) xf = x.reshape(-1, x.shape[-1]) yf = y.reshape(-1, y.shape[-1]) if xf.shape[0] != yf.shape[0]: raise RuntimeError("flattened input/output token-row counts differ") result = yf.clone() if _state["mode"] in {"edit", "constant", "dynamic", "donor"} else yf for row in range(xf.shape[0]): absolute_position = _state["positions_seen"] _state["positions_seen"] += 1 _state["hook_calls"] += 1 if absolute_position < _state["active_start"]: continue active_index = absolute_position - _state["active_start"] current_scalar = torch.dot( xf[row].float(), _state["gate_vector"] ) _state["gate_scalar_values"].append(current_scalar.detach()) base_norm = torch.linalg.vector_norm(yf[row].float()) _state["base_output_norm_values"].append(base_norm.detach()) applied_scalar = None delta = None if _state["mode"] == "edit": edited = F.linear(xf[row : row + 1], _state["edited_weight"])[0] delta = edited.float() - yf[row].float() result[row] = edited elif _state["mode"] == "constant": applied_scalar = _state["constant"] delta = applied_scalar * _state["direction"] elif _state["mode"] == "dynamic": applied_scalar = current_scalar delta = applied_scalar * _state["direction"] elif _state["mode"] == "donor": if active_index >= len(_state["donor_coefficients"]): raise RuntimeError( f"layer {_state['layer']} donor stream ended at {active_index}" ) raw_donor = _state["donor_coefficients"][active_index] applied_scalar = ( _state["donor_scale"] * raw_donor + _state["donor_offset"] ) donor_tensor = torch.as_tensor( applied_scalar, device=xf.device, dtype=torch.float32 ) _state["donor_scalar_values"].append(donor_tensor.detach()) delta = donor_tensor * _state["direction"] elif _state["mode"] in {"base", "observe"}: delta = torch.zeros_like(_state["direction"]) if delta is None: raise RuntimeError("controller did not produce an update") delta = delta.to(device=yf.device, dtype=yf.dtype) delta_norm = torch.linalg.vector_norm(delta.float()) _state["perturbation_norm_values"].append(delta_norm.detach()) _state["relative_perturbation_norm_values"].append( (delta_norm / base_norm.clamp_min(1e-12)).detach() ) if _state["mode"] in {"constant", "dynamic", "donor"}: result[row] = yf[row] + delta _state["active_positions"] += 1 shaped = result.reshape_as(y) if isinstance(output, tuple): return (shaped, *output[1:]) return shaped handle = module.register_forward_hook(hook) module._modelclinic_e001d_handle = handle module._modelclinic_e001d_state = state installed.append({"module": name, "layer": layer, "mode": mode}) except Exception: remove_controller_hooks(model) raise return installed def read_controller_stats(model) -> dict: result = {} tensor_fields = { "gate_scalar_values": "gate_scalar", "donor_scalar_values": "donor_scalar", "perturbation_norm_values": "perturbation_norm", "base_output_norm_values": "base_output_norm", "relative_perturbation_norm_values": "relative_perturbation_norm", } for _name, module in model.named_modules(): state = getattr(module, "_modelclinic_e001d_state", None) if state is None: continue row = {} for key, value in state.items(): if key in {"direction", "gate_vector", "edited_weight"} or key in tensor_fields: continue row[key] = value for source_key, output_key in tensor_fields.items(): values = state[source_key] if values: row[output_key] = torch.stack(values).detach().float().cpu().tolist() else: row[output_key] = [] result[str(state["layer"])] = row return result def remove_controller_hooks(model) -> list[str]: removed = [] for name, module in model.named_modules(): handle = getattr(module, "_modelclinic_e001d_handle", None) if handle is None: continue handle.remove() delattr(module, "_modelclinic_e001d_handle") delattr(module, "_modelclinic_e001d_state") removed.append(name) return removed