OSCR

Naturalistic behavior and self-generated neural activity predictive of self-correction

Code ↔ Paper

1 match between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 1 match
  1. [1] § Hippocampal representations of alternatives predict correct choices. ↔ src/gucompaper/changeOfMind_remote_interval.py, lines 421–467 · score 0.60 · remote arm representations, home arm, interval, segments, location, decoded

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 · 675 lines · 31 KB · no license · 1 match

  1. import numpy as np
  2. import pandas as pd
  3. import pickle
  4. from spyglass.utils.nwb_helper_fn import get_nwb_copy_filename
  5. from ripple_detection.core import segment_boolean_series
  7. from gucompaper.decodeQuality import return_low_hpd_time
  8. from gucompaper.decodeHelpers import runSessionNames
  9. from gucompaper.changeOfMind_triggered import region
  10. from gucompaper.ripple_add_replay import (find_start_end,
  11. position_posterior2arm_posterior,
  12. select_subset_helper,select_subset_helper_pd)
  14. from gucompaper.load import load_decode
  15. from gucompaper.changeOfMind_triggered import linear_map
  16. from gucompaper.changeOfMind_triggered_position import load_triggered_position_decode_day
  17. from gucompaper.Analysis_SGU import TrialChoice,DecodeIngredients,ChangeofMind,get_linearization_map,ChangeofMindTriggeredDecode,ChangeofMindRemoteTheta
  18. from gucompaper.changeOfMind_remote import is_rat_interior
  19. from gucompaper.changeOfMind import nodes, vectors
  20. from scipy import stats
  22. def parse_remote_master(animal,list_of_days,params,minimum_duration = 0.02, min_sum_posterior = 0.2, fill_spyglass = False):
  23. """This function calls find_remote_theta_animal() and saves the data"""
  25. all_info_animal, info_animal, time_intervals_animal, arm_identities_animal = find_remote_theta_animal(
  26. animal,list_of_days,fill_spyglass = fill_spyglass,
  27. minimum_duration = minimum_duration,
  28. min_sum_posterior = min_sum_posterior,
  29. **params)
  31. success = 1
  32. #all_info_animal_control, info_animal_control, time_intervals_animal_control, arm_identities_animal_control = find_remote_theta_animal(
  33. # animal,list_of_days,classifier_param_name,encoding_set,control=True,fill_spyglass = False,**params)
  35. #success = save_remote_animal(animal, list_of_days, encoding_set, classifier_param_name,params,
  36. # all_info_animal, info_animal, time_intervals_animal, arm_identities_animal,
  37. # all_info_animal_control, info_animal_control, time_intervals_animal_control, arm_identities_animal_control,
  38. # )
  39. return success
  42. output_folder = '/stelmo/shijie/change_of_mind_analysis/figure4/'
  43. def return_save_name_remote_parser(animal, encoding_set, classifier_param_name, d1, d2, proportion = 0.1, use_1d = 1):
  44. save_name = f'{animal.lower()}_{encoding_set}_{classifier_param_name}_{d1}_{d2}_p{proportion}_use1d{use_1d}'
  45. return save_name
  47. def save_remote_animal(animal, list_of_days, encoding_set, classifier_param_name, params,
  48. all_info_animal, info_animal, time_intervals_animal, arm_identities_animal,
  49. all_info_animal_control, info_animal_control, time_intervals_animal_control, arm_identities_animal_control
  50. ):
  52. d1= list_of_days[0]
  53. d2= list_of_days[-1]
  54. proportion = params["proportion"]
  55. use_1d = int(params["use_1d"])
  56. save_name = return_save_name_remote_parser(animal, encoding_set, classifier_param_name, d1, d2, proportion, use_1d)
  57. file_path = output_folder + save_name + '.pkl'
  59. data = {}
  60. (data["all_info_animal"],data["all_info_animal_control"],
  61. data["info_animal"], data["info_animal_control"],
  62. data["time_intervals_animal"], data["time_intervals_animal_control"],
  63. data["arm_identities_animal"], data["arm_identities_animal_control"]) = (
  64. all_info_animal,all_info_animal_control,
  65. info_animal, info_animal_control,
  66. time_intervals_animal,time_intervals_animal_control,
  67. arm_identities_animal, arm_identities_animal_control)
  69. # Open the file in binary write mode and dump the data
  70. with open(file_path, 'wb') as file:
  71. pickle.dump(data, file, protocol=pickle.HIGHEST_PROTOCOL)
  72. print(f"Data successfully pickled and saved to {file_path}")
  73. return 1
  75. def load_remote_animal(animal, list_of_days, encoding_set, classifier_param_name,
  76. proportion = 0.1, use_1d = 1, minimum_duration = 0.02, min_posterior = 0.2, spyglass = False):
  77. if spyglass:
  78. print("Loading from spyglass database instead of pickle file.")
  79. loaded_data = load_remote_animal_spyglass(animal, list_of_days,
  80. encoding_set,
  81. minimum_duration = minimum_duration,
  82. min_posterior = min_posterior,
  83. proportion = proportion, use_1d = use_1d)
  84. return loaded_data
  85. d1, d2 = list_of_days[0], list_of_days[-1]
  86. save_name = return_save_name_remote_parser(animal, encoding_set, classifier_param_name, d1, d2, proportion, use_1d)
  87. file_path = output_folder + save_name + '.pkl'
  89. with open(file_path, 'rb') as file:
  90. loaded_data = pickle.load(file)
  91. print(f"Successfully loaded data from '{file_path}':")
  92. return loaded_data
  94. def load_remote_animal_spyglass(animal, list_of_days, parameter_name, minimum_duration = 0.02,min_posterior=0.2,
  95. proportion = 0.1, use_1d = 1):
  96. """load from spyglass database instead of pickle file."""
  97. day_session_animal = []
  98. time_intervals_animal = []
  99. arm_identities_animal = []
  100. change_of_mind_num_animal = []
  102. for day in list_of_days:
  103. nwb_file_name = animal.lower() + day + '.nwb'
  104. nwb_copy_file_name = get_nwb_copy_filename(nwb_file_name)
  105. print(nwb_copy_file_name)
  106. session_interval, position_interval = runSessionNames(nwb_copy_file_name)
  107. remote_parameter = f"dur_{minimum_duration}_sum_{min_posterior}"
  108. for ind in range(len(session_interval)):
  110. session_name = session_interval[ind]
  111. position_name = position_interval[ind]
  112. epoch_num = int(session_name[:2])
  114. key_pre = {"nwb_file_name": nwb_copy_file_name, "epoch":epoch_num,
  115. "minimum_duration":minimum_duration,"remote_parameter":remote_parameter,
  116. "proportion":proportion, "parameter": parameter_name}
  117. query = ChangeofMindRemoteTheta & key_pre
  118. if len(query) == 0:
  119. print("No triggered decode found for ", key_pre)
  120. continue
  122. df = ChangeofMindRemoteTheta().fetch1_dataframe(key_pre)
  124. trials = df[df.has_remote_interval].index
  125. for trial in trials:
  126. remote_interval = df.loc[trial,'remote_interval']
  127. remote_content = df.loc[trial,'remote_content']
  128. change_of_mind_num = df.loc[trial,'change_of_mind_num']
  131. # if use post stopping content only
  132. # initial_stopping = df.loc[trial,'initial_time']
  133. # post_ind = [ind for ind in range(len(remote_interval)) if remote_interval[ind][0] >= initial_stopping]
  134. # remote_interval = [remote_interval[ind] for ind in post_ind]
  135. # remote_content = [remote_content[ind] for ind in post_ind]
  136. # if len(remote_content) == 0:
  137. # continue
  139. change_of_mind_num_animal.append(change_of_mind_num)
  140. day_session_animal.append([nwb_copy_file_name, session_name, [trial for i in range(len(remote_interval))]])
  141. time_intervals_animal.append(remote_interval)
  142. arm_identities_animal.append(remote_content)
  144. return {
  145. "info_animal": day_session_animal,
  146. "change_of_mind_num_animal": change_of_mind_num_animal,
  147. "time_intervals_animal": time_intervals_animal,
  148. "arm_identities_animal": arm_identities_animal
  149. }
  153. def find_remote_theta_animal(animal,list_of_days,
  154. parameter_name = None,
  155. use_1d = True,
  156. use_center = False, use_outer = False, use_home = True,
  157. proportion = 0.05,
  158. speed_threshold = 4,
  159. minimum_duration = 0.02,
  160. min_sum_posterior = 0.2,
  161. fill_spyglass = False):
  162. """
  163. default parameters should be:
  164. multiple_CoM = True, single_CoM = True, first_CoM = False,
  165. max_flag = True,
  166. delta_t_minus = 5,delta_t_plus = 5,
  167. "segment_only": False,
  169. Similar to find_remote_theta_animal_new(), but instead of a lumpsum of posterior in arms, it classfies intervals.
  170. use_1d: if True, use 1D decoding. if False, use 1D decoding collapsed from 2D decoding
  171. use_center: if True, consider moments when the rat in the center platform, and find decodes that in are outer arms
  172. use_home: if True, consider moments when the rat is in home arm, and find decodes that are in outer arms
  173. use_outer: if True, consider moments when the rat is in outer arms, and find decodes that are in all other outer arms including the home arm
  174. """
  175. if "2_state" in parameter_name:
  176. classifier_param_name = "default_decoding_gpu_4armMaze"
  177. elif "3_state" in parameter_name:
  178. classifier_param_name = "default_decoding_gpu_4armMaze_3states"
  179. else:
  180. classifier_param_name = "default_decoding_gpu_4armMaze"
  182. if "all_maze" in parameter_name:
  183. encoding_set = "all_maze"
  184. elif "run" in parameter_name:
  185. encoding_set = '2Dheadspeed_above_4'
  186. else:
  187. encoding_set = '2Dheadspeed_above_4'
  189. (day_session_animal, time_intervals_animal, arm_identities_animal) = (
  190. [],[],[])
  191. all_day_session_animal = [] # all the trials considered
  193. for day in list_of_days:
  194. nwb_file_name = animal.lower() + day + '.nwb'
  195. nwb_copy_file_name = get_nwb_copy_filename(nwb_file_name)
  196. print(nwb_copy_file_name)
  197. session_interval, position_interval = runSessionNames(nwb_copy_file_name)
  200. for ind in range(len(session_interval)):
  202. session_name = session_interval[ind]
  203. position_name = position_interval[ind]
  204. epoch_num = int(session_name[:2])
  206. # load triggered position and decode
  207. key_pre = {"nwb_file_name": nwb_copy_file_name, "epoch":epoch_num,
  208. "proportion":proportion, "parameter": parameter_name}
  209. query = ChangeofMindTriggeredDecode & key_pre
  210. if len(query) == 0:
  211. print("No triggered decode found for ", key_pre)
  212. continue
  213. parameters = (ChangeofMindTriggeredDecode & key_pre).fetch1("parameter_value")
  215. loaded_data = ChangeofMindTriggeredDecode().fetch1_dataframe(key_pre)
  216. (triggered_positions, triggered_positions_abs,
  217. triggered_times_triggered, triggered_times_abs,
  218. triggered_trial_infos) = (
  219. loaded_data["triggered_positions_baseoff"], loaded_data["triggered_positions"],
  220. loaded_data["time_triggered"], loaded_data["time_abs"],
  221. loaded_data["triggered_trial_info"],
  222. )
  223. # make triggered_positions a dataframe, with index of triggered_times_abs
  224. for tp_ind in range(len(triggered_positions)):
  225. triggered_positions[tp_ind] = pd.DataFrame({
  226. 'linear_position': triggered_positions[tp_ind],
  227. }, index = triggered_times_abs[tp_ind])
  228. triggered_positions_abs[tp_ind] = pd.DataFrame({
  229. 'linear_position': triggered_positions_abs[tp_ind],
  230. }, index = triggered_times_triggered[tp_ind])
  232. entry = DecodeIngredients & {'nwb_file_name':nwb_copy_file_name,
  233. 'interval_list_name':session_name}
  234. # position_1d,position_2d,
  235. position_1d = pd.read_csv(entry.fetch1('position_1d')) #still need 1D position
  236. position_2d = pd.read_csv(entry.fetch1('position_2d')) # need 2D position
  238. # load ChangeofMind info
  239. key={'nwb_file_name':nwb_copy_file_name,'epoch':epoch_num,'proportion': proportion}
  240. print(ChangeofMind & key)
  241. log = ChangeofMind().fetch1_dataframe(key)
  242. log2 = log.copy()
  244. # initialization, for spyglass insertion
  245. log2.insert(6,'has_remote_interval',[False for i in range(len(log2))])
  246. log2.insert(7,'remote_interval',[[] for i in range(len(log2))])
  247. log2.insert(8,'remote_content',[[] for i in range(len(log2))])
  248. log2.insert(9,'change_of_mind_num',[[] for i in range(len(log2))])
  250. # load decode
  251. results1d = load_decode(nwb_copy_file_name,
  252. session_name,
  253. classifier_param_name = classifier_param_name,
  254. encoding_set = encoding_set,
  255. use_1d = use_1d)
  256. #posterior1d = results1d.sum("state")
  258. event_indices_session = np.arange(len(triggered_positions))#[ind for ind in range(len(triggered_trial_infos)) if triggered_trial_infos[ind][1] == session_name]
  260. for event_index in event_indices_session:
  261. triggered_position = triggered_positions[event_index]
  262. triggered_position_abs = triggered_positions_abs[event_index]
  263. triggered_trial_info = triggered_trial_infos[event_index]
  265. (trial,
  266. time_interval,
  267. replayed_arm_identity) = find_remote_theta_interval(
  268. triggered_position, triggered_position_abs, triggered_trial_info,
  269. results1d, log, position_1d, position_2d,
  270. parameters["max_flag"],use_home,use_outer,use_center,
  271. minimum_duration = minimum_duration,
  272. min_sum_posterior = min_sum_posterior)
  275. if len(trial) > 0:
  276. print("Found remote theta in trial ", trial)
  277. day_session_animal.append([nwb_copy_file_name,session_name,trial])
  278. time_intervals_animal.append(time_interval)
  279. arm_identities_animal.append(replayed_arm_identity)
  281. trialID = trial[0]
  282. log2.loc[trialID,'has_remote_interval'] = True
  283. log2.at[trialID,'remote_interval'] += time_interval
  284. log2.at[trialID,'remote_content'] += replayed_arm_identity
  286. if len(log2.at[trialID,'change_of_mind_num']) == 0:
  287. log2.at[trialID,'change_of_mind_num'] += [0 for _ in range(len(replayed_arm_identity))]
  288. else:
  289. change_of_mind_num = int(np.max(log2.loc[trialID,'change_of_mind_num'])) + 1
  290. log2.at[trialID,'change_of_mind_num'] += [change_of_mind_num for _ in range(len(replayed_arm_identity))]
  291. all_day_session_animal.append([nwb_copy_file_name,session_name,trial])
  293. # save back to spyglass
  294. if fill_spyglass:
  295. q = {}
  296. q["parameter"] = parameter_name
  297. q["pandas"] = log2.to_dict()
  298. q["nwb_file_name"] = nwb_copy_file_name
  299. q["epoch"] = epoch_num
  300. q["proportion"] = proportion
  301. q["remote_parameter"] = f"dur_{minimum_duration}_sum_{min_sum_posterior}"
  302. ChangeofMindRemoteTheta().insert1(q, replace = True)
  304. return all_day_session_animal, day_session_animal,time_intervals_animal,arm_identities_animal
  306. def find_remote_interval(decode_subset, position2d, threshold = 20, minimum_duration = 0.02):
  308. position_axis = np.array(decode_subset.coords['position'])
  309. posterior_position_subset = decode_subset.causal_posterior.sum(dim='state')
  310. max_posterior_position1d = np.array(position_axis[posterior_position_subset.argmax(dim = 'position')])
  311. max_posterior_position2d = loc1d_to_2d_vector(max_posterior_position1d)
  313. # find remote time
  314. is_remote = np.sqrt(np.sum((max_posterior_position2d - position2d) ** 2, axis = 1)) > threshold
  316. is_remote_pd = pd.Series(is_remote, index = decode_subset.time)
  317. is_remote_segments = np.array(segment_boolean_series(
  318. is_remote_pd, minimum_duration=minimum_duration))
  320. if len(is_remote_segments) == 0:
  321. return [],[]
  323. time_intervals = []
  324. arm_identity = []
  326. for i in range(is_remote_segments.shape[0]):
  328. (t0,t1) = is_remote_segments[i]
  330. # restrict to continuous state:
  331. # length of the continuous state should be greater than 20ms
  332. decode_subset_ = select_subset_helper(decode_subset,(t0,t1))
  333. state_subset = np.array(decode_subset_.causal_posterior.sum(dim='position'))
  334. time=np.array(decode_subset_.causal_posterior.time)
  336. snippets_conti = find_start_end(state_subset[:,0] > 0.5) #continuous
  337. snippets = [time[s] for s in snippets_conti if np.diff(time[s])[0]>minimum_duration]
  339. for s in range(len(snippets)):
  341. (t0_peak,t1_peak) = snippets[s]
  343. # overall sum of decode posterior in the max posterior arm should be greater than 0.2
  344. posterior_by_arm = position_posterior2arm_posterior(
  345. select_subset_helper(posterior_position_subset,snippets[s]),
  346. linear_map)
  348. # classify the max/mean posterior arm, exclude the arm the animal is physically at
  349. subset_ind = (decode_subset.time >= t0_peak) & (decode_subset.time <= t1_peak)
  350. subset_arm_snippet = linear2arm_including_home(max_posterior_position1d[subset_ind])
  351. if len(subset_arm_snippet) == 0:
  352. continue
  353. subset_arm_snippet = subset_arm_snippet[~np.isnan(subset_arm_snippet)]
  354. if len(subset_arm_snippet) == 0:
  355. continue
  357. modes = np.unique(subset_arm_snippet)
  358. final_arms = []
  359. for mode in modes:
  361. max_arm_ind = int(mode - 5)
  363. if np.mean(posterior_by_arm[max_arm_ind,:]) < 0.2:
  364. continue
  365. final_arms.append(max_arm_ind)
  367. time_intervals.append(snippets[s])
  368. arm_identity.append(final_arms)
  370. return time_intervals, arm_identity
  372. def find_remote_theta_interval(triggered_position,triggered_position_abs,triggered_trial_info,
  373. decode,log_df,position_1d,position_2d,
  374. max_flag = 1,use_home = False,use_outer = True, use_center = False,
  375. minimum_duration = 0.02, min_sum_posterior = 0.2): # in seconds
  376. """
  377. if home = 1: find remote representation at home arm during running instead of at outer well.
  379. # 1. find time points out side of arm position
  380. # 2. for each time interval, find arm
  381. # decode should pass certain criteria:
  382. # (a) be continuous in decoder state
  383. # (b) posterior >= threshold%
  384. # 3. return for each trial a list of time range and arm identity for the decode
  386. INPUT: decode should be the absolute
  387. """
  388. position_axis = np.array(decode.coords['position'])
  390. # find the arm the animal is at
  391. subset_arm = triggered_trial_info[-1] + 5
  393. # find the trial
  394. # find t0, t1 to consider
  395. trialID = triggered_trial_info[-2]
  396. (t0, t1) = (triggered_position.index[0],triggered_position.index[-1])
  398. if use_home:
  399. timestamp_H = log_df.loc[trialID,'timestamp_H']
  400. if not np.isnan(timestamp_H):
  401. t0 = timestamp_H
  403. # set by time
  404. position2d_subset = position_2d[np.logical_and(position_2d.time>=t0, position_2d.time<=t1)]
  405. position1d_subset = position_1d[np.logical_and(position_1d.time>=t0, position_1d.time<=t1)]
  406. decode_subset = select_subset_helper(decode,(t0,t1))
  407. if abs(len(position1d_subset) - len(decode_subset.time)) > 3:
  408. print("skipped due to decode and camera time frame do not fully match.")
  409. return [],[],[]
  411. # set by location
  412. if use_home:
  413. subset_arm = 5
  414. # set by location
  415. #animal is physically at the home segment and not in the well area
  416. #stricter: remove well area
  417. subset_ind = np.logical_and(np.array(position1d_subset.linear_position) >= 10,
  418. np.array(position1d_subset.linear_position) <= linear_map[1][1])
  419. elif use_outer:
  421. # set by location
  422. subset_ind = position1d_subset.track_segment_id == subset_arm
  423. else: # use center
  424. subset_arm = 5
  425. p_rat = np.hstack((np.array(position2d_subset.head_position_x).reshape((-1,1)),
  426. np.array(position2d_subset.head_position_y).reshape((-1,1))))
  427. subset_ind = is_rat_interior(p_rat)
  429. position2d_subset = position2d_subset[subset_ind]
  430. position1d_subset = position1d_subset[subset_ind]
  431. decode_subset = decode_subset.isel(time = np.argwhere(subset_ind).ravel())
  433. # all previous operations restrict time to consider
  436. posterior_position_subset = decode_subset.causal_posterior.sum(dim='state')
  437. # chew down decode to either mean or max position
  438. # get max posterior
  439. if max_flag:
  440. max_posterior_position = np.array(position_axis[posterior_position_subset.argmax(dim = 'position')])
  441. # get mean posterior
  442. else:
  443. posterior_position_subset_array = np.array(posterior_position_subset).T
  444. posterior_position_subset_array = posterior_position_subset_array/np.sum(posterior_position_subset_array, axis = 0)
  445. max_posterior_position = np.matmul(position_axis,posterior_position_subset_array)
  447. # find remote time
  448. is_remote = np.zeros_like(max_posterior_position) #just to initialize
  449. if use_home: # find remote arm representations when the animal is in the home arm
  451. for k in region.keys():
  452. (arm_base, arm_top) = region[k]
  453. is_remote = is_remote + np.logical_and(max_posterior_position <= arm_top, max_posterior_position >= arm_base)
  455. elif use_outer: # find remote representations when the animal is in outer arms
  456. # find representation in other arms
  457. for k in region.keys():
  458. if k == int(subset_arm):
  459. continue
  460. (arm_base, arm_top) = region[k]
  461. is_remote = is_remote + np.logical_and(max_posterior_position <= arm_top, max_posterior_position >= arm_base)
  462. # find remote representation at home
  463. is_remote = is_remote + np.logical_and(max_posterior_position >= 0, max_posterior_position <= linear_map[0][1])
  464. else: # use center
  465. for k in region.keys():
  466. (arm_base, arm_top) = region[k]
  467. is_remote = is_remote + np.logical_and(max_posterior_position <= arm_top, max_posterior_position >= arm_base)
  470. # restrict to moving time
  471. is_moving = np.array(position2d_subset.head_speed) > 4
  472. min_len = np.min([len(is_moving),len(is_remote)])
  473. # choose min because one variable is a subset of decode and the other is a subset of position.
  474. # there could be 1 or 2 time point difference.
  475. is_moving = is_moving[:min_len]
  476. is_remote = is_remote[:min_len]
  478. is_remote = np.logical_and(is_remote, is_moving)
  480. if min_sum_posterior == 0:
  481. # if no posterior threshold, there will be no continuity and state requirement,
  482. trials = [trialID]
  483. arm_identity = [0,1,2,3,4] # all arms including home arm
  484. time_intervals = []
  485. # for each region, count the number of time bins that the max posterior position falls into that region,
  486. for k in [5,6,7,8,9]:
  487. (arm_base, arm_top) = region[k]
  488. time_in_arm = np.logical_and(max_posterior_position <= arm_top, max_posterior_position >= arm_base)
  489. time_in_arm = time_in_arm[:min_len]
  490. time_in_arm = np.logical_and(time_in_arm, is_remote)
  491. delta_t = np.sum(time_in_arm) * np.median(np.diff(posterior_position_subset.time))
  492. t0 = float(posterior_position_subset.time[0])
  493. time_intervals.append((t0, t0 + delta_t))
  494. return trials, time_intervals, arm_identity
  496. is_remote_pd = pd.Series(is_remote, index = posterior_position_subset.time)
  497. is_remote_segments = np.array(segment_boolean_series(
  498. is_remote_pd, minimum_duration=minimum_duration))
  501. if len(is_remote_segments) == 0:
  502. return [],[],[]
  504. time_intervals = []
  505. arm_identity = []
  506. trials = []
  511. for i in range(is_remote_segments.shape[0]):
  513. (t0,t1) = is_remote_segments[i]
  515. # restrict to continuous state:
  516. # length of the continuous state should be greater than 20ms
  517. decode_subset_ = select_subset_helper(decode_subset,(t0,t1))
  518. state_subset = np.array(decode_subset_.causal_posterior.sum(dim='position'))
  519. time=np.array(decode_subset_.causal_posterior.time)
  521. snippets_conti = find_start_end(state_subset[:,0] > 0.5) #continuous
  522. snippets = [time[s] for s in snippets_conti if np.diff(time[s])[0]>minimum_duration]
  524. for s in range(len(snippets)):
  526. (t0_peak,t1_peak) = snippets[s]
  528. # overall sum of decode posterior in the max posterior arm should be greater than 0.2
  529. posterior_by_arm = position_posterior2arm_posterior(
  530. select_subset_helper(posterior_position_subset,snippets[s]),
  531. linear_map)
  533. # classify the max/mean posterior arm, exclude the arm the animal is physically at
  534. subset_ind = (posterior_position_subset.time >= t0_peak) & (posterior_position_subset.time <= t1_peak)
  535. subset_arm_snippet = linear2arm_including_home(max_posterior_position[subset_ind])
  536. if len(subset_arm_snippet) == 0:
  537. continue
  538. subset_arm_snippet = subset_arm_snippet[~np.isnan(subset_arm_snippet)]
  539. if len(subset_arm_snippet) == 0:
  540. continue
  542. mode, count = stats.mode(subset_arm_snippet)
  544. if mode == subset_arm or count <= (len(subset_arm_snippet) * 0.8):
  545. #ambiguous situation, we will not consider those
  546. continue
  548. max_arm_ind = int(mode - 5)
  550. if np.mean(posterior_by_arm[max_arm_ind,:]) < min_sum_posterior:
  551. continue
  553. time_intervals.append(snippets[s])
  554. arm_identity.append(max_arm_ind)
  555. trials.append(trialID)
  556. return trials, time_intervals, arm_identity
  559. def linear2arm(position):
  560. arm = np.zeros_like(position) + np.nan
  561. for p_ind in range(len(position)):
  562. p = position[p_ind]
  563. for k in region.keys():
  564. if p>=region[k][0] and p<region[k][1]:
  565. arm[p_ind] = k
  566. continue
  567. return arm
  569. def linear2arm_including_home(position):
  570. arm = np.zeros_like(position) + np.nan
  571. for p_ind in range(len(position)):
  572. p = position[p_ind]
  573. for k in region.keys():
  574. if p>=region[k][0] and p<region[k][1]:
  575. arm[p_ind] = k
  576. continue
  577. if p >= 0 and p <= linear_map[0][1]:
  578. arm[p_ind] = 5
  579. return arm
  581. def add_trial(t0,log_df):
  582. trial_ind=np.array(log_df.index)
  583. trial_number = trial_ind[np.argwhere((np.array(log_df.timestamp_O[:-1])-t0) > 0).ravel()[0]]
  584. return trial_number
  586. def dotproduct(head_direction, arm):
  587. # arms are 0,1,2,3,4.
  589. # get arm direction
  590. arm_vector = vectors[arm + 5]
  592. return np.dot(head_direction, arm_vector)
  594. #### return angle between remote content and the rat head direction
  595. ### code in figure4d calls the following functions
  597. def find_angle(max_posterior_2d,head_orientation,animal_location):
  598. # in radian
  600. # make unit vector
  601. head_orientation_unit = np.hstack((np.cos(head_orientation).reshape((-1,1)),np.sin(head_orientation).reshape((-1,1)))) #unit vector
  602. displacement_unit = max_posterior_2d - animal_location
  603. displacement_unit = displacement_unit / np.linalg.norm(displacement_unit, axis = 1).reshape((-1,1))
  604. # shape of both displacement_unit and head_orientation_unit are (number of time bin, 2)
  606. # finally: return radian between head orientation and remote content
  607. dot_product = [np.dot(head_orientation_unit[i],displacement_unit[i].T) for i in range(displacement_unit.shape[0])]
  608. angle = np.arccos(np.clip(dot_product, -1.0, 1.0))
  610. return angle, head_orientation_unit, displacement_unit
  612. linear_map,welllocations = get_linearization_map()
  613. linear_map_arms = linear_map[[0,3,5,7,9]]
  615. def loc1d_to_2d_vector(loc1d_vector, arm = None):
  616. loc2d_vector = np.array([loc1d_to_2d(loc1d, arm) for loc1d in loc1d_vector])
  617. return loc2d_vector
  619. def loc1d_to_2d(loc1d, arm_avoid = None):
  620. # linear_map is like this:
  621. # array([[ 57.63896252, 0. ], arm 0 base - outer
  622. # [165.66041604, 252.64353221], arm 1 base - outer
  623. # [331.10211383, 418.29227956], arm 2 base - outer
  624. # [496.49241045, 583.18763812], arm 3 base - outer
  625. # [657.72023142, 743.03215907]]). arm 4 base - outer
  627. # the arm the 1d location belongs, 1-indexed
  628. row_ind = np.argwhere(np.logical_and(linear_map_arms[:,0] <= loc1d, linear_map_arms[:,1] > loc1d)).ravel()
  629. if len(row_ind) == 0:
  630. return np.array([np.nan,np.nan])
  631. arm_id = int(row_ind)
  632. if arm_id == arm_avoid:
  633. return np.array([np.nan,np.nan])
  635. # the base - outer 1d
  636. arm = linear_map_arms[arm_id].ravel()
  637. if arm_id == 0:
  638. arm = arm[::-1]
  640. # convert to proportion
  641. proportion = (loc1d - arm[0])/(arm[1]-arm[0])
  643. # get 2D node location
  644. node = nodes[int(arm_id + 5)]
  645. loc2d = (node[1] - node[0]) * proportion + node[0]
  647. return loc2d
  649. def loc1d_to_baseoff_vector(loc1d_vector, arm_avoid = None):
  650. loc2d_vector = np.array([loc1d_to_baseoff(loc1d) for loc1d in loc1d_vector])
  651. return loc2d_vector
  653. def loc1d_to_baseoff(loc1d, arm_avoid = None):
  654. # linear_map is like this:
  655. # array([[ 0, 57.63896252], arm 0 base - outer
  656. # [165.66041604, 252.64353221], arm 1 base - outer
  657. # [331.10211383, 418.29227956], arm 2 base - outer
  658. # [496.49241045, 583.18763812], arm 3 base - outer
  659. # [657.72023142, 743.03215907]]). arm 4 base - outer
  661. # the arm the 1d location belongs, 1-indexed
  662. row_ind = np.argwhere(np.logical_and(linear_map_arms[:,0] <= loc1d, linear_map_arms[:,1] > loc1d)).ravel()
  663. if len(row_ind) == 0:
  664. return np.array([np.nan,np.nan])
  665. arm_id = int(row_ind)
  666. if arm_id == arm_avoid:
  667. return np.array([np.nan,np.nan])
  669. # the base - outer 1d
  670. arm = linear_map_arms[arm_id].ravel()
  671. d = loc1d - arm[0]
  672. if arm_id == 0:
  673. d = arm[1] - loc1d
  675. return arm_id, d

changeOfMind_remote_interval.py at commit 0f0c9a7, no license · at the source

Overview

Authors: Shijie Gu1, Chenyan Liu2,3, Anna K. Gillespie2,4, Rhino Nevers5, Eric L. Denovellis2, Michael E. Coulter2, Kenneth Kay2, Loren M. Frank2,6,7
ORCID iDs: Shijie Gu, Chenyan Liu, Anna K. Gillespie, Rhino Nevers, Eric L. Denovellis, Michael E. Coulter, Kenneth Kay, Loren M. Frank
  1. UC Berkeley – UCSF Joint Graduate Program in Bioengineering, University of California, San Francisco, 94143, USA
  2. Department of Physiology, University of California, San Francisco, 94143, USA
  3. Graduate Program in Computational Neuroscience, University of Chicago, Chicago, 60637, USA
  4. Department of Neurobiology & Biophysics, University of Washington, Seattle, 98195, USA
  5. Neuroscience Graduate Program, University of California San Francisco, San Francisco, 94143, USA
  6. Howard Hughes Medical Institute, University of California, San Francisco, 94143, USA
  7. Kavli Institute for Fundamental Neuroscience, University of California, San Francisco, 94143, USA
Journal: bioRxiv : the preprint server for biology, article 2026.05.26.727951
Dates: published online 27 May 2026
Type: Research article · Language: English
License: CC BY-NC
Identifiers: DOI · PMCID PMC13232212
Status: code verified
Methods: Machine learning
Funding: UC Berkeley – UCSF Joint Graduate Program in Bioengineering, SG; Simons Foundation, SG, CL, AKG, MEC, LF (542981); K99, NIA, AKG (K99AG068425); Howard Hughes Medical Institute (RN, ELD, KK, LF)
Citations: 38 references in the paper

Abstract

Changing one’s mind — revising a past decision independently of external cues — can lead to better outcomes, but its neural basis remains poorly understood. We therefore developed a challenging spatial task for rats where a conflict between innate foraging biases and task rules leads to abundant, spontaneous, and characteristically corrective changes-of-mind (COMs). Neural recordings in the hippocampus, a brain region implicated in counterfactual thinking, revealed two distinct stages wherein more local representations gave way to representations of distant alternatives after animals had begun to reverse course. These representations predicted their eventual choice, and often serially encoded trial start and end locations. Our novel task paradigm reveals distinct representational phases engaged during self-correction and uncovers a rich repertoire of hippocampal spatial representations tied to behavior.

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

Repositories

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

Zenodo 20371883

License: CC-BY-4.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: the end of the paper
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (76 files), pandas (63 files), Matplotlib (48 files), SciPy (42 files), xarray (35 files), Neurodata Without Borders (PyNWB, MatNWB) (9 files), statsmodels (8 files), seaborn (6 files), CuPy (5 files), scikit-learn (5 files), SpikeInterface (4 files), Elephant (2 files), Neo (2 files), OpenCV (2 files), JAX (1 file), NetworkX (1 file), Pillow (1 file), scikit-image (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
86 files
At the source: zenodo.org/records/20371883

shijiegu/gu2026

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 0f0c9a7dadba3b5c9cbf2e8f3ac3372cff9726ee, 24 May 2026
Languages: Python (84), Jupyter (1)
Size: 89 files, 85 scripts
Software Heritage: not archived
Found in: the Zenodo archive record
Holds: README, environment (pyproject.toml), 1 notebook
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (76 files), pandas (63 files), Matplotlib (48 files), SciPy (42 files), xarray (36 files), Neurodata Without Borders (PyNWB, MatNWB) (9 files), statsmodels (8 files), CuPy (5 files), scikit-learn (5 files), seaborn (5 files), SpikeInterface (4 files), Elephant (2 files), Neo (2 files), OpenCV (2 files), JAX (1 file), NetworkX (1 file), Pillow (1 file), scikit-image (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
86 files
At the source: github.com/shijiegu/Gu2026/tree/v1.1

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

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

Data

Datasets cited

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, pages, dates, 8 authors, 4 funders, 30 references.

Cite

This paper

Gu, S., Liu, C., Gillespie, A. K., Nevers, R., Denovellis, E. L., Coulter, M. E., Kay, K., & Frank, L. M. (2026). Naturalistic behavior and self-generated neural activity predictive of self-correction. bioRxiv : the preprint server for biology, 2026.05.26.727951.

BibTeX

@article{gu2026naturalistic,
author = {Gu, Shijie and Liu, Chenyan and Gillespie, Anna K. and Nevers, Rhino and Denovellis, Eric L. and Coulter, Michael E. and Kay, Kenneth and Frank, Loren M.},
title = {{Naturalistic behavior and self-generated neural activity predictive of self-correction}},
journal = {bioRxiv : the preprint server for biology},
year = {2026},
month = may,
pages = {2026.05.26.727951},
publisher = {bioRxiv},
issn = {2692-8205},
pmcid = {PMC13232212}
}

RIS

TY - JOUR
AU - Gu, Shijie
AU - Liu, Chenyan
AU - Gillespie, Anna K.
AU - Nevers, Rhino
AU - Denovellis, Eric L.
AU - Coulter, Michael E.
AU - Kay, Kenneth
AU - Frank, Loren M.
TI - Naturalistic behavior and self-generated neural activity predictive of self-correction
T2 - bioRxiv : the preprint server for biology
J2 - bioRxiv
PY - 2026
DA - 2026/05/27
SP - 2026.05.26.727951
SN - 2692-8205
PB - bioRxiv
LA - en
ER -

CSL-JSON

{
"id": "pmcid:PMC13232212",
"type": "article-journal",
"title": "Naturalistic behavior and self-generated neural activity predictive of self-correction",
"container-title": "bioRxiv : the preprint server for biology",
"author": [
{
"family": "Gu",
"given": "Shijie"
},
{
"family": "Liu",
"given": "Chenyan"
},
{
"family": "Gillespie",
"given": "Anna K."
},
{
"family": "Nevers",
"given": "Rhino"
},
{
"family": "Denovellis",
"given": "Eric L."
},
{
"family": "Coulter",
"given": "Michael E."
},
{
"family": "Kay",
"given": "Kenneth"
},
{
"family": "Frank",
"given": "Loren M."
}
],
"container-title-short": "bioRxiv",
"page": "2026.05.26.727951",
"PMCID": "PMC13232212",
"ISSN": "2692-8205",
"publisher": "bioRxiv",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
27
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41593-026-02232-0 [code]
Entorhinal cortex represents task-relevant remote locations independently of CA1.
Journal: Nature neuroscience
In common: SpikeInterface, Neurodata Without Borders (PyNWB, MatNWB), xarray, 11 other tools, 2 references
[2] doi:10.1002/hipo.70131 [code]
Decoding Medial Entorhinal Cortical Dynamics Produces Planning-Like Alternations in Hippocampal theta Sequences.
Journal: Hippocampus
In common: JAX, xarray, OpenCV, 5 other tools, 6 references
[3] doi:10.1016/j.isci.2026.115488 [code]
An integrated &lt;i&gt;i&lt;/i&gt; &lt;i&gt;n vitro&lt;/i&gt; platform and biophysical modeling approach for studying synaptic transmission in isolated neuronal pairs.
Journal: iScience
In common: Elephant, Neo, SpikeInterface, 10 other tools
[4] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: Neo, SpikeInterface, Neurodata Without Borders (PyNWB, MatNWB), 9 other tools
[5] doi:10.1016/j.celrep.2026.117420 [code]
Neural population dynamics of direct electrical stimulation of neocortex.
Journal: Cell reports
In common: Neurodata Without Borders (PyNWB, MatNWB), JAX, NetworkX, 10 other tools
[6] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: CuPy, JAX, NetworkX, 10 other tools
[7] doi:10.1126/sciadv.aeg6797 [code]
Dorsoventral gradient of theta sweeps in the medial entorhinal cortex.
Journal: Science advances
In common: JAX, NetworkX, statsmodels, 6 other tools, 3 references
[8] doi:10.1016/j.isci.2026.116825 [code]
Social hierarchy shapes behavioral and transcriptional responses to chronic stress and ketamine in male mice.
Journal: iScience
In common: CuPy, NetworkX, OpenCV, 9 other tools
[9] doi:10.1371/journal.pcbi.1014752 [code]
Hierarchical feature binding in a spiking neural network model of the primate ventral visual pathway.
Journal: PLoS computational biology
In common: Elephant, Neo, xarray, 6 other tools
[10] doi:10.1038/s41593-026-02365-2 [code]
Hippocampal theta sweeps indicate goal direction during navigation.
Journal: Nature neuroscience
In common: JAX, SciPy, Matplotlib, 1 other tool, 6 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

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