Add avg_entropy calculation for attention heads

- Compute normalized attention entropy averaged over query positions
- Normalize by log(k_i) where k_i = number of keys each position can attend to
- Average over latter half of positions for more stable signal
- Return both entropy (last-token) and avg_entropy fields for each head

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

backend/model_service.py

@@ -1713,9 +1713,30 @@ async def analyze_research_attention(request: Dict[str, Any], authenticated: boo
                         max_weight = head_weights.max().item()
                         entropy = -(head_weights * torch.log(head_weights + 1e-10)).sum().item()
 
+                        # Normalized attention entropy averaged over latter half of query positions
+                        # Normalized by log(k_i) where k_i = number of keys position i can attend to
+                        # This produces values in [0,1] with better spread across heads
+                        # layer_attn[head_idx] shape: [q_len, k_len]
+                        head_attn = layer_attn[head_idx]  # [q_len, k_len]
+                        q_len = head_attn.shape[0]
+
+                        # Compute raw entropy per query position
+                        token_entropies = -(head_attn * torch.log(head_attn + 1e-10)).sum(dim=-1)  # [q_len]
+
+                        # Normalize by max possible entropy: log(k_i) where k_i = i + 1 (causal mask)
+                        # Skip position 0 where log(1) = 0
+                        positions = torch.arange(1, q_len + 1, device=head_attn.device, dtype=head_attn.dtype)
+                        max_entropies = torch.log(positions + 1e-10)  # log(k_i), with epsilon for position 0
+                        normalized_entropies = token_entropies / (max_entropies + 1e-10)  # [0, 1] range
+
+                        # Average over latter half of positions (where there's enough context)
+                        start_idx = q_len // 2
+                        avg_entropy = normalized_entropies[start_idx:].mean().item() if start_idx < q_len else normalized_entropies.mean().item()
+
                         # Sanitize to prevent NaN/Inf in JSON
                         max_weight = 0.0 if math.isnan(max_weight) or math.isinf(max_weight) else max_weight
                         entropy = 0.0 if math.isnan(entropy) or math.isinf(entropy) else entropy
+                        avg_entropy = 0.0 if math.isnan(avg_entropy) or math.isinf(avg_entropy) else avg_entropy
 
                         # Classify pattern
                         pattern_type = None
@@ -1759,6 +1780,7 @@ async def analyze_research_attention(request: Dict[str, Any], authenticated: boo
                         critical_heads.append({
                             "head_idx": head_idx,
                             "entropy": entropy,
+                            "avg_entropy": avg_entropy,  # Averaged over all query positions
                             "max_weight": max_weight,
                             "attention_weights": attention_matrix,  # Full attention matrix for spreadsheet
                             "q_matrix": q_matrix,  # [seq_len, head_dim]
@@ -2161,8 +2183,27 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                             max_weight = head_weights.max().item()
                             entropy = -(head_weights * torch.log(head_weights + 1e-10)).sum().item()
 
+                            # Normalized attention entropy averaged over latter half of query positions
+                            # Normalized by log(k_i) where k_i = number of keys position i can attend to
+                            # This produces values in [0,1] with better spread across heads
+                            head_attn = layer_attn[head_idx]  # [q_len, k_len]
+                            q_len = head_attn.shape[0]
+
+                            # Compute raw entropy per query position
+                            token_entropies = -(head_attn * torch.log(head_attn + 1e-10)).sum(dim=-1)  # [q_len]
+
+                            # Normalize by max possible entropy: log(k_i) where k_i = i + 1 (causal mask)
+                            positions = torch.arange(1, q_len + 1, device=head_attn.device, dtype=head_attn.dtype)
+                            max_entropies = torch.log(positions + 1e-10)
+                            normalized_entropies = token_entropies / (max_entropies + 1e-10)  # [0, 1] range
+
+                            # Average over latter half of positions
+                            start_idx = q_len // 2
+                            avg_entropy = normalized_entropies[start_idx:].mean().item() if start_idx < q_len else normalized_entropies.mean().item()
+
                             max_weight = 0.0 if math.isnan(max_weight) or math.isinf(max_weight) else max_weight
                             entropy = 0.0 if math.isnan(entropy) or math.isinf(entropy) else entropy
+                            avg_entropy = 0.0 if math.isnan(avg_entropy) or math.isinf(avg_entropy) else avg_entropy
 
                             pattern_type = None
                             confidence = 0.0
@@ -2195,6 +2236,7 @@ async def analyze_research_attention_stream(request: Dict[str, Any], authenticat
                             critical_heads.append({
                                 "head_idx": head_idx,
                                 "entropy": entropy,
+                                "avg_entropy": avg_entropy,  # Averaged over all query positions
                                 "max_weight": max_weight,
                                 "attention_weights": attention_matrix,
                                 "q_matrix": q_matrix,