Update README.md

README.md

@@ -223,6 +223,15 @@ Currently it includes two files:
 - **sequential_additional.parquet** →  Sequential mode (non-randomized, strict per-key ordered update blocks). Trivial for humans yet still challenging for many LLMs; smaller (all <600B) models are especially affected, with proactive-interference effects clearly exposed (even in short contexts, ~5–8k tokens).
 
 
+# PI-LLM Dataset File List
+
+This repository hosts the **PI-LLM** dataset.  
+Currently it includes two files:
+
+- **core.parquet** → Main dataset (randomized updates). Recommended as the primary/SOTA comparison setting; All tested models fail to reliably retrieve the last value. 
+- **sequential_additional.parquet** →  Sequential mode (non-randomized, strict per-key ordered update blocks). Trivial for humans yet still challenging for many LLMs; smaller (all <600B) models are especially affected, with proactive-interference effects clearly exposed (even in short contexts, ~5–8k tokens).
+
+
 ## Quick Start - Evaluate Your Model
 
 ```python
@@ -344,7 +353,7 @@ def n_tokens(messages):
     """Count tokens in messages."""
     return sum([len(enc.encode(m["content"])) for m in messages])
 
-# Evaluate your model
+# Evaluate your model (Recommnd Using below AUC/weighted score )
 results = []
 for index, row in dataset.iterrows():
     messages = json.loads(row["prompt"])
@@ -393,11 +402,133 @@ if 'run_id' in results_df.columns:
     print("\n=== Experiment accuracy averaged across runs (run_id) ===")
     for _, r in exp_avg.iterrows():
         print(f"{r['experiment']}: {r['accuracy_percent']:.1f}% (averaged over runs)")
+```
+
+## 🏆 Advanced Evaluation with AUC Scoring (Highly Recommand)
+```python
+
+
+### Why AUC Scoring?
+- **Average accuracy** treats all tasks equally → poor model differentiation
+- **AUC (log base 1.5)** weighs harder tasks more → better high-end model ranking
+- **Essential for research** comparing SOTA models on difficult ranges
+
+### Complete Evaluation Function
+
+
+import math
+
+def compute_pi_auc_score(results, log_base=1.5):
+    """
+    PI-LLM AUC score (PRIMARY: 'auc_log1.5'), using log_base(n_updates) weights.
+    - For two-mode experiments (keys/value length), also returns easy/hard AUCs.
+    - For others (updates/sequential), returns a single overall AUC.
+    """
+    if not results:
+        return {'avg_accuracy': 0.0, 'auc_log1.5': 0.0, 'total_samples': 0}
+
+    def wmean(samples):
+        # weight = log_base(max(n_updates, 2)) to reflect difficulty
+        ws = [math.log(max(s.get('n_updates', 2), 2), log_base) for s in samples]
+        denom = sum(ws)
+        return (sum(s['accuracy'] * w for s, w in zip(samples, ws)) / denom) if denom else 0.0
+
+    exp = results[0].get('experiment', '')
+    avg = sum(s['accuracy'] for s in results) / len(results)
+    overall = wmean(results)
+
+    # Two-mode thresholds
+    if 'exp_keys' in exp:
+        easy_thr, hard_thr = 125, 350
+    elif 'exp_valuelength' in exp:
+        easy_thr, hard_thr = 4, 20
+    else:
+        # Single-mode path
+        return {'avg_accuracy': avg, 'auc_log1.5': overall, 'total_samples': len(results)}
+
+    easy = [s for s in results if s.get('n_updates', 0) <= easy_thr]
+    hard = [s for s in results if s.get('n_updates', 0) >= hard_thr]
+
+    return {
+        'avg_accuracy': avg,
+        'auc_log1.5': overall,                 # PRIMARY metric
+        'auc_log1.5_easy': wmean(easy) if easy else 0.0,
+        'auc_log1.5_hard': wmean(hard) if hard else 0.0,
+        'total_samples': len(results),
+    }
+
+
+### Usage Example
+
+
+from datasets import load_dataset
+
+# Load PI-LLM dataset
+dataset = load_dataset("giantfish-fly/pi-llm", "core")['test']
+
+# Run your model and collect results
+results = []
+for sample in dataset:
+    pred = your_model(sample['prompt'])  # Your model inference
+    accuracy = grade_pi_response(pred, sample['answer_formatted'])
+    results.append({
+        'accuracy': accuracy,
+        'n_updates': sample['n_updates'], 
+        'experiment': sample['experiment']
+    })
+
+# Compute AUC scores
+scores = compute_pi_auc_score(results)
+
+# Display results (format varies by experiment)
+print(f"🏆 AUC Score: {scores['auc_log1.5']:.3f}")  # PRIMARY metric
+if 'auc_log1.5_easy' in scores:
+    print(f"📊 Easy Mode: {scores['auc_log1.5_easy']:.3f}")
+    print(f"📊 Hard Mode: {scores['auc_log1.5_hard']:.3f}")
+
+
+### Output Formats
+
+**Single-Mode Experiments** (`exp_updates`, `exp_sequential`):
+
+{'avg_accuracy': 0.600, 'auc_log1.5': 0.412, 'total_samples': 100}
+
+
+**Two-Mode Experiments** (`exp_keys`, `exp_valuelength`):  
+
+{
+    'avg_accuracy': 0.600, 'auc_log1.5': 0.576,     # Overall metrics
+    'auc_log1.5_easy': 0.850, 'auc_log1.5_hard': 0.350,  # Mode breakdown
+    'total_samples': 150
+}
 
 
+### 🎯 For Model Ranking: Use `auc_log1.5` as your primary metric!
 
+### ✅ Finally, Total Score (Macro PI-AUC1.5)
 
+**Definition:** average of each test’s `auc_log1.5` (simple, clear leaderboard number).
 
+def compute_total_pi_auc(all_tests, log_base=1.5):
+    """
+    Total PI-AUC1.5 across tests = average of per-test auc_log1.5.
+    all_tests: dict {test_name -> list[results]} where each `results` list
+               is what you'd pass to compute_pi_auc_score(...).
+    """
+    if not all_tests:
+        return {"per_test_auc_log1.5": {}, "total_auc_log1.5": 0.0}
+
+    per_test = {
+        name: compute_pi_auc_score(rs, log_base)["auc_log1.5"]
+        for name, rs in all_tests.items() if rs
+    }
+    total = sum(per_test.values()) / len(per_test) if per_test else 0.0
+    return {"per_test_auc_log1.5": per_test, "total_auc_log1.5": total}
+
+```
+
+
+```
 ## References
 - 
 - PI-LLM demo site: https://sites.google.com/view/cog4llm
@@ -412,19 +543,4 @@ if 'run_id' in results_df.columns:
       primaryClass={cs.CL},
       url={https://arxiv.org/abs/2506.08184}, 
 }
-```
-
-We are an interdisciplinary group interested and probing the boundaries between human and machine intelligence.
-
-Chupei Wang*
-Bachelor, University of Virginia, Physics Department.
-
-With a foundation in physics and philosophy—including a year at the University of Chicago Divinity School—Chupei explores where logic and mind meet their limits, probing how the edges of science and the humanities intersect. Chupei is driven by a curiosity about where cognitive architectures—biological and artificial—break down, and what these failures teach us about intelligence itself. Currently seeking Lab and Research.
-
-📫 cw4bb@virginia.edu
-
-Jiaqiu Vince Sun*
-PhD Candidate, NYU Center for Neuroscience
-
-A former professional architect turned neuroscientist, Jiaqiu draws on his background in spatial design, cognitive neuroscience, and philosophy of mind to investigate how memory emerges and diverges in brains and artificial systems. His primary focus lies in the higher-level functions of the brain, such as self-monitoring and control.
-📫 vince.sun@nyu.edu
+```