File size: 23,096 Bytes
87cc7f2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
"""Utilities for signed constant and approximate rank-one layer controls.



For a weight edit ``delta`` with shape ``[out_features, in_features]``, the

best rank-one SVD approximation is ``u @ gate_vector.T``. At the edited

linear's output, it produces the activation-dependent update

``(x @ gate_vector) * u``. A signed constant controller instead adds

``coefficient * u`` at every token.

"""

from __future__ import annotations

from itertools import product
import math
from typing import Iterable, Mapping, Sequence

import torch
import torch.nn.functional as F


def _as_delta(delta: torch.Tensor) -> torch.Tensor:
    if not torch.is_tensor(delta) or delta.ndim != 2:
        raise ValueError("delta must be a 2D [out_features, in_features] tensor")
    delta = delta.to(dtype=torch.float32)
    if delta.numel() == 0 or not torch.isfinite(delta).all():
        raise ValueError("delta must be non-empty and finite")
    if torch.linalg.vector_norm(delta) == 0:
        raise ValueError("delta must be non-zero")
    return delta


def _canonicalize(direction: torch.Tensor, paired: torch.Tensor | None = None):
    """Fix the SVD sign ambiguity by making the largest-magnitude entry positive."""
    pivot = int(direction.abs().argmax().item())
    if direction[pivot] < 0:
        direction = -direction
        if paired is not None:
            paired = -paired
    return direction, paired


def decompose(delta: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
    """Return canonical unit left direction and scaled right gate vector.



    The returned vectors satisfy ``u @ v.T == best_rank_one(delta)`` up to

    floating-point error, where ``u`` has shape ``[out]`` and ``v`` has shape

    ``[in]``. The sign convention makes serialized directions reproducible

    across repeated decompositions of the same tensor.

    """
    delta = _as_delta(delta)
    left, singular_values, right = torch.linalg.svd(delta, full_matrices=False)
    direction = left[:, 0]
    gate_vector = singular_values[0] * right[0, :]
    direction, gate_vector = _canonicalize(direction, gate_vector)
    return direction, gate_vector


def _as_activations(activations: torch.Tensor, in_features: int, device) -> torch.Tensor:
    if not torch.is_tensor(activations) or activations.ndim < 1:
        raise ValueError("activations must be a tensor with in_features in its last dimension")
    if activations.shape[-1] != in_features:
        raise ValueError(
            f"activation width mismatch: expected {in_features}, got {activations.shape[-1]}"
        )
    flat = activations.to(device=device, dtype=torch.float32).reshape(-1, in_features)
    if flat.shape[0] == 0 or not torch.isfinite(flat).all():
        raise ValueError("activations must contain at least one finite position")
    return flat


def _as_activation_groups(activations, in_features: int, device) -> list[torch.Tensor]:
    """Normalize a tensor or one tensor per prompt to flattened activation rows."""
    if torch.is_tensor(activations):
        raw_groups = [activations]
    elif isinstance(activations, (list, tuple)) and activations:
        raw_groups = list(activations)
    else:
        raise ValueError("activations must be a tensor or a non-empty list of prompt tensors")
    return [_as_activations(group, in_features, device) for group in raw_groups]


def _weighted_mean(values: Sequence[torch.Tensor], prompt_weighting: str) -> torch.Tensor:
    if prompt_weighting == "token":
        return torch.cat([value.reshape(-1) for value in values]).mean()
    if prompt_weighting == "prompt":
        return torch.stack([value.reshape(-1).mean() for value in values]).mean()
    raise ValueError("prompt_weighting must be 'token' or 'prompt'")


def fit_signed_constant(

    delta: torch.Tensor,

    activations,

    direction: torch.Tensor | None = None,

    *,

    prompt_weighting: str = "token",

) -> tuple[torch.Tensor, float]:
    """Fit the signed least-squares constant along an output direction.



    ``activations`` may be one tensor with any leading dimensions or one tensor

    per prompt; each must end in the input width of ``delta``. ``prompt_weighting``

    is ``"token"`` for a pooled token mean or ``"prompt"`` for an equal mean of

    per-prompt gate means. If ``direction`` is omitted, the canonical leading

    left singular vector is used. The direction is normalized and sign-fixed;

    the returned coefficient is the mean scalar projection of ``delta @ x``

    onto that direction. This minimizes summed squared error among constant

    updates constrained to the selected direction.

    """
    delta = _as_delta(delta)
    if direction is None:
        direction, _ = decompose(delta)
    else:
        if not torch.is_tensor(direction) or direction.ndim != 1:
            raise ValueError("direction must be a 1D output vector")
        direction = direction.to(device=delta.device, dtype=torch.float32)
        if direction.shape[0] != delta.shape[0]:
            raise ValueError(
                f"direction width mismatch: expected {delta.shape[0]}, got {direction.shape[0]}"
            )
        norm = torch.linalg.vector_norm(direction)
        if not torch.isfinite(norm) or norm == 0:
            raise ValueError("direction must be finite and non-zero")
        direction = direction / norm
        direction, _ = _canonicalize(direction)

    groups = _as_activation_groups(activations, delta.shape[1], delta.device)
    projections = [F.linear(group, delta) @ direction for group in groups]
    mean = _weighted_mean(projections, prompt_weighting)
    return direction, float(mean.item())


def signed_projection_rms(

    delta: torch.Tensor,

    activations,

    direction: torch.Tensor,

    *,

    prompt_weighting: str = "token",

) -> float:
    """Return RMS signed projection of the edit effect along ``direction``."""
    delta = _as_delta(delta)
    if not torch.is_tensor(direction) or direction.ndim != 1:
        raise ValueError("direction must be a 1D output vector")
    direction = direction.to(device=delta.device, dtype=torch.float32)
    if direction.shape[0] != delta.shape[0]:
        raise ValueError("direction width mismatch")
    norm = torch.linalg.vector_norm(direction)
    if not torch.isfinite(norm) or norm == 0:
        raise ValueError("direction must be finite and non-zero")
    direction = direction / norm
    direction, _ = _canonicalize(direction)
    groups = _as_activation_groups(activations, delta.shape[1], delta.device)
    projections = [F.linear(group, delta) @ direction for group in groups]
    return float(_weighted_mean([value.square() for value in projections], prompt_weighting).sqrt().item())


def coefficient_grid(

    projection_rms: float,

    multipliers: Iterable[float] = (-2.0, -1.0, 0.0, 1.0, 2.0),

) -> list[float]:
    """Build a symmetric signed candidate grid scaled to a layer's edit effect."""
    scale = float(projection_rms)
    if not math.isfinite(scale) or scale < 0:
        raise ValueError("projection_rms must be finite and non-negative")
    factors = [float(value) for value in multipliers]
    if not factors or any(not math.isfinite(value) for value in factors):
        raise ValueError("multipliers must contain finite values")
    return sorted({scale * factor for factor in factors})


def calibrate_layer(

    delta: torch.Tensor,

    activations,

    *,

    grid_multipliers: Iterable[float] = (-2.0, -1.0, 0.0, 1.0, 2.0),

    prompt_weighting: str = "token",

) -> dict:
    """Return JSON-safe factors and descriptive calibration metrics for a layer."""
    delta = _as_delta(delta)
    direction, gate_vector = decompose(delta)
    summary = calibrate_direction(
        delta,
        activations,
        direction,
        grid_multipliers=grid_multipliers,
        prompt_weighting=prompt_weighting,
    )
    summary["rank1_energy_fraction"] = summary.pop("direction_energy_fraction")
    summary["rank1_gate_vector"] = gate_vector.cpu().tolist()
    return summary


def calibrate_direction(

    delta: torch.Tensor,

    activations,

    direction: torch.Tensor,

    *,

    grid_multipliers: Iterable[float] = (-2.0, -1.0, 0.0, 1.0, 2.0),

    prompt_weighting: str = "token",

) -> dict:
    """Calibrate any fixed direction against edit effects on disjoint activations.



    This supports independent or random control directions as well as the

    published edit's leading singular direction. The signed mean and RMS are

    projections of the exact weight-edit effect onto the supplied unit

    direction; no direction is inferred from ``delta`` here.

    """
    delta = _as_delta(delta)
    if not torch.is_tensor(direction) or direction.ndim != 1:
        raise ValueError("direction must be a 1D output vector")
    direction = direction.to(device=delta.device, dtype=torch.float32)
    if direction.shape[0] != delta.shape[0]:
        raise ValueError("direction width mismatch")
    norm = torch.linalg.vector_norm(direction)
    if not torch.isfinite(norm) or norm == 0:
        raise ValueError("direction must be finite and non-zero")
    direction = direction / norm
    direction, _ = _canonicalize(direction)

    groups = _as_activation_groups(activations, delta.shape[1], delta.device)
    effects = [F.linear(group, delta) for group in groups]
    projections = [effect @ direction for effect in effects]
    energy = _weighted_mean([effect.square().sum(dim=-1) for effect in effects], prompt_weighting)
    if energy == 0:
        raise ValueError("calibration activations produce a zero edit effect")
    mean_coefficient = _weighted_mean(projections, prompt_weighting)
    rank_one_residual = [effect - projection.unsqueeze(-1) * direction
                         for effect, projection in zip(effects, projections)]
    constant_residual = [effect - mean_coefficient * direction for effect in effects]
    rank_one_residual_energy = _weighted_mean(
        [residual.square().sum(dim=-1) for residual in rank_one_residual], prompt_weighting
    )
    constant_residual_energy = _weighted_mean(
        [residual.square().sum(dim=-1) for residual in constant_residual], prompt_weighting
    )
    projection_rms = _weighted_mean([projection.square() for projection in projections], prompt_weighting).sqrt()
    return {
        "direction": direction.cpu().tolist(),
        "signed_mean_coefficient": float(mean_coefficient.item()),
        "projection_rms": float(projection_rms.item()),
        "edit_effect_rms": float(energy.sqrt().item()),
        "direction_energy_fraction": float((1.0 - rank_one_residual_energy / energy).item()),
        "constant_residual_energy_fraction": float((constant_residual_energy / energy).item()),
        "coefficient_grid": coefficient_grid(float(projection_rms.item()), grid_multipliers),
        "activation_tokens": int(sum(group.shape[0] for group in groups)),
        "calibration_prompts": int(len(groups)),
        "prompt_weighting": prompt_weighting,
    }


def controller_grid(

    projection_rms_by_layer: Mapping[str | int, float],

    multipliers: Iterable[float] = (-2.0, -1.0, 0.0, 1.0, 2.0),

) -> list[dict[str, float]]:
    """Enumerate a Cartesian grid with separately tunable coefficient per layer."""
    ordered = [(str(layer), coefficient_grid(rms, multipliers))
               for layer, rms in projection_rms_by_layer.items()]
    if not ordered:
        raise ValueError("at least one layer scale is required")
    return [dict(zip((layer for layer, _ in ordered), values))
            for values in product(*(grid for _, grid in ordered))]


def select_behavioral_controller(

    grid_results: Sequence[Mapping],

    signed_mean_by_layer: Mapping[str | int, float],

    *,

    score_key: str = "correct",

) -> dict:
    """Select the highest-scoring grid row, with stable prespecified tie-breaks.



    Each result must contain ``coefficients`` (a per-layer mapping) and a

    numeric behavioral score such as the number of calibration answers graded

    correct. Ties prefer coefficients closest in squared distance to the signed

    mean fit, then the smallest coefficient norm, then lexicographic order.

    Callers should retain every grid row and prompt-level score in the manifest.

    """
    if not grid_results:
        raise ValueError("grid_results must contain at least one scored row")
    mean = {str(layer): float(value) for layer, value in signed_mean_by_layer.items()}
    if not mean or any(not math.isfinite(value) for value in mean.values()):
        raise ValueError("signed_mean_by_layer must contain finite coefficients")

    candidates = []
    for row in grid_results:
        if "coefficients" not in row or score_key not in row:
            raise ValueError(f"each grid result needs coefficients and {score_key!r}")
        coefficients = {str(layer): float(value) for layer, value in row["coefficients"].items()}
        if set(coefficients) != set(mean):
            raise ValueError("grid result layers do not match signed_mean_by_layer")
        score = float(row[score_key])
        if not math.isfinite(score) or any(not math.isfinite(value) for value in coefficients.values()):
            raise ValueError("grid scores and coefficients must be finite")
        distance = sum((coefficients[layer] - mean[layer]) ** 2 for layer in mean)
        magnitude = sum(value * value for value in coefficients.values())
        stable = tuple(coefficients[layer] for layer in sorted(coefficients))
        candidates.append((-score, distance, magnitude, stable, dict(row)))
    return min(candidates, key=lambda item: item[:4])[-1]


def adjustment(

    x: torch.Tensor,

    direction: torch.Tensor,

    gate_vector: torch.Tensor | None = None,

    coefficient: float | torch.Tensor | None = None,

) -> torch.Tensor:
    """Compute a constant or activation-gated output update.



    ``gate_vector`` selects the approximate rank-one update ``(x @ v) * u``.

    Otherwise ``coefficient`` selects the constant ``coefficient * u``. A

    per-position coefficient tensor may match all leading dimensions of ``x``.

    """
    if not torch.is_tensor(x) or x.ndim < 1:
        raise ValueError("x must be a tensor with a feature dimension")
    if not torch.is_tensor(direction) or direction.ndim != 1:
        raise ValueError("direction must be a 1D output vector")
    u = direction.to(device=x.device, dtype=torch.float32)
    if not torch.isfinite(u).all() or torch.linalg.vector_norm(u) == 0:
        raise ValueError("direction must be finite and non-zero")
    if gate_vector is not None:
        if coefficient is not None:
            raise ValueError("provide either gate_vector or coefficient, not both")
        if not torch.is_tensor(gate_vector) or gate_vector.ndim != 1:
            raise ValueError("gate_vector must be a 1D input vector")
        if gate_vector.shape[0] != x.shape[-1]:
            raise ValueError("gate_vector width mismatch")
        if not torch.isfinite(gate_vector).all():
            raise ValueError("gate_vector must be finite")
        gate = F.linear(
            x.to(dtype=torch.float32),
            gate_vector.to(device=x.device, dtype=torch.float32).unsqueeze(0),
        )
        update = gate * u
    else:
        if coefficient is None:
            raise ValueError("a gate_vector or coefficient is required")
        gate = torch.as_tensor(coefficient, device=x.device, dtype=torch.float32)
        if not torch.isfinite(gate).all():
            raise ValueError("coefficient must be finite")
        if gate.ndim == x.ndim - 1:
            gate = gate.unsqueeze(-1)
        update = gate * u
    try:
        update = torch.broadcast_to(update, (*x.shape[:-1], u.numel()))
    except RuntimeError as exc:
        raise ValueError("coefficient shape is not broadcastable to output positions") from exc
    return update.to(dtype=x.dtype)


def make_output_hook(

    direction: torch.Tensor,

    *,

    coefficient: float | None = None,

    gate_vector: torch.Tensor | None = None,

    state: dict | None = None,

):
    """Build a forward hook with controller validation done once at install.



    Runtime calls retain Python-side tensor and shape guards, but reuse validated

    controller tensors and avoid GPU-to-CPU scalar checks such as ``isfinite``

    and vector-norm reductions on every token.

    """
    if (coefficient is None) == (gate_vector is None):
        raise ValueError("provide exactly one of coefficient or gate_vector")
    if not torch.is_tensor(direction) or direction.ndim != 1:
        raise ValueError("direction must be a 1D output vector")
    direction = direction.to(dtype=torch.float32)
    if not torch.isfinite(direction).all() or torch.linalg.vector_norm(direction) == 0:
        raise ValueError("direction must be finite and non-zero")
    scale = None
    if gate_vector is None:
        scale = float(coefficient)
        if not math.isfinite(scale):
            raise ValueError("coefficient must be finite")
    else:
        if not torch.is_tensor(gate_vector) or gate_vector.ndim != 1:
            raise ValueError("gate_vector must be a 1D input vector")
        gate_vector = gate_vector.to(dtype=torch.float32)
        if not torch.isfinite(gate_vector).all():
            raise ValueError("gate_vector must be finite")
    if state is None:
        state = {}
    device_cache = {}
    constant_dtype_cache = {}

    def on_device(device):
        key = (device.type, device.index)
        if key not in device_cache:
            u = direction.to(device=device, dtype=torch.float32)
            v = gate_vector.to(device=device, dtype=torch.float32) if gate_vector is not None else None
            constant = u * scale if v is None else None
            device_cache[key] = (u, v, constant)
        return device_cache[key]

    def hook(_module, args, output):
        if not args:
            raise ValueError("down-projection hook received no input")
        x = args[0]
        if not torch.is_tensor(x) or x.ndim < 1:
            raise ValueError("down-projection input must be a tensor with a feature dimension")
        target = output[0] if isinstance(output, tuple) else output
        if not torch.is_tensor(target):
            raise TypeError(f"unsupported hook output type: {type(target)}")
        u, v, constant = on_device(x.device)
        if target.ndim < 1 or target.shape[-1] != u.numel():
            raise ValueError("output width does not match direction")
        if tuple(x.shape[:-1]) != tuple(target.shape[:-1]):
            raise ValueError("input and output leading dimensions do not match")
        if v is None:
            key = (target.device.type, target.device.index, target.dtype, x.dtype)
            if key not in constant_dtype_cache:
                constant_dtype_cache[key] = constant.to(device=target.device, dtype=x.dtype)
            delta = constant_dtype_cache[key].expand(*x.shape[:-1], u.numel())
        else:
            if x.shape[-1] != v.numel():
                raise ValueError("input width does not match gate_vector")
            gate = F.linear(x.to(dtype=torch.float32), v.unsqueeze(0))
            delta = (gate * u).to(dtype=x.dtype)
        if delta.shape != target.shape:
            raise ValueError(f"update shape {tuple(delta.shape)} != output shape {tuple(target.shape)}")
        state["calls"] = state.get("calls", 0) + 1
        steered = target + delta.to(device=target.device, dtype=target.dtype)
        if isinstance(output, tuple):
            return (steered, *output[1:])
        return steered

    return hook


def install_vllm_hooks(model, specs: Sequence[Mapping]) -> list[dict]:
    """Install per-layer constant or rank-one hooks on Qwen-style down projections.



    Each spec has ``layer`` and ``direction``, plus exactly one of ``coefficient``

    or ``gate_vector``. This is designed for use inside a trusted

    ``LLM.apply_model`` callback; it does not depend on vLLM imports itself.

    """
    installed = []
    try:
        for spec in specs:
            if "layer" not in spec or "direction" not in spec:
                raise ValueError("each spec needs a layer and direction")
            if ("coefficient" in spec) == ("gate_vector" in spec):
                raise ValueError("each spec needs exactly one of coefficient or gate_vector")
            layer = int(spec["layer"])
            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]}")
            name, module = matches[0]
            if hasattr(module, "_modelclinic_controller_handle"):
                raise RuntimeError(f"a ModelClinic controller is already installed on {name}")
            device = module.weight.device if hasattr(module, "weight") else None
            direction = torch.as_tensor(spec["direction"], device=device, dtype=torch.float32)
            state = {"calls": 0}
            if "gate_vector" in spec:
                gate_vector = torch.as_tensor(spec["gate_vector"], device=device, dtype=torch.float32)
                hook = make_output_hook(direction, gate_vector=gate_vector, state=state)
                mode = "rank1"
            else:
                hook = make_output_hook(
                    direction, coefficient=float(spec["coefficient"]), state=state
                )
                mode = "constant"
            handle = module.register_forward_hook(hook)
            module._modelclinic_controller_handle = handle
            module._modelclinic_controller_state = state
            installed.append({"module": name, "layer": layer, "mode": mode})
    except Exception:
        remove_vllm_hooks(model)
        raise
    return installed


def read_vllm_hook_stats(model) -> dict:
    """Read call counts for installed ModelClinic vLLM hooks."""
    return {
        name: dict(module._modelclinic_controller_state)
        for name, module in model.named_modules()
        if hasattr(module, "_modelclinic_controller_state")
    }


def remove_vllm_hooks(model) -> list[str]:
    """Remove installed ModelClinic hooks and clear their temporary attributes."""
    removed = []
    for name, module in model.named_modules():
        handle = getattr(module, "_modelclinic_controller_handle", None)
        if handle is None:
            continue
        handle.remove()
        delattr(module, "_modelclinic_controller_handle")
        delattr(module, "_modelclinic_controller_state")
        removed.append(name)
    return removed