Emit per-layer top-K SwiGLU intermediate activations for RQ1 Step 5

Adds a forward hook on Mistral/LLaMA-style FFN modules that captures
the top-K (=32) hidden neurons of `silu(W_gate · x) ⊙ (W_up · x)` at
the predicting (last) position for each generation step. Stored on
each layer entry as `ffn_top_neurons: { k, intermediate_size,
neurons: [{idx, value}] }`.

Memory-bounded: top-32 of 14,336 ≈ 256 bytes per layer per step,
versus the 57KB-per-layer-per-step the full intermediate vector
would require. The top-K is what the RQ1 frontend's "Behind the
SwiGLU" disclosure needs to render an honest per-neuron view rather
than synthesising activations or showing only summary stats.

Only registers on layers exposing both `gate_proj` and `up_proj`
(SwiGLU); other architectures fall back to the existing
`gate_stats` / `mlp_output_norm` / `ffn_contribution` summary
fields.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

backend/model_service.py

@@ -2921,6 +2921,16 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
             attn_output_norms = {}
             mlp_output_norms = {}
             gate_activation_stats = {}
+            # Per-layer top-K SwiGLU intermediate activations at the
+            # predicting position (last token of the current forward
+            # pass). Each entry is a list of {idx, value} for the
+            # top-K neurons by |silu(W_g·x) ⊙ (W_u·x)| at that layer
+            # for that step. Powers RQ1 Step 5's "Behind the SwiGLU"
+            # per-neuron view without storing the full 14,336-d
+            # vector — bounded memory, full transparency for the
+            # most-loaded neurons.
+            ffn_top_neurons = {}
+            FFN_TOPK = 32
 
             def make_attn_output_hook(layer_idx):
                 def hook(module, input, output):
@@ -2965,6 +2975,63 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                         pass
                 return hook
 
+            def make_ffn_top_neurons_hook(layer_idx):
+                """
+                Capture the top-K of the SwiGLU intermediate activation
+                vector at the predicting (last) position for this layer.
+
+                Computes silu(W_gate · x) ⊙ (W_up · x) — the same
+                14,336-d intermediate that gets fed to W_down. Storing
+                only the top-K (=32) by |value| keeps memory bounded:
+                32 × {idx:int, value:float} ≈ 256 bytes per layer per
+                step, vs 14,336 × 4 bytes = 57KB per layer per step
+                if we stored the full vector. The top-K is what a
+                developer reads anyway (the rest are noise) and the
+                stored neuron index lets the frontend label "neuron
+                8421 dominated this token at L37".
+
+                Only fires for SwiGLU layers (gate_proj + up_proj
+                present); other architectures are skipped at
+                registration time.
+                """
+                def hook(module, input, output):
+                    try:
+                        inp = input[0] if isinstance(input, tuple) else input
+                        if inp.dim() == 3:
+                            inp = inp[0, -1]  # last (predicting) token
+                        elif inp.dim() == 2:
+                            inp = inp[-1]
+                        if hasattr(module, 'gate_proj') and hasattr(module, 'up_proj'):
+                            gate_out = torch.nn.functional.silu(
+                                module.gate_proj(inp)
+                            )
+                            up_out = module.up_proj(inp)
+                            intermediate = gate_out * up_out
+                            abs_inter = intermediate.abs()
+                            k = min(FFN_TOPK, intermediate.shape[-1])
+                            top_vals, top_idx = torch.topk(abs_inter, k=k)
+                            # Use the signed values (not abs) so the
+                            # frontend can render direction; abs only
+                            # drove the ranking.
+                            signed = intermediate[top_idx]
+                            ffn_top_neurons[layer_idx] = {
+                                "k": k,
+                                "intermediate_size": int(intermediate.shape[-1]),
+                                "neurons": [
+                                    {
+                                        "idx": int(i),
+                                        "value": round(float(v), 4),
+                                    }
+                                    for i, v in zip(
+                                        top_idx.cpu().tolist(),
+                                        signed.cpu().tolist(),
+                                    )
+                                ],
+                            }
+                    except Exception:
+                        pass
+                return hook
+
             # Cache for decoded token texts (reused across heads within a step)
             step_token_texts_cache: Dict[str, Any] = {}
 
@@ -2996,6 +3063,14 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                                 hooks.append(hook)
                                 if layer_idx == 0:
                                     ffn_type = "swiglu"
+                            # FFN top-K intermediate hook — needs both
+                            # gate_proj and up_proj to compute the
+                            # SwiGLU intermediate vector.
+                            if hasattr(layer.mlp, 'gate_proj') and hasattr(layer.mlp, 'up_proj'):
+                                hook = layer.mlp.register_forward_hook(
+                                    make_ffn_top_neurons_hook(layer_idx)
+                                )
+                                hooks.append(hook)
                 logger.info(f"Registered attn/MLP output hooks for contribution tracking (ffn_type={ffn_type})")
             except Exception as hook_error:
                 logger.warning(f"Could not register attn/MLP hooks: {hook_error}")
@@ -3017,6 +3092,7 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                     attn_output_norms.clear()
                     mlp_output_norms.clear()
                     gate_activation_stats.clear()
+                    ffn_top_neurons.clear()
 
                     # Forward pass with full outputs
                     outputs = manager.model(
@@ -3585,6 +3661,17 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                                 layer_entry["ffn_contribution"] = round(mlp_n / total, 4)
                         if layer_idx in gate_activation_stats:
                             layer_entry["gate_stats"] = gate_activation_stats[layer_idx]
+                        if layer_idx in ffn_top_neurons:
+                            # `ffn_top_neurons` holds top-K SwiGLU
+                            # intermediate activations at the
+                            # predicting position — see
+                            # make_ffn_top_neurons_hook for the
+                            # per-neuron value semantics. The frontend
+                            # uses this to render Step 5's per-neuron
+                            # bar chart inside "Behind the SwiGLU"
+                            # without the backend needing a separate
+                            # endpoint or a 14,336-d cache entry.
+                            layer_entry["ffn_top_neurons"] = ffn_top_neurons[layer_idx]
 
                         # Phase 5: Logit lens at sampled layers (every 8th layer)
                         logit_lens_stride = max(1, n_layers // 5)