| """ |
| 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 |
|
|
|
|
| |
| |
| |
|
|
| 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(): |
| |
| 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, |
| ) |
| |
| hidden = enc_out.last_hidden_state |
|
|
| |
| mask = attention_mask.unsqueeze(-1).float() |
| pooled = (hidden * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1) |
|
|
| |
| elif (hasattr(model, 'encoder') and hasattr(model.encoder, 'encoder_frozen') |
| and hasattr(model.encoder.encoder_frozen, 'forward')): |
| |
| pooled = model.encoder.encoder_frozen(input_ids, attention_mask) |
|
|
| |
| 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) |
|
|
| |
| elif hasattr(model, 'model'): |
| out = model.model( |
| input_ids=input_ids, |
| attention_mask=attention_mask, |
| output_hidden_states=True, |
| ) |
| hidden = out.hidden_states[-1] |
| seq_lens = attention_mask.sum(dim=1) - 1 |
| B = hidden.size(0) |
| pooled = hidden[torch.arange(B, device=device), seq_lens] |
|
|
| |
| 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 |
|
|
|
|
| |
| |
| |
|
|
| 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_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) |
|
|
| |
|
|
| 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 |
|
|
| |
| 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']) |
|
|
| |
| 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', '')}')") |
| |
|
|
| |
| 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) |
| return embeddings, task_ids |
|
|
| |
|
|
| 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 '' |
|
|
| |
| 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 |
|
|
| |
| 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') |
|
|
| |
|
|
| 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']}") |
|
|
| |
|
|
| 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 |
|
|
| |
|
|
| 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} |
|
|
| |
| 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}") |
|
|
| |
|
|
| 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']}") |
|
|
| |
|
|
| 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 |
| ) |
|
|
| |
|
|
| 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} |
| |
| 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}") |
|
|
