Update README.md

README.md

@@ -1,3 +1,248 @@
----
-license: mit
----
+---
+license: mit
+language:
+- en
+---
+# PI-LLM: The Core Retrieval Challenge Behind MRCR
+Multi-round co-reference interference in long context
+
+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.
+
+- 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 of up to 400 needles limits retrieval accuracy even without any "haystack" as background. And 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 (ICML Long-Context Workshop): https://arxiv.org/abs/2506.08184
+
+## 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. 
+
+
+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.
+
+results: 
+LLMs cannot reliably retrieve Value_N. Distribution spans value_1 to value_N, and as N increases, the answers skew increasingly toward value_1. 
+
+
+## Why this is challenging for LLMs
+- Multiple co-references to the same key cause strong interference.
+
+As N gets larger, LLMs increasingly confuse earlier values with the most recent one, and cannot retrieve the last value. 
+
+## 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.
+
+See: https://sites.google.com/view/cog4llm 
+
+## Results at a glance
+- Humans: near-ceiling accuracy 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).
+
+## 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
+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)")
+
+
+
+
+
+
+
+## References
+- 
+- PI-LLM demo site: https://sites.google.com/view/cog4llm
+- PI-LLM paper: https://arxiv.org/abs/2506.08184