OSCR

Plasticity and language in the anaesthetized human hippocampus.

A correction to this paper has been published: the notice, 42277412, from Europe PMC.

A correction to this paper has been published: the notice, 42680833, from Europe PMC.

Code ↔ Paper

9 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 9 matches · 3 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § Methods › Continuous-rate RNN model ↔ code/rate/model.py, lines 446–567 · score 0.86 · synaptic decay, sigmoid function, inhibitory units, rate RNN, firing rate, sum
  2. [2] § Methods › Continuous-rate RNN model ↔ code/rate/fnc_eval_model.m, the whole file · a weak match · score 0.80 · recurrent connectivity matrix, synaptic decay, firing rate, sigmoid, excitatory, variable
  3. [3] § Methods › Neuropixels data acquisition set-up and intraoperative recordings ↔ notebook/ap_chronic_demo.ipynb, lines 77–118 · score 0.65 · SpikeGLX, Neuropixels probe, shank, AP, filtered, channels
  4. [4] § Plasticity in the unconscious state ↔ code/rate/model.py, lines 22–26 · score 0.61 · recurrent connection, inhibitory neurons, RNN model, excitatory
  5. [5] § Methods › Continuous-rate RNN model ↔ code/rate/model.py, lines 27–64 · score 0.60 · readout weights, recurrent connectivity, classifier, network, model
  6. [6] § Methods › Continuous-rate RNN model ↔ code/rate/fnc_eval_model.m, the whole file · a weak match · score 0.59 · synaptic decay, recurrent connectivity, weights, model, RNN, trained
  7. [7] § Auditory monitoring during anaesthesia ↔ code/rate/svm_decoding_per_neuron.m, lines 281–354 · score 0.58 · SVM decoding, tone accuracy, tone identity, encoding
  8. [8] § Methods › Neuronal data processing › Motion correction ↔ matlab/dredge.m, the whole file · a weak match · score 0.55 · Decentralized Registration, Motion correction, DREDge, raw
  9. [9] § Methods › Neuronal data processing › LFP data ↔ notebook/lfp_registration_and_interpolation_demo.ipynb, lines 201–252 · score 0.55 · bandpass filtered, LFP band, raw, signal, channels

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 · 701 lines · 22 KB · Apache-2.0 · 3 matches

  1. #! /usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. # vim:fenc=utf-8
  4. #
  5. # Name: Robert Kim
  6. # Date: October 11, 2019
  7. # Email: [email hidden]
  8. # Description: Implementation of the continuous rate RNN model
  10. import os, sys
  11. import numpy as np
  12. import tensorflow as tf
  13. if tf.__version__[0] == '2':
  14. import tensorflow.compat.v1 as tf
  15. tf.disable_v2_behavior()
  16. import scipy.io
  18. '''
  19. CONTINUOUS FIRING-RATE RNN CLASS
  20. '''
  22. class FR_RNN_dale:
  23. """
  24. Firing-rate RNN model for excitatory and inhibitory neurons
  25. Initialization of the firing-rate model with recurrent connections
  26. """
  27. def __init__(self, N, P_inh, P_rec, w_in, som_N, w_dist, gain, apply_dale, w_out):
  28. """
  29. Network initialization method
  30. N: number of units (neurons)
  31. P_inh: probability of a neuron being inhibitory
  32. P_rec: recurrent connection probability
  33. w_in: NxN weight matrix for the input stimuli
  34. som_N: number of SOM neurons (set to 0 for no SOM neurons)
  35. w_dist: recurrent weight distribution ('gaus' or 'gamma')
  36. apply_dale: apply Dale's principle ('True' or 'False')
  37. w_out: Nx1 readout weights
  39. Based on the probability (P_inh) provided above,
  40. the units in the network are classified into
  41. either excitatory or inhibitory. Next, the
  42. weight matrix is initialized based on the connectivity
  43. probability (P_rec) provided above.
  44. """
  45. self.N = N
  46. self.P_inh = P_inh
  47. self.P_rec = P_rec
  48. self.w_in = w_in
  49. self.som_N = som_N
  50. self.w_dist = w_dist
  51. self.gain = gain
  52. self.apply_dale = apply_dale
  53. self.w_out = w_out
  55. # Assign each unit as excitatory or inhibitory
  56. inh, exc, NI, NE, som_inh = self.assign_exc_inh()
  57. self.inh = inh
  58. self.som_inh = som_inh
  59. self.exc = exc
  60. self.NI = NI
  61. self.NE = NE
  63. # Initialize the weight matrix
  64. self.W, self.mask, self.som_mask = self.initialize_W()
  66. def assign_exc_inh(self):
  67. """
  68. Method to randomly assign units as excitatory or inhibitory (Dale's principle)
  70. Returns
  71. inh: bool array marking which units are inhibitory
  72. exc: bool array marking which units are excitatory
  73. NI: number of inhibitory units
  74. NE: number of excitatory units
  75. som_inh: indices of "inh" for SOM neurons
  76. """
  77. # Apply Dale's principle
  78. if self.apply_dale == True:
  79. inh = np.random.rand(self.N, 1) < self.P_inh
  80. exc = ~inh
  81. NI = len(np.where(inh == True)[0])
  82. NE = self.N - NI
  84. # Do NOT apply Dale's principle
  85. else:
  86. inh = np.random.rand(self.N, 1) < 0 # no separate inhibitory units
  87. exc = ~inh
  88. NI = len(np.where(inh == True)[0])
  89. NE = self.N - NI
  91. if self.som_N > 0:
  92. som_inh = np.where(inh==True)[0][:self.som_N]
  93. else:
  94. som_inh = 0
  96. return inh, exc, NI, NE, som_inh
  98. def initialize_W(self):
  99. """
  100. Method to generate and initialize the connectivity weight matrix, W
  101. The weights are drawn from either gaussian or gamma distribution.
  103. Returns
  104. w: NxN weights (all positive)
  105. mask: NxN matrix of 1's (excitatory units)
  106. and -1's (for inhibitory units)
  107. NOTE: To compute the "full" weight matrix, simply
  108. multiply w and mask (i.e. w*mask)
  109. """
  110. # Weight matrix
  111. w = np.zeros((self.N, self.N), dtype = np.float32)
  112. idx = np.where(np.random.rand(self.N, self.N) < self.P_rec)
  113. if self.w_dist.lower() == 'gamma':
  114. w[idx[0], idx[1]] = np.random.gamma(2, 0.003, len(idx[0]))
  115. elif self.w_dist.lower() == 'gaus':
  116. w[idx[0], idx[1]] = np.random.normal(0, 1.0, len(idx[0]))
  117. w = w/np.sqrt(self.N*self.P_rec)*self.gain # scale by a gain to make it chaotic
  119. if self.apply_dale == True:
  120. w = np.abs(w)
  122. # Mask matrix
  123. mask = np.eye(self.N, dtype=np.float32)
  124. mask[np.where(self.inh==True)[0], np.where(self.inh==True)[0]] = -1
  126. # SOM mask matrix
  127. som_mask = np.ones((self.N, self.N), dtype=np.float32)
  128. if self.som_N > 0:
  129. for i in self.som_inh:
  130. som_mask[i, np.where(self.inh==True)[0]] = 0
  132. return w, mask, som_mask
  134. def load_net(self, model_dir):
  135. """
  136. Method to load pre-configured network settings
  137. """
  138. settings = scipy.io.loadmat(model_dir)
  139. self.N = settings['N'][0][0]
  140. self.som_N = settings['som_N'][0][0]
  141. self.inh = settings['inh']
  142. self.exc = settings['exc']
  143. self.inh = self.inh == 1
  144. self.exc = self.exc == 1
  145. self.NI = len(np.where(settings['inh'] == True)[0])
  146. self.NE = len(np.where(settings['exc'] == True)[0])
  147. self.mask = settings['m']
  148. self.som_mask = settings['som_m']
  149. self.W = settings['w']
  150. self.w_in = settings['w_in']
  151. self.b_out = settings['b_out']
  152. self.w_out = settings['w_out']
  154. return self
  156. def display(self):
  157. """
  158. Method to print the network setup
  159. """
  160. print('Network Settings')
  161. print('====================================')
  162. print('Number of Units: ', self.N)
  163. print('\t Number of Excitatory Units: ', self.NE)
  164. print('\t Number of Inhibitory Units: ', self.NI)
  165. print('Weight Matrix, W')
  166. full_w = self.W*self.mask
  167. zero_w = len(np.where(full_w == 0)[0])
  168. pos_w = len(np.where(full_w > 0)[0])
  169. neg_w = len(np.where(full_w < 0)[0])
  170. print('\t Zero Weights: %2.2f %%' % (zero_w/(self.N*self.N)*100))
  171. print('\t Positive Weights: %2.2f %%' % (pos_w/(self.N*self.N)*100))
  172. print('\t Negative Weights: %2.2f %%' % (neg_w/(self.N*self.N)*100))
  174. '''
  175. Task-specific input signals
  176. '''
  177. def generate_input_stim_go_nogo(settings):
  178. """
  179. Method to generate the input stimulus matrix for the
  180. Go-NoGo task
  182. INPUT
  183. settings: dict containing the following keys
  184. T: duration of a single trial (in steps)
  185. stim_on: stimulus starting time (in steps)
  186. stim_dur: stimulus duration (in steps)
  187. prob: probability for GO trials
  188. taus: time-constants (in steps)
  189. DeltaT: sampling rate
  190. OUTPUT
  191. u: 1xT stimulus matrix
  192. label: either +1 (Go trial) or 0 (NoGo trial)
  193. """
  194. T = settings['T']
  195. stim_on = settings['stim_on']
  196. stim_dur = settings['stim_dur']
  197. prob = settings['prob']
  199. u = np.zeros((1, T)) #+ np.random.randn(1, T)
  200. u_lab = np.zeros((2, 1))
  201. if np.random.rand() <= prob:
  202. u[0, stim_on:stim_on+stim_dur] = 1
  203. label = 1
  204. else:
  205. u[0, stim_on:stim_on+stim_dur] = -1
  206. label = 0
  208. return u, label
  210. def generate_input_stim_go_nogo2(settings):
  211. """
  212. Method to generate the input stimulus matrix for the
  213. Go-NoGo task
  214. Modified to include two input channels
  216. INPUT
  217. settings: dict containing the following keys
  218. T: duration of a single trial (in steps)
  219. stim_on: stimulus starting time (in steps)
  220. stim_dur: stimulus duration (in steps)
  221. prob: probability for GO trials
  222. taus: time-constants (in steps)
  223. DeltaT: sampling rate
  224. OUTPUT
  225. u: 1xT stimulus matrix
  226. label: either +1 (Go trial) or 0 (NoGo trial)
  227. """
  228. T = settings['T']
  229. stim_on = settings['stim_on']
  230. stim_dur = settings['stim_dur']
  231. prob = settings['prob']
  233. u = np.zeros((2, T)) #+ np.random.randn(1, T)
  234. u = u + np.random.randn(np.shape(u)[0], np.shape(u)[1])
  236. u_lab = np.zeros((2, 1))
  237. if np.random.rand() <= prob:
  238. u[1, stim_on:stim_on+stim_dur] = u[1, stim_on:stim_on+stim_dur] + 1
  239. label = 1
  240. else:
  241. u[0, stim_on:stim_on+stim_dur] = u[0, stim_on:stim_on+stim_dur] + 1
  242. label = 0
  244. return u, label
  246. def generate_input_stim_xor(settings):
  247. """
  248. Method to generate the input stimulus matrix (u)
  249. for the XOR task
  251. INPUT
  252. settings: dict containing the following keys
  253. T: duration of a single trial (in steps)
  254. stim_on: stimulus starting time (in steps)
  255. stim_dur: stimulus duration (in steps)
  256. delay: delay b/w two stimuli (in steps)
  257. taus: time-constants (in steps)
  258. DeltaT: sampling rate
  259. OUTPUT
  260. u: 2xT stimulus matrix
  261. label: 'same' or 'diff'
  262. """
  263. T = settings['T']
  264. stim_on = settings['stim_on']
  265. stim_dur = settings['stim_dur']
  266. delay = settings['delay']
  268. # Initialize u
  269. u = np.zeros((2, T))
  271. # XOR task
  272. labs = []
  273. if np.random.rand() < 0.50:
  274. u[0, stim_on:stim_on+stim_dur] = 1
  275. labs.append(1)
  276. else:
  277. u[0, stim_on:stim_on+stim_dur] = -1
  278. labs.append(-1)
  280. if np.random.rand() < 0.50:
  281. u[1, stim_on+stim_dur+delay:stim_on+2*stim_dur+delay] = 1
  282. labs.append(1)
  283. else:
  284. u[1, stim_on+stim_dur+delay:stim_on+2*stim_dur+delay] = -1
  285. labs.append(-1)
  287. if np.prod(labs) == 1:
  288. label = 'same'
  289. else:
  290. label = 'diff'
  292. return u, label
  294. def generate_input_stim_mante(settings):
  295. """
  296. Method to generate the input stimulus matrix for the
  297. mante task
  299. INPUT
  300. settings: dict containing the following keys
  301. T: duration of a single trial (in steps)
  302. stim_on: stimulus starting time (in steps)
  303. stim_dur: stimulus duration (in steps)
  304. taus: time-constants (in steps)
  305. DeltaT: sampling rate
  306. OUTPUT
  307. u: 4xT stimulus matrix (first 2 rows for motion/color and the second
  308. 2 rows for context
  309. label: either +1 or -1
  310. """
  311. T = settings['T']
  312. stim_on = settings['stim_on']
  313. stim_dur = settings['stim_dur']
  315. # Color/motion sensory inputs
  316. u = np.zeros((2, T))
  317. u_lab = np.zeros((2, 1))
  318. if np.random.rand() <= 0.50:
  319. u[0, stim_on:stim_on+stim_dur] = np.random.randn(1, stim_dur) + 0.5
  320. u_lab[0, 0] = 1
  321. else:
  322. u[0, stim_on:stim_on+stim_dur] = np.random.randn(1, stim_dur) - 0.5
  323. u_lab[0, 0] = -1
  325. if np.random.rand() <= 0.50:
  326. u[1, stim_on:stim_on+stim_dur] = np.random.randn(1, stim_dur) + 0.5
  327. u_lab[1, 0] = 1
  328. else:
  329. u[1, stim_on:stim_on+stim_dur] = np.random.randn(1, stim_dur) - 0.5
  330. u_lab[1, 0] = -1
  332. # Context input
  333. c = np.zeros((2, T))
  334. label = 0
  335. if np.random.rand() <= 0.50:
  336. c[0, :] = 1
  338. if u_lab[0, 0] == 1:
  339. label = 1
  340. elif u_lab[0, 0] == -1:
  341. label = -1
  342. else:
  343. c[1, :] = 1
  345. if u_lab[1, 0] == 1:
  346. label = 1
  347. elif u_lab[1, 0] == -1:
  348. label = -1
  350. return np.vstack((u, c)), label
  353. '''
  354. Task-specific target signals
  355. '''
  356. def generate_target_continuous_go_nogo(settings, label):
  357. """
  358. Method to generate a continuous target signal (z)
  359. for the Go-NoGo task
  361. INPUT
  362. settings: dict containing the following keys
  363. T: duration of a single trial (in steps)
  364. stim_on: stimulus starting time (in steps)
  365. stim_dur: stimulus duration (in steps)
  366. taus: time-constants (in steps)
  367. DeltaT: sampling rate
  368. label: either +1 or -1
  369. OUTPUT
  370. z: 1xT target signal
  371. """
  372. T = settings['T']
  373. stim_on = settings['stim_on']
  374. stim_dur = settings['stim_dur']
  376. z = np.zeros((1, T))
  377. if label == 1:
  378. z[0, stim_on+stim_dur:] = 1
  379. elif label == 0:
  380. z[0, stim_on+stim_dur:] = -1
  382. return np.squeeze(z)
  384. def generate_target_continuous_xor(settings, label):
  385. """
  386. Method to generate a continuous target signal (z)
  387. for the XOR task
  389. INPUT
  390. settings: dict containing the following keys
  391. T: duration of a single trial (in steps)
  392. stim_on: stimulus starting time (in steps)
  393. stim_dur: stimulus duration (in steps)
  394. delay: delay b/w two stimuli (in steps)
  395. taus: time-constants (in steps)
  396. DeltaT: sampling rate
  397. label: string value (either 'same' or 'diff')
  398. OUTPUT
  399. z: 1xT target signal
  400. """
  401. T = settings['T']
  402. stim_on = settings['stim_on']
  403. stim_dur = settings['stim_dur']
  404. delay = settings['delay']
  405. task_end_T = stim_on+2*stim_dur + delay
  407. z = np.zeros((1, T))
  408. if label == 'same':
  409. z[0, 10+task_end_T:10+task_end_T+100] = 1
  410. elif label == 'diff':
  411. z[0, 10+task_end_T:10+task_end_T+100] = -1
  413. return np.squeeze(z)
  415. def generate_target_continuous_mante(settings, label):
  416. """
  417. Method to generate a continuous target signal (z)
  418. for the MANTE task
  420. INPUT
  421. settings: dict containing the following keys
  422. T: duration of a single trial (in steps)
  423. stim_on: stimulus starting time (in steps)
  424. stim_dur: stimulus duration (in steps)
  425. taus: time-constants (in steps)
  426. DeltaT: sampling rate
  427. label: either +1 or -1
  428. OUTPUT
  429. z: 1xT target signal
  430. """
  431. T = settings['T']
  432. stim_on = settings['stim_on']
  433. stim_dur = settings['stim_dur']
  435. z = np.zeros((1, T))
  436. if label == 1:
  437. z[0, stim_on+stim_dur:] = 1
  438. else:
  439. z[0, stim_on+stim_dur:] = -1
  441. return np.squeeze(z)
  443. '''
  444. CONSTRUCT TF GRAPH FOR TRAINING
  445. '''
  446. def construct_tf(fr_rnn, settings, training_params):
  447. """
  448. Method to construct a TF graph and return nodes with
  449. Dale's principle
  450. INPUT
  451. fr_rnn: firing-rate RNN class
  452. settings: dict containing the following keys
  453. T: duration of a single trial (in steps)
  454. stim_on: stimulus starting time (in steps)
  455. stim_dur: stimulus duration (in steps)
  456. delay: delay b/w two stimuli (in steps)
  457. taus: time-constants (in steps)
  458. DeltaT: sampling rate
  459. training_params: dictionary containing training parameters
  460. learning_rate: learning rate
  461. OUTPUT
  462. TF graph
  463. """
  465. # Task params
  466. T = settings['T']
  467. taus = settings['taus']
  468. DeltaT = settings['DeltaT']
  469. task = settings['task']
  471. # Training params
  472. learning_rate = training_params['learning_rate']
  474. # Excitatory units
  475. exc_idx_tf = tf.constant(np.where(fr_rnn.exc == True)[0], name='exc_idx')
  477. # Inhibitory units
  478. inh_idx_tf = tf.constant(np.where(fr_rnn.inh == True)[0], name='inh_idx')
  479. som_inh_idx_tf = tf.constant(fr_rnn.som_inh, name='som_inh_idx')
  481. # Input node
  482. # XOR task
  483. if task == 'xor':
  484. stim = tf.placeholder(tf.float32, [2, T], name='u')
  486. # Sensory integration task
  487. elif task == 'mante':
  488. stim = tf.placeholder(tf.float32, [4, T], name='u')
  490. # Go-NoGo task
  491. elif task == 'go-nogo':
  492. stim = tf.placeholder(tf.float32, [1, T], name='u')
  494. elif task == 'go-nogo2':
  495. stim = tf.placeholder(tf.float32, [2, T], name='u')
  497. # Target node
  498. z = tf.placeholder(tf.float32, [T,], name='target')
  500. # Initialize the decay synaptic time-constants (gaussian random).
  501. # This vector will go through the sigmoid transfer function.
  502. if len(taus) > 1:
  503. taus_gaus = tf.Variable(tf.random_normal([fr_rnn.N, 1]), dtype=tf.float32,
  504. name='taus_gaus', trainable=True)
  505. elif len(taus) == 1:
  506. taus_gaus = tf.Variable(tf.random_normal([fr_rnn.N, 1]), dtype=tf.float32,
  507. name='taus_gaus', trainable=False)
  508. print('Synaptic decay time-constants will not get updated!')
  510. # Synaptic currents and firing-rates
  511. x = [] # synaptic currents
  512. r = [] # firing-rates
  513. x.append(tf.random_normal([fr_rnn.N, 1], dtype=tf.float32)/100)
  515. # Transfer function options
  516. if training_params['activation'] == 'sigmoid':
  517. r.append(tf.sigmoid(x[0]))
  518. elif training_params['activation'] == 'clipped_relu':
  519. r.append(tf.clip_by_value(tf.nn.relu(x[0]), 0, 20))
  520. elif training_params['activation'] == 'softplus':
  521. r.append(tf.clip_by_value(tf.nn.softplus(x[0]), 0, 20))
  523. # Initialize recurrent weight matrix, mask, input & output weight matrices
  524. w = tf.get_variable('w', initializer = fr_rnn.W, dtype=tf.float32, trainable=True)
  525. m = tf.get_variable('m', initializer = fr_rnn.mask, dtype=tf.float32, trainable=False)
  526. som_m = tf.get_variable('som_m', initializer = fr_rnn.som_mask, dtype=tf.float32,
  527. trainable=False)
  528. w_in = tf.get_variable('w_in', initializer = fr_rnn.w_in, dtype=tf.float32, trainable=False)
  529. w_out = tf.get_variable('w_out', initializer = fr_rnn.w_out, dtype=tf.float32,
  530. trainable=True)
  532. b_out = tf.Variable(0, dtype=tf.float32, name='b_out', trainable=True)
  534. # Forward pass
  535. o = [] # output (i.e. weighted linear sum of rates, r)
  536. for t in range(1, T):
  537. if fr_rnn.apply_dale == True:
  538. # Parametrize the weight matrix to enforce exc/inh synaptic currents
  539. w = tf.nn.relu(w)
  541. # next_x is [N x 1]
  542. ww = tf.matmul(w, m)
  543. ww = tf.multiply(ww, som_m)
  545. # Pass the synaptic time constants thru the sigmoid function
  546. if len(taus) > 1:
  547. taus_sig = tf.sigmoid(taus_gaus)*(taus[1] - taus[0]) + taus[0]
  548. elif len(taus) == 1: # one scalar synaptic decay time-constant
  549. taus_sig = taus[0]
  551. next_x = tf.multiply((1 - DeltaT/taus_sig), x[t-1]) + \
  552. tf.multiply((DeltaT/taus_sig), ((tf.matmul(ww, r[t-1]))\
  553. + tf.matmul(w_in, tf.expand_dims(stim[:, t-1], 1)))) +\
  554. tf.random_normal([fr_rnn.N, 1], dtype=tf.float32)/10
  555. x.append(next_x)
  557. if training_params['activation'] == 'sigmoid':
  558. r.append(tf.sigmoid(next_x))
  559. elif training_params['activation'] == 'clipped_relu':
  560. r.append(tf.clip_by_value(tf.nn.relu(next_x), 0, 20))
  561. elif training_params['activation'] == 'softplus':
  562. r.append(tf.clip_by_value(tf.nn.softplus(next_x), 0, 20))
  564. next_o = tf.matmul(w_out, r[t]) + b_out
  565. o.append(next_o)
  567. return stim, z, x, r, o, w, w_in, m, som_m, w_out, b_out, taus_gaus
  569. '''
  570. DEFINE LOSS AND OPTIMIZER
  571. '''
  572. def loss_op(o, z, training_params):
  573. """
  574. Method to define loss and optimizer for ONLY ONE target signal
  575. INPUT
  576. o: list of output values
  577. z: target values
  578. training_params: dictionary containing training parameters
  579. learning_rate: learning rate
  581. OUTPUT
  582. loss: loss function
  583. training_op: optimizer
  584. """
  585. # Loss function
  586. loss = tf.zeros(1)
  587. loss_fn = training_params['loss_fn']
  588. for i in range(0, len(o)):
  589. if loss_fn.lower() == 'l1':
  590. loss += tf.norm(o[i] - z[i])
  591. elif loss_fn.lower() == 'l2':
  592. loss += tf.square(o[i] - z[i])
  593. if loss_fn.lower() == 'l2':
  594. loss = tf.sqrt(loss)
  596. # Optimizer function
  597. with tf.name_scope('ADAM'):
  598. optimizer = tf.train.AdamOptimizer(learning_rate = training_params['learning_rate'])
  600. training_op = optimizer.minimize(loss)
  602. return loss, training_op
  604. '''
  605. EVALUATE THE TRAINED MODEL
  606. NOTE: NEED TO BE UPDATED!!
  607. '''
  608. def eval_tf(model_dir, settings, u):
  609. """
  610. Method to evaluate a trained TF graph
  611. INPUT
  612. model_dir: full path to the saved model .mat file
  613. stim_params: dictionary containig the following keys
  614. u: 12xT stimulus matrix
  615. NOTE: There are 12 rows (one per dot pattern): 6 cues and 6 probes.
  616. OUTPUT
  617. o: 1xT output vector
  618. """
  619. T = settings['T']
  620. stim_on = settings['stim_on']
  621. stim_dur = settings['stim_dur']
  622. delay = settings['delay']
  623. DeltaT = settings['DeltaT']
  625. # Load the trained mat file
  626. var = scipy.io.loadmat(model_dir)
  628. # Get some additional params
  629. N = var['N'][0][0]
  630. exc_ind = [np.bool(i) for i in var['exc']]
  632. # Get the delays
  633. taus_gaus = var['taus_gaus']
  634. taus = var['taus'][0] # tau [min, max]
  635. taus_sig = (1/(1+np.exp(-taus_gaus))*(taus[1] - taus[0])) + taus[0]
  637. # Synaptic currents and firing-rates
  638. x = np.zeros((N, T)) # synaptic currents
  639. r = np.zeros((N, T)) # firing-rates
  640. x[:, 0] = np.random.randn(N, )/100
  641. r[:, 0] = 1/(1 + np.exp(-x[:, 0]))
  642. # r[:, 0] = np.minimum(np.maximum(x[:, 0], 0), 1) #clipped relu
  643. # r[:, 0] = np.clip(np.minimum(np.maximum(x[:, 0], 0), 1), None, 10) #clipped relu
  644. # r[:, 0] = np.clip(np.log(np.exp(x[:, 0])+1), None, 10) # softplus
  645. # r[:, 0] = np.minimum(np.maximum(x[:, 0], 0), 6)/6 #clipped relu6
  648. # Output
  649. o = np.zeros((T, ))
  650. o_counter = 0
  652. # Recurrent weights and masks
  653. # w = var['w0'] #!!!!!!!!!!!!
  654. w = var['w']
  656. m = var['m']
  657. som_m = var['som_m']
  658. som_N = var['som_N'][0][0]
  660. # Identify excitatory/inhibitory neurons
  661. exc = var['exc']
  662. exc_ind = np.where(exc == 1)[0]
  663. inh = var['inh']
  664. inh_ind = np.where(inh == 1)[0]
  665. som_inh_ind = inh_ind[:som_N]
  667. for t in range(1, T):
  668. # next_x is [N x 1]
  669. ww = np.matmul(w, m)
  670. ww = np.multiply(ww, som_m)
  672. # next_x = (1 - DeltaT/tau)*x[:, t-1] + \
  673. # (DeltaT/tau)*(np.matmul(ww, r[:, t-1]) + \
  674. # np.matmul(var['w_in'], u[:, t-1])) + \
  675. # np.random.randn(N, )/10
  677. next_x = np.multiply((1 - DeltaT/taus_sig), np.expand_dims(x[:, t-1], 1)) + \
  678. np.multiply((DeltaT/taus_sig), ((np.matmul(ww, np.expand_dims(r[:, t-1], 1)))\
  679. + np.matmul(var['w_in'], np.expand_dims(u[:, t-1], 1)))) +\
  680. np.random.randn(N, 1)/10
  682. x[:, t] = np.squeeze(next_x)
  683. r[:, t] = 1/(1 + np.exp(-x[:, t]))
  684. # r[:, t] = np.minimum(np.maximum(x[:, t], 0), 1)
  685. # r[:, t] = np.clip(np.minimum(np.maximum(x[:, t], 0), 1), None, 10)
  686. # r[:, t] = np.clip(np.log(np.exp(x[:, t])+1), None, 10) # softplus
  687. # r[:, t] = np.minimum(np.maximum(x[:, t], 0), 6)/6
  690. wout = var['w_out']
  691. wout_exc = wout[0, exc_ind]
  692. wout_inh = wout[0, inh_ind]
  693. r_exc = r[exc_ind, :]
  694. r_inh = r[inh_ind, :]
  696. o[o_counter] = np.matmul(wout, r[:, t]) + var['b_out']
  697. # o[o_counter] = np.matmul(wout_exc, r[exc_ind, t]) + var['b_out'] # excitatory output
  698. # o[o_counter] = np.matmul(wout_inh, r[inh_ind, t]) + var['b_out'] # inhibitory output
  699. o_counter += 1
  700. return x, r, o

model.py at commit c8937f9, under Apache-2.0 · at the source

Overview

Authors: Kalman A. Katlowitz1, Eric R. Cole1, Elizabeth A. Mickiewicz1, Shraddha Shah1, Melissa Franch1, Joshua A. Adkinson1, James L. Belanger1, Raissa K. Mathura1, Domokos Meszéna2,3,4, Matthew McGinley5, William Muñoz6, Garrett P. Banks1, Sydney S. Cash2,4, Chih-Wei Hsu7, Angelique C. Paulk2,4, Nicole R. Provenza1,8,9,10, Andrew J. Watrous1, Ziv Williams6, Alica M. Goldman11, Vaishnav Krishnan5,8,11
and 6 other authorsAtul Maheshwari11, Sarah R. Heilbronner1,5,10, Robert Kim12, Nuttida Rungratsameetaweemana13, Benjamin Y. Hayden1,5,8,10, Sameer A. Sheth1,5,8,10,14,15
ORCID iDs: Kalman A. Katlowitz, Eric R. Cole, Shraddha Shah, Melissa Franch, Joshua A. Adkinson, James L. Belanger, Raissa K. Mathura, Domokos Meszéna, Matthew McGinley, William Muñoz, Sydney S. Cash, Chih-Wei Hsu, Angelique C. Paulk, Nicole R. Provenza, Ziv Williams, Robert Kim, Sameer A. Sheth
15 affiliations
  1. Department of Neurosurgery, Baylor College of Medicine,Houston, TX USA
  2. Department of Neurology, Massachusetts General Hospital, Harvard Medical School,Boston, MA USA
  3. HUN-REN Research Centre for Natural Sciences, Budapest, Hungary PPCU Faculty of Information Technology and Bionics,Budapest, Hungary
  4. Center for Neurotechnology and Neurorecovery, Department of Neurology, Mass General Brigham,Boston, MA USA
  5. Department of Neuroscience, Baylor College of Medicine,Houston, TX USA
  6. Department of Neurosurgery, Massachusetts General Hospital, Harvard Medical School,Boston, MA USA
  7. Department of Integrative Physiology, Baylor College of Medicine,Houston, TX USA
  8. Department of Electrical & Computer Engineering, Rice University,Houston, TX USA
  9. Department of Bioengineering, Rice University,Houston, TX USA
  10. Neuroengineering Initiative, Rice University,Houston, TX USA
  11. Department of Neurology, Baylor College of Medicine,Houston, TX USA
  12. Department of Neurology, Cedars-Sinai Medical Center,Los Angeles, CA USA
  13. Department of Biomedical Engineering, Columbia University,New York, NY USA
  14. Department of Psychiatry and Behavioral Sciences, Baylor College of Medicine,Houston, TX USA
  15. Cain Laboratories, Duncan Neurological Research Institute, Texas Children’s Hospital,Houston, TX USA
Institutions: Baylor College of Medicine (United States); Massachusetts General Hospital (United States); Pázmány Péter Catholic University (Hungary); Mass General Brigham (United States); Rice University (United States); Cedars-Sinai Medical Center (United States); Columbia University (United States); Texas Children's Hospital (United States)
Journal: Nature, volume 654, issue 8119, pages 714-723
Dates: received 9 April 2025; accepted 25 March 2026; published online 6 May 2026; in print 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41586-026-10448-0 · PMID 42092132 · PMCID PMC13275293 · OpenAlex W7160451128
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: extracellular electrophysiology (units, LFP) (modality), human (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing, Evoked potentials, fMRI & imaging, Single-unit activity, calcium imaging
Keywords: Perception, Language, Hippocampus, Sensory processing, Consciousness
MeSH: Anesthesia, General*, Hippocampus*, Language*, Neuronal Plasticity*, Acoustic Stimulation, Adult, Consciousness, Discrimination, Psychological, Female, Humans, Local Field Potential Measurement, Male, Models, Neurological, Neurons, Semantics, Unconsciousness, Young Adult (* major topic)
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: NINDS NIH HHS (U01 NS121472)
Citations: cited by 6 papers (Europe PMC); 68 references in the paper
Notices: A correction to this paper has been published (42277412, from Europe PMC); A correction to this paper has been published (42680833, from Europe PMC)

Abstract

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

Repositories

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

evarol/DREDge

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: ed236113a0b6c29b376065440174da6341a1d875, 21 March 2026
Languages: MATLAB (23), Python (5), Jupyter (4)
Size: 44 files, 32 scripts
Software Heritage: not archived
Found in: the text, “Motion correction”
Holds: README, license file, environment (pyproject.toml), continuous integration, 4 notebooks
Not found: CITATION.cff, tests, documentation
Tools: NumPy (8 files), Image Processing Toolbox (5 files), Matplotlib (4 files), SpikeInterface (4 files), Statistics and Machine Learning Toolbox (3 files), SciPy (3 files), Signal Processing Toolbox (1 file), PyTorch (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
34 files
At the source: github.com/evarol/DREDge

NuttidaLab/rnn_oddball

License: Apache-2.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: c8937f93abb5c4dc14b747ae3b5b95028b07fc65, 10 February 2026
Languages: MATLAB (14), Python (5), Shell (2)
Size: 28 files, 21 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Statistics and Machine Learning Toolbox (8 files), TensorFlow (5 files), NumPy (4 files), SciPy (4 files), Parallel Computing Toolbox (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
23 files
At the source: github.com/NuttidaLab/rnn_oddball

Code availability statement

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

Read it in the paper: doi.org/10.1038/s41586-026-10448-0.

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;
  • 53 scripts, each with its path and the digest of its content;
  • 9 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

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

Data

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

Data availability statement

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

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

Read it in the paper: doi.org/10.1038/s41586-026-10448-0.

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 2, 28 September 2026

  • Publisher: n/a → Nature Portfolio

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 26 authors, 5 keywords, 17 MeSH terms, 1 funder, 62 references, 2 integrity notices.

Cite

This paper

Katlowitz, K. A., Cole, E. R., Mickiewicz, E. A., Shah, S., Franch, M., Adkinson, J. A., Belanger, J. L., Mathura, R. K., Meszéna, D., McGinley, M., Muñoz, W., Banks, G. P., Cash, S. S., Hsu, C.-W., Paulk, A. C., Provenza, N. R., Watrous, A. J., Williams, Z., Goldman, A. M., . . . Sheth, S. A. (2026). Plasticity and language in the anaesthetized human hippocampus. Nature, 654(8119), 714-723. https://doi.org/10.1038/s41586-026-10448-0

BibTeX

@article{katlowitz2026plasticity,
author = {Katlowitz, Kalman A. and Cole, Eric R. and Mickiewicz, Elizabeth A. and Shah, Shraddha and Franch, Melissa and Adkinson, Joshua A. and Belanger, James L. and Mathura, Raissa K. and Meszéna, Domokos and McGinley, Matthew and Muñoz, William and Banks, Garrett P. and Cash, Sydney S. and Hsu, Chih-Wei and Paulk, Angelique C. and Provenza, Nicole R. and Watrous, Andrew J. and Williams, Ziv and Goldman, Alica M. and Krishnan, Vaishnav and Maheshwari, Atul and Heilbronner, Sarah R. and Kim, Robert and Rungratsameetaweemana, Nuttida and Hayden, Benjamin Y. and Sheth, Sameer A.},
title = {{Plasticity and language in the anaesthetized human hippocampus}},
journal = {Nature},
year = {2026},
month = may,
volume = {654},
number = {8119},
pages = {714--723},
publisher = {Nature Portfolio},
issn = {0028-0836},
doi = {10.1038/s41586-026-10448-0},
url = {https://doi.org/10.1038/s41586-026-10448-0},
pmid = {42092132},
pmcid = {PMC13275293}
}

RIS

TY - JOUR
AU - Katlowitz, Kalman A.
AU - Cole, Eric R.
AU - Mickiewicz, Elizabeth A.
AU - Shah, Shraddha
AU - Franch, Melissa
AU - Adkinson, Joshua A.
AU - Belanger, James L.
AU - Mathura, Raissa K.
AU - Meszéna, Domokos
AU - McGinley, Matthew
AU - Muñoz, William
AU - Banks, Garrett P.
AU - Cash, Sydney S.
AU - Hsu, Chih-Wei
AU - Paulk, Angelique C.
AU - Provenza, Nicole R.
AU - Watrous, Andrew J.
AU - Williams, Ziv
AU - Goldman, Alica M.
AU - Krishnan, Vaishnav
AU - Maheshwari, Atul
AU - Heilbronner, Sarah R.
AU - Kim, Robert
AU - Rungratsameetaweemana, Nuttida
AU - Hayden, Benjamin Y.
AU - Sheth, Sameer A.
TI - Plasticity and language in the anaesthetized human hippocampus
T2 - Nature
J2 - Nature
PY - 2026
DA - 2026/05/06
VL - 654
IS - 8119
SP - 714
EP - 723
SN - 0028-0836
PB - Nature Portfolio
DO - 10.1038/s41586-026-10448-0
UR - https://doi.org/10.1038/s41586-026-10448-0
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41586-026-10448-0",
"type": "article-journal",
"title": "Plasticity and language in the anaesthetized human hippocampus",
"container-title": "Nature",
"author": [
{
"family": "Katlowitz",
"given": "Kalman A."
},
{
"family": "Cole",
"given": "Eric R."
},
{
"family": "Mickiewicz",
"given": "Elizabeth A."
},
{
"family": "Shah",
"given": "Shraddha"
},
{
"family": "Franch",
"given": "Melissa"
},
{
"family": "Adkinson",
"given": "Joshua A."
},
{
"family": "Belanger",
"given": "James L."
},
{
"family": "Mathura",
"given": "Raissa K."
},
{
"family": "Meszéna",
"given": "Domokos"
},
{
"family": "McGinley",
"given": "Matthew"
},
{
"family": "Muñoz",
"given": "William"
},
{
"family": "Banks",
"given": "Garrett P."
},
{
"family": "Cash",
"given": "Sydney S."
},
{
"family": "Hsu",
"given": "Chih-Wei"
},
{
"family": "Paulk",
"given": "Angelique C."
},
{
"family": "Provenza",
"given": "Nicole R."
},
{
"family": "Watrous",
"given": "Andrew J."
},
{
"family": "Williams",
"given": "Ziv"
},
{
"family": "Goldman",
"given": "Alica M."
},
{
"family": "Krishnan",
"given": "Vaishnav"
},
{
"family": "Maheshwari",
"given": "Atul"
},
{
"family": "Heilbronner",
"given": "Sarah R."
},
{
"family": "Kim",
"given": "Robert"
},
{
"family": "Rungratsameetaweemana",
"given": "Nuttida"
},
{
"family": "Hayden",
"given": "Benjamin Y."
},
{
"family": "Sheth",
"given": "Sameer A."
}
],
"container-title-short": "Nature",
"volume": "654",
"issue": "8119",
"page": "714-723",
"DOI": "10.1038/s41586-026-10448-0",
"PMID": "42092132",
"PMCID": "PMC13275293",
"ISSN": "0028-0836",
"publisher": "Nature Portfolio",
"URL": "https://doi.org/10.1038/s41586-026-10448-0",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
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.1038/s41586-026-10691-5 [code]
Mapping the neuronal building blocks of human language with language models.
Journal: Nature
In common: SciPy, Matplotlib, NumPy, cognitive, 3 references, 2 authors
[2] doi:10.1016/j.patter.2026.101590 [code]
Density-based longitudinal neuron tracking in high-density electrophysiological recordings.
Journal: Patterns (New York, N.Y.)
In common: SpikeInterface, Parallel Computing Toolbox, Signal Processing Toolbox, 5 other tools, extracellular electrophysiology (units, LFP), 3 references
[3] doi:10.1038/s41586-026-10653-x [code]
A mosaic of whole-body representations on the human precentral gyrus.
Journal: Nature
In common: PyTorch, Statistics and Machine Learning Toolbox, SciPy, 2 other tools, 2 authors
[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, Image Processing Toolbox, PyTorch, 4 other tools, 1 reference, author Robert Kim
[5] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: SpikeInterface, TensorFlow, PyTorch, 3 other tools, extracellular electrophysiology (units, LFP), 4 references
[6] doi:10.1038/s41467-026-71443-7 [code]
Large-scale single-neuron recording in the human cortex using an ultra-flexible electrode array.
Journal: Nature communications
In common: Signal Processing Toolbox, Statistics and Machine Learning Toolbox, extracellular electrophysiology (units, LFP), 6 references
[7] doi:10.1038/s41593-026-02205-3 [code]
Competitive interactions shape mammalian brain network dynamics and computation.
Journal: Nature neuroscience
In common: Parallel Computing Toolbox, Image Processing Toolbox, Signal Processing Toolbox, 5 other tools, 2 references
[8] doi:10.1038/s41593-026-02258-4 [code]
Laminar organization of cellular microcircuits modulating human interictal epileptiform discharges.
Journal: Nature neuroscience
In common: Parallel Computing Toolbox, Image Processing Toolbox, Signal Processing Toolbox, 4 other tools, 2 references
[9] doi:10.1038/s41593-026-02357-2 [code]
Experience reorganizes content-specific memory traces in macaques.
Journal: Nature neuroscience
In common: Parallel Computing Toolbox, Image Processing Toolbox, Signal Processing Toolbox, 4 other tools, 2 references
[10] doi:10.1038/s41467-026-73106-z [code]
Respiratory pauses highlight sleep architecture in mice.
Journal: Nature communications
In common: Parallel Computing Toolbox, TensorFlow, Image Processing Toolbox, 5 other tools, extracellular electrophysiology (units, LFP)

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.