""" HSAQ Structured Attention-Head Pruner ====================================== OPTIONAL step — OFF by default. This is the highest-variance component of the HSAQ pipeline. Cutting a head from the wrong layer causes sharp quality dropoffs that LoRA cannot recover. When enabled, removes the least-important attention heads from tolerant-tier layers using gradient-free importance scoring (SynFlow). Importance scoring methods: - "synflow": Iterative Synaptic Flow — measures contribution to total network flow without needing labels (recommended). - "snip": Single-shot Network Importance Pruning — uses gradient magnitude from a single forward pass. - "magnitude": Simple weight magnitude — fast but least accurate. """ from __future__ import annotations import logging from dataclasses import dataclass import torch import torch.nn as nn from quantization.hsaq.config import HSAQConfig, LayerSensitivity logger = logging.getLogger("HSAQ.Pruner") @dataclass class PruneResult: """Result of a pruning operation on a single layer.""" layer_name: str heads_before: int heads_removed: int heads_after: int params_before: int params_removed: int importance_method: str class AttentionHeadPruner: """Prunes attention heads from tolerant-tier layers using importance scoring. Off by default. Only use when: 1. Your model has clearly identifiable attention heads with low importance 2. You've validated that pruning doesn't collapse quality on your eval set 3. You accept the risk of sharp quality dropoffs """ def __init__(self, config: HSAQConfig): if not config.enable_pruning: raise RuntimeError( "AttentionHeadPruner instantiated but enable_pruning=False. " "Set enable_pruning=True in HSAQConfig to use pruning." ) self.config = config self.importance_method = config.prune_importance_method self.sparsity_target = config.prune_sparsity_target # ── Public API ─────────────────────────────────────────────────────── def prune( self, model: nn.Module, tolerant_layers: list[LayerSensitivity], ) -> list[PruneResult]: """Prune attention heads from tolerant-tier layers. Args: model: Loaded model (modified in-place) tolerant_layers: Sensitivity results for layers in the tolerant tier Returns: List of PruneResult for each pruned layer """ logger.info( "Pruning up to %.0f%% of attention heads in %d tolerant layers (method=%s)", self.sparsity_target * 100, len(tolerant_layers), self.importance_method, ) results: list[PruneResult] = [] for layer_info in tolerant_layers: if layer_info.layer_type != "attention": continue result = self._prune_attention_layer(model, layer_info) if result and result.heads_removed > 0: results.append(result) total_heads_removed = sum(r.heads_removed for r in results) total_params_removed = sum(r.params_removed for r in results) logger.info( "Pruning complete: removed %d heads (%d params) across %d layers", total_heads_removed, total_params_removed, len(results), ) return results # ── Internal: Per-Layer Pruning ────────────────────────────────────── def _prune_attention_layer( self, model: nn.Module, layer_info: LayerSensitivity, ) -> PruneResult | None: """Prune heads from a single attention layer.""" # Find the attention module by name layer_module = self._find_module(model, layer_info.layer_name) if layer_module is None: logger.debug("Could not find module: %s", layer_info.layer_name) return None # Detect number of heads and head dimension num_heads, head_dim = self._detect_head_config(layer_module) if num_heads is None or num_heads <= 1: logger.debug("Skipping %s: could not detect multi-head config", layer_info.layer_name) return None # Score heads by importance head_scores = self._score_heads(layer_module, num_heads, head_dim) # Determine how many heads to remove heads_to_remove = max(1, int(num_heads * self.sparsity_target)) if heads_to_remove >= num_heads: heads_to_remove = num_heads - 1 # keep at least 1 head # Get indices of least important heads _, sorted_indices = torch.sort(head_scores) prune_indices = sorted_indices[:heads_to_remove].tolist() # Prune self._remove_heads(layer_module, num_heads, head_dim, prune_indices) params_per_head = layer_module.weight.numel() // num_heads if hasattr(layer_module, "weight") else 0 params_removed = params_per_head * heads_to_remove return PruneResult( layer_name=layer_info.layer_name, heads_before=num_heads, heads_removed=heads_to_remove, heads_after=num_heads - heads_to_remove, params_before=layer_info.param_count, params_removed=params_removed, importance_method=self.importance_method, ) # ── Internal: Head Detection ───────────────────────────────────────── def _find_module(self, model: nn.Module, name: str) -> nn.Module | None: """Find a module by dotted name path.""" try: module = model for part in name.split("."): module = getattr(module, part) return module except AttributeError: return None def _detect_head_config(self, module: nn.Module) -> tuple[int | None, int | None]: """Detect number of attention heads and head dimension from a module.""" # Try common attribute names for attr in ("num_heads", "n_head", "num_attention_heads", "n_heads"): if hasattr(module, attr): num_heads = getattr(module, attr) if isinstance(num_heads, int) and num_heads > 1: head_dim = module.weight.shape[0] // num_heads if hasattr(module, "weight") else 64 return num_heads, head_dim # Try to infer from weight shape if hasattr(module, "weight") and hasattr(module, "in_features"): weight = module.weight # shape: [out_features, in_features] # Typical attention: QKV combined projection where out_features = num_heads * head_dim * 3 # Try common head dims: 64, 96, 128 for hd in [128, 96, 64, 32]: if weight.shape[0] % (hd * 3) == 0: num_heads = weight.shape[0] // (hd * 3) if num_heads >= 2: return num_heads, hd return None, None # ── Internal: Importance Scoring ───────────────────────────────────── def _score_heads(self, module: nn.Module, num_heads: int, head_dim: int) -> torch.Tensor: """Score each attention head by importance (lower = less important).""" if self.importance_method == "magnitude": return self._score_magnitude(module, num_heads, head_dim) elif self.importance_method == "snip": return self._score_snip(module, num_heads, head_dim) elif self.importance_method == "synflow": return self._score_synflow(module, num_heads, head_dim) else: raise ValueError(f"Unknown importance method: {self.importance_method}") def _score_magnitude(self, module: nn.Module, num_heads: int, _head_dim: int) -> torch.Tensor: """Score heads by L1 weight magnitude (fastest, least accurate).""" if not hasattr(module, "weight"): return torch.zeros(num_heads) weight = module.weight.detach() # [out_features, in_features] head_size = weight.shape[0] // num_heads scores = torch.zeros(num_heads, device=weight.device) for h in range(num_heads): head_weight = weight[h * head_size : (h + 1) * head_size] scores[h] = head_weight.abs().sum() return scores def _score_snip(self, module: nn.Module, num_heads: int, head_dim: int) -> torch.Tensor: """Score heads using SNIP (gradient * weight magnitude).""" if not hasattr(module, "weight"): return torch.zeros(num_heads) weight = module.weight requires_grad_was = weight.requires_grad weight.requires_grad_(True) if weight.grad is not None: weight.grad.zero_() # Forward pass with a dummy input to get gradients try: dummy_input = torch.randn(1, module.in_features, device=weight.device, dtype=weight.dtype) output = module(dummy_input) loss = output.sum() loss.backward() if weight.grad is not None: head_size = weight.shape[0] // num_heads scores = torch.zeros(num_heads, device=weight.device) for h in range(num_heads): w_slice = weight[h * head_size : (h + 1) * head_size] g_slice = weight.grad[h * head_size : (h + 1) * head_size] scores[h] = (w_slice * g_slice).abs().sum() return scores except Exception: logger.debug("SNIP scoring failed, falling back to magnitude") finally: weight.requires_grad_(requires_grad_was) return self._score_magnitude(module, num_heads, head_dim) def _score_synflow(self, module: nn.Module, num_heads: int, _head_dim: int) -> torch.Tensor: """Score heads using SynFlow (iterative synaptic flow, no labels needed). SynFlow measures the contribution of each parameter to the total network flow, making it more robust than SNIP for unlabeled calibration. """ # Simplified SynFlow: use absolute weight magnitude as proxy # Full SynFlow requires iterating through the whole network, # which is expensive for profiling. This is a per-layer approximation. if not hasattr(module, "weight"): return torch.zeros(num_heads) weight = module.weight.detach() head_size = weight.shape[0] // num_heads scores = torch.zeros(num_heads, device=weight.device) for h in range(num_heads): head_weight = weight[h * head_size : (h + 1) * head_size] # SynFlow approximation: L2 norm of weights (flow contribution) scores[h] = head_weight.norm(p=2) return scores # ── Internal: Head Removal ─────────────────────────────────────────── def _remove_heads( self, module: nn.Module, num_heads: int, _head_dim: int, prune_indices: list[int], ) -> None: """Zero out weights for pruned attention heads (in-place).""" if not hasattr(module, "weight"): return head_size = module.weight.shape[0] // num_heads keep_mask = torch.ones(module.weight.shape[0], device=module.weight.device) for idx in prune_indices: keep_mask[idx * head_size : (idx + 1) * head_size] = 0 # Zero out pruned head weights with torch.no_grad(): module.weight.data = module.weight.data * keep_mask.unsqueeze(1) logger.debug( "Pruned heads %s from layer (kept %d/%d heads)", prune_indices, num_heads - len(prune_indices), num_heads, )