Download code/src/experiment_001d_runtime.py from PratikBuilds/modelclinic-experiment-001: direct link, hf CLI and curl.
- Browser
- Download file 10.9 kB
-
https://huggingface.co/datasets/PratikBuilds/modelclinic-experiment-001/resolve/main/code/src/experiment_001d_runtime.py
- Command line
-
hf download hf://datasets/PratikBuilds/modelclinic-experiment-001/code/src/experiment_001d_runtime.py
-
curl -L -o experiment_001d_runtime.py https://huggingface.co/datasets/PratikBuilds/modelclinic-experiment-001/resolve/main/code/src/experiment_001d_runtime.py
10.9 kB
| """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 | |