OSCR

Hippocampo-neocortical interaction as compressive retrieval-augmented generation.

Code ↔ Paper

29 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 29 matches
  1. [1] § Methods › Neocortical learning of sequential structure for inference and planning ↔ inference/rag_composition.py, lines 1–53 · score 0.89 · ef WEST gh, ab EAST cd, gh NORTH, SOUTH ef, inference, traces
  2. [2] § Results › Inference from memory as retrieval-augmented generation ↔ inference/rag_composition.py, lines 1–53 · score 0.84 · ef WEST gh, ab EAST cd, gh NORTH, SOUTH ef, inference, baselines
  3. [3] § Methods › Modelling hippocampal-neocortical interaction as retrieval-augmented generation › The compression and encoding of episodic memory ↔ full_model/memory_simulation.py, lines 1126–1165 · score 0.81 · sentence boundaries, coordinating conjunction, spaCy, commas, splitting, phrases
  4. [4] § Methods › Modelling hippocampal-neocortical interaction as retrieval-augmented generation › The compression and encoding of episodic memory ↔ full_model/narratives/utils.py, lines 455–491 · score 0.69 · short clause, spaCy, conjunctions, splitting, phrases, perplexity
  5. [5] § Results › Modelling consolidation and forgetting ↔ full_model/semantic_memory_standalone.py, lines 83–189 · score 0.66 · asking factual questions, correct answer, Semantic memory, Remember, embedding, prompt
  6. [6] § Methods › Modelling hippocampal-neocortical interaction as retrieval-augmented generation › Modelling the hippocampus ↔ scripts/dual_mhn.py, lines 1–19 · score 0.65 · modern Hopfield network, sequence memory, MHN, heteroassociative, autoassociative, vector
  7. [7] § Methods › Modelling hippocampal-neocortical interaction as retrieval-augmented generation › Analysing the HIPPOCORPUS and NFRD datasets ↔ full_model/collate_all_figures.py, lines 281–314 · score 0.65 · Naturalistic Free Recall, baseball, eyespy, oregontrail, pieman, recalled stories
  8. [8] § Results › Inspecting the hidden representations supporting inference ↔ inference/plot_family_reps.py, lines 449–483 · score 0.65 · Pearson correlation, pre trained GPT, family tree, random walk, location, nodes
  9. [9] § Results › Gist-based distortions and prior experience ↔ full_model/narratives/collate_figures.py, lines 2324–2364 · score 0.64 · L6 v2, MiniLM, cosine distance, Bergman, Roediger, PCA
  10. [10] § Results › The compression and encoding of episodic memory ↔ full_model/semantic_memory_standalone.py, lines 83–189 · score 0.63 · L6 v2, MiniLM, correct answer, Semantic memory, accuracy, embeddings
  11. [11] § Results › Neocortical learning of sequential structure for problem solving ↔ inference/graph_sequence_model.py, lines 737–884 · score 0.63 · trained spatial model, ab EAST, aggregated, child, loss, graphs
  12. [12] § Results › Gist-based distortions and prior experience ↔ full_model/narratives/utils.py, lines 27–51 · score 0.61 · young men, Ghosts, War, heard, Egulac, night
  13. [13] § Methods › Modelling hippocampal-neocortical interaction as retrieval-augmented generation › The compression and encoding of episodic memory ↔ full_model/narratives/utils.py, lines 289–299 · score 0.61 · XRAG_TOKEN, single token, phrases, perplexity, surprising
  14. [14] § Methods › Summary of models trained ↔ full_model/narratives/stories.py, lines 28–77 · score 0.61 · ROC Stories, LoRA, xRAG, v0, Instruct, Mistral
  15. [15] § Results › Modelling consolidation and forgetting ↔ full_model/memory_simulation.py, lines 176–297 · score 0.60 · asking factual questions, correct answer, Semantic memory, Remember, embedding, prompt
  16. [16] § Methods › Summary of models trained ↔ full_model/narratives/stories.py, lines 28–77 · score 0.60 · ROC Stories, LoRA, xRAG, v0, Instruct, Mistral
  17. [17] § Results › Neocortical learning of sequential structure for problem solving ↔ inference/plot_family_reps.py, lines 63–126 · score 0.58 · directed graph, family tree, children, grandchild, spouse, sibling
  18. [18] § Results › Event extension and contraction ↔ full_model/narratives/collate_figures.py, lines 1187–1291 · score 0.58 · omission errors, extension errors, updated stories, incomplete
  19. [19] § Results › Neocortical learning of sequential structure for problem solving ↔ inference/graph_sequence_model.py, lines 737–884 · score 0.58 · EAST zr, sz WEST, invalid, aggregated, entity, losses
  20. [20] § Results ↔ scripts/dual_mhn.py, lines 1–19 · score 0.57 · modern Hopfield network, nearest stored, MHN, sequence, memory
  21. [21] § Results › The compression and encoding of episodic memory ↔ full_model/narratives/bartlett_twostage.py, lines 377–436 · score 0.54 · L6 v2, MiniLM, original story, cosine, background, tokens
  22. [22] § Results › Changes in memory content over time ↔ full_model/LLM ratings/HIPPOCORPUS attributes comparison.ipynb, lines 1–52 · score 0.54 · OpenAI API, mini, rich, concrete, metrics, abstract
  23. [23] § Methods › Modelling hippocampal-neocortical interaction as retrieval-augmented generation › Modelling the hippocampus ↔ scripts/dual_mhn.py, lines 22–36 · score 0.53 · inverse temperature, softmax, MHN, heteroassociatively, autoassociative, Retrieval
  24. [24] § Results › Inspecting the hidden representations supporting inference ↔ inference/plot_family_reps.py, lines 486–519 · score 0.53 · family tree, pre trained, random walk, hidden, location, medium
  25. [25] § Methods › Summary of models trained ↔ inference/plot_family_reps.py, lines 449–483 · score 0.53 · train GPT, family trees, random walks, medium, graphs, inference
  26. [26] § Methods › Modelling hippocampal-neocortical interaction as retrieval-augmented generation › Analysing the HIPPOCORPUS and NFRD datasets ↔ full_model/LLM ratings/HIPPOCORPUS attributes comparison.ipynb, lines 1–52 · score 0.52 · OpenAI API, attributes, mini, HIPPOCORPUS, gpt, prompt
  27. [27] § Methods › Modelling hippocampal-neocortical interaction as retrieval-augmented generation › Analysing the HIPPOCORPUS and NFRD datasets ↔ full_model/LLM ratings/llm_specificity_analysis.py, lines 98–150 · score 0.51 · baseball, eyespy, oregontrail, pieman, recalled stories, NFRD
  28. [28] § Results › Changes in memory content over time ↔ full_model/LLM ratings/llm_specificity_analysis.py, lines 52–80 · score 0.50 · OpenAI API, mini, rich, concrete, abstract, gpt
  29. [29] § Methods › Summary of models trained ↔ full_model/narratives/bartlett_encoding_vs_consolidation.py, lines 47–87 · score 0.50 · LoRA, xRAG, v0, Instruct, Bartlett, Mistral

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 553 lines · 22 KB · MIT · 4 matches

  1. """
  2. Analogous to plot_reps.py but for the family tree model.
  4. Instead of spatial positions on a 3x3 grid, each person in the family tree
  5. has a *generation* (grandparent=0, parent=1, child=2). We ask whether
  6. the model's latent representations capture this generational structure.
  8. Graphs are created in code (so generation assignments are known), then
  9. random walks are sampled from them and fed to the model.
  10. """
  12. import random
  13. import string
  14. import time
  16. import numpy as np
  17. import torch
  18. import logging
  19. import networkx as nx
  20. from transformers import GPT2LMHeadModel, GPT2TokenizerFast
  21. from sklearn.decomposition import PCA
  22. from umap import UMAP
  23. import matplotlib.pyplot as plt
  24. from scipy.stats import pearsonr
  27. def set_seed(seed):
  28. random.seed(seed)
  29. np.random.seed(seed)
  30. torch.manual_seed(seed)
  31. if torch.cuda.is_available():
  32. torch.cuda.manual_seed_all(seed)
  33. torch.backends.cudnn.deterministic = True
  34. torch.backends.cudnn.benchmark = False
  36. set_seed(321)
  38. logging.basicConfig(level=logging.DEBUG,
  39. format='%(asctime)s - %(levelname)s - %(message)s')
  42. # ---------------------------------------------------------------------------
  43. # Family tree construction (with collision-free names)
  44. # ---------------------------------------------------------------------------
  46. _GENERATION_OFFSETS = {
  47. "PARENT_OF": 1, "CHILD_OF": -1,
  48. "GRANDPARENT_OF": 2, "GRANDCHILD_OF": -2,
  49. "SPOUSE_OF": 0, "SIBLING_OF": 0,
  50. }
  52. GENERATION_LABELS = {0: "Grandparent", 1: "Parent", 2: "Child"}
  55. def _generate_unique_names(n):
  56. """Generate n unique 2-letter lowercase names."""
  57. names = set()
  58. while len(names) < n:
  59. names.add("".join(random.choices(string.ascii_lowercase, k=2)))
  60. return list(names)
  63. def build_family_tree():
  64. """Build a random extended family tree with guaranteed unique names.
  66. Structure (10 people, 3 generations):
  67. Gen 0: GP1a, GP1b, GP2a, GP2b (4 grandparents)
  68. Gen 1: Parent1, Aunt/Uncle1, Parent2, Aunt/Uncle2 (4 parents-level)
  69. Gen 2: Child1, Child2 (2 children)
  71. Returns (G, node_names, generation_map)
  72. """
  73. names = _generate_unique_names(10)
  75. gp1a, gp1b = names[0], names[1]
  76. parent1, uncle1 = names[2], names[3]
  77. gp2a, gp2b = names[4], names[5]
  78. parent2, aunt2 = names[6], names[7]
  79. child1, child2 = names[8], names[9]
  81. # Build all relationships
  82. relationships = {
  83. # Grandparent family 1
  84. gp1a: {"SPOUSE_OF": [gp1b], "PARENT_OF": [parent1, uncle1]},
  85. gp1b: {"SPOUSE_OF": [gp1a], "PARENT_OF": [parent1, uncle1]},
  86. uncle1: {"CHILD_OF": [gp1a, gp1b], "SIBLING_OF": [parent1]},
  87. # Grandparent family 2
  88. gp2a: {"SPOUSE_OF": [gp2b], "PARENT_OF": [parent2, aunt2]},
  89. gp2b: {"SPOUSE_OF": [gp2a], "PARENT_OF": [parent2, aunt2]},
  90. aunt2: {"CHILD_OF": [gp2a, gp2b], "SIBLING_OF": [parent2]},
  91. # Base family
  92. parent1: {
  93. "SPOUSE_OF": [parent2], "PARENT_OF": [child1, child2],
  94. "CHILD_OF": [gp1a, gp1b], "SIBLING_OF": [uncle1],
  95. },
  96. parent2: {
  97. "SPOUSE_OF": [parent1], "PARENT_OF": [child1, child2],
  98. "CHILD_OF": [gp2a, gp2b], "SIBLING_OF": [aunt2],
  99. },
  100. child1: {"CHILD_OF": [parent1, parent2], "SIBLING_OF": [child2]},
  101. child2: {"CHILD_OF": [parent1, parent2], "SIBLING_OF": [child1]},
  102. }
  104. # Add grandparent <-> grandchild edges
  105. for gp in [gp1a, gp1b, gp2a, gp2b]:
  106. relationships[gp].setdefault("GRANDPARENT_OF", []).extend([child1, child2])
  107. for ch in [child1, child2]:
  108. relationships[ch].setdefault("GRANDCHILD_OF", []).extend([gp1a, gp1b, gp2a, gp2b])
  110. # Build directed graph
  111. G = nx.DiGraph()
  112. for person, rels in relationships.items():
  113. G.add_node(person)
  114. for rel_type, targets in rels.items():
  115. for target in targets:
  116. G.add_edge(person, target, relationship=rel_type)
  118. node_names = list(G.nodes)
  120. generation_map = {
  121. gp1a: 0, gp1b: 0, gp2a: 0, gp2b: 0,
  122. parent1: 1, uncle1: 1, parent2: 1, aunt2: 1,
  123. child1: 2, child2: 2,
  124. }
  126. return G, node_names, generation_map
  129. # ---------------------------------------------------------------------------
  130. # Random walk generation
  131. # ---------------------------------------------------------------------------
  133. def generate_random_walk(G, walk_length=50):
  134. """Return a walk string: node REL node REL … node"""
  135. current = random.choice(list(G.nodes))
  136. tokens = [current]
  137. for _ in range(walk_length):
  138. neighbors = list(G.successors(current))
  139. if not neighbors:
  140. break
  141. nxt = random.choice(neighbors)
  142. rel = G.edges[current, nxt]["relationship"]
  143. tokens.append(rel)
  144. tokens.append(nxt)
  145. current = nxt
  146. return " ".join(tokens)
  149. # ---------------------------------------------------------------------------
  150. # GPT wrapper & embedding extraction
  151. # ---------------------------------------------------------------------------
  153. def _default_entity_tokenizer_dir():
  154. """Return the canonical entity tokenizer path if it exists, else None."""
  155. from pathlib import Path
  156. path = Path(__file__).resolve().parent / "tokenizers" / "gpt2-medium_2letter_entities"
  157. if (path / "tokenizer.json").exists() or (path / "vocab.json").exists():
  158. return str(path)
  159. return None
  162. class GPTWrapper:
  163. def __init__(self, model_name="gpt2", tokenizer_name=None):
  164. logging.info(f"Loading model: {model_name}")
  165. self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  166. self.model = GPT2LMHeadModel.from_pretrained(
  167. model_name, output_hidden_states=True
  168. )
  169. self.model.to(self.device)
  170. self.model.eval()
  171. emb_size = self.model.get_input_embeddings().weight.shape[0]
  173. # Resolve tokenizer: explicit > canonical entity tokenizer > model dir
  174. tok_path = tokenizer_name or model_name
  175. if tokenizer_name is None and not model_name.startswith("gpt2"):
  176. canon = _default_entity_tokenizer_dir()
  177. if canon is not None:
  178. candidate = GPT2TokenizerFast.from_pretrained(canon)
  179. if len(candidate) == emb_size:
  180. tok_path = canon
  181. logging.info(f"Using canonical entity tokenizer from {canon}")
  183. self.tokenizer = GPT2TokenizerFast.from_pretrained(tok_path)
  184. self.tokenizer.pad_token = self.tokenizer.eos_token
  185. logging.info(f"Model and tokenizer loaded successfully (vocab={len(self.tokenizer)}, emb={emb_size}).")
  187. def get_hidden_states_with_offsets(self, prompt, layer_idx):
  188. enc = self.tokenizer(
  189. prompt, return_tensors="pt", truncation=True,
  190. return_offsets_mapping=True,
  191. )
  192. offsets = enc["offset_mapping"][0].tolist()
  193. # Remove offset_mapping before passing to model (it's not a model input)
  194. model_inputs = {k: v.to(self.device) for k, v in enc.items() if k != "offset_mapping"}
  195. with torch.no_grad():
  196. out = self.model(**model_inputs)
  197. hidden_states = out.hidden_states[layer_idx].squeeze(0).detach().cpu().numpy()
  198. return hidden_states, offsets
  200. def get_all_hidden_states_with_offsets(self, prompt):
  201. """Single forward pass returning hidden states for *every* layer.
  203. Returns ``(all_hidden_states, offsets)`` where
  204. ``all_hidden_states[i]`` is the numpy array for layer *i*.
  205. """
  206. enc = self.tokenizer(
  207. prompt, return_tensors="pt", truncation=True,
  208. return_offsets_mapping=True,
  209. )
  210. offsets = enc["offset_mapping"][0].tolist()
  211. model_inputs = {k: v.to(self.device) for k, v in enc.items() if k != "offset_mapping"}
  212. with torch.no_grad():
  213. out = self.model(**model_inputs)
  214. all_hs = [h.squeeze(0).detach().cpu().numpy() for h in out.hidden_states]
  215. return all_hs, offsets
  218. def substring_positions(haystack, needle):
  219. result = []
  220. start = 0
  221. while True:
  222. idx = haystack.find(needle, start)
  223. if idx == -1:
  224. break
  225. result.append([idx, idx + len(needle)])
  226. start = idx + 1
  227. return result
  230. def gather_embeddings_for_span(offsets, hidden_states, span, flanking=True):
  231. """Gather hidden-state vectors for a character span.
  233. If *flanking* is True (default), the tokens immediately before and after
  234. the entity token(s) are included in the average. For the custom entity
  235. tokenizer these flanking tokens are the space characters that sit between
  236. the entity and the neighbouring relation token, and they carry rich
  237. contextual information about the entity's role in the family tree.
  238. """
  239. start_needed, end_needed = span
  240. n_tokens = len(offsets)
  241. entity_idxs = [i for i, (s, e) in enumerate(offsets)
  242. if not (e <= start_needed or s >= end_needed)]
  243. if not entity_idxs:
  244. return None
  246. if flanking:
  247. all_idxs = set(entity_idxs)
  248. min_idx, max_idx = min(entity_idxs), max(entity_idxs)
  249. if min_idx > 0:
  250. all_idxs.add(min_idx - 1)
  251. if max_idx < n_tokens - 1:
  252. all_idxs.add(max_idx + 1)
  253. vecs = [hidden_states[i] for i in sorted(all_idxs)]
  254. else:
  255. vecs = [hidden_states[i] for i in entity_idxs]
  257. return np.mean(vecs, axis=0)
  260. def average_locations_via_substring(prompt, offsets, hidden_states, locs,
  261. flanking=True, second_half_only=False):
  262. """Average entity representations across all occurrences in the prompt.
  264. When *flanking* is True the representation for each occurrence includes
  265. the entity token and its immediately adjacent tokens (typically spaces).
  267. When *second_half_only* is True, only occurrences whose character start
  268. position is in the second half of the prompt string are used.
  269. """
  270. half = len(prompt) // 2 if second_half_only else 0
  271. loc_means = {}
  272. for loc in locs:
  273. pos_list = substring_positions(prompt, loc)
  274. if not pos_list:
  275. continue
  276. if second_half_only:
  277. pos_list = [(s, e) for s, e in pos_list if s >= half]
  278. if not pos_list:
  279. continue
  280. vecs = [v for s, e in pos_list
  281. for v in [gather_embeddings_for_span(offsets, hidden_states,
  282. (s, e), flanking=flanking)]
  283. if v is not None]
  284. if vecs:
  285. loc_means[loc] = np.mean(vecs, axis=0)
  286. return loc_means
  289. # ---------------------------------------------------------------------------
  290. # Distance & correlation helpers
  291. # ---------------------------------------------------------------------------
  293. def calc_pearson_correlation(node_names, loc_mean_repr, generation_map):
  294. rec = [n for n in node_names if n in loc_mean_repr and n in generation_map]
  295. if len(rec) < 2:
  296. return float("nan")
  297. gen_d, rep_d = [], []
  298. for i in range(len(rec)):
  299. for j in range(i + 1, len(rec)):
  300. gen_d.append(abs(generation_map[rec[i]] - generation_map[rec[j]]))
  301. rep_d.append(np.linalg.norm(loc_mean_repr[rec[i]] - loc_mean_repr[rec[j]]))
  302. if len(gen_d) < 2:
  303. return float("nan")
  304. r, _ = pearsonr(gen_d, rep_d)
  305. return r
  308. def gather_boxplot_data(node_names, loc_mean_repr, generation_map):
  309. rec = [n for n in node_names if n in loc_mean_repr and n in generation_map]
  310. dist_map = {}
  311. for i in range(len(rec)):
  312. for j in range(i + 1, len(rec)):
  313. gd = abs(generation_map[rec[i]] - generation_map[rec[j]])
  314. rd = np.linalg.norm(loc_mean_repr[rec[i]] - loc_mean_repr[rec[j]])
  315. dist_map.setdefault(gd, []).append(rd)
  316. return dist_map
  319. def merge_dist_map(gmap, dmap):
  320. for d, lst in dmap.items():
  321. gmap.setdefault(d, []).extend(lst)
  324. # ---------------------------------------------------------------------------
  325. # Plotting
  326. # ---------------------------------------------------------------------------
  328. def plot_all_runs_in_one_pca(all_points, all_edges, model_name, reducer="pca"):
  329. if not all_points:
  330. return
  331. X = np.array([p["vector"] for p in all_points])
  332. X_c = X - X.mean(axis=0, keepdims=True)
  333. dim_red = PCA(n_components=2) if reducer == "pca" else UMAP(n_components=2)
  334. X_2d = dim_red.fit_transform(X_c)
  335. for i, c in enumerate(X_2d):
  336. all_points[i]["x2d"], all_points[i]["y2d"] = c[0], c[1]
  338. gens = sorted(set(p["generation"] for p in all_points))
  339. cmap = plt.get_cmap("tab10")
  340. plt.figure(figsize=(3, 3))
  341. for gi, g in enumerate(gens):
  342. pts = [p for p in all_points if p["generation"] == g]
  343. plt.scatter([p["x2d"] for p in pts], [p["y2d"] for p in pts],
  344. color=cmap(gi % 10), label=GENERATION_LABELS.get(g, f"Gen {g}"))
  345. for e in all_edges:
  346. i_, j_ = e["u_index"], e["v_index"]
  347. plt.plot([all_points[i_]["x2d"], all_points[j_]["x2d"]],
  348. [all_points[i_]["y2d"], all_points[j_]["y2d"]],
  349. "--", color=cmap(gens.index(all_points[i_]["generation"]) % 10), alpha=0.0)
  350. if model_name == "gpt2-medium":
  351. plt.legend()
  352. plt.savefig(f"{model_name}_family_combined_{reducer}.png", dpi=200, bbox_inches="tight")
  353. logging.info(f"Saved {model_name}_family_combined_{reducer}.png")
  356. def boxplot_of_dist_map(gmap, model_name):
  357. if not gmap:
  358. return
  359. keys = sorted(gmap.keys())
  360. tick = {0: "Same gen.", 1: "1 gen.", 2: "2 gen."}
  361. plt.figure(figsize=(3, 2))
  362. plt.boxplot([gmap[k] for k in keys], showfliers=False, showmeans=False)
  363. plt.xticks(range(1, len(keys) + 1), [tick.get(k, f"{k} gen.") for k in keys])
  364. plt.xlabel("Generational distance")
  365. plt.ylabel("Distance between rep.s")
  366. plt.savefig(f"{model_name}_family_boxplot.png", dpi=200, bbox_inches="tight")
  367. logging.info(f"Saved {model_name}_family_boxplot.png")
  370. def plot_embeddings_with_graph_edges(
  371. mean_repr, G, generation_map, model_name="gpt2", reducer="pca", title="",
  372. ):
  373. keys = sorted(mean_repr.keys())
  374. if len(keys) < 2:
  375. return
  376. X = np.array([mean_repr[k] for k in keys])
  377. X_c = X - X.mean(axis=0, keepdims=True)
  378. dim_red = PCA(n_components=2) if reducer == "pca" else UMAP(n_components=2)
  379. X_2d = dim_red.fit_transform(X_c)
  380. loc_idx = {k: i for i, k in enumerate(keys)}
  381. gens = sorted(set(generation_map.get(k, -1) for k in keys))
  382. cmap = plt.get_cmap("tab10")
  383. plt.figure(figsize=(3, 3))
  384. for gi, g in enumerate(gens):
  385. gk = [k for k in keys if generation_map.get(k, -1) == g]
  386. ix = [loc_idx[k] for k in gk]
  387. plt.scatter(X_2d[ix, 0], X_2d[ix, 1], color=cmap(gi % 10),
  388. label=GENERATION_LABELS.get(g, f"Gen {g}"))
  389. for i, k in zip(ix, gk):
  390. plt.annotate(k, (X_2d[i, 0], X_2d[i, 1]), xytext=(3, 3), textcoords="offset points")
  391. for u, v in G.edges():
  392. if u in loc_idx and v in loc_idx:
  393. i, j = loc_idx[u], loc_idx[v]
  394. plt.plot([X_2d[i, 0], X_2d[j, 0]], [X_2d[i, 1], X_2d[j, 1]], "k--", alpha=0.3)
  395. plt.title(title + f" ({reducer.upper()})")
  396. plt.legend()
  397. ts = str(int(time.time()))
  398. plt.savefig(f"{model_name}_family_single_{reducer}_{ts}.png", dpi=200, bbox_inches="tight")
  399. logging.info(f"Saved {model_name}_family_single_{reducer}_{ts}.png")
  402. # ---------------------------------------------------------------------------
  403. # Analysis functions
  404. # ---------------------------------------------------------------------------
  406. def multi_tree_allinone(model_name="gpt2", layer_idx=10, n_runs=300,
  407. walk_length=50, reducer="pca"):
  408. logging.info(f"multi_tree_allinone: {model_name}, {n_runs} runs")
  409. wrapper = GPTWrapper(model_name)
  410. all_points, all_edges, global_dist = [], [], {}
  411. pt_idx = 0
  413. for run in range(n_runs):
  414. logging.info(f"=== RUN {run+1}/{n_runs} ===")
  415. G, node_names, gen_map = build_family_tree()
  416. prompt = generate_random_walk(G, walk_length)
  417. hs, off = wrapper.get_hidden_states_with_offsets(prompt, layer_idx)
  418. loc_repr = average_locations_via_substring(prompt, off, hs, node_names)
  420. node_pt = {}
  421. for n in (n for n in node_names if n in loc_repr):
  422. all_points.append({"run_idx": run, "node_name": n,
  423. "vector": loc_repr[n], "generation": gen_map[n]})
  424. node_pt[n] = pt_idx; pt_idx += 1
  425. for u, v in G.edges():
  426. if u in node_pt and v in node_pt:
  427. all_edges.append({"u_index": node_pt[u], "v_index": node_pt[v]})
  428. merge_dist_map(global_dist, gather_boxplot_data(node_names, loc_repr, gen_map))
  430. plot_all_runs_in_one_pca(all_points, all_edges, model_name, reducer)
  431. boxplot_of_dist_map(global_dist, model_name)
  434. def single_tree_with_edge_lines(model_name="gpt2", layer_idx=10,
  435. walk_length=100000, reducer="pca"):
  436. G, node_names, gen_map = build_family_tree()
  437. prompt = generate_random_walk(G, walk_length)
  438. wrapper = GPTWrapper(model_name)
  439. hs, off = wrapper.get_hidden_states_with_offsets(prompt, layer_idx)
  440. loc_repr = average_locations_via_substring(prompt, off, hs, node_names)
  441. plot_embeddings_with_graph_edges(loc_repr, G, gen_map, model_name, reducer,
  442. title=f"{model_name} L{layer_idx}")
  445. def rolling_mean(vals, w=3):
  446. return [np.mean(vals[max(0, i - w + 1):i + 1]) for i in range(len(vals))]
  449. def correlation_vs_context_length_multi(models, layer_idx=12, context_lengths=None,
  450. n_runs=100, rolling_window=1):
  451. if context_lengths is None:
  452. context_lengths = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]
  453. labels = {"outputs_tree": "Our model", "gpt2-medium": "Pre-trained GPT-2"}
  455. # Pre-build graphs so both models see the same data
  456. runs = [(build_family_tree(), ) for _ in range(n_runs)]
  458. plt.figure(figsize=(3, 2))
  459. for model_name in models:
  460. wrapper = GPTWrapper(model_name)
  461. avg_corrs = []
  462. for L in context_lengths:
  463. corrs = []
  464. for (G, node_names, gen_map), in runs:
  465. prompt = generate_random_walk(G, L)
  466. hs, off = wrapper.get_hidden_states_with_offsets(prompt, layer_idx)
  467. loc_repr = average_locations_via_substring(prompt, off, hs, node_names)
  468. c = calc_pearson_correlation(node_names, loc_repr, gen_map)
  469. if not np.isnan(c):
  470. corrs.append(c)
  471. m = np.mean(corrs) if corrs else float("nan")
  472. avg_corrs.append(m)
  473. logging.info(f"[{model_name}] ctx={L}, r={m:.3f}")
  474. if rolling_window > 1:
  475. plt.plot(context_lengths, rolling_mean(avg_corrs, rolling_window),
  476. "o-", label=f"{model_name} (rolled)")
  477. color = "blue" if model_name == "gpt2-medium" else "red"
  478. plt.plot(context_lengths, avg_corrs, "o--",
  479. label=labels.get(model_name, model_name), color=color)
  481. plt.xlabel("Context length"); plt.ylabel("Pearson correlation")
  482. plt.title("Family: Correlation vs context length"); plt.legend()
  483. plt.savefig("comparison_family_correlation_vs_context_length.png", dpi=200, bbox_inches="tight")
  486. def correlation_vs_layer_multi(models, layer_indices=None, n_runs=100, walk_length=50):
  487. if layer_indices is None:
  488. layer_indices = list(range(24))
  489. labels = {"outputs_tree": "Our model", "gpt2-medium": "Pre-trained GPT-2"}
  491. # Pre-build graphs + walks so both models see identical data
  492. runs = []
  493. for _ in range(n_runs):
  494. G, names, gm = build_family_tree()
  495. prompt = generate_random_walk(G, walk_length)
  496. runs.append((prompt, G, names, gm))
  498. plt.figure(figsize=(3, 2))
  499. for model_name in models:
  500. wrapper = GPTWrapper(model_name)
  501. avg = {}
  502. for layer_idx in layer_indices:
  503. corrs = []
  504. logging.info(f" Layer {layer_idx} for {model_name}...")
  505. for prompt, G, names, gm in runs:
  506. hs, off = wrapper.get_hidden_states_with_offsets(prompt, layer_idx)
  507. loc_repr = average_locations_via_substring(prompt, off, hs, names)
  508. c = calc_pearson_correlation(names, loc_repr, gm)
  509. if not np.isnan(c):
  510. corrs.append(c)
  511. avg[layer_idx] = np.mean(corrs) if corrs else float("nan")
  512. logging.info(f"[{model_name}] L{layer_idx} r={avg[layer_idx]:.3f}")
  513. color = "blue" if model_name == "gpt2-medium" else "red"
  514. plt.plot(list(avg.keys()), list(avg.values()), "o--",
  515. label=labels.get(model_name, model_name), color=color)
  517. plt.xlabel("Layer index"); plt.ylabel("Pearson correlation")
  518. plt.title("Family: Correlation vs layer"); plt.legend()
  519. plt.savefig("comparison_family_correlation_vs_layer.png", dpi=200, bbox_inches="tight")
  522. # ---------------------------------------------------------------------------
  523. # Entry point
  524. # ---------------------------------------------------------------------------
  526. if __name__ == "__main__":
  527. import argparse
  528. parser = argparse.ArgumentParser()
  529. parser.add_argument("--smoke", action="store_true")
  530. args = parser.parse_args()
  532. model_to_test = "outputs_tree"
  534. if args.smoke:
  535. n_pca, n_single, n_corr = 5, 1, 3
  536. ctx_lens = [10, 30]
  537. layers = [6, 12, 18]
  538. else:
  539. n_pca, n_single, n_corr = 300, 3, 100
  540. ctx_lens = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]
  541. layers = list(range(24))
  543. multi_tree_allinone("gpt2-medium", 12, n_pca, 50, "pca")
  544. for _ in range(n_single):
  545. single_tree_with_edge_lines("gpt2-medium", 12, 100000, "pca")
  547. multi_tree_allinone(model_to_test, 12, n_pca, 50, "pca")
  548. for _ in range(n_single):
  549. single_tree_with_edge_lines(model_to_test, 12, 100000, "pca")
  551. models = ["gpt2-medium", model_to_test]
  552. correlation_vs_context_length_multi(models, 12, ctx_lens, n_corr)
  553. correlation_vs_layer_multi(models, layers, n_corr, 50)

plot_family_reps.py at commit ed8901b, under MIT · at the source

Overview

Authors: Eleanor Spens1, Neil Burgess2,3
ORCID iDs: Eleanor Spens, Neil Burgess
  1. Nuffield Department of Clinical Neurosciences, University of Oxford, Oxford, UK
  2. Institute of Cognitive Neuroscience, University College London, London, UK
  3. Queen Square Institute of Neurology, University College London, London, UK
Institutions: University of Oxford (United Kingdom); UCL Queen Square Institute of Neurology (United Kingdom); University College London (United Kingdom)
Journal: Nature communications, volume 17, issue 1, article 7971
Dates: received 5 September 2025; accepted 2 June 2026; published online 25 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41467-026-74357-6 · PMID 42350398 · PMCID PMC13447824 · OpenAlex W7165934846
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: computational modeling (no new data) (modality), human (organism)
Methods: Statistics, Machine learning
Keywords: Cognitive neuroscience, Human behaviour, Computational neuroscience
MeSH: Hippocampus*, Memory, Episodic*, Mental Recall*, Neocortex*, Animals, Computer Simulation, Humans, Memory, Short-Term, Models, Neurological, Nerve Net, Problem Solving (* major topic)
Topic: Memory and Neural Mechanisms (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Citations: cited by 1 paper (Europe PMC); 118 references in the paper

Abstract

Many aspects of learning, memory, and problem solving involve interplay between episodic (hippocampal) and semantic (neocortical) systems, but the neural mechanisms supporting this are unclear. We present a computational model in which sequential experiences are encoded in hippocampus in compressed form and replayed to train a neocortical generative network. This network captures the gist of specific episodes and extracts statistical patterns that generalise to new situations, enabling efficient reconstruction of the past and prediction of the future. The two systems interact during encoding, recall and problem solving, with the hippocampus retrieving relevant episodic information into working memory as a basis for generation using the ‘general knowledge’ of the neocortical network. We simulate this interaction as ‘retrieval-augmented generation’, with the addition of mechanisms to compress episodic memories into hippocampus and to consolidate them into neocortex. The model explains changes to memories over time, including schema-based distortions, and shows how episodic and semantic memory contribute to problem solving.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 29 matches between paragraphs and lines of code.

ellie-as/hippocampal-neocortical-RAG

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: ed8901b5cb93a2a4b68d9524e75efcb921798aec, 28 May 2026
Languages: Python (69), Jupyter (2)
Size: 318 files, 71 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt), 2 notebooks
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (33 files), PyTorch (29 files), Hugging Face Transformers (27 files), Matplotlib (21 files), pandas (15 files), SciPy (12 files), scikit-learn (9 files), UMAP (5 files), NetworkX (4 files), seaborn (3 files), Pillow (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
73 files
At the source: github.com/ellie-as/hippocampal-neocortical-RAG

Zenodo 20215885

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: the references
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
At the source:

Code availability

Code for all simulations can be found at https://github.com/ellie-as/hippocampal-neocortical-RAG. This repository is archived on Zenodo114.

Reproduced under the paper's license (CC BY), from the paper cited above.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 71 scripts, each with its path and the digest of its content;
  • 29 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Data availability

All datasets used are publicly available, and the codebase for the project loads the data required for each simulation automatically. Source data for all figures are provided with this paper. Source data are provided in this paper.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 2 authors, 3 keywords, 11 MeSH terms, 75 references.

Cite

This paper

Spens, E., & Burgess, N. (2026). Hippocampo-neocortical interaction as compressive retrieval-augmented generation. Nature communications, 17(1), 7971. https://doi.org/10.1038/s41467-026-74357-6

BibTeX

@article{spens2026hippocampo,
author = {Spens, Eleanor and Burgess, Neil},
title = {{Hippocampo-neocortical interaction as compressive retrieval-augmented generation}},
journal = {Nature communications},
year = {2026},
month = jun,
volume = {17},
number = {1},
pages = {7971},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-74357-6},
url = {https://doi.org/10.1038/s41467-026-74357-6},
pmid = {42350398},
pmcid = {PMC13447824}
}

RIS

TY - JOUR
AU - Spens, Eleanor
AU - Burgess, Neil
TI - Hippocampo-neocortical interaction as compressive retrieval-augmented generation
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/06/25
VL - 17
IS - 1
SP - 7971
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-74357-6
UR - https://doi.org/10.1038/s41467-026-74357-6
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-74357-6",
"type": "article-journal",
"title": "Hippocampo-neocortical interaction as compressive retrieval-augmented generation",
"container-title": "Nature communications",
"author": [
{
"family": "Spens",
"given": "Eleanor"
},
{
"family": "Burgess",
"given": "Neil"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "7971",
"DOI": "10.1038/s41467-026-74357-6",
"PMID": "42350398",
"PMCID": "PMC13447824",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-74357-6",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
25
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1016/j.cub.2026.05.068 [code]
An abstract relational map emerges in the human medial prefrontal cortex with consolidation.
Journal: Current biology : CB
In common: statsmodels, seaborn, pandas, 3 other tools, 6 references
[2] doi:10.1126/sciadv.aeg6797 [code]
Dorsoventral gradient of theta sweeps in the medial entorhinal cortex.
Journal: Science advances
In common: UMAP, NetworkX, statsmodels, 6 other tools, author Neil Burgess
[3] doi:10.1038/s41467-026-71428-6 [code]
Binding items to contexts through conjunctive neural representations with the method of loci.
Journal: Nature communications
In common: statsmodels, seaborn, scikit-learn, 4 other tools, 5 references
[4] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: Hugging Face Transformers, UMAP, NetworkX, 9 other tools
[5] doi:10.64898/2026.03.30.714220 [code]
An integrated single cell and spatial omics atlas of human prenatal development
Journal: bioRxiv (preprint)
In common: Hugging Face Transformers, UMAP, NetworkX, 9 other tools
[6] doi:10.1038/s41467-026-74358-5 [code]
Brain-inspired spatial intelligence for embodied agents.
Journal: Nature communications
In common: Hugging Face Transformers, NetworkX, Pillow, 7 other tools, 2 references
[7] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: Hugging Face Transformers, Pillow, statsmodels, 7 other tools, 2 references
[8] doi:10.1038/s42256-026-01254-4 [code]
Neural sampling from cognitive maps enables goal-directed imagination and planning.
Journal: Nature machine intelligence
In common: NetworkX, PyTorch, seaborn, 3 other tools, computational modeling (no new data), 4 references
[9] doi:10.1016/j.isci.2026.116825 [code]
Social hierarchy shapes behavioral and transcriptional responses to chronic stress and ketamine in male mice.
Journal: iScience
In common: UMAP, NetworkX, Pillow, 8 other tools
[10] doi:10.1038/s41598-026-43529-1 [code]
A spiking neural network inspired by neuroscience and psychology for Western mode- and key-conditioned music learning and composition.
Journal: Scientific reports
In common: NetworkX, Pillow, PyTorch, 6 other tools, computational modeling (no new data), 1 reference

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.