OSCR

Multiple mechanisms of rhythm switching in recurrent neural networks with adaptive time constants.

Code ↔ Paper

30 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 30 matches
  1. [1] § Methods › Analysis methods › Causal silencing analysis ↔ analysis_ablation.py, lines 1 to 36 · score 0.95 · silenced subpopulations, random subsets, recurrent dynamics, firing rate, trained network, band power · Report a mismatch
  2. [2] § Results › Structural and dynamical basis: recurrent connectivity and gain modulation ↔ analysis_connectivity.py, lines 1 to 33 · score 0.93 · leak rates held, unstable eigenfrequency, Slowest relaxation, dynamical basis, Gain modulation, neuronal gain · Report a mismatch
  3. [3] § Methods › Analysis methods › Connectivity structure and linearized dynamics ↔ analysis_connectivity.py, lines 1 to 33 · score 0.90 · leak rates held, Connectivity structure, slowest relaxation, Gain modulation, timescale, intrinsic · Report a mismatch
  4. [4] § Results › Phase interference controls band power ↔ analysis_phase_coherence.py, lines 1 to 20 · score 0.80 · coherence ratio, amplitude suppression, phase interference, amplitude ratio, band amplitude, band power · Report a mismatch
  5. [5] § Appendix C Inter-mode population sharing and the learned time-constant distribution ↔ analysis_outlier_tau.py, lines 1 to 29 · score 0.80 · inter mode population, inter mode amplitude, median learned, pattern correlations, outliers, active · Report a mismatch
  6. [6] § Results › Robustness to time-constant initialization ↔ analysis_reinit_compare.py, lines 1 to 31 · score 0.78 · 5–300 ms, log uniform, matched mode amplitude, Spearman correlation, 5 ms, skewness · Report a mismatch
  7. [7] § Results › Inter-mode population similarity and run-to-run variability ↔ make_fig4_intermode.py, lines 1 to 16 · score 0.76 · Jaccard coefficient matrix, Spearman correlation matrix, Inter mode population, sync degree, mode amplitudes, variability · Report a mismatch
  8. [8] § Results › Baseline shifts drive rhythm switching ↔ analysis_baseline_fp.py, lines 435 to 556 · score 0.76 · eigenvalue magnitude, median amplitude, Baseline shift, oscillation amplitude, Power spectrum, peaks · Report a mismatch
  9. [9] § Appendix A Distribution of across training runs ↔ analysis_phase_coherence.py, lines 197 to 322 · score 0.74 · band coherence ratio, amplitude suppression, amplitude ratio, phase interference, classification · Report a mismatch
  10. [10] § Results › Phase interference controls band power ↔ analysis_phase_coherence.py, lines 1 to 20 · score 0.72 · coherence ratio, amplitude suppression, phase interference, amplitude ratio, band amplitude, classification · Report a mismatch
  11. [11] § Methods › Task ↔ train_once.py, lines 37 to 60 · score 0.71 · 8–13 Hz, 14–29 Hz, 30–50 Hz, 4–7 Hz, pulses, 30 Hz · Report a mismatch
  12. [12] § Methods › Task ↔ train_reinit.py, lines 43 to 61 · score 0.71 · 8–13 Hz, 14–29 Hz, 30–50 Hz, 4–7 Hz, pulses, 30 Hz · Report a mismatch
  13. [13] § Results › Fast neurons are the causal substrate of high-frequency rhythms ↔ analysis_ablation.py, lines 1 to 36 · score 0.71 · baseline contribution, firing rate, band power, fastest, shortest, clamped · Report a mismatch
  14. [14] § Appendix D Robustness to time-constant initialization ↔ analysis_reinit_compare.py, lines 1 to 31 · score 0.70 · 5–300 ms, log uniform, 5 ms, Gini, recurrent, baseline · Report a mismatch
  15. [15] § Results › Structural and dynamical basis: recurrent connectivity and gain modulation ↔ analysis_connectivity.py, lines 146 to 161 · score 0.70 · frequency retuning, dominant unstable, gain profile, gain modulation, connectivity, band · Report a mismatch
  16. [16] § Results › Structural and dynamical basis: recurrent connectivity and gain modulation ↔ analysis_connectivity.py, lines 60 to 91 · score 0.69 · slowest decaying, free dynamics, eigenmode, origin, connectivity, Linearizing · Report a mismatch
  17. [17] § Results › Phase interference controls band power ↔ analysis_phase_supfig.py, lines 59 to 80 · score 0.64 · log spaced bins, amplitude suppression, phase interference, Histogram, threshold · Report a mismatch
  18. [18] § Results › Frequency-dependent synchronization structure ↔ make_fig3_sync.py, lines 1 to 22 · score 0.63 · Absolute sync strength, synchronization structure, sync degree, ascending, matrix, Figure 3 · Report a mismatch
  19. [19] § Results › Inter-mode population similarity and run-to-run variability ↔ analysis_outlier_tau.py, lines 1 to 29 · score 0.60 · amplitude pattern correlation, Inter mode population, inter mode sharing, outliers, active, Jaccard · Report a mismatch
  20. [20] § Methods › Analysis methods › Baseline analysis: fixed-point search and stability analysis ↔ analysis_baseline_fp.py, lines 276 to 413 · score 0.58 · pre activation, power spectrum, simulation, baseline, oscillations, population · Report a mismatch
  21. [21] § Results › Frequency-dependent synchronization structure ↔ make_fig3_sync.py, lines 1 to 22 · score 0.58 · absolute sync strength, neurons sorted, ascending, synchronized, matrix · Report a mismatch
  22. [22] § Results › Phase interference controls band power ↔ analysis_phase_fig6.py, lines 1 to 27 · score 0.57 · phase interference mechanism, representative neuron, single neuron, transition, Figure 6, oscillation · Report a mismatch
  23. [23] § Methods › Analysis methods › Bandpass filtering and amplitude extraction ↔ analysis_phase_coherence.py, lines 29 to 67 · score 0.55 · Hilbert transform, bandpass filter · Report a mismatch
  24. [24] § Results › Fast neurons are the causal substrate of high-frequency rhythms ↔ analysis_ablation.py, lines 294 to 341 · score 0.55 · neuron silencing, oscillatory contribution, isolates, freeze, fast, causal · Report a mismatch
  25. [25] § Results › Baseline shifts drive rhythm switching ↔ analysis_baseline_fp.py, lines 435 to 556 · score 0.54 · low amplitude neurons, baseline shift, eigenvalue, scatter, activity, oscillation · Report a mismatch
  26. [26] § Results › Inter-mode population similarity and run-to-run variability ↔ make_fig4_intermode.py, lines 33 to 55 · score 0.53 · matched mode amplitude, correlation matrix, vectors, Spearman, Inter · Report a mismatch
  27. [27] § Methods › Analysis methods › Baseline analysis: fixed-point search and stability analysis ↔ analysis_baseline_fp.py, lines 276 to 413 · score 0.53 · pre activation, cluster, perturbations, baseline · Report a mismatch
  28. [28] § Methods › Analysis methods › Inter-mode population similarity ↔ make_fig4_intermode.py, lines 1 to 16 · score 0.53 · Jaccard coefficient, sync degree, Inter, population · Report a mismatch
  29. [29] § Methods › Analysis methods › Bandpass filtering and amplitude extraction ↔ analysis_phase_coherence.py, lines 70 to 97 · score 0.52 · Hilbert envelope, band amplitude, Bandpass, filtering, rhythm · Report a mismatch
  30. [30] § Methods › Analysis methods › Amplitude distribution statistics ↔ analysis_multiple.py, lines 93 to 138 · score 0.52 · Gini coefficient, matched mode amplitudes, skewness · 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

Python · 326 lines · 12 KB · MIT · 5 matches

  1. """
  2. Analysis for Sect. 3.6: phase-interference control of band power.
  4. For each of the 20 trained networks, the following quantities are computed:
  5. 1. Coherence ratio eta^(m,k) over all (mode, band) pairs (4 x 4 matrix).
  6. 2. Alpha-band amplitude ratio kappa_i = A_i^(alpha, beta mode) / A_i^(alpha, alpha mode).
  7. 3. Per-run classification: amplitude-suppression vs phase-interference type.
  8. """
  10. import os
  11. import sys
  12. import json
  13. import argparse
  14. import numpy as np
  15. from scipy import signal as sp_signal
  16. from function import *
  18. import matplotlib
  19. matplotlib.use('Agg')
  20. import matplotlib.pyplot as plt
  22. # GPU memory configuration
  23. gpus = tf.config.list_physical_devices('GPU')
  24. if gpus:
  25. for gpu in gpus:
  26. tf.config.experimental.set_memory_growth(gpu, True)
  29. def compute_coherence_ratio(r_split, rhythms, labels, Fs, cut_s=500):
  30. """
  31. Compute the coherence ratio eta^(m,k) over all (mode, band) pairs.
  32. eta = <R^(k)(t)>_t / <(1/N) sum_i A_i^(k)(t)>_t
  33. R^(k)(t) = |(1/N) sum_i A_i^(k)(t) exp(i phi_i^(k)(t))|
  35. Returns: (n_modes, n_bands) array.
  36. """
  37. n_modes = len(labels)
  38. units = r_split.shape[1]
  39. eta = np.zeros((n_modes, n_modes)) # eta[mode, band]
  41. band_names = list(rhythms.keys())
  43. for k_idx, band_name in enumerate(band_names):
  44. low, high = rhythms[band_name]
  45. # Band-pass filter
  46. filtered = bandpass_filter(r_split, low, high, Fs) # (n_modes, units, T)
  47. # Hilbert transform
  48. _, envelopes, phases = hilbert(filtered) # (n_modes, units, T)
  50. for m_idx in range(n_modes):
  51. env = envelopes[m_idx, :, cut_s:] # (units, T)
  52. pha = phases[m_idx, :, cut_s:] # (units, T)
  54. # R^(k)(t) = |(1/N) Σ_i A_i exp(i φ_i)|
  55. vector_sum_t = np.mean(env * np.exp(1j * pha), axis=0) # (T,)
  56. R_t = np.abs(vector_sum_t) # (T,)
  58. # (1/N) Σ_i A_i(t)
  59. scalar_mean_t = np.mean(env, axis=0) # (T,)
  61. # η = <R(t)> / <scalar_mean(t)>
  62. mean_R = np.mean(R_t)
  63. mean_scalar = np.mean(scalar_mean_t)
  65. eta[m_idx, k_idx] = mean_R / (mean_scalar + 1e-20)
  67. return eta
  70. def compute_kappa(r_split, rhythms, labels, Fs, cut_s=500):
  71. """
  72. Compute the alpha-band amplitude ratio kappa_i = A_i^(alpha, beta_mode) / A_i^(alpha, alpha_mode).
  74. Returns: dict with kappa array and summary statistics.
  75. """
  76. alpha_idx = list(labels).index('alpha')
  77. beta_idx = list(labels).index('beta')
  79. low, high = rhythms['alpha']
  80. filtered = bandpass_filter(r_split, low, high, Fs)
  82. # Time-averaged Hilbert envelope
  83. _, envelopes, _ = hilbert(filtered)
  84. amp_alpha_mode = np.mean(envelopes[alpha_idx, :, cut_s:], axis=-1) # (units,)
  85. amp_beta_mode = np.mean(envelopes[beta_idx, :, cut_s:], axis=-1) # (units,)
  87. kappa = amp_beta_mode / (amp_alpha_mode + 1e-20)
  89. return {
  90. 'kappa': kappa,
  91. 'mean_kappa': float(np.mean(kappa)),
  92. 'median_kappa': float(np.median(kappa)),
  93. 'n_above_0.5': int(np.sum(kappa > 0.5)),
  94. 'n_above_1.0': int(np.sum(kappa > 1.0)),
  95. 'amp_alpha_mode': amp_alpha_mode,
  96. 'amp_beta_mode': amp_beta_mode,
  97. }
  100. def compute_cancel_ratio_alpha(r_split, rhythms, labels, Fs, cut_s=500):
  101. """
  102. For both the alpha mode and the beta mode, compute the alpha-band cancel_ratio
  103. cancel_ratio = |sum_i A_i exp(i phi_i)| / sum_i A_i
  104. (equivalent to computing eta with a different time-averaging convention).
  105. """
  106. alpha_idx = list(labels).index('alpha')
  107. beta_idx = list(labels).index('beta')
  109. low, high = rhythms['alpha']
  110. filtered = bandpass_filter(r_split, low, high, Fs)
  111. _, envelopes, phases = hilbert(filtered)
  113. results = {}
  114. for mode_idx, mode_name in [(alpha_idx, 'alpha'), (beta_idx, 'beta')]:
  115. env = envelopes[mode_idx, :, cut_s:]
  116. pha = phases[mode_idx, :, cut_s:]
  118. # Time-averaged amplitude and representative phase
  119. mean_amp = np.mean(env, axis=-1)
  120. mean_phase = np.angle(np.mean(np.exp(1j * pha), axis=-1))
  122. vector_sum = np.abs(np.sum(mean_amp * np.exp(1j * mean_phase)))
  123. scalar_sum = np.sum(mean_amp)
  124. cancel_ratio = vector_sum / (scalar_sum + 1e-20)
  126. results[mode_name] = {
  127. 'vector_sum': float(vector_sum),
  128. 'scalar_sum': float(scalar_sum),
  129. 'cancel_ratio': float(cancel_ratio),
  130. }
  132. return results
  135. def analyze_run(run_id):
  136. """Run the analysis pipeline for a single training run."""
  137. run_path = f"multiple_runs/{run_id}/results"
  139. if not os.path.exists(run_path):
  140. print(f" Run {run_id}: path not found, skipping")
  141. return None
  143. # Load the trained model
  144. model, dsg, history = load_from_json(run_path)
  145. checkpoint_path = f"{run_path}/checkpoints/best_model.weights.h5"
  146. model.load_weights(checkpoint_path)
  148. try:
  149. model.sort_by_tau()
  150. except:
  151. pass
  153. # Generate the evaluation dataset
  154. dsg.update_task_config(period_length=8000, switch_num=dsg.task.n_rhythm)
  155. dsg.update_noise_config(strength=0)
  157. inputs, noise, mask, onehots, labels = dsg.make_datasets(
  158. batch_size=1, specified_rhythm=dsg.task.rhythm_names
  159. )
  160. labels = labels[0]
  161. init_state = model.get_initial_state(batch_size=1)
  163. y, z = model(inputs, noise, init_state)
  164. r = model.r[0].numpy().T # (units, time)
  166. Fs = dsg.Fs
  167. wait_length = dsg.task.wait_length
  168. switch_num = dsg.task.switch_num
  169. rhythms = dsg.task.rhythms
  171. # Split into per-interval segments
  172. r_split = split_signal(r, wait_length, switch_num)
  174. # 1. Coherence ratio
  175. eta = compute_coherence_ratio(r_split, rhythms, labels, Fs)
  177. # 2. kappa (alpha-band amplitude ratio)
  178. kappa_result = compute_kappa(r_split, rhythms, labels, Fs)
  180. # 3. cancel ratio
  181. cancel = compute_cancel_ratio_alpha(r_split, rhythms, labels, Fs)
  183. return {
  184. 'run_id': run_id,
  185. 'labels': list(labels),
  186. 'eta': eta,
  187. 'kappa_mean': kappa_result['mean_kappa'],
  188. 'kappa_median': kappa_result['median_kappa'],
  189. 'kappa_n_above_0.5': kappa_result['n_above_0.5'],
  190. 'kappa_n_above_1.0': kappa_result['n_above_1.0'],
  191. 'cancel_alpha_in_alpha': cancel['alpha']['cancel_ratio'],
  192. 'cancel_alpha_in_beta': cancel['beta']['cancel_ratio'],
  193. 'kappa_all': kappa_result['kappa'],
  194. }
  197. def main():
  198. parser = argparse.ArgumentParser()
  199. parser.add_argument('--runs', type=str, default='all',
  200. help='Comma-separated run IDs or "all"')
  201. args = parser.parse_args()
  203. if args.runs == 'all':
  204. run_ids = list(range(1, 21))
  205. else:
  206. run_ids = [int(x) for x in args.runs.split(',')]
  208. all_results = []
  210. for run_id in run_ids:
  211. print(f"\n{'='*50}")
  212. print(f"Run {run_id}")
  213. print(f"{'='*50}")
  214. result = analyze_run(run_id)
  215. if result is not None:
  216. all_results.append(result)
  218. if not all_results:
  219. print("No results.")
  220. return
  222. # ===== Summary output =====
  223. print("\n" + "="*70)
  224. print("SUMMARY: Phase coherence screening")
  225. print("="*70)
  227. band_names = ['theta', 'alpha', 'beta', 'gamma']
  229. # --- Statistics of the diagonal of eta (matched mode) ---
  230. print("\n--- Coherence ratio η^(m,m) (matched mode, diagonal) ---")
  231. print(f"{'Run':>4s} {'θ':>6s} {'α':>6s} {'β':>6s} {'γ':>6s}")
  232. diag_eta = []
  233. for res in all_results:
  234. eta = res['eta']
  235. diag = np.diag(eta)
  236. diag_eta.append(diag)
  237. print(f" {res['run_id']:>2d} {diag[0]:.4f} {diag[1]:.4f} {diag[2]:.4f} {diag[3]:.4f}")
  238. diag_eta = np.array(diag_eta)
  239. print(f"{'mean':>6s} {diag_eta[:,0].mean():.4f} {diag_eta[:,1].mean():.4f} "
  240. f"{diag_eta[:,2].mean():.4f} {diag_eta[:,3].mean():.4f}")
  241. print(f"{'std':>6s} {diag_eta[:,0].std():.4f} {diag_eta[:,1].std():.4f} "
  242. f"{diag_eta[:,2].std():.4f} {diag_eta[:,3].std():.4f}")
  244. # --- Statistics of eta^(beta, alpha): alpha-band coherence in the beta mode ---
  245. print("\n--- η^(β,α): alpha coherence in beta mode ---")
  246. eta_beta_alpha = []
  247. for res in all_results:
  248. beta_idx = res['labels'].index('beta')
  249. alpha_band_idx = list(band_names).index('alpha')
  250. val = res['eta'][beta_idx, alpha_band_idx]
  251. eta_beta_alpha.append(val)
  252. print(f" Run {res['run_id']:>2d}: η^(β,α) = {val:.6f}")
  253. eta_beta_alpha = np.array(eta_beta_alpha)
  254. print(f" mean: {eta_beta_alpha.mean():.6f} ± {eta_beta_alpha.std():.6f}")
  256. # --- κ (alpha amplitude ratio) ---
  257. print("\n--- κ: alpha amplitude ratio (beta mode / alpha mode) ---")
  258. print(f"{'Run':>4s} {'mean_κ':>8s} {'median_κ':>9s} {'n>0.5':>6s} {'n>1.0':>6s} {'Type':>12s}")
  260. for res in all_results:
  261. # Classification rule: median(kappa) > 0.3 AND at least 20 neurons with kappa > 0.5 -> phase-interference type
  262. is_phase_type = res['kappa_median'] > 0.3 and res['kappa_n_above_0.5'] >= 20
  263. type_label = "PHASE-INTERF" if is_phase_type else "AMP-SUPPRESS"
  264. print(f" {res['run_id']:>2d} {res['kappa_mean']:>8.4f} {res['kappa_median']:>9.4f} "
  265. f"{res['kappa_n_above_0.5']:>6d} {res['kappa_n_above_1.0']:>6d} {type_label:>12s}")
  267. # --- Per-run classification ---
  268. phase_runs = [res['run_id'] for res in all_results
  269. if res['kappa_median'] > 0.3 and res['kappa_n_above_0.5'] >= 20]
  270. amp_runs = [res['run_id'] for res in all_results
  271. if not (res['kappa_median'] > 0.3 and res['kappa_n_above_0.5'] >= 20)]
  273. print(f"\n--- Classification ---")
  274. print(f" Phase-interference type ({len(phase_runs)} runs): {phase_runs}")
  275. print(f" Amplitude-suppression type ({len(amp_runs)} runs): {amp_runs}")
  277. # --- Mean eta matrix across all runs ---
  278. all_eta = np.array([res['eta'] for res in all_results])
  279. mean_eta = np.mean(all_eta, axis=0)
  280. std_eta = np.std(all_eta, axis=0)
  282. print(f"\n--- Mean η matrix (mode × band) ---")
  283. print(f"{'':>8s} {'θ-band':>8s} {'α-band':>8s} {'β-band':>8s} {'γ-band':>8s}")
  284. mode_names = all_results[0]['labels']
  285. for i, m in enumerate(mode_names):
  286. print(f" {m:>6s} {mean_eta[i,0]:.4f}±{std_eta[i,0]:.3f} "
  287. f"{mean_eta[i,1]:.4f}±{std_eta[i,1]:.3f} "
  288. f"{mean_eta[i,2]:.4f}±{std_eta[i,2]:.3f} "
  289. f"{mean_eta[i,3]:.4f}±{std_eta[i,3]:.3f}")
  291. # --- Save results to JSON ---
  292. save_path = "multiple_runs/summary"
  293. os.makedirs(save_path, exist_ok=True)
  295. save_data = {
  296. 'n_runs': len(all_results),
  297. 'run_ids': [res['run_id'] for res in all_results],
  298. 'phase_interference_runs': phase_runs,
  299. 'amplitude_suppression_runs': amp_runs,
  300. 'mean_eta_diagonal': {
  301. 'theta': f"{diag_eta[:,0].mean():.4f}±{diag_eta[:,0].std():.4f}",
  302. 'alpha': f"{diag_eta[:,1].mean():.4f}±{diag_eta[:,1].std():.4f}",
  303. 'beta': f"{diag_eta[:,2].mean():.4f}±{diag_eta[:,2].std():.4f}",
  304. 'gamma': f"{diag_eta[:,3].mean():.4f}±{diag_eta[:,3].std():.4f}",
  305. },
  306. 'mean_eta_matrix': mean_eta.tolist(),
  307. 'std_eta_matrix': std_eta.tolist(),
  308. 'per_run': [{
  309. 'run_id': res['run_id'],
  310. 'eta_diagonal': np.diag(res['eta']).tolist(),
  311. 'eta_beta_alpha': float(res['eta'][res['labels'].index('beta'),
  312. list(band_names).index('alpha')]),
  313. 'kappa_mean': res['kappa_mean'],
  314. 'kappa_median': res['kappa_median'],
  315. 'kappa_n_above_0.5': res['kappa_n_above_0.5'],
  316. } for res in all_results],
  317. }
  319. with open(f"{save_path}/phase_coherence_results.json", 'w') as f:
  320. json.dump(save_data, f, indent=2)
  322. print(f"\nResults saved to {save_path}/phase_coherence_results.json")
  325. if __name__ == '__main__':
  326. main()

analysis_phase_coherence.py at commit 7122c45, under MIT · at the source

Overview

Authors: Yutaka Yamaguti1, Shota Nakamura2
ORCID iDs: Yutaka Yamaguti
  1. Faculty of Information Engineering, Fukuoka Institute of Technology, 3-30-1 Wajiro-Higashi, Higashi-ku, Fukuoka, Fukuoka 811-0295 Japan
  2. Graduate School of Engineering, Fukuoka Institute of Technology, 3-30-1 Wajiro-Higashi, Higashi-ku, Fukuoka, Fukuoka 811-0295 Japan
Institutions: Fukuoka Institute of Technology (Japan)
Journal: Biological cybernetics, volume 120, issue 5-6, article 41
Dates: received 14 May 2026; accepted 20 October 2026; published online 6 November 2026; in print 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1007/s00422-026-01074-0 · PMID 42993300 · PMCID PMC13743668 · OpenAlex W7161251093
Open access: hybrid, a free copy (OpenAlex)
Preprint: arxiv:2605.14388
Status: code verified (how the code is found and verified)
Categories: computational (subfield)
Methods: Spectral & time-frequency, Statistics, Connectivity, Single-unit activity, calcium imaging, Physiology & signal measures
Keywords: Rhythm generation, Functional differentiation, Recurrent neural networks, Time constant diversity
MeSH: Models, Neurological*, Nerve Net*, Neural Networks, Computer*, Neurons*, Periodicity*, Animals, Recurrent Neural Networks, Time Factors (* major topic)
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Japan Society for the Promotion of Science (26K15000)
Citations: not cited yet (Europe PMC); 25 references in the paper

Abstract

Although recurrent neural networks (RNNs) trained on cognitive tasks have become a widely used framework for studying neural computation, the internal mechanisms by which RNNs switch between rhythms across multiple frequency bands, and how these mechanisms relate to neuronal time constants, have not been systematically analyzed. We trained leaky integrator RNNs with neuron-specific learnable time constants on a four-band (theta, alpha, beta, gamma) rhythm-switching task and analyzed 20 independently trained networks. Whereas low-frequency rhythms were produced by distributed participation of many neurons, high-frequency rhythms were dominated by a small subpopulation of short-time-constant neurons, and the negative correlation between time constant and matched-mode amplitude strengthened monotonically with frequency. Rhythm switching was supported by multiple coexisting mechanisms: turnover of the active subpopulation, network-wide baseline shifts that reposition the operating point near distinct unstable fixed points, and inter-neuronal phase reorganization that selectively cancels or supports band components in the population output. Analysis of the learned recurrent connectivity linked these mechanisms to network structure: the short-time-constant neurons formed a more strongly interconnected module, and the baseline shift retuned the oscillation frequency through gain modulation of the recurrent interactions. The mechanism deployed for each mode pair varied across training runs, exposing a degeneracy of learned solutions. These findings parallel the coexistence of rhythm-specific and multi-rhythm interneurons reported in biological circuits and provide a candidate framework for interpreting frequency-band-specific functional differentiation in neural systems.

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

Repositories

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

cncs-fit/rnn-rhythm

License: MIT
State: the link answers, verified on 9 November 2026
Evidence: files inventoried
Commit: 7122c45d0846bab9e1e3036d728d3ada5f5560f4, 12 August 2026
Languages: Python (23), Shell (2)
Size: 29 files, 25 scripts
Software Heritage: not archived
Found in: “Code Availability”
Holds: README, license file, environment (requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (22 files), Matplotlib (17 files), SciPy (12 files), TensorFlow (10 files), Keras (5 files), h5py (2 files), pandas (2 files), seaborn (2 files), scikit-learn (1 file)
Availability: 1 check, the latest on 9 November 2026: the link answers
  • 9 November 2026: the link answers
27 files
At the source: github.com/cncs-fit/rnn-rhythm

Zenodo 21900320

License: MIT
State: the link answers, verified on 9 November 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Code Availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (22 files), Matplotlib (17 files), SciPy (12 files), TensorFlow (10 files), Keras (5 files), h5py (2 files), pandas (2 files), seaborn (2 files), scikit-learn (1 file)
Availability: 1 check, the latest on 9 November 2026: the link answers (HTTP 200)
  • 9 November 2026: the link answers (HTTP 200)
27 files
At the source: doi.org/10.5281/zenodo.21900320

Code Availability

The code used to train the networks and to perform all analyses is publicly available at https://github.com/cncs-fit/rnn-rhythm and permanently archived at Zenodo (DOI: https://doi.org/10.5281/zenodo.21900320).

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

Tracing map

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

What the map holds:

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

All data analyzed in this study were generated by the simulation and analysis code described in Sect. 2. The code, together with scripts to reproduce the analyses and figures, is publicly available at https://github.com/cncs-fit/rnn-rhythm and archived at Zenodo (https://doi.org/10.5281/zenodo.21900320).

The code used to train the networks and to perform all analyses is publicly available at https://github.com/cncs-fit/rnn-rhythm and permanently archived at Zenodo (DOI: https://doi.org/10.5281/zenodo.21900320).

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, 9 November 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 2 authors, 4 keywords, 8 MeSH terms, 1 funder, 23 references.

Cite

This paper

Yamaguti, Y., & Nakamura, S. (2026). Multiple mechanisms of rhythm switching in recurrent neural networks with adaptive time constants. Biological cybernetics, 120(5-6), 41. https://doi.org/10.1007/s00422-026-01074-0

BibTeX

@article{yamaguti2026multiple,
author = {Yamaguti, Yutaka and Nakamura, Shota},
title = {{Multiple mechanisms of rhythm switching in recurrent neural networks with adaptive time constants}},
journal = {Biological cybernetics},
year = {2026},
month = nov,
volume = {120},
number = {5-6},
pages = {41},
publisher = {Springer Science+Business Media},
issn = {0340-1200},
doi = {10.1007/s00422-026-01074-0},
url = {https://doi.org/10.1007/s00422-026-01074-0},
pmid = {42993300},
pmcid = {PMC13743668}
}

RIS

TY - JOUR
AU - Yamaguti, Yutaka
AU - Nakamura, Shota
TI - Multiple mechanisms of rhythm switching in recurrent neural networks with adaptive time constants
T2 - Biological cybernetics
J2 - Biol Cybern
PY - 2026
DA - 2026/11/06
VL - 120
IS - 5-6
SP - 41
SN - 0340-1200
PB - Springer Science+Business Media
DO - 10.1007/s00422-026-01074-0
UR - https://doi.org/10.1007/s00422-026-01074-0
LA - en
ER -

CSL-JSON

{
"id": "10.1007/s00422-026-01074-0",
"type": "article-journal",
"title": "Multiple mechanisms of rhythm switching in recurrent neural networks with adaptive time constants",
"container-title": "Biological cybernetics",
"author": [
{
"family": "Yamaguti",
"given": "Yutaka"
},
{
"family": "Nakamura",
"given": "Shota"
}
],
"container-title-short": "Biol Cybern",
"volume": "120",
"issue": "5-6",
"page": "41",
"DOI": "10.1007/s00422-026-01074-0",
"PMID": "42993300",
"PMCID": "PMC13743668",
"ISSN": "0340-1200",
"publisher": "Springer Science+Business Media",
"URL": "https://doi.org/10.1007/s00422-026-01074-0",
"language": "en",
"issued": {
"date-parts": [
[
2026,
11,
6
]
]
}
}

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.1007/s11571-025-10377-0 [code]
Emergence of functionally differentiated structures via mutual information minimization in recurrent neural networks.
Journal: Cognitive neurodynamics
In common: Keras, TensorFlow, seaborn, 5 other tools, computational, 4 references, author Yutaka Yamaguti
[2] doi:10.3389/fnsys.2024.1269190 [code]
Exploring Flip Flop memories and beyond: training Recurrent Neural Networks with key insights.
Journal: Frontiers in systems neuroscience
In common: Keras, TensorFlow, scikit-learn, 3 other tools, computational, 4 references
[3] 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, 4 references
[4] doi:10.1038/s41467-022-33581-6 [code]
Recurrent neural networks with explicit representation of dynamic latent variables can mimic behavioral patterns in a physical inference task.
Journal: Nature communications
In common: TensorFlow, h5py, seaborn, 5 other tools, computational, 2 references
[5] doi:10.1007/s11571-023-10038-0 [code]
Coincidence detection and integration behavior in spiking neural networks.
Journal: Cognitive neurodynamics
In common: Keras, TensorFlow, scikit-learn, 4 other tools, computational, 2 references
[6] doi:10.1016/j.celrep.2024.114580 [code]
Adaptive robustness through incoherent signaling mechanisms in a regenerative brain.
Journal: Cell reports
In common: Keras, TensorFlow, h5py, 5 other tools, 2 references
[7] doi:10.1038/s41467-023-35824-6 [code]
Distributed context-dependent choice information in mouse posterior cortex.
Journal: Nature communications
In common: Keras, TensorFlow, h5py, 5 other tools, 2 references
[8] doi:10.1038/s41540-026-00727-x [code]
Association-sensory spatiotemporal hierarchy and functional gradient-regularised recurrent neural network with implications for schizophrenia.
Journal: NPJ systems biology and applications
In common: h5py, seaborn, pandas, 3 other tools, computational, 3 references
[9] doi:10.1371/journal.pcbi.1014162 [code]
Exploring neural manifolds across a wide range of intrinsic dimensions.
Journal: PLoS computational biology
In common: TensorFlow, h5py, scikit-learn, 4 other tools, computational, 2 references
[10] doi:10.1038/s41467-025-63771-x [code]
Efficient and robust temporal processing with neural oscillations modulated spiking neural networks.
Journal: Nature communications
In common: TensorFlow, h5py, scikit-learn, 4 other tools, computational, 2 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.1007/s00422-026-01074-0.svg)](https://openscicode.org/badge/doi/10.1007/s00422-026-01074-0)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1007/s00422-026-01074-0.svg
   :target: https://openscicode.org/badge/doi/10.1007/s00422-026-01074-0
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1007/s00422-026-01074-0"><img src="https://openscicode.org/badge/doi/10.1007/s00422-026-01074-0.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.