Add FFN contribution metrics and gate activation stats to research endpoint

- Compute attn_contribution/ffn_contribution ratios from existing
attention and MLP output norm hooks (no new forward passes needed)
- Add gate activation hook for SwiGLU models (LLaMA/Mistral) capturing
sparsity, mean, and max of gate values per layer per token
- Expose ffnType and intermediateSize in modelInfo response
- Clear gate_activation_stats each generation step alongside existing dicts

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

backend/model_service.py

@@ -2663,9 +2663,10 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
             except Exception as hook_error:
                 logger.warning(f"Could not register QKV hooks: {hook_error}")
 
-            # Phase 4: Hooks for attention and MLP output norms
+            # Phase 4: Hooks for attention and MLP output norms + gate activation stats
             attn_output_norms = {}
             mlp_output_norms = {}
+            gate_activation_stats = {}
 
             def make_attn_output_hook(layer_idx):
                 def hook(module, input, output):
@@ -2689,6 +2690,30 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                         pass
                 return hook
 
+            def make_gate_hook(layer_idx):
+                """Capture gate activation stats for SwiGLU FFN (LLaMA/Mistral)."""
+                def hook(module, input, output):
+                    try:
+                        inp = input[0] if isinstance(input, tuple) else input
+                        if inp.dim() == 3:
+                            inp = inp[0, -1]  # last token
+                        elif inp.dim() == 2:
+                            inp = inp[-1]
+                        if hasattr(module, 'gate_proj'):
+                            gate_out = torch.nn.functional.silu(module.gate_proj(inp))
+                            abs_gate = gate_out.abs()
+                            gate_activation_stats[layer_idx] = {
+                                "sparsity": round(float((abs_gate < 0.01).float().mean().item()), 4),
+                                "mean": round(float(gate_out.mean().item()), 4),
+                                "max": round(float(gate_out.max().item()), 4),
+                            }
+                    except Exception:
+                        pass
+                return hook
+
+            # Detect FFN type from first layer
+            ffn_type = "gelu"  # default
+
             try:
                 # CodeGen style
                 if hasattr(manager.model, 'transformer') and hasattr(manager.model.transformer, 'h'):
@@ -2708,7 +2733,13 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                         if hasattr(layer, 'mlp'):
                             hook = layer.mlp.register_forward_hook(make_mlp_output_hook(layer_idx))
                             hooks.append(hook)
-                logger.info(f"Registered attn/MLP output hooks for contribution tracking")
+                            # Gate hook for SwiGLU models
+                            if hasattr(layer.mlp, 'gate_proj'):
+                                hook = layer.mlp.register_forward_hook(make_gate_hook(layer_idx))
+                                hooks.append(hook)
+                                if layer_idx == 0:
+                                    ffn_type = "swiglu"
+                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}")
 
@@ -2728,6 +2759,7 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                     qkv_captures.clear()
                     attn_output_norms.clear()
                     mlp_output_norms.clear()
+                    gate_activation_stats.clear()
 
                     # Forward pass with full outputs
                     outputs = manager.model(
@@ -3195,11 +3227,20 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                             "delta_norm": delta_norm,
                             "margin_contribution": margin_contribution,
                         }
-                        # Phase 4: Attention and MLP output norms
+                        # Phase 4: Attention and MLP output norms + contribution ratios
                         if layer_idx in attn_output_norms:
-                            layer_entry["attn_output_norm"] = attn_output_norms[layer_idx]
+                            layer_entry["attn_output_norm"] = round(attn_output_norms[layer_idx], 4)
                         if layer_idx in mlp_output_norms:
-                            layer_entry["mlp_output_norm"] = mlp_output_norms[layer_idx]
+                            layer_entry["mlp_output_norm"] = round(mlp_output_norms[layer_idx], 4)
+                        if layer_idx in attn_output_norms and layer_idx in mlp_output_norms:
+                            attn_n = attn_output_norms[layer_idx]
+                            mlp_n = mlp_output_norms[layer_idx]
+                            total = attn_n + mlp_n
+                            if total > 0:
+                                layer_entry["attn_contribution"] = round(attn_n / total, 4)
+                                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]
 
                         # Phase 5: Logit lens at sampled layers (every 8th layer)
                         logit_lens_stride = max(1, n_layers // 5)
@@ -3490,6 +3531,8 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                     "headDim": head_dim,
                     "vocabSize": manager.model.config.vocab_size,
                     "tunedLensAvailable": tuned_lens_runtime.available,
+                    "ffnType": ffn_type,
+                    "intermediateSize": getattr(manager.model.config, 'intermediate_size', None),
                 },
                 "generationTime": generation_time,
                 "numTokensGenerated": len(generated_tokens),