OSCR

Exploring neural manifolds across a wide range of intrinsic dimensions.

Code ↔ Paper

1 match 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 1 match
  1. [1] § Materials and methods › Recurrent neural networks performing cog-tasks ↔ Code/task_handler2.py, lines 150–165 · score 0.60 · connection matrices, 0–1, Win, Wout, Wrec

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 · 601 lines · 20 KB · MIT · 1 match

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  3. import h5py
  5. from ID_estimator import *
  6. from network_structures import BPTT
  8. import tensorflow as tf
  10. import sys
  11. sys.path.append('../multitask/')
  12. from task import generate_trials, rule_name
  13. from network import Model
  14. import tools
  16. from pyFCI import pyFCI
  18. class Task:
  20. # Class to handle all operations each task needs
  22. def __init__(self, task_name, task_dir, basedir=".", batch_size=200, verbose=False, **kwargs):
  24. # initialize all the matrices
  25. initial_time = kwargs.get('initial_time', None)
  26. self.task_name = task_name
  27. self.basedir = basedir
  28. self.task_dir = task_dir
  29. self.q = batch_size
  30. with h5py.File(f"{basedir}/{task_dir}/RNN_params.h5", "r") as f:
  31. self.Win = f["w_in"][:]
  32. self.Wrec = f["w_rec"][:]
  33. self.Wout = f["w_out"][:]
  34. self.brec = f["brec"][:]
  35. self.bout = f["bout"][:]
  37. with h5py.File(f"{basedir}/{task_dir}/network_activity.h5", "r") as f:
  38. self.r = f["r"][:]
  39. self.z = f["z"][:]
  40. self.x_train = f["x_train"][:]
  41. self.y_train = f["y_train"][:]
  43. if verbose:
  44. print(f"Task {task_name} loaded.")
  45. print(f"Number of neurons: {np.size(self.Win.T[0])}")
  47. def network(self):
  49. # compute the back-propagation through time on the given task
  51. r, z = BPTT(self.Win.T, self.Wrec.T, self.Wout.T, self.brec, self.bout, self.x_train)
  53. self.r = r
  54. self.z = z
  56. return r, z # return recurrent and output part
  57. def network_yang(self, task_name=None, basedir=None,batch_size=200, **kwargs):
  58. basedir = self.basedir if basedir is None else basedir
  59. task_name = self.task_name if task_name is None else task_name
  60. model_dir = basedir+"/"+ task_name
  61. rule = task_name
  63. model = Model(model_dir)
  64. hp = model.hp
  66. initial_time = kwargs.get('initial_time', None)
  68. with tf.compat.v1.Session() as sess:
  69. model.restore()
  71. #trial = generate_trials(rule, hp, mode='test',batch_size = 1)
  72. if initial_time:
  73. trial = generate_trials(rule, hp, mode='random',batch_size = batch_size, initial_time = initial_time)
  74. else:
  75. trial = generate_trials(rule, hp, mode='random',batch_size = batch_size)
  76. feed_dict = tools.gen_feed_dict(model, trial, hp)
  77. h, y_hat = sess.run([model.h, model.y_hat], feed_dict=feed_dict)
  78. # All matrices have shape (n_time, n_condition, n_neuron)
  80. # print(np.shape(trial.x), np.shape(h), np.shape(y_hat))
  82. if initial_time:
  83. h = h[initial_time:,:,:]
  84. y_hat = y_hat[initial_time:,:,:]
  85. var_list = model.var_list
  87. # evaluate the parameters after training
  88. params = [sess.run(var) for var in var_list]
  89. # get name of each variable
  90. names = [var.name for var in var_list]
  92. y_trained = np.vstack(np.swapaxes(y_hat, 0, 1))
  93. h_trained = np.vstack(np.swapaxes(h, 0, 1))
  95. self.r = h_trained
  96. self.z = y_trained
  98. return h_trained, y_trained
  100. def find_relevant_points(self):
  101. # find relevant points for the task
  102. x_train = self.x_train
  103. y_train = self.y_train
  104. trials_len = x_train.shape[0]//self.q
  105. self.trials_len = trials_len
  106. stim = np.where(x_train[:trials_len,1:65].max(1)>0.3)[0]
  107. stim_start = stim[0] if len(stim)>0 else 0
  108. stim_end = stim[-1] if len(stim)>0 else 0
  109. go = np.where(y_train[:trials_len,0]<0.8)[0]
  110. go_start = go[0] if len(go)>0 else 0
  111. go_end = go[-1] if len(go)>0 else 0
  112. self.stim_start = stim_start
  113. self.stim_end = stim_end
  114. self.go_start = go_start
  115. self.go_end = go_end
  116. return stim_start, stim_end, go_start, go_end, trials_len
  118. def compute_angle(self):
  119. # decode target angle from output
  120. # z: output part
  121. # n: trial length
  122. angle = np.zeros(self.q)
  123. z = self.z
  124. n = self.trials_len
  125. q = self.q
  126. for i in range(q):
  127. f = z[n*(i+1)-10:n*(i+1),1:]
  128. fm = np.mean(f,axis=0)
  129. angle[i] = np.argmax(fm)
  130. self.angle = angle
  131. return angle
  133. def split_data(self):
  134. q = self.q
  135. n = self.trials_len
  136. n1 = self.stim_start
  137. n2 = self.go_start
  139. beginning = np.repeat(np.arange(0, n*q, n), n1) + np.tile(np.arange(0, n1), q)
  140. if n2>n1:
  141. middle = np.repeat(np.arange(0, n*q, n), n2-n1) + np.tile(np.arange(n1, n2), q)
  142. else:
  143. middle = np.array([])
  144. final = np.repeat(np.arange(0, n*q, n), n-n2) + np.tile(np.arange(n2, n), q)
  146. self.beginning = beginning
  147. self.middle = middle
  148. self.final = final
  150. def connectivity_matrix(self):
  152. # plot the connectivity matrix
  153. fig, ax = plt.subplots(2, 2, figsize=(4, 4),tight_layout=True)
  154. A = ax[0,0].imshow(self.Win.T)
  155. plt.colorbar(A)
  156. ax[0,0].set_title("$W_{in}$")
  158. B = ax[0,1].imshow(self.Wrec.T)
  159. plt.colorbar(B)
  160. ax[0,1].set_title("$W_{rec}$")
  162. C = ax[1,0].imshow(self.Wout.T)
  163. plt.colorbar(C)
  164. ax[1,0].set_title("$W_{out}$")
  165. plt.show()
  167. def network_plot(self, lim):
  169. # display the dynamics of the network
  171. fig, axs = plt.subplots(2, 2, figsize=(7, 4),tight_layout=True)
  173. fig.suptitle("Train")
  175. axs[0,0].plot(self.z[:,1:65])
  176. axs[0,0].set_xlim(0, lim)
  177. axs[0,0].set_xlabel("time step (ms)")
  178. axs[0,0].set_ylabel("output")
  180. axs[0,1].plot(self.y_train[:,1:65])
  181. axs[0,1].set_xlim(0, lim)
  182. axs[0,1].set_xlabel("time step (ms)")
  183. axs[0,1].set_ylabel("target")
  185. axs[1,0].plot((self.z - self.y_train)[:,1:65])
  186. axs[1,0].set_xlim(0, lim)
  187. axs[1,0].set_title("Training error")
  188. axs[1,0].set_xlabel("time step (ms)")
  189. axs[1,0].set_ylabel(r"$\Delta$")
  191. axs[1,1].set_axis_off()
  192. plt.show()
  194. def sample_plots(self, lim=200):
  195. """
  196. Plots the values of the different input an output channels
  197. task : task object with the task data and the trial information
  198. lim: time limit
  199. """
  200. relevant = self.find_relevant_points()
  201. x_train = self.x_train[:lim+1]
  202. z = self.z[:lim+1]
  203. r = self.r[:lim+1]
  204. len_trial = self.trials_len
  206. fig = plt.figure(figsize=(8,6))
  207. gs = fig.add_gridspec(4, height_ratios=[1.4,1,1.07,1.07], hspace=0, bottom=0.14,left=0.12)
  208. axs = gs.subplots(sharex=True)
  209. numcols = lim+1
  210. numrows = 32
  212. norm_r = (r - r.mean()) / r.std()
  213. #print(norm_r.min(), norm_r.max())
  214. #adj_r = r - r.min()
  215. #adj_r /= adj_r.max()
  216. #print(adj_r.min(), adj_r.max())
  217. axs[0].imshow(norm_r.T, vmin=-1,vmax=10, cmap="viridis",origin="lower", aspect="auto")
  218. axs[0].set_yticks([50,150,250],labels=(50,150,250), fontsize="x-large")
  220. igo = np.repeat(x_train[:,0].reshape(1,-1), 2, axis=0)
  221. i1go = np.concatenate((igo,x_train[:lim+1,1:33].T), axis=0)
  223. fix = np.repeat(z[:,0].reshape(1,-1), 2, axis=0)
  224. ofix = np.concatenate((fix,z[:,1:33].T), axis=0)
  226. axs[1].imshow(x_train[:,33:-1].T, vmin=0,vmax=1, origin="lower",extent=(-0.5,numcols-0.5,-0.5,numrows-0.5), aspect="auto")
  227. axs[2].imshow(i1go, vmin=0,vmax=1, origin="lower",extent=(-0.5,numcols-0.5,-2.5,numrows-0.5), aspect="auto")
  228. axs[3].imshow(ofix, vmin=0,vmax=1, origin="lower", extent=(-0.5,numcols-0.5,-2.5,numrows-0.5), aspect="auto")
  230. for i in range(lim//len_trial):
  231. axs[0].axvline((i+1)*len_trial-0.5, color="lime", linewidth=1.5)
  232. axs[1].axvline((i+1)*len_trial-0.5, color="lime", linewidth=1.5)
  233. axs[2].axvline((i+1)*len_trial-0.5, color="lime", linewidth=1.5)
  234. axs[3].axvline((i+1)*len_trial-0.5, color="lime", linewidth=1.5)
  236. axs[2].axhline(-0.5, color="darkslategray", linewidth=1.5)
  237. axs[3].axhline(-0.5, color="slategray", linewidth=1.5)
  240. axs[1].set_xlim(0, lim)
  241. axs[2].set_xlim(0, lim)
  242. axs[3].set_xlim(0, lim)
  244. axs[0].set_ylabel(r"$\mathbf{N}\ $",rotation=0, fontsize="x-large")
  245. axs[1].set_ylabel(r"$\mathbf{I_2}$",rotation=0, fontsize="x-large")
  246. axs[2].set_ylabel(r"$\mathbf{I_1}$",rotation=0, fontsize="x-large")
  247. axs[3].set_ylabel(r"$\mathbf{O}$", rotation=0, fontsize="x-large")
  248. axs[3].set_xlabel("t", fontweight="bold")
  250. axs[2].annotate(r"$\mathbf{I_{fix}}$", xy=(0, -1.5), xycoords="data", xytext=(-38, -0.7), textcoords="axes points",fontsize="large", fontweight="bold")
  251. axs[3].annotate(r"$\mathbf{O_{fix}}$", xy=(0, -1.5), xycoords="data", xytext=(-38, -0.7), textcoords="axes points",fontsize="large", fontweight="bold")
  253. axs[0].spines["bottom"].set_edgecolor("silver")
  254. axs[1].spines["top"].set_edgecolor("silver")
  255. axs[1].spines["bottom"].set_edgecolor("darkslategray")
  256. axs[2].spines["top"].set_edgecolor("darkslategray")
  257. axs[2].spines["bottom"].set_edgecolor("silver")
  258. axs[3].spines["top"].set_edgecolor("silver")
  260. axs[1].set_yticks([0,16,32],labels=(0,r"$\pi$",r"$2\pi$"), fontsize="x-large")
  261. axs[2].set_yticks([0,16],labels=(0,r"$\pi$"), fontsize="x-large")
  262. axs[3].set_yticks([0,16],labels=(0,r"$\pi$"), fontsize="x-large")
  264. fig.align_ylabels()
  266. def ID_FCI_estimator(self, Niter, full, method = "full", **kwargs):
  267. """
  268. compute the intrinsic dimension using the FCI method
  269. Parameters:
  270. -----------
  271. Niter : int
  272. the number of iterations if method is "mc"
  274. full : boolean
  275. if True returns also the fit parameters and the fci integral
  277. method : string
  278. the method used to compute the intrinsic dimension, default is "full",
  279. the other option is "mc".
  280. Returns:
  281. --------
  282. id_fci : float
  283. the intrinsic dimension using FCI
  284. """
  286. if method == "mc":
  287. # compute the FCI using montecarlo
  288. if full:
  289. id_fci, fit, fci = ID_FCI_MC(self.r, Niter, full, **kwargs)
  290. else:
  291. id_fci = ID_FCI_MC(self.r, Niter, **kwargs)
  292. elif method == "full":
  293. # compute the FCI
  294. if full:
  295. id_fci, fit, fci = ID_FCI(self.r, full, **kwargs)
  296. else:
  297. id_fci = ID_FCI(self.r, **kwargs)
  298. else:
  299. raise ValueError("method must be 'full' or 'mc'")
  301. self.id_fci = id_fci
  302. if full:
  303. return id_fci, fit, fci
  304. else:
  305. return id_fci
  307. def ID_pca(self,normalize, full):
  308. """
  309. Compute the intrinsic dimension using the PCA explained variance.
  311. Parameters
  312. ----------
  313. normalize : boolean
  314. if True, the data points are normalized
  315. full : boolean
  316. if True returns also the PCs and the explained variance
  317. Returns
  318. -------
  319. id_pca : float
  320. the intrinsic dimension using PCA
  321. y : array
  322. the projected data points
  323. v : array
  324. the explained variance ratio
  325. """
  326. if full:
  327. id_pca, y, v = ID_PCA(self.r, normalize, full)
  328. self.id_pca = id_pca
  329. return id_pca, y, v
  330. else:
  331. id_pca = ID_PCA(self.r, normalize)
  332. self.id_pca = id_pca
  333. return id_pca
  335. def ID_participation_ratio(self):
  336. """
  337. Compute the intrinsic dimension using the participation ratio.
  339. Parameters
  340. ----------
  341. None
  343. Returns
  344. -------
  345. id_pr : float
  346. The intrinsic dimension using the participation ratio
  347. """
  348. d_pr = participation_ratio(self.r)
  349. self.id_pr = d_pr
  350. return d_pr
  352. def ID_parallel_analysis(self,data_range = None,**kwargs):
  353. """
  354. Compute the intrinsic dimension using the parallel analysis.
  356. Parameters
  357. ----------
  358. data_range : array, optional, default None
  359. the range of the data for the parallel analysis
  360. kwargs : dict
  361. keyword arguments for the parallel analysis:
  362. - num_shuffles: default 250,
  363. - percentile: default 95
  365. Returns
  366. -------
  367. id_pa : float
  368. The intrinsic dimension using the parallel analysis
  369. """
  370. if data_range is None:
  371. id_pa = id_parallel_analysis(self.r, **kwargs)
  372. else:
  373. id_pa = id_parallel_analysis(self.r[data_range], **kwargs)
  374. self.id_pa = id_pa
  375. return id_pa
  377. def id_twoNN(self, twonn=True, scale_dependent=False,**kwargs):
  379. # compute the intrinsic dimension using two nearest neighbors
  380. drange = kwargs.get('drange', None)
  381. if twonn and scale_dependent:
  382. id_2NN, id_2NN_scale, fitting_params = ID_twoNN_dadapy(self.r[drange].squeeze(), twonn, scale_dependent, **kwargs)
  383. self.id_2NN = id_2NN
  384. self.id_2NN_scale = id_2NN_scale
  385. return id_2NN, id_2NN_scale, fitting_params
  386. elif twonn and not scale_dependent:
  387. id_2NN, fitting_params = ID_twoNN_dadapy(self.r[drange].squeeze(), twonn, scale_dependent, **kwargs)
  388. self.id_2NN = id_2NN
  389. return id_2NN, fitting_params
  390. elif not twonn and scale_dependent:
  391. id_2NN_scale, fitting_params = ID_twoNN_dadapy(self.r[drange].squeeze(), twonn, scale_dependent, **kwargs)
  392. self.id_2NN_scale = id_2NN_scale
  393. return id_2NN_scale, fitting_params
  395. def ID(self):
  397. # compute the intrinsic dimension
  399. d, x, y = ID_estimator(self.r)
  401. self.d = d
  402. self.x = x
  403. self.y = y
  405. def collect_ID_FCI(self, n_iter = 20, method = "mc", **kwargs):
  406. """
  407. compute the intrinsic dimension using FCI
  408. parameters:
  409. -----------
  410. n_iter : int
  411. the number of iterations if method is "mc"
  413. method : string
  414. the method used to compute the intrinsic dimension, default is "mc",
  415. the other option is "full".
  416. """
  417. q = self.q
  418. n = self.trials_len
  419. n1 = self.stim_start
  420. n2 = self.go_start
  422. r = self.r
  423. norm_r = pyFCI.center_and_normalize(r)
  425. beginning = self.beginning
  426. middle = self.middle
  427. final = self.final
  428. if method == "full":
  429. d_beg_fci = ID_FCI(norm_r[beginning,:], normalize=False, **kwargs)
  430. else:
  431. d_beg_fci = ID_FCI_MC(norm_r[beginning,:], n_iter, normalize=False, **kwargs)
  432. print(f"Beginning dimension: {d_beg_fci}")
  434. if n2-n1>0:
  435. if method == "full":
  436. d_mid_fci = ID_FCI(norm_r[middle,:], normalize=False, **kwargs)
  437. else:
  438. d_mid_fci = ID_FCI_MC(norm_r[middle,:], n_iter, normalize=False, **kwargs)
  439. print(f"Middle dimension: {d_mid_fci}")
  440. else:
  441. d_mid_fci = 0
  442. if method == "full":
  443. d_fin_fci = ID_FCI(norm_r[final,:], normalize=False, **kwargs)
  444. else:
  445. d_fin_fci = ID_FCI_MC(norm_r[final,:], n_iter, normalize=False, **kwargs)
  446. print(f"Final dimension: {d_fin_fci}")
  448. if method == "full":
  449. d_tot_fci = ID_FCI(norm_r, normalize=False, **kwargs)
  450. else:
  451. d_tot_fci = ID_FCI_MC(norm_r, n_iter, normalize=False, **kwargs)
  452. print(f"Total dimension: {d_tot_fci}")
  454. dim_vector_fci = np.array([d_beg_fci, d_mid_fci, d_fin_fci, d_tot_fci])
  455. self.dim_fci_regions = dim_vector_fci
  457. return dim_vector_fci
  459. def collect_ID_twoNN(self, display=False, **kwargs):
  461. beginning = self.beginning
  462. middle = self.middle
  463. final = self.final
  464. r = self.r
  466. # norm_r = (r - np.mean(r, axis=0)) / np.std(r, axis=0)
  468. if len(beginning)>10:
  469. d_beg, beg = ID_twoNN_dadapy(r[beginning, :])
  470. print(f"Beginning dimension: {d_beg}")
  471. else:
  472. d_beg = 0
  474. if len(middle)>10:
  475. d_mid, mid = ID_twoNN_dadapy(r[middle, :])
  476. print(f"Middle dimension: {d_mid}")
  477. else:
  478. d_mid = 0
  480. if len(final)>10:
  481. d_fin, fin = ID_twoNN_dadapy(r[final, :])
  482. print(f"Final dimension: {d_fin}")
  483. else:
  484. d_fin = 0
  486. d_tot, tot = ID_twoNN_dadapy(r)
  487. print(f"Total dimension: {d_tot}")
  488. dim_vector = np.array([d_beg, d_mid, d_fin, d_tot])
  489. self.dim_twonn_regions = dim_vector
  490. if display:
  491. self.display_ID(beg, mid, fin, tot)
  493. return dim_vector
  496. def display_ID(self, beg, mid, fin, tot):
  498. # plot the intrinsic dimension
  500. dims = self.dim_vector_twonn
  501. d_beg = dims[0]
  502. d_mid = dims[1]
  503. d_fin = dims[2]
  504. d_tot = dims[3]
  506. fig, axs = plt.subplots(2, 2, figsize=(10, 8))
  508. axs[0, 0].scatter(beg[1], beg[0], s=20, marker="x")
  509. axs[0, 0].plot(beg[1], beg[1]*d_beg, c="red")
  510. axs[0, 0].set_title(f"Beginning dimension: {np.round(d_beg, 2)}")
  512. axs[0, 1].scatter(mid[1], mid[0], s=20, marker="x")
  513. axs[0, 1].plot(mid[1], mid[1]*d_mid, c="red")
  514. axs[0, 1].set_title(f"Middle dimension: {np.round(d_mid, 2)}")
  516. axs[1, 0].scatter(fin[1], fin[0], s=20, marker="x")
  517. axs[1, 0].plot(fin[1], fin[1]*d_fin, c="red")
  518. axs[1, 0].set_title(f"Final dimension: {np.round(d_fin, 2)}")
  520. axs[1, 1].scatter(tot[1], tot[0], s=10, marker="x")
  521. axs[1, 1].plot(tot[1], tot[1]*d_tot, c="red")
  522. axs[1, 1].set_title(f"Total dimension: {np.round(d_tot, 2)}")
  524. plt.show()
  527. def scale_ID_twoNN(self, display = False, **kwargs):
  529. # compute scale dependent ID for every range defined before
  531. beginning = self.beginning
  532. middle = self.middle
  533. final = self.final
  534. r = self.r
  536. # compute the intrinsic dimension
  537. if len(beginning)>10:
  538. dim_beg, beg = ID_twoNN_dadapy(r[beginning, :],twonn=False, scale_dependent=True, **kwargs)
  539. else:
  540. dim_beg = 0
  542. if len(middle)>10:
  543. dim_mid, mid = ID_twoNN_dadapy(r[middle, :],twonn=False, scale_dependent=True, **kwargs)
  544. else:
  545. dim_mid = 0
  547. if len(final)>10:
  548. dim_fin, fin = ID_twoNN_dadapy(r[final, :],twonn=False, scale_dependent=True, **kwargs)
  549. else:
  550. dim_fin = 0
  551. dim_tot, tot = ID_twoNN_dadapy(r,twonn=False, scale_dependent=True, **kwargs)
  553. # compute and return the four dimensions
  555. res = np.array([dim_beg, dim_mid, dim_fin, dim_tot])
  557. self.dim_twonn_scale_regions = res
  559. if display:
  560. if "beg" in locals():
  561. fig, axs = plt.subplots(2, 2, figsize=(12, 7))
  562. axs[0, 0].errorbar(beg[1], beg[0], yerr=beg[2], marker="o", capsize=4)
  563. axs[0, 0].set_title(f"Beginning dimension")
  564. #axs[0, 0].set_xscale("log")
  565. axs[0, 0].grid(axis="y")
  567. if "mid" in locals():
  568. axs[0, 1].errorbar(mid[1], mid[0], yerr=mid[2], marker="o", capsize=4)
  569. axs[0, 1].set_title(f"Middle dimension")
  570. #axs[0, 1].set_xscale("log")
  571. axs[0, 1].grid(axis="y")
  573. if "fin" in locals():
  574. axs[1, 0].errorbar(fin[1], fin[0], yerr=fin[2], marker="o", capsize=4)
  575. axs[1, 0].set_title(f"Final dimension")
  576. #axs[1, 0].set_xscale("log")
  577. axs[1, 0].grid(axis="y")
  579. axs[1, 1].errorbar(tot[1], tot[0], yerr=tot[2], marker="o", capsize=4)
  580. axs[1, 1].set_title(f"Total dimension")
  581. #axs[1, 1].set_xscale("log")
  582. axs[1, 1].grid(axis="y")
  584. plt.show()
  586. return res, dim_beg, dim_mid, dim_fin, dim_tot
  588. def find_dim(self, dim):
  590. # find the dimension from the plateaux in the scale dependent ID
  591. plateaus, _, _ = find_plateaus(dims, min_length=2, tolerance = 0.3)
  593. if len(plateaus) > 0:
  594. means = []
  595. for p in plateaus:
  596. means.append(np.mean(dims[p[0]:p[1]]))
  597. p_dim = np.min(means)
  598. else:
  599. p_dim = ids_scaling[-1]
  601. return p_dim

task_handler2.py at commit 8fd202d, under MIT · at the source

Overview

Authors: Jacopo Fadanni1, Rosalba Pacelli2, Alberto Zucchetta2, Pietro Rotondo3, Michele Allegra1,4
ORCID iDs: Jacopo Fadanni, Michele Allegra
  1. Physics and Astronomy Department, University of Padova, Padova, Italy
  2. Istituto Nazionale di Fisica Nucleare, Sezione di Padova, Padova, Italy
  3. Department of Mathematical, Physical and Computer Sciences, University of Parma, Parma, Italy
  4. Padova Neuroscience Center, University of Padova, Padova, Italy
Institutions: University of Padua (Italy); Istituto Nazionale di Fisica Nucleare, Sezione di Padova (Italy); University of Parma (Italy)
Journal: PLoS computational biology, volume 22, issue 4, article e1014162
Dates: received 18 September 2025; accepted 23 March 2026; published online 3 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pcbi.1014162 · PMID 41931565 · PMCID PMC13068349 · OpenAlex W7148705637
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), computational (subfield)
Methods: Connectivity, Smoothing, state filtering, decompositions, Statistics, Machine learning, Single-unit activity, calcium imaging
MeSH: Models, Neurological*, Neurons*, Algorithms, Animals, Computational Biology, Humans, Neural Networks, Computer, Recurrent Neural Networks (* major topic)
Journal subjects: Physical sciences, Mathematics, Geometry, Non-Euclidean geometry, Topology, Manifolds, Biology and Life Sciences, Cell Biology, Cellular Types, Animal Cells, Neurons, Neuroscience, Cellular Neuroscience, Research and Analysis Methods, Mathematical and Statistical Techniques, Statistical Methods, Multivariate Analysis, Principal Component Analysis, Statistics, Cognitive Science, Cognitive Psychology, Perception, Sensory Perception, Vision, Psychology, Social Sciences, Tangents, Curvature, Computer and Information Sciences, Neural Networks, Recurrent Neural Networks
Topic: Face Recognition and Perception (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: MUR (PRIN grant 2022HSKLK9)
Citations: not cited yet (Europe PMC); 82 references in the paper

Abstract

The rapid surge in the number of simultaneously recorded neurons demands reliable tools to explore the latent geometry of high-dimensional neural spaces. Within such spaces, neuronal activity typically lies on a subspace or manifold characterized by an intrinsic dimension (ID) that is much lower than the total number of recorded units. The ID can provide immediate information about the neural code, such as the minimum number of encoded variables and the relation between collective and individual neural activity. Existing studies rely on disparate and potentially unreliable ID estimators, which can contribute to conflicting reports of high-dimensional vs. low-dimensional manifolds. Here, we propose a robust and versatile pipeline for ID estimation, exploiting a local version of the full correlation integral estimator (lFCI). Being able to simultaneously cope with high dimensionality and non-linearity, lFCI overcomes some major limitations of common ID estimation methods. We prove the strength and accuracy of lFCI by applying it to synthetic benchmark data by Altan et al., 2019, where other methods typically underestimate the ID. We apply lFCI to study neural manifolds arising in recurrent neural networks trained on the 20 tasks of the well-known ‘cog-Task’ battery. Across tasks and training repetitions, lFCI uncovers a consistently low ID, which we show to be fundamentally related to the task structure. Finally, we apply lFCI to a reference experimental dataset by Stringer et al., 2019, comprising visual responses to a large set of natural images, strongly supporting previous reports that responses are organized in a high-dimensional manifold. lFCI has the potential to shed light on the current debate about the geometry of neural codes, and its dependence on structural constraints and computational goals in biological and artificial neural networks.

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

Repository

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

JFadanni/ExploringNeuralManifolds

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 8fd202d5ef149c5b77e1cc25cd06863f849422eb, 21 September 2026
Languages: Python (10), Jupyter (5), Shell (1)
Size: 20 files, 16 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: README, license file, 5 notebooks
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (14 files), Matplotlib (11 files), h5py (10 files), SciPy (8 files), scikit-learn (7 files), pandas (1 file), TensorFlow (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
18 files
At the source: github.com/JFadanni/ExploringNeuralManifolds.git

The paper's code and data availability statement is in the Data section.

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;
  • 16 scripts, each with its path and the digest of its content;
  • 1 match 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

The source code and data used to produce the results and analyses presented in this manuscript are available on GitHub: https://github.com/JFadanni/ExploringNeuralManifolds.git.

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

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 8 MeSH terms, 1 funder, 62 references.

Cite

This paper

Fadanni, J., Pacelli, R., Zucchetta, A., Rotondo, P., & Allegra, M. (2026). Exploring neural manifolds across a wide range of intrinsic dimensions. PLoS computational biology, 22(4), e1014162. https://doi.org/10.1371/journal.pcbi.1014162

BibTeX

@article{fadanni2026exploring,
author = {Fadanni, Jacopo and Pacelli, Rosalba and Zucchetta, Alberto and Rotondo, Pietro and Allegra, Michele},
title = {{Exploring neural manifolds across a wide range of intrinsic dimensions}},
journal = {PLoS computational biology},
year = {2026},
month = apr,
volume = {22},
number = {4},
pages = {e1014162},
publisher = {PLOS},
issn = {1553-734X},
doi = {10.1371/journal.pcbi.1014162},
url = {https://doi.org/10.1371/journal.pcbi.1014162},
pmid = {41931565},
pmcid = {PMC13068349}
}

RIS

TY - JOUR
AU - Fadanni, Jacopo
AU - Pacelli, Rosalba
AU - Zucchetta, Alberto
AU - Rotondo, Pietro
AU - Allegra, Michele
TI - Exploring neural manifolds across a wide range of intrinsic dimensions
T2 - PLoS computational biology
J2 - PLoS Comput Biol
PY - 2026
DA - 2026/04/03
VL - 22
IS - 4
SP - e1014162
SN - 1553-734X
PB - PLOS
DO - 10.1371/journal.pcbi.1014162
UR - https://doi.org/10.1371/journal.pcbi.1014162
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pcbi.1014162",
"type": "article-journal",
"title": "Exploring neural manifolds across a wide range of intrinsic dimensions",
"container-title": "PLoS computational biology",
"author": [
{
"family": "Fadanni",
"given": "Jacopo"
},
{
"family": "Pacelli",
"given": "Rosalba"
},
{
"family": "Zucchetta",
"given": "Alberto"
},
{
"family": "Rotondo",
"given": "Pietro"
},
{
"family": "Allegra",
"given": "Michele"
}
],
"container-title-short": "PLoS Comput Biol",
"volume": "22",
"issue": "4",
"page": "e1014162",
"DOI": "10.1371/journal.pcbi.1014162",
"PMID": "41931565",
"PMCID": "PMC13068349",
"ISSN": "1553-734X",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pcbi.1014162",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
3
]
]
}
}

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/s41593-026-02333-w [code]
Learning shapes neural geometry in the primate prefrontal cortex.
Journal: Nature neuroscience
In common: scikit-learn, pandas, SciPy, 2 other tools, 8 references
[2] doi:10.1080/26941899.2026.2619222
Neurodatascience: Past, Present, and Future.
Journal: Data science in science
In common: computational, 10 references
[3] doi:10.3390/biomimetics11080569 [code]
Pretraining of Embodied Recurrent Networks Bridges the Gap Between Artificial and Cortical Neural Activities.
Journal: Biomimetics (Basel, Switzerland)
In common: scikit-learn, SciPy, Matplotlib, 1 other tool, 8 references
[4] doi:10.1371/journal.pbio.3003831 [code]
Disinhibitory signaling enables flexible coding of top-down information in cortical networks.
Journal: PLoS biology
In common: TensorFlow, h5py, scikit-learn, 4 other tools, 5 references
[5] doi:10.1038/s41598-026-55225-1 [code]
Benchmarking criteria to determine latent linear dimensionality in neural data.
Journal: Scientific reports
In common: pandas, 9 references
[6] doi:10.1177/26331055261460858 [code]
The Geometric Signatures of Brain State Transitions: Recursive Informational Curvature Reveals Hidden Dynamics in Primate Cortex.
Journal: Neuroscience insights
In common: scikit-learn, pandas, SciPy, 2 other tools, 7 references
[7] doi:10.1016/j.neuron.2026.07.016 [code]
Inferring brain-wide interactions using data-constrained recurrent neural network models.
Journal: Neuron
In common: Matplotlib, NumPy, 8 references
[8] doi:10.1038/s41467-026-75924-7 [code]
Data-driven reduced modeling of neural dynamics.
Journal: Nature communications
In common: h5py, scikit-learn, SciPy, 2 other tools, 6 references
[9] doi:10.1038/s41467-026-76104-3 [code]
Sensorimotor remapping drives task specialization in prefrontal cortex.
Journal: Nature communications
In common: scikit-learn, pandas, SciPy, 2 other tools, 5 references
[10] doi:10.1038/s41467-026-74347-8 [code]
Compositionality of social gaze in the prefrontal-amygdala circuits.
Journal: Nature communications
In common: scikit-learn, pandas, SciPy, 2 other tools, 5 references

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.