OSCR

Prioritized nonlinear modeling of shared dynamics across neural populations.

Code ↔ Paper

7 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 7 matches
  1. [1] § Methods › Testing the nonlinearity in cross-population model components ↔ CroP-DYNO/source/CroPDYNO/example/CroPDYNO_tutorial.ipynb, lines 246 to 273 · score 0.84 · candidate configurations, fold inner cross, nonlinearity configuration, hidden layer, cross population prediction, validation · Report a mismatch
  2. [2] § Methods › Testing the nonlinearity in cross-population model components ↔ CroP-DYNO/source/DPAD/example/DPAD_tutorial2.ipynb, lines 1 to 329 · score 0.73 · fold inner cross, selected configuration, inner validation, nonlinearity configuration, hidden layer, hidden units · Report a mismatch
  3. [3] § Methods › Testing the nonlinearity in cross-population model components ↔ CroP-DYNO/source/DPAD/tools/flexible.py, lines 4736 to 4807 · score 0.71 · multilayer perceptrons, hidden layer, hidden units, MLPs, linear, DYNO · Report a mismatch
  4. [4] § Methods › Testing the nonlinearity in cross-population model components ↔ CroP-DYNO/source/CroPDYNO/example/CroPDYNO_tutorial.ipynb, lines 246 to 273 · score 0.60 · inner cross validation, nonlinearity configuration, candidate, flexible, fold, CroP · Report a mismatch
  5. [5] § Methods › Neural recordings, behavioral tasks, and data preprocessing ↔ CroP-DYNO/source/DPAD/tools/GaussianSmoother.py, lines 7 to 54 · score 0.58 · Gaussian kernel, standard deviation, smoothed · Report a mismatch
  6. [6] § Methods › Neural recordings, behavioral tasks, and data preprocessing ↔ CroP-DYNO/source/DPAD/example/DPAD_tutorial2.ipynb, lines 535 to 649 · score 0.53 · Gaussian kernel, downsampled, bins, spiking, smoothed, behavioral · Report a mismatch
  7. [7] § Methods › Testing the nonlinearity in cross-population model components ↔ CroP-DYNO/source/DPAD/example/DPAD_tutorial.ipynb, lines 210 to 257 · score 0.53 · hidden layer, hidden units, MLPs, nonlinear, training, neural · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Jupyter notebook · 323 lines · 14 KB · no license · 2 matches

  1. # %% [markdown]
  2. # Written by: Trisha Jha
  3. #
  4. # Last update: Jul, 2026
  6. # %% [markdown]
  7. # # CroP-DYNO Tutorial
  8. #
  9. # ## Overview
  10. # CroP-DYNO (cross-population prioritized dynamical nonlinear interaction model) is a method for nonlinear dynamical modeling of interactions between two simultaneously recorded neural populations. Given the activity of a source population Y and a target population Z, CroP-DYNO learns a dynamical model of population Y while prioritizing the dynamics that are shared with population Z. For more details, see our manuscript: Jha T, Song D and Shanechi M M 2026 Prioritized nonlinear
  11. # modeling of shared dynamics across neural populations *J. Neural Eng.*
  12. # https://doi.org/10.1088/1741-2552/ae9bee
  13. #
  14. # CroP-DYNO's implementation is derived from the [DPAD](https://github.com/ShanechiLab/DPAD) codebase (Sani, Pesaran, and Shanechi, *Nature Neuroscience*, 2024).
  15. #
  16. # ## Model
  17. # Given the activity of a source population, $y_k$, and a target population, $z_k$, CroP-DYNO learns a latent state $x_k$, composed of two components: $x_k^{(1)}$, the dynamics shared between populations Y and Z, and $x_k^{(2)}$, the within-population Y dynamics not shared with population Z. The model is formulated as:
  18. #
  19. # $$ x_{k+1} = A'(x_k) + K(y_k) $$
  20. #
  21. # $$ y_k = C_y(x_k) + e_k $$
  22. #
  23. # $$ z_k = C_z(x_k) + \epsilon_k $$
  24. #
  25. # Multi-input multi-output functions $A'$ (latent state dynamics), $K$ (mapping from source population Y activity to latent states), $C_y$ (source population Y readout), and $C_z$ (target population Z readout) define the model. CroP-DYNO allows the user to flexibly set any of these four mappings to be linear or nonlinear, which in turn enables testing hypotheses about where nonlinearity in the cross-population interaction originates.
  26. #
  27. # *Note: in the CroP-DYNO paper these two populations are referred to as population A and population B; here we call them population Y and population Z to match the naming used in the code below.*
  29. # %% [markdown]
  30. # # Using CroP-DYNO
  31. # ## Modeling data
  32. # To use CroP-DYNO, import the model class:
  33. # ```python
  34. # from CroPDYNO.CroPDYNOModel import CroPDYNOModel
  35. # ```
  36. #
  37. # You can then use it to model cross-population data as:
  38. # ```python
  39. # idSys = CroPDYNOModel()
  40. # methodCode = 'CroPDYNO_Cz1HL64U' # Only Cz (the target-population Z readout) will be nonlinear, 1 Hidden layer with 64 Units.
  41. # args = CroPDYNOModel.prepare_args(methodCode)
  42. # idSys.fit(Y=yTrain, Z=zTrain, nx=6, n1=2, **args)
  43. # ```
  44. #
  45. # With the following arguments:
  46. # - `Y`: Source population Y activity. Dimensions are: data x time.
  47. # - `Z`: Target population Z activity, i.e. the cross-population prediction objective. Dimensions are: data x time.
  48. # - `nx`: the total dimension of the latent state in the model.
  49. # - `n1`: the number of latent state dimensions dedicated to shared cross-population dynamics ($x_k^{(1)}$).
  50. # - `args`: other arguments specifying which mappings are linear vs. nonlinear.
  51. #
  52. # `CroPDYNOModel.prepare_args` takes a `methodCode` string and returns the arguments to pass to `idSys.fit`. In the example above, `methodCode` is `'CroPDYNO_Cz1HL64U'`, which makes only $C_z$ nonlinear while $A'$, $K$, and $C_y$ remain linear. You can inspect the output of `CroPDYNOModel.prepare_args` to see how the architecture of each mapping is specified.
  53. #
  54. # After running the above, the learned model is stored in the object `idSys`.
  55. #
  56. # ## Using the model for cross-population prediction and self-prediction
  57. # For a learned model `idSys`, use `predict` to extract the latent state and predict both populations' activity given new source population Y activity:
  58. # ```python
  59. # zPred, yPred, xPred = idSys.predict(yTest)
  60. # ```
  61. # With the argument:
  62. # - `yTest`: Source population Y activity in the test data. Dimensions are: time x data dimension.
  63. #
  64. # And with outputs (all dimensions are time x data dimension):
  65. # - `zPred`: Prediction of target population Z activity from past source population Y activity (i.e., cross-population prediction).
  66. # - `yPred`: Self-prediction of source population Y activity from its own past.
  67. # - `xPred`: The latent state extracted at each time point.
  68. #
  69. # Note that inference only requires source population Y activity, consistent with CroP-DYNO's design for settings where only one population is accessible at inference time.
  70. #
  71. # We next go through a complete worked example on simulated data.
  73. # %% [markdown]
  74. # # Example: CroP-DYNO on simulated cross-population data
  75. # In this example, we use CroP-DYNO to model simulated data from a system with a known ground-truth model, and evaluate cross-population prediction performance against that ground truth. We use a simulated dataset where only $C_z$ is nonlinear. Both populations are multi-channel (3 channels each).
  76. #
  77. # First, we import CroP-DYNO and a few other useful tools.
  79. # %%
  80. # CroP-DYNO requires Python 3.11 (see the repository README for setup).
  81. # This prints your Python version as a quick check.
  82. !python --version
  85. # %%
  86. import logging
  87. import os
  88. import sys
  90. sys.path.insert(0, os.path.join("..", ".."))
  91. sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath("")), "..", ".."))
  93. # Setting up logs
  94. logging.basicConfig(level=logging.INFO)
  95. logger = logging.getLogger(__name__)
  97. import coloredlogs
  99. coloredlogs.install(
  100. level=logging.INFO,
  101. fmt="%(asctime)s %(name)s [%(filename)s > %(lineno)s] %(levelname)s %(message)s",
  102. datefmt="%Y-%m-%d %H:%M:%S",
  103. logger=logger,
  104. )
  106. # Prepare plots
  107. import matplotlib
  108. import matplotlib.pyplot as plt
  109. import numpy as np
  111. matplotlib.rcParams["figure.facecolor"] = "w"
  112. matplotlib.rcParams["axes.facecolor"] = "w"
  113. matplotlib.rcParams.update(
  114. {"font.size": 16, "axes.titlesize": 14, "axes.labelsize": 14}
  115. )
  117. # Import CroP-DYNO and supporting tools
  118. import CroPDYNO
  119. from CroPDYNO.CroPDYNOModel import CroPDYNOModel
  120. from CroPDYNO.tools.evaluation import evalPrediction
  121. from CroPDYNO.tools.file_tools import pickle_load
  123. # Set random seeds for exact reproducibility
  124. seed = 42
  125. import random
  127. import tensorflow as tf
  129. random.seed(seed)
  130. np.random.seed(seed)
  131. tf.random.set_seed(seed)
  134. # %% [markdown]
  135. # Let's load data from an example ground-truth model where $C_z$ is nonlinear. We treat the first signal as source population Y activity ($y_k$) and the second signal as target population Z activity ($z_k$):
  137. # %%
  138. # Load data
  140. data_dir = os.path.join(os.path.dirname(CroPDYNO.__file__), "..", "..", "data")
  141. fName = "sample_data.p"
  143. sample_data_path = os.path.join(data_dir, fName)
  145. print("Loading example data from {}".format(sample_data_path))
  146. data = pickle_load(sample_data_path)
  147. # This data is from a ground-truth model with a nonlinear Cz.
  149. maxN = int(2 * 1e4) # Number of time points to use in this notebook
  150. N = np.min((maxN, data["y"].shape[0]))
  151. y = data["y"][:N, :] # Source population Y activity
  152. z = data["z"][:N, :] # Target population Z activity
  153. trueModel = data["csys"] # The object containing the true simulated model
  155. n1 = len(
  156. trueModel.zDims
  157. ) # The number of latent state dimensions shared with population Z (cross-population states)
  159. nx = n1 # Only running stage 1 (extract cross-population states); set nx > n1 to also learn residual within-population Y dynamics
  161. allYData, allZData = y, z
  164. # %% [markdown]
  165. # Let's separate the data into training and test segments.
  167. # %%
  168. # Separate data into training and test data:
  169. trainInds = np.arange(np.round(0.9 * allYData.shape[0]), dtype=int)
  170. testInds = np.arange(1 + trainInds[-1], allYData.shape[0])
  171. yTrain = allYData[trainInds, :]
  172. yTest = allYData[testInds, :]
  173. zTrain = allZData[trainInds, :]
  174. zTest = allZData[testInds, :]
  177. # %% [markdown]
  178. # ## Section 1: Ideal vs. nonlinear $C_z$ vs. linear CroP-DYNO
  179. #
  180. # Training the model. We fit CroP-DYNO with the ground-truth latent dimensions, using a nonlinear readout for population Z ($C_z$) and keeping the other three mappings linear:
  182. # %%
  183. # Fit CroP-DYNO to the training data:
  184. idSys = CroPDYNOModel()
  186. methodCode = "CroPDYNO_Cz1HL64U_ErSV16_skipCy"
  187. #ErSV16: changes early stopping to 16 epochs, based on an inner validation set (last 20% of the training data). Without this, by default early stopping is 3 epochs and based on training loss.
  188. #skipCy: skip fitting Cy parameter as it is not relevant to cross-region prediction (save time for this tutorial)
  190. args = CroPDYNOModel.prepare_args(methodCode)
  192. epochs = 2000
  194. idSys.fit(Y=yTrain.T, Z=zTrain.T, nx=nx, n1=n1, epochs=epochs, **args)
  197. # %% [markdown]
  198. # Inference on test data and computing cross-population prediction performance. Inference uses only source population Y activity, consistent with CroP-DYNO's causal inference from the source population:
  200. # %%
  201. # Inference:
  202. print("Computing predictions for the learned model")
  203. zTestPred, yTestPred, xTestPred = idSys.predict(yTest)
  205. # Compute CC of cross-population prediction (z from y)
  206. zCC = evalPrediction(zTest, zTestPred, "CC")
  208. # For comparison, do the same using the true model
  209. print("Computing predictions for the true model (slower due to the analytical symbolic implementation of nonlinearity)")
  210. zTestPredIdeal, yTestPredIdeal, xTestPredIdeal = trueModel.predict(yTest)
  211. zCCIdeal = evalPrediction(zTest, zTestPredIdeal, "CC")
  214. print(
  215. f"Cross-population prediction (Z from Y) CC:\n"
  216. f" CroP-DYNO (Cz nonlinear) => {np.mean(zCC):.3g}\n"
  217. f" Ideal using true model => {np.mean(zCCIdeal):.3g}"
  218. )
  220. # %% [markdown]
  221. # ## Comparison to a fully linear CroP-DYNO model
  222. #
  223. # As a baseline, we also fit a fully linear CroP-DYNO model (all mappings linear) to see how much the nonlinear $C_z$ actually helps cross-population prediction.
  225. # %%
  226. # Fit a fully linear CroP-DYNO model
  227. methodCode = "CroPDYNO_ErSV16_skipCy" # No nonlinearity terms; ErSV16 (early stopping) and skipCy still apply
  229. idSysLin = CroPDYNOModel()
  230. argsLin = CroPDYNOModel.prepare_args(methodCode)
  231. idSysLin.fit(Y=yTrain.T, Z=zTrain.T, nx=nx, n1=n1, epochs=epochs, **argsLin)
  233. # Inference and cross-population prediction CC
  234. print("Computing predictions for the linear model")
  235. zTestPredLin, yTestPredLin, xTestPredLin = idSysLin.predict(yTest)
  236. zCCLin = evalPrediction(zTest, zTestPredLin, "CC")
  240. print(
  241. f"Cross-population prediction (Z from Y) CC:\n"
  242. f" Linear CroP-DYNO => {np.mean(zCCLin):.3g}\n"
  243. f" CroP-DYNO (Cz nonlinear) => {np.mean(zCC):.3g}"
  244. )
  246. # %% [markdown]
  247. # ## Section 2: Flexible CroP-DYNO — automatically searching for the best nonlinearity
  248. #
  249. # Above, we manually chose `'CroPDYNO_Cz1HL64U_ErSV16_skipCy'`, i.e., we assumed only $C_z$ should be nonlinear. Instead of guessing, flexible CroP-DYNO can search over which of the three mappings relevant to cross-population prediction ($A'$, $K$, $C_z$) should be linear vs. nonlinear. It does so by using an inner cross-validation on the training data, and picks the configuration that best predicts population Z. This runs in two steps: (1) search for the best nonlinearity configuration, then (2) fit one final model on all training data using that configuration.
  251. # %%
  252. # Step 1: search for the best nonlinearity configuration via inner cross-validation
  253. from CroPDYNO.tools.flexible import fitCroPDYNOWithFlexibleNonlinearity
  255. settings = {}
  256. settings["min_cores_to_enable_parallelization"] = 100 # If fewer cores than this are available, runs will not be parallelized
  258. settings["fit_epochs"] = 2000 # Same max-epochs cap as above; fitting stops early upon convergence
  260. # Search space: A', K, and Cz each tried as linear (0 hidden layers) or nonlinear (1 hidden layer, 64 units) => 2^3 = 8 cases
  261. # (Cy is not searched here and is skipped as it is not relevant for cross-region prediction),
  262. # selected via 2-fold inner cross-validation (iCVF2) on cross-population (z) prediction
  263. methodCode = "CroPDYNO_GSUT_iCVF2_AKCz1HL64U_ErSV16_skipCy"
  266. saveDir = os.path.join("results") # Where the inner cross-validation results are saved
  268. # Typical runtime: sum (no parallelization) or max (full parallelization) of run time across the 8 candidate configurations
  269. selectedMethodCode, iCVRes = fitCroPDYNOWithFlexibleNonlinearity(
  270. yTrain, Z=zTrain, nx=nx, n1=n1, settings=settings, methodCode=methodCode, saveDir=saveDir
  271. )
  273. print(f"\n\nSelected nonlinearity setting: {selectedMethodCode}")
  276. # %% [markdown]
  277. # The flexible search found that $C_z$-only is the best nonlinearity configuration. This means the flexible search works as intended; it recovered the correct configuation. Next, we can fit a final model on all the training data using this selected configuration.
  279. # %%
  280. # Step 2: fit one final model on all training data using the selected nonlinearity configuration
  281. idSysFlex = CroPDYNOModel()
  282. argsFlex = CroPDYNOModel.prepare_args(selectedMethodCode)
  283. idSysFlex.fit(Y=yTrain.T, Z=zTrain.T, nx=nx, n1=n1, epochs=epochs, **argsFlex)
  285. # Inference and cross-population prediction CC
  286. print("Computing predictions for the flexible model")
  287. zTestPredFlex, yTestPredFlex, xTestPredFlex = idSysFlex.predict(yTest)
  288. zCCFlex = evalPrediction(zTest, zTestPredFlex, "CC")
  290. print(
  291. f"Cross-population prediction (Z from Y) CC:\n Flexible CroP-DYNO ({selectedMethodCode}) => {np.mean(zCCFlex):.3g}"
  292. )
  296. # %% [markdown]
  297. # ## Section 3: Causal vs. noncausal (smoothing) CroP-DYNO
  298. #
  299. # So far, every model has been causal in time: prediction of $z_k$ only uses past activity of population Y. CroP-DYNO can also run noncausally (smoothing), where the RNN is bidirectional and estimates $z_k$ using both past *and future* activity of population Y. This is no longer causal in time, as it requires the full Y activity, but it can improve prediction accuracy.
  300. #
  301. # Adding `_xSmth` to the `methodCode` string enables this bidirectional/noncausal mode. To isolate the effect of causal vs. noncausal on its own, we keep everything else the same as our original ground-truth-nonlinearity model (only $C_z$ nonlinear) and compare below.
  303. # %%
  304. # Fit the noncausal (smoothing) counterpart of our original nonlinear-Cz model:
  305. methodCode = "CroPDYNO_Cz1HL64U_ErSV16_skipCy_xSmth" # now noncausal (smoothing)
  307. idSysSmth = CroPDYNOModel()
  308. argsSmth = CroPDYNOModel.prepare_args(methodCode)
  309. idSysSmth.fit(Y=yTrain.T, Z=zTrain.T, nx=nx, n1=n1, epochs=epochs, **argsSmth)
  312. # %%
  313. # Inference and cross-population prediction CC
  314. print("Computing predictions for the noncausal (smoothing) model")
  315. zTestPredSmth, yTestPredSmth, xTestPredSmth = idSysSmth.predict(yTest)
  316. zCCSmth = evalPrediction(zTest, zTestPredSmth, "CC")
  318. print(
  319. f"Cross-population prediction (Z from Y) CC:\n"
  320. f" CroP-DYNO (Cz nonlinear, causal) => {np.mean(zCC):.3g}\n"
  321. f" CroP-DYNO (Cz nonlinear, noncausal/smoothing) => {np.mean(zCCSmth):.3g}"
  322. )

CroPDYNO_tutorial.ipynb at commit 762f351, no license · at the source

Overview

Authors: Trisha Jha1, Dong Song2,3, Maryam M Shanechi1,3,4
ORCID iDs: Trisha Jha, Dong Song, Maryam M Shanechi
  1. Ming Hsieh Department of Electrical and Computer Engineering, Viterbi School of Engineering, University of Southern California, Los Angeles, CA, United States of America
  2. Department of Neurological Surgery, University of Southern California, Los Angeles, CA, United States of America
  3. Alfred E. Mann Department of Biomedical Engineering, University of Southern California, Los Angeles, CA, United States of America
  4. Thomas Lord Department of Computer Science, Neuroscience Graduate Program, University of Southern California, Los Angeles, CA, United States of America
Institutions: University of Southern California (United States)
Journal: Journal of neural engineering, volume 23, issue 5, article 056054
Dates: received 22 May 2026; accepted 19 August 2026; published online 16 October 2026; in print 1 October 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1088/1741-2552/ae9bee · PMID 42617643 · PMCID PMC13673170 · OpenAlex W7203780094
Open access: hybrid, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: systems (subfield)
Methods: Connectivity, Statistics, Machine learning, Preprocessing
Keywords: multiregional modeling, nonlinear dynamical models, RNNs, filtering, smoothing
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: NSF CRCNS (IIS 2113271); national institutes of health (R01MH123770, R61MH135407, RF1DA056402)
Citations: not cited yet (OpenAlex); 134 references in the paper

Abstract

Objective. Advances in neural recording technology enable simultaneous measurements across multiple brain regions, providing new opportunities to study inter-regional interactions. However, several challenges arise when developing nonlinear dynamical models of cross-region interactions. In particular, we identify three key desired properties for a nonlinear framework. First, it should prioritize extraction of cross-region dynamics to avoid confounds from within-region dynamics. Second, it should enable localization of nonlinear structure within the model to better interpret cross-regional interaction models. Third, it should support both temporally causal and non-causal inference of shared dynamics and do so using source region activity alone. Current cross-regional models do not satisfy all these properties. Approach. Here, we address these challenges by developing cross-population prioritized dynamical nonlinear interaction model (CroP-DYNO), a nonlinear dynamical framework that prioritizes the learning of shared cross-population dynamics to avoid confounds from within-population activity. Further, CroP-DYNO allows individual components of the dynamical model to be independently specified as nonlinear or linear. Finally, it supports both temporally causal and non-causal inference of latent states, using only source region activity. Main results. We validate our method on datasets across species and distinct brain regions. We find that both the prioritized learning and the nonlinear modeling in CroP-DYNO are important for accurately extracting cross-population dynamics. As such, CroP-DYNO outperforms baseline nonprioritized and linear prioritized models in predicting target neural population activity from source activity. Further, CroP-DYNO enables systematic localization of nonlinear structure and quantifies dominant predictive interactions between brain regions, with interaction strengths that align with known circuit anatomy. Significance. Overall, these results establish CroP-DYNO as a flexible nonlinear framework for studying interactions between neural populations and brain regions, enabling both accurate modeling and interpretable dissection of nonlinear structure in cross-regional communication models.

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 7 matches between paragraphs and lines of code.

ShanechiLab/CroP

License: none: the authors keep all their rights
State: the link answers, verified on 24 October 2026
Evidence: files inventoried
Commit: 762f351a51b087e5b344d0a5a5d5b3506a619494, 8 September 2026
Languages: Python (83), Jupyter (6)
Size: 105 files, 89 scripts
Software Heritage: not archived
Found in: “Code availability statement”
Holds: README, environment (CroP-DYNO/requirements.txt, CroP-LDM/requirements.txt, CroP-DYNO/source/setup.py, CroP-LDM/source/setup.py), tests, 6 notebooks
Not found: license file, CITATION.cff, continuous integration, documentation
Tools: NumPy (46 files), SciPy (17 files), Matplotlib (15 files), TensorFlow (11 files), scikit-learn (3 files), SymPy (3 files), Keras (2 files)
Availability: 1 check, the latest on 24 October 2026: the link answers
  • 24 October 2026: the link answers
90 files
At the source: github.com/ShanechiLab/CroP

Code availability statement

The code used to support the results is available at: https://github.com/ShanechiLab/CroP.

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:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 89 scripts, each with its path and the digest of its content;
  • 7 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 main data supporting the results in this study are available within the paper. Raw data from Dataset 1 are publicly available as cited in the paper. Raw data from Dataset 2 are too large to be publicly shared, yet may be made available for research purposes from the corresponding author on reasonable request.

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, 24 October 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 3 authors, 5 keywords, 2 funders, 129 references.

Cite

This paper

Jha, T., Song, D., & Shanechi, M. M. (2026). Prioritized nonlinear modeling of shared dynamics across neural populations. Journal of neural engineering, 23(5), 056054. https://doi.org/10.1088/1741-2552/ae9bee

BibTeX

@article{jha2026prioritized,
author = {Jha, Trisha and Song, Dong and Shanechi, Maryam M},
title = {{Prioritized nonlinear modeling of shared dynamics across neural populations}},
journal = {Journal of neural engineering},
year = {2026},
month = oct,
volume = {23},
number = {5},
pages = {056054},
publisher = {IOP Publishing},
issn = {1741-2560},
doi = {10.1088/1741-2552/ae9bee},
url = {https://doi.org/10.1088/1741-2552/ae9bee},
pmid = {42617643},
pmcid = {PMC13673170}
}

RIS

TY - JOUR
AU - Jha, Trisha
AU - Song, Dong
AU - Shanechi, Maryam M
TI - Prioritized nonlinear modeling of shared dynamics across neural populations
T2 - Journal of neural engineering
J2 - J Neural Eng
PY - 2026
DA - 2026/10/16
VL - 23
IS - 5
SP - 056054
SN - 1741-2560
PB - IOP Publishing
DO - 10.1088/1741-2552/ae9bee
UR - https://doi.org/10.1088/1741-2552/ae9bee
LA - en
ER -

CSL-JSON

{
"id": "10.1088/1741-2552/ae9bee",
"type": "article-journal",
"title": "Prioritized nonlinear modeling of shared dynamics across neural populations",
"container-title": "Journal of neural engineering",
"author": [
{
"family": "Jha",
"given": "Trisha"
},
{
"family": "Song",
"given": "Dong"
},
{
"family": "Shanechi",
"given": "Maryam M"
}
],
"container-title-short": "J Neural Eng",
"volume": "23",
"issue": "5",
"page": "056054",
"DOI": "10.1088/1741-2552/ae9bee",
"PMID": "42617643",
"PMCID": "PMC13673170",
"ISSN": "1741-2560",
"publisher": "IOP Publishing",
"URL": "https://doi.org/10.1088/1741-2552/ae9bee",
"language": "en",
"issued": {
"date-parts": [
[
2026,
10,
16
]
]
}
}

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-024-01731-2 [code]
Dissociative and prioritized modeling of behaviorally relevant neural dynamics using recurrent neural networks.
Journal: Nature neuroscience
In common: SymPy, Keras, TensorFlow, 4 other tools, 25 references, author Maryam M Shanechi
[2] doi:10.1088/1741-2552/ad1053 [code]
Multimodal subspace identification for modeling discrete-continuous spiking and field potential population activity.
Journal: Journal of neural engineering
In common: 28 references, author Maryam M Shanechi
[3] doi:10.1073/pnas.2212887121 [code]
Modeling and dissociation of intrinsic and input-driven neural population dynamics underlying behavior.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: scikit-learn, SciPy, Matplotlib, 1 other tool, systems, 21 references, author Maryam M Shanechi
[4] doi:10.1088/1741-2552/ad038d [code]
Unsupervised learning of stationary and switching dynamical system models from Poisson observations.
Journal: Journal of neural engineering
In common: 19 references, author Maryam M Shanechi
[5] doi:10.1038/s41551-023-01106-1 [code]
Dynamical flexible inference of nonlinear latent factors and structures in neural population activity.
Journal: Nature biomedical engineering
In common: scikit-learn, SciPy, Matplotlib, 1 other tool, systems, 18 references, author Maryam M Shanechi
[6] doi:10.1038/s41467-026-71725-0 [code]
Interactions across hemispheres in prefrontal cortex reflect global cognitive processing.
Journal: Nature communications
In common: scikit-learn, SciPy, Matplotlib, 1 other tool, 13 references
[7] doi:10.1038/s41467-025-59652-y [code]
Stabilizing brain-computer interfaces through alignment of latent dynamics.
Journal: Nature communications
In common: Keras, TensorFlow, scikit-learn, 3 other tools, systems, 8 references
[8] doi:10.1088/1741-2552/ad88a4 [code]
Reducing power requirements for high-accuracy decoding in iBCIs.
Journal: Journal of neural engineering
In common: scikit-learn, SciPy, Matplotlib, 1 other tool, systems, 8 references
[9] 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, systems, 10 references
[10] doi:10.1038/s41586-023-06714-0 [code]
Preserved neural dynamics across animals performing similar behaviour.
Journal: Nature
In common: scikit-learn, SciPy, Matplotlib, 1 other tool, systems, 8 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.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1088/1741-2552/ae9bee.svg)](https://openscicode.org/badge/doi/10.1088/1741-2552/ae9bee)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1088/1741-2552/ae9bee.svg
   :target: https://openscicode.org/badge/doi/10.1088/1741-2552/ae9bee
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1088/1741-2552/ae9bee"><img src="https://openscicode.org/badge/doi/10.1088/1741-2552/ae9bee.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

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