src/forward_cache.py

"""Forward-pass cache shared by all cross-interaction features.

A single forward pass populates ``ForwardCache``; subsequent features read
from it without re-running the model. Captures:

- hidden_states[l]   for l in 0..L      (L+1 tensors, pre-LN residual)
- ln_inputs[l]       for l in 0..L-1    (input to attention LayerNorm at layer l)
- attn_weights[l]    for l in 0..L-1    (B, H, T, T)
- attn_outputs[l]    for l in 0..L-1    (B, T, H*Dh) raw before W_O
- mlp_pre_act[l]     for l in 0..L-1    (B, T, 4*D)  W_up @ LN(h)
- mlp_post_act[l]    for l in 0..L-1    (B, T, 4*D)  activation
- mlp_out[l]         for l in 0..L-1    (B, T, D)    W_down @ post_act
- head_writes[l]     for l in 0..L-1    (B, H, T, D) per-head contribution after W_O
- logits             (B, C)

Compatible with HuggingFace RoBERTa / ELECTRA encoder layouts:
  model.encoder.layer[l].attention.self
  model.encoder.layer[l].attention.output.dense          (W_O)
  model.encoder.layer[l].attention.output.LayerNorm      (post-attn LN)
  model.encoder.layer[l].intermediate.dense              (W_up)
  model.encoder.layer[l].intermediate.intermediate_act_fn
  model.encoder.layer[l].output.dense                    (W_down)
  model.encoder.layer[l].output.LayerNorm                (post-MLP LN)
"""
from __future__ import annotations

from dataclasses import dataclass, field
from typing import List, Optional

import torch
import torch.nn as nn


@dataclass
class ForwardCache:
    """Container for activations captured during a single forward pass."""
    hidden_states:   List[torch.Tensor] = field(default_factory=list)
    ln_inputs:       List[torch.Tensor] = field(default_factory=list)
    attn_weights:    List[torch.Tensor] = field(default_factory=list)
    attn_outputs:    List[torch.Tensor] = field(default_factory=list)
    mlp_pre_act:     List[torch.Tensor] = field(default_factory=list)
    mlp_post_act:    List[torch.Tensor] = field(default_factory=list)
    mlp_out:         List[torch.Tensor] = field(default_factory=list)
    head_writes:     List[torch.Tensor] = field(default_factory=list)
    logits:          Optional[torch.Tensor] = None
    # Per-layer LN params (gain/bias) — useful for LN-decomposition (LGAP)
    ln_gain:         List[torch.Tensor] = field(default_factory=list)
    ln_bias:         List[torch.Tensor] = field(default_factory=list)


def _find_encoder_layers(model: nn.Module) -> List[nn.Module]:
    """Locate the transformer encoder layer list for RoBERTa / ELECTRA."""
    if hasattr(model, "roberta"):
        return model.roberta.encoder.layer
    if hasattr(model, "electra"):
        return model.electra.encoder.layer
    if hasattr(model, "encoder") and hasattr(model.encoder, "layer"):
        return model.encoder.layer
    raise ValueError(f"Could not locate encoder layers in {type(model).__name__}")


def _attn_layout(layer: nn.Module):
    """Return (attention_self, attention_output_dense, attention_output_LN)."""
    return (layer.attention.self,
            layer.attention.output.dense,
            layer.attention.output.LayerNorm)


def _mlp_layout(layer: nn.Module):
    """Return (intermediate.dense, intermediate.intermediate_act_fn,
              output.dense, output.LayerNorm)."""
    return (layer.intermediate.dense,
            layer.intermediate.intermediate_act_fn,
            layer.output.dense,
            layer.output.LayerNorm)


@torch.no_grad()
def run_with_hooks(model: nn.Module,
                    input_ids: torch.Tensor,
                    attention_mask: torch.Tensor) -> ForwardCache:
    """Run a single forward pass, capturing activations into ForwardCache.

    The model is put in eval mode; gradients are disabled.
    """
    cache = ForwardCache()
    layers = _find_encoder_layers(model)
    L = len(layers)
    H = layers[0].attention.self.num_attention_heads
    Dh = layers[0].attention.self.attention_head_size

    handles = []

    # ---- Per-layer hooks --------------------------------------------------
    def make_attn_inp_hook(idx):
        def hook(module, inputs, output):
            # input[0] to attention.self is the post-LN normalised hidden state
            x = inputs[0].detach()
            while len(cache.ln_inputs) <= idx: cache.ln_inputs.append(None)
            cache.ln_inputs[idx] = x
        return hook

    def make_attn_self_hook(idx):
        def hook(module, inputs, output):
            # output: (context_layer, [attention_probs]) or context_layer
            if isinstance(output, tuple):
                ctx = output[0]
                # attention_probs are returned when output_attentions=True
                if len(output) > 1 and isinstance(output[1], torch.Tensor):
                    while len(cache.attn_weights) <= idx: cache.attn_weights.append(None)
                    cache.attn_weights[idx] = output[1].detach()
            else:
                ctx = output
            # ctx shape: (B, T, H*Dh)
            while len(cache.attn_outputs) <= idx: cache.attn_outputs.append(None)
            cache.attn_outputs[idx] = ctx.detach()
        return hook

    def make_int_hook(idx):
        def hook(module, inputs, output):
            # intermediate.dense output = W_up @ LN(h); pre activation
            while len(cache.mlp_pre_act) <= idx: cache.mlp_pre_act.append(None)
            cache.mlp_pre_act[idx] = output.detach()
        return hook

    def make_act_hook(idx):
        def hook(module, inputs, output):
            while len(cache.mlp_post_act) <= idx: cache.mlp_post_act.append(None)
            cache.mlp_post_act[idx] = output.detach()
        return hook

    def make_outdense_hook(idx):
        def hook(module, inputs, output):
            # output.dense projects post_act -> D
            while len(cache.mlp_out) <= idx: cache.mlp_out.append(None)
            cache.mlp_out[idx] = output.detach()
        return hook

    def make_post_attn_ln_hook(idx):
        def hook(module, inputs, output):
            # Capture the LayerNorm gain/bias and the input
            gain = module.weight.detach()
            bias = module.bias.detach()
            while len(cache.ln_gain) <= idx: cache.ln_gain.append(None)
            while len(cache.ln_bias) <= idx: cache.ln_bias.append(None)
            cache.ln_gain[idx] = gain
            cache.ln_bias[idx] = bias
        return hook

    for l, layer in enumerate(layers):
        attn_self, attn_dense, attn_LN = _attn_layout(layer)
        int_dense, act_fn, out_dense, out_LN = _mlp_layout(layer)
        handles.append(attn_self.register_forward_hook(make_attn_inp_hook(l)))
        handles.append(attn_self.register_forward_hook(make_attn_self_hook(l)))
        handles.append(int_dense.register_forward_hook(make_int_hook(l)))
        handles.append(act_fn.register_forward_hook(make_act_hook(l)))
        handles.append(out_dense.register_forward_hook(make_outdense_hook(l)))
        handles.append(attn_LN.register_forward_hook(make_post_attn_ln_hook(l)))

    try:
        model.eval()
        out = model(input_ids=input_ids,
                    attention_mask=attention_mask,
                    output_hidden_states=True,
                    output_attentions=True,
                    return_dict=True)
        cache.hidden_states = [h.detach() for h in out.hidden_states]
        # Some HF heads return attentions even when not hooked
        if hasattr(out, "attentions") and out.attentions is not None and not cache.attn_weights:
            cache.attn_weights = [a.detach() for a in out.attentions]
        cache.logits = out.logits.detach()
    finally:
        for h in handles:
            h.remove()

    # ---- Derived: head_writes -------------------------------------------
    # head_writes[l][b, h, t, :] = W_O_slice_h @ attn_outputs[l][b, t, h*Dh:(h+1)*Dh]
    for l, layer in enumerate(layers):
        attn_out = cache.attn_outputs[l]                       # (B, T, H*Dh)
        _, attn_dense, _ = _attn_layout(layer)
        W_O = attn_dense.weight.detach()                       # (D, H*Dh)
        b_O = attn_dense.bias.detach() if attn_dense.bias is not None else None
        B, T, _ = attn_out.shape
        D = W_O.shape[0]
        attn_h = attn_out.view(B, T, H, Dh)                    # (B, T, H, Dh)
        W_h = W_O.view(D, H, Dh).permute(1, 0, 2)              # (H, D, Dh)
        # head_writes[b, h, t, :] = sum_d (attn_h[b, t, h, d] * W_h[h, :, d])
        # = einsum("bthd, hpd -> bhtp", attn_h, W_h)
        hw = torch.einsum("bthd, hpd -> bhtp", attn_h, W_h)    # (B, H, T, D)
        cache.head_writes.append(hw)

    return cache