OSCR

Energy-efficient information processing and eligibility-trace plasticity in the Drosophila optic lobe connectome.

Code ↔ Paper

14 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 14 matches
  1. [1] § Results › Part B Structural information: type symmetries compress the connectome; spatial extensions require conservative treatment ↔ partB_pubready_package/partB_pubready/scripts/compute_heldout_nll.py, lines 1–30 · score 0.92 · Poisson NLL diagnostics, exact dyad split, sample dyad, distance binned, coordinate shuffled, structural model
  2. [2] § Results › Part E Eligibility-trace learning robustly aligns wiring geometry under cost constraints and outperforms REINFORCE under compute-matched budgets ↔ partE_pubready_package/partE_pubready/scripts/make_partE_patch_motif_generalization.py, lines 1–32 · score 0.88 · motif fingerprint space, multi patch motif, geometry alignment, biological patch, representative patch, learned graphs
  3. [3] § Results › Part C Functional information: decoder-based bounds show decodable signal that vanishes under null controls ↔ partC_pubready_package/partC_pubready_pkg/scripts/make_partC_decoder_sensitivity.py, lines 173–204 · score 0.87 · matched split sensitivity, alternative low capacity, claim narrow, activity tensors, archived raw, ConnShuffle
  4. [4] § Results › Part E Eligibility-trace learning robustly aligns wiring geometry under cost constraints and outperforms REINFORCE under compute-matched budgets ↔ partE_pubready_package/partE_pubready/scripts/make_partE_figures.py, lines 639–660 · score 0.66 · eligibility trace learning, forward pass budget, scale robustness, fairness, win, rank
  5. [5] § Methods › Learning rules and benchmarking ↔ partE_pubready_package/partE_pubready/scripts/make_partE_patch_motif_generalization.py, lines 1–32 · score 0.66 · multi patch motif, representative patch motif, fingerprints
  6. [6] § Methods › Learning rules and benchmarking ↔ partE_pubready_package/partE_pubready/scripts/make_partE_figures.py, lines 639–660 · score 0.65 · stochastic perturbation, Eligibility trace learning, gradient, baseline, prop, REINFORCE
  7. [7] § Results › Part C Functional information: decoder-based bounds show decodable signal that vanishes under null controls ↔ partC_pubready_package/partC_pubready_pkg/scripts/make_partC_decoder_sensitivity.py, lines 173–204 · score 0.60 · decoder family, real graph supports, zero lower bound, disappears, reproducible, regime
  8. [8] § Methods › Dynamical model and information bounds ↔ partD_pubready_package/scripts/local_decoding.py, lines 19–58 · score 0.59 · cross entropy, local decoding, lower bounds, classifier, population, shuffling
  9. [9] § Results › Part D Energetic accounting reveals higher bits-per-energy in the real connectome than in matched null networks ↔ partD_pubready_package/scripts/plot_partD_pubready.py, lines 232–295 · score 0.58 · Null_Strength, Null_Conn, energy efficiency, global, bits
  10. [10] § Results › Part C Functional information: decoder-based bounds show decodable signal that vanishes under null controls ↔ partC_pubready_package/partC_pubready_pkg/scripts/partC_metrics_utils.py, lines 1–35 · score 0.58 · cross entropy, mutual information, definition, clip, intentionally, stimulus
  11. [11] § Methods › Structural models and MDL ↔ partB_pubready_package/partB_pubready/scripts/plot_partB_pubready.py, lines 135–211 · score 0.57 · log likelihood, BIC, M0, M2, SBM, penalty
  12. [12] § Results › Part C Functional information: decoder-based bounds show decodable signal that vanishes under null controls ↔ partC_pubready_package/partC_pubready_pkg/scripts/plot_partC_pubready.py, lines 81–159 · score 0.55 · ConnShuffle, LabelShuffle, Global decoding, information lower bounds, accuracy, Decoder
  13. [13] § Results › Part C Functional information: decoder-based bounds show decodable signal that vanishes under null controls ↔ partC_pubready_package/partC_pubready_pkg/scripts/make_partC_report.py, lines 25–105 · score 0.55 · ConnShuffle, LabelShuffle, Global decoding, accuracy, tiles, lower bounds
  14. [14] § Results › Part A Data integrity and retinotopic coverage set the constraints for inference ↔ partA_figures_package/partA_figures/scripts/fig_t4t5_subtypes.py, lines 71–216 · score 0.51 · retinotopy coordinates, weight distributions, population, synapse, cell, neurons

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 · 574 lines · 23 KB · no license · 2 matches

  1. #!/usr/bin/env python3
  2. """Multi-patch motif generalization analysis for Part E.
  4. This script extends the representative-patch motif proxy by rerunning a small
  5. set of spatially distinct patches with the same lightweight Part E update rules,
  6. then comparing each learned graph to its own biological patch baseline in both
  7. geometry-alignment space and motif-fingerprint space.
  8. """
  10. from __future__ import annotations
  12. import argparse
  13. import sys
  14. from pathlib import Path
  16. import matplotlib.pyplot as plt
  17. import networkx as nx
  18. import numpy as np
  19. import pandas as pd
  20. import scipy.sparse as sp
  21. from scipy.stats import spearmanr
  24. RULE_ORDER = ["EProp", "RewardHebb", "REINFORCE", "Oja"]
  25. RULE_COLORS = {
  26. "EProp": "#0072B2",
  27. "RewardHebb": "#D55E00",
  28. "REINFORCE": "#009E73",
  29. "Oja": "#7A7A7A",
  30. "BioInit": "#111111",
  31. }
  32. FOCAL_TRIADS = ["201", "120U", "300", "021C"]
  35. def import_metrics(raw_root: Path):
  36. sys.path.insert(0, str(raw_root))
  37. from opticflow_partE import metrics # type: ignore
  39. return metrics
  42. def load_inputs(raw_root: Path):
  43. ret_typed = pd.read_parquet(
  44. raw_root / "outputs" / "audit" / "retinotopy_typed.parquet",
  45. columns=["body_id", "mean_u", "mean_v"],
  46. )
  47. nodes = pd.read_parquet(
  48. raw_root / "outputs" / "full_opticlobe_dataset" / "nodes.parquet",
  49. columns=["body_id", "type"],
  50. )
  51. edges = pd.read_parquet(
  52. raw_root / "outputs" / "full_opticlobe_dataset" / "edges.parquet",
  53. columns=["pre_id", "post_id", "weight"],
  54. )
  55. return ret_typed, nodes, edges
  58. def select_patches(ret_typed: pd.DataFrame, num_patches: int, patch_size: int, seed: int) -> list[np.ndarray]:
  59. rng = np.random.default_rng(seed)
  60. all_valid_ids = ret_typed["body_id"].to_numpy()
  61. available_mask = np.ones(len(all_valid_ids), dtype=bool)
  62. node_coords = ret_typed[["mean_u", "mean_v"]].to_numpy(dtype=float)
  64. patches = []
  65. attempts = 0
  66. while len(patches) < num_patches and attempts < 500:
  67. attempts += 1
  68. avail_indices = np.where(available_mask)[0]
  69. if len(avail_indices) < patch_size:
  70. break
  71. center_idx = int(rng.choice(avail_indices))
  72. center = node_coords[center_idx]
  73. dists = np.linalg.norm(node_coords[avail_indices] - center, axis=1)
  74. nearest_local = np.argsort(dists)[:patch_size]
  75. patch_indices = avail_indices[nearest_local]
  76. patches.append(all_valid_ids[patch_indices].copy())
  77. available_mask[patch_indices] = False
  78. return patches
  81. def build_patch_graph(
  82. patch_ids: np.ndarray, ret_typed: pd.DataFrame, nodes: pd.DataFrame, edges: pd.DataFrame
  83. ):
  84. patch_nodes = nodes[nodes["body_id"].isin(patch_ids)].reset_index(drop=True)
  85. patch_nodes = patch_nodes.merge(ret_typed, on="body_id", how="left")
  86. uid_map = {uid: i for i, uid in enumerate(patch_nodes["body_id"].to_numpy())}
  88. patch_edges = edges[edges["pre_id"].isin(uid_map) & edges["post_id"].isin(uid_map)].copy()
  89. rows = patch_edges["pre_id"].map(uid_map).to_numpy(dtype=np.int64)
  90. cols = patch_edges["post_id"].map(uid_map).to_numpy(dtype=np.int64)
  91. weights = patch_edges["weight"].fillna(1.0).to_numpy(dtype=float)
  93. adj_init = sp.csr_matrix((np.full(len(rows), 0.1, dtype=float), (rows, cols)), shape=(len(patch_nodes), len(patch_nodes)))
  94. conn = sp.csr_matrix((weights, (rows, cols)), shape=(len(patch_nodes), len(patch_nodes)))
  96. coords = patch_nodes[["mean_u", "mean_v"]].to_numpy(dtype=float)
  97. r_idx, c_idx = adj_init.nonzero()
  98. d_flat = np.linalg.norm(coords[r_idx] - coords[c_idx], axis=1)
  99. return patch_nodes, adj_init, conn, d_flat, r_idx, c_idx
  102. def compute_geometry_metrics(W_csr: sp.csr_matrix, d_flat: np.ndarray) -> tuple[float, float]:
  103. weights = np.abs(W_csr.data)
  104. if len(weights) == 0:
  105. return 0.0, 0.0
  106. rho = float(np.corrcoef(weights, d_flat)[0, 1]) if len(weights) > 1 else 0.0
  107. q95_w = np.percentile(weights, 95)
  108. q25_d = np.percentile(d_flat, 25)
  109. strong = weights >= q95_w
  110. short = d_flat <= q25_d
  111. short_share = float(np.sum(weights[strong & short]) / (np.sum(weights[strong]) + 1e-9))
  112. return rho, short_share
  115. def compute_ew_norm(W_csr: sp.csr_matrix, d_flat: np.ndarray, mean_d_norm: float) -> float:
  116. weights = np.abs(W_csr.data)
  117. if len(weights) == 0:
  118. return 0.0
  119. total_w = np.sum(weights) + 1e-9
  120. return float((np.sum(weights * d_flat) / total_w) / max(mean_d_norm, 1e-9))
  123. def compute_mean_pair_distance(coords: np.ndarray, seed: int, n_sample: int = 5000) -> float:
  124. rng = np.random.default_rng(seed)
  125. idx_a = rng.integers(0, len(coords), size=n_sample)
  126. idx_b = rng.integers(0, len(coords), size=n_sample)
  127. mean_d = float(np.mean(np.linalg.norm(coords[idx_a] - coords[idx_b], axis=1)))
  128. return mean_d if mean_d > 1e-6 else 1.0
  131. def aggregate_type_graph(W: sp.csr_matrix, patch_nodes: pd.DataFrame) -> pd.DataFrame:
  132. W = W.copy()
  133. W.eliminate_zeros()
  134. coo = W.tocoo()
  135. return (
  136. pd.DataFrame(
  137. {
  138. "pre_type": patch_nodes.iloc[coo.row]["type"].to_numpy(),
  139. "post_type": patch_nodes.iloc[coo.col]["type"].to_numpy(),
  140. "weight_sum": coo.data.astype(float),
  141. }
  142. )
  143. .groupby(["pre_type", "post_type"], as_index=False)["weight_sum"]
  144. .sum()
  145. )
  148. def density_matched_graph(type_df: pd.DataFrame, top_frac: float) -> nx.DiGraph:
  149. sub = type_df[type_df["pre_type"] != type_df["post_type"]].copy()
  150. if sub.empty:
  151. return nx.DiGraph()
  152. k = max(1, int(np.ceil(len(sub) * top_frac)))
  153. sub = sub.nlargest(k, "weight_sum")
  154. g = nx.DiGraph()
  155. for row in sub.itertuples(index=False):
  156. g.add_edge(str(row.pre_type), str(row.post_type), weight=float(row.weight_sum))
  157. return g
  160. def reciprocal_fraction(g: nx.DiGraph) -> float:
  161. if g.number_of_edges() == 0:
  162. return float("nan")
  163. pairs = {tuple(sorted((u, v))) for u, v in g.edges()}
  164. reciprocal = sum(1 for u, v in pairs if g.has_edge(u, v) and g.has_edge(v, u))
  165. return float(reciprocal / max(len(pairs), 1))
  168. def motif_zscores(g: nx.DiGraph, n_nulls: int, seed_base: int) -> dict[str, float]:
  169. real = nx.triadic_census(g)
  170. out = {}
  171. for triad in FOCAL_TRIADS:
  172. vals = []
  173. for i in range(n_nulls):
  174. h = g.copy()
  175. if h.number_of_edges() >= 4:
  176. try:
  177. nswap = min(5 * h.number_of_edges(), 10000)
  178. nx.algorithms.swap.directed_edge_swap(
  179. h, nswap=nswap, max_tries=max(20 * nswap, 1000), seed=seed_base + i
  180. )
  181. except Exception:
  182. pass
  183. vals.append(float(nx.triadic_census(h)[triad]))
  184. mu = float(np.mean(vals))
  185. sd = float(np.std(vals))
  186. out[triad] = (float(real[triad]) - mu) / sd if sd > 0 else float("nan")
  187. return out
  190. def run_rule(
  191. rule: str,
  192. seed: int,
  193. adj: sp.csr_matrix,
  194. d_flat: np.ndarray,
  195. r_idx: np.ndarray,
  196. c_idx: np.ndarray,
  197. metrics,
  198. lam: float = 0.01,
  199. gam: float = 1.0,
  200. n_steps: int = 200,
  201. n_classes: int = 8,
  202. ):
  203. rng = np.random.default_rng(seed)
  204. angles = np.linspace(0, 2 * np.pi, n_classes, endpoint=False)
  205. N = adj.shape[0]
  206. batch_size = 64
  208. W = adj.copy().astype(float)
  209. W_readout = np.zeros((N, n_classes), dtype=float)
  210. lr_plas = 1e-4 if rule == "Oja" else 1e-3
  211. lr_read = 0.01
  212. sigma = 0.001
  213. R_avg = 0.0
  214. e_trace = np.zeros_like(W.data)
  215. alpha = 0.9
  216. node_prefs = rng.random(N) * 2 * np.pi
  218. def fwd(W_c, r):
  219. W_d = W_c.toarray() if sp.issparse(W_c) else W_c
  220. res = r.dot(W_d)
  221. np.maximum(res, 0, out=res)
  222. return res
  224. trace_rows = []
  225. total_forwards = 0
  226. for t in range(n_steps):
  227. target_cls = rng.integers(0, n_classes, size=batch_size)
  228. delta = node_prefs[None, :] - angles[target_cls][:, None]
  229. r_in = np.maximum(np.cos(delta), 0)
  231. if rule == "REINFORCE":
  232. noise = rng.normal(0, sigma, size=W.data.shape)
  233. W_base = W.copy()
  235. W.data = W_base.data + noise
  236. np.maximum(W.data, 0, out=W.data)
  237. rp = fwd(W, r_in)
  238. Ep = np.mean(np.sum(rp, axis=1)) + gam * np.sum(W.data * d_flat)
  239. lp = rp @ W_readout
  240. probs_p = np.exp(lp - np.max(lp, axis=1, keepdims=True))
  241. probs_p /= np.sum(probs_p, axis=1, keepdims=True)
  242. mip = metrics.compute_mi_lb_bits(
  243. np.mean(-np.log2(np.clip(probs_p[np.arange(batch_size), target_cls], 1e-9, 1.0))),
  244. n_classes,
  245. verify=False,
  246. )
  247. Jp = metrics.compute_objective_j(mip, Ep, lam)
  249. W.data = W_base.data - noise
  250. np.maximum(W.data, 0, out=W.data)
  251. rn = fwd(W, r_in)
  252. En = np.mean(np.sum(rn, axis=1)) + gam * np.sum(W.data * d_flat)
  253. ln = rn @ W_readout
  254. probs_n = np.exp(ln - np.max(ln, axis=1, keepdims=True))
  255. probs_n /= np.sum(probs_n, axis=1, keepdims=True)
  256. min_ = metrics.compute_mi_lb_bits(
  257. np.mean(-np.log2(np.clip(probs_n[np.arange(batch_size), target_cls], 1e-9, 1.0))),
  258. n_classes,
  259. verify=False,
  260. )
  261. Jn = metrics.compute_objective_j(min_, En, lam)
  263. grad = (Jp - Jn) / (2 * sigma) * noise
  264. W.data = W_base.data + lr_plas * grad
  265. np.maximum(W.data, 0, out=W.data)
  266. r_out = fwd(W, r_in)
  267. total_forwards += 3
  268. else:
  269. r_out = fwd(W, r_in)
  270. total_forwards += 1
  272. E_tot = np.mean(np.sum(r_out, axis=1)) + gam * np.sum(W.data * d_flat)
  273. logits = r_out @ W_readout
  274. probs = np.exp(logits - np.max(logits, axis=1, keepdims=True))
  275. probs /= np.sum(probs, axis=1, keepdims=True)
  276. ce = np.mean(-np.log2(np.clip(probs[np.arange(batch_size), target_cls], 1e-9, 1.0)))
  277. mi = float(metrics.compute_mi_lb_bits(ce, n_classes, verify=False))
  278. J = float(metrics.compute_objective_j(mi, E_tot, lam))
  280. rp_ = r_in[:, r_idx]
  281. rc_ = r_out[:, c_idx]
  282. hebb = np.mean(rc_ * rp_, axis=0)
  283. if rule == "Oja":
  284. W.data += lr_plas * (hebb - np.mean(rc_**2, axis=0) * W.data)
  285. elif rule == "RewardHebb":
  286. W.data += lr_plas * (J - R_avg) * hebb
  287. R_avg = 0.9 * R_avg + 0.1 * J
  288. elif rule == "EProp":
  289. e_trace = alpha * e_trace + hebb
  290. W.data += lr_plas * (J - R_avg) * e_trace
  291. R_avg = 0.9 * R_avg + 0.1 * J
  292. np.maximum(W.data, 0, out=W.data)
  294. dprob = probs.copy()
  295. dprob[np.arange(batch_size), target_cls] -= 1
  296. W_readout -= lr_read * (r_out.T @ dprob) / batch_size
  298. trace_rows.append(
  299. {
  300. "epoch": t,
  301. "rule": rule,
  302. "seed": seed,
  303. "J": J,
  304. "MI_lb": mi,
  305. "E_total": float(E_tot),
  306. "total_forwards": total_forwards,
  307. }
  308. )
  310. return W.copy(), pd.DataFrame(trace_rows)
  313. def compute_d3z(df_rows: pd.DataFrame, df_bio: pd.DataFrame) -> pd.Series:
  314. metrics_base = ["Ew_norm", "Rho", "ShortShare"]
  315. vec_stats = {}
  316. for m in metrics_base:
  317. pool = np.concatenate([df_rows[m].to_numpy(dtype=float), df_bio[m].to_numpy(dtype=float)])
  318. vec_stats[m] = (float(np.mean(pool)), float(np.std(pool)))
  320. dvals = []
  321. for row in df_rows.itertuples(index=False):
  322. dist_sq = 0.0
  323. bio = df_bio[df_bio["patch_idx"] == row.patch_idx].iloc[0]
  324. for m in metrics_base:
  325. mean, std = vec_stats[m]
  326. std = std if std > 1e-9 else 1.0
  327. z_rule = (getattr(row, m) - mean) / std
  328. z_bio = (bio[m] - mean) / std
  329. dist_sq += (z_rule - z_bio) ** 2
  330. dvals.append(np.sqrt(dist_sq))
  331. return pd.Series(dvals, index=df_rows.index, dtype=float)
  334. def compute_motif_distance(df_rows: pd.DataFrame, df_bio: pd.DataFrame) -> pd.Series:
  335. motif_cols = ["reciprocal_fraction"] + [f"{triad}_z" for triad in FOCAL_TRIADS]
  336. vec_stats = {}
  337. for m in motif_cols:
  338. pool = np.concatenate([df_rows[m].to_numpy(dtype=float), df_bio[m].to_numpy(dtype=float)])
  339. finite = pool[np.isfinite(pool)]
  340. mean = float(np.mean(finite)) if len(finite) else 0.0
  341. std = float(np.std(finite)) if len(finite) else 1.0
  342. vec_stats[m] = (mean, std if std > 1e-9 else 1.0)
  344. dvals = []
  345. for _, row in df_rows.iterrows():
  346. bio = df_bio[df_bio["patch_idx"] == row["patch_idx"]].iloc[0]
  347. dist_sq = 0.0
  348. for m in motif_cols:
  349. mean, std = vec_stats[m]
  350. row_v = row[m]
  351. bio_v = bio[m]
  352. if not np.isfinite(row_v) or not np.isfinite(bio_v):
  353. continue
  354. dist_sq += (((row_v - mean) / std) - ((bio_v - mean) / std)) ** 2
  355. dvals.append(np.sqrt(dist_sq))
  356. return pd.Series(dvals, index=df_rows.index, dtype=float)
  359. def make_figure(
  360. learned: pd.DataFrame,
  361. summary: pd.DataFrame,
  362. corr_rho: float,
  363. corr_p: float,
  364. out_pdf: Path,
  365. out_png: Path,
  366. ) -> None:
  367. fig, axes = plt.subplots(1, 3, figsize=(15.2, 5.2), layout="constrained")
  369. ax = axes[0]
  370. order = RULE_ORDER
  371. xpos = np.arange(len(order))
  372. vals = [summary.loc[summary["rule"] == r, "motif_dist_median"].iloc[0] for r in order]
  373. lo = [summary.loc[summary["rule"] == r, "motif_dist_min"].iloc[0] for r in order]
  374. hi = [summary.loc[summary["rule"] == r, "motif_dist_max"].iloc[0] for r in order]
  375. ax.bar(xpos, vals, color=[RULE_COLORS[r] for r in order], edgecolor="black", linewidth=0.8)
  376. ax.errorbar(xpos, vals, yerr=[np.array(vals) - np.array(lo), np.array(hi) - np.array(vals)], fmt="none", ecolor="black", capsize=3)
  377. ax.set_xticks(xpos, order, rotation=20, ha="right")
  378. ax.set_ylabel("Motif-fingerprint distance to patch connectome")
  379. ax.set_title("Lower is closer to the biological patch")
  380. ax.grid(axis="y", alpha=0.25)
  382. ax = axes[1]
  383. heat = summary.set_index("rule")[["reciprocal_fraction_median"] + [f"{triad}_z_median" for triad in FOCAL_TRIADS]].reindex(order)
  384. finite = heat.to_numpy()[np.isfinite(heat.to_numpy())]
  385. vmax = 2.0 if finite.size == 0 else float(np.nanpercentile(np.abs(finite), 95))
  386. im = ax.imshow(heat.to_numpy(), aspect="auto", cmap="coolwarm", vmin=-vmax, vmax=vmax)
  387. ax.set_xticks(np.arange(1 + len(FOCAL_TRIADS)), ["recip"] + FOCAL_TRIADS)
  388. ax.set_yticks(np.arange(len(order)), order)
  389. ax.set_title("Median motif fingerprint across patches")
  390. for i in range(len(order)):
  391. for j in range(1 + len(FOCAL_TRIADS)):
  392. val = heat.iloc[i, j]
  393. text = "nan" if not np.isfinite(val) else f"{val:.2f}"
  394. ax.text(j, i, text, ha="center", va="center", fontsize=8)
  395. cbar = fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
  396. cbar.set_label("Metric value")
  398. ax = axes[2]
  399. for rule in order:
  400. sub = learned[learned["rule"] == rule]
  401. ax.scatter(
  402. sub["D_3z"],
  403. sub["motif_dist_to_bio"],
  404. label=rule,
  405. color=RULE_COLORS[rule],
  406. s=55,
  407. alpha=0.85,
  408. edgecolor="black",
  409. linewidth=0.4,
  410. )
  411. ax.set_xlabel("Geometry alignment distance $D_{3z}$")
  412. ax.set_ylabel("Motif-fingerprint distance to patch connectome")
  413. ax.set_title(f"Across learned graphs: Spearman $\\rho={corr_rho:.2f}$, $p={corr_p:.3f}$")
  414. ax.grid(alpha=0.25)
  415. ax.legend(frameon=False, fontsize=9, loc="lower center", bbox_to_anchor=(0.5, -0.30), ncol=2)
  417. fig.suptitle("Multi-patch motif generalization of learned Part E connectomes", fontsize=13)
  418. fig.savefig(out_pdf, bbox_inches="tight")
  419. fig.savefig(out_png, dpi=600, bbox_inches="tight")
  420. plt.close(fig)
  423. def write_report(
  424. summary: pd.DataFrame,
  425. learned: pd.DataFrame,
  426. corr_rho: float,
  427. corr_p: float,
  428. out_md: Path,
  429. ) -> None:
  430. lines = []
  431. lines.append("# Part E Multi-patch Motif Generalization\n\n")
  432. lines.append("- Source: deterministic rerun of spatially distinct 1000-node patches using the archived patch-generalization regime (`lambda=0.01`, `gamma=1.0`, 8-way motion task).\n")
  433. lines.append("- For each patch we compared learned motif fingerprints to the corresponding biological patch graph after type-level aggregation and density matching.\n")
  434. lines.append(f"- Across learned graphs, motif distance and geometry-alignment distance are related with Spearman rho = {corr_rho:.2f} (p = {corr_p:.3g}).\n\n")
  435. lines.append("| Rule | Patches | Median motif distance | Median D_3z | Median reciprocity |\n")
  436. lines.append("|---|---:|---:|---:|---:|\n")
  437. for row in summary.itertuples(index=False):
  438. lines.append(
  439. f"| {row.rule} | {row.n_patches} | {row.motif_dist_median:.3f} | "
  440. f"{row.D_3z_median:.3f} | {row.reciprocal_fraction_median:.3f} |\n"
  441. )
  442. lines.append("\n")
  443. motif_wins = learned.pivot(index="patch_idx", columns="rule", values="motif_dist_to_bio").idxmin(axis=1).value_counts()
  444. geom_wins = learned.pivot(index="patch_idx", columns="rule", values="D_3z").idxmin(axis=1).value_counts()
  445. lines.append("Interpretation:\n")
  446. lines.append("- This analysis moves beyond a single representative patch: each rule is evaluated across multiple spatially distinct patches against its own biological motif baseline.\n")
  447. lines.append("- Lower motif distance means the learned graph stays closer to the biological patch in combined reciprocity and triad-enrichment space.\n")
  448. lines.append(
  449. f"- Geometry alignment and motif similarity partly dissociate in this rerun: EProp gives the lowest $D_{{3z}}$ on all {learned['patch_idx'].nunique()} patches, "
  450. f"whereas the motif-fingerprint winner is REINFORCE on {int(motif_wins.get('REINFORCE', 0))} patches, RewardHebb on {int(motif_wins.get('RewardHebb', 0))}, and EProp on {int(motif_wins.get('EProp', 0))}.\n"
  451. )
  452. lines.append("- The weak overall D_3z-to-motif correlation shows that motif resemblance is an additional descriptor of learned solutions rather than a simple restatement of the geometry-alignment score.\n")
  453. lines.append("- The analysis is still type-level rather than cell-level, but it is no longer confined to one patch.\n")
  454. out_md.write_text("".join(lines))
  457. def main() -> None:
  458. ap = argparse.ArgumentParser()
  459. ap.add_argument("--raw_root", required=True)
  460. ap.add_argument("--fig_dir", required=True)
  461. ap.add_argument("--table_dir", required=True)
  462. ap.add_argument("--report_dir", required=True)
  463. ap.add_argument("--n_patches", type=int, default=5)
  464. ap.add_argument("--patch_size", type=int, default=1000)
  465. ap.add_argument("--top_frac", type=float, default=0.2)
  466. ap.add_argument("--n_nulls", type=int, default=10)
  467. ap.add_argument("--seed", type=int, default=42)
  468. args = ap.parse_args()
  470. raw_root = Path(args.raw_root).expanduser().resolve()
  471. fig_dir = Path(args.fig_dir).expanduser().resolve()
  472. table_dir = Path(args.table_dir).expanduser().resolve()
  473. report_dir = Path(args.report_dir).expanduser().resolve()
  474. for d in [fig_dir / "pdf", fig_dir / "png", table_dir, report_dir]:
  475. d.mkdir(parents=True, exist_ok=True)
  477. metrics = import_metrics(raw_root)
  478. ret_typed, nodes, edges = load_inputs(raw_root)
  479. patches = select_patches(ret_typed, args.n_patches, args.patch_size, args.seed)
  480. if not patches:
  481. raise RuntimeError("No patches selected for motif generalization analysis")
  483. learned_rows = []
  484. bio_rows = []
  485. trace_rows = []
  487. for patch_idx, patch_ids in enumerate(patches):
  488. patch_nodes, adj_init, conn, d_flat, r_idx, c_idx = build_patch_graph(patch_ids, ret_typed, nodes, edges)
  489. coords = patch_nodes[["mean_u", "mean_v"]].to_numpy(dtype=float)
  490. mean_d = compute_mean_pair_distance(coords, seed=args.seed + patch_idx)
  492. bio_type = aggregate_type_graph(conn.copy(), patch_nodes)
  493. bio_graph = density_matched_graph(bio_type, args.top_frac)
  494. bio_z = motif_zscores(bio_graph, args.n_nulls, seed_base=1000 + 100 * patch_idx)
  495. bio_rho, bio_short = compute_geometry_metrics(conn, d_flat)
  496. bio_rows.append(
  497. {
  498. "patch_idx": patch_idx,
  499. "rule": "BioInit",
  500. "Ew_norm": compute_ew_norm(conn, d_flat, mean_d),
  501. "Rho": bio_rho,
  502. "ShortShare": bio_short,
  503. "reciprocal_fraction": reciprocal_fraction(bio_graph),
  504. **{f"{triad}_z": bio_z[triad] for triad in FOCAL_TRIADS},
  505. }
  506. )
  508. for rule in RULE_ORDER:
  509. seed = args.seed + 1000 * patch_idx
  510. W_final, trace_df = run_rule(rule, seed, adj_init, d_flat, r_idx, c_idx, metrics)
  511. trace_df["patch_idx"] = patch_idx
  512. trace_rows.append(trace_df)
  514. sp.save_npz(table_dir / f"patch{patch_idx}_{rule}_final_weights.npz", W_final)
  515. type_df = aggregate_type_graph(W_final, patch_nodes)
  516. type_df.to_csv(table_dir / f"patch{patch_idx}_{rule}_type_graph.csv", index=False)
  517. g = density_matched_graph(type_df, args.top_frac)
  518. z = motif_zscores(g, args.n_nulls, seed_base=2000 + 1000 * patch_idx + 100 * RULE_ORDER.index(rule))
  519. rho, short = compute_geometry_metrics(W_final, d_flat)
  520. learned_rows.append(
  521. {
  522. "patch_idx": patch_idx,
  523. "rule": rule,
  524. "Ew_norm": compute_ew_norm(W_final, d_flat, mean_d),
  525. "Rho": rho,
  526. "ShortShare": short,
  527. "reciprocal_fraction": reciprocal_fraction(g),
  528. **{f"{triad}_z": z[triad] for triad in FOCAL_TRIADS},
  529. }
  530. )
  531. print(f"[OK] patch {patch_idx} rule {rule}")
  533. learned = pd.DataFrame(learned_rows)
  534. bio = pd.DataFrame(bio_rows)
  535. learned["D_3z"] = compute_d3z(learned, bio)
  536. learned["motif_dist_to_bio"] = compute_motif_distance(learned, bio)
  538. corr = spearmanr(learned["D_3z"], learned["motif_dist_to_bio"], nan_policy="omit")
  539. corr_rho = float(corr.statistic) if np.isfinite(corr.statistic) else float("nan")
  540. corr_p = float(corr.pvalue) if np.isfinite(corr.pvalue) else float("nan")
  542. summary = (
  543. learned.groupby("rule", as_index=False)
  544. .agg(
  545. n_patches=("patch_idx", "nunique"),
  546. motif_dist_median=("motif_dist_to_bio", "median"),
  547. motif_dist_min=("motif_dist_to_bio", "min"),
  548. motif_dist_max=("motif_dist_to_bio", "max"),
  549. D_3z_median=("D_3z", "median"),
  550. reciprocal_fraction_median=("reciprocal_fraction", "median"),
  551. **{f"{triad}_z_median": (f"{triad}_z", "median") for triad in FOCAL_TRIADS},
  552. )
  553. .reset_index(drop=True)
  554. )
  556. learned.to_csv(table_dir / "patch_motif_generalization_rows.csv", index=False)
  557. bio.to_csv(table_dir / "patch_motif_bio_rows.csv", index=False)
  558. summary.to_csv(table_dir / "patch_motif_generalization_summary.csv", index=False)
  559. pd.concat(trace_rows, ignore_index=True).to_csv(table_dir / "patch_motif_generalization_traces.csv", index=False)
  561. make_figure(
  562. learned,
  563. summary,
  564. corr_rho,
  565. corr_p,
  566. fig_dir / "pdf" / "FigE9_MotifGeneralization.pdf",
  567. fig_dir / "png" / "FigE9_MotifGeneralization.png",
  568. )
  569. write_report(summary, learned, corr_rho, corr_p, report_dir / "partE_patch_motif_generalization_report.md")
  570. print("[OK] wrote multi-patch motif generalization outputs and FigE9")
  573. if __name__ == "__main__":
  574. main()

make_partE_patch_motif_generalization.py at commit 19bcd7d, no license · at the source

Overview

Authors: Nalin Dhiman1, Siddharth Panwar1
  1. School of Computing and Electrical Engineering, Indian Institute of Technology Mandi,Mandi, India
Institutions: Indian Institute of Technology Mandi (India)
Journal: Scientific reports, volume 16, issue 1, article 22754
Dates: received 12 March 2026; accepted 4 May 2026; published online 19 May 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41598-026-52140-3 · PMID 42156870 · PMCID PMC13385933 · OpenAlex W7161631646
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: drosophila (organism), cellular / molecular (subfield)
Methods: Machine learning
Keywords: Computational biology and bioinformatics, Neuroscience, Physics
MeSH: Connectome*, Drosophila*, Drosophila melanogaster*, Energy Metabolism*, Neuronal Plasticity*, Optic Lobe, Nonmammalian*, Animals (* major topic)
Topic: Neural Networks and Reservoir Computing (Artificial Intelligence, Computer Science), according to OpenAlex
Citations: not cited yet (Europe PMC); 22 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

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

nalin-dhiman/Energy-efficient-information-processing-and-eligibility

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 19bcd7d83a044f90ad691bff5bfe1df636b7150a, 26 May 2026
Languages: Python (33)
Size: 267 files, 33 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, environment (partA_figures_package/partA_figures/REQUIREMENTS.txt, partD_pubready_package/scripts/requirements_partD.txt, partB_pubready_package/partB_pubready/scripts/requirements.txt, partE_pubready_package/partE_pubready/scripts/requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (27 files), pandas (20 files), Matplotlib (14 files), SciPy (7 files), scikit-learn (4 files), NetworkX (2 files), PyTorch (2 files), seaborn (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
34 files
At the source: github.com/nalin-dhiman/Energy-efficient-information-processing-and-eligibility.git

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41598-026-52140-3.

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:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 33 scripts, each with its path and the digest of its content;
  • 14 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

No dataset and no data link were found in the paper.

Data availability statement

The paper has a data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

  • no repository, dataset or request procedure was recognized in it

Read it in the paper: doi.org/10.1038/s41598-026-52140-3.

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, 28 September 2026: the first record

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

Cite

This paper

Dhiman, N., & Panwar, S. (2026). Energy-efficient information processing and eligibility-trace plasticity in the Drosophila optic lobe connectome. Scientific reports, 16(1), 22754. https://doi.org/10.1038/s41598-026-52140-3

BibTeX

@article{dhiman2026energy,
author = {Dhiman, Nalin and Panwar, Siddharth},
title = {{Energy-efficient information processing and eligibility-trace plasticity in the Drosophila optic lobe connectome}},
journal = {Scientific reports},
year = {2026},
month = may,
volume = {16},
number = {1},
pages = {22754},
publisher = {Nature Publishing Group},
issn = {2045-2322},
doi = {10.1038/s41598-026-52140-3},
url = {https://doi.org/10.1038/s41598-026-52140-3},
pmid = {42156870},
pmcid = {PMC13385933}
}

RIS

TY - JOUR
AU - Dhiman, Nalin
AU - Panwar, Siddharth
TI - Energy-efficient information processing and eligibility-trace plasticity in the Drosophila optic lobe connectome
T2 - Scientific reports
J2 - Sci Rep
PY - 2026
DA - 2026/05/19
VL - 16
IS - 1
SP - 22754
SN - 2045-2322
PB - Nature Publishing Group
DO - 10.1038/s41598-026-52140-3
UR - https://doi.org/10.1038/s41598-026-52140-3
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41598-026-52140-3",
"type": "article-journal",
"title": "Energy-efficient information processing and eligibility-trace plasticity in the Drosophila optic lobe connectome",
"container-title": "Scientific reports",
"author": [
{
"family": "Dhiman",
"given": "Nalin"
},
{
"family": "Panwar",
"given": "Siddharth"
}
],
"container-title-short": "Sci Rep",
"volume": "16",
"issue": "1",
"page": "22754",
"DOI": "10.1038/s41598-026-52140-3",
"PMID": "42156870",
"PMCID": "PMC13385933",
"ISSN": "2045-2322",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41598-026-52140-3",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
19
]
]
}
}

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.1038/s41586-026-10735-w [code]
Distributed control circuits across a brain-and-cord connectome.
Journal: Nature
In common: NetworkX, PyTorch, seaborn, 5 other tools, drosophila, 2 references
[2] doi:10.3389/fnsys.2026.1822122 [code]
Convergence-divergence circuits for multimodal integration of innate and learned opponent valences.
Journal: Frontiers in systems neuroscience
In common: NetworkX, PyTorch, seaborn, 5 other tools, 2 references
[3] doi:10.1371/journal.pone.0348005 [code]
THOI: An efficient and accessible library for computing higher-order interactions enhanced by batch-processing.
Journal: PloS one
In common: NetworkX, PyTorch, seaborn, 5 other tools, 1 reference
[4] doi:10.1038/s41467-026-72152-x [code]
Centralized brain networks controlling antennal grooming coordination.
Journal: Nature communications
In common: NetworkX, seaborn, scikit-learn, 4 other tools, drosophila, 1 reference
[5] doi:10.1073/pnas.2531706123 [code]
Metabolism-weighted brain connectome reveals synaptic integration and vulnerability to neurodegeneration.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: NetworkX, seaborn, scikit-learn, 4 other tools, cellular / molecular, 1 reference
[6] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: NetworkX, PyTorch, seaborn, 5 other tools, cellular / molecular
[7] doi:10.1038/s41467-026-76841-5 [code]
Stable clique membership in male mouse societies requires oxytocin-enabled social sensory states.
Journal: Nature communications
In common: NetworkX, PyTorch, seaborn, 5 other tools, cellular / molecular
[8] doi:10.1186/s12864-026-12965-8 [code]
Systematic evaluation of single-cell foundation model interpretability: attention-derived edge scores add no incremental value over gene-level features for perturbation-target prediction.
Journal: BMC genomics
In common: NetworkX, PyTorch, seaborn, 5 other tools, cellular / molecular
[9] doi:10.1038/s41467-026-71759-4 [code]
CellNiche represents cellular microenvironments in atlas-scale spatial omics data with contrastive learning.
Journal: Nature communications
In common: NetworkX, PyTorch, seaborn, 5 other tools, cellular / molecular
[10] doi:10.1101/gr.281350.125 [code]
High-fidelity bidirectional translation between single-cell transcriptomes and DNA methylomes with scBOND.
Journal: Genome research
In common: NetworkX, PyTorch, seaborn, 5 other tools, cellular / molecular

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.