OSCR

Visuomotor decision-making through multifeature convergence in the larval zebrafish hindbrain.

Code ↔ Paper

26 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 26 matches
  1. [1] § Results › Neuron morphology of computational units refines model structure ↔ figure5_S8_photoactivations.py, lines 1099–1156 · score 0.98 · stratum album centrale, stratum griseum centrale, griseum superficiale, stratum fibrosum, intermediate hypothalamus, interpeduncular nucleus
  2. [2] § Methods › KDE binary mask generation and mapzebrain atlas-based anatomical analysis ↔ figure5_S8_photoactivations.py, lines 868–953 · score 0.92 · neurons project posterior, neurons project ventral, front pathway, neurons project anterior, lateral pathway, tectal neuron
  3. [3] § Methods › KDE binary mask generation and mapzebrain atlas-based anatomical analysis ↔ figure5_S8_photoactivations.py, lines 868–953 · score 0.90 · lateral_cross_neurons, front pathway, local_ipsi, anterior hindbrain neurons, lateral pathway, tectal neurons
  4. [4] § Methods › Synthetic data simulation ↔ figure3_S3_S4_imaging_modelbased.py, lines 1830–1906 · score 0.88 · added Gaussian noise, create synthetic, GCaMP, model node, activity trace, Poisson
  5. [5] § Results › Neuron morphology of computational units refines model structure ↔ figure3_S3_S4_imaging_modelbased.py, lines 2197–2239 · score 0.83 · tectal neuropil, dorsal thalamus, luminance increase detectors, luminance decrease detectors, luminance change detectors, intermediate
  6. [6] § Methods › Additive and winner-takes-all steady-state models and fitting strategy ↔ figure1_behavior_overview.py, lines 164–188 · score 0.74 · winner takes, model hypothesis, stimulus model, additive model, bias, guess
  7. [7] § Results › Model-predicted activity is represented across the brain ↔ figure3_S3_S4_imaging_modelbased.py, lines 2197–2239 · score 0.74 · superior dorsal medulla, periventricular layer, oblongata stripe, model node, logical statements, multifeature integrators
  8. [8] § Methods › KDE binary mask generation and mapzebrain atlas-based anatomical analysis ↔ figure5_S8_photoactivations.py, lines 1099–1156 · score 0.70 · superior dorsal medulla, oblongata stripe, soma, masks, mapzebrain, ZBRAIN
  9. [9] § Methods › KDE binary mask generation and mapzebrain atlas-based anatomical analysis ↔ figure5_S8_photoactivations.py, lines 786–824 · score 0.70 · local_ipsi, project anterior, contra, posterior, hemisphere, ventral
  10. [10] § Results › Neuron morphology of computational units refines model structure ↔ figure5_S8_photoactivations.py, lines 16–164 · score 0.70 · Reference brain regions, neuron morphology, full brain, Scale bar, cerebellum, pa
  11. [11] § Methods › Threshold-and-width-based psychometric curve fitting ↔ figureS1_psychometricfits.py, lines 38–150 · score 0.69 · psychometric curve, curve_fit, single fish, guess, width, threshold
  12. [12] § Results › Excitation and inhibition are largely balanced across motion and lateral luminance processing neurons ↔ figure4-S7/figure4_S7_hcr.py, lines 402–546 · score 0.67 · G8s pre, G8s post, situ image, overlay, channel, vglut
  13. [13] § Results › A three-pathway model captures behavioral dynamics to multifeature stimulus configurations ↔ figure3_S3_S4_imaging_modelbased.py, lines 69–201 · score 0.67 · luminance change pathway, motion pathway, integrated motion, mutual, decayed, repulsive
  14. [14] § Methods › Model fitting ↔ figure2_S2_behavior_tempdynamics.py, lines 1304–1362 · score 0.66 · unifeature training, training rounds, fitted parameter, median, split, MSE
  15. [15] § Results › A three-pathway model captures behavioral dynamics to multifeature stimulus configurations ↔ figure2_S2_behavior_tempdynamics.py, lines 1045–1170 · score 0.65 · black backgrounds, model fitting, lumi change, SEM, rows, training
  16. [16] § Results › A three-pathway model captures behavioral dynamics to multifeature stimulus configurations ↔ figure2_S2_behavior_tempdynamics.py, lines 405–476 · score 0.65 · luminance change pathway, motion pathway, integrated motion, mutual, repulsive, sum
  17. [17] § Results › Addition of multifeature sensory cues captures sensorimotor decision-making ↔ figure2_S2_behavior_tempdynamics.py, lines 1419–1457 · score 0.64 · congruent stimuli, conflicting stimuli, luminance cues, lateral luminance, Swims, behavior
  18. [18] § Methods › Behavior data analysis ↔ figure1_behavior_overview.py, lines 105–125 · score 0.64 · right bouts, interbout interval, orientation change, behavior, fish
  19. [19] § Results › Addition of multifeature sensory cues captures sensorimotor decision-making ↔ figure1_behavior_overview.py, lines 459–594 · score 0.63 · relative interbout interval, individual fish, luminance stimuli, ns, orientation, behavior
  20. [20] § Methods › Imaging analysis with linear regression ↔ figure3_S3_S4_imaging_modelbased.py, lines 69–201 · score 0.61 · GCaMP, model predictions, linregress, decay, convolving, kernel
  21. [21] § Methods › HCR-FISH analysis ↔ figure4-S7/figure4_S7_hcr.py, lines 402–546 · score 0.59 · volume stacks, situ imaging, ANTs, HCR
  22. [22] § Methods › Behavior data analysis ↔ figure1_behavior_overview.py, lines 459–594 · score 0.57 · leftward stimuli, rightward stimuli, flipped, orientation, behavior, conflicts
  23. [23] § Results › Better separability of congruent than conflicting stimuli in low-dimensional space ↔ figure2_S2_behavior_tempdynamics.py, lines 1419–1457 · score 0.57 · congruent stimuli, conflicting stimuli, lateral luminance, cues, behavioral, model
  24. [24] § Methods › Behavior ↔ figure1_behavior_overview.py, lines 597–644 · score 0.56 · interbout interval, orientation change, raw, bouts, window, Behavior
  25. [25] § Results › A three-pathway model captures behavioral dynamics to multifeature stimulus configurations ↔ figure2_S2_behavior_tempdynamics.py, lines 1218–1260 · score 0.54 · unifeature trained model, multifeature trained model, pathways, behavior, motion, stimuli
  26. [26] § Methods › Additive network model ↔ figure2_S2_behavior_tempdynamics.py, lines 270–334 · score 0.52 · weighted sum, integrated motion, repulsive, attractive, luminance change, Additive

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 · 1,558 lines · 100 KB · no license · 7 matches

  1. import numpy as np
  2. from pathlib import Path
  3. import pandas as pd
  4. from multifeature_integration_paper.figure_helper import Figure
  5. from scipy.optimize import curve_fit
  6. from scipy.stats import ttest_ind
  7. from sklearn.model_selection import GroupShuffleSplit
  8. from scipy.ndimage import convolve1d
  9. from multifeature_integration_paper.useful_small_funcs import cohens_d, rolling_end_window, fill_nans
  11. def get_stim_input(folder_name, stim_len, stim_type, zero_coh=0.1):
  12. '''
  13. This function obtains the input to the models for each experiment stimulus.
  14. :param folder_name: Name of the experiment stimulus.
  15. :param stim_len: Length of the stimulus in 0.1s steps (e.g. a 25s stimulus is written here as 250).
  16. :param stim_type: Stimulus type (Motion, Photo, Same or Oppo)
  17. :param zero_coh: To avoid divisions by zero we set the perceived motion at 0% coherence to a small value.
  18. :return: Four input arrays: motion_left, motion_right, luminance_left, luminance_right.
  19. '''
  20. # Get the experiment specific parameters of when motion start and stops, luminance starts and stops. The strength factors measured from the data,
  21. # as well as the luminance factors pre/post stimulus and on the bright and dark side of the stimulus.
  22. if folder_name == 'converted_phototaxis_dotmotion_integration_simultaneous_white': # Simultaneous
  23. mot_on, mot_off, lumi_on, lumi_off = [50, 200, 50, 200]
  24. mot_fac, lumi_fac = [1., 1.]
  25. lumi_pre, lumi_bright, lumi_dark = [1., 1., 0.]
  26. elif folder_name == 'phototaxis_dotmotion_simultaneous_low_Sep': # Simultaneous low
  27. mot_on, mot_off, lumi_on, lumi_off = [200, 400, 200, 400]
  28. mot_fac, lumi_fac = [0.12, 1.17]
  29. lumi_pre, lumi_bright, lumi_dark = [1., 1., 0.]
  30. elif folder_name == 'converted_phototaxis_dotmotion_integration_peppersalt': # Peppersalt
  31. mot_on, mot_off, lumi_on, lumi_off = [50, 150, 150, 250]
  32. mot_fac, lumi_fac = [0.37, 0.19]
  33. lumi_pre, lumi_bright, lumi_dark = [0.7, 1., 0.]
  34. elif folder_name == 'phototaxis_dotmotion_reverse_Sep': # Reverse
  35. mot_on, mot_off, lumi_on, lumi_off = [150, 250, 50, 150]
  36. mot_fac, lumi_fac = [0.41, 1.29]
  37. lumi_pre, lumi_bright, lumi_dark = [1., 1., 0.]
  38. elif folder_name == 'phototaxis_dotmotion_white_Sep': # White
  39. mot_on, mot_off, lumi_on, lumi_off = [50, 150, 150, 250]
  40. mot_fac, lumi_fac = [0.33, 0.64]
  41. lumi_pre, lumi_bright, lumi_dark = [1., 1., 0.]
  42. elif folder_name == 'converted_phototaxis_dotmotion_integration_long':
  43. mot_on, mot_off, lumi_on, lumi_off = [50, 250, 250, 450]
  44. mot_fac, lumi_fac = [0.90, 1.00]
  45. lumi_pre, lumi_bright, lumi_dark = [0., 0.7, 0.]
  46. elif folder_name == 'beh_simultaneous_blackwhite_white':
  47. mot_on, mot_off, lumi_on, lumi_off = [50, 200, 50, 200]
  48. mot_fac, lumi_fac = [0.82, 0.53]
  49. lumi_pre, lumi_bright, lumi_dark = [1., 1., 0.]
  50. elif folder_name == 'beh_simultaneous_blackwhite_black':
  51. mot_on, mot_off, lumi_on, lumi_off = [50, 200, 50, 200]
  52. mot_fac, lumi_fac = [1.02, 1.08]
  53. lumi_pre, lumi_bright, lumi_dark = [0., 1., 0.]
  54. elif folder_name == 'phototaxis_dotmotion_integration_halfoverlap':
  55. mot_on, mot_off, lumi_on, lumi_off = [100, 250, 50, 200]
  56. mot_fac, lumi_fac = [1.00, 1.65]
  57. lumi_pre, lumi_bright, lumi_dark = [1., 1., 0.]
  58. elif folder_name == 'beh_simultaneous_10only':
  59. mot_on, mot_off, lumi_on, lumi_off = [50, 200, 50, 200]
  60. mot_fac, lumi_fac = [0.13, 1.04]
  61. lumi_pre, lumi_bright, lumi_dark = [1., 1., 0.]
  62. elif folder_name == 'imaging_prediction':
  63. mot_on, mot_off, lumi_on, lumi_off = [100, 400, 100, 400]
  64. mot_fac, lumi_fac = [1., 1.]
  65. lumi_pre, lumi_bright, lumi_dark = [0.3, 1., 0.]
  67. # Get the four inputs for the given stimulus type.
  68. if stim_type == 'Motion':
  69. left_input_mot = mot_fac * np.concatenate(
  70. (zero_coh * np.ones(mot_on), 1. * np.ones(mot_off - mot_on), zero_coh * np.ones(stim_len - mot_off)))
  71. right_input_mot = mot_fac * zero_coh * np.ones(stim_len)
  72. left_input_lumi = lumi_fac * lumi_pre * np.ones(stim_len)
  73. right_input_lumi = lumi_fac * lumi_pre * np.ones(stim_len)
  74. elif stim_type == 'Photo':
  75. left_input_mot = mot_fac * zero_coh * np.ones(stim_len)
  76. right_input_mot = mot_fac * zero_coh * np.ones(stim_len)
  77. left_input_lumi = lumi_fac * np.concatenate((lumi_pre * np.ones(lumi_on),
  78. lumi_bright * np.ones(lumi_off - lumi_on),
  79. lumi_pre * np.ones(stim_len - lumi_off)))
  80. right_input_lumi = lumi_fac * np.concatenate((lumi_pre * np.ones(lumi_on),
  81. lumi_dark * np.ones(lumi_off - lumi_on),
  82. lumi_pre * np.ones(stim_len - lumi_off)))
  83. elif stim_type == 'Same':
  84. left_input_mot = mot_fac * np.concatenate(
  85. (zero_coh * np.ones(mot_on), 1. * np.ones(mot_off - mot_on), zero_coh * np.ones(stim_len - mot_off)))
  86. right_input_mot = mot_fac * zero_coh * np.ones(stim_len)
  87. left_input_lumi = lumi_fac * np.concatenate((lumi_pre * np.ones(lumi_on),
  88. lumi_bright * np.ones(lumi_off - lumi_on),
  89. lumi_pre * np.ones(stim_len - lumi_off)))
  90. right_input_lumi = lumi_fac * np.concatenate((lumi_pre * np.ones(lumi_on),
  91. lumi_dark * np.ones(lumi_off - lumi_on),
  92. lumi_pre * np.ones(stim_len - lumi_off)))
  93. elif stim_type == 'Oppo':
  94. left_input_mot = mot_fac * np.concatenate(
  95. (zero_coh * np.ones(mot_on), 1. * np.ones(mot_off - mot_on), zero_coh * np.ones(stim_len - mot_off)))
  96. right_input_mot = mot_fac * zero_coh * np.ones(stim_len)
  97. left_input_lumi = lumi_fac * np.concatenate((lumi_pre * np.ones(lumi_on),
  98. lumi_dark * np.ones(lumi_off - lumi_on),
  99. lumi_pre * np.ones(stim_len - lumi_off)))
  100. right_input_lumi = lumi_fac * np.concatenate((lumi_pre * np.ones(lumi_on),
  101. lumi_bright * np.ones(lumi_off - lumi_on),
  102. lumi_pre * np.ones(stim_len - lumi_off)))
  104. return left_input_mot, right_input_mot, left_input_lumi, right_input_lumi
  106. def avg_mot_lumi(model_input, tau_mot=4.26, tau_ph_eye=12.66, tau_drive=6.46, w_mot=2.783, w_attractor_pos=0.126):
  107. '''
  108. This function contains the additive model with motion and luminance level.
  109. :param model_input: List of 5 input arrays (time, motion left, motion right, luminance left, luminance right).
  110. :param tau_mot: Timeconstant of the motion integrator.
  111. :param tau_ph_eye: Timeconstant of the luminance level integrator.
  112. :param tau_drive: Timeconstant of the multifeature integrator.
  113. :param w_mot: Weight of the motion pathway
  114. :param w_attractor_pos: Weight of the luminance level pathway.
  115. :return: Curve matching the percentage left swims over time.
  116. '''
  117. # We add some baseline activity to both multifeature nodes to avoid division by zero. Since both nodes contain this baseline, it doesn't affect the percentage left swims.
  118. baseline = 1
  120. time, left_input_mot, right_input_mot, left_input_ph, right_input_ph = model_input
  122. # Integrate motion
  123. exp_kernel_mot = np.concatenate((np.zeros(150), 1/tau_mot * np.exp(-np.linspace(0, 150, 151) / tau_mot)))
  124. exp_kernel_mot = exp_kernel_mot / np.sum(exp_kernel_mot)
  125. left_integrated_mot = convolve1d(left_input_mot, exp_kernel_mot)
  126. right_integrated_mot = convolve1d(right_input_mot, exp_kernel_mot)
  128. # Integrate luminance for each eye
  129. exp_kernel_ph_eye = np.concatenate((np.zeros(150), 1/tau_ph_eye * np.exp(-np.linspace(0, 150, 151) / tau_ph_eye)))
  130. exp_kernel_ph_eye = exp_kernel_ph_eye / np.sum(exp_kernel_ph_eye)
  131. left_integrated_ph = convolve1d(left_input_ph, exp_kernel_ph_eye)
  132. right_integrated_ph = convolve1d(right_input_ph, exp_kernel_ph_eye)
  134. # Linear weighted sum going ino the multifeature node (drive)
  135. drive_to_left = w_mot * left_integrated_mot + baseline + w_attractor_pos * left_integrated_ph
  136. drive_to_right = w_mot * right_integrated_mot + baseline + w_attractor_pos * right_integrated_ph
  138. # For integration of the drive
  139. exp_kernel_drive = np.concatenate((np.zeros(150), 1 / tau_drive * np.exp(-np.linspace(0, 150, 151) / tau_drive)))
  140. exp_kernel_drive = exp_kernel_drive / np.sum(exp_kernel_drive)
  141. left_integrated_drive = convolve1d(drive_to_left, exp_kernel_drive)
  142. right_integrated_drive = convolve1d(drive_to_right, exp_kernel_drive)
  144. # Get the ratio of leftward swims
  145. swims_to_left_tot = ((left_integrated_drive - right_integrated_drive) / (
  146. left_integrated_drive + right_integrated_drive) + 1) / 2
  148. # Apply a rolling window to match the data preprocessing. And transform ratios to percentages.
  149. swims_to_left_tot_rw = rolling_end_window(swims_to_left_tot, 20)
  150. swims_to_left_tot_rw = swims_to_left_tot_rw * 100
  151. swims_to_left_tot_rw[np.isinf(swims_to_left_tot_rw)] = 50
  152. swims_to_left_tot_rw[np.isnan(swims_to_left_tot_rw)] = 50
  154. return swims_to_left_tot_rw
  156. def avg_mot_change(model_input, tau_mot=4.26, tau_ph_rep=12.66, tau_drive=6.46, w_mot=2.783, w_repulsor_pos=1.857):
  157. '''
  158. This function contains the additive model with motion and changes in luminance.
  159. :param model_input: List of 5 input arrays (time, motion left, motion right, luminance left, luminance right).
  160. :param tau_mot: Timeconstant of the motion integrator.
  161. :param tau_ph_rep: Timeconstant of the integrator in the luminance change pathway.
  162. :param tau_drive: Timeconstant of the multifeature integrator.
  163. :param w_mot: Weight of the motion pathway
  164. :param w_repulsor_pos: Weight of the luminance change pathway.
  165. :return: Curve matching the percentage left swims over time.
  166. '''
  167. # We add some baseline activity to both multifeature nodes to avoid division by zero. Since both nodes contain this baseline, it doesn't affect the percentage left swims.
  168. baseline = 1
  170. time, left_input_mot, right_input_mot, left_input_ph, right_input_ph = model_input
  172. # Integrate motion
  173. exp_kernel_mot = np.concatenate((np.zeros(150), 1 / tau_mot * np.exp(-np.linspace(0, 150, 151) / tau_mot)))
  174. exp_kernel_mot = exp_kernel_mot / np.sum(exp_kernel_mot)
  175. left_integrated_mot = convolve1d(left_input_mot, exp_kernel_mot)
  176. right_integrated_mot = convolve1d(right_input_mot, exp_kernel_mot)
  178. # Calculate repulsion force
  179. exp_kernel_ph_rep = np.concatenate((np.zeros(150), 1 / tau_ph_rep * np.exp(-np.linspace(0, 150, 151) / tau_ph_rep)))
  180. exp_kernel_ph_rep = exp_kernel_ph_rep / np.sum(exp_kernel_ph_rep)
  181. left_integrated_rep = convolve1d(left_input_ph, exp_kernel_ph_rep)
  182. right_integrated_rep = convolve1d(right_input_ph, exp_kernel_ph_rep)
  184. dark_left = np.clip(left_integrated_rep - left_input_ph, 0, np.inf)
  185. dark_right = np.clip(right_integrated_rep - right_input_ph, 0, np.inf)
  186. bright_left = np.clip(left_input_ph - left_integrated_rep, 0, np.inf)
  187. bright_right = np.clip(right_input_ph - right_integrated_rep, 0, np.inf)
  188. repulsion_from_left = bright_left + dark_left
  189. repulsion_from_right = bright_right + dark_right
  191. # Linear weighted sum going ino the multifeature node (drive)
  192. drive_to_left = w_mot * left_integrated_mot + w_repulsor_pos * repulsion_from_right + baseline
  193. drive_to_right = w_mot * right_integrated_mot + w_repulsor_pos * repulsion_from_left + baseline
  195. # For integration of the drive
  196. exp_kernel_drive = np.concatenate((np.zeros(150), 1 / tau_drive * np.exp(-np.linspace(0, 150, 151) / tau_drive)))
  197. exp_kernel_drive = exp_kernel_drive / np.sum(exp_kernel_drive)
  198. left_integrated_drive = convolve1d(drive_to_left, exp_kernel_drive)
  199. right_integrated_drive = convolve1d(drive_to_right, exp_kernel_drive)
  201. # Get the ratio of leftward swims
  202. swims_to_left_tot = ((left_integrated_drive - right_integrated_drive) / (
  203. left_integrated_drive + right_integrated_drive) + 1) / 2
  205. # Apply a rolling window to match the data preprocessing. And transform ratios to percentages.
  206. swims_to_left_tot_rw = rolling_end_window(swims_to_left_tot, 20)
  207. swims_to_left_tot_rw = swims_to_left_tot_rw * 100
  208. swims_to_left_tot_rw[np.isinf(swims_to_left_tot_rw)] = 50
  209. swims_to_left_tot_rw[np.isnan(swims_to_left_tot_rw)] = 50
  211. return swims_to_left_tot_rw
  213. def avg_lumi_change(model_input, tau_ph_eye=12.66, tau_ph_rep=12.66, tau_drive=6.46, w_attractor_pos=0.126, w_repulsor_pos=1.857):
  214. '''
  215. This function contains the additive model with luminance level and changes in luminance.
  216. :param model_input: List of 5 input arrays (time, motion left, motion right, luminance left, luminance right).
  217. :param tau_ph_eye: Timeconstant of the luminance level integrator.
  218. :param tau_ph_rep: Timeconstant of the integrator in the luminance change pathway.
  219. :param tau_drive: Timeconstant of the multifeature integrator.
  220. :param w_attractor_pos: Weight of the luminance level pathway.
  221. :param w_repulsor_pos: Weight of the luminance change pathway.
  222. :return: Curve matching the percentage left swims over time.
  223. '''
  224. # We add some baseline activity to both multifeature nodes to avoid division by zero. Since both nodes contain this baseline, it doesn't affect the percentage left swims.
  225. baseline = 1
  227. time, left_input_mot, right_input_mot, left_input_ph, right_input_ph = model_input
  229. # Integrate luminance for each eye
  230. exp_kernel_ph_eye = np.concatenate((np.zeros(150), 1 / tau_ph_eye * np.exp(-np.linspace(0, 150, 151) / tau_ph_eye)))
  231. exp_kernel_ph_eye = exp_kernel_ph_eye / np.sum(exp_kernel_ph_eye)
  232. left_integrated_ph = convolve1d(left_input_ph, exp_kernel_ph_eye)
  233. right_integrated_ph = convolve1d(right_input_ph, exp_kernel_ph_eye)
  235. # Calculate repulsion force
  236. exp_kernel_ph_rep = np.concatenate((np.zeros(150), 1 / tau_ph_rep * np.exp(-np.linspace(0, 150, 151) / tau_ph_rep)))
  237. exp_kernel_ph_rep = exp_kernel_ph_rep / np.sum(exp_kernel_ph_rep)
  238. left_integrated_rep = convolve1d(left_input_ph, exp_kernel_ph_rep)
  239. right_integrated_rep = convolve1d(right_input_ph, exp_kernel_ph_rep)
  241. dark_left = np.clip(left_integrated_rep - left_input_ph, 0, np.inf)
  242. dark_right = np.clip(right_integrated_rep - right_input_ph, 0, np.inf)
  243. bright_left = np.clip(left_input_ph - left_integrated_rep, 0, np.inf)
  244. bright_right = np.clip(right_input_ph - right_integrated_rep, 0, np.inf)
  245. repulsion_from_left = bright_left + dark_left
  246. repulsion_from_right = bright_right + dark_right
  248. # Linear weighted sum going ino the multifeature node (drive)
  249. drive_to_left = w_repulsor_pos * repulsion_from_right + baseline + w_attractor_pos * left_integrated_ph
  250. drive_to_right = w_repulsor_pos * repulsion_from_left + baseline + w_attractor_pos * right_integrated_ph
  252. # For integration of the drive
  253. exp_kernel_drive = np.concatenate((np.zeros(150), 1 / tau_drive * np.exp(-np.linspace(0, 150, 151) / tau_drive)))
  254. exp_kernel_drive = exp_kernel_drive / np.sum(exp_kernel_drive)
  255. left_integrated_drive = convolve1d(drive_to_left, exp_kernel_drive)
  256. right_integrated_drive = convolve1d(drive_to_right, exp_kernel_drive)
  258. # Get the ratio of leftward swims
  259. swims_to_left_tot = ((left_integrated_drive - right_integrated_drive) / (
  260. left_integrated_drive + right_integrated_drive) + 1) / 2
  262. # Apply a rolling window to match the data preprocessing. And transform ratios to percentages.
  263. swims_to_left_tot_rw = rolling_end_window(swims_to_left_tot, 20)
  264. swims_to_left_tot_rw = swims_to_left_tot_rw * 100
  265. swims_to_left_tot_rw[np.isinf(swims_to_left_tot_rw)] = 50
  266. swims_to_left_tot_rw[np.isnan(swims_to_left_tot_rw)] = 50
  268. return swims_to_left_tot_rw
  270. def avg_mot_lumi_change(model_input, tau_mot=4.26, tau_ph_eye=12.66, tau_ph_rep=12.66, tau_drive=6.46,
  271. w_mot=2.783, w_attractor_pos=0.126, w_repulsor_pos=1.857):
  272. '''
  273. This function contains the additive model with motion, luminance level and changes in luminance.
  274. :param model_input: List of 5 input arrays (time, motion left, motion right, luminance left, luminance right).
  275. :param tau_mot: Timeconstant of the motion integrator.
  276. :param tau_ph_eye: Timeconstant of the luminance level integrator.
  277. :param tau_ph_rep: Timeconstant of the integrator in the luminance change pathway.
  278. :param tau_drive: Timeconstant of the multifeature integrator.
  279. :param w_mot: Weight of the motion pathway
  280. :param w_attractor_pos: Weight of the luminance level pathway.
  281. :param w_repulsor_pos: Weight of the luminance change pathway.
  282. :return: Curve matching the percentage left swims over time.
  283. '''
  284. # We add some baseline activity to both multifeature nodes to avoid division by zero. Since both nodes contain this baseline, it doesn't affect the percentage left swims.
  285. baseline = 1
  287. time, left_input_mot, right_input_mot, left_input_ph, right_input_ph = model_input
  289. # Integrate motion
  290. exp_kernel_mot = np.concatenate((np.zeros(150), 1 / tau_mot * np.exp(-np.linspace(0, 150, 151) / tau_mot)))
  291. exp_kernel_mot = exp_kernel_mot / np.sum(exp_kernel_mot)
  292. left_integrated_mot = convolve1d(left_input_mot, exp_kernel_mot)
  293. right_integrated_mot = convolve1d(right_input_mot, exp_kernel_mot)
  295. # Integrate luminance for each eye
  296. exp_kernel_ph_eye = np.concatenate((np.zeros(150), 1 / tau_ph_eye * np.exp(-np.linspace(0, 150, 151) / tau_ph_eye)))
  297. exp_kernel_ph_eye = exp_kernel_ph_eye / np.sum(exp_kernel_ph_eye)
  298. left_integrated_ph = convolve1d(left_input_ph, exp_kernel_ph_eye)
  299. right_integrated_ph = convolve1d(right_input_ph, exp_kernel_ph_eye)
  301. # Calculate repulsion force
  302. exp_kernel_ph_rep = np.concatenate((np.zeros(150), 1 / tau_ph_rep * np.exp(-np.linspace(0, 150, 151) / tau_ph_rep)))
  303. exp_kernel_ph_rep = exp_kernel_ph_rep / np.sum(exp_kernel_ph_rep)
  304. left_integrated_rep = convolve1d(left_input_ph, exp_kernel_ph_rep)
  305. right_integrated_rep = convolve1d(right_input_ph, exp_kernel_ph_rep)
  307. dark_left = np.clip(left_integrated_rep - left_input_ph, 0, np.inf)
  308. dark_right = np.clip(right_integrated_rep - right_input_ph, 0, np.inf)
  309. bright_left = np.clip(left_input_ph - left_integrated_rep, 0, np.inf)
  310. bright_right = np.clip(right_input_ph - right_integrated_rep, 0, np.inf)
  311. repulsion_from_left = bright_left + dark_left
  312. repulsion_from_right = bright_right + dark_right
  314. # Linear weighted sum going ino the multifeature node (drive)
  315. drive_to_left = w_mot * left_integrated_mot + w_repulsor_pos * repulsion_from_right + baseline + w_attractor_pos * left_integrated_ph
  316. drive_to_right = w_mot * right_integrated_mot + w_repulsor_pos * repulsion_from_left + baseline + w_attractor_pos * right_integrated_ph
  318. # For integration of the drive
  319. exp_kernel_drive = np.concatenate((np.zeros(150), 1 / tau_drive * np.exp(-np.linspace(0, 150, 151) / tau_drive)))
  320. exp_kernel_drive = exp_kernel_drive / np.sum(exp_kernel_drive)
  321. left_integrated_drive = convolve1d(drive_to_left, exp_kernel_drive)
  322. right_integrated_drive = convolve1d(drive_to_right, exp_kernel_drive)
  324. # Get the ratio of leftward swims
  325. swims_to_left_tot = ((left_integrated_drive - right_integrated_drive) / (
  326. left_integrated_drive + right_integrated_drive) + 1) / 2
  328. # Apply a rolling window to match the data preprocessing. And transform ratios to percentages.
  329. swims_to_left_tot_rw = rolling_end_window(swims_to_left_tot, 20)
  330. swims_to_left_tot_rw = swims_to_left_tot_rw * 100
  331. swims_to_left_tot_rw[np.isinf(swims_to_left_tot_rw)] = 50
  332. swims_to_left_tot_rw[np.isnan(swims_to_left_tot_rw)] = 50
  334. return swims_to_left_tot_rw
  336. def avg_mot_lumi_change_full_node_outputs(model_input, tau_mot=4.26, tau_ph_eye=12.66, tau_ph_rep=12.66, tau_drive=6.46,
  337. w_mot=2.783, w_attractor_pos=0.126, w_repulsor_pos=1.857):
  338. '''
  339. This function contains the additive model with motion, luminance level and changes in luminance. It returns the contributions of several nodes.
  340. :param model_input: List of 5 input arrays (time, motion left, motion right, luminance left, luminance right).
  341. :param tau_mot: Timeconstant of the motion integrator.
  342. :param tau_ph_eye: Timeconstant of the luminance level integrator.
  343. :param tau_ph_rep: Timeconstant of the integrator in the luminance change pathway.
  344. :param tau_drive: Timeconstant of the multifeature integrator.
  345. :param w_mot: Weight of the motion pathway
  346. :param w_attractor_pos: Weight of the luminance level pathway.
  347. :param w_repulsor_pos: Weight of the luminance change pathway.
  348. :return: motion_left-, motion_right-, lumi_left-, lumi_right-, change_left-, change_right-, multifeature_left-, multifeature_right- contributions, Curve matching the percentage left swims over time.
  349. '''
  350. # We add some baseline activity to both multifeature nodes to avoid division by zero. Since both nodes contain this baseline, it doesn't affect the percentage left swims.
  351. baseline = 1
  353. time, left_input_mot, right_input_mot, left_input_ph, right_input_ph = model_input
  355. # Integrate motion
  356. exp_kernel_mot = np.concatenate((np.zeros(150), 1 / tau_mot * np.exp(-np.linspace(0, 150, 151) / tau_mot)))
  357. exp_kernel_mot = exp_kernel_mot / np.sum(exp_kernel_mot)
  358. left_integrated_mot = convolve1d(left_input_mot, exp_kernel_mot)
  359. right_integrated_mot = convolve1d(right_input_mot, exp_kernel_mot)
  361. # Integrate luminance for each eye
  362. exp_kernel_ph_eye = np.concatenate((np.zeros(150), 1 / tau_ph_eye * np.exp(-np.linspace(0, 150, 151) / tau_ph_eye)))
  363. exp_kernel_ph_eye = exp_kernel_ph_eye / np.sum(exp_kernel_ph_eye)
  364. left_integrated_ph = convolve1d(left_input_ph, exp_kernel_ph_eye)
  365. right_integrated_ph = convolve1d(right_input_ph, exp_kernel_ph_eye)
  367. # Calculate repulsion force
  368. exp_kernel_ph_rep = np.concatenate((np.zeros(150), 1 / tau_ph_rep * np.exp(-np.linspace(0, 150, 151) / tau_ph_rep)))
  369. exp_kernel_ph_rep = exp_kernel_ph_rep / np.sum(exp_kernel_ph_rep)
  370. left_integrated_rep = convolve1d(left_input_ph, exp_kernel_ph_rep)
  371. right_integrated_rep = convolve1d(right_input_ph, exp_kernel_ph_rep)
  373. dark_left = np.clip(left_integrated_rep - left_input_ph, 0, np.inf)
  374. dark_right = np.clip(right_integrated_rep - right_input_ph, 0, np.inf)
  375. bright_left = np.clip(left_input_ph - left_integrated_rep, 0, np.inf)
  376. bright_right = np.clip(right_input_ph - right_integrated_rep, 0, np.inf)
  377. repulsion_from_left = bright_left + dark_left
  378. repulsion_from_right = bright_right + dark_right
  380. # Linear weighted sum going into the multifeature (drive) node.
  381. drive_to_left = w_mot * left_integrated_mot + w_repulsor_pos * repulsion_from_right + baseline + w_attractor_pos * left_integrated_ph
  382. drive_to_right = w_mot * right_integrated_mot + w_repulsor_pos * repulsion_from_left + baseline + w_attractor_pos * right_integrated_ph
  384. # For integration of the drive
  385. exp_kernel_drive = np.concatenate((np.zeros(150), 1 / tau_drive * np.exp(-np.linspace(0, 150, 151) / tau_drive)))
  386. exp_kernel_drive = exp_kernel_drive / np.sum(exp_kernel_drive)
  387. left_integrated_drive = convolve1d(drive_to_left, exp_kernel_drive)
  388. right_integrated_drive = convolve1d(drive_to_right, exp_kernel_drive)
  390. # Get the ratio of leftward swims
  391. swims_to_left_tot = ((left_integrated_drive - right_integrated_drive) / (
  392. left_integrated_drive + right_integrated_drive) + 1) / 2
  394. # Apply a rolling window to match the data preprocessing. And transform ratios to percentages.
  395. swims_to_left_tot_rw = rolling_end_window(swims_to_left_tot, 20)
  396. swims_to_left_tot_rw = swims_to_left_tot_rw * 100
  397. swims_to_left_tot_rw[np.isinf(swims_to_left_tot_rw)] = 50
  398. swims_to_left_tot_rw[np.isnan(swims_to_left_tot_rw)] = 50
  400. return (w_mot * left_integrated_mot, w_mot * right_integrated_mot,
  401. w_attractor_pos * left_integrated_ph, w_attractor_pos * right_integrated_ph,
  402. w_repulsor_pos * repulsion_from_left, w_repulsor_pos * repulsion_from_right,
  403. left_integrated_drive, right_integrated_drive, swims_to_left_tot_rw)
  405. def avg_mot_lumi_change_withmotinhib(model_input, tau_mot=4.26, tau_ph_eye=12.66, tau_ph_rep=12.66, tau_drive=6.46,
  406. w_mot=2.783, w_attractor_pos=0.126, w_repulsor_pos=1.857, w_mot_inhib=0):
  407. '''
  408. This function contains the additive model with motion, luminance level and changes in luminance. Additionally, it contains a mutually inhibitory connection between the left and right motion integrators.
  409. :param model_input: List of 5 input arrays (time array, motion left, motion right, luminance left, luminance right).
  410. :param tau_mot: Timeconstant of the motion integrator.
  411. :param tau_ph_eye: Timeconstant of the luminance level integrator.
  412. :param tau_ph_rep: Timeconstant of the integrator in the luminance change pathway.
  413. :param tau_drive: Timeconstant of the multifeature integrator.
  414. :param w_mot: Weight of the motion pathway
  415. :param w_attractor_pos: Weight of the luminance level pathway.
  416. :param w_repulsor_pos: Weight of the luminance change pathway.
  417. :param w_mot_inhib: Relative weight of the motion inhibition.
  418. :return: Curve matching the percentage left swims over time.
  419. '''
  420. # We add some baseline activity to both multifeature nodes to avoid division by zero. Since both nodes contain this baseline, it doesn't affect the percentage left swims.
  421. baseline = 1
  423. time, left_input_mot, right_input_mot, left_input_ph, right_input_ph = model_input
  425. # Integrate motion
  426. exp_kernel_mot = np.concatenate((np.zeros(150), 1 / tau_mot * np.exp(-np.linspace(0, 150, 151) / tau_mot)))
  427. exp_kernel_mot = exp_kernel_mot / np.sum(exp_kernel_mot)
  428. left_integrated_mot = convolve1d(left_input_mot, exp_kernel_mot)
  429. right_integrated_mot = convolve1d(right_input_mot, exp_kernel_mot)
  430. # Compute the mutual inhibition between the motion nodes (and make sure they remain positive).
  431. left_integrated_mot_preinhib = left_integrated_mot
  432. left_integrated_mot = left_integrated_mot - w_mot_inhib * right_integrated_mot
  433. right_integrated_mot = right_integrated_mot - w_mot_inhib * left_integrated_mot_preinhib
  434. left_integrated_mot[left_integrated_mot < 0] = 0
  435. right_integrated_mot[right_integrated_mot < 0] = 0
  437. # Integrate luminance for each eye
  438. exp_kernel_ph_eye = np.concatenate((np.zeros(150), 1 / tau_ph_eye * np.exp(-np.linspace(0, 150, 151) / tau_ph_eye)))
  439. exp_kernel_ph_eye = exp_kernel_ph_eye / np.sum(exp_kernel_ph_eye)
  440. left_integrated_ph = convolve1d(left_input_ph, exp_kernel_ph_eye)
  441. right_integrated_ph = convolve1d(right_input_ph, exp_kernel_ph_eye)
  443. # Calculate repulsion force
  444. exp_kernel_ph_rep = np.concatenate((np.zeros(150), 1 / tau_ph_rep * np.exp(-np.linspace(0, 150, 151) / tau_ph_rep)))
  445. exp_kernel_ph_rep = exp_kernel_ph_rep / np.sum(exp_kernel_ph_rep)
  446. left_integrated_rep = convolve1d(left_input_ph, exp_kernel_ph_rep)
  447. right_integrated_rep = convolve1d(right_input_ph, exp_kernel_ph_rep)
  449. dark_left = np.clip(left_integrated_rep - left_input_ph, 0, np.inf)
  450. dark_right = np.clip(right_integrated_rep - right_input_ph, 0, np.inf)
  451. bright_left = np.clip(left_input_ph - left_integrated_rep, 0, np.inf)
  452. bright_right = np.clip(right_input_ph - right_integrated_rep, 0, np.inf)
  453. repulsion_from_left = bright_left + dark_left
  454. repulsion_from_right = bright_right + dark_right
  456. # Compute the linear weighted sum into the multifeature node (drive).
  457. drive_to_left = w_mot * left_integrated_mot + w_repulsor_pos * repulsion_from_right + baseline + w_attractor_pos * left_integrated_ph
  458. drive_to_right = w_mot * right_integrated_mot + w_repulsor_pos * repulsion_from_left + baseline + w_attractor_pos * right_integrated_ph
  460. # For integration of the drive
  461. exp_kernel_drive = np.concatenate((np.zeros(150), 1 / tau_drive * np.exp(-np.linspace(0, 150, 151) / tau_drive)))
  462. exp_kernel_drive = exp_kernel_drive / np.sum(exp_kernel_drive)
  463. left_integrated_drive = convolve1d(drive_to_left, exp_kernel_drive)
  464. right_integrated_drive = convolve1d(drive_to_right, exp_kernel_drive)
  466. # Calculate the ratio of leftward swims.
  467. swims_to_left_tot = ((left_integrated_drive - right_integrated_drive) / (
  468. left_integrated_drive + right_integrated_drive) + 1) / 2
  470. # Apply a rollowing window to match the data processing step. and transform ratios to percentage.
  471. swims_to_left_tot_rw = rolling_end_window(swims_to_left_tot, 20)
  472. swims_to_left_tot_rw = swims_to_left_tot_rw * 100
  473. swims_to_left_tot_rw[np.isinf(swims_to_left_tot_rw)] = 50
  474. swims_to_left_tot_rw[np.isnan(swims_to_left_tot_rw)] = 50
  476. return swims_to_left_tot_rw
  479. def get_data(folder_name, stim_len_timepoints, stim_name, path_to_folders, nsplits=3, debug=False):
  480. '''
  481. This function retrieves the data of the specified experiments and stimulus types.
  482. :param folder_names: List of experiment stimuli to train on.
  483. :param stim_len_timepoints: List of the length of each stimulus in 0.1s steps (e.g. a 25s stimulus is written as 250 in this list).
  484. :param stim_names: List of stimulus types to train on (e.g. Motion, Photo, Same and Oppo).
  485. :param path_to_folders: path to the folder containing all experiments.
  486. :param nsplits: Number of splits to split the data in, one of the splits will be used as testing data, the rest will be used as training data. Default is 3.
  487. :param debug: Print how many fish are used for testing and how many for training.
  488. :return: The data: mean training values, SEM training values, mean testing values, SEM testing values.
  489. '''
  490. # Load the analysed dataframe.
  491. try:
  492. path_to_local_folder = rf'{path_to_folders}\{folder_name}'
  493. df_path = f'{path_to_local_folder}/data_analysed.hdf5'
  494. df = pd.read_hdf(df_path)
  495. except:
  496. path_to_local_folder = rf'{path_to_folders}\{folder_name}\Analysis'
  497. df_path = f'{path_to_local_folder}/data_analysed.hdf5'
  498. df = pd.read_hdf(df_path)
  500. # Group the data into the splits.
  501. gkf = GroupShuffleSplit(n_splits=nsplits)
  502. datasplitss = {}
  503. datasplitss.update({f"{folder_name}": [(train_ids, test_ids) for train_ids, test_ids in
  504. gkf.split(df.index.unique('experiment_ID'),
  505. groups=df.index.unique('experiment_ID').tolist())]})
  507. # Create the two separate dataframes for the training and testing data.
  508. train_df = df[np.isin(df.index.get_level_values('experiment_ID'),
  509. df.index.unique('experiment_ID')[datasplitss[f'{folder_name}'][0][0]])]
  510. test_df = df[np.isin(df.index.get_level_values('experiment_ID'),
  511. df.index.unique('experiment_ID')[datasplitss[f'{folder_name}'][0][1]])]
  513. if debug:
  514. print(f'{folder_name} - {stim_name}: ')
  515. print(f'Train N FISH: {len(train_df.index.unique("experiment_ID"))}')
  516. print(f'Test N FISH: {len(test_df.index.unique("experiment_ID"))}\n')
  518. # Extract the mean and sem of percentage_left swims for the specific stimulus type. Both for the training and testing data set.
  519. stimulus_data = train_df.xs(stim_name, level='stimulus_name')
  520. data_mean = stimulus_data.groupby('window_time').mean()['percentage_left']
  521. data_sem = stimulus_data.groupby('window_time').std()['percentage_left'] / np.sqrt(
  522. len(train_df.index.unique('experiment_ID')))
  523. stimulus_data_test = test_df.xs(stim_name, level='stimulus_name')
  524. data_mean_test = stimulus_data_test.groupby('window_time').mean()['percentage_left']
  525. data_sem_test = stimulus_data_test.groupby('window_time').std()['percentage_left'] / np.sqrt(
  526. len(test_df.index.unique('experiment_ID')))
  528. # This is needed in case there were no bouts in the first 0.1 s (this happens). We need to make sure the length of the dataframe matches across stimulus types.
  529. for iter in range(10):
  530. if len(data_mean) < stim_len_timepoints:
  531. data_mean = pd.concat([pd.Series([0.5]), data_mean])
  532. data_sem = pd.concat([pd.Series([0.]), data_sem])
  534. if len(data_mean_test) < stim_len_timepoints:
  535. data_mean_test = pd.concat([pd.Series([0.5]), data_mean_test])
  536. data_sem_test = pd.concat([pd.Series([0.]), data_sem_test])
  538. # Replace first 0,5 seconds of each stimulus with a flat line - there are not enough bouts in this initial time for a good percentage estimate.
  539. # And since the stimulus input is always 0 here - it won't affect the model fitting.
  540. data_mean[:0.5] = 0.5
  541. data_sem[:0.5] = 0.05
  542. data_mean_test[:0.5] = 0.5
  543. data_sem_test[:0.5] = 0.05
  545. data_mean = data_mean * 100
  546. data_sem = data_sem * 100
  547. data_mean_test = data_mean_test * 100
  548. data_sem_test = data_sem_test * 100
  550. # Fill any potential nans since scipy's curve-fit can't handle it.
  551. data_mean = fill_nans(data_mean)
  552. data_sem = fill_nans(data_sem)
  553. data_mean_test = fill_nans(data_mean_test)
  554. data_sem_test = fill_nans(data_sem_test)
  556. return data_mean, data_sem, data_mean_test, data_sem_test
  558. def train_model_once(model_func, folder_names, stim_len_timepoints, stim_names, path_to_folders, subfig=None):
  559. '''
  560. This function trains the model once.
  561. :param model_func: name of the model, e.g. avg_mot_lumi_change.
  562. :param folder_names: List of experiment stimuli to train on.
  563. :param stim_len_timepoints: List of the length of each stimulus in 0.1s steps (e.g. a 25s stimulus is written as 250 in this list).
  564. :param stim_names: List of stimulus types to train on (e.g. Motion, Photo, Same and Oppo).
  565. :param path_to_folders: Path the folder containing all experiment folders.
  566. :param subfig: If not None plot the data and model fit from the training. This is not used anymore in the paper.
  567. :return: best model parameters, best_mse, list_of_folder_ids
  568. '''
  570. n_loops = len(stim_len_timepoints) * len(stim_names)
  571. list_of_folder_ids = []
  572. list_of_stim_ids = []
  573. # Loop over randomly drawn stimulus combinations.
  574. for i in range(n_loops):
  575. random_folder_id = np.random.randint(len(folder_names))
  576. random_stim_id = np.random.randint(len(stim_names))
  578. list_of_folder_ids = np.append(list_of_folder_ids, random_folder_id)
  579. list_of_stim_ids = np.append(list_of_stim_ids, random_stim_id)
  581. # Get the data, split into a training (2/3 of the data) and a testing (1/3 of the data) set.
  582. # Note that training is only based on the mean, the sem we only use for the plotting of the data.
  583. data_mean, data_sem, data_mean_test, data_sem_test = get_data(folder_names[random_folder_id],
  584. stim_len_timepoints[random_folder_id],
  585. stim_names[random_stim_id],
  586. path_to_folders=path_to_folders)
  587. # Get the input into the model
  588. left_mot_input, right_mot_input, left_lumi_input, right_lumi_input = get_stim_input(
  589. folder_names[random_folder_id], stim_len_timepoints[random_folder_id], stim_names[random_stim_id])
  591. time = np.linspace(0, (len(data_mean) - 1) / 10, len(data_mean))
  593. # Collect the model input, data mean and sem for training and testing, folder and stim ids.
  594. if i == 0:
  595. model_input = [time, left_mot_input, right_mot_input, left_lumi_input, right_lumi_input]
  596. data_full = data_mean
  597. data_sem_full = data_sem
  598. data_full_test = data_mean_test
  599. data_sem_full_test = data_sem_test
  600. folder_ids = random_folder_id * np.ones(stim_len_timepoints[random_folder_id])
  601. stim_ids = random_stim_id * np.ones(stim_len_timepoints[random_folder_id])
  602. else:
  603. model_input = np.hstack(
  604. (model_input, [time, left_mot_input, right_mot_input, left_lumi_input, right_lumi_input]))
  605. data_full = np.append(data_full, data_mean)
  606. data_full_test = np.append(data_full_test, data_mean_test)
  607. data_sem_full = np.append(data_sem_full, data_sem)
  608. data_sem_full_test = np.append(data_sem_full_test, data_sem_test)
  609. folder_ids = np.append(folder_ids, random_folder_id * np.ones(stim_len_timepoints[random_folder_id]))
  610. stim_ids = np.append(stim_ids, random_stim_id * np.ones(stim_len_timepoints[random_folder_id]))
  612. # We add a chunk of 5s between the different stimuli to allow the model to return back to baseline before starting the next stimulus.
  613. if i < n_loops - 1:
  614. model_input = np.hstack((model_input, [np.zeros(50), np.zeros(50), np.zeros(50), np.ones(50), np.ones(50)]))
  615. data_full = np.append(data_full, 50 * np.ones(50))
  616. data_full_test = np.append(data_full_test, 50 * np.ones(50))
  617. data_sem_full = np.append(data_sem_full, 0 * np.ones(50))
  618. data_sem_full_test = np.append(data_sem_full_test, 0 * np.ones(50))
  619. folder_ids = np.append(folder_ids, -1 * np.ones(50))
  620. stim_ids = np.append(stim_ids, -1 * np.ones(50))
  622. # Find the best_mse across 5 model fitting with different initital parameter guesses.
  623. # Usually scipy's curve-fit finds the best fit immediately, but since it sometimes gets stuck and returns a warning 'optimal parameters not found', we give it 5 tries to be quite sure it always finds the true best fit.
  624. best_mse = 1000
  625. for c in range(5):
  626. # Define the initial parameters, as well as the bounds for each model option (timeconstants are bound between 0 and 100, weights are bound between 0 and 25).
  627. if model_func == avg_mot_lumi:
  628. tau_mot = np.random.uniform(0.1, 100)
  629. tau_ph_eye = np.random.uniform(0.1, 100)
  630. tau_drive = np.random.uniform(0.1, 100)
  631. w_mot = np.random.uniform(0.1, 25)
  632. w_attractor_pos = np.random.uniform(0.1, 25)
  634. p0 = [tau_mot, tau_ph_eye, tau_drive, w_mot, w_attractor_pos,]
  635. bounds = ([0, 0, 0, 0, 0], [100, 100, 100, 25, 25])
  636. elif model_func == avg_mot_change:
  637. tau_mot = np.random.uniform(0.1, 100)
  638. tau_ph_rep = np.random.uniform(0.1, 100)
  639. tau_drive = np.random.uniform(0.1, 100)
  640. w_mot = np.random.uniform(0.1, 25)
  641. w_repulsor_pos = np.random.uniform(0.1, 25)
  643. p0 = [tau_mot, tau_ph_rep, tau_drive, w_mot, w_repulsor_pos,]
  644. bounds = ([0, 0, 0, 0, 0], [100, 100, 100, 25, 25])
  645. elif model_func == avg_lumi_change:
  646. tau_ph_eye = np.random.uniform(0.1, 100)
  647. tau_ph_rep = np.random.uniform(0.1, 100)
  648. tau_drive = np.random.uniform(0.1, 100)
  649. w_attractor_pos = np.random.uniform(0.1, 25)
  650. w_repulsor_pos = np.random.uniform(0.1, 25)
  652. p0 = [tau_ph_eye, tau_ph_rep, tau_drive, w_attractor_pos, w_repulsor_pos]
  653. bounds = ([0, 0, 0, 0, 0], [100, 100, 100, 25, 25])
  654. elif model_func == avg_mot_lumi_change:
  655. tau_mot = np.random.uniform(0.1, 100)
  656. tau_ph_eye = np.random.uniform(0.1, 100)
  657. tau_ph_rep = np.random.uniform(0.1, 100)
  658. tau_drive = np.random.uniform(0.1, 100)
  659. w_mot = np.random.uniform(0.1, 25)
  660. w_attractor_pos = np.random.uniform(0.1, 25)
  661. w_repulsor_pos = np.random.uniform(0.1, 25)
  663. p0 = [tau_mot, tau_ph_eye, tau_ph_rep, tau_drive, w_mot, w_attractor_pos, w_repulsor_pos,]
  664. bounds = ([0, 0, 0, 0, 0, 0, 0], [100, 100, 100, 100, 25, 25, 25])
  666. elif model_func == avg_mot_lumi_change_withmotinhib:
  667. tau_mot = np.random.uniform(0.1, 100)
  668. tau_ph_eye = np.random.uniform(0.1, 100)
  669. tau_ph_rep = np.random.uniform(0.1, 100)
  670. tau_drive = np.random.uniform(0.1, 100)
  671. w_mot = np.random.uniform(0.1, 25)
  672. w_attractor_pos = np.random.uniform(0.1, 25)
  673. w_repulsor_pos = np.random.uniform(0.1, 25)
  674. w_mot_inhib = np.random.uniform(0.001, 0.999)
  676. p0 = [tau_mot, tau_ph_eye, tau_ph_rep, tau_drive, w_mot, w_attractor_pos, w_repulsor_pos, w_mot_inhib]
  677. bounds = ([0, 0, 0, 0, 0, 0, 0, 0], [100, 100, 100, 100, 25, 25, 25, 1])
  679. # Find the best fit between the model and the training data.
  680. try:
  681. popt, pcov = curve_fit(model_func, model_input, data_full, p0=p0, bounds=bounds)
  682. except:
  683. print('Warning optimal params not found, using initial params instead.')
  684. popt = p0
  685. # Calculate the MSE between the left-out testing data and the model.
  686. test_mse = np.nanmean(np.square(model_func(model_input, *popt) - data_full_test))
  688. # Update the best MSE and parameter set.
  689. if test_mse < best_mse:
  690. best_mse = test_mse
  691. best_popt = popt
  693. # If subfig is not None, plot the data with the model fit. Since the stimuli are drawn randomly and differ in length, we cannot know before how long the x-axis should be. We give a warning if not all data is shown.
  694. if subfig is not None:
  695. if len(data_full_test) > 7500:
  696. print(f'Warning: Length of data outside xmax (not the full plot will be visible) {len(data_full_test)}. ')
  697. subfig.draw_line(np.arange(len(data_full_test)), data_full_test, yerr=data_sem_full_test, lc='tab:blue', lw=1,
  698. eafc='#AEC7E8', eaalpha=1.0, ealw=1, eaec='#AEC7E8')
  699. subfig.draw_line(np.arange(len(data_full_test)), model_func(model_input, *best_popt), lc='k', lw=1.)
  700. subfig.draw_line([len(data_full_test)-150, len(data_full_test)], [21, 21], lc='k')
  701. subfig.draw_text(len(data_full_test)-75, 15, '15s')
  702. subfig.draw_text(0, 105, 'Model training on 20x random stimuli M or L', textlabel_ha='left')
  703. return best_popt, best_mse, list_of_folder_ids
  705. def train_model_full(model_func, folder_names, stim_len_timepoints, stim_names, path_to_folders, subfig=None, train_loops=10, debug=False):
  706. '''
  707. This function trains the model on all stimuli in folder_names and all stimulus_types in stim_names.
  708. :param model_func: Name of the model to train, e.g. avg_mot_lumi_change
  709. :param folder_names: List of experiment stimuli to train on.
  710. :param stim_len_timepoints: List of the length of each stimulus in 0.1s steps (e.g. a 25s stimulus is written as 250 in this list).
  711. :param stim_names: List of stimulus types to train on (e.g. Motion, Photo, Same and Oppo).
  712. :param path_to_folders: path to folder containing all experiment folders.
  713. :param subfig: Subfigure to draw the model training fit. This is not used anymore in the paper.
  714. :param train_loops: Number of training-rounds.
  715. :param debug: If True print all parameters, the best parameter set and all training MSEs.
  716. :return: All parameter sets, all training MSEs, a list of the lists with folder-ids used in each round.
  717. '''
  718. # Inititalize the best_test_mse at a high-value to be beaten by the model fits. initialize lists of all values to return.
  719. best_test_mse = 1000
  720. all_params = []
  721. all_mse = []
  722. list_of_lists_of_folder_ids = []
  723. # Loop over training rounds and train the model.
  724. for t in range(train_loops):
  725. print(f'Training round {t}')
  726. popt, test_mse, folder_ids = train_model_once(model_func,
  727. folder_names,
  728. stim_len_timepoints,
  729. stim_names,
  730. path_to_folders,
  731. subfig=subfig)
  732. list_of_lists_of_folder_ids = np.append(list_of_lists_of_folder_ids, folder_ids)
  734. all_params = np.append(all_params, popt)
  735. all_mse = np.append(all_mse, test_mse)
  736. # Update the best mse and parameter set.
  737. if test_mse < best_test_mse:
  738. best_test_mse = test_mse
  739. best_params = popt
  741. if debug:
  742. print(best_params)
  743. print(all_params)
  744. print(all_mse)
  746. return all_params, all_mse, list_of_lists_of_folder_ids
  748. def test_model_once(model_func, params, folder_names, stim_len_timepoints, stim_names, path_to_folders, subfig_data=None, subfig_model=None, training_folder_ids=None, pick_stim_ids=None, pl_color='k', debug=False):
  749. '''
  750. This function tests the model fit once.
  751. This is related to most of the subpanels in Figure 2 and S2.
  752. :param model_func: Name of the model, e.g. avg_mot_lumi_change.
  753. :param params: List of model parameters to test.
  754. :param folder_names: List of experiment stimuli to test.
  755. :param stim_len_timepoints: List with the length of each stimulus in 0.1s (a stimulus of 25 seconds should be written as 250 in this list).
  756. :param stim_names: List of stimulus-types to test, e.g. Motion, Photo, Same, Oppo.
  757. :param path_to_folders: Path to folder containing all experiment folders.
  758. :param subfig_data: Subfigure to plot the data in.
  759. :param subfig_model: Subfigure to plot the model in.
  760. :param training_folder_ids: Default None. If specified it contains a list of integers indicating the experiment stimuli to test (used in Fig. 2g to match the drawn cartoons).
  761. :param pick_stim_ids: Default None. If specified it contains a list of integers indicating the stimulus types to test (used in Fig. 2g to match the drawn cartoons).
  762. :param pl_color: Color to use for the model plot.
  763. :param debug: if True print the test_mse for each fit.
  764. :return: test_mse (mean-squared-error between the model and the data).
  765. '''
  766. # Loop over all stimuli and stimulus-types to test (this can be randomly drawn, or following the list if training_folder_ids and/or pick_stim_ids are not None.
  767. list_of_stim_ids = []
  768. for i in range(len(stim_len_timepoints) * len(stim_names)):
  769. if training_folder_ids is None:
  770. folder_id = i % len(stim_len_timepoints)
  771. else:
  772. folder_id = int(training_folder_ids[i])
  774. if pick_stim_ids is None and training_folder_ids is None:
  775. stim_id = int(i / len(stim_len_timepoints))
  776. elif pick_stim_ids is None:
  777. stim_id = np.random.choice(np.arange(len(stim_names)))
  778. else:
  779. stim_id = int(pick_stim_ids[i])
  781. # Append the list of stimulus ids.
  782. list_of_stim_ids = np.append(list_of_stim_ids, stim_id)
  784. # Load the data of a specific stimulus and stimulus-type.
  785. _, _, data_mean, data_sem = get_data(folder_names[folder_id],
  786. stim_len_timepoints[folder_id],
  787. stim_names[stim_id],
  788. path_to_folders=path_to_folders,
  789. nsplits=3)
  790. # Get the model input for this stimulus and stimulus-type.
  791. left_mot_input, right_mot_input, left_lumi_input, right_lumi_input = get_stim_input(folder_names[folder_id],
  792. stim_len_timepoints[
  793. folder_id],
  794. stim_names[stim_id])
  796. time = np.linspace(0, (len(data_mean) - 1) / 10, len(data_mean))
  798. #Collect the model_inputs, mean of the data, sem of the data, stimulus-ids (folder_ids) and stimulus-types.
  799. if i == 0:
  800. model_input = [time, left_mot_input, right_mot_input, left_lumi_input, right_lumi_input]
  801. data_full = data_mean
  802. data_sem_full = data_sem
  803. # The in_stim_tracker keeps track of which data should be plotted (we stick 5s pieces of flat data between the stimuli to allow any longer timescale model
  804. # fits to return to baseline before starting the next stim. These 5s pieces are skipped in the plotting based on in_stim_tracker.
  805. in_stim_tracker = np.zeros(len(data_mean))
  806. folder_ids = folder_id * np.ones(stim_len_timepoints[folder_id])
  807. stim_ids = stim_id * np.ones(stim_len_timepoints[folder_id])
  808. else:
  809. model_input = np.hstack(
  810. (model_input, [time, left_mot_input, right_mot_input, left_lumi_input, right_lumi_input]))
  811. data_full = np.append(data_full, data_mean)
  812. data_sem_full = np.append(data_sem_full, data_sem)
  813. in_stim_tracker = np.append(in_stim_tracker, np.zeros(len(data_mean)))
  814. folder_ids = np.append(folder_ids, folder_id * np.ones(stim_len_timepoints[folder_id]))
  815. stim_ids = np.append(stim_ids, stim_id * np.ones(stim_len_timepoints[folder_id]))
  817. # Here we attach a 5s piece between each stimulus to allow all models to return back to baseline before the next stimulus starts.
  818. if i < len(stim_len_timepoints) * len(stim_names) - 1:
  819. model_input = np.hstack((model_input, [np.zeros(50), np.zeros(50), np.zeros(50), np.ones(50), np.ones(50)]))
  820. data_full = np.append(data_full, 50 * np.ones(50))
  821. data_sem_full = np.append(data_sem_full, 0 * np.ones(50))
  822. in_stim_tracker = np.append(in_stim_tracker, np.ones(50))
  823. folder_ids = np.append(folder_ids, -1 * np.ones(50))
  824. stim_ids = np.append(stim_ids, -1 * np.ones(50))
  826. # Calculate the entire Mean-squared-error between the data and the model.
  827. test_mse = np.nanmean(np.square(model_func(model_input, *params) - data_full))
  828. if debug:
  829. print(test_mse)
  831. # Plot the data if subfig_data is not None.
  832. if subfig_data is not None:
  833. print('length of data', len(data_full))
  834. data_full[in_stim_tracker.astype(bool)] = np.nan
  835. data_sem_full[in_stim_tracker.astype(bool)] = np.nan
  836. subfig_data.draw_line(np.arange(len(data_full)), data_full, yerr=data_sem_full, lc='k', lw=1,
  837. eafc='#404040', eaalpha=1.0, ealw=1, eaec='#404040')
  838. subfig_data.draw_line([len(data_full)-150, len(data_full)], [21, 21], lc='k')
  839. subfig_data.draw_text(len(data_full)-75, 15, '15s')
  841. # Plot the model fit if subfig_model is not None.
  842. if subfig_model is not None:
  843. model_output = model_func(model_input, *params)
  844. model_output[in_stim_tracker.astype(bool)] = np.nan
  845. subfig_model.draw_line(np.arange(len(data_full)), model_output, lc=pl_color, lw=1.)
  847. return test_mse
  850. def plot_model_contribution_single_experiment(model_func, params, folder_name, stim_len_timepoints, stim_name, path_to_folders, subfig_contributions_left=None, subfig_contributions_right=None):
  851. '''
  852. This function plots the contributions of the main 3 nodes to the model output.
  853. This is related to figure S2c.
  854. :param model_func: Name of the model function to use, e.g. avg_mot_lumi_change.
  855. :param params: Model parameters, in case of the avg_mot_lumi_change model these are the four weigths and three timeconstants.
  856. :param folder_name: Folder name of the experiment to plot.
  857. :param stim_len_timepoints: Length of the stimulus in 0.1s steps (a 25s stimulus is written as 250 here).
  858. :param stim_name: The name of the stimulus type (e.g. Motion, Photo, Same, Oppo)
  859. :param path_to_folders: Path to folder containing all experiment folders.
  860. :param subfig_contributions_left: subfigure to plot the contributions to the leftward multifeature integrator.
  861. :param subfig_contributions_right: Subfigure to plot the contributions to the rightward multifeature integrator (with flipped y-axis).
  862. '''
  864. # Load the data of one specific experiment (folder_name) and one specific stimulus type (Motion, Photo, Same or Oppo).
  865. _, _, data_mean, data_sem = get_data(folder_name,
  866. stim_len_timepoints,
  867. stim_name,
  868. path_to_folders=path_to_folders,
  869. nsplits=3)
  871. # Load the input to the model for the same folder_name and stimulus type (stim_name).
  872. left_mot_input, right_mot_input, left_lumi_input, right_lumi_input = get_stim_input(folder_name,
  873. stim_len_timepoints,
  874. stim_name)
  876. time = np.linspace(0, (len(data_mean) - 1) / 10, len(data_mean))
  878. model_input = [time, left_mot_input, right_mot_input, left_lumi_input, right_lumi_input]
  880. # Plot the contributions of the left/right motion integrators, left/right luminance integrators and left/right luminance change detectors.
  881. if subfig_contributions_left is not None or subfig_contributions_right is not None:
  882. mot_left, mot_right, ph_left, ph_right, diff_left, diff_right, drive_left, drive_right, model_output = model_func(model_input, *params)
  884. subfig_contributions_left.draw_line(np.arange(len(mot_left)), mot_left, lc='#359B73', lw=1.)
  885. # We flip the y-axis of the rightward contributions for better visualization
  886. subfig_contributions_right.draw_line(np.arange(len(mot_right)), -mot_right, lc='#359B73', lw=1.)
  887. subfig_contributions_left.draw_line(np.arange(len(ph_left)), ph_left, lc='#E69F00', lw=1.)
  888. subfig_contributions_right.draw_line(np.arange(len(ph_right)), -ph_right, lc='#E69F00', lw=1.)
  889. # Note that the leftward change detectors feeds into the right multifeature integrator and is therefore flipped.
  890. subfig_contributions_right.draw_line(np.arange(len(diff_left)), -diff_left, lc='#D55E00', lw=1.)
  891. subfig_contributions_left.draw_line(np.arange(len(diff_right)), diff_right, lc='#D55E00', lw=1.)
  892. return
  895. def sub_plot_temp_dyn_data(path_to_analysed_data, subfigs):
  896. '''
  897. This function plots the behavior curves over time.
  898. This is related to figure 2a-d
  899. :param path_to_analysed_data: the path to the combined dataframe for figure 2a-d. Each row in this dataframe contains the percentage left within a rolling window.
  900. :param subfigs: list of subfigures to plot the decision curves over time.
  901. '''
  903. # Load the data
  904. analysed_df = pd.read_hdf(path_to_analysed_data)
  906. # Looping over the four stimulus-types (only-motion, only-luminance, congruent, and conflicting).
  907. stim_names = ['Mot', 'Lumi', 'Same', 'Oppo']
  908. plot_names = ['only-motion (M)', 'only-luminance (L)', 'congruent (M=L)', 'conflicting (M\u2260L)']
  909. for st, pl_name, plot in zip(stim_names, plot_names, subfigs):
  910. # Select and then plot the data of the current stimulus with white background during pre- and post stim.
  911. stim = f'{st} W'
  912. stim_df = analysed_df.xs(stim, level='stimulus_name')
  913. n_fish = len(stim_df.index.unique('experiment_ID'))
  914. grouped_df = stim_df.groupby('window_time')
  916. mean = grouped_df['percentage_left'].mean()[0.5:]
  917. std = grouped_df['percentage_left'].std()[0.5:]
  918. sem = std / np.sqrt(n_fish)
  919. binned_time = mean.index.unique('window_time')
  921. plot.draw_line(x=binned_time, y=mean, yerr=sem, lc='#676767', eafc='#989898', eaalpha=1.0, lw=1, ealw=1, eaec='#989898')
  923. # Select and then plot the data of the current stimulus with black background during pre- and post stim.
  924. stim = f'{st} B'
  925. stim_df = analysed_df.xs(stim, level='stimulus_name')
  926. n_fish = len(stim_df.index.unique('experiment_ID'))
  927. grouped_df = stim_df.groupby('window_time')
  929. mean = grouped_df['percentage_left'].mean()[0.5:]
  930. std = grouped_df['percentage_left'].std()[0.5:]
  931. sem = std / np.sqrt(n_fish)
  932. binned_time = mean.index.unique('window_time')
  934. plot.draw_line(x=binned_time, y=mean, yerr=sem, lc='k', eafc='#404040', alpha=0.5, eaalpha=0.5, lw=1, ealw=1, eaec='#404040')
  935. plot.draw_text(12.5, 1.25, f'{pl_name}')
  937. subfigs[-1].draw_line([20, 25], [0.26, 0.26], lc='k')
  938. subfigs[-1].draw_text(22.5, 0.20, '5s')
  939. return
  941. def sub_plot_modelling_example_traces(plot_model_ADD_example, plot_model_ADD_only_example, plot_data_example, path_to_folders):
  942. '''
  943. This function plots the example traces of the multifeature and unifeature fitting strategies, as well as the behavioral data.
  944. This is related to figure 2g.
  945. :param plot_model_ADD_example: Subfigure to plot the multifeature fitted model.
  946. :param plot_model_ADD_only_example: Subfigure to plot the unifeature fiteed model.
  947. :param plot_data_example: Subfigure to plot the fish data.
  948. :param path_to_folders: path to folder containing all experiment folders.
  949. '''
  951. # We define the multifeature training stimuli.
  952. folder_names_half = ['converted_phototaxis_dotmotion_integration_simultaneous_white', # Simultaneous
  953. 'phototaxis_dotmotion_white_Sep', # White
  954. 'phototaxis_dotmotion_simultaneous_low_Sep', # Simultaneous low
  955. 'converted_phototaxis_dotmotion_integration_peppersalt', # peppersalt
  956. 'converted_phototaxis_dotmotion_integration_long'] # long
  957. stim_len_timepoints_half = np.array([250, 300, 450, 350, 600])
  958. stim_names_half = ['Motion', 'Photo', 'Same', 'Oppo']
  960. # We define the unifeature training stimuli.
  961. folder_names_onlyML = ['converted_phototaxis_dotmotion_integration_simultaneous_white', # Simultaneous
  962. 'phototaxis_dotmotion_simultaneous_low_Sep', # Simultaneous low
  963. 'converted_phototaxis_dotmotion_integration_peppersalt', # Peppersalt
  964. 'phototaxis_dotmotion_reverse_Sep', # Reverse
  965. 'phototaxis_dotmotion_white_Sep', # White
  966. 'converted_phototaxis_dotmotion_integration_long', # Long
  967. 'beh_simultaneous_blackwhite_black', # Simultaneous black
  968. 'beh_simultaneous_blackwhite_white', # Simultaneous white
  969. 'phototaxis_dotmotion_integration_halfoverlap', # Halfoverlap
  970. 'beh_simultaneous_10only'] # Simultaneous verylow
  971. stim_len_timepoints_onlyML = np.array([250, 450, 350, 300, 300, 600, 250, 250, 350, 250])
  972. stim_names_onlyML = ['Motion', 'Photo',]
  974. # We define the common testing stimuli to make sure neither model is trained on this data.
  975. folder_names_test = ['beh_simultaneous_blackwhite_white', # simultaneous white
  976. 'phototaxis_dotmotion_reverse_Sep', # reverse
  977. 'beh_simultaneous_blackwhite_black', # simultaneous black
  978. 'phototaxis_dotmotion_integration_halfoverlap', # Halfoverlap
  979. 'beh_simultaneous_10only'] #simultaneous very low
  980. stim_len_timepoints_test = np.array([250, 300, 250, 350, 250])
  981. stim_names_test = ['Same', 'Oppo']
  983. # We hardcoded the random stimulus order to align with the stimulus cartoons.
  984. testing_folder_ids = np.array([0, 1, 2, 3, 4, 3, 1, 0, 4, 2])
  985. testing_stim_ids = np.array([1, 0, 0, 1, 1, 0, 1, 0, 0, 1])
  987. total_time = 450 + np.sum(stim_len_timepoints_test[testing_folder_ids.astype(int)])
  988. print('total time example traces is:, ', total_time)
  990. # Training the multifeature fitted model
  991. model_params, model_train_mse, _ = train_model_full(model_func=avg_mot_lumi_change,
  992. folder_names=folder_names_half,
  993. stim_len_timepoints=stim_len_timepoints_half,
  994. stim_names=stim_names_half,
  995. path_to_folders=path_to_folders,
  996. subfig=None,
  997. train_loops=1)
  999. model_params = np.array(model_params).reshape(-1, 7)
  1001. # Testing the multifeature fitted model; Note that in this case there is only 1 set of parameters, because we trained n=1 train_loops.
  1002. model_test_mse = []
  1003. for params in model_params:
  1004. model_test_mse = np.append(model_test_mse, test_model_once(model_func=avg_mot_lumi_change,
  1005. params=params,
  1006. folder_names=folder_names_test,
  1007. stim_len_timepoints=stim_len_timepoints_test,
  1008. stim_names=stim_names_test,
  1009. path_to_folders=path_to_folders,
  1010. subfig_data=None,
  1011. subfig_model=plot_model_ADD_example,
  1012. training_folder_ids=testing_folder_ids,
  1013. pick_stim_ids=testing_stim_ids,
  1014. pl_color='#808080'))
  1016. # Training the unifeature fitted model
  1017. model_params, model_train_mse, _ = train_model_full(model_func=avg_mot_lumi_change,
  1018. folder_names=folder_names_onlyML,
  1019. stim_len_timepoints=stim_len_timepoints_onlyML,
  1020. stim_names=stim_names_onlyML,
  1021. path_to_folders=path_to_folders,
  1022. subfig=None,
  1023. train_loops=1)
  1025. model_params = np.array(model_params).reshape(-1, 7)
  1027. # Testing the unifeature fitted model; Note that in this case there is only 1 set of parameters, because we trained n=1 train_loops.
  1028. # The fish data will also be plotted in this, since subfig_data in the test_model_once function is not None.
  1029. model_test_mse = []
  1030. for params in model_params:
  1031. model_test_mse = np.append(model_test_mse, test_model_once(model_func=avg_mot_lumi_change,
  1032. params=params,
  1033. folder_names=folder_names_test,
  1034. stim_len_timepoints=stim_len_timepoints_test,
  1035. stim_names=stim_names_test,
  1036. path_to_folders=path_to_folders,
  1037. subfig_data=plot_data_example,
  1038. subfig_model=plot_model_ADD_only_example,
  1039. training_folder_ids=testing_folder_ids,
  1040. pick_stim_ids=testing_stim_ids,
  1041. pl_color='cyan'))
  1043. return
  1045. def sub_plot_example_traces_model_fit(path_to_analysed_data, subfiga, subfigb, subfigcs, subfigds, subfiges, subfigfs, path_to_folders):
  1046. '''
  1047. This figure plots the data and model fit of the decision-curves over time, as well as the node contributions.
  1048. This is related to Fig. S2b,c.
  1049. :param path_to_analysed_data: the path to the combined dataframe for figure 2a-d. Each row in this dataframe contains the percentage left within a rolling window.
  1050. :param subfiga: Subfigure containing the decision curves over time for stimuli with a white-background pre- and post-stimulus.
  1051. :param subfigb: Subfigure containing the decision curves over time for stimuli with a black-background pre- and post-stimulus.
  1052. :param subfigcs: List of subfigures containing the leftward node contributions to stimuli with a white-background pre- and post-stimulus.
  1053. :param subfigds: List of subfigures containing the rightward node contributions to stimuli with a white-background pre- and post-stimulus.
  1054. :param subfiges: List of subfigures containing the leftward node contributions to stimuli with a black-background pre- and post-stimulus.
  1055. :param subfigfs: List of subfigures containing the rightward node contributions to stimuli with a black-background pre- and post-stimulus.
  1056. :param path_to_folders: path to folder containing all experiment folders.
  1057. '''
  1059. # These model parameters are printed by sub_plot_modelling_overview_mse_tau_w, to save time in creating this figure we hard-coded them here.
  1060. model_params = [8, 52, 13, 11, 3.9, 0.9, 4]
  1062. # Add a white line to highlight 50%, or the decision-baseline.
  1063. subfiga.draw_line([0, 1150], [50, 50], lc='w', lw=1.5)
  1064. subfigb.draw_line([0, 1150], [50, 50], lc='w', lw=1.5)
  1066. # Load the data.
  1067. analysed_df = pd.read_hdf(path_to_analysed_data)
  1069. # The stimulus names relate to only-motion, only-luminance, congruent, conflicting.
  1070. stim_names = ['Mot', 'Lumi', 'Same', 'Oppo']
  1072. # The x-starts are used to sequentially plot all stimuli within the same subfigure.
  1073. x_starts = [0, 300, 600, 900, 1200, 1500, 1800, 2100]
  1074. for st, x_start in zip(stim_names, x_starts):
  1075. # The W indicates the white background pre- and post stimulus.
  1076. stim = f'{st} W'
  1077. stim_df = analysed_df.xs(stim, level='stimulus_name')
  1078. n_fish = len(stim_df.index.unique('experiment_ID'))
  1079. grouped_df = stim_df.groupby('window_time')
  1081. # We extract the mean and sem decision curves. We ignore the first 0.5 second of data, since there the windows are not complete and contain less data causing the percentages to fluctuate.
  1082. mean = grouped_df['percentage_left'].mean()[0.5:]
  1083. std = grouped_df['percentage_left'].std()[0.5:]
  1084. sem = std / np.sqrt(n_fish)
  1085. binned_time = mean.index.unique('window_time') * 10 + x_start
  1087. subfiga.draw_line(x=binned_time, y=mean*100, yerr=sem*100, lc='#676767', eafc='#989898', eaalpha=1.0, lw=1, ealw=1, eaec='#989898')
  1089. # The B the black background pre- and post stimulus.
  1090. stim = f'{st} B'
  1091. stim_df = analysed_df.xs(stim, level='stimulus_name')
  1092. n_fish = len(stim_df.index.unique('experiment_ID'))
  1093. grouped_df = stim_df.groupby('window_time')
  1095. # We extract the mean and sem decision curves. We ignore the first 0.5 second of data, since there the windows are not complete and contain less data causing the percentages to fluctuate.
  1096. mean = grouped_df['percentage_left'].mean()[0.5:]
  1097. std = grouped_df['percentage_left'].std()[0.5:]
  1098. sem = std / np.sqrt(n_fish)
  1099. binned_time = mean.index.unique('window_time') * 10 + x_start
  1101. subfigb.draw_line(x=binned_time, y=mean*100, yerr=sem*100, lc='k', eafc='#404040', alpha=0.5, eaalpha=0.5, lw=1, ealw=1, eaec='#404040')
  1103. # Add the model fit to the plot with white background
  1104. folder_names_test = ['beh_simultaneous_blackwhite_white', ]
  1105. stim_len_timepoints_test = np.array([250])
  1106. stim_names_test = ['Motion', 'Photo', 'Same', 'Oppo']
  1108. testing_folder_ids = np.array([0, 0, 0, 0])
  1109. testing_stim_ids = np.array([0, 1, 2, 3, 0, 1, 2, 3])
  1111. test_model_once(model_func=avg_mot_lumi_change,
  1112. params=model_params,
  1113. folder_names=folder_names_test,
  1114. stim_len_timepoints=stim_len_timepoints_test,
  1115. stim_names=stim_names_test,
  1116. path_to_folders=path_to_folders,
  1117. subfig_data=None,
  1118. subfig_model=subfiga,
  1119. training_folder_ids=testing_folder_ids,
  1120. pick_stim_ids=testing_stim_ids,
  1121. pl_color='cyan')
  1123. # Plot the model contributions of all three main pathways - motion, luminance level, change in luminance- to the white background traces.
  1124. for i in range(len(stim_names_test)):
  1125. plot_model_contribution_single_experiment(model_func=avg_mot_lumi_change_full_node_outputs,
  1126. params=model_params,
  1127. folder_name=folder_names_test[0],
  1128. stim_len_timepoints=stim_len_timepoints_test[0],
  1129. stim_name=stim_names_test[i],
  1130. path_to_folders=path_to_folders,
  1131. subfig_contributions_left=subfigcs[i],
  1132. subfig_contributions_right=subfigds[i])
  1134. ## Add the model fit to the plot with black background
  1135. folder_names_test = ['beh_simultaneous_blackwhite_black', # simultaneous black
  1136. ]
  1137. stim_len_timepoints_test = np.array([250])
  1138. stim_names_test = ['Motion', 'Photo', 'Same', 'Oppo']
  1140. testing_folder_ids = np.array([0, 0, 0, 0])
  1141. testing_stim_ids = np.array([0, 1, 2, 3, 0, 1, 2, 3])
  1143. test_model_once(model_func=avg_mot_lumi_change,
  1144. params=model_params,
  1145. folder_names=folder_names_test,
  1146. stim_len_timepoints=stim_len_timepoints_test,
  1147. stim_names=stim_names_test,
  1148. path_to_folders=path_to_folders,
  1149. subfig_data=None,
  1150. subfig_model=subfigb,
  1151. training_folder_ids=testing_folder_ids,
  1152. pick_stim_ids=testing_stim_ids,
  1153. pl_color='cyan')
  1155. # Plot the model contributions of all three main pathways - motion, luminance level, change in luminance- to the black background traces.
  1156. for i in range(len(stim_names_test)):
  1157. plot_model_contribution_single_experiment(model_func=avg_mot_lumi_change_full_node_outputs,
  1158. params=model_params,
  1159. folder_name=folder_names_test[0],
  1160. stim_len_timepoints=stim_len_timepoints_test[0],
  1161. stim_name=stim_names_test[i],
  1162. path_to_folders=path_to_folders,
  1163. subfig_contributions_left=subfiges[i],
  1164. subfig_contributions_right=subfigfs[i])
  1166. subfigb.draw_line([1100, 1150], [22, 22], lc='k')
  1167. subfigb.draw_text(1125, 15, '5s')
  1168. subfigfs[-1].draw_line([200, 250], [-4, -4], lc='k')
  1169. subfigfs[-1].draw_text(225, -5, '5s')
  1170. return
  1172. def sub_plot_modelling_overview_mse_tau_w(n_training_rounds, subfig_mse_btm, subfig_mse_top, subfig_mse_sup, subfig_tau, subfig_w, path_to_folders):
  1173. '''
  1174. This function plots the full overview of the model performance across multifeature and unifeature training/testing strategies, the fitted timeconstants and the fitted weights.
  1175. This is related to Fig. 2h,i,j and Fig. S2d.
  1176. :param n_training_rounds: Integer number of training iterations.
  1177. :param subfig_mse_btm: Subfigure of the mean-squared-error of all model and training alterantives. Up to MSE=75 (the y-axis is split to accommodate for the very high error of the silenced motion-model).
  1178. :param subfig_mse_top: Subfigure of the mean-squared-error of all model and training alterantives. Up from MSE=75 (the y-axis is split to accommodate for the very high error of the silenced motion-model).
  1179. :param subfig_mse_sup: Subfigure of the mean-squared error of alternative models in the supplemental information.
  1180. :param subfig_tau: Subfigure of the fitted timeconstant distributions
  1181. :param subfig_w: Subfigure of the fitted weight distributions.
  1182. :param path_to_folders: path to folder containing all experiment folders.
  1183. :return:
  1184. '''
  1186. # We define the multifeature training stimuli.
  1187. folder_names_half = ['converted_phototaxis_dotmotion_integration_simultaneous_white', # Simultaneous
  1188. 'phototaxis_dotmotion_white_Sep', # White
  1189. 'phototaxis_dotmotion_simultaneous_low_Sep', # simul low
  1190. 'converted_phototaxis_dotmotion_integration_peppersalt', # peppersalt
  1191. 'converted_phototaxis_dotmotion_integration_long'] # long
  1192. stim_len_timepoints_half = np.array([250, 300, 450, 350, 600])
  1193. stim_names_half = ['Motion', 'Photo', 'Same', 'Oppo']
  1195. # We define the unifeature training stimuli.
  1196. folder_names_onlyML = ['converted_phototaxis_dotmotion_integration_simultaneous_white', # Simultaneous
  1197. 'phototaxis_dotmotion_simultaneous_low_Sep', # Simultaneous low
  1198. 'converted_phototaxis_dotmotion_integration_peppersalt', # Peppersalt
  1199. 'phototaxis_dotmotion_reverse_Sep', # Reverse
  1200. 'phototaxis_dotmotion_white_Sep', # White
  1201. 'converted_phototaxis_dotmotion_integration_long', # Long
  1202. 'beh_simultaneous_blackwhite_black', # Simultaneous black
  1203. 'beh_simultaneous_blackwhite_white', # Simultaneous white
  1204. 'phototaxis_dotmotion_integration_halfoverlap', # Halfoverlap
  1205. 'beh_simultaneous_10only'] # Simultaneous verylow
  1206. stim_len_timepoints_onlyML = np.array([250, 450, 350, 300, 300, 600, 250, 250, 350, 250])
  1207. stim_names_onlyML = ['Motion', 'Photo', ]
  1209. # We define the multifeature testing stimuli.
  1210. folder_names_half_test = ['beh_simultaneous_blackwhite_white', # simultaneous white
  1211. 'phototaxis_dotmotion_reverse_Sep', # Reverse
  1212. 'beh_simultaneous_blackwhite_black', # simultaneous black
  1213. 'phototaxis_dotmotion_integration_halfoverlap', # Halfoverlap
  1214. 'beh_simultaneous_10only'] #simulataneous very low
  1215. stim_len_timepoints_half_test = np.array([250, 300, 250, 350, 250])
  1216. stim_names_half_test = ['Motion', 'Photo', 'Same', 'Oppo']
  1218. # We define the unifeature testing stimuli.
  1219. folder_names_onlyML_test = ['converted_phototaxis_dotmotion_integration_simultaneous_white', # Simultaneous
  1220. 'phototaxis_dotmotion_simultaneous_low_Sep', # Simultaneous low
  1221. 'converted_phototaxis_dotmotion_integration_peppersalt', # Peppersalt
  1222. 'phototaxis_dotmotion_reverse_Sep', # Reverse
  1223. 'phototaxis_dotmotion_white_Sep', # White
  1224. 'converted_phototaxis_dotmotion_integration_long', # Long
  1225. 'beh_simultaneous_blackwhite_black', # Simultaneous black
  1226. 'beh_simultaneous_blackwhite_white', # Simultaneous white
  1227. 'phototaxis_dotmotion_integration_halfoverlap', # Halfoverlap
  1228. 'beh_simultaneous_10only'] # Simultaneous verylow
  1229. stim_len_timepoints_onlyML_test = np.array([250, 450, 350, 300, 300, 600, 250, 250, 350, 250])
  1230. stim_names_onlyML_test = ['Same', 'Oppo', ]
  1232. # Prepare lists to store the model performance of 8 models. For in the main figure: 2x original model with multifeature and unifeature training; 3x one of the pathways silenced. For in the supplemental figure: original, no multifeature integration, mutual inhibtion between motion integrators.
  1233. model_test_mses = [[]] * 8
  1235. print(f'Running model avg_mot_lumi_change multifeature training')
  1236. # Training the original model using multifeature training/testing
  1237. model_params, model_train_mse, all_folder_ids = train_model_full(model_func=avg_mot_lumi_change,
  1238. folder_names=folder_names_half,
  1239. stim_len_timepoints=stim_len_timepoints_half,
  1240. stim_names=stim_names_half,
  1241. path_to_folders=path_to_folders,
  1242. subfig=None,
  1243. train_loops=n_training_rounds)
  1244. # Re-arranging the 7 fitted parameters.
  1245. model_params = np.array(model_params).reshape(-1, 7)
  1246. for param in range(7):
  1247. print('Final param means: ')
  1248. print(f'param {param}: {model_params[:, param]}')
  1250. # Testing the performance of each of the n_trainings_round fits.
  1251. all_folder_ids = np.array(all_folder_ids).reshape(-1, 20)
  1252. for params, folder_ids in zip(model_params, all_folder_ids):
  1253. model_test_mses[0] = np.append(model_test_mses[0],
  1254. test_model_once(model_func=avg_mot_lumi_change, params=params,
  1255. folder_names=folder_names_half_test,
  1256. stim_len_timepoints=stim_len_timepoints_half_test,
  1257. stim_names=stim_names_half_test,
  1258. path_to_folders=path_to_folders,
  1259. subfig_data=None, subfig_model=None,
  1260. training_folder_ids=folder_ids))
  1262. # Plotting the model performance of the original model (note the mse-subfigure has a split y-axes at 75).
  1263. btm_idx = np.array(model_test_mses[0]) < 75
  1264. top_idx = np.array(model_test_mses[0]) >= 75
  1265. if np.sum(btm_idx) > 0:
  1266. subfig_mse_btm.draw_scatter(np.zeros(len(model_test_mses[0]))[btm_idx] + np.random.uniform(-0.4, 0.4, len(model_test_mses[0]))[btm_idx], model_test_mses[0][btm_idx], pc='cadetblue', ec='cadetblue')
  1267. if np.sum(top_idx) > 0:
  1268. subfig_mse_top.draw_scatter(np.zeros(len(model_test_mses[0]))[top_idx] + np.random.uniform(-0.4, 0.4, len(model_test_mses[0]))[top_idx], model_test_mses[0][top_idx], pc='cadetblue', ec='cadetblue')
  1269. if np.nanmedian(model_test_mses[0]) < 75:
  1270. subfig_mse_btm.draw_line([-0.4, 0.4], [np.nanmedian(model_test_mses[0]), np.nanmedian(model_test_mses[0])], lc='k', lw='1')
  1271. else:
  1272. subfig_mse_top.draw_line([-0.4, 0.4], [np.nanmedian(model_test_mses[0]), np.nanmedian(model_test_mses[0])], lc='k', lw='1')
  1274. # Plotting the model parameters and the median value (split into 4 timeconstants and 3 weights).
  1275. for param in range(7):
  1276. if param < 4:
  1277. subfig_tau.draw_scatter(2*param * np.ones(len(model_params[:, param])) + np.random.uniform(-0.4, 0.4, len(model_params[:, param])), model_params[:, param], pc='cadetblue', ec='cadetblue')
  1278. subfig_tau.draw_line([2*param - 0.4, 2*param + 0.4], [np.nanmedian(model_params[:, param]), np.nanmedian(model_params[:, param])], lc='k', lw='1')
  1279. else:
  1280. subfig_w.draw_scatter((2*param - 8) * np.ones(len(model_params[:, param])) + np.random.uniform(-0.4, 0.4, len(model_params[:, param])), model_params[:, param], pc='cadetblue', ec='cadetblue')
  1281. subfig_w.draw_line([2*param - 8 - 0.4, 2*param - 8 + 0.4], [np.nanmedian(model_params[:, param]), np.nanmedian(model_params[:, param])], lc='k', lw='1')
  1283. # Loop over all main-figure alternative models to train them using unifeature training/testing and plot their performance, and only for the original model, parameters.
  1284. for model_counter, (modelfunction, pl_color, param_size) in enumerate(zip(
  1285. [avg_mot_lumi_change, avg_mot_lumi, avg_mot_change, avg_lumi_change],
  1286. ['cyan', '#D55E00', '#E69F00', '#359B73'],
  1287. [7, 5, 5, 5])):
  1289. print(f'Running model {model_counter} unifeature training')
  1290. # Training the model using unifeature training/testing
  1291. model_params, model_train_mse, all_folder_ids = train_model_full(model_func=modelfunction,
  1292. folder_names=folder_names_onlyML,
  1293. stim_len_timepoints=stim_len_timepoints_onlyML,
  1294. stim_names=stim_names_onlyML,
  1295. path_to_folders=path_to_folders,
  1296. subfig=None,
  1297. train_loops=n_training_rounds)
  1298. # Re-arranging the 5 or 7 fitted parameters.
  1299. model_params = np.array(model_params).reshape(-1, param_size)
  1300. for param in range(param_size):
  1301. print('Final param means: ')
  1302. print(f'param {param}: {model_params[:, param]}')
  1304. # Testing the performance of each of the n_trainings_round fits.
  1305. all_folder_ids = np.array(all_folder_ids).reshape(-1, 20)
  1306. for params, folder_ids in zip(model_params, all_folder_ids):
  1307. model_test_mses[model_counter+1] = np.append(model_test_mses[model_counter+1],
  1308. test_model_once(model_func=modelfunction, params=params,
  1309. folder_names=folder_names_onlyML_test,
  1310. stim_len_timepoints=stim_len_timepoints_onlyML_test,
  1311. stim_names=stim_names_onlyML_test,
  1312. path_to_folders=path_to_folders,
  1313. subfig_data=None, subfig_model=None,
  1314. training_folder_ids=folder_ids))
  1316. # Plotting the model performance of the model (note the mse-subfigure has a split y-axes at 75).
  1317. btm_idx = np.array(model_test_mses[model_counter+1]) < 75
  1318. top_idx = np.array(model_test_mses[model_counter+1]) >= 75
  1319. if np.sum(btm_idx) > 0:
  1320. subfig_mse_btm.draw_scatter((model_counter + 1) * np.ones(len(model_test_mses[model_counter+1]))[btm_idx] + np.random.uniform(-0.4, 0.4, len(model_test_mses[model_counter+1]))[btm_idx],
  1321. model_test_mses[model_counter+1][btm_idx], pc=pl_color, ec=pl_color)
  1322. if np.sum(top_idx) > 0:
  1323. subfig_mse_top.draw_scatter((model_counter + 1) * np.ones(len(model_test_mses[model_counter+1]))[top_idx] + np.random.uniform(-0.4, 0.4, len(model_test_mses[model_counter+1]))[top_idx],
  1324. model_test_mses[model_counter+1][top_idx], pc=pl_color, ec=pl_color)
  1325. if np.nanmedian(model_test_mses[model_counter+1]) < 75:
  1326. subfig_mse_btm.draw_line([model_counter + 0.6, model_counter + 1.4], [np.nanmedian(model_test_mses[model_counter+1]), np.nanmedian(model_test_mses[model_counter+1])], lc='k', lw='1')
  1327. else:
  1328. subfig_mse_top.draw_line([model_counter + 0.6, model_counter + 1.4], [np.nanmedian(model_test_mses[model_counter+1]), np.nanmedian(model_test_mses[model_counter+1])], lc='k', lw='1')
  1330. # Only for the original model: Plotting the model parameters and the median value (split into 4 timeconstants and 3 weights).
  1331. if model_counter == 0:
  1332. for param in range(param_size):
  1333. if param < 4:
  1334. subfig_tau.draw_scatter((2*param+1) * np.ones(len(model_params[:, param])) + np.random.uniform(-0.4, 0.4, len(model_params[:, param])), model_params[:, param], pc=pl_color, ec=pl_color)
  1335. subfig_tau.draw_line([2*param+1-0.4, 2*param+1+0.4], [np.nanmedian(model_params[:, param]), np.nanmedian(model_params[:, param])], lc='k', lw='1')
  1336. print(f'Param {param}: {np.nanmedian(model_params[:, param])}')
  1337. else:
  1338. subfig_w.draw_scatter((2*param - 7) * np.ones(len(model_params[:, param])) + np.random.uniform(-0.4, 0.4, len(model_params[:, param])), model_params[:, param], pc=pl_color, ec=pl_color)
  1339. subfig_w.draw_line([2*param-7-0.4, 2*param-7+0.4], [np.nanmedian(model_params[:, param]), np.nanmedian(model_params[:, param])], lc='k', lw='1')
  1340. print(f'Param {param}: {np.nanmedian(model_params[:, param])}')
  1343. # Loop over all supplemental-figure alternative models to train them using unifeature training/testing and plot their performance.
  1344. for model_counter, (modelfunction, pl_color, param_size) in enumerate(zip(
  1345. [avg_mot_lumi_change, avg_mot_lumi_change_withmotinhib],
  1346. ['cyan', 'green'],
  1347. [7, 8])):
  1349. print(f'Running model {model_counter} unifeature training')
  1350. # Training the model using unifeature training/testing
  1351. model_params, model_train_mse, all_folder_ids = train_model_full(model_func=modelfunction,
  1352. folder_names=folder_names_onlyML,
  1353. stim_len_timepoints=stim_len_timepoints_onlyML,
  1354. stim_names=stim_names_onlyML,
  1355. path_to_folders=path_to_folders,
  1356. subfig=None,
  1357. train_loops=n_training_rounds)
  1358. # Re-arranging the 6, 7 or 8 fitted parameters.
  1359. model_params = np.array(model_params).reshape(-1, param_size)
  1360. for param in range(param_size):
  1361. print('Final param means: ')
  1362. print(f'param {param}: {model_params[:, param]}')
  1364. # Testing the performance of each of the n_trainings_round fits.
  1365. all_folder_ids = np.array(all_folder_ids).reshape(-1, 20)
  1366. for params, folder_ids in zip(model_params, all_folder_ids):
  1367. model_test_mses[model_counter+5] = np.append(model_test_mses[model_counter+5],
  1368. test_model_once(model_func=modelfunction, params=params,
  1369. folder_names=folder_names_onlyML_test,
  1370. stim_len_timepoints=stim_len_timepoints_onlyML_test,
  1371. stim_names=stim_names_onlyML_test,
  1372. path_to_folders=path_to_folders,
  1373. subfig_data=None, subfig_model=None,
  1374. training_folder_ids=folder_ids))
  1376. # Plotting the model performance of the model.
  1377. subfig_mse_sup.draw_scatter((model_counter + 1) * np.ones(len(model_test_mses[model_counter+5])) + np.random.uniform(-0.4, 0.4, len(model_test_mses[model_counter+5])),
  1378. model_test_mses[model_counter+5], pc=pl_color, ec=pl_color)
  1380. subfig_mse_sup.draw_line([model_counter + 0.6, model_counter + 1.4], [np.nanmedian(model_test_mses[model_counter+5]), np.nanmedian(model_test_mses[model_counter+5])], lc='k', lw='1')
  1383. # Do the statistical comparisons between the main-figure model fits using a t-test. The pval is compared to a Bonferonni corrected threshold.
  1384. for model1, model2, h in zip([0, 1, 1, 1],
  1385. [1, 2, 3, 4],
  1386. [80, 110, 140, 180]):
  1387. subfig_mse_top.draw_line([model1, model1, model2, model2], [h-1, h, h, h-1], lc='k')
  1388. _, pval = ttest_ind(model_test_mses[model1], model_test_mses[model2])
  1389. if pval < 0.001/4:
  1390. subfig_mse_top.draw_text((model1+model2)/2, h+2, '***')
  1391. elif pval < 0.01/4:
  1392. subfig_mse_top.draw_text((model1+model2)/2, h+2, '**')
  1393. elif pval < 0.05/4:
  1394. subfig_mse_top.draw_text((model1+model2)/2, h+2, '*')
  1395. else:
  1396. subfig_mse_top.draw_text((model1+model2)/2, h+4, 'ns')
  1397. effect_size = cohens_d(model_test_mses[model1], model_test_mses[model2])
  1398. print(f'model1 {model1} vs model2 {model2}, pval {pval}: Cohen D effect size {effect_size}')
  1400. # Do the statistical comparisons between the supplemental-figure model fits using a t-test. The pval is compared to a Bonferonni corrected threshold.
  1401. for model1, model2, h in zip([5,],
  1402. [6,],
  1403. [60,]):
  1404. subfig_mse_sup.draw_line([model1 - 4, model1 - 4, model2 - 4, model2 - 4], [h-1, h, h, h-1], lc='k')
  1405. _, pval = ttest_ind(model_test_mses[model1], model_test_mses[model2])
  1406. if pval < 0.001/2:
  1407. subfig_mse_sup.draw_text((model1-4+model2-4)/2, h+2, '***')
  1408. elif pval < 0.01/2:
  1409. subfig_mse_sup.draw_text((model1-4+model2-4)/2, h+2, '**')
  1410. elif pval < 0.05/2:
  1411. subfig_mse_sup.draw_text((model1-4+model2-4)/2, h+2, '*')
  1412. else:
  1413. subfig_mse_sup.draw_text((model1-4+model2-4)/2, h+4, 'ns')
  1414. effect_size = cohens_d(model_test_mses[model1], model_test_mses[model2])
  1415. print(f'model1 {model1} vs model2 {model2}, pval {pval}: Cohen D effect size {effect_size}')
  1416. return
  1419. if __name__ == '__main__':
  1420. # A general note for this file: We changed the names of the model nodes later for the paper. In this code we use moslty the old names:
  1421. # multifeature integrator used to be drive, luminance change detector used to be diff, luminance level integrator used to be lumi, luminance increase detector used to be bright, and luminance decrease detector used to be dark. Motion integrator was always motion.
  1422. # In the stimuli, lateral luminance cue is often referred to as Photo (from phototaxis stimulus), congruent stimuli are referred to as Same, conflicting stimuli as Oppo.
  1424. # Provide the path to save the figures.
  1425. fig_save_path = 'C:/users/katja/Desktop/fig_2.pdf'
  1426. supfig_save_path = 'C:/users/katja/Desktop/fig_S2.pdf'
  1428. # Provide the path to the figure_2 folder.
  1429. fig_2_folder_path = r'Z:\Bahl lab member directories\Katja\paper_data\figure_2'
  1431. # Get the paths to the combined dataframes for figure 2a-d.
  1432. path_to_analysed = Path(fr'{fig_2_folder_path}\data_analysed.hdf5')
  1434. # Get the path to the folder containing all experiment folders.
  1435. path_to_folders = Path(fr'{fig_2_folder_path}')
  1437. # Here we define the figures and subpanel outlines (e.g. the limits, ticks and labels of the axes) beloning to figure 2 and S2.
  1438. fig = Figure(fig_width=18, fig_height=17)
  1439. subfig = Figure(fig_width=18, fig_height=8)
  1441. # Fig. 2a
  1442. plot_motion = fig.create_plot(xpos=1, ypos=13.5, plot_height=2, plot_width=3.5, errorbar_area=True,
  1443. xmin=0, xmax=25, yl='left swims (%)', ymin=0.25,
  1444. ymax=0.9, yticks=[0.30, 0.50, 0.70, 0.90], yticklabels=['30', '50', '70', '90'], hlines=[0.5],
  1445. helper_lines_lc='w', helper_lines_dashes=(2, 0), helper_lines_lw=1, vspans=[[5, 20, 'lightgray', 1.0], ])
  1447. # Fig. 2b
  1448. plot_lumi = fig.create_plot(xpos=5, ypos=13.5, plot_height=2, plot_width=3.5, errorbar_area=True,
  1449. xmin=0, xmax=25, ymin=0.25,
  1450. ymax=0.9, yticks=[0.30, 0.50, 0.70, 0.90], yticklabels=['', '', '', ''], hlines=[0.5],
  1451. helper_lines_lc='w', helper_lines_dashes=(2, 0), helper_lines_lw=1, vspans=[[5, 20, 'lightgray', 1.0], ])
  1453. # Fig. 2c
  1454. plot_same = fig.create_plot(xpos=9, ypos=13.5, plot_height=2, plot_width=3.5, errorbar_area=True,
  1455. xmin=0, xmax=25, ymin=0.25,
  1456. ymax=0.9, yticks=[0.30, 0.50, 0.70, 0.90], yticklabels=['', '', '', ''], hlines=[0.5],
  1457. helper_lines_lc='w', helper_lines_dashes=(2, 0), helper_lines_lw=1, vspans=[[5, 20, 'lightgray', 1.0], ])
  1459. # Fig. 2d
  1460. plot_oppo = fig.create_plot(xpos=13, ypos=13.5, plot_height=2, plot_width=3.5, errorbar_area=True,
  1461. xmin=0, xmax=25, ymin=0.25,
  1462. ymax=0.9, yticks=[0.30, 0.50, 0.70, 0.90], yticklabels=['', '', '', ''], hlines=[0.5],
  1463. helper_lines_lc='w', helper_lines_dashes=(2, 0), helper_lines_lw=1, vspans=[[5, 20, 'lightgray', 1.0], ])
  1465. # Fig. 2g
  1466. plot_model_ADD_example = fig.create_plot(xpos=1, ypos=9, plot_height=1.4, plot_width=7, errorbar_area=True,
  1467. xmin=0, xmax=3250, ymin=20, ymax=90, yticks=[50, 75], yl='l (%)')
  1468. plot_model_ADD_only_example = fig.create_plot(xpos=1, ypos=8., plot_height=1.4, plot_width=7, errorbar_area=True,
  1469. xmin=0, xmax=3250, ymin=20, ymax=90, yticks=[50, 75], yl='left swims (%)')
  1470. plot_model_data_example = fig.create_plot(xpos=1, ypos=6.5, plot_height=1.4, plot_width=7, errorbar_area=True,
  1471. xmin=0, xmax=3250, ymin=20, ymax=90, yticks=[25, 50, 75], yl='left swims (%)')
  1473. # Fig. S2b
  1474. plot_white_example = subfig.create_plot(xpos=1, ypos=2.5, plot_height=1.4, plot_width=6.5, errorbar_area=True,
  1475. xmin=0, xmax=1150, ymin=20, ymax=90, yticks=[25, 50, 75], yl='left swims (%)',
  1476. vspans=[[50, 200, 'lightgray', 1.0], [350, 500, 'lightgray', 1.0], [650, 800, 'lightgray', 1.0], [950, 1100, 'lightgray', 1.0]])
  1477. plot_black_example = subfig.create_plot(xpos=8.5, ypos=2.5, plot_height=1.4, plot_width=6.5, errorbar_area=True,
  1478. xmin=0, xmax=1150, ymin=20, ymax=90, yticks=[25, 50, 75],
  1479. vspans=[[50, 200, 'lightgray', 1.0], [350, 500, 'lightgray', 1.0], [650, 800, 'lightgray', 1.0], [950, 1100, 'lightgray', 1.0]])
  1481. # Fig. S2c
  1482. plot_contributions_examples_white_left = [[]] * 4
  1483. plot_contributions_examples_white_right = [[]] * 4
  1484. plot_contributions_examples_black_left = [[]] * 4
  1485. plot_contributions_examples_black_right = [[]] * 4
  1486. for i in range(4):
  1487. if i == 0:
  1488. plot_contributions_examples_white_left[i] = subfig.create_plot(xpos=1 + 1.7*i, ypos=1.3, plot_height=0.7, plot_width=1.4, errorbar_area=True,
  1489. xmin=0, xmax=250, ymin=-0.2, ymax=4.5, yticks=[0, 2, 4],
  1490. yticklabels=['0', '2', '4'], yl='node activity (au)',
  1491. vspans=[[50, 200, 'lightgray', 1.0], ])
  1492. plot_contributions_examples_white_right[i] = subfig.create_plot(xpos=1 + 1.7*i, ypos=0.5, plot_height=0.7, plot_width=1.4, errorbar_area=True,
  1493. xmin=0, xmax=250, ymin=-4.5, ymax=0.2, yticks=[-4, -2, 0],
  1494. yticklabels=['4', '2', '0'],
  1495. vspans=[[50, 200, 'lightgray', 1.0], ])
  1496. plot_contributions_examples_black_left[i] = subfig.create_plot(xpos=8.5 + 1.7*i, ypos=1.3, plot_height=0.7, plot_width=1.4, errorbar_area=True,
  1497. xmin=0, xmax=250, ymin=-0.2, ymax=4.5, yticks=[0, 2, 4],
  1498. yticklabels=['0', '2', '4'],
  1499. vspans=[[50, 200, 'lightgray', 1.0], ])
  1500. plot_contributions_examples_black_right[i] = subfig.create_plot(xpos=8.5 + 1.7*i, ypos=0.5, plot_height=0.7, plot_width=1.4, errorbar_area=True,
  1501. xmin=0, xmax=250, ymin=-4.5, ymax=0.2, yticks=[-4, -2, 0],
  1502. yticklabels=['4', '2', '0'],
  1503. vspans=[[50, 200, 'lightgray', 1.0], ])
  1504. else:
  1505. plot_contributions_examples_white_left[i] = subfig.create_plot(xpos=1 + 1.7*i, ypos=1.3, plot_height=0.7, plot_width=1.4, errorbar_area=True,
  1506. xmin=0, xmax=250, ymin=-0.2, ymax=4.5,
  1507. vspans=[[50, 200, 'lightgray', 1.0], ])
  1508. plot_contributions_examples_white_right[i] = subfig.create_plot(xpos=1 + 1.7*i, ypos=0.5, plot_height=0.7, plot_width=1.4, errorbar_area=True,
  1509. xmin=0, xmax=250, ymin=-4.5, ymax=0.2,
  1510. vspans=[[50, 200, 'lightgray', 1.0], ])
  1511. plot_contributions_examples_black_left[i] = subfig.create_plot(xpos=8.5 + 1.7*i, ypos=1.3, plot_height=0.7, plot_width=1.4, errorbar_area=True,
  1512. xmin=0, xmax=250, ymin=-0.2, ymax=4.5,
  1513. vspans=[[50, 200, 'lightgray', 1.0], ])
  1514. plot_contributions_examples_black_right[i] = subfig.create_plot(xpos=8.5 + 1.7*i, ypos=0.5, plot_height=0.7, plot_width=1.4, errorbar_area=True,
  1515. xmin=0, xmax=250, ymin=-4.5, ymax=0.2,
  1516. vspans=[[50, 200, 'lightgray', 1.0], ])
  1518. # Fig. 2h
  1519. plot_mse_overview_bottom = fig.create_plot(xpos=9, ypos=7.5, plot_height=1.25, plot_width=2.25,
  1520. xmin=-1, xmax=5, ymin=0, ymax=75, yticks=[10, 20, 30, 40, 50], yl='MSE',
  1521. xticks=[0, 1, 2, 3, 4], xticklabels=['multifeature\ntesting', 'unifeature\ntesting', 'X lumi change',
  1522. 'X lumi level', 'X motion'], xticklabels_rotation=90)
  1523. plot_mse_overview_top = fig.create_plot(xpos=9, ypos=8.75, plot_height=1.25, plot_width=2.25,
  1524. xmin=-1, xmax=5, ymin=75, ymax=210, yticks=[100, 150, 200])
  1526. # Fig. S2d
  1527. plot_mse_overview_sup = subfig.create_plot(xpos=16, ypos=2.5, plot_height=1.6, plot_width=2,
  1528. xmin=0, xmax=3, ymin=0, ymax=65, yticks=[10, 20, 30, 40, 50], yl='MSE',
  1529. xticks=[1, 3], xticklabels=['unifeature\ntesting', '+ Mot inhi'], xticklabels_rotation=90)
  1531. # Fig. 2i
  1532. plot_timeconstants_overview = fig.create_plot(xpos=12, ypos=7.5, plot_height=2.5, plot_width=2.25,
  1533. xmin=-1, xmax=8, ymin=0, ymax=31, yticks=[0, 5, 10, 15, 20, 25, 30],
  1534. yticklabels=['0', '0.5', '1.0', '1.5', '2.0', '2.5', '3.0'], yl='time constant (s)',
  1535. xticks=[0.5, 2.5, 4.5, 6.5], xticklabels=['\u03C4 motion', '\u03C4 lumi level', '\u03C4 lumi change', '\u03C4 multifeature'],
  1536. xticklabels_rotation=90)
  1537. # Fig. 2j
  1538. plot_weights_overview = fig.create_plot(xpos=15, ypos=7.5, plot_height=2.5, plot_width=2.25,
  1539. xmin=-1, xmax=6, ymin=0, ymax=3.5, yticks=[0, 1, 2, 3], yl='weight',
  1540. xticks=[0.5, 2.5, 4.5], xticklabels=['w motion', 'w lumi level', 'w lumi change'],
  1541. xticklabels_rotation=90)
  1543. print('Plot supplemental figure example data with model fit and node contributions.')
  1544. sub_plot_example_traces_model_fit(path_to_analysed, plot_white_example, plot_black_example, plot_contributions_examples_white_left, plot_contributions_examples_white_right, plot_contributions_examples_black_left, plot_contributions_examples_black_right, path_to_folders)
  1546. print('Plotting temporal data')
  1547. sub_plot_temp_dyn_data(path_to_analysed, [plot_motion, plot_lumi, plot_same, plot_oppo])
  1549. print('Plotting example traces')
  1550. sub_plot_modelling_example_traces(plot_model_ADD_example, plot_model_ADD_only_example, plot_model_data_example, path_to_folders)
  1552. print('Plotting model overview')
  1553. sub_plot_modelling_overview_mse_tau_w(n_training_rounds=25, subfig_mse_btm=plot_mse_overview_bottom, subfig_mse_top=plot_mse_overview_top, subfig_mse_sup=plot_mse_overview_sup, subfig_tau=plot_timeconstants_overview, subfig_w=plot_weights_overview, path_to_folders=path_to_folders)
  1555. fig.save(fig_save_path)
  1556. subfig.save(supfig_save_path)
  1558. # Note that Figure 2e-f and S2a only contain explanatory cartoons without actual data and therefore are not part of this code.

figure2_S2_behavior_tempdynamics.py at commit c321f06, no license · at the source

Overview

Authors: Katja Slangewal1,2,3, Sophie Aimon1,2, Maxim Q. Capelle1,2,3, Florian Kämpf1,4, Heike Naumann1, Krasimir Slanchev5, Herwig Baier5, Armin Bahl1,2,3,6,7
ORCID iDs: Katja Slangewal, Sophie Aimon, Maxim Q. Capelle, Florian Kämpf, Heike Naumann, Krasimir Slanchev, Herwig Baier, Armin Bahl
  1. Department of Biology, University of Konstanz,Konstanz, Germany
  2. Centre for the Advanced Study of Collective Behaviour,Konstanz, Germany
  3. International Max Planck Research School for Quantitative Behaviour, Ecology and Evolution (IMPRS/QBEE); Max Planck Institute of Animal Behavior,Konstanz, Germany
  4. Present Address: Medical Research Council Laboratory of Molecular Biology,Cambridge, UK
  5. Max Planck Institute for Biological Intelligence,Martinsried, Germany
  6. Max Planck Institute of Animal Behavior,Konstanz, Germany
  7. Zukunftskolleg,Konstanz, Germany
Institutions: University of Konstanz (Germany); Max Planck Institute of Animal Behavior (Germany); MRC Laboratory of Molecular Biology (United Kingdom); Max Planck Institute for Biological Intelligence
Journal: Nature communications, volume 17, issue 1, article 2024
Dates: received 20 August 2025; accepted 5 February 2026; published online 5 March 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41467-026-69633-4 · PMID 41786700 · PMCID PMC12963418 · OpenAlex W7133646064
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: zebrafish (organism), cognitive (subfield)
Methods: Connectivity, Statistics, Smoothing, state filtering, decompositions, Evoked potentials, Machine learning, Single-unit activity, calcium imaging
Keywords: Neural circuits, Decision, Sensory processing, Motion detection
MeSH: Decision Making*, Rhombencephalon*, Zebrafish*, Animals, Larva, Neurons, Photic Stimulation, Phototaxis (* major topic)
Topic: Zebrafish Biomedical Research Applications (Cell Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: EC | EU Framework Programme for Research and Innovation H2020 | H2020 Priority Excellent Science | H2020 European Research Council (H2020 Excellent Science - European Research Council) (101075541 – CollectiveDecisions); Deutsche Forschungsgemeinschaft (DFG) (EXC 2117 – 422037984, BA 5923/1-1); NIH (U19NS104653)
Citations: cited by 5 papers (Europe PMC); 89 references in the paper

Abstract

Animals continuously extract and evaluate diverse sensory information from the environment to guide behavior. Yet, how neural circuits integrate multiple, potentially conflicting, inputs remains poorly understood. Here, we use larval zebrafish to address this question, leveraging their robust optomotor response to coherent random dot motion and phototaxis towards light. We demonstrate that animals employ an additive behavioral algorithm of three visual features: motion coherence, luminance level, and changes in luminance. Using brain-wide two-photon imaging, we identify the loci of these computations, with the anterior hindbrain emerging as a multifeature integration hub. Through single-cell neurotransmitter and morphological analyses of functionally identified neurons, we characterize potential connections within and across computational nodes. These experiments reveal three parallel and converging computational pathways, matching our behavioral results. Our study provides a mechanistic brain-wide account of how a vertebrate brain integrates multiple features to drive sensorimotor decisions, bridging behavioral algorithms with their neural implementation.

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

Repository

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

bahl-lab-konstanz/multifeature_integration_paper

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: c321f06836f6fa4a0fb849969854927c75df28bc, 23 February 2026
Languages: Python (12)
Size: 20 files, 12 scripts
Software Heritage: not archived
Found in: DataCite
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (12 files), pandas (9 files), h5py (8 files), Matplotlib (7 files), SciPy (7 files), scikit-learn (2 files), imageio (1 file), Pillow (1 file), seaborn (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
13 files
At the source: github.com/bahl-lab-konstanz/multifeature_integration_paper

Code availability

Analysis and model code have been archived and are publicly available in KonData with the identifier 10.48606/6jhypme0jeu49raa.

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

Tracing map

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

What the map holds:

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

The behavior and preprocessed imaging data reported in this study are publicly available in KonData with the identifier 10.48606/tus7hs1zv77phbtv. The preprocessed imaging data contains the raw fluorescent traces for each neuron, as well as the averaged imaging stack. The raw imaging data itself is too large to upload to KonData (~ 3TB). This data will be provided upon request without restrictions. We will respond to requests within 10 working days, and shared data will remain available as long as requested.

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

Recorded: type, language, journal, volume, issue, pages, dates, 8 authors, 4 keywords, 8 MeSH terms, 3 funders, 86 references.

Cite

This paper

Slangewal, K., Aimon, S., Capelle, M. Q., Kämpf, F., Naumann, H., Slanchev, K., Baier, H., & Bahl, A. (2026). Visuomotor decision-making through multifeature convergence in the larval zebrafish hindbrain. Nature communications, 17(1), 2024. https://doi.org/10.1038/s41467-026-69633-4

BibTeX

@article{slangewal2026visuomotor,
author = {Slangewal, Katja and Aimon, Sophie and Capelle, Maxim Q. and Kämpf, Florian and Naumann, Heike and Slanchev, Krasimir and Baier, Herwig and Bahl, Armin},
title = {{Visuomotor decision-making through multifeature convergence in the larval zebrafish hindbrain}},
journal = {Nature communications},
year = {2026},
month = mar,
volume = {17},
number = {1},
pages = {2024},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-69633-4},
url = {https://doi.org/10.1038/s41467-026-69633-4},
pmid = {41786700},
pmcid = {PMC12963418}
}

RIS

TY - JOUR
AU - Slangewal, Katja
AU - Aimon, Sophie
AU - Capelle, Maxim Q.
AU - Kämpf, Florian
AU - Naumann, Heike
AU - Slanchev, Krasimir
AU - Baier, Herwig
AU - Bahl, Armin
TI - Visuomotor decision-making through multifeature convergence in the larval zebrafish hindbrain
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/03/05
VL - 17
IS - 1
SP - 2024
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-69633-4
UR - https://doi.org/10.1038/s41467-026-69633-4
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-69633-4",
"type": "article-journal",
"title": "Visuomotor decision-making through multifeature convergence in the larval zebrafish hindbrain",
"container-title": "Nature communications",
"author": [
{
"family": "Slangewal",
"given": "Katja"
},
{
"family": "Aimon",
"given": "Sophie"
},
{
"family": "Capelle",
"given": "Maxim Q."
},
{
"family": "Kämpf",
"given": "Florian"
},
{
"family": "Naumann",
"given": "Heike"
},
{
"family": "Slanchev",
"given": "Krasimir"
},
{
"family": "Baier",
"given": "Herwig"
},
{
"family": "Bahl",
"given": "Armin"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "2024",
"DOI": "10.1038/s41467-026-69633-4",
"PMID": "41786700",
"PMCID": "PMC12963418",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-69633-4",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
5
]
]
}
}

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/s41467-026-76267-z [code]
Modulation of habenula axon terminals supports action-outcome associations in larval zebrafish.
Journal: Nature communications
In common: imageio, Pillow, seaborn, 5 other tools, zebrafish, 11 references
[2] doi:10.1016/j.isci.2026.116190
Behavioral algorithms of ontogenetic switching in larval and juvenile zebrafish phototaxis.
Journal: iScience
In common: zebrafish, 12 references, author Armin Bahl
[3] doi:10.7554/elife.100880 [code]
An applicable and efficient retrograde monosynaptic circuit mapping tool for larval zebrafish.
Journal: eLife
In common: h5py, seaborn, scikit-learn, 4 other tools, zebrafish, 7 references
[4] doi:10.1038/s41467-026-71371-6
Molecular and functional dissection using CaMPARI-seq reveals the neuronal organization for dissociating optic flow-dependent behaviors.
Journal: Nature communications
In common: zebrafish, 10 references
[5] doi:10.1016/j.isci.2026.116206 [code]
Gut distension evokes rapid neural dynamics in vagal and hindbrain populations of larval zebrafish.
Journal: iScience
In common: Pillow, seaborn, scikit-learn, 4 other tools, zebrafish, 6 references
[6] doi:10.1038/s41467-026-76242-8 [code]
Whole-brain, all-optical interrogation of neuronal dynamics underlying gut and vascular interoception in zebrafish.
Journal: Nature communications
In common: h5py, scikit-learn, pandas, 3 other tools, zebrafish, 5 references
[7] doi:10.1038/s41467-026-72222-0 [code]
Eye movement kinematics reveal novel circadian organization of sleep substates.
Journal: Nature communications
In common: zebrafish, 7 references
[8] doi:10.1038/s41592-026-03179-7 [code]
Voltage imaging of neurons distributed across entire brains of larval zebrafish.
Journal: Nature methods
In common: h5py, SciPy, Matplotlib, 1 other tool, zebrafish, 5 references
[9] doi:10.1038/s41467-026-71640-4
Neural temporal scaling accounts for robust hunting behavior across temperatures.
Journal: Nature communications
In common: zebrafish, 7 references
[10] doi:10.1016/j.isci.2026.117136 [code]
Complex pectoral-fin-driven locomotion underlies refined visuomotor behavior in the cichlid &lt;i&gt;Astatotilapia burtoni&lt;/i&gt;.
Journal: iScience
In common: scikit-learn, pandas, SciPy, 2 other tools, zebrafish, 4 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.