Upload src/kfac_collector.py with huggingface_hub

src/kfac_collector.py

@@ -0,0 +1,579 @@
+"""
+K-FAC Statistics Collector
+
+Collects activation covariance (A) and gradient covariance (G) matrices
+for MLP layers to approximate the Fisher Information Matrix.
+
+Based on: "From Memorization to Reasoning in the Spectrum of Loss Curvature"
+"""
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+from typing import Optional, Callable
+from dataclasses import dataclass, field
+from tqdm import tqdm
+
+
+@dataclass
+class LayerStatistics:
+    """K-FAC statistics for a single layer."""
+    
+    # Covariance matrices
+    A: Optional[Tensor] = None  # Activation covariance (d_in x d_in)
+    G: Optional[Tensor] = None  # Gradient covariance (d_out x d_out)
+    
+    # Running sums for incremental computation
+    A_sum: Optional[Tensor] = None
+    G_sum: Optional[Tensor] = None
+    
+    # Counts
+    n_samples_A: int = 0
+    n_samples_G: int = 0
+    
+    def finalize(self) -> None:
+        """Convert running sums to means."""
+        if self.A_sum is not None and self.n_samples_A > 0:
+            self.A = self.A_sum / self.n_samples_A
+            self.A_sum = None
+        if self.G_sum is not None and self.n_samples_G > 0:
+            self.G = self.G_sum / self.n_samples_G
+            self.G_sum = None
+
+
+@dataclass
+class KFACConfig:
+    """Configuration for K-FAC collection."""
+    
+    # Target layers (layer indices)
+    target_layers: list[int] = field(default_factory=lambda: [11, 12, 13])
+    
+    # Target projections within MLP
+    target_projections: list[str] = field(default_factory=lambda: ["gate_proj", "up_proj"])
+    
+    # Sequence length for batching
+    seq_length: int = 512
+    
+    # Whether to exclude last position (for causal LM)
+    exclude_last_position: bool = True
+    
+    # Use sampled labels instead of ground truth for proper FIM
+    sample_labels: bool = True
+    
+    # Device
+    device: str = "cuda"
+
+
+class KFACCollector:
+    """
+    Collects K-FAC statistics (activation and gradient covariances) for MLP layers.
+    
+    The K-FAC approximation factorizes the Fisher Information Matrix as:
+        F_W ≈ G ⊗ A = E[gg^T] ⊗ E[aa^T]
+    
+    where:
+        - A is the covariance of activations going into the layer
+        - G is the covariance of gradients on the layer's output
+    
+    Usage:
+        collector = KFACCollector(model, config)
+        collector.register_hooks()
+        
+        for batch in dataloader:
+            collector.collect_batch(batch, tokenizer)
+        
+        collector.finalize()
+        collector.save("kfac_stats.pt")
+    """
+    
+    def __init__(
+        self,
+        model: nn.Module,
+        config: Optional[KFACConfig] = None,
+    ):
+        self.model = model
+        self.config = config or KFACConfig()
+        
+        # Storage for statistics
+        self.stats: dict[str, LayerStatistics] = {}
+        
+        # Hooks
+        self._forward_hooks: list = []
+        self._backward_hooks: list = []
+        
+        # Buffers for current batch
+        self._activation_buffer: dict[str, Tensor] = {}
+        self._gradient_buffer: dict[str, Tensor] = {}
+        
+        # Track registration state
+        self._hooks_registered = False
+        
+    def _get_layer_name(self, layer_idx: int, proj_name: str) -> str:
+        """Generate a unique name for a layer/projection combination."""
+        return f"layer_{layer_idx}.{proj_name}"
+    
+    def _get_target_modules(self) -> dict[str, nn.Linear]:
+        """Find all target modules in the model."""
+        targets = {}
+        
+        # Handle different model architectures
+        # OLMo-2 / LLaMA style: model.layers[i].mlp.{gate_proj, up_proj, down_proj}
+        
+        layers = None
+        if hasattr(self.model, "model") and hasattr(self.model.model, "layers"):
+            # HF style (e.g., OLMoForCausalLM)
+            layers = self.model.model.layers
+        elif hasattr(self.model, "transformer") and hasattr(self.model.transformer, "blocks"):
+            # GPT style
+            layers = self.model.transformer.blocks
+        elif hasattr(self.model, "layers"):
+            # Direct access
+            layers = self.model.layers
+        
+        if layers is None:
+            raise ValueError(
+                "Could not find transformer layers. "
+                "Model architecture not recognized. "
+                f"Model type: {type(self.model)}"
+            )
+        
+        for layer_idx in self.config.target_layers:
+            if layer_idx >= len(layers):
+                print(f"Warning: Layer {layer_idx} does not exist (model has {len(layers)} layers)")
+                continue
+                
+            layer = layers[layer_idx]
+            
+            # Find MLP submodule
+            mlp = None
+            if hasattr(layer, "mlp"):
+                mlp = layer.mlp
+            elif hasattr(layer, "feed_forward"):
+                mlp = layer.feed_forward
+            elif hasattr(layer, "ff"):
+                mlp = layer.ff
+            
+            if mlp is None:
+                print(f"Warning: Could not find MLP in layer {layer_idx}")
+                continue
+            
+            for proj_name in self.config.target_projections:
+                if hasattr(mlp, proj_name):
+                    proj = getattr(mlp, proj_name)
+                    if isinstance(proj, nn.Linear):
+                        name = self._get_layer_name(layer_idx, proj_name)
+                        targets[name] = proj
+                        self.stats[name] = LayerStatistics()
+                else:
+                    print(f"Warning: {proj_name} not found in layer {layer_idx}")
+        
+        return targets
+    
+    def register_hooks(self) -> None:
+        """Register forward and backward hooks on target modules."""
+        if self._hooks_registered:
+            print("Hooks already registered")
+            return
+        
+        targets = self._get_target_modules()
+        
+        if not targets:
+            raise ValueError("No target modules found to hook")
+        
+        print(f"Registering hooks on {len(targets)} modules:")
+        for name in targets:
+            print(f"  - {name}")
+        
+        for name, module in targets.items():
+            # Forward hook: capture input activations
+            def make_forward_hook(layer_name: str):
+                def hook(module: nn.Module, input: tuple, output: Tensor) -> None:
+                    # input is a tuple, first element is the activation tensor
+                    x = input[0]
+                    if x.requires_grad:
+                        # Store for backward pass
+                        self._activation_buffer[layer_name] = x.detach()
+                return hook
+            
+            # Backward hook: capture output gradients
+            def make_backward_hook(layer_name: str):
+                def hook(module: nn.Module, grad_input: tuple, grad_output: tuple) -> None:
+                    # grad_output is tuple, first element is gradient w.r.t. output
+                    g = grad_output[0]
+                    if g is not None:
+                        self._gradient_buffer[layer_name] = g.detach()
+                return hook
+            
+            fh = module.register_forward_hook(make_forward_hook(name))
+            bh = module.register_full_backward_hook(make_backward_hook(name))
+            
+            self._forward_hooks.append(fh)
+            self._backward_hooks.append(bh)
+        
+        self._hooks_registered = True
+    
+    def remove_hooks(self) -> None:
+        """Remove all registered hooks."""
+        for hook in self._forward_hooks:
+            hook.remove()
+        for hook in self._backward_hooks:
+            hook.remove()
+        
+        self._forward_hooks = []
+        self._backward_hooks = []
+        self._hooks_registered = False
+    
+    def _update_statistics(self) -> None:
+        """Update running statistics from current buffers."""
+        for name in self.stats:
+            if name in self._activation_buffer:
+                x = self._activation_buffer[name]
+                # x shape: (batch, seq_len, d_in)
+                
+                # Optionally exclude last position
+                if self.config.exclude_last_position and x.shape[1] > 1:
+                    x = x[:, :-1, :]
+                
+                # Flatten batch and sequence dimensions
+                x_flat = x.reshape(-1, x.shape[-1])  # (batch * seq, d_in)
+                n_positions = x_flat.shape[0]
+                
+                # Compute A contribution: x^T @ x
+                A_batch = x_flat.T @ x_flat  # (d_in, d_in)
+                
+                # Update running sum
+                if self.stats[name].A_sum is None:
+                    self.stats[name].A_sum = A_batch
+                else:
+                    self.stats[name].A_sum = self.stats[name].A_sum + A_batch
+                self.stats[name].n_samples_A += n_positions
+            
+            if name in self._gradient_buffer:
+                g = self._gradient_buffer[name]
+                # g shape: (batch, seq_len, d_out)
+                
+                # Optionally exclude last position
+                if self.config.exclude_last_position and g.shape[1] > 1:
+                    g = g[:, :-1, :]
+                
+                # Flatten batch and sequence dimensions
+                g_flat = g.reshape(-1, g.shape[-1])  # (batch * seq, d_out)
+                n_positions = g_flat.shape[0]
+                
+                # Compute G contribution: g^T @ g
+                G_batch = g_flat.T @ g_flat  # (d_out, d_out)
+                
+                # Update running sum
+                if self.stats[name].G_sum is None:
+                    self.stats[name].G_sum = G_batch
+                else:
+                    self.stats[name].G_sum = self.stats[name].G_sum + G_batch
+                self.stats[name].n_samples_G += n_positions
+        
+        # Clear buffers
+        self._activation_buffer.clear()
+        self._gradient_buffer.clear()
+    
+    @torch.no_grad()
+    def _sample_labels(self, logits: Tensor) -> Tensor:
+        """
+        Sample labels from model's predicted distribution.
+        
+        For proper FIM computation, we sample ŷ ~ p(y|x) rather than
+        using ground truth labels.
+        """
+        # logits shape: (batch, seq_len, vocab_size)
+        probs = torch.softmax(logits, dim=-1)
+        # Sample from categorical distribution
+        sampled = torch.multinomial(
+            probs.view(-1, probs.shape[-1]), 
+            num_samples=1
+        ).view(probs.shape[:-1])
+        return sampled
+    
+    def collect_batch(
+        self,
+        input_ids: Tensor,
+        attention_mask: Optional[Tensor] = None,
+        labels: Optional[Tensor] = None,
+    ) -> float:
+        """
+        Collect K-FAC statistics from a single batch.
+        
+        Args:
+            input_ids: Token IDs (batch, seq_len)
+            attention_mask: Attention mask (batch, seq_len)
+            labels: Ground truth labels (optional, will be sampled if not provided
+                    or if config.sample_labels is True)
+        
+        Returns:
+            Loss value for this batch
+        """
+        self.model.train()  # Need gradients
+        
+        # Move to device
+        input_ids = input_ids.to(self.config.device)
+        if attention_mask is not None:
+            attention_mask = attention_mask.to(self.config.device)
+        
+        # Forward pass
+        with torch.enable_grad():
+            outputs = self.model(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                use_cache=False,
+            )
+            logits = outputs.logits
+            
+            # Get labels for loss computation
+            if self.config.sample_labels or labels is None:
+                # Sample from model's distribution (proper FIM)
+                sampled_labels = self._sample_labels(logits)
+                # Shift for causal LM
+                shift_labels = sampled_labels[:, 1:].contiguous()
+                shift_logits = logits[:, :-1, :].contiguous()
+            else:
+                # Use provided labels
+                shift_labels = labels[:, 1:].contiguous().to(self.config.device)
+                shift_logits = logits[:, :-1, :].contiguous()
+            
+            # Compute loss
+            loss_fn = nn.CrossEntropyLoss()
+            loss = loss_fn(
+                shift_logits.view(-1, shift_logits.shape[-1]),
+                shift_labels.view(-1)
+            )
+            
+            # Backward pass to populate gradient buffers
+            loss.backward()
+        
+        # Update statistics from buffers
+        self._update_statistics()
+        
+        # Zero gradients for next batch
+        self.model.zero_grad()
+        
+        return loss.item()
+    
+    def collect_from_dataloader(
+        self,
+        dataloader,
+        max_tokens: int = 20_000_000,
+        progress_bar: bool = True,
+    ) -> dict:
+        """
+        Collect K-FAC statistics from a dataloader.
+        
+        Args:
+            dataloader: PyTorch DataLoader yielding batches with input_ids
+            max_tokens: Maximum number of tokens to process
+            progress_bar: Whether to show progress bar
+        
+        Returns:
+            Dictionary with collection statistics
+        """
+        if not self._hooks_registered:
+            self.register_hooks()
+        
+        total_tokens = 0
+        total_loss = 0.0
+        n_batches = 0
+        
+        iterator = tqdm(dataloader, desc="Collecting K-FAC stats") if progress_bar else dataloader
+        
+        for batch in iterator:
+            if isinstance(batch, dict):
+                input_ids = batch["input_ids"]
+                attention_mask = batch.get("attention_mask")
+            else:
+                input_ids = batch[0]
+                attention_mask = batch[1] if len(batch) > 1 else None
+            
+            batch_tokens = input_ids.numel()
+            
+            loss = self.collect_batch(input_ids, attention_mask)
+            
+            total_tokens += batch_tokens
+            total_loss += loss
+            n_batches += 1
+            
+            if progress_bar:
+                iterator.set_postfix({
+                    "tokens": f"{total_tokens/1e6:.1f}M",
+                    "loss": f"{loss:.3f}"
+                })
+            
+            if total_tokens >= max_tokens:
+                break
+        
+        return {
+            "total_tokens": total_tokens,
+            "n_batches": n_batches,
+            "avg_loss": total_loss / max(n_batches, 1),
+        }
+    
+    def finalize(self) -> None:
+        """Finalize statistics by converting sums to means."""
+        for name, stat in self.stats.items():
+            stat.finalize()
+            print(f"Finalized {name}: A={stat.A.shape if stat.A is not None else None}, "
+                  f"G={stat.G.shape if stat.G is not None else None}")
+    
+    def save(self, path: str) -> None:
+        """Save K-FAC statistics to file."""
+        save_dict = {
+            "config": {
+                "target_layers": self.config.target_layers,
+                "target_projections": self.config.target_projections,
+                "seq_length": self.config.seq_length,
+            },
+            "statistics": {}
+        }
+        
+        for name, stat in self.stats.items():
+            save_dict["statistics"][name] = {
+                "A": stat.A.cpu() if stat.A is not None else None,
+                "G": stat.G.cpu() if stat.G is not None else None,
+                "n_samples_A": stat.n_samples_A,
+                "n_samples_G": stat.n_samples_G,
+            }
+        
+        torch.save(save_dict, path)
+        print(f"Saved K-FAC statistics to {path}")
+    
+    @classmethod
+    def load(cls, path: str, model: nn.Module) -> "KFACCollector":
+        """Load K-FAC statistics from file."""
+        data = torch.load(path, map_location="cpu")
+        
+        config = KFACConfig(
+            target_layers=data["config"]["target_layers"],
+            target_projections=data["config"]["target_projections"],
+            seq_length=data["config"]["seq_length"],
+        )
+        
+        collector = cls(model, config)
+        
+        for name, stat_data in data["statistics"].items():
+            collector.stats[name] = LayerStatistics(
+                A=stat_data["A"],
+                G=stat_data["G"],
+                n_samples_A=stat_data["n_samples_A"],
+                n_samples_G=stat_data["n_samples_G"],
+            )
+        
+        print(f"Loaded K-FAC statistics from {path}")
+        return collector
+    
+    def get_statistics(self) -> dict[str, tuple[Tensor, Tensor]]:
+        """
+        Get computed A and G matrices for all layers.
+        
+        Returns:
+            Dictionary mapping layer names to (A, G) tuples
+        """
+        result = {}
+        for name, stat in self.stats.items():
+            if stat.A is not None and stat.G is not None:
+                result[name] = (stat.A, stat.G)
+        return result
+
+
+def create_dataloader(
+    dataset_name: str = "allenai/dolma",
+    dataset_config: str = "v1_6-sample",
+    tokenizer = None,
+    batch_size: int = 4,
+    seq_length: int = 512,
+    max_samples: Optional[int] = None,
+    streaming: bool = True,
+    shuffle_buffer: int = 10000,
+    seed: int = 42,
+):
+    """
+    Create a DataLoader for K-FAC collection.
+    
+    Args:
+        dataset_name: HuggingFace dataset name
+        dataset_config: Dataset configuration/subset name
+        tokenizer: Tokenizer for the model
+        batch_size: Batch size
+        seq_length: Sequence length for tokenization
+        max_samples: Maximum number of samples to load
+        streaming: Whether to use streaming mode
+        shuffle_buffer: Buffer size for streaming shuffle
+        seed: Random seed
+    
+    Returns:
+        PyTorch DataLoader
+    """
+    from datasets import load_dataset
+    from torch.utils.data import DataLoader, IterableDataset
+    
+    # Load dataset
+    if dataset_config:
+        ds = load_dataset(dataset_name, name=dataset_config, split="train", streaming=streaming)
+    else:
+        ds = load_dataset(dataset_name, split="train", streaming=streaming)
+    
+    if streaming:
+        ds = ds.shuffle(buffer_size=shuffle_buffer, seed=seed)
+    
+    # Tokenization function
+    def tokenize_fn(examples):
+        # Handle different column names
+        text_column = "text" if "text" in examples else list(examples.keys())[0]
+        texts = examples[text_column]
+        
+        tokenized = tokenizer(
+            texts,
+            truncation=True,
+            max_length=seq_length,
+            padding="max_length",
+            return_tensors="pt",
+        )
+        return tokenized
+    
+    # Create streaming dataset wrapper
+    class TokenizedIterableDataset(IterableDataset):
+        def __init__(self, dataset, tokenizer, seq_length, max_samples):
+            self.dataset = dataset
+            self.tokenizer = tokenizer
+            self.seq_length = seq_length
+            self.max_samples = max_samples
+        
+        def __iter__(self):
+            count = 0
+            for example in self.dataset:
+                if self.max_samples and count >= self.max_samples:
+                    break
+                
+                # Get text
+                text = example.get("text", list(example.values())[0])
+                if not text:
+                    continue
+                
+                # Tokenize
+                tokens = self.tokenizer(
+                    text,
+                    truncation=True,
+                    max_length=self.seq_length,
+                    padding="max_length",
+                    return_tensors="pt",
+                )
+                
+                yield {
+                    "input_ids": tokens["input_ids"].squeeze(0),
+                    "attention_mask": tokens["attention_mask"].squeeze(0),
+                }
+                count += 1
+    
+    torch_dataset = TokenizedIterableDataset(ds, tokenizer, seq_length, max_samples)
+    
+    dataloader = DataLoader(
+        torch_dataset,
+        batch_size=batch_size,
+        num_workers=0,  # Streaming doesn't work well with multiple workers
+    )
+    
+    return dataloader