""" SRT Trainer: GainLoRA + SRT Router integration. Implements CONTRIBUTION_1 (SRT) routing within GainLoRA architecture. - Computes {μ_t, Σ_t} from FROZEN backbone embeddings during training - Uses SRT metrics for routing at inference - Replaces learned MLP router with non-parametric SRT router Two modes: --srt_metric_mode hard : ZCA whitening + L2 (matches routing_analysis experiment) --srt_metric_mode dynamics: SRM metric selection (matches contribution_UNIFIED) Key SRT features: - Zero-drift: no learnable parameters in router - Uses FROZEN encoder for embedding extraction (same space at train & inference) - Statistical signatures stored (zero-rehearsal compliant) """ import copy import os import math import numpy as np import torch import torch.nn as nn from torch.utils.data import DataLoader from typing import Dict, Union, Any, Tuple, List, Optional from cl_trainer_gainlora import GainLoRATrainer try: from srt_router import SRTRouter, TaskSignature except ImportError: import sys sys.path.insert(0, os.path.dirname(__file__)) from srt_router import SRTRouter, TaskSignature # ───────────────────────────────────────────────────────────────────────────── # EMBEDDING EXTRACTION — FROZEN ENCODER # ───────────────────────────────────────────────────────────────────────────── def extract_embeddings_from_batch(model, inputs: Dict) -> torch.Tensor: """ Extract frozen backbone embeddings for SRT signatures {μ_t, Σ_t}. Matches routing_analysis extraction EXACTLY: T5 (encoder model): Layer: last encoder hidden state (out.last_hidden_state) Pool: mean over non-padding tokens LLaMA (decoder model): Layer: last decoder hidden state (out.hidden_states[-1]) Pool: last non-padding token (NOT mean pooling) MUST use model.encoder.encoder_frozen (or equivalent frozen wrapper). NEVER use adapted model (LoRA fine-tuned) — embedding space differs. References: T5: routing_analysis/extract_embeddings_t5.py (layer="encoder", pool="avg") LLaMA: routing_analysis/extract_embeddings_llama.py (pool="last", layer="hidden") """ input_ids = inputs.get('input_ids') attention_mask = inputs.get('attention_mask') if not isinstance(input_ids, torch.Tensor): input_ids = torch.tensor(input_ids) if not isinstance(attention_mask, torch.Tensor): attention_mask = torch.tensor(attention_mask) device = next(model.parameters()).device input_ids = input_ids.to(device) if attention_mask is not None: attention_mask = attention_mask.to(device) with torch.no_grad(): # ── Case 1: T5 — frozen encoder (encoder_frozen has last_hidden_state) ── if hasattr(model, 'encoder') and hasattr(model.encoder, 'encoder_frozen'): frozen_enc = model.encoder.encoder_frozen enc_out = frozen_enc( input_ids=input_ids, attention_mask=attention_mask, ) # frozen_enc is T5EncoderModel → has last_hidden_state hidden = enc_out.last_hidden_state # (B, L, d) # Mean pooling — matches routing_analysis/extract_embeddings_t5.py mask = attention_mask.unsqueeze(-1).float() # (B, L, 1) pooled = (hidden * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1) # (B, d) # ── Case 2: LLaMA — frozen decoder (encoder_frozen = FrozenLlamaExtractor) ── elif (hasattr(model, 'encoder') and hasattr(model.encoder, 'encoder_frozen') and hasattr(model.encoder.encoder_frozen, 'forward')): # encoder_frozen is FrozenLlamaExtractor → returns pooled (B, d) directly pooled = model.encoder.encoder_frozen(input_ids, attention_mask) # (B, d) # ── Case 3: bare T5EncoderModel (no gainlora wrapper) ── elif hasattr(model, 'encoder'): enc_out = model.encoder(input_ids=input_ids, attention_mask=attention_mask) hidden = getattr(enc_out, 'last_hidden_state', None) or enc_out[0] mask = attention_mask.unsqueeze(-1).float() pooled = (hidden * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1) # ── Case 4: bare LlamaForCausalLM (no gainlora wrapper) ── elif hasattr(model, 'model'): out = model.model( input_ids=input_ids, attention_mask=attention_mask, output_hidden_states=True, ) hidden = out.hidden_states[-1] # (B, L, d) seq_lens = attention_mask.sum(dim=1) - 1 # (B,) B = hidden.size(0) pooled = hidden[torch.arange(B, device=device), seq_lens] # (B, d) # ── Case 5: bare T5EncoderModel directly ── else: enc_out = model(input_ids=input_ids, attention_mask=attention_mask) hidden = getattr(enc_out, 'last_hidden_state', None) or enc_out[0] mask = attention_mask.unsqueeze(-1).float() pooled = (hidden * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1) return pooled # (B, d), float32 # ───────────────────────────────────────────────────────────────────────────── # SRT TRAINER # ───────────────────────────────────────────────────────────────────────────── class SRT_Trainer(GainLoRATrainer): """ GainLoRA + SRT Router. Changes from GainLoRATrainer: 1. After training task t: extract embeddings → compute {μ_t, Σ_t} 2. Store in SRTRouter (zero-rehearsal compliant) 3. At inference: SRT router replaces attention-based routing 4. SRT router persists across tasks (no drift) SRT modes: srt_metric_mode='hard' : ZCA whitening + L2 (matches routing_analysis) srt_metric_mode='dynamics': SRM metric selection (matches contribution_UNIFIED) """ def __init__( self, model, args, train_dataset, cur_task_id: int, task_order: list, data_collator_replay=None, replay_dataset_dict=None, replay_label_dict=None, eval_dataset=None, tokenizer=None, data_collator=None, compute_metrics=None, callbacks=None, # ── SRT-specific ──────────────────────────────────────────────── srt_metric_mode: str = 'hard', srt_shrink: bool = True, srt_shrink_factor: float = 0.1, srt_max_emb_samples: int = 500, srt_load_path: Optional[str] = None, srt_skip_forward: bool = False, ): super().__init__( model, args, train_dataset, cur_task_id, task_order, data_collator_replay, replay_dataset_dict, replay_label_dict, eval_dataset, tokenizer, data_collator, compute_metrics, callbacks, ) self.srt_metric_mode = srt_metric_mode self.srt_shrink = srt_shrink self.srt_shrink_factor = srt_shrink_factor self.srt_max_emb_samples = srt_max_emb_samples self.srt_load_path = srt_load_path self.srt_skip_forward = srt_skip_forward self.srt_router: Optional[SRTRouter] = None self._srt_init() def _srt_init(self): """Initialize SRT router (idempotent — safe to call multiple times).""" if self.srt_router is not None: return self.srt_router = SRTRouter( srt_metric_mode=self.srt_metric_mode, use_shrink=self.srt_shrink, shrink_factor=self.srt_shrink_factor, ) if self.srt_load_path is not None: self.load_srt_signatures(self.srt_load_path, wire_model=True) # ── 1. EMBEDDING EXTRACTION ──────────────────────────────────────────── def _extract_task_embeddings(self, max_samples: int = None) -> Tuple[torch.Tensor, List]: """ Extract embeddings for the current training task. Two modes controlled by self.srt_skip_forward: False (default): forward pass through FROZEN backbone (original behavior) True : load pre-extracted embeddings from disk embeddings/{backbone}/{split}/{task}/train.npz Keys: 'embeddings' (n,d), 'labels' (n,) """ if max_samples is None: max_samples = self.srt_max_emb_samples # ── MODE 1: Load pre-extracted embeddings from disk ─────────────── if self.srt_skip_forward: cur_task = self.task_order[self.cur_task_id] emb_path = self._srt_emb_cache_path(cur_task) if emb_path is not None and os.path.exists(emb_path): print(f" [SRT] ★ LOAD FROM CACHE: {emb_path}") data = np.load(emb_path, allow_pickle=True) embeddings = torch.from_numpy(data['embeddings']) # (n, d) # Take at most max_samples (in samples, not batches) if embeddings.shape[0] > max_samples: embeddings = embeddings[:max_samples] print(f" [SRT] → Loaded {embeddings.shape[0]} embeddings, dim={embeddings.shape[1]}") return embeddings, [] else: print(f" [SRT] ✗ SKIP_FORWARD=True but cache MISS for '{cur_task}' → falling back to forward pass") if emb_path is not None: print(f" [SRT] → Expected path: {emb_path}") else: print(f" [SRT] → Unknown backbone (model_name='{getattr(self.args, 'model_name_or_path', '')}')") # Fall through to forward extraction below # ── MODE 2: Forward pass extraction (original behavior) ─────────── print(f" [SRT] → Forward pass extraction ({max_samples} batches, backbone)") train_dataloader = self.get_train_dataloader() h_list = [] task_ids = [] max_batches = min(max_samples, len(train_dataloader)) for step, inputs in enumerate(train_dataloader): if step >= max_batches: break inputs = self._prepare_inputs(inputs) h = extract_embeddings_from_batch(self.model, inputs) h_list.append(h.cpu()) if 'task_ids' in inputs: task_ids.extend(inputs['task_ids'].tolist()) if not h_list: return torch.empty(0), task_ids embeddings = torch.cat(h_list, dim=0) # (n, d) return embeddings, task_ids # ── helper: resolve embedding cache path ─────────────────────────────── def _srt_emb_cache_path(self, task_name: str) -> Optional[str]: """ Resolve pre-extracted embedding path. Mapping: google/flan-t5-xl → embeddings/flan-t5-xl/ google/flan-t5-large → embeddings/flan-t5-large/ meta-llama/Llama-2-7b-hf → embeddings/Llama-2-7b-hf/ Task split: SuperNI tasks (task*): {backbone}/SuperNI/{task}/train.npz Long-Sequence tasks: {backbone}/Long_Sequence/{task}/train.npz """ model_name = getattr(self.args, 'model_name_or_path', '') or '' # Map model identifier to embeddings subdirectory backbone = None if 'flan-t5-xl' in model_name.lower(): backbone = 'flan-t5-xl' elif 'flan-t5-large' in model_name.lower(): backbone = 'flan-t5-large' elif 'llama' in model_name.lower(): backbone = 'Llama-2-7b-hf' else: return None # Determine split (SuperNI vs Long_Sequence) split = 'SuperNI' if task_name.startswith('task') else 'Long_Sequence' root = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'embeddings') return os.path.join(root, backbone, split, task_name, 'train.npz') # ── 2. SIGMA COMPUTATION ─────────────────────────────────────────────── def _compute_and_store_signature(self, task_id: int): """After training task t: extract embeddings → compute {μ_t, Σ_t} → add to router.""" if self.srt_router is None: self._srt_init() h_train, _ = self._extract_task_embeddings(self.srt_max_emb_samples) if h_train.shape[0] == 0: print(f" [SRT] WARNING: no embeddings extracted for task {task_id}") return h_np = h_train.numpy() sig = self.srt_router.add_task(task_id=task_id, h_train=h_np) summary = self.srt_router.summary() print(f" [SRT] Task {task_id}: PaR={sig.par:.1f}, metric={sig.metric}, " f"n={sig.n}, total_tasks={summary['n_tasks']}") # ── 3. SRT ROUTING AT INFERENCE ───────────────────────────────────────── def _srt_route(self, h: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: """Route using SRT router (non-parametric, zero-drift).""" if self.srt_router is None or len(self.srt_router.signatures) == 0: cur_t = self.task_order[self.cur_task_id] B = h.shape[0] return torch.full((B,), cur_t, dtype=torch.long), torch.zeros(B, 1) h_np = h.cpu().numpy() pred, dists = self.srt_router.route(h_np) pred_t = torch.tensor(pred, dtype=torch.long, device=h.device) dists_t = torch.tensor(dists, dtype=torch.float32, device=h.device) return pred_t, dists_t # ── 4. ATTENTION-BASED ROUTING → SRT REPLACEMENT ───────────────────── def _replace_attention_routing(self): """ Wire SRT router into model encoder for non-parametric routing. Position mapping (key_attention_weights shape = (B, 1+N_prev, 1)): index 0 = current task index 1..N_prev = previous tasks in REVERSE chronological order (slot 1 = most recent previous, slot N = oldest) Why reverse? prompts_keys_till_now.pt saves cat([current, prev...]) and previous_lora_list.reverse() loads newest first. So: slot 1 = task_order[cur_task_id - 1] (most recent previous) slot 2 = task_order[cur_task_id - 2] ... slot N = task_order[0] (oldest) """ if self.srt_router is None or len(self.srt_router.signatures) == 0: return current_task = self.task_order[self.cur_task_id] task_id_to_idx = {current_task: 0} # BUG #31 fix: slots are in REVERSE chronological order for prev_idx in range(self.cur_task_id): prev_task = self.task_order[prev_idx] task_id_to_idx[prev_task] = self.cur_task_id - prev_idx self.model.encoder.srt_router = self.srt_router self.model.encoder.srt_task_id_to_idx = task_id_to_idx self.model.encoder.use_srt_routing = True print(f" [SRT] Wired router: {len(self.srt_router.signatures)} tasks, " f"use_srt_routing=True, cur_task={current_task}, mapping={task_id_to_idx}") # ── 5. TASK END HOOK ─────────────────────────────────────────────────── def on_task_end(self, task_id: Union[int, str]): """Called after each task's training finishes.""" self._compute_and_store_signature(task_id) self._replace_attention_routing() if self.srt_router: summary = self.srt_router.summary() print(f" [SRT] Router summary: {summary['n_tasks']} tasks, " f"avg_PaR={summary['avg_par']:.1f}, metrics={summary['metrics']}") # ── 6. EVALUATION ───────────────────────────────────────────────────── def evaluation_loop( self, dataloader: DataLoader, description: str, prediction_loss_only: bool = False, ignore_keys: Optional[List] = None, metric_key_prefix: str = "eval", ) -> Any: """SRT routing handled transparently in model.forward().""" return super().evaluation_loop( dataloader, description, prediction_loss_only, ignore_keys, metric_key_prefix ) # ── 7. SAVE / LOAD SIGNATURES ────────────────────────────────────────── def save_srt_signatures(self, output_dir: str): """Save SRT router signatures to disk.""" if self.srt_router is None: return path = os.path.join(output_dir, 'srt_signatures.npz') self.srt_router.save(path) print(f" [SRT] Saved signatures to {path}") def load_srt_signatures(self, checkpoint_dir: str, wire_model: bool = False): """Load SRT router signatures from a previous checkpoint.""" path = os.path.join(checkpoint_dir, 'srt_signatures.npz') if not os.path.exists(path): print(f" [SRT] No signatures found at {path}") return self.srt_router.load(path) print(f" [SRT] Loaded {len(self.srt_router.signatures)} signatures from {path}") if wire_model and len(self.srt_router.signatures) > 0: self.model.encoder.srt_router = self.srt_router current_task = self.task_order[self.cur_task_id] task_id_to_idx = {current_task: 0} # BUG #31 fix: slots are in REVERSE chronological order for prev_idx in range(self.cur_task_id): task_id_to_idx[self.task_order[prev_idx]] = self.cur_task_id - prev_idx self.model.encoder.srt_task_id_to_idx = task_id_to_idx self.model.encoder.use_srt_routing = True print(f" [SRT] Wired {len(self.srt_router.signatures)} signatures to model, " f"cur_task={current_task}, mapping={task_id_to_idx}")