""" Year-Token Attention Analysis for Knowledge Drift Detection ============================================================= Adapted from D-LEAF (Yang et al., 2025) for temporal knowledge drift. Instead of measuring attention to image tokens (multimodal hallucination), we measure attention to YEAR tokens in temporal queries. Key metrics (adapted from D-LEAF): 1. LTAE - Layer Temporal Attention Entropy: flags layers with diffuse year-token attention 2. TAF - Temporal Attention Focus: scores how much each head attends to year tokens 3. Year-token attention distribution: per-head, per-layer analysis Hypothesis: Drifted facts show different attention patterns to year tokens compared to non-drifted facts. Specific layers/heads fail to properly process temporal context when the model's knowledge is outdated. Usage: python year_attention_analysis.py \ --model Qwen/Qwen2.5-7B-Instruct \ --dataset data/knowledge_drift_dataset.json \ --output data/attention_analysis/ \ --max_samples 300 """ import argparse import json import os import logging import torch import torch.nn.functional as F import numpy as np from tqdm import tqdm from collections import defaultdict logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) def load_model(model_name, device="auto"): from transformers import AutoModelForCausalLM, AutoTokenizer logger.info(f"Loading model: {model_name}") tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) if tokenizer.pad_token is None: tokenizer.pad_token = tokenizer.eos_token model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.float16, device_map=device, trust_remote_code=True, output_attentions=True, ) model.eval() return model, tokenizer def find_year_token_positions(tokenizer, input_ids, years=[2015,2018,2020,2022,2023,2024,2025]): """Find positions of year tokens in the input sequence. Strategy: Encode each year string with the tokenizer, then search for those token IDs in the input. This handles any tokenizer quirks. """ input_id_list = input_ids[0].tolist() year_positions = [] for year in years: # Get the token IDs for this year (try with and without space prefix) for year_str in [str(year), f" {year}"]: year_token_ids = tokenizer.encode(year_str, add_special_tokens=False) if not year_token_ids: continue # Search for this token sequence in input_ids seq_len = len(year_token_ids) for i in range(len(input_id_list) - seq_len + 1): if input_id_list[i:i+seq_len] == year_token_ids: year_positions.extend(range(i, i + seq_len)) return list(set(year_positions)) def compute_layer_temporal_attention_entropy(attention_matrix, year_positions): """ LTAE: Layer Temporal Attention Entropy (adapted from LIAE in D-LEAF) For each layer, compute the Maximum Attention Matrix (MAM) across heads for year tokens, then compute entropy. High LTAE = diffuse attention to year tokens = potential temporal confusion Low LTAE = focused attention to year tokens = clear temporal processing """ if not year_positions: return 0.0 # attention_matrix shape: [num_heads, seq_len, seq_len] num_heads = attention_matrix.shape[0] # Extract attention to year positions for the last token (generation position) # Shape: [num_heads, len(year_positions)] year_attention = attention_matrix[:, -1, year_positions] # MAM: max across heads for each year position mam = year_attention.max(dim=0).values # [len(year_positions)] # Normalize to probability distribution if mam.sum() > 0: p = mam / mam.sum() # Compute entropy entropy = -(p * (p + 1e-10).log()).sum().item() else: entropy = 0.0 return entropy def compute_temporal_attention_focus(attention_matrix, year_positions): """ TAF: Temporal Attention Focus per head (adapted from IAF in D-LEAF) Sum of attention weights each head assigns to year tokens. Higher TAF = head attends more to temporal context. """ if not year_positions: return torch.zeros(attention_matrix.shape[0]) # attention from last token to year positions, per head year_attention = attention_matrix[:, -1, year_positions] # [num_heads, len(year_positions)] taf = year_attention.sum(dim=-1) # [num_heads] return taf def analyze_single_query(model, tokenizer, query, device="cuda"): """Run a query and extract all attention-based temporal signals.""" prompt = f"<|im_start|>system\nAnswer concisely.<|im_end|>\n<|im_start|>user\n{query}<|im_end|>\n<|im_start|>assistant\n" inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512) inputs = {k: v.to(device) for k, v in inputs.items()} year_positions = find_year_token_positions(tokenizer, inputs['input_ids']) if not year_positions: # Debug: log what the tokenizer produces for common years logger.debug(f"No year tokens found in: {query[:80]}...") logger.debug(f" Token IDs for '2025': {tokenizer.encode('2025', add_special_tokens=False)}") logger.debug(f" Input token count: {inputs['input_ids'].shape[1]}") with torch.no_grad(): outputs = model(**inputs, output_attentions=True) attentions = outputs.attentions # tuple of [batch, num_heads, seq_len, seq_len] num_layers = len(attentions) num_heads = attentions[0].shape[1] # Per-layer metrics layer_ltae = [] # Layer Temporal Attention Entropy layer_taf_mean = [] # Mean Temporal Attention Focus across heads layer_taf_std = [] # Std of TAF (measures head disagreement) layer_taf_min = [] # Min TAF (worst head) layer_taf_max = [] # Max TAF (best head) all_head_tafs = [] # Full TAF matrix [num_layers, num_heads] for layer_idx in range(num_layers): attn = attentions[layer_idx][0] # [num_heads, seq_len, seq_len] ltae = compute_layer_temporal_attention_entropy(attn, year_positions) taf = compute_temporal_attention_focus(attn, year_positions) layer_ltae.append(ltae) layer_taf_mean.append(taf.mean().item()) layer_taf_std.append(taf.std().item()) layer_taf_min.append(taf.min().item()) layer_taf_max.append(taf.max().item()) all_head_tafs.append(taf.cpu().numpy().tolist()) # Also compute total attention to year tokens across all layers total_year_attention = sum( attentions[l][0][:, -1, year_positions].sum().item() for l in range(num_layers) ) if year_positions else 0.0 # Generate the answer with torch.no_grad(): gen = model.generate(**inputs, max_new_tokens=30, do_sample=False) answer = tokenizer.decode(gen[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True).strip() return { "num_year_tokens": len(year_positions), "year_positions": year_positions, "generated_answer": answer, "layer_ltae": layer_ltae, "layer_taf_mean": layer_taf_mean, "layer_taf_std": layer_taf_std, "layer_taf_min": layer_taf_min, "layer_taf_max": layer_taf_max, "all_head_tafs": all_head_tafs, "total_year_attention": total_year_attention, "num_layers": num_layers, "num_heads": num_heads, } def run_analysis(model, tokenizer, samples, output_dir, device="cuda", max_samples=None): os.makedirs(output_dir, exist_ok=True) # === TOKENIZER DIAGNOSTIC === logger.info("Year token diagnostic:") for year in [2020, 2024, 2025]: toks = tokenizer.encode(str(year), add_special_tokens=False) toks_sp = tokenizer.encode(f" {year}", add_special_tokens=False) logger.info(f" '{year}' -> {toks} ({tokenizer.convert_ids_to_tokens(toks)})") logger.info(f" ' {year}' -> {toks_sp} ({tokenizer.convert_ids_to_tokens(toks_sp)})") # Test on a sample query if samples: test_q = samples[0].get("query", "In 2025, the PM of UK was ___") test_ids = tokenizer.encode(test_q, add_special_tokens=False) test_tokens = tokenizer.convert_ids_to_tokens(test_ids) logger.info(f" Sample query tokens: {list(zip(range(len(test_tokens)), test_tokens))[:20]}") test_year_pos = find_year_token_positions(tokenizer, torch.tensor([test_ids])) logger.info(f" Year positions found: {test_year_pos}") if max_samples: # Smart sample: balanced drifted vs non-drifted drifted = [s for s in samples if s.get("is_drifted_query")] not_drifted = [s for s in samples if not s.get("is_drifted_query")] n_d = min(len(drifted), max_samples // 3) n_nd = min(len(not_drifted), max_samples - n_d) import random; random.seed(42) samples = random.sample(drifted, n_d) + random.sample(not_drifted, n_nd) all_results = [] group_signals = defaultdict(lambda: { "ltae": [], "taf_mean": [], "taf_std": [], "total_year_attn": [], "layer_ltae_all": [], "layer_taf_mean_all": [], "head_tafs_all": [], }) year_token_hits = 0 year_token_misses = 0 for sample in tqdm(samples, desc="Analyzing attention"): query = sample["query"] category = sample.get("category", "unknown") is_drifted = sample.get("is_drifted_query", False) try: result = analyze_single_query(model, tokenizer, query, device) except Exception as e: logger.error(f"Error: {e}") continue if result["num_year_tokens"] > 0: year_token_hits += 1 else: year_token_misses += 1 result["query"] = query result["category"] = category result["is_drifted_query"] = is_drifted result["expected_answer"] = sample.get("expected_answer", "") result["entity"] = sample.get("entity", "") result["year"] = sample.get("year", 0) all_results.append(result) # Group: drifted vs not drifted group = "DRIFTED" if is_drifted else f"{category}_not_drifted" signals = group_signals[group] signals["ltae"].append(np.mean(result["layer_ltae"])) signals["taf_mean"].append(np.mean(result["layer_taf_mean"])) signals["taf_std"].append(np.mean(result["layer_taf_std"])) signals["total_year_attn"].append(result["total_year_attention"]) signals["layer_ltae_all"].append(result["layer_ltae"]) signals["layer_taf_mean_all"].append(result["layer_taf_mean"]) signals["head_tafs_all"].append(result["all_head_tafs"]) # === PRINT COMPARISON === print("\n" + "=" * 90) print(" YEAR-TOKEN ATTENTION ANALYSIS: DRIFTED vs NON-DRIFTED") print("=" * 90) print(f"\n Year token detection: {year_token_hits} hits / {year_token_misses} misses out of {year_token_hits+year_token_misses} samples") if year_token_misses > year_token_hits: print(f" ⚠️ Most queries have NO year tokens detected! Check tokenizer diagnostic above.") print(f"\n{'Group':<45} {'N':>5} {'LTAE':>10} {'TAF mean':>10} {'TAF std':>10} {'YearAttn':>10}") print("-" * 95) summary = {} for group in sorted(group_signals.keys()): s = group_signals[group] n = len(s["ltae"]) if n == 0: continue print(f"{group:<45} {n:>5} {np.mean(s['ltae']):>10.4f} {np.mean(s['taf_mean']):>10.4f} " f"{np.mean(s['taf_std']):>10.4f} {np.mean(s['total_year_attn']):>10.4f}") summary[group] = { "count": n, "avg_ltae": float(np.mean(s["ltae"])), "avg_taf_mean": float(np.mean(s["taf_mean"])), "avg_taf_std": float(np.mean(s["taf_std"])), "avg_total_year_attn": float(np.mean(s["total_year_attn"])), } if s["layer_ltae_all"]: summary[group]["layer_avg_ltae"] = np.array(s["layer_ltae_all"]).mean(axis=0).tolist() summary[group]["layer_avg_taf_mean"] = np.array(s["layer_taf_mean_all"]).mean(axis=0).tolist() # === KEY COMPARISON === if "DRIFTED" in summary: d = summary["DRIFTED"] nd_keys = [k for k in summary if k != "DRIFTED"] if nd_keys: nd = summary[nd_keys[0]] # Take first non-drifted group print(f"\n === DRIFTED vs {nd_keys[0]} ===") print(f" LTAE: {d['avg_ltae']:.4f} vs {nd['avg_ltae']:.4f} (Δ={d['avg_ltae']-nd['avg_ltae']:+.4f})") print(f" TAF mean: {d['avg_taf_mean']:.4f} vs {nd['avg_taf_mean']:.4f} (Δ={d['avg_taf_mean']-nd['avg_taf_mean']:+.4f})") if d['avg_ltae'] > nd['avg_ltae']: print(f" ✅ Drifted facts have HIGHER temporal entropy (more confused about time)") if d['avg_taf_mean'] < nd['avg_taf_mean']: print(f" ✅ Drifted facts have LOWER temporal focus (ignoring year token)") # === FIND ANOMALOUS LAYERS (D-LEAF style) === if "DRIFTED" in summary and "layer_avg_ltae" in summary["DRIFTED"]: d_layers = np.array(summary["DRIFTED"]["layer_avg_ltae"]) if nd_keys and "layer_avg_ltae" in summary[nd_keys[0]]: nd_layers = np.array(summary[nd_keys[0]]["layer_avg_ltae"]) layer_diff = d_layers - nd_layers top_layers = np.argsort(layer_diff)[-5:][::-1] print(f"\n Top 5 layers where DRIFTED has higher LTAE than non-drifted:") for l in top_layers: print(f" Layer {l}: Δ LTAE = {layer_diff[l]:+.4f}") # Save with open(os.path.join(output_dir, "attention_raw.json"), 'w') as f: json.dump([{k:v for k,v in r.items()} for r in all_results], f, indent=2, default=str) with open(os.path.join(output_dir, "attention_summary.json"), 'w') as f: json.dump(summary, f, indent=2) logger.info(f"Results saved to {output_dir}") return summary def main(): parser = argparse.ArgumentParser() parser.add_argument("--model", default="Qwen/Qwen2.5-7B-Instruct") parser.add_argument("--dataset", default="data/knowledge_drift_dataset.json") parser.add_argument("--output", default="data/attention_analysis/") parser.add_argument("--max_samples", type=int, default=None) parser.add_argument("--device", default="auto") parser.add_argument("--post_cutoff_only", action="store_true") args = parser.parse_args() with open(args.dataset, 'r') as f: dataset = json.load(f) samples = dataset["samples"] if args.post_cutoff_only: samples = [s for s in samples if s.get("temporal_zone") == "post_cutoff"] model, tokenizer = load_model(args.model, args.device) device = "cuda" if torch.cuda.is_available() else "cpu" run_analysis(model, tokenizer, samples, args.output, device, args.max_samples) if __name__ == "__main__": main()