--- license: mit language: - en task_categories: - question-answering tags: - llm - memory - retrieval - context interference - long-context configs: - config_name: core description: Randomized updates (keys shuffled across key–value pairs). Recommended as the primary/SOTA comparison setting. At the highest stress tier, all tested models (as of May 2025) fail to reliably recover the final value. data_files: - split: test path: core.parquet - config_name: sequential_additional description: Non-randomized – clear and strict sequential blocks; prove short context(token=5k-8k) can already have a strong context interference for most LLMs. Even with this well formatted data, many model's the performance still drop rapidly. data_files: - split: test path: sequential_additional.parquet --- --- # PI-LLM Bench: The Core Retrieval Challenge Behind MRCR - ICML 2025 Long-Context Foundation Models Workshop Accepted. A simple context interference evaluation. > **Adoption (Aug 31, 2025):** This dataset is integrated into a top-5 open-weight model company’s **internal benchmarking framework** for assessing ** tracking capacity and context interference in agents**. > **Update:Sept.6-mergerd into Moonshot/Kimi AI's internal eval tools and under review by a leading properiety model's eval team** ## TL;DR We identify a task that is **super easy for humans** but where all LLMs—from early 0.1B to the most modern 600B+ (GPT-5, Grok-4, Gemini, DeepSeek, etc.)—consistently **fail in the Same Way**. This pinpoints the **core challenge of MRCR** -Multi-round co-reference in Context Interference: Classic long-context benchmarks often test retrieving a single "needle" from a massive "haystack." MRCR raises the bar by placing many similar needles in the same context, requiring models to select the correct item (up to 8 needles), and shows that all LLMs struggle with this task. - PI-LLM paper: https://arxiv.org/abs/2506.08184 - OpenAI MRCR dataset: https://huggingface.co/datasets/openai/mrcr - DeepMind MRCR (Gemini) paper: https://arxiv.org/pdf/2409.12640v2 ## Our test takes this one step further If MRCR is "multiple needles in a haystack", we show the **haystack isn't necessary** to expose core retrieval failures. By isolating—and precisely controlling—the number of similar, co-referenced items (we repeatedly update the value of the same keys in key–value pairs), our paradigm directly measures how interference from up to 400 needles limits retrieval accuracy even without any "haystack" as background. LLMs cannot perform a simple task like "retrieving the last value" of each co-referenced item. - We observe a clear log-linear decline in accuracy as the number of interfering updates grows (i.e., co-references increase). - The effect holds across the transformer models we tested. See our paper for details and methodology. - Our demo site: https://sites.google.com/view/cog4llm - Our paper (ICML2025 Long-Context Workshop): https://arxiv.org/abs/2506.08184 - Mechanistic research is ongoing. The test is well-established in cognitive science, where it has been studied extensively to measure human **Working Memory capacity**. ## Key–value update paradigm (what the model sees) We present a classical key–value experiment: the same key is updated multiple times. The model is then asked to return the current (last) value for each key. This isolates co-reference interference without requiring extremely long distractor contexts. Minimal example (1 keys, N updates each): ``` Key1: Value_1 Key1: Value_2 ...... Key1: Value_N Question: What is the current value (the last value) for Key1? ``` Expected: ``` The current value of Key1 is Value_N. ``` ## Results: ALL tested SOTA LLMs **cannot reliably retrieve** Value_N. Distribution spans value_1 to value_N, and **as N increases**, the **answers skew** increasingly toward **value_1**. ## Note on dataset scale: (N from 1 to 400). We put up to 46 such groups (key1..key46) together and then ask the model to retrieve just the last value of each key. We make sure all values are different, so when the model replies, we know how far away the answer is from the correct answer. ## Why this is challenging for LLMs: - Multiple co-references to the same key cause strong interference. 1. As the number of updates per key (N) increases, LLMs **confuse earlier values** with the most recent one and fail to retrieve the last value. (Dataset column: exp_updates) 2. We intentionally make the task to only retrieve the last value to keep searching difficulties low and to show all LLM are unable to keep track due to **context interference**. ## On Randomization We **RANDOMIZE** update order after generation to mimic unpredictable changes by interleaving updates across different keys (i.e., different keys’ updates occur back-to-back rather than in contiguous blocks). Counterintuitively, this often helps LLMs, since the final update usually lands near the end of the context. In the sequential setting, most smaller (less than ~600B) models lose track after only a few updates—even with 5–8k-token inputs. See the **Sequntial /Original-Non-Random Mode** section at the end of this document, where many LLMs’ performance still **collapses** with only a **small amount of input (5–8k)** ## Cognitive science connection: Proactive Interference (PI) Our test adopts the **classic proactive** interference paradigm from cognitive science, a **foundational method** for studying **human working memory**. PI shows how older, similar information disrupts encoding and retrieval of newer content. Bringing this approach to LLMs allows us to directly measure how interference—not just context length—limits memory and retrieval. - Interestingly, humans are **also affected by these three dimensions**, but far less than LLMs. Humans consistently outperform even the latest and largest models on this task.” See: https://sites.google.com/view/cog4llm ## SAME Log-linear Decline of Accuracy for ALL SOTA LLMs tested(2019-2025) - Humans: near-ceiling accuracy (99%+) on this controlled task across conditions (see paper for protocol and exact numbers). - LLMs: accuracy declines approximately log-linearly with the number of updates per key and with the number of concurrent update blocks (details, plots, and model list in our paper). ## Full detail of 3 tests This dataset consists of 2 additional dimensions of evaluation to show current LLMs' limits. Including SOTA models: GPT5, Grok4, DeepSeek, Gemini 2.5PRO, Mistral, Llama4...etc - Experiment2. (Dataset column: exp_keys). LLMs's capacity to resist interference and their accuracy to retrieve the last value decrease log-linearly as the number of concurrent keys(n_keys) grows. This experiment fixes everything else and vary only n_keys. (Two sets of test are provided, one fix update to 350 and another fixed update to 125 as lower difficulty settings) - Experiment3. (Dataset column: exp_valuelength).— This causes rapid decline across LLMs (GPT-5 and Grok-4 decline similarly to GPT-2).” Retrieval accuracy also decreases log-linearly as value length grows. This experiment fixes everything else, and vary only the value_length. Two sets of tests are provided, one fix update to 20 and another fixed update per key to only 4 as low- difficulty settings (As this test is too hard, only 4 updates per key make all LLMs fail to retrieve the last value—which we intentionally designed to keep the searching difficulty low. Retrieve other order of value has even lower performance) ## One more things: Sequential / Non-Randomized Mode (Last but interesting) In a separated dataset files (Dataset column: extra_exp_updates_randomoff) This mode takes the exact format shown in this document, without randomization. We fix everything but vary only the update times just like in the above experiment, but turn randomize_mode off .(column: randomize_mode) - This separate dataset consists of 46 of following blocks in a non-randomized order: Key1: Value_1 Key1: Value_2 ...... Key1: Value_N Key2: Value_1 Key2: Value_2 ...... Key2: Value_N ....all the way to key46 block Question: What is the current value (the last value) for key1 key2....key46? **Result** - In this mode, **most Modern LLMs (all <600B) still confuse the last value with earlier value after only 50–100 updates** (fewer than 12–25k tokens, far less than any LLMs' context window). - Models quickly confuse earlier values with the most recent one. - This is the **original and most simple test** - Performance for this mode is also **reported in our paper (Figure 4).** - **Step-like failure pattern** in this sequential key–value update tests. Retrieval accuracy remains near-perfect as interfering information is added in strictly sequential order, until a model-specific threshold is reached—after which **performance drops rapidly to near-zero**. - # 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). 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 ## Quick Start - Evaluate Your Model ```python from huggingface_hub import hf_hub_download import pandas as pd from openai import OpenAI import json import tiktoken # Set accordingly MAX_CONTEXT_WINDOW = 1000000 MODEL = "" # or your preferred model # Download the dataset dataset = pd.read_parquet( hf_hub_download(repo_id="giantfish-fly/pi-llm", filename="core.parquet", repo_type="dataset") ) client = OpenAI() enc = tiktoken.get_encoding("o200k_base") def extract_pieces_response_to_dict(model_output, probe_target="current"): """ Extract the dictionary of key-value pairs from the model output. First extract using verbal language match, then using colon match. Merge the two dictionaries, prioritizing keys from the verbal match. """ import re if len(model_output) == 0: return None if "error code" in model_output.lower(): return None if model_output.startswith("error") or model_output.startswith("Error"): return None if (re.search(r'\berror\b', model_output, re.IGNORECASE)) and (len(model_output) < 680): return None # Remove backslashes and asterisks model_output = re.sub(r'\\(?!n)', '', model_output) model_output = re.sub(r'\*', '', model_output) dict_verbal_match = _extract_verbal_matches(model_output, probe_target) dict_colon_match = _extract_colon_matches(model_output) dict_merged = dict_colon_match.copy() dict_merged.update(dict_verbal_match) dict_merged.pop("key", None) return dict_merged def _extract_verbal_matches(model_output, probe_target="current"): """Extract key-value pairs using verbal patterns like 'The current value of X is Y'""" import re patterns = [ r"(?:the)?\s*(?:most recent|final|last|latest|current|up-to-date|asked|queried|specified)\s+(?:value|word|term)?(?:s)?(?:\s+\w+){0,1}\s+(?:with|for|of|to)?\s+(?:the )?(?:category|key)?\s*([\"'\[\<]?\w+(?:\s+\w+)?[\"'\]\>]?)\s+(?:is|was)(?:\s*:\s*)?\s+([\"'\[\<]?\w+(?:\s+\w+)?[\"'\]\>]?)(?=\n|[,.;:]|$)", ] dict_response = {} for pattern in patterns: matches = re.findall(pattern, model_output, re.IGNORECASE | re.DOTALL) for match in matches: if len(match) >= 2: key, value = match[0], match[1] key = re.sub(r'[\*\'"""''\[\]\{\}\(\)\<\>]', '', key).strip() value = re.sub(r'[\*\'"""''\[\]\{\}\(\)\<\>]', '', value).strip() if key and value: dict_response[key] = value return dict_response def _extract_colon_matches(model_output): """Extract key-value pairs using colon-separated patterns""" import re # Simple colon-based extraction dict_response = {} lines = model_output.split('\n') for line in lines: if ':' in line: parts = line.split(':', 1) if len(parts) == 2: key = re.sub(r'[\*\'"""''\[\]\{\}\(\)\<\>]', '', parts[0]).strip() value = re.sub(r'[\*\'"""''\[\]\{\}\(\)\<\>]', '', parts[1]).strip() if key and value: dict_response[key] = value return dict_response def grade_pi_response(response, answer_formatted): """ Compute per-row accuracy for PI-LLM: fraction of tracked keys answered with the last value. - Parses the ground truth JSON string (answer_formatted) into {key: last_value}. - Parses model output into {key: value} using robust extractors. - Returns (# of keys with exact value match) / (# of keys in ground truth). """ try: # Parse ground truth JSON ground_truth = json.loads(answer_formatted) # Extract key-value pairs from model response using parsing functions response_dict = extract_pieces_response_to_dict(response, probe_target="current") if not isinstance(ground_truth, dict) or ground_truth is None: return 0.0 if not isinstance(response_dict, dict) or response_dict is None: return 0.0 keys = list(ground_truth.keys()) if len(keys) == 0: return 0.0 correct = sum(1 for k in keys if response_dict.get(k) == ground_truth.get(k)) return correct / len(keys) except Exception as e: return 0.0 def n_tokens(messages): """Count tokens in messages.""" return sum([len(enc.encode(m["content"])) for m in messages]) # Evaluate your model (Recommnd Using below AUC/weighted score ) results = [] for index, row in dataset.iterrows(): messages = json.loads(row["prompt"]) if n_tokens(messages) > MAX_CONTEXT_WINDOW: continue completion = client.chat.completions.create( model=MODEL, messages=messages, ) response = completion.choices[0].message.content accuracy = grade_pi_response(response, row["answer_formatted"]) parsed = extract_pieces_response_to_dict(response, probe_target="current") # Store result with experiment info and raw/parsed responses (useful for axes + error analysis) results.append({ 'experiment': row['experiment'], 'session_id': row['session_id'], 'run_id': row.get('run_id', None), 'accuracy': accuracy, 'index': index, 'response_text': response, 'parsed_response': parsed, }) print(f"Row {index} ({row['experiment']}, session {row['session_id']}): {accuracy}") # Calculate accuracy by experiment import pandas as pd results_df = pd.DataFrame(results) # Group by experiment and calculate mean accuracy experiment_accuracy = results_df.groupby('experiment')['accuracy'].agg(['mean', 'count']).reset_index() experiment_accuracy['accuracy_percent'] = experiment_accuracy['mean'] * 100 print("\n=== Accuracy by Experiment ===") for _, row in experiment_accuracy.iterrows(): print(f"{row['experiment']}: {row['accuracy_percent']:.1f}% ({row['count']} samples)") # Average across runs (e.g., 10 sessions via run_id) if 'run_id' in results_df.columns: # Mean accuracy per experiment per run, then average across runs per_run = results_df.groupby(['experiment', 'run_id'])['accuracy'].mean().reset_index() exp_avg = per_run.groupby('experiment')['accuracy'].mean().reset_index() exp_avg['accuracy_percent'] = 100 * exp_avg['accuracy'] 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 - PI-LLM paper: https://arxiv.org/abs/2506.08184 @misc{wang2025unableforgetproactiveinterference, title={Unable to Forget: Proactive Interference Reveals Working Memory Limits in LLMs Beyond Context Length}, author={Chupei Wang and Jiaqiu Vince Sun}, year={2025}, eprint={2506.08184}, archivePrefix={arXiv}, primaryClass={cs.CL}, url={https://arxiv.org/abs/2506.08184}, } ```