Upload folder using huggingface_hub

.gitattributes

@@ -58,3 +58,30 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/external/sparql_extension_samples.json filter=lfs diff=lfs merge=lfs -text
+data/external/templama_converted.json filter=lfs diff=lfs merge=lfs -text
+data/external/templama_test.json filter=lfs diff=lfs merge=lfs -text
+data/external/temporal-robustness/data/dynamic-templama/dataset_from_2019-1-1_to_2022-12-31_per_quarter/test.jsonl filter=lfs diff=lfs merge=lfs -text
+data/external/temporal-robustness/data/dynamic-templama/dataset_from_2019-1-1_to_2022-6-31_per_quarter/test.jsonl filter=lfs diff=lfs merge=lfs -text
+data/external/temporal-robustness/data/dynamic-templama/dataset_from_2019-1-1_to_2022-6-31_per_quarter_improved/test.jsonl filter=lfs diff=lfs merge=lfs -text
+data/external/temporal-robustness/dynamic-templama-data-analysis.ipynb filter=lfs diff=lfs merge=lfs -text
+data/knowledge_drift_dataset_multimodel.json filter=lfs diff=lfs merge=lfs -text
+data/knowledge_drift_unified_full.json filter=lfs diff=lfs merge=lfs -text
+data/knowledge_drift_unified_tier1.json filter=lfs diff=lfs merge=lfs -text
+data/knowledge_drift_unified_tier1_clean.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_gemma2.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_gemma2_paraonly.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_gemma2_paraphrased.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_llama2.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_llama2_paraonly.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_llama2_paraphrased.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_llama31.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_llama31_paraonly.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_llama31_paraphrased.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_mistral.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_mistral_paraonly.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_mistral_paraphrased.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_paraphrased.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_qwen25.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_qwen25_paraonly.json filter=lfs diff=lfs merge=lfs -text
+data/tier1_qwen25_paraphrased.json filter=lfs diff=lfs merge=lfs -text

analyze_drift_signals.py

@@ -0,0 +1,533 @@
+"""
+Knowledge Drift Internal Signal Analysis
+==========================================
+Runs queries through a model and measures internal confidence signals
+to see if the model "knows it doesn't know" for drifted facts.
+
+Metrics computed per query:
+1. Output entropy (how uncertain is the final prediction?)
+2. Top-1 probability (how confident in the best answer?)
+3. Top-5 token probabilities (is the model spread across options?)
+4. Logit lens per layer (what does the model predict at each layer?)
+5. Layer-wise entropy (does uncertainty build up or resolve across layers?)
+6. Old vs New answer probability (does the model consider both?)
+
+Usage:
+    python analyze_drift_signals.py \
+        --model Qwen/Qwen2.5-7B-Instruct \
+        --dataset data/knowledge_drift_dataset.json \
+        --output data/drift_analysis/ \
+        --max_samples 500
+"""
+
+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
+from datetime import datetime
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+def load_model(model_name, device="auto"):
+    """Load model with hooks for internal state access."""
+    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_hidden_states=True,
+    )
+    model.eval()
+    
+    num_layers = model.config.num_hidden_layers
+    hidden_dim = model.config.hidden_size
+    vocab_size = model.config.vocab_size
+    logger.info(f"Model loaded: {num_layers} layers, {hidden_dim} hidden dim, {vocab_size} vocab")
+    
+    return model, tokenizer
+
+
+def compute_entropy(logits):
+    """Compute entropy of a probability distribution from logits."""
+    probs = F.softmax(logits, dim=-1)
+    log_probs = F.log_softmax(logits, dim=-1)
+    entropy = -(probs * log_probs).sum(dim=-1)
+    return entropy.item()
+
+
+def compute_top_k_probs(logits, tokenizer, k=10):
+    """Get top-k tokens and their probabilities."""
+    probs = F.softmax(logits, dim=-1)
+    top_probs, top_indices = probs.topk(k)
+    
+    results = []
+    for i in range(k):
+        token = tokenizer.decode(top_indices[i].item())
+        prob = top_probs[i].item()
+        results.append({"token": token, "probability": prob, "token_id": top_indices[i].item()})
+    
+    return results
+
+
+def get_answer_token_ids(tokenizer, answer_text):
+    """Get the first token ID(s) for an answer string."""
+    # Try to find the first meaningful token of the answer
+    tokens = tokenizer.encode(answer_text, add_special_tokens=False)
+    if len(tokens) > 0:
+        return tokens[0]  # First token of the answer
+    return None
+
+
+def analyze_single_query(model, tokenizer, query, expected_answer="", old_answer="", device="cuda"):
+    """
+    Run a single query and collect all internal signals.
+    
+    Returns a dict with:
+    - output_entropy: entropy of final layer output distribution
+    - top1_prob: probability of the most likely next token
+    - top10_tokens: top 10 predicted tokens with probabilities
+    - layer_entropies: entropy at each layer (via logit lens)
+    - layer_top1_tokens: what each layer predicts as top-1
+    - layer_top1_probs: confidence of each layer's top prediction
+    - expected_answer_rank: rank of expected answer token in final output
+    - expected_answer_prob: probability of expected answer token
+    - old_answer_rank: rank of old/outdated answer token (for drifted queries)
+    - old_answer_prob: probability of old answer token
+    """
+    # Format as simple question
+    prompt = f"<|im_start|>system\nAnswer the following question concisely in a few words.<|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=2048)
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+    
+    with torch.no_grad():
+        outputs = model(**inputs, output_hidden_states=True)
+    
+    # === FINAL LAYER ANALYSIS ===
+    final_logits = outputs.logits[0, -1, :]  # [vocab_size]
+    
+    output_entropy = compute_entropy(final_logits)
+    top10 = compute_top_k_probs(final_logits, tokenizer, k=10)
+    top1_prob = top10[0]["probability"]
+    top1_token = top10[0]["token"]
+    
+    # === ANSWER TOKEN TRACKING ===
+    expected_token_id = get_answer_token_ids(tokenizer, expected_answer) if expected_answer else None
+    old_token_id = get_answer_token_ids(tokenizer, old_answer) if old_answer else None
+    
+    final_probs = F.softmax(final_logits, dim=-1)
+    sorted_indices = final_probs.argsort(descending=True)
+    
+    expected_answer_prob = 0.0
+    expected_answer_rank = -1
+    if expected_token_id is not None:
+        expected_answer_prob = final_probs[expected_token_id].item()
+        rank_mask = (sorted_indices == expected_token_id).nonzero(as_tuple=True)[0]
+        expected_answer_rank = rank_mask[0].item() if len(rank_mask) > 0 else -1
+    
+    old_answer_prob = 0.0
+    old_answer_rank = -1
+    if old_token_id is not None:
+        old_answer_prob = final_probs[old_token_id].item()
+        rank_mask = (sorted_indices == old_token_id).nonzero(as_tuple=True)[0]
+        old_answer_rank = rank_mask[0].item() if len(rank_mask) > 0 else -1
+    
+    # === LAYER-BY-LAYER ANALYSIS (Logit Lens) ===
+    # Project each layer's hidden state into vocabulary space
+    # using the model's unembedding matrix (lm_head)
+    hidden_states = outputs.hidden_states  # tuple of (num_layers + 1) tensors
+    num_layers = len(hidden_states) - 1  # exclude embedding layer
+    
+    # Get the unembedding matrix
+    if hasattr(model, 'lm_head'):
+        unembed = model.lm_head
+    elif hasattr(model, 'model') and hasattr(model.model, 'lm_head'):
+        unembed = model.model.lm_head
+    else:
+        unembed = None
+    
+    layer_entropies = []
+    layer_top1_tokens = []
+    layer_top1_probs = []
+    layer_expected_probs = []
+    layer_old_probs = []
+    
+    if unembed is not None:
+        # Also need the layer norm before unembedding
+        if hasattr(model, 'model') and hasattr(model.model, 'norm'):
+            final_norm = model.model.norm
+        elif hasattr(model, 'transformer') and hasattr(model.transformer, 'ln_f'):
+            final_norm = model.transformer.ln_f
+        else:
+            final_norm = None
+        
+        for layer_idx in range(num_layers):
+            h = hidden_states[layer_idx + 1][0, -1, :]  # [hidden_dim], last token
+            
+            # Apply final layer norm if available (important for logit lens accuracy)
+            if final_norm is not None:
+                h_normed = final_norm(h.unsqueeze(0)).squeeze(0)
+            else:
+                h_normed = h
+            
+            # Project to vocabulary
+            layer_logits = unembed(h_normed.unsqueeze(0).to(unembed.weight.dtype)).squeeze(0)
+            
+            # Entropy at this layer
+            layer_ent = compute_entropy(layer_logits)
+            layer_entropies.append(layer_ent)
+            
+            # Top prediction at this layer
+            layer_probs = F.softmax(layer_logits, dim=-1)
+            top_prob, top_idx = layer_probs.max(dim=-1)
+            layer_top1_tokens.append(tokenizer.decode(top_idx.item()))
+            layer_top1_probs.append(top_prob.item())
+            
+            # Track expected and old answer probability at each layer
+            if expected_token_id is not None:
+                layer_expected_probs.append(layer_probs[expected_token_id].item())
+            else:
+                layer_expected_probs.append(0.0)
+            
+            if old_token_id is not None:
+                layer_old_probs.append(layer_probs[old_token_id].item())
+            else:
+                layer_old_probs.append(0.0)
+    
+    # === ALSO GENERATE THE FULL ANSWER ===
+    with torch.no_grad():
+        gen_outputs = model.generate(
+            **inputs,
+            max_new_tokens=50,
+            do_sample=False,
+        )
+    generated_text = tokenizer.decode(gen_outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
+    
+    return {
+        # Final output signals
+        "output_entropy": output_entropy,
+        "top1_probability": top1_prob,
+        "top1_token": top1_token,
+        "top10_tokens": top10,
+        "generated_answer": generated_text.strip(),
+        
+        # Answer tracking
+        "expected_answer_prob": expected_answer_prob,
+        "expected_answer_rank": expected_answer_rank,
+        "old_answer_prob": old_answer_prob,
+        "old_answer_rank": old_answer_rank,
+        
+        # Layer-by-layer signals
+        "layer_entropies": layer_entropies,
+        "layer_top1_tokens": layer_top1_tokens,
+        "layer_top1_probs": layer_top1_probs,
+        "layer_expected_answer_probs": layer_expected_probs,
+        "layer_old_answer_probs": layer_old_probs,
+        "num_layers": num_layers,
+    }
+
+
+def run_analysis(model, tokenizer, samples, output_dir, device="cuda", max_samples=None):
+    """Run analysis on all samples and aggregate results."""
+    os.makedirs(output_dir, exist_ok=True)
+    
+    if max_samples and len(samples) > max_samples:
+        # Balanced sampling: ensure we get drifted + non-drifted
+        import random
+        random.seed(42)
+        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_drifted = min(len(drifted), max(max_samples // 3, 1))
+        n_other = min(len(not_drifted), max_samples - n_drifted)
+        if drifted:
+            samples = random.sample(drifted, n_drifted) + random.sample(not_drifted, n_other)
+        else:
+            samples = random.sample(not_drifted, min(len(not_drifted), max_samples))
+        random.shuffle(samples)
+        logger.info(f"Balanced sample: {n_drifted} drifted + {n_other} non-drifted = {len(samples)}")
+    
+    all_results = []
+    
+    # Group results by category for comparison
+    category_signals = defaultdict(lambda: {
+        "entropies": [], "top1_probs": [], "expected_probs": [],
+        "old_probs": [], "expected_ranks": [],
+        "layer_entropies": [], "layer_top1_probs": [],
+        "layer_expected_probs": [], "layer_old_probs": [],
+    })
+    
+    logger.info(f"Analyzing {len(samples)} samples...")
+    
+    for sample in tqdm(samples, desc="Analyzing queries"):
+        query = sample["query"]
+        expected = sample.get("expected_answer", "")
+        old = sample.get("model_likely_answer", "")
+        category = sample.get("category", "unknown")
+        is_drifted = sample.get("is_drifted_query", False)
+        year = sample.get("year", 0)
+        
+        # Only analyze 2025 (post-cutoff) queries for the main comparison
+        # But also include some pre-cutoff for baseline
+        try:
+            result = analyze_single_query(
+                model, tokenizer, query,
+                expected_answer=expected,
+                old_answer=old,
+                device=device,
+            )
+        except Exception as e:
+            logger.error(f"Error analyzing query: {e}")
+            continue
+        
+        # Add metadata
+        result["query"] = query
+        result["expected_answer"] = expected
+        result["model_likely_answer"] = old
+        result["category"] = category
+        result["is_drifted_query"] = is_drifted
+        result["year"] = year
+        result["knowledge_type"] = sample.get("knowledge_type", "")
+        result["temporal_zone"] = sample.get("temporal_zone", "")
+        result["entity"] = sample.get("entity", "")
+        
+        all_results.append(result)
+        
+        # Aggregate by category
+        # Use fine-grained grouping: category + temporal_zone
+        if is_drifted:
+            group = "DRIFTED (post-cutoff, answer changed)"
+        elif category == "stable":
+            if sample.get("temporal_zone") == "post_cutoff":
+                group = "STABLE (post-cutoff, never changes)"
+            else:
+                group = "STABLE (pre-cutoff, never changes)"
+        elif category == "no_drift":
+            if sample.get("temporal_zone") == "post_cutoff":
+                group = "NO_DRIFT (post-cutoff, could change but didn't)"
+            else:
+                group = "NO_DRIFT (pre-cutoff)"
+        elif category == "known_drift":
+            group = "KNOWN_DRIFT (pre-cutoff, model knows change)"
+        else:
+            group = f"{category}_{sample.get('temporal_zone', 'unknown')}"
+        
+        signals = category_signals[group]
+        signals["entropies"].append(result["output_entropy"])
+        signals["top1_probs"].append(result["top1_probability"])
+        signals["expected_probs"].append(result["expected_answer_prob"])
+        signals["old_probs"].append(result["old_answer_prob"])
+        signals["expected_ranks"].append(result["expected_answer_rank"])
+        if result["layer_entropies"]:
+            signals["layer_entropies"].append(result["layer_entropies"])
+            signals["layer_top1_probs"].append(result["layer_top1_probs"])
+            signals["layer_expected_probs"].append(result["layer_expected_answer_probs"])
+            signals["layer_old_probs"].append(result["layer_old_answer_probs"])
+    
+    # === SAVE RAW RESULTS ===
+    # Remove non-serializable items for JSON
+    serializable_results = []
+    for r in all_results:
+        sr = {k: v for k, v in r.items()}
+        serializable_results.append(sr)
+    
+    raw_path = os.path.join(output_dir, "raw_results.json")
+    with open(raw_path, 'w', encoding='utf-8') as f:
+        json.dump(serializable_results, f, indent=2, ensure_ascii=False, default=str)
+    logger.info(f"Saved raw results to {raw_path}")
+    
+    # === COMPUTE AND PRINT AGGREGATE STATISTICS ===
+    print("\n" + "=" * 80)
+    print("  KNOWLEDGE DRIFT INTERNAL SIGNAL ANALYSIS")
+    print("=" * 80)
+    
+    # Header
+    print(f"\n{'Group':<55} {'Count':>6} {'Entropy':>10} {'Top1 Prob':>10} {'Exp Prob':>10} {'Exp Rank':>10}")
+    print("-" * 105)
+    
+    summary = {}
+    for group in sorted(category_signals.keys()):
+        signals = category_signals[group]
+        n = len(signals["entropies"])
+        if n == 0:
+            continue
+        
+        avg_entropy = np.mean(signals["entropies"])
+        avg_top1 = np.mean(signals["top1_probs"])
+        avg_exp_prob = np.mean(signals["expected_probs"])
+        valid_ranks = [r for r in signals["expected_ranks"] if r >= 0]
+        avg_rank = np.mean(valid_ranks) if valid_ranks else -1
+        
+        print(f"{group:<55} {n:>6} {avg_entropy:>10.4f} {avg_top1:>10.4f} {avg_exp_prob:>10.4f} {avg_rank:>10.1f}")
+        
+        summary[group] = {
+            "count": n,
+            "avg_entropy": float(avg_entropy),
+            "std_entropy": float(np.std(signals["entropies"])),
+            "avg_top1_prob": float(avg_top1),
+            "std_top1_prob": float(np.std(signals["top1_probs"])),
+            "avg_expected_answer_prob": float(avg_exp_prob),
+            "avg_expected_answer_rank": float(avg_rank),
+            "avg_old_answer_prob": float(np.mean(signals["old_probs"])) if signals["old_probs"] else 0,
+        }
+        
+        # Compute layer-wise averages
+        if signals["layer_entropies"]:
+            layer_ent_array = np.array(signals["layer_entropies"])
+            layer_top1_array = np.array(signals["layer_top1_probs"])
+            layer_exp_array = np.array(signals["layer_expected_probs"])
+            layer_old_array = np.array(signals["layer_old_probs"])
+            
+            summary[group]["layer_avg_entropies"] = layer_ent_array.mean(axis=0).tolist()
+            summary[group]["layer_avg_top1_probs"] = layer_top1_array.mean(axis=0).tolist()
+            summary[group]["layer_avg_expected_probs"] = layer_exp_array.mean(axis=0).tolist()
+            summary[group]["layer_avg_old_probs"] = layer_old_array.mean(axis=0).tolist()
+    
+    # === KEY COMPARISONS ===
+    print("\n" + "=" * 80)
+    print("  KEY COMPARISONS")
+    print("=" * 80)
+    
+    drifted_key = "DRIFTED (post-cutoff, answer changed)"
+    nodrift_key = "NO_DRIFT (post-cutoff, could change but didn't)"
+    stable_key = "STABLE (post-cutoff, never changes)"
+    
+    if drifted_key in summary and nodrift_key in summary:
+        d = summary[drifted_key]
+        nd = summary[nodrift_key]
+        
+        print(f"\n  🔥 DRIFTED vs NO_DRIFT (both post-cutoff, same fact types):")
+        print(f"     Entropy:    DRIFTED={d['avg_entropy']:.4f}  vs  NO_DRIFT={nd['avg_entropy']:.4f}  "
+              f"(Δ={d['avg_entropy'] - nd['avg_entropy']:+.4f})")
+        print(f"     Top1 Prob:  DRIFTED={d['avg_top1_prob']:.4f}  vs  NO_DRIFT={nd['avg_top1_prob']:.4f}  "
+              f"(Δ={d['avg_top1_prob'] - nd['avg_top1_prob']:+.4f})")
+        print(f"     Exp Answer: DRIFTED={d['avg_expected_answer_prob']:.4f}  vs  NO_DRIFT={nd['avg_expected_answer_prob']:.4f}")
+        
+        if d['avg_entropy'] > nd['avg_entropy']:
+            print(f"\n     ✅ Model is MORE uncertain on drifted facts (higher entropy)")
+        else:
+            print(f"\n     ⚠️  Model is NOT more uncertain on drifted facts")
+        
+        if d['avg_top1_prob'] < nd['avg_top1_prob']:
+            print(f"     ✅ Model is LESS confident on drifted facts (lower top-1 prob)")
+        else:
+            print(f"     ⚠️  Model is NOT less confident on drifted facts")
+    
+    if drifted_key in summary and stable_key in summary:
+        d = summary[drifted_key]
+        s = summary[stable_key]
+        print(f"\n  🔥 DRIFTED vs STABLE (post-cutoff):")
+        print(f"     Entropy:    DRIFTED={d['avg_entropy']:.4f}  vs  STABLE={s['avg_entropy']:.4f}  "
+              f"(Δ={d['avg_entropy'] - s['avg_entropy']:+.4f})")
+        print(f"     Top1 Prob:  DRIFTED={d['avg_top1_prob']:.4f}  vs  STABLE={s['avg_top1_prob']:.4f}  "
+              f"(Δ={d['avg_top1_prob'] - s['avg_top1_prob']:+.4f})")
+    
+    # === SAVE SUMMARY ===
+    summary_path = os.path.join(output_dir, "signal_summary.json")
+    with open(summary_path, 'w') as f:
+        json.dump(summary, f, indent=2)
+    logger.info(f"Saved summary to {summary_path}")
+    
+    # === SAVE LAYER-WISE DATA FOR PLOTTING ===
+    plot_data_path = os.path.join(output_dir, "layer_signals_for_plotting.json")
+    plot_data = {}
+    for group, data in summary.items():
+        if "layer_avg_entropies" in data:
+            plot_data[group] = {
+                "layer_entropies": data["layer_avg_entropies"],
+                "layer_top1_probs": data["layer_avg_top1_probs"],
+                "layer_expected_probs": data["layer_avg_expected_probs"],
+                "layer_old_probs": data["layer_avg_old_probs"],
+            }
+    
+    with open(plot_data_path, 'w') as f:
+        json.dump(plot_data, f, indent=2)
+    logger.info(f"Saved plot data to {plot_data_path}")
+    
+    # === PRINT EXAMPLE DRIFTED QUERIES ===
+    print("\n" + "=" * 80)
+    print("  EXAMPLE DRIFTED QUERIES (model answers vs ground truth)")
+    print("=" * 80)
+    
+    drifted_examples = [r for r in all_results if r.get("is_drifted_query")][:10]
+    for ex in drifted_examples:
+        print(f"\n  Q: {ex['query']}")
+        print(f"  Model says: '{ex['generated_answer']}'")
+        print(f"  Should be:  '{ex['expected_answer']}'")
+        print(f"  Old answer: '{ex['model_likely_answer']}'")
+        print(f"  Entropy: {ex['output_entropy']:.4f} | Top1 prob: {ex['top1_probability']:.4f}")
+        top3 = ', '.join(f"{t['token']}({t['probability']:.3f})" for t in ex['top10_tokens'][:3])
+        print(f"  Top 3 tokens: {top3}")
+    
+    print("\n" + "=" * 80)
+    
+    return summary
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Analyze internal drift signals")
+    parser.add_argument("--model", type=str, default="Qwen/Qwen2.5-7B-Instruct")
+    parser.add_argument("--dataset", type=str, default="data/knowledge_drift_dataset.json")
+    parser.add_argument("--output", type=str, default="data/drift_analysis/")
+    parser.add_argument("--max_samples", type=int, default=None)
+    parser.add_argument("--device", type=str, default="auto")
+    parser.add_argument("--post_cutoff_only", action="store_true",
+                        help="Only analyze post-cutoff (2025) queries for speed")
+    
+    args = parser.parse_args()
+    
+    # Load dataset
+    logger.info(f"Loading dataset from {args.dataset}")
+    with open(args.dataset, 'r', encoding='utf-8') as f:
+        dataset = json.load(f)
+    
+    samples = dataset["samples"]
+    
+    # Filter to post-cutoff if requested (much faster, focuses on the key comparison)
+    if args.post_cutoff_only:
+        samples = [s for s in samples if s.get("temporal_zone") == "post_cutoff"]
+        logger.info(f"Filtered to {len(samples)} post-cutoff samples")
+    
+    if args.max_samples:
+        # Smart sampling: ensure we get a balanced mix
+        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_drifted = min(len(drifted), args.max_samples // 3)
+        n_other = min(len(not_drifted), args.max_samples - n_drifted)
+        
+        import random
+        random.seed(42)
+        samples = random.sample(drifted, n_drifted) + random.sample(not_drifted, n_other)
+        random.shuffle(samples)
+        logger.info(f"Sampled {len(samples)} samples ({n_drifted} drifted, {n_other} non-drifted)")
+    
+    # Load model
+    model, tokenizer = load_model(args.model, device=args.device)
+    
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    if args.device != "auto":
+        device = args.device
+    
+    # Run analysis
+    summary = run_analysis(model, tokenizer, samples, args.output, device=device)
+    
+    logger.info(f"\nDone! Results saved to {args.output}")
+    logger.info(f"Next: python plot_drift_signals.py --input {args.output}")
+
+
+if __name__ == "__main__":
+    main()

analyze_single.py

@@ -0,0 +1,1235 @@
+#!/usr/bin/env python3
+"""
+analyze_single.py — Per-Model Disentanglement Analysis
+=======================================================
+Runs on cached hidden states only. Never touches the model.
+Produces all per-model results, figures, and probe bundles.
+
+Experiments:
+  [CORE]   L1-ISTA probing: drift / uncertainty / correctness (true sparsity)
+  [IDEA-1] Drift vs Correctness dissociation — Cell B key result
+  [NEW-A]  Null-space projection: project out uncertainty, re-probe drift
+  [NEW-B]  Probe direction stability: L×L cosine matrix
+  [NEW-C]  Logit lens: per-layer P(expected token) decay curve
+  [NEW-E]  Temporal distance: drift score vs months since cutoff
+  [NEW-F]  Calibration: reliability diagrams
+  [PERM]   Permutation test at best layer
+  [SPARSE] Lambda-AUROC-neurons sparsity tradeoff
+  [REL]    Per-relation breakdown
+
+Outputs:
+  final_results.json            Complete results summary
+  all_layer_results.json        Per-layer JSON (resumable)
+  probe_bundle_{model}.npz      Weight vectors + norms for cross-model
+  per_layer/layer_XX.json       Individual layer results
+  figures/fig1..fig11.png       Publication figures
+
+Usage:
+  python analyze_single.py --model qwen25
+  python analyze_single.py --model llama31 --layers 20 21 22 23 24 25 26 27
+  python analyze_single.py --model qwen25 --skip_permutation --skip_logit_lens
+"""
+
+import argparse
+import json
+import logging
+import time
+import warnings
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+import torch
+import yaml
+
+warnings.filterwarnings("ignore")
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[logging.StreamHandler()])
+logger = logging.getLogger(__name__)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# CONFIG
+# ─────────────────────────────────────────────────────────────────────────────
+
+def load_config(config_path="models.yaml"):
+    with open(config_path) as f:
+        return yaml.safe_load(f)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# L1-ISTA PROBE (true sparsity)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def soft_threshold(w, lam):
+    return torch.sign(w) * torch.clamp(torch.abs(w) - lam, min=0.0)
+
+
+class L1ProbeGPU:
+    """L1-regularised logistic regression via ISTA on GPU."""
+
+    def __init__(self, dim, lam=1e-3, max_iter=2000, tol=1e-6, device="cuda"):
+        self.lam = lam
+        self.max_iter = max_iter
+        self.tol = tol
+        self.device = device
+        self.w = torch.zeros(dim, device=device)
+        self.b = torch.zeros(1, device=device)
+        self.coef_ = None
+
+    def _loss_grad(self, w, b, X, y):
+        z = torch.clamp(X @ w + b, -30, 30)
+        p = torch.sigmoid(z)
+        L = -((y * torch.log(p + 1e-12)) +
+              (1 - y) * torch.log(1 - p + 1e-12)).mean()
+        e = p - y
+        return L, (X.T @ e) / len(y), e.mean().unsqueeze(0)
+
+    def fit(self, X, y):
+        w = torch.zeros(X.shape[1], device=self.device)
+        b = torch.zeros(1, device=self.device)
+        lr = 1.0
+        for _ in range(self.max_iter):
+            L, gw, gb = self._loss_grad(w, b, X, y)
+            for _ in range(30):
+                wt = soft_threshold(w - lr * gw, lr * self.lam)
+                bt = b - lr * gb
+                Lt, _, _ = self._loss_grad(wt, bt, X, y)
+                if Lt <= L + 1e-4:
+                    break
+                lr *= 0.5
+            lr = min(lr * 1.05, 10.0)
+            if (wt - w).abs().max().item() < self.tol:
+                w, b = wt, bt
+                break
+            w, b = wt, bt
+        self.w, self.b = w, b
+        self.coef_ = [w.cpu().numpy()]
+        return self
+
+    @torch.no_grad()
+    def predict_proba_t(self, X):
+        p = torch.sigmoid(torch.clamp(X @ self.w + self.b, -30, 30))
+        p = p.cpu().numpy().ravel()
+        return np.column_stack([1 - p, p])
+
+
+class ProbeWrapper:
+    """Wraps L1ProbeGPU with preprocessing and sklearn-like interface."""
+
+    def __init__(self, probe, mean, std, device):
+        self._p = probe
+        self._mean = mean
+        self._std = std
+        self._dev = device
+        self.coef_ = probe.coef_
+
+    def _to_gpu(self, X_np):
+        X = np.nan_to_num(X_np.astype(np.float32), nan=0., posinf=1e4, neginf=-1e4)
+        X = np.clip(X, -1e4, 1e4)
+        return torch.tensor((X - self._mean) / self._std,
+                            dtype=torch.float32, device=self._dev)
+
+    def predict_proba(self, X_np):
+        return self._p.predict_proba_t(self._to_gpu(X_np))
+
+    @property
+    def w_np(self):
+        return self._p.w.cpu().numpy()
+
+    @property
+    def n_active(self):
+        return int(np.sum(self.w_np != 0))
+
+    @property
+    def norm_stats(self):
+        return {"mean": self._mean, "std": self._std}
+
+
+def _preprocess(X_np):
+    X = np.nan_to_num(X_np.astype(np.float32), nan=0., posinf=1e4, neginf=-1e4)
+    X = np.clip(X, -1e4, 1e4)
+    m = X.mean(0, keepdims=True)
+    s = X.std(0, keepdims=True) + 1e-8
+    return X, m, s
+
+
+def fit_probe(X_np, y_np, lam, device, max_iter=2000):
+    X, m, s = _preprocess(X_np)
+    Xt = torch.tensor((X - m) / s, dtype=torch.float32, device=device)
+    yt = torch.tensor(y_np.astype(np.float32), device=device)
+    p = L1ProbeGPU(Xt.shape[1], lam=lam, max_iter=max_iter, device=device)
+    p.fit(Xt, yt)
+    return ProbeWrapper(p, m, s, device)
+
+
+def cv_auroc(X_np, y_np, lam, device, max_iter=500, n_splits=3):
+    from sklearn.model_selection import StratifiedKFold
+    from sklearn.metrics import roc_auc_score
+    min_c = min(int(y_np.sum()), int((1 - y_np).sum()))
+    k = min(n_splits, min_c)
+    if k < 2:
+        return 0.5
+    scores = []
+    for tr, va in StratifiedKFold(k, shuffle=True, random_state=42).split(X_np, y_np):
+        pw = fit_probe(X_np[tr], y_np[tr], lam, device, max_iter)
+        p = pw.predict_proba(X_np[va])[:, 1]
+        if len(np.unique(y_np[va])) > 1:
+            scores.append(roc_auc_score(y_np[va], p))
+    return float(np.mean(scores)) if scores else 0.5
+
+
+def best_probe(X_np, y_np, device, lambda_grid, max_iter=2000, cv_max_iter=500):
+    best_au, best_lam = 0.0, lambda_grid[0]
+    for lam in lambda_grid:
+        au = cv_auroc(X_np, y_np, lam, device, max_iter=cv_max_iter)
+        if au > best_au:
+            best_au, best_lam = au, lam
+    return fit_probe(X_np, y_np, best_lam, device, max_iter), best_au, best_lam
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# UTILITIES
+# ─────────────────────────────────────────────────────────────────────────────
+
+def cosine(w1, w2):
+    n1, n2 = np.linalg.norm(w1), np.linalg.norm(w2)
+    return float(np.dot(w1, w2) / (n1 * n2 + 1e-12))
+
+
+def jaccard(w1, w2):
+    s1 = set(np.where(w1 != 0)[0])
+    s2 = set(np.where(w2 != 0)[0])
+    u = len(s1 | s2)
+    return len(s1 & s2) / u if u > 0 else 0.0
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PER-LAYER ANALYSIS
+# ─────────────────────────────────────────────────────────────────────────────
+
+def analyze_layer(layer, results, device, lambda_grid, max_iter=2000,
+                  cv_max_iter=500):
+    from sklearn.metrics import roc_auc_score
+    t0 = time.time()
+
+    drifted = [r for r in results if r["is_drifted"]]
+    non_drifted = [r for r in results if not r["is_drifted"]]
+
+    X_all = np.array([r["hidden_states"][layer] for r in results])
+    y_drift = np.array([int(r["is_drifted"]) for r in results])
+    y_corr = np.array([int(r.get("correct", False)) for r in results])
+
+    # 1. Drift probe
+    dp, dp_au, dp_lam = best_probe(X_all, y_drift, device, lambda_grid,
+                                    max_iter, cv_max_iter)
+    w_d = dp.w_np
+
+    # 2. Uncertainty probe (on non-drifted only)
+    X_nd = np.array([r["hidden_states"][layer] for r in non_drifted])
+    ct = float(np.median([r["top_prob"] for r in non_drifted]))
+    y_unc = np.array([int(r["top_prob"] < ct) for r in non_drifted])
+    if y_unc.sum() < 5 or (len(y_unc) - y_unc.sum()) < 5:
+        ct = 0.5
+        y_unc = np.array([int(r["top_prob"] < ct) for r in non_drifted])
+    up, up_au, up_lam = best_probe(X_nd, y_unc, device, lambda_grid,
+                                    max_iter, cv_max_iter)
+    w_u = up.w_np
+
+    # 3. Correctness probe
+    cp, cp_au, cp_lam = None, 0.5, 0.0
+    w_c = np.zeros_like(w_d)
+    nc, nw = int(y_corr.sum()), int((1 - y_corr).sum())
+    if nc >= 10 and nw >= 10:
+        cp, cp_au, cp_lam = best_probe(X_all, y_corr, device, lambda_grid,
+                                        max_iter, cv_max_iter)
+        w_c = cp.w_np
+
+    # 4. Cosines + Jaccard
+    cos_du = cosine(w_d, w_u)
+    cos_dc = cosine(w_d, w_c)
+    cos_uc = cosine(w_u, w_c)
+    jac_du = jaccard(w_d, w_u)
+    jac_dc = jaccard(w_d, w_c)
+
+    # 5. [NEW-A] Null-space projection
+    ns_au = 0.5
+    wu_n = np.linalg.norm(w_u)
+    if wu_n > 1e-8:
+        u_hat = w_u / wu_n
+        X_perp = X_all - (X_all @ u_hat)[:, None] * u_hat[None, :]
+        _, ns_au, _ = best_probe(X_perp, y_drift, device, lambda_grid,
+                                  max_iter, cv_max_iter)
+
+    # 6. Cell analysis (Idea 1)
+    cells = {}
+    for cname, samps in [
+        ("A_confident_stable", [r for r in non_drifted if r["top_prob"] >= ct]),
+        ("B_confident_drifted", [r for r in drifted if r["top_prob"] >= ct]),
+        ("C_uncertain_stable", [r for r in non_drifted if r["top_prob"] < ct]),
+        ("D_uncertain_drifted", [r for r in drifted if r["top_prob"] < ct]),
+    ]:
+        if not samps:
+            cells[cname] = {"n": 0}
+            continue
+        Xc = np.array([r["hidden_states"][layer] for r in samps])
+        p_d = dp.predict_proba(Xc)[:, 1]
+        p_c = cp.predict_proba(Xc)[:, 1] if cp else np.full(len(samps), 0.5)
+        p_u = up.predict_proba(Xc)[:, 1]
+        cells[cname] = {
+            "n": len(samps),
+            "drift_mean": float(np.mean(p_d)),
+            "drift_std": float(np.std(p_d)),
+            "correct_mean": float(np.mean(p_c)),
+            "correct_std": float(np.std(p_c)),
+            "uncertainty_mean": float(np.mean(p_u)),
+            "uncertainty_std": float(np.std(p_u)),
+            "drift_flag_rate": float(np.mean(p_d > 0.5)),
+            "correct_flag_rate": float(np.mean(p_c > 0.5)),
+        }
+
+    # 7. Per-relation probing
+    per_rel = {}
+    for rel in sorted(set(r.get("relation", "unknown") for r in results)):
+        rs = [r for r in results if r.get("relation", "unknown") == rel]
+        nd_ = sum(1 for r in rs if r["is_drifted"])
+        ns_ = len(rs) - nd_
+        if nd_ < 5 or ns_ < 5:
+            continue
+        Xr = np.array([r["hidden_states"][layer] for r in rs])
+        ydr = np.array([int(r["is_drifted"]) for r in rs])
+        ycr = np.array([int(r.get("correct", False)) for r in rs])
+        try:
+            au_d = roc_auc_score(ydr, dp.predict_proba(Xr)[:, 1])
+        except Exception:
+            au_d = 0.5
+        try:
+            au_c = (roc_auc_score(ycr, cp.predict_proba(Xr)[:, 1])
+                    if cp else 0.5)
+        except Exception:
+            au_c = 0.5
+        per_rel[rel] = {"drift_auroc": au_d, "correct_auroc": au_c,
+                        "n_drifted": nd_, "n_stable": ns_}
+
+    return {
+        "layer": layer,
+        "drift_auroc": dp_au,
+        "uncertainty_auroc": up_au,
+        "correctness_auroc": cp_au,
+        "drift_lam": dp_lam,
+        "cos_du": cos_du,
+        "cos_dc": cos_dc,
+        "cos_uc": cos_uc,
+        "jaccard_du": jac_du,
+        "jaccard_dc": jac_dc,
+        "n_active_drift": dp.n_active,
+        "n_active_unc": up.n_active,
+        "n_active_corr": int(np.sum(w_c != 0)),
+        "null_space_drift_auroc": ns_au,
+        "conf_threshold": ct,
+        "cells": cells,
+        "per_relation": per_rel,
+        "elapsed_s": time.time() - t0,
+        # Kept in memory for figures/bundle — stripped before JSON save
+        "_w_drift": w_d, "_w_unc": w_u, "_w_corr": w_c,
+        "_probes": {"drift": dp, "uncertainty": up, "correctness": cp},
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# [NEW-B] PROBE DIRECTION STABILITY
+# ─────────────────────────────────────────────────────────────────────────────
+
+def probe_direction_stability(all_lr):
+    layers = sorted(k for k in all_lr if "_w_drift" in all_lr[k])
+    n = len(layers)
+    mat = np.eye(n)
+    for i, l1 in enumerate(layers):
+        for j, l2 in enumerate(layers):
+            if i != j:
+                mat[i, j] = cosine(all_lr[l1]["_w_drift"],
+                                    all_lr[l2]["_w_drift"])
+    return layers, mat
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# [NEW-C] LOGIT LENS
+# ─────────────────────────────────────────────────────────────────────────────
+
+def logit_lens_analysis(results, model_dir, model_key, device):
+    lm_path = Path(model_dir) / f"lm_head_{model_key}.npz"
+    if not lm_path.exists():
+        logger.warning(f"lm_head not found: {lm_path}")
+        return None
+
+    lm = np.load(str(lm_path), allow_pickle=True)
+    lm_w = torch.tensor(lm["lm_head"], dtype=torch.float32, device=device)
+    ln_w = torch.tensor(lm["ln_weight"], dtype=torch.float32, device=device)
+    ln_b = torch.tensor(lm["ln_bias"], dtype=torch.float32, device=device)
+
+    layers = sorted(results[0]["hidden_states"].keys())
+    drifted = [r for r in results if r["is_drifted"]]
+    stable = [r for r in results if not r["is_drifted"]]
+
+    def layer_prob(samps, layer):
+        probs = []
+        for r in samps:
+            h = torch.tensor(r["hidden_states"][layer],
+                             dtype=torch.float32, device=device)
+            h_n = (h - h.mean()) / (h.std() + 1e-5) * ln_w + ln_b
+            lgts = torch.clamp(lm_w @ h_n, -60, 60)
+            p = torch.softmax(lgts, dim=-1)
+            probs.append(float(p.max().item()))
+        return float(np.mean(probs)) if probs else 0.0
+
+    data = {"layers": layers, "drifted": [], "stable": []}
+    for l in layers:
+        data["drifted"].append(layer_prob(drifted, l))
+        data["stable"].append(layer_prob(stable, l))
+        if (l + 1) % 7 == 0:
+            logger.info(f"  logit lens L{l}: "
+                        f"drifted={data['drifted'][-1]:.4f} "
+                        f"stable={data['stable'][-1]:.4f}")
+    return data
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# [NEW-E] TEMPORAL DISTANCE
+# ─────────────────────────────────────────────────────────────────────────────
+
+def temporal_distance_analysis(results, cutoff_months):
+    bins, scores = [], []
+    for r in results:
+        if not r["is_drifted"]:
+            continue
+        cd = r.get("drift_date")
+        if cd in (None, "", "None"):
+            continue
+        try:
+            pts = str(cd).split("T")[0].split("-")
+            y = int(pts[0])
+            m = int(pts[1]) if len(pts) > 1 else 6
+            dist = (y - 2020) * 12 + m - cutoff_months
+        except Exception:
+            continue
+        if not (-60 <= dist <= 60):
+            continue
+        bins.append(dist)
+        scores.append(r.get("_drift_score", 0.5))
+
+    if len(bins) < 20:
+        return None
+    bins, scores = np.array(bins), np.array(scores)
+    corr = float(np.corrcoef(bins, scores)[0, 1])
+    logger.info(f"  Temporal corr: {corr:.4f} ({len(bins)} samples)")
+    return {"bins": bins.tolist(), "scores": scores.tolist(),
+            "correlation": corr}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PERMUTATION TEST
+# ─────────────────────────────────────────────────────────────────────────────
+
+def permutation_test(results, best_layer, n_perms, device, lambda_grid):
+    from sklearn.metrics import roc_auc_score
+    logger.info(f"Permutation test ({n_perms}) at layer {best_layer}")
+    X = np.array([r["hidden_states"][best_layer] for r in results])
+    y = np.array([int(r["is_drifted"]) for r in results])
+    _, true_au, _ = best_probe(X, y, device, lambda_grid, cv_max_iter=300)
+    logger.info(f"  True AUROC: {true_au:.4f}")
+
+    nulls = []
+    for i in range(n_perms):
+        y_perm = np.random.permutation(y)
+        pw = fit_probe(X, y_perm, 1e-3, device, max_iter=300)
+        p_n = pw.predict_proba(X)[:, 1]
+        try:
+            nulls.append(roc_auc_score(y_perm, p_n))
+        except Exception:
+            nulls.append(0.5)
+        if (i + 1) % 250 == 0:
+            logger.info(f"  {i+1}/{n_perms}  null_mean={np.mean(nulls):.4f}")
+
+    nulls = np.array(nulls)
+    p_val = float(np.mean(nulls >= true_au))
+    logger.info(f"  p={p_val:.6f}  null_mean={nulls.mean():.4f}")
+    return {"true_auroc": float(true_au), "null_mean": float(nulls.mean()),
+            "null_std": float(nulls.std()), "p_value": p_val, "n": n_perms}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SPARSITY CURVE
+# ─────────────────────────────────────────────────────────────────────────────
+
+def sparsity_curve(results, best_layer, device, sparsity_lambdas):
+    logger.info(f"Sparsity curve at layer {best_layer}")
+    X = np.array([r["hidden_states"][best_layer] for r in results])
+    y = np.array([int(r["is_drifted"]) for r in results])
+    out = []
+    for lam in sparsity_lambdas:
+        pw = fit_probe(X, y, lam, device, max_iter=500)
+        au = cv_auroc(X, y, lam, device, max_iter=300)
+        out.append({"lambda": lam, "n_active": pw.n_active, "auroc": float(au)})
+        logger.info(f"  lam={lam:.2e}  active={pw.n_active:>5d}  AUROC={au:.4f}")
+    return out
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PROBE BUNDLE EXPORT (for cross-model analysis)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def export_probe_bundle(all_lr, best_layer, results, model_key, out_dir):
+    """Export probe weight vectors + normalization stats for cross_model.py."""
+    bl = all_lr[best_layer]
+    X = np.array([r["hidden_states"][best_layer] for r in results])
+    _, m, s = _preprocess(X)
+
+    bundle = {
+        "model_key": model_key,
+        "best_layer": best_layer,
+        "hidden_dim": X.shape[1],
+        "n_samples": len(results),
+        "w_drift": bl["_w_drift"],
+        "w_unc": bl["_w_unc"],
+        "w_corr": bl["_w_corr"],
+        "norm_mean": m,
+        "norm_std": s,
+        "drift_auroc": bl["drift_auroc"],
+        "n_active_drift": bl["n_active_drift"],
+        "cos_du": bl["cos_du"],
+        "cos_dc": bl["cos_dc"],
+    }
+    path = Path(out_dir) / f"probe_bundle_{model_key}.npz"
+    np.savez_compressed(str(path), **{k: v for k, v in bundle.items()})
+    logger.info(f"  Probe bundle: {path}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# FIGURES (same as v3 — consolidated)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def save_figures(all_lr, model_dir, model_key, results,
+                 stability_data=None, lens_data=None,
+                 sparsity_data=None, temporal_data=None):
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    fig_dir = Path(model_dir) / "figures"
+    fig_dir.mkdir(parents=True, exist_ok=True)
+
+    layers = sorted(k for k in all_lr if "drift_auroc" in all_lr[k])
+    if len(layers) < 2:
+        return
+    best = max(layers, key=lambda l: all_lr[l]["drift_auroc"])
+
+    P = {"drift": "#e74c3c", "unc": "#3498db", "corr": "#2ecc71",
+         "null": "#9b59b6", "neu": "#e67e22"}
+
+    # ── Fig 1: 6-panel dashboard ──────────────────────────────────────────
+    fig, axes = plt.subplots(2, 3, figsize=(22, 12))
+    fig.suptitle(f"[{model_key}] Disentanglement Dashboard", fontsize=16,
+                 fontweight="bold")
+
+    ax = axes[0, 0]
+    for key, lbl, col, ls in [
+        ("drift_auroc", "Drift", P["drift"], "-"),
+        ("uncertainty_auroc", "Uncertainty", P["unc"], "--"),
+        ("correctness_auroc", "Correctness", P["corr"], "-."),
+        ("null_space_drift_auroc", "Drift (null-space)", P["null"], ":"),
+    ]:
+        ax.plot(layers, [all_lr[l].get(key, np.nan) for l in layers],
+                f"o{ls}", color=col, lw=2, ms=5, label=lbl)
+    ax.axvline(best, color="gray", ls="--", alpha=0.4)
+    ax.set(xlabel="Layer", ylabel="AUROC", title="Probe AUROC by Layer",
+           ylim=(0.4, 1.05))
+    ax.legend(fontsize=9)
+    ax.grid(alpha=0.3)
+
+    ax = axes[0, 1]
+    for key, lbl, col in [
+        ("cos_du", "|cos(drift, unc)|", P["drift"]),
+        ("cos_dc", "|cos(drift, corr)|", P["corr"]),
+        ("cos_uc", "|cos(unc, corr)|", P["unc"]),
+    ]:
+        ax.plot(layers, [abs(all_lr[l].get(key, 0)) for l in layers],
+                "o-", color=col, lw=2, ms=5, label=lbl)
+    ax.axhline(0.3, color="gray", ls="--", alpha=0.4, label="0.3 threshold")
+    ax.set(xlabel="Layer", ylabel="|Cosine Similarity|",
+           title="3-Way Disentanglement", ylim=(0, 1.0))
+    ax.legend(fontsize=9)
+    ax.grid(alpha=0.3)
+
+    ax = axes[0, 2]
+    ax.plot(layers, [all_lr[l].get("n_active_drift", 0) for l in layers],
+            "o-", color=P["drift"], lw=2, ms=5, label="Drift")
+    ax.plot(layers, [all_lr[l].get("n_active_unc", 0) for l in layers],
+            "s-", color=P["unc"], lw=2, ms=5, label="Unc")
+    ax.plot(layers, [all_lr[l].get("n_active_corr", 0) for l in layers],
+            "^-", color=P["corr"], lw=2, ms=5, label="Corr")
+    ax2 = ax.twinx()
+    ax2.plot(layers, [all_lr[l].get("jaccard_du", 0) for l in layers],
+             "D--", color=P["null"], lw=2, ms=4, label="J(d,u)")
+    ax2.plot(layers, [all_lr[l].get("jaccard_dc", 0) for l in layers],
+             "P--", color=P["neu"], lw=2, ms=4, label="J(d,c)")
+    ax.set(xlabel="Layer", ylabel="Active neurons",
+           title="True Sparsity & Jaccard")
+    ax2.set_ylabel("Jaccard")
+    ax.legend(loc="upper left", fontsize=8)
+    ax2.legend(loc="upper right", fontsize=8)
+    ax.grid(alpha=0.3)
+
+    ax = axes[1, 0]
+    d_au = [all_lr[l]["drift_auroc"] for l in layers]
+    ns_au = [all_lr[l].get("null_space_drift_auroc", np.nan) for l in layers]
+    ax.plot(layers, d_au, "o-", color=P["drift"], lw=2.5, ms=7, label="Full")
+    ax.plot(layers, ns_au, "s--", color=P["null"], lw=2, ms=7,
+            label="Null-space of unc")
+    ax.fill_between(layers, ns_au, d_au, alpha=0.15, color=P["null"])
+    ax.set(xlabel="Layer", ylabel="AUROC",
+           title="[NEW-A] Null-Space Projection", ylim=(0.4, 1.05))
+    ax.legend(fontsize=10)
+    ax.grid(alpha=0.3)
+
+    ax = axes[1, 1]
+    bl = best
+    cells = all_lr[bl].get("cells", {})
+    cnames = ["A_confident_stable", "B_confident_drifted",
+              "C_uncertain_stable", "D_uncertain_drifted"]
+    if cells and any(cells.get(c, {}).get("n", 0) > 0 for c in cnames):
+        ns_ = [cells.get(c, {}).get("n", 0) for c in cnames]
+        dm_ = [cells.get(c, {}).get("drift_mean", 0) for c in cnames]
+        cm_ = [cells.get(c, {}).get("correct_mean", 0) for c in cnames]
+        x = np.arange(4)
+        w = 0.35
+        ax.bar(x - w / 2, dm_, w, color=P["drift"], label="Drift",
+               edgecolor="black", lw=0.5)
+        ax.bar(x + w / 2, cm_, w, color=P["corr"], label="Correctness",
+               edgecolor="black", lw=0.5)
+        ax.set_xticks(x)
+        ax.set_xticklabels([f"{c[:3]}\nn={ns_[i]}" for i, c in enumerate(cnames)],
+                           fontsize=9)
+        ax.axhline(0.5, color="gray", ls="--", alpha=0.5)
+        ax.set(ylabel="Mean score", title="[IDEA-1] Cell B Dissociation",
+               ylim=(0, 1.1))
+        ax.legend(fontsize=9)
+        ax.grid(alpha=0.3, axis="y")
+
+    ax = axes[1, 2]
+    if lens_data:
+        ls_ = lens_data["layers"]
+        ax.plot(ls_, lens_data["stable"], "o-", color=P["unc"], lw=2,
+                label="Stable")
+        ax.plot(ls_, lens_data["drifted"], "s--", color=P["drift"], lw=2,
+                label="Drifted")
+        ax.fill_between(ls_, lens_data["drifted"], lens_data["stable"],
+                        alpha=0.2, color=P["drift"])
+        ax.axvline(best, color="gray", ls=":", lw=1.5)
+        ax.set(xlabel="Layer", ylabel="P(expected token)",
+               title="[NEW-C] Logit Lens")
+        ax.legend(fontsize=10)
+        ax.grid(alpha=0.3)
+    else:
+        ax.text(0.5, 0.5, "Logit lens\n(enable with flag)",
+                ha="center", va="center", transform=ax.transAxes)
+
+    plt.tight_layout()
+    plt.savefig(fig_dir / "fig1_dashboard.png", dpi=300, bbox_inches="tight")
+    plt.close()
+    logger.info("  fig1 saved")
+
+    # ── Fig 2: Idea 1 deep dive ──────────────────────────────────────────
+    if cells and any(cells.get(c, {}).get("n", 0) > 0 for c in cnames):
+        fig, axes2 = plt.subplots(1, 3, figsize=(21, 7))
+        fig.suptitle(f"[{model_key}] IDEA-1: Cell B Dissociation (Layer {best})",
+                     fontsize=14, fontweight="bold")
+        clrs = [P["unc"], P["drift"], "#95a5a6", P["neu"]]
+        ns_ = [cells.get(c, {}).get("n", 0) for c in cnames]
+        xlbls = [f"Cell {chr(65+i)}\nn={ns_[i]}" for i in range(4)]
+        x = np.arange(4)
+        w = 0.6
+        for ax, key, ekey, title in [
+            (axes2[0], "drift_mean", "drift_std", "Drift Probe"),
+            (axes2[1], "correct_mean", "correct_std", "Correctness Probe"),
+            (axes2[2], "uncertainty_mean", "uncertainty_std", "Uncertainty Probe"),
+        ]:
+            vals = [cells.get(c, {}).get(key, 0) for c in cnames]
+            errs = [cells.get(c, {}).get(ekey, 0) for c in cnames]
+            ax.bar(x, vals, w, yerr=errs, capsize=7, color=clrs,
+                   edgecolor="black", lw=0.7, alpha=0.85)
+            if vals[1] > 0:
+                ax.annotate("Cell B", xy=(1, vals[1] + errs[1]),
+                            xytext=(1.6, vals[1] + errs[1] + 0.12),
+                            arrowprops=dict(arrowstyle="->", color="red"),
+                            fontsize=9, color="red", fontweight="bold")
+            ax.axhline(0.5, color="gray", ls="--", alpha=0.6)
+            ax.set_xticks(x)
+            ax.set_xticklabels(xlbls, fontsize=9)
+            ax.set(ylabel="Mean score", title=title, ylim=(0, 1.2))
+            ax.grid(alpha=0.3, axis="y")
+        plt.tight_layout()
+        plt.savefig(fig_dir / "fig2_idea1_dissociation.png",
+                    dpi=300, bbox_inches="tight")
+        plt.close()
+        logger.info("  fig2 saved")
+
+    # ── Fig 3: 3×3 cosine heatmap ────────────────────────────────────────
+    bl = best
+    mat = np.array([
+        [1.0, all_lr[bl]["cos_du"], all_lr[bl]["cos_dc"]],
+        [all_lr[bl]["cos_du"], 1.0, all_lr[bl]["cos_uc"]],
+        [all_lr[bl]["cos_dc"], all_lr[bl]["cos_uc"], 1.0],
+    ])
+    fig, ax = plt.subplots(figsize=(8, 7))
+    im = ax.imshow(mat, cmap="RdBu_r", vmin=-1, vmax=1)
+    lbls = ["Drift", "Uncertainty", "Correctness"]
+    ax.set_xticks(range(3))
+    ax.set_yticks(range(3))
+    ax.set_xticklabels(lbls, fontsize=13)
+    ax.set_yticklabels(lbls, fontsize=13)
+    for i in range(3):
+        for j in range(3):
+            c = "white" if abs(mat[i, j]) > 0.5 else "black"
+            ax.text(j, i, f"{mat[i,j]:+.3f}", ha="center", va="center",
+                    fontsize=14, fontweight="bold", color=c)
+    ax.set_title(f"[{model_key}] Cosine Matrix — Layer {bl}", fontsize=13)
+    plt.colorbar(im, ax=ax, shrink=0.8)
+    plt.tight_layout()
+    plt.savefig(fig_dir / "fig3_cosine_matrix.png", dpi=300, bbox_inches="tight")
+    plt.close()
+    logger.info("  fig3 saved")
+
+    # ── Fig 4: PCA ───────────────────────────────────────────────────────
+    if "_w_drift" in all_lr.get(best, {}):
+        from sklearn.decomposition import PCA
+        bl = best
+        X_b = np.array([r["hidden_states"][bl] for r in results])
+        is_d = np.array([r["is_drifted"] for r in results])
+        is_c = np.array([r.get("correct", False) for r in results])
+        pca = PCA(n_components=2)
+        X2 = pca.fit_transform(X_b)
+        Xsc = (X_b - X_b.mean(0)) / (X_b.std(0) + 1e-8)
+        w_d = all_lr[bl]["_w_drift"]
+        w_u = all_lr[bl]["_w_unc"]
+        w_c = all_lr[bl]["_w_corr"]
+        nd, nu, nc_ = (np.linalg.norm(w_d), np.linalg.norm(w_u),
+                        np.linalg.norm(w_c))
+        pd_ = Xsc @ (w_d / (nd + 1e-8))
+        pu_ = Xsc @ (w_u / (nu + 1e-8))
+        pc_ = (Xsc @ (w_c / (nc_ + 1e-8)) if nc_ > 1e-8
+               else np.zeros(len(results)))
+
+        fig, axes3 = plt.subplots(1, 3, figsize=(22, 7))
+        fig.suptitle(f"[{model_key}] Geometry — Layer {bl}", fontsize=14,
+                     fontweight="bold")
+        ax = axes3[0]
+        ax.scatter(X2[~is_d, 0], X2[~is_d, 1], c=P["unc"], alpha=0.3,
+                   s=20, label="Stable", edgecolors="none")
+        ax.scatter(X2[is_d, 0], X2[is_d, 1], c=P["drift"], alpha=0.7,
+                   s=50, label="Drifted", edgecolors="black", lw=0.3,
+                   marker="*")
+        ax.set(xlabel=f"PC1 ({pca.explained_variance_ratio_[0]:.1%})",
+               ylabel=f"PC2 ({pca.explained_variance_ratio_[1]:.1%})",
+               title="PCA")
+        ax.legend()
+        ax.grid(alpha=0.2)
+
+        ax = axes3[1]
+        ax.scatter(pd_[~is_d], pu_[~is_d], c=P["unc"], alpha=0.3, s=20,
+                   label="Stable", edgecolors="none")
+        ax.scatter(pd_[is_d], pu_[is_d], c=P["drift"], alpha=0.7, s=50,
+                   label="Drifted", edgecolors="black", lw=0.3, marker="*")
+        ax.axhline(0, color="gray", ls="--", alpha=0.3)
+        ax.axvline(0, color="gray", ls="--", alpha=0.3)
+        ax.set(xlabel="Drift direction", ylabel="Uncertainty direction",
+               title=f"cos={all_lr[bl]['cos_du']:+.3f}")
+        ax.legend()
+        ax.grid(alpha=0.2)
+
+        ax = axes3[2]
+        ax.scatter(pd_[is_c], pc_[is_c], c=P["corr"], alpha=0.5, s=20,
+                   label="Correct", edgecolors="none")
+        ax.scatter(pd_[~is_c], pc_[~is_c], c=P["drift"], alpha=0.5, s=20,
+                   label="Incorrect", edgecolors="none")
+        ax.axhline(0, color="gray", ls="--", alpha=0.3)
+        ax.axvline(0, color="gray", ls="--", alpha=0.3)
+        ax.set(xlabel="Drift direction", ylabel="Correctness direction",
+               title=f"cos={all_lr[bl]['cos_dc']:+.3f}")
+        ax.legend()
+        ax.grid(alpha=0.2)
+        plt.tight_layout()
+        plt.savefig(fig_dir / "fig4_pca_projection.png",
+                    dpi=300, bbox_inches="tight")
+        plt.close()
+        logger.info("  fig4 saved")
+
+    # ── Fig 5: Direction stability ───────────────────────────────────────
+    if stability_data:
+        sl, sm = stability_data
+        fig, axes4 = plt.subplots(1, 2, figsize=(18, 7))
+        fig.suptitle(f"[{model_key}] [NEW-B] Direction Stability", fontsize=14,
+                     fontweight="bold")
+        ax = axes4[0]
+        im = ax.imshow(sm, cmap="RdBu_r", vmin=-1, vmax=1, aspect="auto")
+        step = max(1, len(sl) // 8)
+        tp = list(range(0, len(sl), step))
+        ax.set_xticks(tp)
+        ax.set_yticks(tp)
+        ax.set_xticklabels([sl[i] for i in tp])
+        ax.set_yticklabels([sl[i] for i in tp])
+        ax.set(xlabel="Layer", ylabel="Layer",
+               title="cos(w_drift_i, w_drift_j)")
+        plt.colorbar(im, ax=ax, shrink=0.8)
+
+        ax = axes4[1]
+        mean_c = [np.mean([sm[i, j] for j in range(len(sl)) if j != i])
+                  for i in range(len(sl))]
+        d_au_s = [all_lr[l]["drift_auroc"] for l in sl]
+        ax.plot(sl, mean_c, "o-", color=P["drift"], lw=2, ms=6,
+                label="Mean cross-layer cos")
+        ax3 = ax.twinx()
+        ax3.plot(sl, d_au_s, "s--", color="#7f8c8d", lw=2, ms=6,
+                 label="Drift AUROC")
+        ax.set(xlabel="Layer", ylabel="Mean cosine",
+               title="Stability vs AUROC")
+        ax3.set_ylabel("AUROC")
+        ax.legend(loc="lower left", fontsize=9)
+        ax3.legend(loc="lower right", fontsize=9)
+        ax.grid(alpha=0.3)
+        plt.tight_layout()
+        plt.savefig(fig_dir / "fig5_probe_stability.png",
+                    dpi=300, bbox_inches="tight")
+        plt.close()
+        logger.info("  fig5 saved")
+
+    # ── Fig 6: Logit lens ────────────────────────────────────────────────
+    if lens_data:
+        fig, axes5 = plt.subplots(1, 2, figsize=(16, 6))
+        fig.suptitle(f"[{model_key}] [NEW-C] Logit Lens", fontsize=14,
+                     fontweight="bold")
+        ls_ = lens_data["layers"]
+        axes5[0].plot(ls_, lens_data["stable"], "o-", color=P["unc"], lw=2.5,
+                      ms=7, label="Stable")
+        axes5[0].plot(ls_, lens_data["drifted"], "s--", color=P["drift"],
+                      lw=2.5, ms=7, label="Drifted")
+        axes5[0].fill_between(ls_, lens_data["drifted"], lens_data["stable"],
+                              alpha=0.2, color=P["drift"])
+        axes5[0].axvline(best, color="gray", ls=":", lw=1.5)
+        axes5[0].set(xlabel="Layer", ylabel="P(expected token)",
+                     title="Per-layer probability")
+        axes5[0].legend()
+        axes5[0].grid(alpha=0.3)
+
+        gap = [s - d for s, d in zip(lens_data["stable"], lens_data["drifted"])]
+        axes5[1].plot(ls_, gap, "o-", color=P["neu"], lw=2.5, ms=7)
+        axes5[1].fill_between(ls_, 0, gap, alpha=0.3, color=P["neu"])
+        axes5[1].axhline(0, color="gray", ls="--", alpha=0.5)
+        axes5[1].axvline(best, color=P["drift"], ls=":", lw=1.5)
+        axes5[1].set(xlabel="Layer", ylabel="Stable − Drifted gap",
+                     title="Knowledge gap curve")
+        axes5[1].grid(alpha=0.3)
+        plt.tight_layout()
+        plt.savefig(fig_dir / "fig6_logit_lens.png",
+                    dpi=300, bbox_inches="tight")
+        plt.close()
+        logger.info("  fig6 saved")
+
+    # ── Fig 7: Sparsity tradeoff ─────────────────────────────────────────
+    if sparsity_data:
+        fig, ax1 = plt.subplots(figsize=(10, 6))
+        lams = [d["lambda"] for d in sparsity_data]
+        nus = [d["n_active"] for d in sparsity_data]
+        aus = [d["auroc"] for d in sparsity_data]
+        ax1.semilogx(lams, aus, "o-", color=P["drift"], lw=2.5, ms=8,
+                     label="AUROC")
+        ax4 = ax1.twinx()
+        ax4.semilogx(lams, nus, "s--", color=P["unc"], lw=2.5, ms=8,
+                     label="Active neurons")
+        ax1.set(xlabel="L1 lambda", ylabel="AUROC",
+                title=f"[{model_key}] Sparsity Tradeoff")
+        ax4.set_ylabel("Active neurons")
+        ax1.legend(loc="lower left")
+        ax4.legend(loc="upper right")
+        ax1.grid(alpha=0.3, which="both")
+        plt.tight_layout()
+        plt.savefig(fig_dir / "fig7_sparsity_tradeoff.png",
+                    dpi=300, bbox_inches="tight")
+        plt.close()
+        logger.info("  fig7 saved")
+
+    # ── Fig 8: Calibration ───────────────────────────────────────────────
+    bl = best
+    pr_objs = all_lr[bl].get("_probes", {})
+    X_b = np.array([r["hidden_states"][bl] for r in results])
+    is_d = np.array([int(r["is_drifted"]) for r in results])
+    is_c = np.array([int(r.get("correct", False)) for r in results])
+    fig, axes6 = plt.subplots(1, 3, figsize=(18, 6))
+    fig.suptitle(f"[{model_key}] Reliability Diagrams (Layer {bl})",
+                 fontsize=14, fontweight="bold")
+    for ax, pkey, yt, lbl, col in [
+        (axes6[0], "drift", is_d, "Drift", P["drift"]),
+        (axes6[1], "correctness", is_c, "Correctness", P["corr"]),
+    ]:
+        probe = pr_objs.get(pkey)
+        if probe is None:
+            ax.set_visible(False)
+            continue
+        scores = probe.predict_proba(X_b)[:, 1]
+        bins_e = np.linspace(0, 1, 11)
+        mid = (bins_e[:-1] + bins_e[1:]) / 2
+        frac = [float(yt[(scores >= lo) & (scores < hi)].mean())
+                if ((scores >= lo) & (scores < hi)).sum() > 0 else np.nan
+                for lo, hi in zip(bins_e[:-1], bins_e[1:])]
+        ax.plot([0, 1], [0, 1], "k--", lw=1.5, label="Perfect")
+        ax.bar(mid, frac, 0.08, alpha=0.6, color=col, edgecolor="black",
+               lw=0.5, label=lbl)
+        ax.set(xlabel="Predicted prob", ylabel="Fraction positive",
+               title=lbl, xlim=(0, 1), ylim=(0, 1))
+        ax.legend()
+        ax.grid(alpha=0.3)
+
+    ax = axes6[2]
+    probe = pr_objs.get("drift")
+    if probe:
+        s = probe.predict_proba(X_b)[:, 1]
+        ax.hist(s[is_d == 0], 30, alpha=0.6, color=P["unc"], density=True,
+                label="Stable")
+        ax.hist(s[is_d == 1], 30, alpha=0.6, color=P["drift"], density=True,
+                label="Drifted")
+        ax.set(xlabel="Drift score", ylabel="Density",
+               title="Score distribution")
+        ax.legend()
+        ax.grid(alpha=0.3)
+    plt.tight_layout()
+    plt.savefig(fig_dir / "fig8_calibration.png", dpi=300, bbox_inches="tight")
+    plt.close()
+    logger.info("  fig8 saved")
+
+    # ── Fig 10: Temporal distance ────────────────────────────────────────
+    if temporal_data and len(temporal_data.get("bins", [])) > 10:
+        bins_ = np.array(temporal_data["bins"])
+        scrs_ = np.array(temporal_data["scores"])
+        fig, ax = plt.subplots(figsize=(10, 6))
+        be = np.linspace(bins_.min(), bins_.max(), 10)
+        bm = (be[:-1] + be[1:]) / 2
+        bmean = [scrs_[(bins_ >= lo) & (bins_ < hi)].mean()
+                 if ((bins_ >= lo) & (bins_ < hi)).sum() > 0 else np.nan
+                 for lo, hi in zip(be[:-1], be[1:])]
+        ax.scatter(bins_, scrs_, alpha=0.3, s=15, color=P["drift"])
+        ax.plot(bm, bmean, "o-", color="black", lw=2.5, ms=8,
+                label=f"Bin mean (r={temporal_data['correlation']:.3f})")
+        ax.axvline(0, color="gray", ls="--", alpha=0.6, label="Cutoff")
+        ax.set(xlabel="Months since cutoff",
+               ylabel="Drift probe score",
+               title=f"[{model_key}] [NEW-E] Temporal Distance")
+        ax.legend()
+        ax.grid(alpha=0.3)
+        plt.tight_layout()
+        plt.savefig(fig_dir / "fig10_temporal_distance.png",
+                    dpi=300, bbox_inches="tight")
+        plt.close()
+        logger.info("  fig10 saved")
+
+    # ── Fig 11: Per-relation heatmap ─────────────────────────────────────
+    bl = best
+    pr_d = all_lr[bl].get("per_relation", {})
+    if len(pr_d) >= 3:
+        rels = sorted(pr_d.keys())
+        d_au = [pr_d[r]["drift_auroc"] for r in rels]
+        c_au = [pr_d[r]["correct_auroc"] for r in rels]
+        nd_ = [pr_d[r]["n_drifted"] for r in rels]
+        ns_ = [pr_d[r]["n_stable"] for r in rels]
+        fig, axes7 = plt.subplots(1, 2, figsize=(18, 7))
+        fig.suptitle(f"[{model_key}] Per-Relation AUROC (Layer {bl})",
+                     fontsize=14, fontweight="bold")
+        x = np.arange(len(rels))
+        w = 0.35
+        axes7[0].bar(x - w / 2, d_au, w, color=P["drift"], edgecolor="black",
+                     lw=0.5, label="Drift")
+        axes7[0].bar(x + w / 2, c_au, w, color=P["corr"], edgecolor="black",
+                     lw=0.5, label="Correctness")
+        axes7[0].set_xticks(x)
+        axes7[0].set_xticklabels(rels, rotation=35, ha="right", fontsize=9)
+        axes7[0].axhline(0.5, color="gray", ls="--", alpha=0.5)
+        axes7[0].set(ylabel="AUROC", title="AUROC by relation")
+        axes7[0].legend()
+        axes7[0].grid(alpha=0.3, axis="y")
+        axes7[1].barh(rels, nd_, color=P["drift"], alpha=0.7, label="Drifted")
+        axes7[1].barh(rels, ns_, left=nd_, color=P["unc"], alpha=0.7,
+                      label="Stable")
+        axes7[1].set(xlabel="Count", title="Class balance")
+        axes7[1].legend()
+        axes7[1].grid(alpha=0.3, axis="x")
+        plt.tight_layout()
+        plt.savefig(fig_dir / "fig11_relation_heatmap.png",
+                    dpi=300, bbox_inches="tight")
+        plt.close()
+        logger.info("  fig11 saved")
+
+    logger.info(f"All figures -> {fig_dir}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# MAIN
+# ─────────────────────────────────────────────────────────────────────────────
+
+def run(model_key, cfg, output_dir, probe_device, layers_override,
+        n_permutations, max_iter, cv_max_iter,
+        skip_logit_lens, skip_sparsity, skip_permutation):
+
+    mcfg = cfg["models"][model_key]
+    defaults = cfg.get("defaults", {})
+    lambda_grid = defaults.get("lambda_grid",
+                               [1e-5, 5e-5, 1e-4, 5e-4, 1e-3, 5e-3, 1e-2, 5e-2])
+    sparsity_lambdas = defaults.get("sparsity_lambdas",
+                                     [1e-6, 1e-5, 5e-5, 1e-4, 5e-4, 1e-3,
+                                      5e-3, 1e-2, 5e-2, 0.1, 0.2])
+    cutoff_months = mcfg.get("cutoff_months", 48)
+
+    model_dir = Path(output_dir) / model_key
+    model_dir.mkdir(parents=True, exist_ok=True)
+    (model_dir / "per_layer").mkdir(exist_ok=True)
+
+    fh = logging.FileHandler(model_dir / "analysis.log")
+    fh.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
+    logger.addHandler(fh)
+
+    # Load cache
+    cache_path = model_dir / f"cached_{model_key}.npz"
+    if not cache_path.exists():
+        logger.error(f"Cache not found: {cache_path}")
+        logger.error("Run extract_models.py first.")
+        sys.exit(1)
+
+    logger.info(f"\n{'='*70}")
+    logger.info(f"  {model_key} — Analysis")
+    logger.info(f"{'='*70}")
+    logger.info(f"Loading cache: {cache_path}")
+    results = np.load(str(cache_path), allow_pickle=True)["results"].tolist()
+    n_d = sum(1 for r in results if r["is_drifted"])
+    logger.info(f"  {len(results)} samples ({n_d} drifted, {len(results)-n_d} stable)")
+
+    # Determine layers
+    num_layers = max(max(r["hidden_states"].keys()) for r in results) + 1
+    all_layers = layers_override or list(range(num_layers))
+
+    # Resume from checkpoint
+    all_lr = {}
+    rj = model_dir / "all_layer_results.json"
+    if rj.exists():
+        with open(rj) as f:
+            saved = json.load(f)
+        all_lr = {int(k): v for k, v in saved.items()}
+        logger.info(f"Resumed: {len(all_lr)} layers done")
+
+    # Layer loop
+    for layer in all_layers:
+        if layer in all_lr and "drift_auroc" in all_lr[layer]:
+            logger.info(f"L{layer}: skip (AUROC={all_lr[layer]['drift_auroc']:.4f})")
+            continue
+
+        logger.info(f"\n── Layer {layer}/{num_layers-1} ──")
+        res = analyze_layer(layer, results, probe_device, lambda_grid,
+                            max_iter, cv_max_iter)
+
+        logger.info(
+            f"  Drift={res['drift_auroc']:.4f} "
+            f"(lam={res['drift_lam']:.0e}, act={res['n_active_drift']})  "
+            f"Unc={res['uncertainty_auroc']:.4f}  "
+            f"Corr={res['correctness_auroc']:.4f}")
+        logger.info(
+            f"  cos(d,u)={res['cos_du']:+.4f}  "
+            f"cos(d,c)={res['cos_dc']:+.4f}  "
+            f"null_space={res['null_space_drift_auroc']:.4f}  "
+            f"drop={res['drift_auroc']-res['null_space_drift_auroc']:+.4f}")
+        logger.info(
+            f"  Jaccard(d,u)={res['jaccard_du']:.2%}  "
+            f"Jaccard(d,c)={res['jaccard_dc']:.2%}  "
+            f"t={res['elapsed_s']:.1f}s")
+
+        cb = res["cells"].get("B_confident_drifted", {})
+        if cb.get("n", 0) > 0:
+            logger.info(
+                f"  [CellB] drift={cb['drift_mean']:.3f}  "
+                f"corr={cb['correct_mean']:.3f}  "
+                f"d_flag={cb['drift_flag_rate']:.1%}  "
+                f"c_flag={cb['correct_flag_rate']:.1%}")
+
+        # Save (strip weight vectors for JSON)
+        save_res = {k: v for k, v in res.items() if not k.startswith("_")}
+        all_lr[layer] = res  # keep full for figures
+
+        with open(model_dir / "per_layer" / f"layer_{layer:02d}.json", "w") as f:
+            json.dump(save_res, f, indent=2, default=str)
+        with open(rj, "w") as f:
+            json.dump({int(k): {kk: vv for kk, vv in v.items()
+                                if not kk.startswith("_")}
+                       for k, v in all_lr.items()},
+                      f, indent=2, default=str)
+
+        # Incremental figures
+        save_figures(all_lr, str(model_dir), model_key, results)
+
+    # Best layer
+    best_layer = int(max(all_lr, key=lambda l: all_lr[l]["drift_auroc"]))
+    logger.info(f"\nBest layer: {best_layer}  "
+                f"AUROC={all_lr[best_layer]['drift_auroc']:.4f}")
+
+    # Re-fit best for full probe objects if needed
+    if "_w_drift" not in all_lr[best_layer]:
+        logger.info("Re-fitting best layer...")
+        all_lr[best_layer] = analyze_layer(
+            best_layer, results, probe_device, lambda_grid,
+            max_iter, cv_max_iter)
+
+    # [NEW-B] Direction stability
+    logger.info("[NEW-B] Direction stability...")
+    for l in all_layers:
+        if "_w_drift" not in all_lr.get(l, {}):
+            X = np.array([r["hidden_states"][l] for r in results])
+            y = np.array([int(r["is_drifted"]) for r in results])
+            pw = fit_probe(X, y, 1e-3, probe_device, 400)
+            if l not in all_lr:
+                all_lr[l] = {}
+            all_lr[l]["_w_drift"] = pw.w_np
+    stability_data = probe_direction_stability(all_lr)
+    mean_cos = float(np.mean(
+        stability_data[1][~np.eye(len(stability_data[1]), dtype=bool)]))
+    logger.info(f"  Mean cross-layer cosine: {mean_cos:.4f}")
+
+    # [NEW-C] Logit lens
+    lens_data = None
+    if not skip_logit_lens:
+        logger.info("[NEW-C] Logit lens...")
+        lens_data = logit_lens_analysis(results, str(model_dir),
+                                         model_key, probe_device)
+
+    # [PERM] Permutation test
+    perm_res = None
+    if not skip_permutation:
+        perm_res = permutation_test(results, best_layer, n_permutations,
+                                     probe_device, lambda_grid)
+
+    # [SPARSE] Sparsity curve
+    sparsity_data = None
+    if not skip_sparsity:
+        sparsity_data = sparsity_curve(results, best_layer, probe_device,
+                                        sparsity_lambdas)
+
+    # [NEW-E] Temporal distance
+    X_all = np.array([r["hidden_states"][best_layer] for r in results])
+    dp = all_lr[best_layer]["_probes"]["drift"]
+    scores = dp.predict_proba(X_all)[:, 1]
+    for r, sc in zip(results, scores):
+        r["_drift_score"] = float(sc)
+    temporal_data = temporal_distance_analysis(results, cutoff_months)
+
+    # Final figures
+    save_figures(all_lr, str(model_dir), model_key, results,
+                 stability_data=stability_data, lens_data=lens_data,
+                 sparsity_data=sparsity_data, temporal_data=temporal_data)
+
+    # Export probe bundle
+    export_probe_bundle(all_lr, best_layer, results, model_key, str(model_dir))
+
+    # Final summary
+    bl = all_lr[best_layer]
+    drop = bl["drift_auroc"] - bl["null_space_drift_auroc"]
+    print(f"\n{'='*70}")
+    print(f"  [{model_key}] FINAL RESULTS")
+    print(f"{'='*70}")
+    print(f"  Best layer:              {best_layer}")
+    print(f"  Drift AUROC:             {bl['drift_auroc']:.4f}")
+    print(f"  Uncertainty AUROC:       {bl['uncertainty_auroc']:.4f}")
+    print(f"  Correctness AUROC:       {bl['correctness_auroc']:.4f}")
+    print(f"  Null-space drift AUROC:  {bl['null_space_drift_auroc']:.4f}")
+    print(f"  cos(drift, unc):         {bl['cos_du']:+.4f}")
+    print(f"  cos(drift, corr):        {bl['cos_dc']:+.4f}")
+    print(f"  Active neurons (drift):  {bl['n_active_drift']}")
+    print(f"  Jaccard(drift, unc):     {bl['jaccard_du']:.2%}")
+    print(f"  Null-space drop:         {drop:+.4f}")
+    print(f"  Mean cross-layer cos:    {mean_cos:.4f}")
+    if perm_res:
+        print(f"  Permutation p-value:     {perm_res['p_value']:.6f}")
+    cb = bl.get("cells", {}).get("B_confident_drifted", {})
+    if cb.get("n", 0) > 0:
+        print(f"\n  [IDEA-1] Cell B (n={cb['n']}):")
+        print(f"    Drift:       {cb['drift_mean']:.3f} "
+              f"(flagged {cb['drift_flag_rate']:.1%})")
+        print(f"    Correctness: {cb['correct_mean']:.3f} "
+              f"(flagged {cb['correct_flag_rate']:.1%})")
+        if cb["drift_mean"] > 0.55 and cb["correct_mean"] < 0.55:
+            print("    DISSOCIATION CONFIRMED")
+    print()
+    if abs(bl["cos_du"]) < 0.1:
+        print("  ORTHOGONAL: |cos(drift,unc)| < 0.10")
+    if abs(bl["cos_dc"]) < 0.3:
+        print("  DISTINCT: |cos(drift,corr)| < 0.30")
+    if abs(drop) < 0.02:
+        print(f"  NULL-SPACE STABLE: drop={drop:+.4f}")
+    if mean_cos > 0.5:
+        print(f"  GLOBAL DIRECTION: mean_cos={mean_cos:.3f}")
+    print(f"{'='*70}")
+
+    # Save final results
+    final = {
+        "model_key": model_key,
+        "model_name": mcfg["name"],
+        "n_samples": len(results),
+        "n_drifted": n_d,
+        "best_layer": best_layer,
+        "best_layer_results": {k: v for k, v in bl.items()
+                                if not k.startswith("_")},
+        "permutation_test": perm_res,
+        "sparsity_curve": sparsity_data,
+        "logit_lens": lens_data,
+        "temporal_distance": temporal_data,
+        "probe_stability": {
+            "layers": stability_data[0],
+            "mean_cross_layer_cosine": float(mean_cos),
+        },
+        "timestamp": datetime.now().isoformat(),
+    }
+    with open(model_dir / "final_results.json", "w") as f:
+        json.dump(final, f, indent=2, default=str)
+
+    logger.info(f"\nAll results saved to {model_dir}")
+    return results, best_layer
+
+
+def main():
+    import sys
+    p = argparse.ArgumentParser(
+        description="Per-model disentanglement analysis",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    p.add_argument("--model", required=True,
+                   help="Model key from models.yaml")
+    p.add_argument("--config", default="models.yaml")
+    p.add_argument("--output_dir", default=None)
+    p.add_argument("--probe_device", default="cuda:0")
+    p.add_argument("--layers", type=int, nargs="+", default=None)
+    p.add_argument("--n_permutations", type=int, default=None)
+    p.add_argument("--max_iter", type=int, default=None)
+    p.add_argument("--cv_max_iter", type=int, default=None)
+    p.add_argument("--skip_logit_lens", action="store_true")
+    p.add_argument("--skip_sparsity", action="store_true")
+    p.add_argument("--skip_permutation", action="store_true")
+    args = p.parse_args()
+
+    cfg = load_config(args.config)
+    defaults = cfg.get("defaults", {})
+    output_dir = args.output_dir or defaults.get("output_dir",
+                    "data/experiments/v4")
+    n_perms = args.n_permutations or defaults.get("n_permutations", 1000)
+    max_iter = args.max_iter or defaults.get("max_iter", 2000)
+    cv_max_iter = args.cv_max_iter or defaults.get("cv_max_iter", 500)
+
+    run(args.model, cfg, output_dir, args.probe_device, args.layers,
+        n_perms, max_iter, cv_max_iter,
+        args.skip_logit_lens, args.skip_sparsity, args.skip_permutation)
+
+
+if __name__ == "__main__":
+    main()

collect_all.py

@@ -0,0 +1,409 @@
+"""
+Knowledge Drift Dataset - Master Collection Script
+====================================================
+Orchestrates all data collection and produces the final unified dataset.
+
+Usage:
+    python collect_all.py --all          # Run everything
+    python collect_all.py --static       # Only static/manual facts
+    python collect_all.py --wikidata     # Only Wikidata queries
+    python collect_all.py --merge        # Merge existing raw files
+    python collect_all.py --stats        # Print dataset statistics
+"""
+
+import argparse
+import json
+import os
+import logging
+from datetime import datetime
+from typing import Dict, List
+from collections import Counter
+
+import sys
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+DATA_DIR = os.path.join(SCRIPT_DIR, "data")
+
+
+def ensure_data_dir():
+    os.makedirs(DATA_DIR, exist_ok=True)
+
+
+def collect_static():
+    """Run static facts collection."""
+    from collectors.static_collector import collect_all_static
+    
+    logger.info("=" * 60)
+    logger.info("COLLECTING STATIC/MANUAL FACTS")
+    logger.info("=" * 60)
+    
+    results = collect_all_static()
+    
+    output_path = os.path.join(DATA_DIR, "static_facts.json")
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+    
+    logger.info(f"Static facts saved to {output_path}")
+    return results
+
+
+def collect_wikidata():
+    """Run Wikidata SPARQL collection."""
+    from collectors.wikidata_collector import collect_all_wikidata
+    
+    logger.info("=" * 60)
+    logger.info("COLLECTING FROM WIKIDATA")
+    logger.info("=" * 60)
+    
+    results = collect_all_wikidata()
+    
+    output_path = os.path.join(DATA_DIR, "wikidata_raw.json")
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+    
+    logger.info(f"Wikidata facts saved to {output_path}")
+    return results
+
+
+def flatten_to_query_level(all_data: Dict) -> List[Dict]:
+    """
+    Flatten the hierarchical dataset into individual query-level samples.
+    Each sample is a single query at a single timestamp — ready for model inference.
+    
+    This is the format you'll feed to the model + probe pipeline:
+    - Run model on query
+    - Extract hidden states
+    - Record model's answer
+    - Compare with expected answer
+    - Train/evaluate drift detection probe
+    """
+    flat_samples = []
+    sample_id = 0
+    
+    for source_key, items in all_data.items():
+        for item in items:
+            # Handle items with temporal_variants already generated
+            if "temporal_variants" in item:
+                for variant in item["temporal_variants"]:
+                    flat_sample = {
+                        "sample_id": f"q_{sample_id:06d}",
+                        "query": variant["query"],
+                        "expected_answer": variant.get("expected_answer", ""),
+                        "year": variant.get("year", 0),
+                        "temporal_zone": variant.get("temporal_zone", "unknown"),
+                        "is_drifted_query": variant.get("is_drifted_query", False),
+                        "model_likely_answer": variant.get("model_likely_answer", ""),
+                        "language": variant.get("language", "en"),
+                        # Metadata from parent
+                        "entity": item.get("entity", ""),
+                        "relation": item.get("relation", ""),
+                        "knowledge_type": item.get("knowledge_type", ""),
+                        "category": item.get("category", ""),
+                        "source": item.get("source", ""),
+                        "parent_id": item.get("id", ""),
+                        "drift_date": item.get("drift_date", ""),
+                    }
+                    flat_samples.append(flat_sample)
+                    sample_id += 1
+            
+            # Handle bilingual items (Arabic)
+            for lang_key in ["temporal_variants_ar", "temporal_variants_en"]:
+                if lang_key in item:
+                    for variant in item[lang_key]:
+                        flat_sample = {
+                            "sample_id": f"q_{sample_id:06d}",
+                            "query": variant["query"],
+                            "expected_answer": variant.get("expected_answer", ""),
+                            "year": variant.get("year", 0),
+                            "temporal_zone": variant.get("temporal_zone", "unknown"),
+                            "is_drifted_query": variant.get("is_drifted_query", False),
+                            "language": variant.get("language", "en"),
+                            "entity": item.get("entity", item.get("entity_en", "")),
+                            "relation": item.get("relation", item.get("relation_en", "")),
+                            "knowledge_type": item.get("knowledge_type", ""),
+                            "category": item.get("category", ""),
+                            "source": item.get("source", ""),
+                            "parent_id": item.get("id", ""),
+                            "is_bilingual": True,
+                            "drift_date": item.get("drift_date", ""),
+                        }
+                        flat_samples.append(flat_sample)
+                        sample_id += 1
+            
+            # Handle raw wikidata items without temporal variants
+            if "temporal_variants" not in item and "temporal_variants_ar" not in item:
+                from configs.config import TIMESTAMP_YEARS
+                templates = item.get("templates", [])
+                if not templates:
+                    continue
+                template = templates[0]
+                
+                for year in TIMESTAMP_YEARS:
+                    temporal_zone = "pre_cutoff" if year < 2024 else (
+                        "near_cutoff" if year == 2024 else "post_cutoff"
+                    )
+                    
+                    try:
+                        query = template.format(
+                            year=year,
+                            subject=item.get("entity", ""),
+                            object="___"
+                        )
+                    except (KeyError, IndexError):
+                        query = f"In {year}, {item.get('entity', '')} {item.get('relation', '')} ___"
+                    
+                    # Determine expected answer
+                    if item["category"] == "unknown_drift":
+                        if temporal_zone == "post_cutoff":
+                            expected = item.get("new_answer", "")
+                            model_likely = item.get("old_answer", "")
+                            is_drifted = True
+                        else:
+                            expected = item.get("old_answer", "")
+                            model_likely = ""
+                            is_drifted = False
+                    elif item["category"] == "known_drift":
+                        # Try to determine which answer based on year
+                        drift_date = item.get("drift_date", "")
+                        try:
+                            drift_year = int(drift_date[:4]) if drift_date else 2023
+                        except ValueError:
+                            drift_year = 2023
+                        expected = item["old_answer"] if year < drift_year else item["new_answer"]
+                        model_likely = ""
+                        is_drifted = False
+                    else:  # no_drift
+                        expected = item.get("answer", "")
+                        model_likely = ""
+                        is_drifted = False
+                    
+                    flat_sample = {
+                        "sample_id": f"q_{sample_id:06d}",
+                        "query": query,
+                        "expected_answer": expected,
+                        "year": year,
+                        "temporal_zone": temporal_zone,
+                        "is_drifted_query": is_drifted,
+                        "model_likely_answer": model_likely,
+                        "language": "en",
+                        "entity": item.get("entity", ""),
+                        "relation": item.get("relation", ""),
+                        "knowledge_type": item.get("knowledge_type", ""),
+                        "category": item.get("category", ""),
+                        "source": item.get("source", ""),
+                        "parent_id": item.get("entity_qid", ""),
+                        "drift_date": item.get("drift_date", ""),
+                    }
+                    flat_samples.append(flat_sample)
+                    sample_id += 1
+    
+    return flat_samples
+
+
+def merge_all():
+    """Merge all collected data into a single unified dataset."""
+    logger.info("=" * 60)
+    logger.info("MERGING ALL DATA")
+    logger.info("=" * 60)
+    
+    all_data = {}
+    
+    # Load static facts
+    static_path = os.path.join(DATA_DIR, "static_facts.json")
+    if os.path.exists(static_path):
+        with open(static_path, 'r', encoding='utf-8') as f:
+            static_data = json.load(f)
+            all_data.update(static_data)
+        logger.info(f"Loaded static facts from {static_path}")
+    
+    # Load wikidata facts
+    wiki_path = os.path.join(DATA_DIR, "wikidata_raw.json")
+    if os.path.exists(wiki_path):
+        with open(wiki_path, 'r', encoding='utf-8') as f:
+            wiki_data = json.load(f)
+            all_data.update(wiki_data)
+        logger.info(f"Loaded wikidata facts from {wiki_path}")
+    
+    # Flatten to query level
+    flat_samples = flatten_to_query_level(all_data)
+    
+    # Build the final dataset
+    dataset = {
+        "metadata": {
+            "name": "Knowledge Drift Detection Dataset",
+            "version": "1.0",
+            "created": datetime.now().isoformat(),
+            "model_target": "Qwen 2.5 7B",
+            "model_cutoff": "2024-08-01",
+            "description": (
+                "Dataset for detecting knowledge drift in LLMs using "
+                "mechanistic interpretability. Contains temporally-scoped "
+                "factual queries across stable and changing knowledge."
+            ),
+            "categories": {
+                "stable": "Category 1 - Facts that never change (control)",
+                "known_drift": "Category 2 - Facts that changed pre-cutoff (model knows both)",
+                "unknown_drift": "Category 3 - Facts that changed post-cutoff (model doesn't know)",
+                "no_drift": "Category 4 - Changeable facts that didn't change (control)",
+            },
+            "total_samples": len(flat_samples),
+        },
+        "samples": flat_samples,
+    }
+    
+    # Save the unified dataset
+    output_path = os.path.join(DATA_DIR, "knowledge_drift_dataset.json")
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(dataset, f, indent=2, ensure_ascii=False)
+    
+    logger.info(f"Saved unified dataset to {output_path}")
+    logger.info(f"Total query-level samples: {len(flat_samples)}")
+    
+    # Also save a compact version for quick loading
+    compact_path = os.path.join(DATA_DIR, "knowledge_drift_compact.jsonl")
+    with open(compact_path, 'w', encoding='utf-8') as f:
+        for sample in flat_samples:
+            f.write(json.dumps(sample, ensure_ascii=False) + '\n')
+    
+    logger.info(f"Saved compact JSONL to {compact_path}")
+    
+    return dataset
+
+
+def print_stats():
+    """Print detailed statistics about the dataset."""
+    dataset_path = os.path.join(DATA_DIR, "knowledge_drift_dataset.json")
+    
+    if not os.path.exists(dataset_path):
+        logger.error(f"Dataset not found at {dataset_path}. Run --merge first.")
+        return
+    
+    with open(dataset_path, 'r', encoding='utf-8') as f:
+        dataset = json.load(f)
+    
+    samples = dataset["samples"]
+    
+    print("\n" + "=" * 70)
+    print("  KNOWLEDGE DRIFT DATASET STATISTICS")
+    print("=" * 70)
+    
+    print(f"\nTotal query-level samples: {len(samples)}")
+    
+    # By category
+    cat_counts = Counter(s["category"] for s in samples)
+    print(f"\n📊 By Category:")
+    for cat, count in sorted(cat_counts.items()):
+        pct = 100 * count / len(samples)
+        bar = "█" * int(pct / 2)
+        print(f"  {cat:20s}: {count:5d} ({pct:5.1f}%) {bar}")
+    
+    # By temporal zone
+    tz_counts = Counter(s["temporal_zone"] for s in samples)
+    print(f"\n⏰ By Temporal Zone:")
+    for tz, count in sorted(tz_counts.items()):
+        pct = 100 * count / len(samples)
+        print(f"  {tz:20s}: {count:5d} ({pct:5.1f}%)")
+    
+    # By knowledge type
+    kt_counts = Counter(s["knowledge_type"] for s in samples)
+    print(f"\n🧠 By Knowledge Type:")
+    for kt, count in sorted(kt_counts.items()):
+        pct = 100 * count / len(samples)
+        print(f"  {kt:20s}: {count:5d} ({pct:5.1f}%)")
+    
+    # Drifted queries
+    drifted = sum(1 for s in samples if s.get("is_drifted_query", False))
+    print(f"\n🔄 Drifted Queries (post-cutoff, answer changed):")
+    if len(samples) > 0:
+        print(f"  Total: {drifted} / {len(samples)} ({100*drifted/len(samples):.1f}%)")
+    else:
+        print(f"  Total: 0 (dataset is empty — check that --merge ran correctly)")
+    
+    # By language
+    lang_counts = Counter(s.get("language", "en") for s in samples)
+    print(f"\n🌍 By Language:")
+    for lang, count in sorted(lang_counts.items()):
+        print(f"  {lang:5s}: {count:5d}")
+    
+    # By source
+    src_counts = Counter(s.get("source", "unknown") for s in samples)
+    print(f"\n📦 By Source:")
+    for src, count in sorted(src_counts.items()):
+        print(f"  {src:25s}: {count:5d}")
+    
+    # By year
+    year_counts = Counter(s.get("year", 0) for s in samples)
+    print(f"\n📅 By Year:")
+    for year, count in sorted(year_counts.items()):
+        marker = " ← CUTOFF" if year == 2024 else (" ← POST-CUTOFF (drift zone)" if year == 2025 else "")
+        print(f"  {year}: {count:5d}{marker}")
+    
+    # Key comparisons for mechanistic interpretability
+    print(f"\n🔬 Key Comparisons for Probing:")
+    
+    post_cutoff_drifted = [s for s in samples if s["temporal_zone"] == "post_cutoff" and s.get("is_drifted_query")]
+    post_cutoff_stable = [s for s in samples if s["temporal_zone"] == "post_cutoff" and not s.get("is_drifted_query")]
+    pre_cutoff = [s for s in samples if s["temporal_zone"] == "pre_cutoff"]
+    
+    print(f"  Comparison 1 (drift vs no-drift, both post-cutoff):")
+    print(f"    Post-cutoff DRIFTED:   {len(post_cutoff_drifted)}")
+    print(f"    Post-cutoff STABLE:    {len(post_cutoff_stable)}")
+    
+    print(f"  Comparison 2 (pre vs post cutoff):")
+    print(f"    Pre-cutoff queries:    {len(pre_cutoff)}")
+    print(f"    Post-cutoff queries:   {len(post_cutoff_drifted) + len(post_cutoff_stable)}")
+    
+    # Show some example queries
+    print(f"\n📝 Example Queries:")
+    
+    for cat_name in ["stable", "known_drift", "unknown_drift", "no_drift"]:
+        cat_samples = [s for s in samples if s["category"] == cat_name]
+        if cat_samples:
+            example = cat_samples[0]
+            print(f"\n  [{cat_name}]")
+            print(f"    Query:    {example['query']}")
+            print(f"    Answer:   {example['expected_answer']}")
+            if example.get('model_likely_answer'):
+                print(f"    Model likely says: {example['model_likely_answer']}")
+    
+    print("\n" + "=" * 70)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Knowledge Drift Dataset Collection")
+    parser.add_argument("--all", action="store_true", help="Run everything")
+    parser.add_argument("--static", action="store_true", help="Collect static facts only")
+    parser.add_argument("--wikidata", action="store_true", help="Collect from Wikidata only")
+    parser.add_argument("--merge", action="store_true", help="Merge existing raw files")
+    parser.add_argument("--stats", action="store_true", help="Print dataset statistics")
+    
+    args = parser.parse_args()
+    
+    # Default to --all if no flags
+    if not any([args.all, args.static, args.wikidata, args.merge, args.stats]):
+        args.all = True
+    
+    ensure_data_dir()
+    
+    if args.all or args.static:
+        collect_static()
+    
+    if args.all or args.wikidata:
+        collect_wikidata()
+    
+    if args.all or args.merge:
+        merge_all()
+    
+    if args.all or args.stats:
+        print_stats()
+
+
+if __name__ == "__main__":
+    main()

collectors/static_collector.py

@@ -0,0 +1,324 @@
+"""
+Static Facts Collector
+======================
+Processes manually curated facts:
+- Category 1: Stable/timeless facts
+- Category 3 supplements: Verified post-cutoff changes
+- Category 4 supplements: Verified post-cutoff unchanged facts
+- Category 5: Arabic/MENA knowledge
+"""
+
+import json
+import os
+import logging
+from typing import List, Dict
+
+import sys
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_DIR = os.path.dirname(SCRIPT_DIR)
+sys.path.insert(0, PROJECT_DIR)
+from configs.config import (
+    STABLE_FACTS, VERIFIED_POST_CUTOFF_CHANGES,
+    VERIFIED_UNCHANGED_POST_CUTOFF, ARABIC_KNOWLEDGE,
+    TIMESTAMP_YEARS
+)
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+def collect_stable_facts() -> List[Dict]:
+    """
+    Category 1: Facts that never change.
+    Generate temporal variants for each fact across all timestamp years.
+    """
+    samples = []
+    sample_id = 0
+    
+    for knowledge_type, facts in STABLE_FACTS.items():
+        for fact in facts:
+            if "pairs" in fact:
+                # This is a parameterized fact (e.g., capital of {country})
+                for subject, answer in fact["pairs"]:
+                    base_query = fact["query"].replace("{country}", subject).replace("{continent}", answer)
+                    
+                    # Generate temporal variants
+                    temporal_variants = []
+                    for year in TIMESTAMP_YEARS:
+                        temporal_zone = "pre_cutoff" if year < 2024 else (
+                            "near_cutoff" if year == 2024 else "post_cutoff"
+                        )
+                        
+                        # Add year prefix to query
+                        query_with_year = f"In {year}, " + base_query.replace(" is ___", " was ___" if year < 2025 else " is ___")
+                        
+                        temporal_variants.append({
+                            "query": query_with_year,
+                            "year": year,
+                            "temporal_zone": temporal_zone,
+                            "expected_answer": answer,
+                            "is_drifted_query": False,
+                        })
+                    
+                    sample = {
+                        "id": f"stable_{sample_id:04d}",
+                        "entity": subject,
+                        "relation": fact["query"].split("{")[0].strip(),
+                        "knowledge_type": knowledge_type,
+                        "category": "stable",
+                        "answer": answer,
+                        "temporal_variants": temporal_variants,
+                        "source": "manual_curated",
+                    }
+                    samples.append(sample)
+                    sample_id += 1
+            else:
+                # Single fact
+                temporal_variants = []
+                for year in TIMESTAMP_YEARS:
+                    temporal_zone = "pre_cutoff" if year < 2024 else (
+                        "near_cutoff" if year == 2024 else "post_cutoff"
+                    )
+                    
+                    query_text = f"In {year}, " + fact["query"].lower()
+                    temporal_variants.append({
+                        "query": query_text,
+                        "year": year,
+                        "temporal_zone": temporal_zone,
+                        "expected_answer": fact["answer"],
+                        "is_drifted_query": False,
+                    })
+                
+                sample = {
+                    "id": f"stable_{sample_id:04d}",
+                    "entity": fact["query"].split("___")[0].strip(),
+                    "relation": "fact",
+                    "knowledge_type": knowledge_type,
+                    "category": "stable",
+                    "answer": fact["answer"],
+                    "temporal_variants": temporal_variants,
+                    "source": "manual_curated",
+                }
+                samples.append(sample)
+                sample_id += 1
+    
+    logger.info(f"Collected {len(samples)} stable facts (Category 1)")
+    return samples
+
+
+def collect_verified_post_cutoff_changes() -> List[Dict]:
+    """
+    Category 3 (supplement): Manually verified facts that changed after cutoff.
+    These are high-confidence examples where we KNOW the ground truth.
+    """
+    samples = []
+    
+    for idx, fact in enumerate(VERIFIED_POST_CUTOFF_CHANGES):
+        # Generate temporal variants
+        temporal_variants = []
+        
+        # Add pre-cutoff history
+        for hist in fact.get("pre_cutoff_history", []):
+            template = fact["templates"][0]
+            query = template.format(year=hist["year"])
+            temporal_variants.append({
+                "query": query,
+                "year": hist["year"],
+                "temporal_zone": "pre_cutoff",
+                "expected_answer": hist["answer"],
+                "is_drifted_query": False,
+            })
+        
+        # Add the post-cutoff query (the drift point)
+        template = fact["templates"][0]
+        post_cutoff_query = template.format(year=2025)
+        temporal_variants.append({
+            "query": post_cutoff_query,
+            "year": 2025,
+            "temporal_zone": "post_cutoff",
+            "expected_answer": fact["new_answer"],
+            "model_likely_answer": fact["old_answer"],
+            "is_drifted_query": fact["old_answer"] != fact["new_answer"],
+        })
+        
+        sample = {
+            "id": f"verified_drift_{idx:04d}",
+            "entity": fact["entity"],
+            "relation": fact["relation"],
+            "knowledge_type": fact["knowledge_type"],
+            "category": "unknown_drift",
+            "old_answer": fact["old_answer"],
+            "new_answer": fact["new_answer"],
+            "drift_date": fact.get("change_date", ""),
+            "temporal_variants": temporal_variants,
+            "all_templates": fact["templates"],
+            "note": fact.get("note", ""),
+            "source": "manual_verified",
+        }
+        samples.append(sample)
+    
+    logger.info(f"Collected {len(samples)} verified post-cutoff changes (Category 3)")
+    return samples
+
+
+def collect_verified_unchanged() -> List[Dict]:
+    """
+    Category 4 (supplement): Manually verified facts that did NOT change after cutoff.
+    Same type as Category 3 but stable — critical for the drift detection contrast.
+    """
+    samples = []
+    
+    for idx, fact in enumerate(VERIFIED_UNCHANGED_POST_CUTOFF):
+        temporal_variants = []
+        
+        for year in TIMESTAMP_YEARS:
+            temporal_zone = "pre_cutoff" if year < 2024 else (
+                "near_cutoff" if year == 2024 else "post_cutoff"
+            )
+            template = fact["templates"][0]
+            query = template.format(year=year)
+            
+            temporal_variants.append({
+                "query": query,
+                "year": year,
+                "temporal_zone": temporal_zone,
+                "expected_answer": fact["answer"],
+                "is_drifted_query": False,
+            })
+        
+        sample = {
+            "id": f"verified_stable_{idx:04d}",
+            "entity": fact["entity"],
+            "relation": fact["relation"],
+            "knowledge_type": fact["knowledge_type"],
+            "category": "no_drift",
+            "answer": fact["answer"],
+            "stable_since": fact["stable_since"],
+            "temporal_variants": temporal_variants,
+            "all_templates": fact["templates"],
+            "source": "manual_verified",
+        }
+        samples.append(sample)
+    
+    logger.info(f"Collected {len(samples)} verified unchanged facts (Category 4)")
+    return samples
+
+
+def collect_arabic_knowledge() -> List[Dict]:
+    """
+    Category 5: Arabic/MENA-specific knowledge.
+    Bilingual queries (Arabic + English) for cross-lingual drift detection.
+    """
+    samples = []
+    sample_id = 0
+    
+    for category, items in ARABIC_KNOWLEDGE.items():
+        for item in items:
+            temporal_variants_ar = []
+            temporal_variants_en = []
+            
+            for year in TIMESTAMP_YEARS:
+                temporal_zone = "pre_cutoff" if year < 2024 else (
+                    "near_cutoff" if year == 2024 else "post_cutoff"
+                )
+                
+                # Determine expected answer based on stability
+                if item.get("stable", True):
+                    answer_ar = item.get("answer", item.get("answer_ar", ""))
+                    answer_en = item.get("answer_en", item.get("answer", ""))
+                    is_drifted = False
+                else:
+                    change_date = item.get("change_date", "2024-08-01")
+                    try:
+                        change_year = int(change_date[:4])
+                    except (ValueError, TypeError):
+                        change_year = 2024
+                    
+                    if year < change_year or (year == change_year and temporal_zone == "pre_cutoff"):
+                        answer_ar = item.get("old_answer_ar", "")
+                        answer_en = item.get("old_answer_en", "")
+                        is_drifted = False
+                    else:
+                        answer_ar = item.get("new_answer_ar", "")
+                        answer_en = item.get("new_answer_en", "")
+                        is_drifted = True
+                
+                # Arabic variants
+                if "templates_ar" in item:
+                    for template_ar in item["templates_ar"]:
+                        temporal_variants_ar.append({
+                            "query": template_ar.format(year=year),
+                            "year": year,
+                            "language": "ar",
+                            "temporal_zone": temporal_zone,
+                            "expected_answer": answer_ar,
+                            "is_drifted_query": is_drifted and temporal_zone == "post_cutoff",
+                        })
+                
+                # English variants
+                if "templates_en" in item:
+                    for template_en in item["templates_en"]:
+                        temporal_variants_en.append({
+                            "query": template_en.format(year=year),
+                            "year": year,
+                            "language": "en",
+                            "temporal_zone": temporal_zone,
+                            "expected_answer": answer_en,
+                            "is_drifted_query": is_drifted and temporal_zone == "post_cutoff",
+                        })
+            
+            is_stable = item.get("stable", True)
+            sample = {
+                "id": f"arabic_{sample_id:04d}",
+                "entity": item.get("entity", ""),
+                "entity_en": item.get("entity_en", ""),
+                "relation": item.get("relation", ""),
+                "relation_en": item.get("relation_en", ""),
+                "knowledge_type": item.get("knowledge_type", category),
+                "category": "no_drift" if is_stable else "unknown_drift",
+                "is_bilingual": True,
+                "temporal_variants_ar": temporal_variants_ar,
+                "temporal_variants_en": temporal_variants_en,
+                "note": item.get("note", ""),
+                "source": "manual_arabic",
+            }
+            
+            if not is_stable:
+                sample["old_answer_ar"] = item.get("old_answer_ar", "")
+                sample["new_answer_ar"] = item.get("new_answer_ar", "")
+                sample["old_answer_en"] = item.get("old_answer_en", "")
+                sample["new_answer_en"] = item.get("new_answer_en", "")
+                sample["drift_date"] = item.get("change_date", "")
+            
+            samples.append(sample)
+            sample_id += 1
+    
+    logger.info(f"Collected {len(samples)} Arabic/MENA knowledge items (Category 5)")
+    return samples
+
+
+def collect_all_static() -> Dict[str, List]:
+    """Collect all manually curated/verified facts."""
+    return {
+        "category_1_stable": collect_stable_facts(),
+        "category_3_verified_drift": collect_verified_post_cutoff_changes(),
+        "category_4_verified_stable": collect_verified_unchanged(),
+        "category_5_arabic": collect_arabic_knowledge(),
+    }
+
+
+if __name__ == "__main__":
+    results = collect_all_static()
+    
+    output_path = os.path.join(PROJECT_DIR, "data", "static_facts.json")
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+    
+    logger.info(f"Saved to {output_path}")
+    
+    # Print summary
+    total = sum(len(v) for v in results.values())
+    print(f"\nTotal static facts collected: {total}")
+    for cat, items in results.items():
+        print(f"  {cat}: {len(items)}")

collectors/wikidata_collector.py

@@ -0,0 +1,359 @@
+"""
+Wikidata Temporal Facts Collector
+=================================
+Queries Wikidata SPARQL endpoint for facts that:
+- Changed before model cutoff (Category 2: known drift)
+- Changed after model cutoff (Category 3: unknown drift)  
+- Remained stable (Category 4: no drift)
+"""
+
+import json
+import os
+import time
+import requests
+import logging
+from typing import List, Dict, Optional
+from datetime import datetime
+
+import sys
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_DIR = os.path.dirname(SCRIPT_DIR)
+sys.path.insert(0, PROJECT_DIR)
+from configs.config import (
+    TEMPORAL_RELATIONS, MODEL_CUTOFF, WIKIDATA_ENDPOINT,
+    WIKIDATA_USER_AGENT, RESULTS_PER_QUERY,
+    SPARQL_POST_CUTOFF_CHANGES, SPARQL_PRE_CUTOFF_CHANGES,
+    SPARQL_STABLE_TEMPORAL, TIMESTAMP_YEARS
+)
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+def query_wikidata(sparql_query: str, max_retries: int = 3) -> List[Dict]:
+    """Execute a SPARQL query against Wikidata with retry logic."""
+    headers = {
+        'User-Agent': WIKIDATA_USER_AGENT,
+        'Accept': 'application/json'
+    }
+    
+    for attempt in range(max_retries):
+        try:
+            response = requests.get(
+                WIKIDATA_ENDPOINT,
+                params={'query': sparql_query, 'format': 'json'},
+                headers=headers,
+                timeout=120
+            )
+            
+            if response.status_code == 429:
+                wait_time = 60 * (attempt + 1)
+                logger.warning(f"Rate limited. Waiting {wait_time}s...")
+                time.sleep(wait_time)
+                continue
+            
+            response.raise_for_status()
+            data = response.json()
+            results = data.get('results', {}).get('bindings', [])
+            logger.info(f"Query returned {len(results)} results")
+            return results
+            
+        except requests.exceptions.Timeout:
+            logger.warning(f"Timeout on attempt {attempt + 1}")
+            time.sleep(30)
+        except Exception as e:
+            logger.error(f"Error on attempt {attempt + 1}: {e}")
+            time.sleep(10)
+    
+    logger.error("All retries exhausted")
+    return []
+
+
+def parse_wikidata_result(result: Dict) -> Dict:
+    """Parse a single Wikidata SPARQL result binding into a clean dict."""
+    parsed = {}
+    for key, value in result.items():
+        if value['type'] == 'uri':
+            # Extract QID from URI
+            parsed[key] = value['value'].split('/')[-1]
+        elif value['type'] == 'literal':
+            parsed[key] = value['value']
+    return parsed
+
+
+def collect_post_cutoff_changes(relation: Dict) -> List[Dict]:
+    """
+    Category 3: Facts that changed AFTER the model cutoff.
+    The model doesn't know the new answer.
+    """
+    logger.info(f"Collecting post-cutoff changes for: {relation['label']}")
+    
+    query = SPARQL_POST_CUTOFF_CHANGES.format(
+        prop=relation['property'],
+        subject_type=relation['subject_type'],
+        cutoff_date=MODEL_CUTOFF,
+        limit=RESULTS_PER_QUERY
+    )
+    
+    raw_results = query_wikidata(query)
+    
+    samples = []
+    for r in raw_results:
+        parsed = parse_wikidata_result(r)
+        
+        subject_label = parsed.get('subjectLabel', '')
+        old_value_label = parsed.get('old_valueLabel', '')
+        new_value_label = parsed.get('new_valueLabel', '')
+        
+        # Skip if labels are QIDs (unresolved)
+        if subject_label.startswith('Q') or old_value_label.startswith('Q'):
+            continue
+        
+        sample = {
+            "entity": subject_label,
+            "entity_qid": parsed.get('subject', ''),
+            "relation": relation['label'],
+            "relation_property": relation['property'],
+            "knowledge_type": relation['knowledge_type'],
+            "category": "unknown_drift",  # Category 3
+            "old_answer": old_value_label,
+            "new_answer": new_value_label,
+            "old_start": parsed.get('old_start', ''),
+            "old_end": parsed.get('old_end', ''),
+            "new_start": parsed.get('new_start', ''),
+            "drift_date": parsed.get('old_end', ''),
+            "model_likely_answer": old_value_label,  # Model probably knows old answer
+            "correct_answer_2025": new_value_label,
+            "templates": relation['templates'],
+            "source": "wikidata_sparql"
+        }
+        samples.append(sample)
+    
+    logger.info(f"  Found {len(samples)} post-cutoff changes for {relation['label']}")
+    return samples
+
+
+def collect_pre_cutoff_changes(relation: Dict) -> List[Dict]:
+    """
+    Category 2: Facts that changed BEFORE the model cutoff.
+    The model should know both old and new answers.
+    """
+    logger.info(f"Collecting pre-cutoff changes for: {relation['label']}")
+    
+    query = SPARQL_PRE_CUTOFF_CHANGES.format(
+        prop=relation['property'],
+        subject_type=relation['subject_type'],
+        cutoff_date=MODEL_CUTOFF,
+        limit=RESULTS_PER_QUERY
+    )
+    
+    raw_results = query_wikidata(query)
+    
+    samples = []
+    for r in raw_results:
+        parsed = parse_wikidata_result(r)
+        
+        subject_label = parsed.get('subjectLabel', '')
+        old_value_label = parsed.get('old_valueLabel', '')
+        new_value_label = parsed.get('new_valueLabel', '')
+        
+        if subject_label.startswith('Q') or old_value_label.startswith('Q'):
+            continue
+        
+        sample = {
+            "entity": subject_label,
+            "entity_qid": parsed.get('subject', ''),
+            "relation": relation['label'],
+            "relation_property": relation['property'],
+            "knowledge_type": relation['knowledge_type'],
+            "category": "known_drift",  # Category 2
+            "old_answer": old_value_label,
+            "new_answer": new_value_label,
+            "old_start": parsed.get('old_start', ''),
+            "old_end": parsed.get('old_end', ''),
+            "new_start": parsed.get('new_start', ''),
+            "drift_date": parsed.get('old_end', ''),
+            "templates": relation['templates'],
+            "source": "wikidata_sparql"
+        }
+        samples.append(sample)
+    
+    logger.info(f"  Found {len(samples)} pre-cutoff changes for {relation['label']}")
+    return samples
+
+
+def collect_stable_temporal(relation: Dict) -> List[Dict]:
+    """
+    Category 4: Facts of the same type that have NOT changed.
+    Same relation type as changing facts, but answer is stable.
+    """
+    logger.info(f"Collecting stable temporal facts for: {relation['label']}")
+    
+    query = SPARQL_STABLE_TEMPORAL.format(
+        prop=relation['property'],
+        subject_type=relation['subject_type'],
+        cutoff_date=MODEL_CUTOFF,
+        limit=RESULTS_PER_QUERY
+    )
+    
+    raw_results = query_wikidata(query)
+    
+    samples = []
+    for r in raw_results:
+        parsed = parse_wikidata_result(r)
+        
+        subject_label = parsed.get('subjectLabel', '')
+        value_label = parsed.get('valueLabel', '')
+        
+        if subject_label.startswith('Q') or value_label.startswith('Q'):
+            continue
+        
+        sample = {
+            "entity": subject_label,
+            "entity_qid": parsed.get('subject', ''),
+            "relation": relation['label'],
+            "relation_property": relation['property'],
+            "knowledge_type": relation['knowledge_type'],
+            "category": "no_drift",  # Category 4
+            "answer": value_label,
+            "stable_since": parsed.get('start_time', 'unknown'),
+            "templates": relation['templates'],
+            "source": "wikidata_sparql"
+        }
+        samples.append(sample)
+    
+    logger.info(f"  Found {len(samples)} stable facts for {relation['label']}")
+    return samples
+
+
+def generate_temporal_variants(sample: Dict) -> List[Dict]:
+    """
+    Generate queries at different timestamps for a single sample.
+    This creates the temporal contrast needed for mechanistic interpretability.
+    """
+    variants = []
+    templates = sample.get('templates', [])
+    if not templates:
+        return variants
+    
+    template = templates[0]  # Use primary template
+    
+    for year in TIMESTAMP_YEARS:
+        temporal_zone = "pre_cutoff" if year < 2024 else (
+            "near_cutoff" if year == 2024 else "post_cutoff"
+        )
+        
+        if sample['category'] == 'unknown_drift':
+            # For post-cutoff drift: old answer was true pre-cutoff, new answer post-cutoff
+            if year <= 2024:
+                answer = sample.get('old_answer', sample.get('answer', ''))
+                is_correct = True
+            else:
+                answer = sample.get('new_answer', '')
+                is_correct = True  # This is the ground truth
+                model_likely_answer = sample.get('old_answer', '')
+        elif sample['category'] == 'known_drift':
+            # Model should know both
+            old_end = sample.get('old_end', '')
+            if old_end:
+                try:
+                    change_year = int(old_end[:4])
+                    answer = sample['old_answer'] if year < change_year else sample['new_answer']
+                except (ValueError, IndexError):
+                    answer = sample.get('new_answer', '')
+            else:
+                answer = sample.get('new_answer', '')
+            is_correct = True
+        elif sample['category'] == 'no_drift':
+            answer = sample.get('answer', '')
+            is_correct = True
+        else:
+            answer = sample.get('answer', '')
+            is_correct = True
+        
+        query_text = template.format(
+            year=year,
+            subject=sample.get('entity', ''),
+            object=answer
+        )
+        # Also create the question version (without answer filled in)
+        query_question = template.format(
+            year=year,
+            subject=sample.get('entity', ''),
+            object='___'
+        )
+        
+        variant = {
+            "query": query_question,
+            "query_with_answer": query_text,
+            "year": year,
+            "temporal_zone": temporal_zone,
+            "expected_answer": answer,
+            "entity": sample.get('entity', ''),
+            "relation": sample.get('relation', ''),
+            "knowledge_type": sample.get('knowledge_type', ''),
+            "category": sample['category'],
+        }
+        
+        if sample['category'] == 'unknown_drift' and year > 2024:
+            variant["model_likely_answer"] = sample.get('old_answer', '')
+            variant["is_drifted_query"] = True
+        else:
+            variant["is_drifted_query"] = False
+        
+        variants.append(variant)
+    
+    return variants
+
+
+def collect_all_wikidata() -> Dict[str, List]:
+    """Run all Wikidata collection queries and return organized results."""
+    all_results = {
+        "category_2_known_drift": [],
+        "category_3_unknown_drift": [],
+        "category_4_no_drift": [],
+    }
+    
+    for relation in TEMPORAL_RELATIONS:
+        logger.info(f"\n{'='*60}")
+        logger.info(f"Processing relation: {relation['label']} ({relation['property']})")
+        logger.info(f"{'='*60}")
+        
+        # Category 3: Post-cutoff changes
+        post_cutoff = collect_post_cutoff_changes(relation)
+        all_results["category_3_unknown_drift"].extend(post_cutoff)
+        
+        # Be nice to Wikidata
+        time.sleep(2)
+        
+        # Category 2: Pre-cutoff changes
+        pre_cutoff = collect_pre_cutoff_changes(relation)
+        all_results["category_2_known_drift"].extend(pre_cutoff)
+        
+        time.sleep(2)
+        
+        # Category 4: Stable facts
+        stable = collect_stable_temporal(relation)
+        all_results["category_4_no_drift"].extend(stable)
+        
+        time.sleep(2)
+    
+    # Log summary
+    logger.info(f"\n{'='*60}")
+    logger.info("WIKIDATA COLLECTION SUMMARY")
+    logger.info(f"{'='*60}")
+    for cat, samples in all_results.items():
+        logger.info(f"  {cat}: {len(samples)} samples")
+    
+    return all_results
+
+
+if __name__ == "__main__":
+    results = collect_all_wikidata()
+    
+    output_path = os.path.join(PROJECT_DIR, "data", "wikidata_raw.json")
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+    
+    logger.info(f"Saved to {output_path}")

collectors/wikipedia_collector.py

@@ -0,0 +1,165 @@
+"""
+Wikipedia-based Fact Collector (Alternative)
+=============================================
+Uses Wikipedia's API to collect current facts for verification.
+Use this if Wikidata SPARQL endpoint is unavailable.
+
+This script fetches current information from Wikipedia to VERIFY
+whether facts have changed post-cutoff. It doesn't replace the 
+Wikidata collector but supplements it.
+
+Usage:
+    python wikipedia_collector.py
+    
+NOTE: For full Wikidata SPARQL collection, run wikidata_collector.py
+on your local machine where query.wikidata.org is accessible.
+"""
+
+import json
+import os
+import re
+import time
+import logging
+import requests
+from typing import Dict, List, Optional
+
+import sys
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_DIR = os.path.dirname(SCRIPT_DIR)
+sys.path.insert(0, PROJECT_DIR)
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+WIKIPEDIA_API = "https://en.wikipedia.org/w/api.php"
+
+
+def get_wikipedia_extract(title: str, sentences: int = 3) -> Optional[str]:
+    """Get the opening extract from a Wikipedia article."""
+    params = {
+        "action": "query",
+        "titles": title,
+        "prop": "extracts",
+        "exsentences": sentences,
+        "exlimit": 1,
+        "explaintext": True,
+        "format": "json",
+    }
+    
+    try:
+        response = requests.get(WIKIPEDIA_API, params=params, timeout=30)
+        response.raise_for_status()
+        data = response.json()
+        
+        pages = data.get("query", {}).get("pages", {})
+        for page_id, page_data in pages.items():
+            if page_id == "-1":
+                return None
+            return page_data.get("extract", "")
+    except Exception as e:
+        logger.error(f"Error fetching Wikipedia for '{title}': {e}")
+        return None
+
+
+def verify_entity_role_facts() -> List[Dict]:
+    """
+    Verify current holders of positions by checking Wikipedia.
+    Returns verified facts with current information.
+    """
+    # Entities to verify — these are our Category 3/4 candidates
+    entities_to_check = [
+        # (Wikipedia article title, what to look for, relation type)
+        ("Prime_Minister_of_the_United_Kingdom", "prime minister", "head_of_government"),
+        ("President_of_the_United_States", "president", "head_of_state"),
+        ("Prime_Minister_of_Japan", "prime minister", "head_of_government"),
+        ("Chancellor_of_Germany", "chancellor", "head_of_government"),
+        ("Prime_Minister_of_Canada", "prime minister", "head_of_government"),
+        ("Prime_Minister_of_India", "prime minister", "head_of_government"),
+        ("President_of_France", "president", "head_of_state"),
+        ("President_of_Russia", "president", "head_of_state"),
+        ("President_of_China", "president", "head_of_state"),
+        ("King_of_Saudi_Arabia", "king", "head_of_state"),
+        ("President_of_the_United_Arab_Emirates", "president", "head_of_state"),
+        ("President_of_Egypt", "president", "head_of_state"),
+        ("President_of_South_Korea", "president", "head_of_state"),
+        ("President_of_Brazil", "president", "head_of_state"),
+        ("President_of_Syria", "president/leader", "head_of_state"),
+        # Companies
+        ("Apple_Inc.", "CEO", "ceo"),
+        ("Microsoft", "CEO", "ceo"),
+        ("Amazon_(company)", "CEO", "ceo"),
+        ("Alphabet_Inc.", "CEO", "ceo"),
+        ("Tesla,_Inc.", "CEO", "ceo"),
+        ("Meta_Platforms", "CEO", "ceo"),
+        ("OpenAI", "CEO", "ceo"),
+    ]
+    
+    verified_facts = []
+    
+    for article_title, role, relation in entities_to_check:
+        logger.info(f"Checking: {article_title}")
+        
+        extract = get_wikipedia_extract(article_title.replace("_", " "))
+        if extract:
+            verified_facts.append({
+                "article": article_title,
+                "role": role,
+                "relation": relation,
+                "wikipedia_extract": extract,
+                "checked_date": "2025-02-25",
+                "note": "Extract from Wikipedia — manually verify the current holder",
+            })
+        
+        time.sleep(1)  # Be nice to Wikipedia
+    
+    return verified_facts
+
+
+def collect_recent_events_from_wikipedia() -> List[Dict]:
+    """
+    Collect recent notable events from Wikipedia's Current Events portal.
+    These are events that happened post-cutoff (after Aug 2024).
+    """
+    # Wikipedia Current Events pages by month
+    months = [
+        "September_2024", "October_2024", "November_2024",
+        "December_2024", "January_2025", "February_2025"
+    ]
+    
+    events = []
+    
+    for month in months:
+        title = f"Portal:Current_events/{month}"
+        extract = get_wikipedia_extract(title, sentences=10)
+        
+        if extract:
+            events.append({
+                "month": month,
+                "extract": extract,
+                "note": "Raw extract — process manually for specific fact changes",
+            })
+        
+        time.sleep(1)
+    
+    return events
+
+
+if __name__ == "__main__":
+    logger.info("Verifying entity-role facts via Wikipedia...")
+    verified = verify_entity_role_facts()
+    
+    output_path = os.path.join(PROJECT_DIR, "data", "wikipedia_verified.json")
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(verified, f, indent=2, ensure_ascii=False)
+    
+    logger.info(f"Saved {len(verified)} verified facts to {output_path}")
+    
+    # Print summaries
+    print("\n" + "="*60)
+    print("WIKIPEDIA VERIFICATION RESULTS")
+    print("="*60)
+    for fact in verified:
+        print(f"\n📌 {fact['article'].replace('_', ' ')}")
+        extract_preview = fact['wikipedia_extract'][:200] + "..."
+        print(f"   {extract_preview}")

configs/config.py

@@ -0,0 +1,530 @@
+"""
+Configuration for Knowledge Drift Dataset Collection
+=====================================================
+Model: Qwen 2.5 7B
+Knowledge Cutoff: August 2024
+Collection Date: February 2025
+"""
+
+# ============================================================
+# TEMPORAL BOUNDARIES
+# ============================================================
+MODEL_CUTOFF = "2024-08-01"
+COLLECTION_DATE = "2025-02-25"
+
+# Time periods for temporal variants
+TIMESTAMP_YEARS = [2015, 2018, 2020, 2022, 2023, 2024, 2025]
+
+# ============================================================
+# WIKIDATA PROPERTIES FOR TEMPORAL FACTS
+# ============================================================
+TEMPORAL_RELATIONS = [
+    {
+        "property": "P6",
+        "label": "head of government",
+        "knowledge_type": "entity_role",
+        "templates": [
+            "In {year}, the head of government of {subject} was {object}.",
+            "Who was the head of government of {subject} in {year}?",
+            "As of {year}, {subject} was led by {object}.",
+        ],
+        "subject_type": "Q6256",
+        "example": "UK → PM"
+    },
+    {
+        "property": "P35",
+        "label": "head of state",
+        "knowledge_type": "entity_role",
+        "templates": [
+            "In {year}, the head of state of {subject} was {object}.",
+            "Who was the head of state of {subject} in {year}?",
+        ],
+        "subject_type": "Q6256",
+        "example": "US → President"
+    },
+    {
+        "property": "P169",
+        "label": "chief executive officer",
+        "knowledge_type": "entity_role",
+        "templates": [
+            "In {year}, the CEO of {subject} was {object}.",
+            "Who was the CEO of {subject} in {year}?",
+            "As of {year}, {subject} was led by CEO {object}.",
+        ],
+        "subject_type": "Q4830453",
+        "example": "Google → CEO"
+    },
+    {
+        "property": "P286",
+        "label": "head coach",
+        "knowledge_type": "entity_role",
+        "templates": [
+            "In {year}, the head coach of {subject} was {object}.",
+            "Who coached {subject} in {year}?",
+        ],
+        "subject_type": "Q476028",
+        "example": "Real Madrid → Coach"
+    },
+]
+
+# ============================================================
+# WIKIDATA SPARQL QUERIES
+# ============================================================
+
+SPARQL_POST_CUTOFF_CHANGES = """
+SELECT DISTINCT ?subject ?subjectLabel ?property ?propertyLabel
+       ?old_value ?old_valueLabel ?old_start ?old_end
+       ?new_value ?new_valueLabel ?new_start
+WHERE {{
+  ?subject p:{prop} ?new_statement .
+  ?new_statement ps:{prop} ?new_value .
+  OPTIONAL {{ ?new_statement pq:P580 ?new_start . }}
+  ?subject p:{prop} ?old_statement .
+  ?old_statement ps:{prop} ?old_value .
+  OPTIONAL {{ ?old_statement pq:P580 ?old_start . }}
+  OPTIONAL {{ ?old_statement pq:P582 ?old_end . }}
+  FILTER(BOUND(?old_end) && ?old_end >= "{cutoff_date}"^^xsd:dateTime)
+  FILTER(?new_value != ?old_value)
+  ?subject wdt:P31/wdt:P279* wd:{subject_type} .
+  SERVICE wikibase:label {{ bd:serviceParam wikibase:language "en". }}
+}}
+LIMIT {limit}
+"""
+
+SPARQL_PRE_CUTOFF_CHANGES = """
+SELECT DISTINCT ?subject ?subjectLabel 
+       ?old_value ?old_valueLabel ?old_start ?old_end
+       ?new_value ?new_valueLabel ?new_start ?new_end
+WHERE {{
+  ?subject p:{prop} ?new_statement .
+  ?new_statement ps:{prop} ?new_value .
+  OPTIONAL {{ ?new_statement pq:P580 ?new_start . }}
+  OPTIONAL {{ ?new_statement pq:P582 ?new_end . }}
+  ?subject p:{prop} ?old_statement .
+  ?old_statement ps:{prop} ?old_value .
+  OPTIONAL {{ ?old_statement pq:P580 ?old_start . }}
+  ?old_statement pq:P582 ?old_end .
+  FILTER(?old_end >= "2020-01-01"^^xsd:dateTime && ?old_end < "{cutoff_date}"^^xsd:dateTime)
+  FILTER(?new_value != ?old_value)
+  ?subject wdt:P31/wdt:P279* wd:{subject_type} .
+  SERVICE wikibase:label {{ bd:serviceParam wikibase:language "en". }}
+}}
+LIMIT {limit}
+"""
+
+SPARQL_STABLE_TEMPORAL = """
+SELECT DISTINCT ?subject ?subjectLabel 
+       ?value ?valueLabel ?start_time
+WHERE {{
+  ?subject p:{prop} ?statement .
+  ?statement ps:{prop} ?value .
+  OPTIONAL {{ ?statement pq:P580 ?start_time . }}
+  FILTER NOT EXISTS {{ ?statement pq:P582 ?end_time . }}
+  FILTER(!BOUND(?start_time) || ?start_time < "{cutoff_date}"^^xsd:dateTime)
+  ?subject wdt:P31/wdt:P279* wd:{subject_type} .
+  SERVICE wikibase:label {{ bd:serviceParam wikibase:language "en". }}
+}}
+LIMIT {limit}
+"""
+
+# ============================================================
+# STABLE FACTS (Category 1)
+# ============================================================
+
+STABLE_FACTS = {
+    "geographical": [
+        {"query": "The capital of {country} is ___", "pairs": [
+            ("France", "Paris"), ("Japan", "Tokyo"), ("Egypt", "Cairo"),
+            ("Germany", "Berlin"), ("Brazil", "Brasília"), ("Australia", "Canberra"),
+            ("Canada", "Ottawa"), ("Italy", "Rome"), ("South Korea", "Seoul"),
+            ("Saudi Arabia", "Riyadh"), ("United Arab Emirates", "Abu Dhabi"),
+            ("Morocco", "Rabat"), ("Turkey", "Ankara"), ("India", "New Delhi"),
+            ("China", "Beijing"), ("Russia", "Moscow"), ("Mexico", "Mexico City"),
+            ("Argentina", "Buenos Aires"), ("South Africa", "Pretoria"),
+            ("Indonesia", "Jakarta"), ("Thailand", "Bangkok"), ("Vietnam", "Hanoi"),
+            ("Poland", "Warsaw"), ("Sweden", "Stockholm"), ("Norway", "Oslo"),
+            ("Spain", "Madrid"), ("Portugal", "Lisbon"), ("Greece", "Athens"),
+            ("Ireland", "Dublin"), ("Switzerland", "Bern"),
+        ]},
+        {"query": "The largest continent by area is ___", "answer": "Asia"},
+        {"query": "The longest river in the world is ___", "answer": "the Nile"},
+        {"query": "The highest mountain in the world is ___", "answer": "Mount Everest"},
+        {"query": "The largest ocean is ___", "answer": "the Pacific Ocean"},
+        {"query": "The largest desert in the world is ___", "answer": "the Sahara Desert"},
+        {"query": "{country} is located in {continent}", "pairs": [
+            ("Japan", "Asia"), ("Brazil", "South America"), ("Nigeria", "Africa"),
+            ("France", "Europe"), ("Australia", "Oceania"), ("Egypt", "Africa"),
+            ("Canada", "North America"), ("India", "Asia"), ("Argentina", "South America"),
+        ]},
+    ],
+    "scientific": [
+        {"query": "Water boils at ___ degrees Celsius at standard pressure", "answer": "100"},
+        {"query": "The speed of light is approximately ___ km/s", "answer": "300,000"},
+        {"query": "The chemical formula for water is ___", "answer": "H2O"},
+        {"query": "The chemical formula for table salt is ___", "answer": "NaCl"},
+        {"query": "The atomic number of hydrogen is ___", "answer": "1"},
+        {"query": "The atomic number of carbon is ___", "answer": "6"},
+        {"query": "The atomic number of oxygen is ___", "answer": "8"},
+        {"query": "DNA stands for ___", "answer": "deoxyribonucleic acid"},
+        {"query": "The Earth orbits around ___", "answer": "the Sun"},
+        {"query": "Photosynthesis converts sunlight into ___ for plants", "answer": "energy"},
+        {"query": "The force of gravity on Earth is approximately ___ m/s²", "answer": "9.8"},
+        {"query": "Absolute zero is ___ degrees Celsius", "answer": "-273.15"},
+    ],
+    "mathematical": [
+        {"query": "The value of pi to two decimal places is ___", "answer": "3.14"},
+        {"query": "The square root of 144 is ___", "answer": "12"},
+        {"query": "The square root of 169 is ___", "answer": "13"},
+        {"query": "2 to the power of 10 is ___", "answer": "1024"},
+        {"query": "The sum of angles in a triangle is ___ degrees", "answer": "180"},
+        {"query": "The derivative of x² is ___", "answer": "2x"},
+        {"query": "The integral of 2x is ___", "answer": "x²"},
+        {"query": "Euler's number e is approximately ___", "answer": "2.718"},
+        {"query": "The Pythagorean theorem states that a² + b² = ___", "answer": "c²"},
+        {"query": "The factorial of 5 (5!) is ___", "answer": "120"},
+    ],
+    "historical": [
+        {"query": "World War I started in ___", "answer": "1914"},
+        {"query": "World War II ended in ___", "answer": "1945"},
+        {"query": "The first moon landing was in ___", "answer": "1969"},
+        {"query": "The Berlin Wall fell in ___", "answer": "1989"},
+        {"query": "The United Nations was founded in ___", "answer": "1945"},
+        {"query": "The French Revolution began in ___", "answer": "1789"},
+        {"query": "The Titanic sank in ___", "answer": "1912"},
+        {"query": "The first iPhone was released in ___", "answer": "2007"},
+        {"query": "The Internet was invented in ___", "answer": "1969"},
+        {"query": "Islam's Prophet Muhammad was born in ___", "answer": "570 CE"},
+        {"query": "The pyramids of Giza were built in ancient ___", "answer": "Egypt"},
+    ],
+    "cultural_religious": [
+        {"query": "The holy book of Islam is ___", "answer": "the Quran"},
+        {"query": "The holy city of Islam is ___", "answer": "Mecca"},
+        {"query": "The language of the Quran is ___", "answer": "Arabic"},
+        {"query": "The five pillars of Islam include Shahada, Salah, Zakat, Sawm, and ___", "answer": "Hajj"},
+        {"query": "The author of Romeo and Juliet is ___", "answer": "William Shakespeare"},
+        {"query": "The Mona Lisa was painted by ___", "answer": "Leonardo da Vinci"},
+        {"query": "The theory of relativity was developed by ___", "answer": "Albert Einstein"},
+        {"query": "The inventor of the telephone was ___", "answer": "Alexander Graham Bell"},
+    ],
+}
+
+# ============================================================
+# KNOWN POST-CUTOFF CHANGES (Category 3)
+# ============================================================
+
+VERIFIED_POST_CUTOFF_CHANGES = [
+    {
+        "entity": "United Kingdom",
+        "relation": "head of government",
+        "knowledge_type": "entity_role",
+        "old_answer": "Rishi Sunak",
+        "new_answer": "Keir Starmer",
+        "change_date": "2024-07-05",
+        "templates": [
+            "In {year}, the Prime Minister of the United Kingdom was ___",
+            "Who was the Prime Minister of the UK in {year}?",
+            "As of {year}, the UK was governed by Prime Minister ___",
+        ],
+        "pre_cutoff_history": [
+            {"year": 2020, "answer": "Boris Johnson"},
+            {"year": 2022, "answer": "Rishi Sunak"},
+            {"year": 2023, "answer": "Rishi Sunak"},
+        ]
+    },
+    {
+        "entity": "United States",
+        "relation": "president",
+        "knowledge_type": "entity_role",
+        "old_answer": "Joe Biden",
+        "new_answer": "Donald Trump",
+        "change_date": "2025-01-20",
+        "templates": [
+            "In {year}, the President of the United States was ___",
+            "Who was the US President in {year}?",
+            "As of {year}, the United States was led by President ___",
+        ],
+        "pre_cutoff_history": [
+            {"year": 2018, "answer": "Donald Trump"},
+            {"year": 2020, "answer": "Donald Trump"},
+            {"year": 2022, "answer": "Joe Biden"},
+            {"year": 2023, "answer": "Joe Biden"},
+        ]
+    },
+    {
+        "entity": "Japan",
+        "relation": "prime minister",
+        "knowledge_type": "entity_role",
+        "old_answer": "Fumio Kishida",
+        "new_answer": "Shigeru Ishiba",
+        "change_date": "2024-10-01",
+        "templates": [
+            "In {year}, the Prime Minister of Japan was ___",
+            "Who was Japan's Prime Minister in {year}?",
+        ],
+        "pre_cutoff_history": [
+            {"year": 2020, "answer": "Yoshihide Suga"},
+            {"year": 2022, "answer": "Fumio Kishida"},
+            {"year": 2023, "answer": "Fumio Kishida"},
+        ]
+    },
+    {
+        "entity": "European Commission",
+        "relation": "president",
+        "knowledge_type": "entity_role",
+        "old_answer": "Ursula von der Leyen",
+        "new_answer": "Ursula von der Leyen",
+        "change_date": "2024-07-18",
+        "note": "Same person re-elected — control for change event without answer change",
+        "templates": [
+            "In {year}, the President of the European Commission was ___",
+        ],
+        "pre_cutoff_history": [
+            {"year": 2020, "answer": "Ursula von der Leyen"},
+            {"year": 2023, "answer": "Ursula von der Leyen"},
+        ]
+    },
+    {
+        "entity": "Syria",
+        "relation": "political situation",
+        "knowledge_type": "event",
+        "old_answer": "Bashar al-Assad",
+        "new_answer": "Ahmad al-Sharaa (transitional government)",
+        "change_date": "2024-12-08",
+        "templates": [
+            "In {year}, the leader of Syria was ___",
+            "Who controlled Syria in {year}?",
+        ],
+        "pre_cutoff_history": [
+            {"year": 2020, "answer": "Bashar al-Assad"},
+            {"year": 2023, "answer": "Bashar al-Assad"},
+        ]
+    },
+    {
+        "entity": "BRICS",
+        "relation": "member countries expansion",
+        "knowledge_type": "relational",
+        "old_answer": "Brazil, Russia, India, China, South Africa",
+        "new_answer": "Brazil, Russia, India, China, South Africa, Iran, Egypt, Ethiopia, UAE, Saudi Arabia",
+        "change_date": "2024-01-01",
+        "note": "Expansion announced 2023 but effective Jan 2024",
+        "templates": [
+            "In {year}, the members of BRICS included ___",
+            "Which countries were part of BRICS in {year}?",
+        ],
+        "pre_cutoff_history": [
+            {"year": 2020, "answer": "Brazil, Russia, India, China, South Africa"},
+            {"year": 2023, "answer": "Brazil, Russia, India, China, South Africa"},
+        ]
+    },
+    {
+        "entity": "OpenAI",
+        "relation": "board and leadership changes",
+        "knowledge_type": "relational",
+        "old_answer": "nonprofit-controlled structure",
+        "new_answer": "for-profit transition announced",
+        "change_date": "2024-12-01",
+        "templates": [
+            "In {year}, OpenAI's corporate structure was ___",
+            "As of {year}, OpenAI was organized as ___",
+        ],
+        "pre_cutoff_history": [
+            {"year": 2022, "answer": "nonprofit-controlled with capped-profit subsidiary"},
+            {"year": 2023, "answer": "nonprofit-controlled with capped-profit subsidiary"},
+        ]
+    },
+    {
+        "entity": "Twitter/X",
+        "relation": "CEO",
+        "knowledge_type": "entity_role",
+        "old_answer": "Linda Yaccarino",
+        "new_answer": "Linda Yaccarino",
+        "change_date": None,
+        "note": "Control: same type (tech CEO) but did NOT change",
+        "templates": [
+            "In {year}, the CEO of X (formerly Twitter) was ___",
+        ],
+        "pre_cutoff_history": [
+            {"year": 2022, "answer": "Elon Musk (interim)"},
+            {"year": 2023, "answer": "Linda Yaccarino"},
+        ]
+    },
+]
+
+# ============================================================
+# VERIFIED POST-CUTOFF UNCHANGED (Category 4)
+# ============================================================
+
+VERIFIED_UNCHANGED_POST_CUTOFF = [
+    {
+        "entity": "Saudi Arabia",
+        "relation": "head of state",
+        "knowledge_type": "entity_role",
+        "answer": "King Salman bin Abdulaziz",
+        "stable_since": "2015-01-23",
+        "templates": [
+            "In {year}, the King of Saudi Arabia was ___",
+            "Who was the King of Saudi Arabia in {year}?",
+        ],
+    },
+    {
+        "entity": "United Arab Emirates",
+        "relation": "president",
+        "knowledge_type": "entity_role",
+        "answer": "Mohamed bin Zayed Al Nahyan",
+        "stable_since": "2022-05-14",
+        "templates": ["In {year}, the President of the UAE was ___"],
+    },
+    {
+        "entity": "Apple Inc.",
+        "relation": "CEO",
+        "knowledge_type": "entity_role",
+        "answer": "Tim Cook",
+        "stable_since": "2011-08-24",
+        "templates": ["In {year}, the CEO of Apple was ___", "Who was Apple's CEO in {year}?"],
+    },
+    {
+        "entity": "Microsoft",
+        "relation": "CEO",
+        "knowledge_type": "entity_role",
+        "answer": "Satya Nadella",
+        "stable_since": "2014-02-04",
+        "templates": ["In {year}, the CEO of Microsoft was ___"],
+    },
+    {
+        "entity": "Amazon",
+        "relation": "CEO",
+        "knowledge_type": "entity_role",
+        "answer": "Andy Jassy",
+        "stable_since": "2021-07-05",
+        "templates": ["In {year}, the CEO of Amazon was ___"],
+    },
+    {
+        "entity": "Russia",
+        "relation": "president",
+        "knowledge_type": "entity_role",
+        "answer": "Vladimir Putin",
+        "stable_since": "2012-05-07",
+        "templates": ["In {year}, the President of Russia was ___"],
+    },
+    {
+        "entity": "China",
+        "relation": "president",
+        "knowledge_type": "entity_role",
+        "answer": "Xi Jinping",
+        "stable_since": "2013-03-14",
+        "templates": ["In {year}, the President of China was ___"],
+    },
+    {
+        "entity": "France",
+        "relation": "president",
+        "knowledge_type": "entity_role",
+        "answer": "Emmanuel Macron",
+        "stable_since": "2017-05-14",
+        "templates": ["In {year}, the President of France was ___"],
+    },
+    {
+        "entity": "Germany",
+        "relation": "chancellor",
+        "knowledge_type": "entity_role",
+        "answer": "Olaf Scholz",
+        "stable_since": "2021-12-08",
+        "templates": ["In {year}, the Chancellor of Germany was ___"],
+    },
+    {
+        "entity": "Egypt",
+        "relation": "president",
+        "knowledge_type": "entity_role",
+        "answer": "Abdel Fattah el-Sisi",
+        "stable_since": "2014-06-08",
+        "templates": ["In {year}, the President of Egypt was ___"],
+    },
+    {
+        "entity": "Tesla",
+        "relation": "CEO",
+        "knowledge_type": "entity_role",
+        "answer": "Elon Musk",
+        "stable_since": "2008-10-01",
+        "templates": ["In {year}, the CEO of Tesla was ___"],
+    },
+    {
+        "entity": "Google/Alphabet",
+        "relation": "CEO",
+        "knowledge_type": "entity_role",
+        "answer": "Sundar Pichai",
+        "stable_since": "2015-10-02",
+        "templates": ["In {year}, the CEO of Google was ___"],
+    },
+]
+
+# ============================================================
+# ARABIC KNOWLEDGE (Category 5)
+# ============================================================
+
+ARABIC_KNOWLEDGE = {
+    "entity_role_arabic": [
+        {
+            "entity": "المملكة العربية السعودية",
+            "entity_en": "Saudi Arabia",
+            "relation": "ولي العهد",
+            "relation_en": "Crown Prince",
+            "answer": "محمد بن سلمان",
+            "answer_en": "Mohammed bin Salman",
+            "stable": True,
+            "templates_ar": ["في عام {year}، ولي عهد المملكة العربية السعودية هو ___"],
+            "templates_en": ["In {year}, the Crown Prince of Saudi Arabia was ___"],
+        },
+        {
+            "entity": "سوريا",
+            "entity_en": "Syria",
+            "relation": "رئيس",
+            "relation_en": "leader",
+            "old_answer_ar": "بشار الأسد",
+            "new_answer_ar": "أحمد الشرع",
+            "old_answer_en": "Bashar al-Assad",
+            "new_answer_en": "Ahmad al-Sharaa",
+            "stable": False,
+            "change_date": "2024-12-08",
+            "templates_ar": [
+                "في عام {year}، كان رئيس سوريا هو ___",
+                "من كان يحكم سوريا في عام {year}؟",
+            ],
+            "templates_en": [
+                "In {year}, the president of Syria was ___",
+                "Who ruled Syria in {year}?",
+            ],
+        },
+        {
+            "entity": "المملكة المتحدة",
+            "entity_en": "United Kingdom",
+            "relation": "رئيس الوزراء",
+            "relation_en": "Prime Minister",
+            "old_answer_ar": "ريشي سوناك",
+            "new_answer_ar": "كير ستارمر",
+            "old_answer_en": "Rishi Sunak",
+            "new_answer_en": "Keir Starmer",
+            "stable": False,
+            "change_date": "2024-07-05",
+            "templates_ar": ["في عام {year}، رئيس وزراء المملكة المتحدة هو ___"],
+            "templates_en": ["In {year}, the Prime Minister of the UK was ___"],
+        },
+    ],
+    "islamic_finance": [
+        {
+            "entity": "هيئة المحاسبة والمراجعة للمؤسسات المالية الإسلامية",
+            "entity_en": "AAOIFI",
+            "relation": "معايير الصكوك",
+            "relation_en": "sukuk standards",
+            "templates_ar": ["معايير هيئة AAOIFI للصكوك الإسلامية تتطلب ___"],
+            "templates_en": ["AAOIFI standards for Islamic sukuk require ___"],
+            "knowledge_type": "procedural",
+            "note": "Connect to SAHM project",
+        },
+    ],
+}
+
+# ============================================================
+# WIKIDATA ENDPOINT
+# ============================================================
+WIKIDATA_ENDPOINT = "https://query.wikidata.org/sparql"
+WIKIDATA_USER_AGENT = "KnowledgeDriftResearch/1.0 (academic research)"
+RESULTS_PER_QUERY = 200

convert_sparql_to_samples.py

@@ -0,0 +1,60 @@
+import json
+from collections import Counter
+
+print('Loading SPARQL updates...')
+with open('data/external/templama_2023_2026_updates_clean.json') as f:
+    updates = json.load(f)['updates']
+print(f'  {len(updates)} changed entities')
+
+print('Loading Dynamic-TempLAMA templates...')
+dyn = {}
+with open('data/external/temporal-robustness/data/dynamic-templama/dataset_from_2019-1-1_to_2022-12-31_per_quarter/test.jsonl') as f:
+    for line in f:
+        if not line.strip(): continue
+        d = json.loads(line)
+        eid = d['id'].split('_')[0]
+        key = eid + '_' + d['relation']
+        if key not in dyn:
+            dyn[key] = {'template': d['query'], 'answers': {}}
+        ans = d['answer']
+        if isinstance(ans, dict): name = ans.get('name', '')
+        elif isinstance(ans, list) and ans: name = ans[0].get('name', '')
+        else: name = str(ans)
+        dyn[key]['answers'][d['date']] = name
+print(f'  {len(dyn)} entity-relation pairs')
+
+YEARS = [2023, 2024, 2025, 2026]
+CUTOFFS = {'llama2': '2022-09-01', 'mistral': '2023-12-01', 'llama31': '2023-12-01', 'qwen25': '2023-12-31', 'gemma2': '2024-06-01'}
+
+print('Generating samples...')
+samples = []
+sid = 0
+skipped = 0
+
+for uid, u in updates.items():
+    dd = u.get('drift_date', '')[:10]
+    try: dy = int(dd[:4])
+    except: skipped += 1; continue
+    for year in YEARS:
+        if year >= dy: exp, drifted, model_ans = u['new_answer'], True, u['old_answer']
+        else: exp, drifted, model_ans = u['old_answer'], False, ''
+        tz = 'pre_cutoff' if year < 2023 else ('near_cutoff' if year == 2023 else 'post_cutoff')
+        query = 'In ' + str(year) + ', ' + u['query_template'].replace('_X_', '___')
+        s = {'sample_id': 'sparql_' + str(sid).zfill(6), 'query': query, 'expected_answer': exp, 'year': year, 'temporal_zone': tz, 'is_drifted_query': drifted, 'model_likely_answer': model_ans, 'language': 'en', 'entity': u['entity_id'], 'relation': u['relation_name'], 'knowledge_type': 'entity_role', 'category': 'unknown_drift' if drifted else 'known_drift', 'source': 'sparql_extension', 'parent_id': u['entity_id'], 'drift_date': u.get('drift_date', '')}
+        for m, c in CUTOFFS.items(): s['is_drifted_' + m] = (dd > c) and (year >= dy)
+        samples.append(s)
+        sid += 1
+
+with open('data/external/sparql_extension_samples.json', 'w') as f:
+    json.dump({'metadata': {'total': len(samples), 'skipped': skipped}, 'samples': samples}, f, indent=2, ensure_ascii=False)
+
+print(f'Total: {len(samples)} samples, Skipped: {skipped}')
+for label, fn in [('Categories', 'category'), ('Relations', 'relation')]:
+    print(f'{label}:')
+    for k, n in Counter(s[fn] for s in samples).most_common(): print(f'  {k}: {n}')
+print('Years:')
+for y, n in sorted(Counter(s['year'] for s in samples).items()): print(f'  {y}: {n}')
+print('Per-model unknown_drift:')
+for m in CUTOFFS: print(f'  {m}: {sum(1 for s in samples if s.get("is_drifted_" + m, False))}')
+print(f'Differential: {sum(1 for s in samples if len(set(s.get("is_drifted_" + m, False) for m in CUTOFFS)) > 1)}')
+print('Saved to: data/external/sparql_extension_samples.json')

cross_model.py

@@ -0,0 +1,856 @@
+#!/usr/bin/env python3
+"""
+cross_model.py — Cross-Model Drift Analysis
+=============================================
+Runs AFTER analyze_single.py on 2+ models.
+Uses probe bundles + caches to compare drift representations across architectures.
+
+6 Experiments:
+  [CM-1] Full-layer CKA matrix (L_A × L_B per pair, not just best layer)
+  [CM-2] Drift score correlation (probe A scores vs probe B scores on shared queries)
+  [CM-3] Differential facts (queries drifted for A but stable for B)
+  [CM-4] Layer correspondence (best layer as % of depth — universal localization?)
+  [CM-5] Neuron overlap (same-dim models only: which neuron indices carry drift?)
+  [CM-6] Universality score (aggregate metric for paper abstract)
+
+Outputs:
+  cross_model_results.json     Complete results
+  figures/fig_cm1_cka.png      Layer-wise CKA heatmaps
+  figures/fig_cm2_corr.png     Score correlation matrix
+  figures/fig_cm3_diff.png     Differential facts scatter
+  figures/fig_cm4_layers.png   Layer correspondence bar
+  figures/fig_cm5_neurons.png  Neuron overlap (same-dim pairs)
+  figures/fig_cm6_summary.png  Universality summary
+
+Usage:
+  # Compare two models
+  python cross_model.py --models qwen25 llama31
+
+  # All available models
+  python cross_model.py --all
+
+  # Quick mode (skip full-layer CKA, just best-layer)
+  python cross_model.py --all --quick
+"""
+
+import argparse
+import json
+import logging
+import time
+import warnings
+from pathlib import Path
+
+import numpy as np
+import yaml
+
+warnings.filterwarnings("ignore")
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[logging.StreamHandler()])
+logger = logging.getLogger(__name__)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# CONFIG + DATA LOADING
+# ─────────────────────────────────────────────────────────────────────────────
+
+def load_config(path="models.yaml"):
+    with open(path) as f:
+        return yaml.safe_load(f)
+
+
+def load_cache(model_dir, model_key):
+    path = Path(model_dir) / model_key / f"cached_{model_key}.npz"
+    if not path.exists():
+        logger.error(f"Cache not found: {path}")
+        return None
+    results = np.load(str(path), allow_pickle=True)["results"].tolist()
+    logger.info(f"  [{model_key}] Loaded {len(results)} samples")
+    return results
+
+
+def load_probe_bundle(model_dir, model_key):
+    path = Path(model_dir) / model_key / f"probe_bundle_{model_key}.npz"
+    if not path.exists():
+        logger.warning(f"Probe bundle not found: {path}")
+        return None
+    d = np.load(str(path), allow_pickle=True)
+    bundle = {k: d[k] for k in d.files}
+    # Convert scalar items
+    for k in ["best_layer", "hidden_dim", "n_samples"]:
+        if k in bundle:
+            bundle[k] = int(bundle[k])
+    for k in ["drift_auroc", "cos_du", "cos_dc"]:
+        if k in bundle:
+            bundle[k] = float(bundle[k])
+    logger.info(f"  [{model_key}] Bundle: layer={bundle.get('best_layer')}, "
+                f"dim={bundle.get('hidden_dim')}, "
+                f"AUROC={bundle.get('drift_auroc', 0):.4f}")
+    return bundle
+
+
+def load_final_results(model_dir, model_key):
+    path = Path(model_dir) / model_key / "final_results.json"
+    if not path.exists():
+        return None
+    with open(path) as f:
+        return json.load(f)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PROBE FITTING (lightweight — for scoring shared queries)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def soft_threshold(w, lam):
+    import torch
+    return torch.sign(w) * torch.clamp(torch.abs(w) - lam, min=0.0)
+
+
+def fit_quick_probe(X_np, y_np, device="cuda:0", lam=1e-3, max_iter=500):
+    """Fast probe fit for cross-model scoring."""
+    import torch
+    X = np.nan_to_num(X_np.astype(np.float32), nan=0., posinf=1e4, neginf=-1e4)
+    X = np.clip(X, -1e4, 1e4)
+    m = X.mean(0, keepdims=True)
+    s = X.std(0, keepdims=True) + 1e-8
+    Xt = torch.tensor((X - m) / s, dtype=torch.float32, device=device)
+    yt = torch.tensor(y_np.astype(np.float32), device=device)
+
+    w = torch.zeros(Xt.shape[1], device=device)
+    b = torch.zeros(1, device=device)
+    lr = 1.0
+    for _ in range(max_iter):
+        z = torch.clamp(Xt @ w + b, -30, 30)
+        p = torch.sigmoid(z)
+        L = -((yt * torch.log(p + 1e-12)) +
+              (1 - yt) * torch.log(1 - p + 1e-12)).mean()
+        e = p - yt
+        gw = (Xt.T @ e) / len(yt)
+        gb = e.mean(keepdim=True)
+        wt = soft_threshold(w - lr * gw, lr * lam)
+        bt = b - lr * gb
+        Lt = -((yt * torch.log(torch.sigmoid(torch.clamp(Xt @ wt + bt, -30, 30)) + 1e-12)) +
+               (1 - yt) * torch.log(1 - torch.sigmoid(torch.clamp(Xt @ wt + bt, -30, 30)) + 1e-12)).mean()
+        if Lt > L + 1e-4:
+            lr *= 0.5
+        else:
+            lr = min(lr * 1.05, 10.0)
+        if (wt - w).abs().max().item() < 1e-6:
+            w, b = wt, bt
+            break
+        w, b = wt, bt
+
+    def score(X_new):
+        Xn = np.nan_to_num(X_new.astype(np.float32), nan=0., posinf=1e4, neginf=-1e4)
+        Xn = np.clip(Xn, -1e4, 1e4)
+        Xn = torch.tensor((Xn - m) / s, dtype=torch.float32, device=device)
+        with torch.no_grad():
+            return torch.sigmoid(torch.clamp(Xn @ w + b, -30, 30)).cpu().numpy()
+
+    return score, w.cpu().numpy()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# [CM-1] CKA ANALYSIS
+# ─────────────────────────────────────────────────────────────────────────────
+
+def linear_cka(Xa, Xb):
+    """Centered Kernel Alignment between two representation matrices."""
+    def _center(K):
+        n = K.shape[0]
+        H = np.eye(n) - 1.0 / n
+        return H @ K @ H
+    Ka = _center(Xa @ Xa.T)
+    Kb = _center(Xb @ Xb.T)
+    num = np.linalg.norm(Ka.T @ Kb, "fro")
+    den = np.linalg.norm(Ka, "fro") * np.linalg.norm(Kb, "fro")
+    return float(num / (den + 1e-12))
+
+
+def cka_analysis(res_a, res_b, key_a, key_b, quick=False):
+    """
+    [CM-1] CKA between two models.
+    If quick=False: full L_A × L_B heatmap.
+    If quick=True: just best-layer CKA.
+    """
+    logger.info(f"[CM-1] CKA: {key_a} vs {key_b}")
+
+    # Build shared query lookup
+    qa = {r["query"]: r for r in res_a}
+    qb = {r["query"]: r for r in res_b}
+    shared = sorted(set(qa) & set(qb))
+    logger.info(f"  Shared queries: {len(shared)}")
+
+    if len(shared) < 50:
+        logger.warning("  Too few shared queries for CKA")
+        return None
+
+    # Subsample for speed (CKA is O(n²))
+    if len(shared) > 2000:
+        np.random.seed(42)
+        shared = list(np.random.choice(shared, 2000, replace=False))
+
+    layers_a = sorted(res_a[0]["hidden_states"].keys())
+    layers_b = sorted(res_b[0]["hidden_states"].keys())
+
+    if quick:
+        # Just best layers
+        best_a = layers_a[-5:]  # top 5 layers
+        best_b = layers_b[-5:]
+    else:
+        # Sample layers evenly (max 10 per model for tractability)
+        step_a = max(1, len(layers_a) // 10)
+        step_b = max(1, len(layers_b) // 10)
+        best_a = layers_a[::step_a]
+        best_b = layers_b[::step_b]
+
+    cka_mat = np.zeros((len(best_a), len(best_b)))
+    for i, la in enumerate(best_a):
+        Xa = np.array([qa[q]["hidden_states"][la] for q in shared])
+        for j, lb in enumerate(best_b):
+            Xb = np.array([qb[q]["hidden_states"][lb] for q in shared])
+            cka_mat[i, j] = linear_cka(Xa, Xb)
+        if (i + 1) % 3 == 0:
+            logger.info(f"  CKA row {i+1}/{len(best_a)}")
+
+    best_cka = float(cka_mat.max())
+    logger.info(f"  Best CKA: {best_cka:.4f}")
+
+    return {
+        "layers_a": best_a, "layers_b": best_b,
+        "cka_matrix": cka_mat.tolist(),
+        "best_cka": best_cka,
+        "n_shared": len(shared),
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# [CM-2] SCORE CORRELATION
+# ─────────────────────────────────────────────────────────────────────────────
+
+def score_correlation(res_a, res_b, key_a, key_b, bundle_a, bundle_b, device):
+    """
+    [CM-2] Train probe on each model, score shared queries, correlate.
+    """
+    from sklearn.metrics import roc_auc_score
+    logger.info(f"[CM-2] Score correlation: {key_a} vs {key_b}")
+
+    qa = {r["query"]: r for r in res_a}
+    qb = {r["query"]: r for r in res_b}
+    shared = sorted(set(qa) & set(qb))
+    logger.info(f"  Shared: {len(shared)}")
+
+    if len(shared) < 50:
+        return None
+
+    bl_a = int(bundle_a["best_layer"])
+    bl_b = int(bundle_b["best_layer"])
+
+    # Train probes on full data
+    X_a = np.array([r["hidden_states"][bl_a] for r in res_a])
+    y_a = np.array([int(r["is_drifted"]) for r in res_a])
+    X_b = np.array([r["hidden_states"][bl_b] for r in res_b])
+    y_b = np.array([int(r["is_drifted"]) for r in res_b])
+
+    score_a, _ = fit_quick_probe(X_a, y_a, device)
+    score_b, _ = fit_quick_probe(X_b, y_b, device)
+
+    # Score shared queries
+    Xa_shared = np.array([qa[q]["hidden_states"][bl_a] for q in shared])
+    Xb_shared = np.array([qb[q]["hidden_states"][bl_b] for q in shared])
+    sa = score_a(Xa_shared)
+    sb = score_b(Xb_shared)
+
+    # Labels for shared
+    ya_shared = np.array([int(qa[q]["is_drifted"]) for q in shared])
+    yb_shared = np.array([int(qb[q]["is_drifted"]) for q in shared])
+
+    corr = float(np.corrcoef(sa, sb)[0, 1])
+    try:
+        auroc_a = roc_auc_score(ya_shared, sa)
+        auroc_b = roc_auc_score(yb_shared, sb)
+    except Exception:
+        auroc_a = auroc_b = 0.5
+
+    logger.info(f"  Score corr: {corr:.4f}  "
+                f"AUROC_a={auroc_a:.4f}  AUROC_b={auroc_b:.4f}")
+
+    return {
+        "correlation": corr,
+        "auroc_a_on_shared": auroc_a,
+        "auroc_b_on_shared": auroc_b,
+        "n_shared": len(shared),
+        "scores_a": sa.tolist(),
+        "scores_b": sb.tolist(),
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# [CM-3] DIFFERENTIAL FACTS
+# ─────────────────────────────────────────────────────────────────────────────
+
+def differential_facts(res_a, res_b, key_a, key_b, bundle_a, bundle_b, device):
+    """
+    [CM-3] Queries where is_drifted differs between models.
+    Each probe should detect its own model's drift correctly.
+    """
+    from sklearn.metrics import roc_auc_score
+    logger.info(f"[CM-3] Differential facts: {key_a} vs {key_b}")
+
+    qa = {r["query"]: r for r in res_a}
+    qb = {r["query"]: r for r in res_b}
+    shared = sorted(set(qa) & set(qb))
+
+    # Find differential: drifted for A but not B, or vice versa
+    diff_queries = [q for q in shared
+                    if qa[q]["is_drifted"] != qb[q]["is_drifted"]]
+    logger.info(f"  Shared={len(shared)}, Differential={len(diff_queries)}")
+
+    if len(diff_queries) < 20:
+        logger.warning("  Too few differential facts")
+        return None
+
+    bl_a = int(bundle_a["best_layer"])
+    bl_b = int(bundle_b["best_layer"])
+
+    # Train probes
+    X_a = np.array([r["hidden_states"][bl_a] for r in res_a])
+    y_a = np.array([int(r["is_drifted"]) for r in res_a])
+    X_b = np.array([r["hidden_states"][bl_b] for r in res_b])
+    y_b = np.array([int(r["is_drifted"]) for r in res_b])
+    score_a, _ = fit_quick_probe(X_a, y_a, device)
+    score_b, _ = fit_quick_probe(X_b, y_b, device)
+
+    # Score differential queries
+    Xa_d = np.array([qa[q]["hidden_states"][bl_a] for q in diff_queries])
+    Xb_d = np.array([qb[q]["hidden_states"][bl_b] for q in diff_queries])
+    sa = score_a(Xa_d)
+    sb = score_b(Xb_d)
+    la = np.array([int(qa[q]["is_drifted"]) for q in diff_queries])
+    lb = np.array([int(qb[q]["is_drifted"]) for q in diff_queries])
+
+    try:
+        auroc_a = roc_auc_score(la, sa)
+    except Exception:
+        auroc_a = 0.5
+    try:
+        auroc_b = roc_auc_score(lb, sb)
+    except Exception:
+        auroc_b = 0.5
+
+    # Anti-correlation: when A says drifted and B says stable,
+    # score_a should be high and score_b should be low
+    score_corr = float(np.corrcoef(sa, sb)[0, 1])
+
+    # Count categories
+    a_only = sum(1 for q in diff_queries
+                 if qa[q]["is_drifted"] and not qb[q]["is_drifted"])
+    b_only = sum(1 for q in diff_queries
+                 if not qa[q]["is_drifted"] and qb[q]["is_drifted"])
+
+    logger.info(f"  AUROC_a={auroc_a:.4f}  AUROC_b={auroc_b:.4f}  "
+                f"score_corr={score_corr:.4f}")
+    logger.info(f"  A-only drifted: {a_only}  B-only drifted: {b_only}")
+
+    return {
+        "n_differential": len(diff_queries),
+        "n_shared": len(shared),
+        "a_only_drifted": a_only,
+        "b_only_drifted": b_only,
+        "auroc_a": auroc_a,
+        "auroc_b": auroc_b,
+        "score_correlation": score_corr,
+        "scores_a": sa.tolist(),
+        "scores_b": sb.tolist(),
+        "labels_a": la.tolist(),
+        "labels_b": lb.tolist(),
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# [CM-4] LAYER CORRESPONDENCE
+# ─────────────────────────────────────────────────────────────────────────────
+
+def layer_correspondence(all_bundles, all_final):
+    """
+    [CM-4] Best drift layer as fraction of total depth.
+    If all models peak at ~80%, drift localization is universal.
+    """
+    logger.info("[CM-4] Layer correspondence")
+    data = {}
+    for key in all_bundles:
+        bl = int(all_bundles[key]["best_layer"])
+        total = int(all_bundles[key].get("hidden_dim", 0))
+        # Get total layers from final results
+        fr = all_final.get(key, {})
+        n_layers = fr.get("best_layer_results", {}).get("layer", bl) + 1
+        # Better: look at probe stability layers
+        stab = fr.get("probe_stability", {})
+        if "layers" in stab and len(stab["layers"]) > 0:
+            n_layers = max(stab["layers"]) + 1
+
+        frac = bl / max(n_layers, 1)
+        auroc = float(all_bundles[key].get("drift_auroc", 0))
+        data[key] = {
+            "best_layer": bl,
+            "n_layers": n_layers,
+            "fraction": frac,
+            "auroc": auroc,
+        }
+        logger.info(f"  {key}: L{bl}/{n_layers} = {frac:.1%}  "
+                    f"AUROC={auroc:.4f}")
+
+    fracs = [v["fraction"] for v in data.values()]
+    mean_frac = float(np.mean(fracs))
+    std_frac = float(np.std(fracs))
+    logger.info(f"  Mean fraction: {mean_frac:.1%} +/- {std_frac:.1%}")
+
+    return {
+        "per_model": data,
+        "mean_fraction": mean_frac,
+        "std_fraction": std_frac,
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# [CM-5] NEURON OVERLAP (same-dim models only)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def neuron_overlap(bundle_a, bundle_b, key_a, key_b):
+    """
+    [CM-5] For same-dimension models: do the same neuron indices carry drift?
+    """
+    dim_a = int(bundle_a["hidden_dim"])
+    dim_b = int(bundle_b["hidden_dim"])
+
+    if dim_a != dim_b:
+        logger.info(f"[CM-5] {key_a}({dim_a}) vs {key_b}({dim_b}): "
+                    f"dim mismatch, skipping")
+        return None
+
+    logger.info(f"[CM-5] Neuron overlap: {key_a} vs {key_b} (dim={dim_a})")
+
+    w_a = bundle_a["w_drift"]
+    w_b = bundle_b["w_drift"]
+
+    active_a = set(np.where(w_a != 0)[0])
+    active_b = set(np.where(w_b != 0)[0])
+
+    inter = len(active_a & active_b)
+    union = len(active_a | active_b)
+    jacc = inter / union if union > 0 else 0.0
+
+    # Cosine of weight vectors (even though from different models)
+    cos = float(np.dot(w_a, w_b) / (np.linalg.norm(w_a) * np.linalg.norm(w_b) + 1e-12))
+
+    # Top-k overlap
+    top100_a = set(np.argsort(np.abs(w_a))[-100:])
+    top100_b = set(np.argsort(np.abs(w_b))[-100:])
+    top100_overlap = len(top100_a & top100_b) / 100.0
+
+    logger.info(f"  Active: A={len(active_a)}, B={len(active_b)}")
+    logger.info(f"  Jaccard: {jacc:.4f}  Cosine: {cos:.4f}  "
+                f"Top-100 overlap: {top100_overlap:.2%}")
+
+    return {
+        "dim": dim_a,
+        "n_active_a": len(active_a),
+        "n_active_b": len(active_b),
+        "intersection": inter,
+        "union": union,
+        "jaccard": jacc,
+        "cosine": cos,
+        "top100_overlap": top100_overlap,
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# [CM-6] UNIVERSALITY SCORE
+# ─────────────────────────────────────────────────────────────────────────────
+
+def universality_score(all_cka, all_corr, all_diff, all_layer_corr,
+                       n_bootstrap=1000):
+    """
+    [CM-6] Aggregate metric: geometric mean of CKA, score correlation,
+    differential AUROC, and layer consistency.
+    """
+    logger.info("[CM-6] Universality score")
+
+    components = {}
+
+    # Mean best CKA across pairs
+    cka_vals = [v["best_cka"] for v in all_cka.values() if v]
+    if cka_vals:
+        components["mean_cka"] = float(np.mean(cka_vals))
+
+    # Mean score correlation
+    corr_vals = [v["correlation"] for v in all_corr.values() if v]
+    if corr_vals:
+        components["mean_score_corr"] = float(np.mean(corr_vals))
+
+    # Mean differential AUROC
+    diff_aurocs = []
+    for v in all_diff.values():
+        if v:
+            diff_aurocs.extend([v["auroc_a"], v["auroc_b"]])
+    if diff_aurocs:
+        components["mean_diff_auroc"] = float(np.mean(diff_aurocs))
+
+    # Layer consistency (1 - std of fractions)
+    if all_layer_corr:
+        components["layer_consistency"] = float(
+            1.0 - all_layer_corr.get("std_fraction", 0.5))
+
+    if not components:
+        return None
+
+    vals = list(components.values())
+    # Geometric mean
+    geo_mean = float(np.exp(np.mean(np.log(np.clip(vals, 1e-6, None)))))
+
+    # Bootstrap CI
+    boot = []
+    for _ in range(n_bootstrap):
+        idx = np.random.choice(len(vals), len(vals), replace=True)
+        boot.append(np.exp(np.mean(np.log(np.clip(np.array(vals)[idx], 1e-6, None)))))
+    ci_lo = float(np.percentile(boot, 2.5))
+    ci_hi = float(np.percentile(boot, 97.5))
+
+    logger.info(f"  Components: {components}")
+    logger.info(f"  Universality: {geo_mean:.4f} [{ci_lo:.4f}, {ci_hi:.4f}]")
+
+    return {
+        "components": components,
+        "universality_score": geo_mean,
+        "ci_95": [ci_lo, ci_hi],
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# FIGURES
+# ─────────────────────────────────────────────────────────────────────────────
+
+def save_cross_figures(out_dir, keys, all_cka, all_corr, all_diff,
+                       layer_data, neuron_data, univ_data):
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    fig_dir = Path(out_dir) / "figures"
+    fig_dir.mkdir(parents=True, exist_ok=True)
+
+    P = {"drift": "#e74c3c", "unc": "#3498db", "corr": "#2ecc71",
+         "null": "#9b59b6", "neu": "#e67e22"}
+
+    # ── CM-1: CKA heatmaps ───────────────────────────────────────────────
+    cka_pairs = [(k, v) for k, v in all_cka.items() if v]
+    if cka_pairs:
+        n_pairs = len(cka_pairs)
+        fig, axes = plt.subplots(1, n_pairs, figsize=(8 * n_pairs, 7))
+        if n_pairs == 1:
+            axes = [axes]
+        fig.suptitle("[CM-1] Cross-Model CKA", fontsize=16, fontweight="bold")
+        for ax, (pair_key, data) in zip(axes, cka_pairs):
+            mat = np.array(data["cka_matrix"])
+            im = ax.imshow(mat, cmap="viridis", vmin=0, vmax=1, aspect="auto")
+            la = data["layers_a"]
+            lb = data["layers_b"]
+            step_a = max(1, len(la) // 6)
+            step_b = max(1, len(lb) // 6)
+            ax.set_xticks(range(0, len(lb), step_b))
+            ax.set_yticks(range(0, len(la), step_a))
+            ax.set_xticklabels([lb[i] for i in range(0, len(lb), step_b)])
+            ax.set_yticklabels([la[i] for i in range(0, len(la), step_a)])
+            parts = pair_key.split("_vs_")
+            ax.set(xlabel=f"{parts[1]} layer", ylabel=f"{parts[0]} layer",
+                   title=f"{pair_key}\nbest={data['best_cka']:.3f}")
+            plt.colorbar(im, ax=ax, shrink=0.8)
+        plt.tight_layout()
+        plt.savefig(fig_dir / "fig_cm1_cka.png", dpi=300, bbox_inches="tight")
+        plt.close()
+        logger.info("  fig_cm1 saved")
+
+    # ── CM-2: Score correlation matrix ────────────────────────────────────
+    if len(keys) >= 2 and all_corr:
+        n = len(keys)
+        mat = np.eye(n)
+        for pair_key, data in all_corr.items():
+            if data is None:
+                continue
+            parts = pair_key.split("_vs_")
+            if len(parts) == 2:
+                i = keys.index(parts[0]) if parts[0] in keys else -1
+                j = keys.index(parts[1]) if parts[1] in keys else -1
+                if i >= 0 and j >= 0:
+                    mat[i, j] = mat[j, i] = data["correlation"]
+
+        fig, ax = plt.subplots(figsize=(8, 7))
+        im = ax.imshow(mat, cmap="RdBu_r", vmin=-1, vmax=1)
+        ax.set_xticks(range(n))
+        ax.set_yticks(range(n))
+        ax.set_xticklabels(keys, fontsize=12, rotation=20)
+        ax.set_yticklabels(keys, fontsize=12)
+        for i in range(n):
+            for j in range(n):
+                c = "white" if abs(mat[i, j]) > 0.5 else "black"
+                ax.text(j, i, f"{mat[i,j]:.3f}", ha="center", va="center",
+                        fontsize=13, fontweight="bold", color=c)
+        ax.set_title("[CM-2] Drift Score Correlation Matrix", fontsize=14)
+        plt.colorbar(im, ax=ax, shrink=0.8)
+        plt.tight_layout()
+        plt.savefig(fig_dir / "fig_cm2_corr.png", dpi=300, bbox_inches="tight")
+        plt.close()
+        logger.info("  fig_cm2 saved")
+
+    # ── CM-3: Differential facts ──────────────────────────────────────────
+    diff_pairs = [(k, v) for k, v in all_diff.items() if v]
+    if diff_pairs:
+        n_pairs = min(len(diff_pairs), 4)
+        fig, axes = plt.subplots(1, n_pairs, figsize=(7 * n_pairs, 6))
+        if n_pairs == 1:
+            axes = [axes]
+        fig.suptitle("[CM-3] Differential Facts", fontsize=16, fontweight="bold")
+        for ax, (pair_key, data) in zip(axes, diff_pairs[:n_pairs]):
+            sa = np.array(data["scores_a"])
+            sb = np.array(data["scores_b"])
+            la = np.array(data["labels_a"])
+            lb = np.array(data["labels_b"])
+            # Color by which model says drifted
+            a_drifted = la.astype(bool) & ~lb.astype(bool)
+            b_drifted = ~la.astype(bool) & lb.astype(bool)
+            ax.scatter(sa[a_drifted], sb[a_drifted], c=P["drift"], alpha=0.5,
+                       s=30, label="A=drifted, B=stable")
+            ax.scatter(sa[b_drifted], sb[b_drifted], c=P["unc"], alpha=0.5,
+                       s=30, label="A=stable, B=drifted")
+            ax.plot([0, 1], [0, 1], "k--", alpha=0.3)
+            ax.axhline(0.5, color="gray", ls=":", alpha=0.3)
+            ax.axvline(0.5, color="gray", ls=":", alpha=0.3)
+            parts = pair_key.split("_vs_")
+            ax.set(xlabel=f"{parts[0]} score", ylabel=f"{parts[1]} score",
+                   title=f"{pair_key}\nr={data['score_correlation']:.3f}")
+            ax.legend(fontsize=8)
+            ax.grid(alpha=0.2)
+        plt.tight_layout()
+        plt.savefig(fig_dir / "fig_cm3_diff.png", dpi=300, bbox_inches="tight")
+        plt.close()
+        logger.info("  fig_cm3 saved")
+
+    # ── CM-4: Layer correspondence ────────────────────────────────────────
+    if layer_data and "per_model" in layer_data:
+        pm = layer_data["per_model"]
+        models = sorted(pm.keys())
+        fig, axes = plt.subplots(1, 2, figsize=(14, 6))
+        fig.suptitle("[CM-4] Layer Correspondence", fontsize=14,
+                     fontweight="bold")
+
+        # Absolute layers
+        x = np.arange(len(models))
+        bls = [pm[m]["best_layer"] for m in models]
+        nls = [pm[m]["n_layers"] for m in models]
+        ax = axes[0]
+        ax.bar(x, bls, color=P["drift"], edgecolor="black", lw=0.5,
+               label="Best layer")
+        ax.bar(x, [n - b for b, n in zip(bls, nls)], bottom=bls,
+               color="#ecf0f1", edgecolor="black", lw=0.5, label="Remaining")
+        ax.set_xticks(x)
+        ax.set_xticklabels(models, fontsize=11)
+        ax.set(ylabel="Layer", title="Best Drift Layer (absolute)")
+        ax.legend()
+        ax.grid(alpha=0.3, axis="y")
+
+        # Fraction
+        ax = axes[1]
+        fracs = [pm[m]["fraction"] for m in models]
+        bars = ax.bar(x, fracs, color=P["neu"], edgecolor="black", lw=0.5)
+        ax.axhline(layer_data["mean_fraction"], color="red", ls="--", lw=2,
+                    label=f"Mean: {layer_data['mean_fraction']:.1%}")
+        ax.fill_between(
+            [-0.5, len(models) - 0.5],
+            layer_data["mean_fraction"] - layer_data["std_fraction"],
+            layer_data["mean_fraction"] + layer_data["std_fraction"],
+            alpha=0.2, color="red")
+        ax.set_xticks(x)
+        ax.set_xticklabels(models, fontsize=11)
+        ax.set(ylabel="Fraction of depth", title="Best Layer as % of Depth",
+               ylim=(0, 1))
+        ax.legend()
+        ax.grid(alpha=0.3, axis="y")
+        plt.tight_layout()
+        plt.savefig(fig_dir / "fig_cm4_layers.png",
+                    dpi=300, bbox_inches="tight")
+        plt.close()
+        logger.info("  fig_cm4 saved")
+
+    # ── CM-6: Summary ─────────────────────────────────────────────────────
+    if univ_data:
+        fig, ax = plt.subplots(figsize=(10, 6))
+        comp = univ_data["components"]
+        names = list(comp.keys())
+        vals = list(comp.values())
+        x = np.arange(len(names))
+        colors = [P["drift"], P["unc"], P["corr"], P["neu"]][:len(names)]
+        ax.bar(x, vals, color=colors, edgecolor="black", lw=0.5, alpha=0.8)
+        ax.axhline(univ_data["universality_score"], color="red", ls="--",
+                    lw=2.5,
+                    label=f"Geo mean: {univ_data['universality_score']:.3f} "
+                          f"[{univ_data['ci_95'][0]:.3f}, "
+                          f"{univ_data['ci_95'][1]:.3f}]")
+        ax.set_xticks(x)
+        ax.set_xticklabels([n.replace("_", "\n") for n in names], fontsize=10)
+        ax.set(ylabel="Score", title="[CM-6] Universality Score Components",
+               ylim=(0, 1.1))
+        ax.legend(fontsize=11)
+        ax.grid(alpha=0.3, axis="y")
+        plt.tight_layout()
+        plt.savefig(fig_dir / "fig_cm6_summary.png",
+                    dpi=300, bbox_inches="tight")
+        plt.close()
+        logger.info("  fig_cm6 saved")
+
+    logger.info(f"All cross-model figures -> {fig_dir}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# MAIN
+# ─────────────────────────────────────────────────────────────────────────────
+
+def main():
+    p = argparse.ArgumentParser(
+        description="Cross-model drift analysis",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    p.add_argument("--models", nargs="+", default=None,
+                   help="Model keys to compare")
+    p.add_argument("--all", action="store_true",
+                   help="Use all models with available caches")
+    p.add_argument("--config", default="models.yaml")
+    p.add_argument("--output_dir", default=None)
+    p.add_argument("--device", default="cuda:0")
+    p.add_argument("--quick", action="store_true",
+                   help="Skip full-layer CKA, just best-layer")
+    args = p.parse_args()
+
+    cfg = load_config(args.config)
+    defaults = cfg.get("defaults", {})
+    output_dir = args.output_dir or defaults.get("output_dir",
+                    "data/experiments/v4")
+
+    # Determine which models to use
+    if args.all:
+        model_keys = list(cfg["models"].keys())
+    elif args.models:
+        model_keys = args.models
+    else:
+        logger.error("Specify --models or --all")
+        return
+
+    # Load caches and bundles
+    all_results = {}
+    all_bundles = {}
+    all_final = {}
+    for key in model_keys:
+        res = load_cache(output_dir, key)
+        bundle = load_probe_bundle(output_dir, key)
+        final = load_final_results(output_dir, key)
+        if res and bundle:
+            all_results[key] = res
+            all_bundles[key] = bundle
+            if final:
+                all_final[key] = final
+
+    keys = sorted(all_results.keys())
+    logger.info(f"\nModels available: {keys}")
+
+    if len(keys) < 2:
+        logger.error("Need at least 2 models with caches + bundles")
+        return
+
+    cross_dir = Path(output_dir) / "cross_model"
+    cross_dir.mkdir(parents=True, exist_ok=True)
+
+    # Run all 6 experiments
+    all_cka = {}
+    all_corr = {}
+    all_diff = {}
+    all_neuron = {}
+
+    for i, ka in enumerate(keys):
+        for j, kb in enumerate(keys):
+            if i >= j:
+                continue
+            pair = f"{ka}_vs_{kb}"
+            logger.info(f"\n{'─'*50}")
+            logger.info(f"  {pair}")
+            logger.info(f"{'─'*50}")
+
+            # [CM-1] CKA
+            all_cka[pair] = cka_analysis(
+                all_results[ka], all_results[kb], ka, kb, quick=args.quick)
+
+            # [CM-2] Score correlation
+            all_corr[pair] = score_correlation(
+                all_results[ka], all_results[kb], ka, kb,
+                all_bundles[ka], all_bundles[kb], args.device)
+
+            # [CM-3] Differential facts
+            all_diff[pair] = differential_facts(
+                all_results[ka], all_results[kb], ka, kb,
+                all_bundles[ka], all_bundles[kb], args.device)
+
+            # [CM-5] Neuron overlap
+            all_neuron[pair] = neuron_overlap(
+                all_bundles[ka], all_bundles[kb], ka, kb)
+
+    # [CM-4] Layer correspondence
+    layer_data = layer_correspondence(all_bundles, all_final)
+
+    # [CM-6] Universality score
+    univ_data = universality_score(all_cka, all_corr, all_diff, layer_data)
+
+    # Save results
+    results = {
+        "models": keys,
+        "cka": {k: v for k, v in all_cka.items()},
+        "score_correlation": {k: v for k, v in all_corr.items()},
+        "differential_facts": {k: v for k, v in all_diff.items()},
+        "neuron_overlap": {k: v for k, v in all_neuron.items() if v},
+        "layer_correspondence": layer_data,
+        "universality": univ_data,
+        "timestamp": datetime.now().isoformat(),
+    }
+
+    from datetime import datetime
+    out_path = cross_dir / "cross_model_results.json"
+    with open(out_path, "w") as f:
+        json.dump(results, f, indent=2, default=str)
+    logger.info(f"\nResults saved: {out_path}")
+
+    # Figures
+    save_cross_figures(str(cross_dir), keys, all_cka, all_corr, all_diff,
+                       layer_data, all_neuron, univ_data)
+
+    # Print summary
+    print(f"\n{'='*70}")
+    print(f"  CROSS-MODEL SUMMARY")
+    print(f"{'='*70}")
+    for pair, data in all_corr.items():
+        if data:
+            print(f"  {pair}: score_corr={data['correlation']:.4f}")
+    for pair, data in all_diff.items():
+        if data:
+            print(f"  {pair}: diff_AUROC_a={data['auroc_a']:.4f}  "
+                  f"diff_AUROC_b={data['auroc_b']:.4f}  "
+                  f"n_diff={data['n_differential']}")
+    if layer_data:
+        print(f"\n  Layer correspondence: "
+              f"{layer_data['mean_fraction']:.1%} +/- "
+              f"{layer_data['std_fraction']:.1%}")
+    if univ_data:
+        print(f"\n  UNIVERSALITY SCORE: "
+              f"{univ_data['universality_score']:.4f} "
+              f"[{univ_data['ci_95'][0]:.4f}, {univ_data['ci_95'][1]:.4f}]")
+    print(f"{'='*70}")
+
+
+if __name__ == "__main__":
+    main()

data/experiments/attention_analysis/attention_summary.json

@@ -0,0 +1,270 @@
+{
+  "DRIFTED": {
+    "count": 16,
+    "avg_ltae": 1.2609138488769531,
+    "avg_taf_mean": NaN,
+    "avg_taf_std": NaN,
+    "avg_total_year_attn": NaN,
+    "layer_avg_ltae": [
+      1.47076416015625,
+      1.45465087890625,
+      1.437744140625,
+      1.49578857421875,
+      1.27398681640625,
+      1.43035888671875,
+      1.554931640625,
+      1.17523193359375,
+      1.27337646484375,
+      0.9449462890625,
+      1.45892333984375,
+      1.42083740234375,
+      1.42706298828125,
+      1.34649658203125,
+      1.35137939453125,
+      1.24322509765625,
+      1.160400390625,
+      0.8953857421875,
+      1.22137451171875,
+      0.4127349853515625,
+      0.9071044921875,
+      1.000396728515625,
+      1.181884765625,
+      1.33380126953125,
+      1.43408203125,
+      1.26983642578125,
+      1.37713623046875,
+      1.35174560546875
+    ],
+    "layer_avg_taf_mean": [
+      0.049678802490234375,
+      0.05012702941894531,
+      0.05734062194824219,
+      0.057758331298828125,
+      0.011784553527832031,
+      0.01109457015991211,
+      0.010257244110107422,
+      0.02216625213623047,
+      0.014124393463134766,
+      0.020898818969726562,
+      0.017520904541015625,
+      0.03136920928955078,
+      0.03072357177734375,
+      0.041080474853515625,
+      0.04144859313964844,
+      0.036899566650390625,
+      0.0413665771484375,
+      0.05501365661621094,
+      0.04434967041015625,
+      0.07583045959472656,
+      0.04676342010498047,
+      0.04759979248046875,
+      0.18784332275390625,
+      0.02937793731689453,
+      0.008492469787597656,
+      0.015366077423095703,
+      0.016284942626953125,
+      NaN
+    ]
+  },
+  "known_drift_not_drifted": {
+    "count": 18,
+    "avg_ltae": 1.267578125,
+    "avg_taf_mean": NaN,
+    "avg_taf_std": NaN,
+    "avg_total_year_attn": NaN,
+    "layer_avg_ltae": [
+      1.4648980034722223,
+      1.4579535590277777,
+      1.4423285590277777,
+      1.4934353298611112,
+      1.2616102430555556,
+      1.4229058159722223,
+      1.5550130208333333,
+      1.1838107638888888,
+      1.2801106770833333,
+      0.9503038194444444,
+      1.4531792534722223,
+      1.4236653645833333,
+      1.4342990451388888,
+      1.3516710069444444,
+      1.3551974826388888,
+      1.2670355902777777,
+      1.2147352430555556,
+      0.9173719618055556,
+      1.2401258680555556,
+      0.4350043402777778,
+      0.9250759548611112,
+      1.0575086805555556,
+      1.2380099826388888,
+      1.29541015625,
+      1.4357096354166667,
+      1.2632378472222223,
+      1.3846028645833333,
+      1.2879774305555556
+    ],
+    "layer_avg_taf_mean": [
+      0.05064731174045139,
+      0.050286187065972224,
+      0.0579071044921875,
+      0.058252970377604164,
+      0.011647542317708334,
+      0.011139763726128472,
+      0.010056813557942709,
+      0.021834479437934026,
+      0.013749440511067709,
+      0.020189921061197918,
+      0.017441219753689237,
+      0.031412760416666664,
+      0.030748155381944444,
+      0.04120042588975695,
+      0.041086832682291664,
+      0.035666571723090276,
+      0.039328681098090276,
+      0.05196804470486111,
+      0.041771782769097224,
+      0.07118055555555555,
+      0.043381585015190974,
+      0.04065110948350695,
+      0.16392347547743055,
+      0.03054046630859375,
+      0.008420096503363715,
+      0.014623006184895834,
+      0.015851338704427082,
+      NaN
+    ]
+  },
+  "no_drift_not_drifted": {
+    "count": 14,
+    "avg_ltae": 1.2851749342315046,
+    "avg_taf_mean": 0.03568217219138632,
+    "avg_taf_std": 0.039409403898278066,
+    "avg_total_year_attn": 27.97503662109375,
+    "layer_avg_ltae": [
+      1.4906529017857142,
+      1.46337890625,
+      1.4345703125,
+      1.482421875,
+      1.3511439732142858,
+      1.4000418526785714,
+      1.5374581473214286,
+      1.2036830357142858,
+      1.2655552455357142,
+      0.9605538504464286,
+      1.4325474330357142,
+      1.4031110491071428,
+      1.4244559151785714,
+      1.3436802455357142,
+      1.3675362723214286,
+      1.3018275669642858,
+      1.2701590401785714,
+      0.9279436383928571,
+      1.2454659598214286,
+      0.47621372767857145,
+      0.9602399553571429,
+      1.1858956473214286,
+      1.2562081473214286,
+      1.3112444196428572,
+      1.43115234375,
+      1.2403738839285714,
+      1.3879045758928572,
+      1.4294782366071428
+    ],
+    "layer_avg_taf_mean": [
+      0.04708644321986607,
+      0.04849897112165179,
+      0.05767168317522321,
+      0.0569610595703125,
+      0.011593409946986608,
+      0.011277879987444197,
+      0.010521480015345983,
+      0.021795000348772322,
+      0.014025551932198661,
+      0.020132882254464284,
+      0.01705987112862723,
+      0.029680524553571428,
+      0.029687064034598216,
+      0.040538242885044644,
+      0.04040309361049107,
+      0.034088134765625,
+      0.03676714215959821,
+      0.04921613420758929,
+      0.040592738560267856,
+      0.06517464773995536,
+      0.03857203892299107,
+      0.03687831333705357,
+      0.13168116978236608,
+      0.03133174351283482,
+      0.010894230433872767,
+      0.020661490304129466,
+      0.020259857177734375,
+      0.026050022670200894
+    ]
+  },
+  "stable_not_drifted": {
+    "count": 2,
+    "avg_ltae": 1.2617100306919644,
+    "avg_taf_mean": 0.039080756051199775,
+    "avg_taf_std": 0.044298444475446425,
+    "avg_total_year_attn": 30.6380615234375,
+    "layer_avg_ltae": [
+      1.51611328125,
+      1.38330078125,
+      1.443359375,
+      1.4951171875,
+      1.32470703125,
+      1.3896484375,
+      1.490234375,
+      1.36767578125,
+      1.298828125,
+      0.94921875,
+      1.423828125,
+      1.41796875,
+      1.36962890625,
+      1.36572265625,
+      1.3076171875,
+      1.3017578125,
+      1.275390625,
+      0.839111328125,
+      1.034423828125,
+      0.396240234375,
+      0.93896484375,
+      1.031982421875,
+      1.097900390625,
+      1.32470703125,
+      1.544921875,
+      1.21484375,
+      1.43115234375,
+      1.353515625
+    ],
+    "layer_avg_taf_mean": [
+      0.0544586181640625,
+      0.0511016845703125,
+      0.0582122802734375,
+      0.0601806640625,
+      0.0115966796875,
+      0.012378692626953125,
+      0.012664794921875,
+      0.02342987060546875,
+      0.015239715576171875,
+      0.02202606201171875,
+      0.0182647705078125,
+      0.033050537109375,
+      0.03174591064453125,
+      0.0473480224609375,
+      0.035797119140625,
+      0.03704833984375,
+      0.03562164306640625,
+      0.0518341064453125,
+      0.037261962890625,
+      0.060516357421875,
+      0.041290283203125,
+      0.037200927734375,
+      0.0977630615234375,
+      0.0742340087890625,
+      0.0103912353515625,
+      0.0435638427734375,
+      0.02713775634765625,
+      0.0529022216796875
+    ]
+  }
+}

data/experiments/disentanglement/cached_states.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eeca40a26e386337cc926ee3314f4e1a7c51a6a5e669f4153107fedb62df0e36
+size 572278675

data/experiments/disentanglement/disentanglement_results.json

@@ -0,0 +1,331 @@
+{
+  "model": "Qwen/Qwen2.5-7B-Instruct",
+  "n_samples": 2414,
+  "n_drifted": 734,
+  "n_non_drifted": 1680,
+  "confidence_threshold": 0.5,
+  "best_layer": 25,
+  "layer_results": {
+    "20": {
+      "drift_auroc": 0.9401817608974443,
+      "drift_C": 1.0,
+      "drift_active_neurons": 1144,
+      "uncertainty_auroc": 0.9850069912505234,
+      "uncertainty_C": 1.0,
+      "uncertainty_active_neurons": 605,
+      "cosine_similarity": -0.008123186416924,
+      "neuron_overlap_ratio": 0.15981432360742706,
+      "cell_analysis": {
+        "A: confident+stable": {
+          "n": 399,
+          "mean_drift_score": 0.0940876454114914,
+          "std_drift_score": 0.15016916394233704
+        },
+        "B: confident+drifted": {
+          "n": 148,
+          "mean_drift_score": 0.7503010034561157,
+          "std_drift_score": 0.2528006136417389
+        },
+        "C: uncertain+stable": {
+          "n": 1281,
+          "mean_drift_score": 0.09652922302484512,
+          "std_drift_score": 0.15843220055103302
+        },
+        "D: uncertain+drifted": {
+          "n": 586,
+          "mean_drift_score": 0.7983659505844116,
+          "std_drift_score": 0.24514280259609222
+        }
+      }
+    },
+    "21": {
+      "drift_auroc": 0.9301453621239755,
+      "drift_C": 1.0,
+      "drift_active_neurons": 1177,
+      "uncertainty_auroc": 0.9849118890796618,
+      "uncertainty_C": 1.0,
+      "uncertainty_active_neurons": 581,
+      "cosine_similarity": 0.017387816682457924,
+      "neuron_overlap_ratio": 0.1497710922171354,
+      "cell_analysis": {
+        "A: confident+stable": {
+          "n": 399,
+          "mean_drift_score": 0.09789332747459412,
+          "std_drift_score": 0.15043117105960846
+        },
+        "B: confident+drifted": {
+          "n": 148,
+          "mean_drift_score": 0.7385778427124023,
+          "std_drift_score": 0.24958111345767975
+        },
+        "C: uncertain+stable": {
+          "n": 1281,
+          "mean_drift_score": 0.09721978008747101,
+          "std_drift_score": 0.15863172709941864
+        },
+        "D: uncertain+drifted": {
+          "n": 586,
+          "mean_drift_score": 0.7971871495246887,
+          "std_drift_score": 0.24469861388206482
+        }
+      }
+    },
+    "22": {
+      "drift_auroc": 0.9331928302958495,
+      "drift_C": 1.0,
+      "drift_active_neurons": 1448,
+      "uncertainty_auroc": 0.9856988181780402,
+      "uncertainty_C": 1.0,
+      "uncertainty_active_neurons": 568,
+      "cosine_similarity": 0.0028538473416119814,
+      "neuron_overlap_ratio": 0.15265866209262435,
+      "cell_analysis": {
+        "A: confident+stable": {
+          "n": 399,
+          "mean_drift_score": 0.10201846808195114,
+          "std_drift_score": 0.15164713561534882
+        },
+        "B: confident+drifted": {
+          "n": 148,
+          "mean_drift_score": 0.7290875315666199,
+          "std_drift_score": 0.25161898136138916
+        },
+        "C: uncertain+stable": {
+          "n": 1281,
+          "mean_drift_score": 0.09975209087133408,
+          "std_drift_score": 0.16027547419071198
+        },
+        "D: uncertain+drifted": {
+          "n": 586,
+          "mean_drift_score": 0.79399174451828,
+          "std_drift_score": 0.24350778758525848
+        }
+      }
+    },
+    "23": {
+      "drift_auroc": 0.9365118470741198,
+      "drift_C": 1.0,
+      "drift_active_neurons": 1114,
+      "uncertainty_auroc": 0.9879286158449491,
+      "uncertainty_C": 1.0,
+      "uncertainty_active_neurons": 538,
+      "cosine_similarity": -0.012105713598430157,
+      "neuron_overlap_ratio": 0.13228238519533927,
+      "cell_analysis": {
+        "A: confident+stable": {
+          "n": 399,
+          "mean_drift_score": 0.09305085241794586,
+          "std_drift_score": 0.1508861929178238
+        },
+        "B: confident+drifted": {
+          "n": 148,
+          "mean_drift_score": 0.7569237947463989,
+          "std_drift_score": 0.2544007897377014
+        },
+        "C: uncertain+stable": {
+          "n": 1281,
+          "mean_drift_score": 0.09117205440998077,
+          "std_drift_score": 0.16001686453819275
+        },
+        "D: uncertain+drifted": {
+          "n": 586,
+          "mean_drift_score": 0.8082005977630615,
+          "std_drift_score": 0.2454250156879425
+        }
+      }
+    },
+    "24": {
+      "drift_auroc": 0.9431449716220474,
+      "drift_C": 1.0,
+      "drift_active_neurons": 1016,
+      "uncertainty_auroc": 0.9885632111980065,
+      "uncertainty_C": 1.0,
+      "uncertainty_active_neurons": 534,
+      "cosine_similarity": -0.0015611619455739856,
+      "neuron_overlap_ratio": 0.11591072714182865,
+      "cell_analysis": {
+        "A: confident+stable": {
+          "n": 399,
+          "mean_drift_score": 0.09185729175806046,
+          "std_drift_score": 0.14805559813976288
+        },
+        "B: confident+drifted": {
+          "n": 148,
+          "mean_drift_score": 0.7582934498786926,
+          "std_drift_score": 0.25423485040664673
+        },
+        "C: uncertain+stable": {
+          "n": 1281,
+          "mean_drift_score": 0.09093555808067322,
+          "std_drift_score": 0.16004474461078644
+        },
+        "D: uncertain+drifted": {
+          "n": 586,
+          "mean_drift_score": 0.8083383440971375,
+          "std_drift_score": 0.2449658066034317
+        }
+      }
+    },
+    "25": {
+      "drift_auroc": 0.9475673504887931,
+      "drift_C": 1.0,
+      "drift_active_neurons": 952,
+      "uncertainty_auroc": 0.9845519582427782,
+      "uncertainty_C": 1.0,
+      "uncertainty_active_neurons": 606,
+      "cosine_similarity": -0.012070227414369583,
+      "neuron_overlap_ratio": 0.14896755162241887,
+      "cell_analysis": {
+        "A: confident+stable": {
+          "n": 399,
+          "mean_drift_score": 0.09013982117176056,
+          "std_drift_score": 0.1471075862646103
+        },
+        "B: confident+drifted": {
+          "n": 148,
+          "mean_drift_score": 0.7635744214057922,
+          "std_drift_score": 0.2572714686393738
+        },
+        "C: uncertain+stable": {
+          "n": 1281,
+          "mean_drift_score": 0.0893697664141655,
+          "std_drift_score": 0.1600065380334854
+        },
+        "D: uncertain+drifted": {
+          "n": 586,
+          "mean_drift_score": 0.8106054663658142,
+          "std_drift_score": 0.24479782581329346
+        }
+      }
+    },
+    "26": {
+      "drift_auroc": 0.9473336040221698,
+      "drift_C": 1.0,
+      "drift_active_neurons": 1056,
+      "uncertainty_auroc": 0.9875504558093322,
+      "uncertainty_C": 1.0,
+      "uncertainty_active_neurons": 598,
+      "cosine_similarity": -0.02078830823302269,
+      "neuron_overlap_ratio": 0.13676975945017184,
+      "cell_analysis": {
+        "A: confident+stable": {
+          "n": 399,
+          "mean_drift_score": 0.08617039024829865,
+          "std_drift_score": 0.14635789394378662
+        },
+        "B: confident+drifted": {
+          "n": 148,
+          "mean_drift_score": 0.7733995318412781,
+          "std_drift_score": 0.257551908493042
+        },
+        "C: uncertain+stable": {
+          "n": 1281,
+          "mean_drift_score": 0.08761545270681381,
+          "std_drift_score": 0.16016000509262085
+        },
+        "D: uncertain+drifted": {
+          "n": 586,
+          "mean_drift_score": 0.815304696559906,
+          "std_drift_score": 0.24687542021274567
+        }
+      }
+    },
+    "27": {
+      "drift_auroc": 0.9470822738749772,
+      "drift_C": 1.0,
+      "drift_active_neurons": 750,
+      "uncertainty_auroc": 0.9909450020663509,
+      "uncertainty_C": 1.0,
+      "uncertainty_active_neurons": 375,
+      "cosine_similarity": -0.01884481869637966,
+      "neuron_overlap_ratio": 0.10294117647058823,
+      "cell_analysis": {
+        "A: confident+stable": {
+          "n": 399,
+          "mean_drift_score": 0.08059749752283096,
+          "std_drift_score": 0.14659664034843445
+        },
+        "B: confident+drifted": {
+          "n": 148,
+          "mean_drift_score": 0.7845885753631592,
+          "std_drift_score": 0.2633582055568695
+        },
+        "C: uncertain+stable": {
+          "n": 1281,
+          "mean_drift_score": 0.08413389325141907,
+          "std_drift_score": 0.1604897379875183
+        },
+        "D: uncertain+drifted": {
+          "n": 586,
+          "mean_drift_score": 0.8195926547050476,
+          "std_drift_score": 0.24837486445903778
+        }
+      }
+    }
+  },
+  "permutation_test": {
+    "true_auroc": 0.7590015570260802,
+    "null_mean": 0.5,
+    "null_std": 0.0,
+    "p_value": 0.0,
+    "n_permutations": 1000
+  },
+  "sparsity_curve": [
+    {
+      "C": 0.0001,
+      "n_active_neurons": 0,
+      "auroc": 0.5
+    },
+    {
+      "C": 0.0005,
+      "n_active_neurons": 0,
+      "auroc": 0.5
+    },
+    {
+      "C": 0.001,
+      "n_active_neurons": 0,
+      "auroc": 0.5
+    },
+    {
+      "C": 0.005,
+      "n_active_neurons": 7,
+      "auroc": 0.7590015570260802
+    },
+    {
+      "C": 0.01,
+      "n_active_neurons": 25,
+      "auroc": 0.8152385818087453
+    },
+    {
+      "C": 0.05,
+      "n_active_neurons": 125,
+      "auroc": 0.9305858310626702
+    },
+    {
+      "C": 0.1,
+      "n_active_neurons": 203,
+      "auroc": 0.9586617685221227
+    },
+    {
+      "C": 0.5,
+      "n_active_neurons": 588,
+      "auroc": 0.9779551057480212
+    },
+    {
+      "C": 1.0,
+      "n_active_neurons": 952,
+      "auroc": 0.9797083819903984
+    },
+    {
+      "C": 5.0,
+      "n_active_neurons": 2377,
+      "auroc": 0.9801904924094977
+    },
+    {
+      "C": 10.0,
+      "n_active_neurons": 2990,
+      "auroc": 0.9800303295705202
+    }
+  ],
+  "timestamp": "2026-03-06T04:05:50.245822"
+}

data/experiments/disentanglement_llama31/cached_states.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b0a8514c5b05e8cb22ba7edd22eebdeb0fdfecddfba21ca3bfd561ff77f0ab9
+size 743568647

data/experiments/drift_neurons/drift_neuron_results.json

@@ -0,0 +1,8 @@
+{
+  "hidden_layer_0": {
+    "l1_lambda": 0.001,
+    "metrics": {
+      "auroc": 0.5,
+      "auroc_std": 0.0,
+      "auprc": 0.5,
+      "brier": 

data/experiments/entropy_analysis/layer_signals_for_plotting.json

@@ -0,0 +1,490 @@
+{
+  "DRIFTED (post-cutoff, answer changed)": {
+    "layer_entropies": [
+      5.52294921875,
+      2.54351806640625,
+      1.316253662109375,
+      3.26361083984375,
+      1.2166748046875,
+      2.5682373046875,
+      2.9808349609375,
+      2.40643310546875,
+      0.528564453125,
+      1.335601806640625,
+      2.7979736328125,
+      6.949462890625,
+      5.368408203125,
+      5.93310546875,
+      6.6044921875,
+      6.924072265625,
+      5.29052734375,
+      5.44091796875,
+      4.5015869140625,
+      4.8775634765625,
+      4.46875,
+      3.368408203125,
+      3.0117034912109375,
+      5.2076416015625,
+      5.4983367919921875,
+      5.9327392578125,
+      6.9853515625,
+      1.7591285705566406
+    ],
+    "layer_top1_probs": [
+      0.334991455078125,
+      0.734527587890625,
+      0.86883544921875,
+      0.51593017578125,
+      0.6884765625,
+      0.709991455078125,
+      0.600433349609375,
+      0.747467041015625,
+      0.951385498046875,
+      0.86517333984375,
+      0.671905517578125,
+      0.0781402587890625,
+      0.2167205810546875,
+      0.200653076171875,
+      0.11643218994140625,
+      0.10364151000976562,
+      0.3043975830078125,
+      0.32175445556640625,
+      0.3555450439453125,
+      0.21065902709960938,
+      0.2103729248046875,
+      0.37808990478515625,
+      0.483154296875,
+      0.19554710388183594,
+      0.23350238800048828,
+      0.20551586151123047,
+      0.11835479736328125,
+      0.5825424194335938
+    ],
+    "layer_expected_probs": [
+      1.300126314163208e-06,
+      6.891787052154541e-07,
+      2.905726432800293e-07,
+      2.086162567138672e-07,
+      7.078051567077637e-08,
+      3.46451997756958e-07,
+      1.7881393432617188e-07,
+      1.564621925354004e-07,
+      1.7508864402770996e-07,
+      2.4959444999694824e-07,
+      3.0174851417541504e-07,
+      3.0919909477233887e-06,
+      1.475214958190918e-06,
+      2.1494925022125244e-06,
+      2.25752592086792e-06,
+      1.9781291484832764e-06,
+      1.039355993270874e-06,
+      5.848705768585205e-07,
+      9.685754776000977e-08,
+      3.725290298461914e-08,
+      8.195638656616211e-08,
+      1.601874828338623e-07,
+      2.421438694000244e-07,
+      3.028661012649536e-06,
+      1.9855797290802e-06,
+      1.2289732694625854e-05,
+      0.0018126480281352997,
+      0.00417274609208107
+    ],
+    "layer_old_probs": [
+      2.562999725341797e-06,
+      1.1511147022247314e-06,
+      4.284083843231201e-07,
+      2.4586915969848633e-07,
+      5.587935447692871e-08,
+      2.8312206268310547e-07,
+      1.601874828338623e-07,
+      1.8998980522155762e-07,
+      2.1979212760925293e-07,
+      2.980232238769531e-07,
+      2.123415470123291e-07,
+      3.1366944313049316e-06,
+      1.475214958190918e-06,
+      2.7865171432495117e-06,
+      9.793788194656372e-06,
+      4.120171070098877e-06,
+      1.2516975402832031e-06,
+      6.705522537231445e-07,
+      1.043081283569336e-07,
+      2.60770320892334e-08,
+      5.587935447692871e-08,
+      1.4156103134155273e-07,
+      8.307397365570068e-07,
+      2.074986696243286e-06,
+      8.113682270050049e-06,
+      0.0030834004282951355,
+      0.00276801735162735,
+      0.04702179878950119
+    ]
+  },
+  "KNOWN_DRIFT (pre-cutoff, model knows change)": {
+    "layer_entropies": [
+      5.532769097222222,
+      2.6904296875,
+      1.4892578125,
+      3.4954427083333335,
+      1.192626953125,
+      2.5450303819444446,
+      2.9092881944444446,
+      2.40625,
+      0.5602891710069444,
+      1.4476453993055556,
+      3.0266927083333335,
+      7.0546875,
+      5.453342013888889,
+      6.067057291666667,
+      6.706380208333333,
+      7.037760416666667,
+      5.235243055555555,
+      5.470920138888889,
+      4.659830729166667,
+      5.143446180555555,
+      4.777886284722222,
+      3.9322916666666665,
+      2.8102213541666665,
+      4.944769965277778,
+      4.661973741319445,
+      5.928276909722222,
+      7.105251736111111,
+      2.0204366048177085
+    ],
+    "layer_top1_probs": [
+      0.3287082248263889,
+      0.7144097222222222,
+      0.8493381076388888,
+      0.4696044921875,
+      0.7038031684027778,
+      0.7146538628472222,
+      0.6084255642361112,
+      0.7483452690972222,
+      0.9480523003472222,
+      0.8536241319444444,
+      0.6454671223958334,
+      0.0778316921657986,
+      0.21478271484375,
+      0.1902737087673611,
+      0.11335923936631945,
+      0.09361097547743055,
+      0.3209296332465278,
+      0.33294677734375,
+      0.3272298177083333,
+      0.1654052734375,
+      0.1807284884982639,
+      0.2668389214409722,
+      0.5159708658854166,
+      0.242095947265625,
+      0.31541358100043404,
+      0.19419691297743055,
+      0.09735192192925347,
+      0.4987657335069444
+    ],
+    "layer_expected_probs": [
+      3.420644336276584e-06,
+      2.9901663462320962e-06,
+      1.3841523064507378e-06,
+      1.0563267601860894e-06,
+      1.7550256517198352e-07,
+      7.980399661593967e-07,
+      4.635916815863715e-07,
+      3.7749608357747394e-07,
+      3.3775965372721356e-07,
+      7.020102606879341e-07,
+      7.748603820800781e-07,
+      4.516707526312934e-06,
+      1.970264646742079e-06,
+      3.741847144232856e-06,
+      4.990233315361871e-06,
+      3.4504466586642793e-06,
+      1.4139546288384331e-06,
+      1.394086413913303e-06,
+      5.03328111436632e-07,
+      1.1920928955078125e-07,
+      9.602970547146268e-08,
+      6.622738308376736e-08,
+      4.967053731282552e-08,
+      1.5232298109266494e-06,
+      3.688865237765842e-06,
+      1.6669432322184246e-05,
+      0.001622299353281657,
+      0.006558269262313843
+    ],
+    "layer_old_probs": [
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0
+    ]
+  },
+  "NO_DRIFT (post-cutoff, could change but didn't)": {
+    "layer_entropies": [
+      5.503069196428571,
+      2.8865792410714284,
+      1.5439801897321428,
+      3.3995535714285716,
+      1.1728166852678572,
+      2.6416015625,
+      2.821986607142857,
+      2.2252371651785716,
+      0.4691859654017857,
+      1.4714704241071428,
+      2.9832589285714284,
+      7.001674107142857,
+      5.416015625,
+      6.001116071428571,
+      6.802455357142857,
+      6.978794642857143,
+      5.027483258928571,
+      5.341657366071429,
+      4.785993303571429,
+      4.964006696428571,
+      4.733677455357143,
+      3.65771484375,
+      3.9832589285714284,
+      4.494698660714286,
+      4.796247209821429,
+      6.250558035714286,
+      6.985630580357143,
+      2.26318359375
+    ],
+    "layer_top1_probs": [
+      0.32688685825892855,
+      0.6917898995535714,
+      0.8450055803571429,
+      0.47745186941964285,
+      0.7064034598214286,
+      0.705322265625,
+      0.619140625,
+      0.7668805803571429,
+      0.9564383370535714,
+      0.8492954799107143,
+      0.6484026227678571,
+      0.08108084542410714,
+      0.20847865513392858,
+      0.19773646763392858,
+      0.09962027413504464,
+      0.10276576450892858,
+      0.33909388950892855,
+      0.35335867745535715,
+      0.30741664341517855,
+      0.20300728934151785,
+      0.20433262416294642,
+      0.30856759207589285,
+      0.27522059849330355,
+      0.2831638881138393,
+      0.29340689522879465,
+      0.1388059343610491,
+      0.10486602783203125,
+      0.49221365792410715
+    ],
+    "layer_expected_probs": [
+      7.450580596923828e-07,
+      4.981245313371931e-07,
+      1.873288835797991e-07,
+      4.470348358154297e-07,
+      8.089201790945871e-08,
+      4.896095820835658e-07,
+      3.6188534327915735e-07,
+      3.10795647757394e-07,
+      1.1069434029715402e-07,
+      2.2990362984793527e-07,
+      3.405979701450893e-07,
+      1.230410167149135e-06,
+      6.130763462611608e-07,
+      1.1793204716273716e-06,
+      1.4262539999825613e-06,
+      1.4347689492361887e-06,
+      8.600098746163505e-07,
+      4.470348358154297e-07,
+      1.4901161193847656e-07,
+      1.9158635820661273e-07,
+      2.086162567138672e-07,
+      1.532690865652902e-07,
+      2.1287373134068081e-07,
+      1.0601111820765903e-06,
+      4.104205540248326e-06,
+      4.9591064453125e-05,
+      0.005290542330060687,
+      0.0049742162227630615
+    ],
+    "layer_old_probs": [
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0
+    ]
+  },
+  "STABLE (post-cutoff, never changes)": {
+    "layer_entropies": [
+      3.388671875,
+      3.06640625,
+      1.544921875,
+      3.615234375,
+      2.02978515625,
+      3.2109375,
+      2.7822265625,
+      2.4091796875,
+      0.6947021484375,
+      0.908447265625,
+      2.642578125,
+      5.40625,
+      3.8681640625,
+      5.76953125,
+      4.310546875,
+      5.1875,
+      5.240234375,
+      6.1171875,
+      5.146484375,
+      3.80859375,
+      2.8193359375,
+      5.798828125,
+      3.234375,
+      0.8599853515625,
+      1.47216796875,
+      2.302490234375,
+      0.5925039052963257,
+      0.046706557273864746
+    ],
+    "layer_top1_probs": [
+      0.649658203125,
+      0.7109375,
+      0.855712890625,
+      0.517822265625,
+      0.622802734375,
+      0.5374755859375,
+      0.53466796875,
+      0.701171875,
+      0.925048828125,
+      0.89990234375,
+      0.570068359375,
+      0.23565673828125,
+      0.3314208984375,
+      0.119903564453125,
+      0.4659423828125,
+      0.3116455078125,
+      0.23419189453125,
+      0.1383056640625,
+      0.2002410888671875,
+      0.37921142578125,
+      0.55419921875,
+      0.19232177734375,
+      0.330078125,
+      0.711669921875,
+      0.528564453125,
+      0.5738525390625,
+      0.7919921875,
+      0.99169921875
+    ],
+    "layer_expected_probs": [
+      2.092123031616211e-05,
+      6.020069122314453e-06,
+      1.8775463104248047e-06,
+      4.172325134277344e-07,
+      1.1920928955078125e-07,
+      1.4901161193847656e-07,
+      2.682209014892578e-07,
+      0.0,
+      2.9802322387695312e-08,
+      2.9802322387695312e-08,
+      5.960464477539063e-08,
+      5.960464477539062e-07,
+      2.980232238769531e-07,
+      2.980232238769531e-07,
+      7.748603820800781e-07,
+      7.748603820800781e-07,
+      4.172325134277344e-07,
+      2.682209014892578e-07,
+      5.960464477539063e-08,
+      2.9802322387695312e-08,
+      0.0,
+      6.556510925292969e-07,
+      1.1324882507324219e-06,
+      5.662441253662109e-07,
+      2.0265579223632812e-06,
+      0.01308441162109375,
+      0.58233642578125,
+      0.99169921875
+    ],
+    "layer_old_probs": [
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0
+    ]
+  }
+}

data/experiments/entropy_analysis/signal_summary.json

@@ -0,0 +1,522 @@
+{
+  "DRIFTED (post-cutoff, answer changed)": {
+    "count": 16,
+    "avg_entropy": 2.4283905029296875,
+    "std_entropy": 1.4596738111148464,
+    "avg_top1_prob": 0.47666168212890625,
+    "std_top1_prob": 0.277152691495795,
+    "avg_expected_answer_prob": 0.01105436310172081,
+    "avg_expected_answer_rank": 1116.4375,
+    "avg_old_answer_prob": 0.14018350467085838,
+    "layer_avg_entropies": [
+      5.52294921875,
+      2.54351806640625,
+      1.316253662109375,
+      3.26361083984375,
+      1.2166748046875,
+      2.5682373046875,
+      2.9808349609375,
+      2.40643310546875,
+      0.528564453125,
+      1.335601806640625,
+      2.7979736328125,
+      6.949462890625,
+      5.368408203125,
+      5.93310546875,
+      6.6044921875,
+      6.924072265625,
+      5.29052734375,
+      5.44091796875,
+      4.5015869140625,
+      4.8775634765625,
+      4.46875,
+      3.368408203125,
+      3.0117034912109375,
+      5.2076416015625,
+      5.4983367919921875,
+      5.9327392578125,
+      6.9853515625,
+      1.7591285705566406
+    ],
+    "layer_avg_top1_probs": [
+      0.334991455078125,
+      0.734527587890625,
+      0.86883544921875,
+      0.51593017578125,
+      0.6884765625,
+      0.709991455078125,
+      0.600433349609375,
+      0.747467041015625,
+      0.951385498046875,
+      0.86517333984375,
+      0.671905517578125,
+      0.0781402587890625,
+      0.2167205810546875,
+      0.200653076171875,
+      0.11643218994140625,
+      0.10364151000976562,
+      0.3043975830078125,
+      0.32175445556640625,
+      0.3555450439453125,
+      0.21065902709960938,
+      0.2103729248046875,
+      0.37808990478515625,
+      0.483154296875,
+      0.19554710388183594,
+      0.23350238800048828,
+      0.20551586151123047,
+      0.11835479736328125,
+      0.5825424194335938
+    ],
+    "layer_avg_expected_probs": [
+      1.300126314163208e-06,
+      6.891787052154541e-07,
+      2.905726432800293e-07,
+      2.086162567138672e-07,
+      7.078051567077637e-08,
+      3.46451997756958e-07,
+      1.7881393432617188e-07,
+      1.564621925354004e-07,
+      1.7508864402770996e-07,
+      2.4959444999694824e-07,
+      3.0174851417541504e-07,
+      3.0919909477233887e-06,
+      1.475214958190918e-06,
+      2.1494925022125244e-06,
+      2.25752592086792e-06,
+      1.9781291484832764e-06,
+      1.039355993270874e-06,
+      5.848705768585205e-07,
+      9.685754776000977e-08,
+      3.725290298461914e-08,
+      8.195638656616211e-08,
+      1.601874828338623e-07,
+      2.421438694000244e-07,
+      3.028661012649536e-06,
+      1.9855797290802e-06,
+      1.2289732694625854e-05,
+      0.0018126480281352997,
+      0.00417274609208107
+    ],
+    "layer_avg_old_probs": [
+      2.562999725341797e-06,
+      1.1511147022247314e-06,
+      4.284083843231201e-07,
+      2.4586915969848633e-07,
+      5.587935447692871e-08,
+      2.8312206268310547e-07,
+      1.601874828338623e-07,
+      1.8998980522155762e-07,
+      2.1979212760925293e-07,
+      2.980232238769531e-07,
+      2.123415470123291e-07,
+      3.1366944313049316e-06,
+      1.475214958190918e-06,
+      2.7865171432495117e-06,
+      9.793788194656372e-06,
+      4.120171070098877e-06,
+      1.2516975402832031e-06,
+      6.705522537231445e-07,
+      1.043081283569336e-07,
+      2.60770320892334e-08,
+      5.587935447692871e-08,
+      1.4156103134155273e-07,
+      8.307397365570068e-07,
+      2.074986696243286e-06,
+      8.113682270050049e-06,
+      0.0030834004282951355,
+      0.00276801735162735,
+      0.04702179878950119
+    ]
+  },
+  "KNOWN_DRIFT (pre-cutoff, model knows change)": {
+    "count": 18,
+    "avg_entropy": 2.192626953125,
+    "std_entropy": 1.052990943659832,
+    "avg_top1_prob": 0.5486314561631944,
+    "std_top1_prob": 0.24056330318864452,
+    "avg_expected_answer_prob": 0.0022764967547522653,
+    "avg_expected_answer_rank": 594.9444444444445,
+    "avg_old_answer_prob": 0.0,
+    "layer_avg_entropies": [
+      5.532769097222222,
+      2.6904296875,
+      1.4892578125,
+      3.4954427083333335,
+      1.192626953125,
+      2.5450303819444446,
+      2.9092881944444446,
+      2.40625,
+      0.5602891710069444,
+      1.4476453993055556,
+      3.0266927083333335,
+      7.0546875,
+      5.453342013888889,
+      6.067057291666667,
+      6.706380208333333,
+      7.037760416666667,
+      5.235243055555555,
+      5.470920138888889,
+      4.659830729166667,
+      5.143446180555555,
+      4.777886284722222,
+      3.9322916666666665,
+      2.8102213541666665,
+      4.944769965277778,
+      4.661973741319445,
+      5.928276909722222,
+      7.105251736111111,
+      2.0204366048177085
+    ],
+    "layer_avg_top1_probs": [
+      0.3287082248263889,
+      0.7144097222222222,
+      0.8493381076388888,
+      0.4696044921875,
+      0.7038031684027778,
+      0.7146538628472222,
+      0.6084255642361112,
+      0.7483452690972222,
+      0.9480523003472222,
+      0.8536241319444444,
+      0.6454671223958334,
+      0.0778316921657986,
+      0.21478271484375,
+      0.1902737087673611,
+      0.11335923936631945,
+      0.09361097547743055,
+      0.3209296332465278,
+      0.33294677734375,
+      0.3272298177083333,
+      0.1654052734375,
+      0.1807284884982639,
+      0.2668389214409722,
+      0.5159708658854166,
+      0.242095947265625,
+      0.31541358100043404,
+      0.19419691297743055,
+      0.09735192192925347,
+      0.4987657335069444
+    ],
+    "layer_avg_expected_probs": [
+      3.420644336276584e-06,
+      2.9901663462320962e-06,
+      1.3841523064507378e-06,
+      1.0563267601860894e-06,
+      1.7550256517198352e-07,
+      7.980399661593967e-07,
+      4.635916815863715e-07,
+      3.7749608357747394e-07,
+      3.3775965372721356e-07,
+      7.020102606879341e-07,
+      7.748603820800781e-07,
+      4.516707526312934e-06,
+      1.970264646742079e-06,
+      3.741847144232856e-06,
+      4.990233315361871e-06,
+      3.4504466586642793e-06,
+      1.4139546288384331e-06,
+      1.394086413913303e-06,
+      5.03328111436632e-07,
+      1.1920928955078125e-07,
+      9.602970547146268e-08,
+      6.622738308376736e-08,
+      4.967053731282552e-08,
+      1.5232298109266494e-06,
+      3.688865237765842e-06,
+      1.6669432322184246e-05,
+      0.001622299353281657,
+      0.006558269262313843
+    ],
+    "layer_avg_old_probs": [
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0
+    ]
+  },
+  "NO_DRIFT (post-cutoff, could change but didn't)": {
+    "count": 14,
+    "avg_entropy": 3.041259765625,
+    "std_entropy": 1.2868754903974626,
+    "avg_top1_prob": 0.38180106026785715,
+    "std_top1_prob": 0.2012997163043124,
+    "avg_expected_answer_prob": 0.011885932513645716,
+    "avg_expected_answer_rank": 638.3571428571429,
+    "avg_old_answer_prob": 0.0,
+    "layer_avg_entropies": [
+      5.503069196428571,
+      2.8865792410714284,
+      1.5439801897321428,
+      3.3995535714285716,
+      1.1728166852678572,
+      2.6416015625,
+      2.821986607142857,
+      2.2252371651785716,
+      0.4691859654017857,
+      1.4714704241071428,
+      2.9832589285714284,
+      7.001674107142857,
+      5.416015625,
+      6.001116071428571,
+      6.802455357142857,
+      6.978794642857143,
+      5.027483258928571,
+      5.341657366071429,
+      4.785993303571429,
+      4.964006696428571,
+      4.733677455357143,
+      3.65771484375,
+      3.9832589285714284,
+      4.494698660714286,
+      4.796247209821429,
+      6.250558035714286,
+      6.985630580357143,
+      2.26318359375
+    ],
+    "layer_avg_top1_probs": [
+      0.32688685825892855,
+      0.6917898995535714,
+      0.8450055803571429,
+      0.47745186941964285,
+      0.7064034598214286,
+      0.705322265625,
+      0.619140625,
+      0.7668805803571429,
+      0.9564383370535714,
+      0.8492954799107143,
+      0.6484026227678571,
+      0.08108084542410714,
+      0.20847865513392858,
+      0.19773646763392858,
+      0.09962027413504464,
+      0.10276576450892858,
+      0.33909388950892855,
+      0.35335867745535715,
+      0.30741664341517855,
+      0.20300728934151785,
+      0.20433262416294642,
+      0.30856759207589285,
+      0.27522059849330355,
+      0.2831638881138393,
+      0.29340689522879465,
+      0.1388059343610491,
+      0.10486602783203125,
+      0.49221365792410715
+    ],
+    "layer_avg_expected_probs": [
+      7.450580596923828e-07,
+      4.981245313371931e-07,
+      1.873288835797991e-07,
+      4.470348358154297e-07,
+      8.089201790945871e-08,
+      4.896095820835658e-07,
+      3.6188534327915735e-07,
+      3.10795647757394e-07,
+      1.1069434029715402e-07,
+      2.2990362984793527e-07,
+      3.405979701450893e-07,
+      1.230410167149135e-06,
+      6.130763462611608e-07,
+      1.1793204716273716e-06,
+      1.4262539999825613e-06,
+      1.4347689492361887e-06,
+      8.600098746163505e-07,
+      4.470348358154297e-07,
+      1.4901161193847656e-07,
+      1.9158635820661273e-07,
+      2.086162567138672e-07,
+      1.532690865652902e-07,
+      2.1287373134068081e-07,
+      1.0601111820765903e-06,
+      4.104205540248326e-06,
+      4.9591064453125e-05,
+      0.005290542330060687,
+      0.0049742162227630615
+    ],
+    "layer_avg_old_probs": [
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0
+    ]
+  },
+  "STABLE (post-cutoff, never changes)": {
+    "count": 2,
+    "avg_entropy": 0.0290374755859375,
+    "std_entropy": 0.0290374755859375,
+    "avg_top1_prob": 0.994873046875,
+    "std_top1_prob": 0.005126953125,
+    "avg_expected_answer_prob": 0.994873046875,
+    "avg_expected_answer_rank": 0.0,
+    "avg_old_answer_prob": 0.0,
+    "layer_avg_entropies": [
+      3.388671875,
+      3.06640625,
+      1.544921875,
+      3.615234375,
+      2.02978515625,
+      3.2109375,
+      2.7822265625,
+      2.4091796875,
+      0.6947021484375,
+      0.908447265625,
+      2.642578125,
+      5.40625,
+      3.8681640625,
+      5.76953125,
+      4.310546875,
+      5.1875,
+      5.240234375,
+      6.1171875,
+      5.146484375,
+      3.80859375,
+      2.8193359375,
+      5.798828125,
+      3.234375,
+      0.8599853515625,
+      1.47216796875,
+      2.302490234375,
+      0.5925039052963257,
+      0.046706557273864746
+    ],
+    "layer_avg_top1_probs": [
+      0.649658203125,
+      0.7109375,
+      0.855712890625,
+      0.517822265625,
+      0.622802734375,
+      0.5374755859375,
+      0.53466796875,
+      0.701171875,
+      0.925048828125,
+      0.89990234375,
+      0.570068359375,
+      0.23565673828125,
+      0.3314208984375,
+      0.119903564453125,
+      0.4659423828125,
+      0.3116455078125,
+      0.23419189453125,
+      0.1383056640625,
+      0.2002410888671875,
+      0.37921142578125,
+      0.55419921875,
+      0.19232177734375,
+      0.330078125,
+      0.711669921875,
+      0.528564453125,
+      0.5738525390625,
+      0.7919921875,
+      0.99169921875
+    ],
+    "layer_avg_expected_probs": [
+      2.092123031616211e-05,
+      6.020069122314453e-06,
+      1.8775463104248047e-06,
+      4.172325134277344e-07,
+      1.1920928955078125e-07,
+      1.4901161193847656e-07,
+      2.682209014892578e-07,
+      0.0,
+      2.9802322387695312e-08,
+      2.9802322387695312e-08,
+      5.960464477539063e-08,
+      5.960464477539062e-07,
+      2.980232238769531e-07,
+      2.980232238769531e-07,
+      7.748603820800781e-07,
+      7.748603820800781e-07,
+      4.172325134277344e-07,
+      2.682209014892578e-07,
+      5.960464477539063e-08,
+      2.9802322387695312e-08,
+      0.0,
+      6.556510925292969e-07,
+      1.1324882507324219e-06,
+      5.662441253662109e-07,
+      2.0265579223632812e-06,
+      0.01308441162109375,
+      0.58233642578125,
+      0.99169921875
+    ],
+    "layer_avg_old_probs": [
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0
+    ]
+  }
+}

data/experiments/tier1_gemma2_v2/cached_states.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00d7efe60b6dadc21ab51a08e9ce403d40d6d468741c5f51dbaf726238dc9d5a
+size 5351543162

data/experiments/tier1_gemma2_v2/per_layer/layer_00.json

@@ -0,0 +1,92 @@
+{
+  "layer": 0,
+  "drift_auroc": 0.893690467142311,
+  "drift_C": 1.0,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.9468121942708154,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9911295549792435,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": 0.04864960163831711,
+  "cos_drift_correctness": 0.019523993134498596,
+  "cos_uncertainty_correctness": 0.02531621605157852,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.06004580855369568,
+      "std": 0.09024611115455627
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.4490325152873993,
+      "std": 0.19269588589668274
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.02900705859065056,
+      "std": 0.06720896065235138
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.3332471251487732,
+      "std": 0.22961613535881042
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.7026691136224604,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.9078858727663971,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.8167778352619494,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.49824870630239754,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.7720848056537103,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.5192238429677651,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.9392068688802766,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.739601495897723,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.8821834338392397,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 166.7998149394989
+}

data/experiments/tier1_gemma2_v2/per_layer/layer_01.json

@@ -0,0 +1,92 @@
+{
+  "layer": 1,
+  "drift_auroc": 0.9011490479613139,
+  "drift_C": 1.0,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.950048076452063,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9964158507941018,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": 0.0267711840569973,
+  "cos_drift_correctness": -0.005616667214781046,
+  "cos_uncertainty_correctness": 0.005185432732105255,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.04730555787682533,
+      "std": 0.08764217793941498
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.5626447200775146,
+      "std": 0.21129858493804932
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.026469526812434196,
+      "std": 0.06594817340373993
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.387656569480896,
+      "std": 0.24772387742996216
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.6954280562799832,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.9146280954227356,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.8389002062819181,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.4647895811206773,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.8345111896348646,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.5603877783780539,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.951401989627087,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.8182645131202335,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.9043420448793534,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 169.61970496177673
+}

data/experiments/tier1_gemma2_v2/per_layer/layer_02.json

@@ -0,0 +1,92 @@
+{
+  "layer": 2,
+  "drift_auroc": 0.896794238503098,
+  "drift_C": 1.0,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.9524823664516303,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9976293574168594,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": 0.01810559071600437,
+  "cos_drift_correctness": -0.007012477610260248,
+  "cos_uncertainty_correctness": -0.0047056423500180244,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.0446111224591732,
+      "std": 0.08681754022836685
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.5915916562080383,
+      "std": 0.20707546174526215
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.02458667755126953,
+      "std": 0.06488249450922012
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.4164687991142273,
+      "std": 0.24728882312774658
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.6977719823561608,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.9117476343121672,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.8143547310449092,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.5125660030581731,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.7555948174322733,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.5532444924665346,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.9506697066023784,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.8079059184598046,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.9099473701292581,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 173.2671389579773
+}

data/experiments/tier1_gemma2_v2/per_layer/layer_03.json

@@ -0,0 +1,92 @@
+{
+  "layer": 3,
+  "drift_auroc": 0.9225361554547803,
+  "drift_C": 1.0,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.9638786049961436,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9974697877989147,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": 0.010065648704767227,
+  "cos_drift_correctness": 0.023633282631635666,
+  "cos_uncertainty_correctness": 0.00039188837399706244,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.031129170209169388,
+      "std": 0.09004193544387817
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.7261084914207458,
+      "std": 0.2061491310596466
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.017781062051653862,
+      "std": 0.06107195094227791
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.5275082588195801,
+      "std": 0.2770618796348572
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.755339837084259,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.9377751829455391,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.8435954054343507,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.5274670643798159,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.8498233215547703,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.6006663065009904,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.9578111554132155,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.824638788878667,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.9352960264668337,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 162.03071880340576
+}

data/experiments/tier1_gemma2_v2/per_layer/layer_04.json

@@ -0,0 +1,92 @@
+{
+  "layer": 4,
+  "drift_auroc": 0.9396707206563885,
+  "drift_C": 0.1,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.9691975303229995,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9975606877008757,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": -0.020001864060759544,
+  "cos_drift_correctness": 0.007599391043186188,
+  "cos_uncertainty_correctness": -0.01379857212305069,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.04271675646305084,
+      "std": 0.09466906636953354
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.6230219006538391,
+      "std": 0.21390636265277863
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.021475067362189293,
+      "std": 0.06276922672986984
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.4303804934024811,
+      "std": 0.28279992938041687
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.7960913100872533,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.9670924954097121,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.8954248328976688,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.511530291731634,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.9275618374558303,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.698046101206555,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.9653269451749541,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.8409110969771744,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.9528741193055105,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 133.53380727767944
+}

data/experiments/tier1_gemma2_v2/per_layer/layer_05.json

@@ -0,0 +1,92 @@
+{
+  "layer": 5,
+  "drift_auroc": 0.9439126223777906,
+  "drift_C": 0.1,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.9726526636296121,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9979646479961378,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": -0.03619128465652466,
+  "cos_drift_correctness": 0.0033732375595718622,
+  "cos_uncertainty_correctness": -0.001980707747861743,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.043339140713214874,
+      "std": 0.0970807820558548
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.6173967719078064,
+      "std": 0.21449479460716248
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.021661318838596344,
+      "std": 0.061699919402599335
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.42544519901275635,
+      "std": 0.2802523374557495
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.8142341994268971,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.9642101597055112,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.905951018952588,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.5180063121897573,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.9405182567726738,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.7359760489825319,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.967296646088255,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.8937458171329394,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.9624574404082189,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 144.82072019577026
+}

data/experiments/tier1_gemma2_v2/per_layer/layer_06.json

@@ -0,0 +1,92 @@
+{
+  "layer": 6,
+  "drift_auroc": 0.9460011324345245,
+  "drift_C": 0.1,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.9749156173477416,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9979849697082791,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": -0.02005905658006668,
+  "cos_drift_correctness": -0.008644387125968933,
+  "cos_uncertainty_correctness": 0.035370659083127975,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.03948484733700752,
+      "std": 0.09584105759859085
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.6535050868988037,
+      "std": 0.21575653553009033
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.020458266139030457,
+      "std": 0.05958631634712219
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.449584424495697,
+      "std": 0.2899908125400543
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.8088702147525676,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.9679368025155073,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.9193024701886645,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.5090182209869011,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.9658421672555947,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.8011960501830843,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.9661937414455942,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.8923783272065241,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.9598720056148711,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 144.84658360481262
+}

data/experiments/tier1_gemma2_v2/per_layer/layer_07.json

@@ -0,0 +1,92 @@
+{
+  "layer": 7,
+  "drift_auroc": 0.9486147092727818,
+  "drift_C": 0.1,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.9779143750837568,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9976602817614224,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": -0.030850570648908615,
+  "cos_drift_correctness": 0.026000214740633965,
+  "cos_uncertainty_correctness": 0.027471689507365227,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.04007749259471893,
+      "std": 0.09756413847208023
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.6484773755073547,
+      "std": 0.21335306763648987
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.02045559510588646,
+      "std": 0.058983251452445984
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.4480625092983246,
+      "std": 0.2810366153717041
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.811491033194887,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.9661582571409685,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.9180203386302509,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.5355230153887872,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.9517078916372202,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.7831952698241191,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.9660191224328895,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.9027776550873549,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.9633052911950717,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 143.7363555431366
+}

data/experiments/tier1_gemma2_v2/per_layer/layer_08.json

@@ -0,0 +1,92 @@
+{
+  "layer": 8,
+  "drift_auroc": 0.9436369438142326,
+  "drift_C": 0.1,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.9807194646000107,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9980536040821549,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": -0.039751965552568436,
+  "cos_drift_correctness": -0.004410579800605774,
+  "cos_uncertainty_correctness": 0.045971233397722244,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.039205152541399,
+      "std": 0.09732519090175629
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.6585108637809753,
+      "std": 0.20939327776432037
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.020373612642288208,
+      "std": 0.058575961738824844
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.4399964213371277,
+      "std": 0.2834493815898895
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.7786020155188512,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.9747400974591364,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.9201636655584751,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.6448093914536868,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.934040047114252,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.7335449306681072,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.969746209879359,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.8931768841147592,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.9596029915273391,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 144.35505199432373
+}

data/experiments/tier1_gemma2_v2/per_layer/layer_09.json

@@ -0,0 +1,92 @@
+{
+  "layer": 9,
+  "drift_auroc": 0.9478720128144871,
+  "drift_C": 0.1,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.9828307119971361,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9982379131757501,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": -0.02433849684894085,
+  "cos_drift_correctness": -0.025808092206716537,
+  "cos_uncertainty_correctness": 0.021662255749106407,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.03769109770655632,
+      "std": 0.0971510037779808
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.6718498468399048,
+      "std": 0.21020126342773438
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.02007238380610943,
+      "std": 0.05859347805380821
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.44910070300102234,
+      "std": 0.28751757740974426
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.7936089378280048,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.978615622468682,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.9264690810396488,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.7253105250868114,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.9422850412249706,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.7607374392220422,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.9689145730673178,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.9109617197467501,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.9581572719954963,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 151.38029074668884
+}

data/experiments/tier1_gemma2_v2/per_layer/layer_10.json

@@ -0,0 +1,92 @@
+{
+  "layer": 10,
+  "drift_auroc": 0.9496738294032827,
+  "drift_C": 0.1,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.9843212838384111,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9980495750818347,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": -0.025705965235829353,
+  "cos_drift_correctness": -0.003326516365632415,
+  "cos_uncertainty_correctness": 0.043761368840932846,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.037546705454587936,
+      "std": 0.09729484468698502
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.6742916107177734,
+      "std": 0.21287156641483307
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.019854165613651276,
+      "std": 0.057867392897605896
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.44933104515075684,
+      "std": 0.2848002016544342
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.7984996297369523,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.9788993767469486,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.9292829894766189,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.7186141805828608,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.9452296819787986,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.7308586949996997,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.9713187082550228,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.912162192953195,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.9617783722458123,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 147.01239705085754
+}

data/experiments/tier1_gemma2_v2/per_layer/layer_11.json

@@ -0,0 +1,92 @@
+{
+  "layer": 11,
+  "drift_auroc": 0.9478580906085624,
+  "drift_C": 0.1,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.9850862714869608,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9979276801510947,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": -0.005517570301890373,
+  "cos_drift_correctness": -0.017856759950518608,
+  "cos_uncertainty_correctness": 0.03847955912351608,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.03860519826412201,
+      "std": 0.09878534823656082
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.664135754108429,
+      "std": 0.2145092636346817
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.02003399096429348,
+      "std": 0.057298652827739716
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.4452461898326874,
+      "std": 0.2879909873008728
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.8065778035352071,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.9797034787524678,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.9263910949148041,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.7518605141647647,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.9575971731448764,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.722619905156372,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.9714232593694972,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.9172479037815432,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.9616165103652458,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 151.30345034599304
+}

data/experiments/tier1_gemma2_v2/per_layer/layer_12.json

@@ -0,0 +1,92 @@
+{
+  "layer": 12,
+  "drift_auroc": 0.9473017250347686,
+  "drift_C": 0.1,
+  "drift_active_neurons": 3584,
+  "uncertainty_auroc": 0.9866268553564509,
+  "uncertainty_active_neurons": 3584,
+  "uncertainty_threshold": 0.5,
+  "correctness_auroc": 0.9980232805534291,
+  "n_correct": 14955,
+  "n_wrong": 131,
+  "cos_drift_uncertainty": -0.027162229642271996,
+  "cos_drift_correctness": -0.006445594131946564,
+  "cos_uncertainty_correctness": 0.007319244556128979,
+  "neuron_overlap_ratio": 1.0,
+  "neuron_overlap_note": "L2=all active. See sparse_neuron_analysis for L1.",
+  "cell_analysis": {
+    "A_confident_stable": {
+      "n": 8481,
+      "mean": 0.03960072249174118,
+      "std": 0.10105704516172409
+    },
+    "B_confident_drifted": {
+      "n": 954,
+      "mean": 0.6566126942634583,
+      "std": 0.21807824075222015
+    },
+    "C_uncertain_stable": {
+      "n": 5441,
+      "mean": 0.02034013159573078,
+      "std": 0.057039156556129456
+    },
+    "D_uncertain_drifted": {
+      "n": 210,
+      "mean": 0.4324892461299896,
+      "std": 0.28674644231796265
+    }
+  },
+  "per_relation": {
+    "holds_position": {
+      "auroc": 0.8117260697382401,
+      "n_drifted": 44,
+      "n_stable": 1479
+    },
+    "CEO": {
+      "auroc": 0.9780779100846232,
+      "n_drifted": 135,
+      "n_stable": 1163
+    },
+    "head_coach": {
+      "auroc": 0.9285790932775441,
+      "n_drifted": 372,
+      "n_stable": 2264
+    },
+    "works_for": {
+      "auroc": 0.7475463057118539,
+      "n_drifted": 7,
+      "n_stable": 893
+    },
+    "owned_by": {
+      "auroc": 1.0,
+      "n_drifted": 5,
+      "n_stable": 735
+    },
+    "member_of_party": {
+      "auroc": 0.9634864546525325,
+      "n_drifted": 6,
+      "n_stable": 849
+    },
+    "plays_for": {
+      "auroc": 0.7207665526142025,
+      "n_drifted": 25,
+      "n_stable": 1851
+    },
+    "head_of_state": {
+      "auroc": 0.9708467476737795,
+      "n_drifted": 223,
+      "n_stable": 1255
+    },
+    "chair_of": {
+      "auroc": 0.9255170630128197,
+      "n_drifted": 70,
+      "n_stable": 788
+    },
+    "head_of_government": {
+      "auroc": 0.9610409550531096,
+      "n_drifted": 277,
+      "n_stable": 1959
+    }
+  },
+  "elapsed_seconds": 163.91591429710388
+}