OSCR

Machine learning discovers numerous new computational principles supporting elementary motion detection.

Code ↔ Paper

4 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 4 matches
  1. [1] § Results › Methods to identify circuit components participating in DS computations ↔ main.py, lines 1–59 · score 0.61 · RF structure, receptive field, presynaptic population, surround, postsynaptic, components
  2. [2] § Results › Machine learning framework to study motion computations ↔ main.py, lines 1–59 · score 0.58 · RF orientations, receptive field, presynaptic population, network, synapsing, kinetics
  3. [3] § Methods ↔ GA_RF.py, lines 44–113 · score 0.55 · RF component, Gaussian, fraction, sum, width, surround
  4. [4] § Results › Machine learning framework to study motion computations ↔ GA_RF.py, lines 44–113 · score 0.50 · temporal activation, standard deviation, shifted, dynamics, peak, RF

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 · 452 lines · 22 KB · no license · 2 matches

  1. from multiprocessing import Process, Queue, freeze_support, Pipe
  2. import numpy as np
  3. import time
  4. import matplotlib.pyplot as plt
  5. from neuron import h
  6. #from time import sleep
  7. from GA_RF import GA_Pre_activation , GA_StimTrajectory
  8. from GA_h5 import GA_SaveH5
  9. from neuron import h
  10. import copy
  11. import pickle
  12. #import sys
  13. import argparse
  16. h.load_file('stdrun.hoc')
  18. from GA_NEURON import NEURON_SetCells, NEURON_UpdateSynapses, NEURON_mutation, GA_RecordingVectors
  20. h.load_file('stdrun.hoc')
  21. # Receptive fields of Excitatory and Inhibitory presynaptic populations
  22. pre_cell_types = ["excitation", "inhibition"]
  23. pre_RF_components = ["center", "surround"]
  25. global_params = {
  26. 'randomStart': True, # random params or load from file
  27. 'numPop': 10, # population size
  28. 'numGen': 300, # number of generations
  29. 'activeChannels': '',#'Ka,CaN', #CaN,CaL,caLinear, Ka,Km,IH,Kdr
  30. 'cellType': 'RGC', #['RGC', 'L23', 'L5', 'SAC', 'SAC network'], # Cell type (RGC, L23, L5, SAC, SAC-simple morphology)
  31. 'numSpeed': 3, # number of probed speeds
  32. 'numContrast': 1, # number of probed contrasts
  33. 'numDir': 2, # number of probed directions, keep 2 or more
  35. 'numPreClus': 4, # number of different presynaptic clusters with different response profiles
  36. 'numPostComp': 4, # number of different postsynaptic compartments with possible different distributions of voltage gated channels
  37. 'numVoltagePoints': 20, # number of different postsynaptic voltage points to modify the voltage gated channels, starting at -80 and increse by 5mV
  38. #compartments with possible different distributions of voltage gated channels
  40. 'numSyn': 100, # number of synaptic inputs
  41. 'distSyn': 0, # distance in microns between synapses, set to zero or negative to use random numSyn only
  42. 'dt': 10, # Time step
  43. 'mutationRate': 0.1, # Change in param values between generations
  44. # RF structue
  45. "RF_constrains": {
  46. cell_type: {
  47. cs: {
  48. 'sameKinetics': False, # Presynaptic inputs that vary in their kinetics
  49. 'sameSize': False, # Presynaptic inputs that vary in their RF size
  50. 'sameAmplitude': False, # Presynaptic inputs that vary in their strength
  51. 'sameOrientation': True,# Presynaptic inputs that vary in their RF orientation
  52. 'doSurround': False, # mutate surround (does nothing for center components)
  53. }
  54. for cs in pre_RF_components
  55. }
  56. for cell_type in pre_cell_types
  57. },
  59. 'inhibition': True, # include inhibitory presynaptic inputs
  61. # SAC NETWORK ONLY
  62. 'numSAClayersX': 1, # how many SACs are arranged around the target cell; 0 will create one cell
  63. 'numSAClayersY': 1, # how many SACs are arranged around the target cell in Y; 1 is minimal number
  64. 'distSAC': 25, # Distance between cells
  65. 'maxSAC_syndist': 15, # highest possible distance between pre and post synaptic locations
  66. # SIMULATION
  67. 'debugger': {
  68. 'run_neuron': True, # Actually run the simulation
  69. 'multithread': False, # Use multuple threads or not
  70. 'stop_mutations': False, # Do not mutate the models
  71. 'set_speed': 1, # Use this speed only (set to zero/negative to disable)
  72. 'set_dir': -1, # Use this direction only (set to negative to disable)
  73. 'plot_outcome': True, # Plot simulation results
  74. 'plot_inputs': False, # Plot the inputs
  75. 'plot_positions': False, # Plot the cell positions
  76. 'print_dsi': True, # print DSI values for all cells
  77. },
  78. #'run_debugger': True, # RUN DEBUGGER
  79. 'run_debugger': False, # TRUE to run normal sim, otherwise apply the debugger
  80. 'job_id': 0,
  81. 'save_every_gen': 10,
  82. 'numCells': 1, # number of cells
  83. 'ca_present': False, # ca conductance exists
  84. 'k_present': False, # k conductance exists
  85. 'save_all': False, # Save all parameters (takes a lot of space)
  87. }
  88. if not global_params['run_debugger']:
  89. global_params['debugger']['run_neuron']= True
  90. global_params['debugger']['multithread']= True
  91. global_params['debugger']['stop_mutations']= False
  92. global_params['debugger']['set_speed']= -1
  93. global_params['debugger']['set_dir']= -1
  94. global_params['debugger']['plot_outcome']= False
  95. global_params['debugger']['plot_inputs']= False
  96. global_params['debugger']['plot_positions']= False
  97. global_params['debugger']['print_dsi']= False
  100. #----------------------------- arguments!
  101. parser = argparse.ArgumentParser(description="Simulation Configuration")
  102. parser.add_argument('--cellType', type=str)
  103. parser.add_argument('--activeChannels', type=str)
  104. parser.add_argument('--numSAClayersX', type=int)
  105. parser.add_argument('--distSAC', type=int)
  106. parser.add_argument('--job_id', type=int)
  109. global_params.update({key: val for key, val in vars(parser.parse_args()).items() if val is not None and key in global_params})
  110. if len(global_params['activeChannels']) > 0 :
  111. print(f"active channels: {global_params['activeChannels']}")
  113. stim_params = {
  114. 'dt': global_params['dt'],
  115. 'dx': 10,
  116. 'arena': 1000,
  117. 'tStop': 3000,
  118. 'speed': 1,
  119. 'contrast': 1,
  120. 'angle': 0,
  121. 'delay': 500,
  122. 'duration': 200
  123. }
  125. class Model:
  126. pass
  127. def __init__(self):
  128. self.InputE_synapses = [] # Synaptic inputs from presynaptic populations that can have difefrent RF properties
  129. self.InputI_synapses = []
  130. self.SAC_SAC_synapses = [] # Feedback inhibition from pther SACs
  131. self.cell = [] # Morhphology etc
  132. self.input_params = {}
  133. self.output_params = {}
  136. def GA_Run(model, stim_params, global_params):
  137. h(f"forall g_pas={float(model.input_params['passive_params']['pas'])}")
  138. h(f"forall Ra={float(model.input_params['passive_params']['Ra'])}")
  139. # Flexible active conductances
  140. v_vec= np.linspace(-80, -80+5*global_params['numVoltagePoints'], global_params['numVoltagePoints']) # Voltage stops
  141. V_Vec = h.Vector(v_vec)
  142. #mtau_vec= h.Vector(model.input_params['active_params']['mtau_caGA'])
  143. #print('presetn',V_Vec.size(), mtau_vec.size()) # Should return True
  145. if "caGA" in global_params['activeChannels']: # Flexible conductance present
  146. h.table_minf_caGA(h.Vector(model.input_params['active_params']['minf_caGA']), V_Vec)
  147. h.table_mtau_caGA(h.Vector(model.input_params['active_params']['mtau_caGA']), V_Vec)
  148. h.table_hinf_caGA(h.Vector(model.input_params['active_params']['hinf_caGA']), V_Vec)
  149. h.table_htau_caGA(h.Vector(model.input_params['active_params']['htau_caGA']), V_Vec)
  150. if "kGA" in global_params['activeChannels']: # Flexible conductance present
  151. h.table_ninf_kGA(h.Vector(model.input_params['active_params']['minf_kGA']), V_Vec)
  152. h.table_ntau_kGA(h.Vector(model.input_params['active_params']['mtau_kGA']), V_Vec)
  153. h.table_hinf_kGA(h.Vector(model.input_params['active_params']['hinf_kGA']), V_Vec)
  154. h.table_htau_kGA(h.Vector(model.input_params['active_params']['htau_kGA']), V_Vec)
  157. for cell in range(global_params['numCells']):
  158. for d, sec in enumerate(model.cell[cell].all):
  159. #sec.push()
  160. type= model.output_params['cell'][cell]['activeCompartment']['type'][d]
  161. if h.ismembrane("canrgc", sec=sec): # N-type conductance present
  162. for seg in sec:
  163. seg.gbar_canrgc = model.input_params['active_params']['gbar_canrgc'][type].item()
  164. seg.shift_canrgc = model.input_params['active_params']['shift_canrgc']
  165. if h.ismembrane("calrgcfix", sec=sec): # L-type conductance present
  166. for seg in sec:
  167. seg.gbar_calrgc = model.input_params['active_params']['gbar_calrgc'][type].item()
  168. seg.shift_calrgc = model.input_params['active_params']['shift_calrgc']
  169. if h.ismembrane("caGA", sec=sec): # Flexible conductance present
  170. for seg in sec:
  171. seg.gMax_caGA = model.input_params['active_params']['gMax_caGA'][type].item()
  172. seg.mN_caGA = model.input_params['active_params']['mN_caGA']
  175. if h.ismembrane("kap", sec=sec): # A-type conductance present
  176. for seg in sec:
  177. seg.gkabar_kap = model.input_params['active_params']['gbar_ka'][type].item()
  178. seg.shift_kap = model.input_params['active_params']['shift_ka']
  179. if h.ismembrane("km", sec=sec): # M-type conductance present
  180. for seg in sec:
  181. seg.gbar_km = model.input_params['active_params']['gbar_km'][type].item()
  182. seg.shift_km = model.input_params['active_params']['shift_km']
  183. if h.ismembrane("kSlow", sec=sec): # DR-type conductance present
  184. for seg in sec:
  185. seg.gkbar_kSlow = model.input_params['active_params']['gbar_kd'][type].item()
  186. seg.v_shift_kSlow = model.input_params['active_params']['shift_kd']
  187. if h.ismembrane("ih", sec=sec): # M-type conductance present
  188. for seg in sec:
  189. seg.ghdbar_ih = model.input_params['active_params']['gbar_ih'][type].item()
  190. seg.shift_ih = model.input_params['active_params']['shift_ih']
  191. if h.ismembrane("kGA", sec=sec): # Flexible conductance present
  192. for seg in sec:
  193. seg.gMax_kGA = model.input_params['active_params']['gMax_kGA'][type].item()
  194. seg.nN_kGA = model.input_params['active_params']['nN_kGA']
  197. GA_RecordingVectors(global_params, stim_params, model, prep= True)
  200. # Run multiple simulations for a range of contrasts and velocities
  201. for speed in range(global_params['numSpeed']):
  202. # Compute speed
  203. stim_params['speed']= 1
  204. if(global_params['numSpeed'] == 5):
  205. stim_params['speed']= 2**(speed - 2)
  206. if(global_params['numSpeed'] == 3):
  207. stim_params['speed']= 4**(speed - 1)
  208. if(global_params['numSpeed'] == 2):
  209. stim_params['speed']= 0.25 + 0.75 * speed
  210. if(global_params['debugger']['set_speed'] > 0):
  211. stim_params['speed']= global_params['debugger']['set_speed']
  213. # Computation of activation params
  214. model.input_params['trajectory'] = GA_StimTrajectory(stim_params)
  215. for cls in range(global_params['numPreClus']):
  216. model.input_params['InputE_syn_time'][cls, :] = GA_Pre_activation('excitation', model.input_params['RF_params'], model.input_params['trajectory'], stim_params, pop=0, cls=cls)
  217. if global_params['inhibition']:
  218. model.input_params['InputI_syn_time'][cls, :] = GA_Pre_activation('inhibition', model.input_params['RF_params'], model.input_params['trajectory'], stim_params, pop=0, cls=cls)
  220. for contrast in range(global_params['numContrast']):
  221. stim_params['contrast']= (3**(contrast + 1)) / 3**global_params['numContrast']
  222. # Run for different directions, compute DSI and store it
  223. score_right= []
  224. score_left= []
  225. model.output_params['cell'][cell]['max_soma_single_run']= []
  226. for cell in range(global_params['numCells']):
  227. model.output_params['cell'][cell]['dendrite_vectors']['max_right_single_run']= []
  228. model.output_params['cell'][cell]['dendrite_vectors']['max_left_single_run']= []
  229. for dr in range (global_params['numDir']):
  231. stim_params['angle'] = (dr / (global_params['numDir']-1)) * np.pi
  232. if(global_params['debugger']['set_dir'] >= 0):
  233. stim_params['angle']= global_params['debugger']['set_dir']
  234. #for cell in range(global_params['numCells']):
  235. score_right.append(np.cos(stim_params['angle']))
  236. score_left.append(-np.cos(stim_params['angle']))
  237. h.tstop= NEURON_UpdateSynapses(global_params, stim_params, model)
  239. if(not global_params['debugger']['run_neuron']):
  240. h.tstop= speed + 10
  241. h.run()
  242. GA_RecordingVectors(global_params, stim_params, model, populate= True)
  245. # Compute DSI after all dirs are done - from somatic responses for RGCs and dendritic calcium levels for SACs
  247. for cell in range(global_params['numCells']):
  248. if (global_params['cellType'] in ['RGC', 'L23', 'L5']): # Somatic
  249. dsi_list=np.dot(np.array(score_right), np.array(model.output_params['cell'][cell]['max_soma_single_run'])) / sum( model.output_params['cell'][cell]['max_soma_single_run'])
  250. else: # SAC
  251. dsi_list= np.dot(np.array(score_right), np.array(model.output_params['cell'][cell]['dendrite_vectors']['max_right_single_run'])) / sum( model.output_params['cell'][cell]['dendrite_vectors']['max_right_single_run']) / 2
  252. dsi_list+= np.dot(np.array(score_left), np.array(model.output_params['cell'][cell]['dendrite_vectors']['max_left_single_run'])) / sum( model.output_params['cell'][cell]['dendrite_vectors']['max_left_single_run']) / 2
  253. model.output_params['cell'][cell]['dsi_list'].append(dsi_list)
  255. if global_params['debugger']['print_dsi']: # Report DSI values from all cells
  256. print(np.array(model.output_params['cell'][cell]['max_soma_single_run']), dsi_list)
  258. for cell in range(global_params['numCells']):
  259. model.output_params['cell'][cell]['dsi']=np.mean(model.output_params['cell'][cell]['dsi_list'])
  262. def GA_Start(conn, model, stim_params, global_params):
  263. h('v_init= -60')
  264. h('stdinit()')
  265. NEURON_SetCells(global_params, stim_params, model)
  268. while True:
  269. if conn.poll(): # Check for incoming command
  270. msg = conn.recv()
  271. response = "---"
  272. if isinstance(msg, str):
  273. if msg == "input_params":
  274. response = model.input_params
  275. if msg == 'global_params':
  276. response= global_params
  277. if msg == 'I_syn':
  278. response= len(model.SAC_SAC_synapses)
  279. elif msg == "quit":
  280. #h.quit()
  281. conn.send("end of simulation")
  282. break
  283. elif msg == "show_inputs":
  284. maxx= -10000
  285. minx= 10000
  286. for syn in model.InputE_synapses:
  287. maxx= max(maxx, syn.x)
  288. minx= min(minx, syn.x)
  289. for syn in model.InputE_synapses:
  290. plt.plot(syn.shifted_drive_vector.to_python(), color= ((syn.x - minx) / (maxx - minx), 0, 0))
  291. plt.show()
  292. response= "done plotting"
  293. #break
  294. elif isinstance(msg, dict):
  295. # Apply the passive and active params, compute the synaptic activation and run the simulation
  296. model.input_params = msg
  297. GA_Run(model, stim_params, global_params)
  298. response = model.output_params
  299. conn.send(response)
  301. if __name__ == "__main__":
  303. freeze_support()
  304. start_time = time.time() # ⏱️ Start timer
  305. # Initialize the models
  306. models=[] # Container of the NEURON models
  307. for pop in range(global_params['numPop']):
  308. model = Model()
  309. models.append(model)
  311. sim_procs = []
  312. sim_conns = []
  313. # Initialize the NEURON threads
  314. for pop in range(global_params['numPop']): # Adjust number of NEURON simulations here
  315. if(global_params['debugger']['multithread']):
  316. parent_conn, child_conn = Pipe()
  317. p = Process(target=GA_Start, args=(child_conn, models[pop], stim_params, global_params))
  318. p.start()
  319. sim_procs.append(p)
  320. sim_conns.append(parent_conn)
  321. else: # Single thread
  322. h('load_file("nrngui.hoc")')
  323. NEURON_SetCells(global_params, stim_params, model)
  324. h('load_file("neuron.ses")')
  325. h('v_init= -60')
  328. # Save a copy of the created params
  329. if(global_params['debugger']['multithread']):
  330. for pop,conn in enumerate(sim_conns):
  331. conn.send("input_params")
  332. models[pop].input_params= conn.recv()
  333. sim_conns[0].send('global_params')
  334. global_params= sim_conns[0].recv()
  335. #sim_conns[0].send('I_syn')
  336. #nSynI= sim_conns[0].recv()
  338. if(global_params['numCells'] > 1):
  339. print(f"Number of SAC-SAC synapses - {global_params['numIsyn']} , Number of cells - {global_params['numCells']}")
  341. models[0].output_params['score']= []
  342. # Generation loop
  343. for gen in range(global_params['numGen']): # number of generations
  344. gen_time = time.time()
  346. # Send new input parameters and run the simulations
  347. if(global_params['debugger']['multithread']):
  348. for pop, conn in enumerate(sim_conns):
  349. #print('send', pop, models[pop].input_params['RF_params']['excitation']['center']['peak'])
  350. conn.send(models[pop].input_params)
  352. # Gather values
  353. for pop,conn in enumerate(sim_conns):
  354. models[pop].output_params= conn.recv()
  355. conn.send("input_params")
  356. models[pop].input_params= conn.recv()
  357. #print('back',pop, models[pop].input_params['RF_params']['excitation']['center']['peak'])
  358. else:
  359. for pop in range(global_params['numPop']):
  360. GA_Run(models[pop], stim_params, global_params)
  362. # Find the model with the largest DSI
  363. best_dsi= -1
  364. best_pos= 0
  365. for pop, model in enumerate(models):
  366. if(model.output_params['cell'][0]['dsi'] > best_dsi):
  367. best_dsi= model.output_params['cell'][0]['dsi']
  368. best_pos= pop
  369. if global_params['debugger']['print_dsi']:
  370. print(f"Model={pop}, DSI={model.output_params['cell'][0]['dsi']}. Best pos={best_pos} ({best_dsi})")
  372. print(f"Done generation {gen}, best score= {best_dsi}, time - {(time.time()-gen_time):.4f}")
  373. models[0].output_params['score'].append(best_dsi) # Save progress
  375. #print(f"Gen - {gen}, time - {(time.time()-gen_time):.4f}")
  376. if((gen%(global_params['save_every_gen'])) == (global_params['save_every_gen']-1)):
  377. GA_SaveH5(global_params, models, final= False)
  378. with open(f"params/input_params_{global_params['job_id']}.pkl", "wb") as f:
  379. pickle.dump(models[0].input_params, f)
  381. # Duplicate best model
  382. if gen < global_params['numGen'] - 1:
  383. for pop, model in enumerate(models):
  384. if pop != best_pos:
  385. models[pop] = copy.deepcopy(models[best_pos])
  386. if global_params['debugger']['print_dsi']:
  387. print(f'Copy {best_pos} into {pop}')
  389. # Mutations
  390. if (global_params['debugger']['stop_mutations'] == False):
  391. for pop, model in enumerate(models):
  392. if(pop > 0): # keep the first model intact
  393. NEURON_mutation(global_params, model.input_params)
  394. if global_params['debugger']['print_dsi']:
  395. print(f'Mutate {pop}')
  397. # End generation loop
  398. #models[0].output_params['score']= score # Save progress
  399. if (global_params['debugger']['plot_inputs']):
  400. sim_conns[0].send("show_inputs")
  401. dummy= conn.recv()
  403. # Cleanup
  404. if(global_params['debugger']['multithread']):
  405. for conn in sim_conns:
  406. conn.send("quit")
  407. dummy= conn.recv()
  408. for p in sim_procs:
  409. p.join()
  411. print("All NEURON simulations completed.")
  412. end_time = time.time() # ⏱️ End timer
  413. elapsed_time = end_time - start_time
  416. # Save to HDF5
  417. GA_SaveH5(global_params, models, final= True)
  418. print("Saved H5 File")
  419. with open(f"params/input_params_{global_params['job_id']}.pkl", "wb") as f:
  420. pickle.dump(models[0].input_params, f)
  424. print(f"Execution Time: {(elapsed_time / 60):.2f} minutes")
  426. if (global_params['debugger']['plot_outcome']):
  427. #print("op ",models[0].output_params)
  428. fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(8, 6), height_ratios=[1, 1, 1])
  429. ax3.plot(models[0].output_params['score'], color='black')
  430. for cell in range(global_params['numCells']):
  431. for v in model.output_params['cell'][cell]['somaV_all_angles']:
  432. ax1.plot(v)
  433. if (global_params['cellType'] in ['RGC', 'L23', 'L5']): # Somatic
  434. pass
  436. else:
  437. for ca in model.output_params['cell'][0]['dendrite_vectors']['ca_right_all_angles']:
  438. ax2.plot(ca, color= 'orange')
  440. for ca in model.output_params['cell'][0]['dendrite_vectors']['ca_left_all_angles']:
  441. ax2.plot(ca, color= 'black')
  443. plt.show()
  445. #for cell in range(global_params['numCells']):
  446. if (global_params['debugger']['plot_positions']):
  447. plt.plot(models[0].input_params['cellPos'][:][0],models[0].input_params['cellPos'][:][1])
  448. x_coords, y_coords = zip(*models[0].input_params['cellPos'])
  450. plt.scatter(x_coords, y_coords)
  451. plt.show()

main.py at commit 6534bcd, no license · at the source

Overview

Authors: Alon Poleg-Polsky1
ORCID iDs: Alon Poleg-Polsky
  1. Department of Physiology and Biophysics, and Neuroscience Program, University of Colorado School of Medicine,Aurora, CO USA
Institutions: University of Colorado Anschutz (United States)
Journal: Nature communications, volume 17, issue 1, article 3424
Dates: received 28 March 2025; accepted 24 February 2026; published online 3 March 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41467-026-70288-4 · PMID 41776191 · PMCID PMC13076616 · OpenAlex W7133356062
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism)
Methods: Preprocessing, Evoked potentials, Statistics, fMRI & imaging
Keywords: Learning algorithms, Motion detection, Sensory processing
MeSH: Machine Learning*, Models, Neurological*, Motion Perception*, Animals, Humans, Motion, Retina, Soft Computing, Visual Cortex (* major topic)
Topic: Visual perception and processing mechanisms (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: NIH (R01EY030841, R01EY035293)
Citations: cited by 1 paper (Europe PMC); 95 references in the paper

Abstract

Motion direction detection is a fundamental visual computation that transforms spatial luminance patterns into directionally tuned outputs. Classical models of direction selectivity rely on temporal asymmetry, where motion detection arises through either delayed excitation or inhibition. Here, I used biologically inspired machine learning applied to retinal and cortical circuits to uncover receptive field architectures capable of direction selectivity. These include mechanisms based on asymmetric synaptic properties, spatial receptive field variations, new roles for pre- and postsynaptic inhibition, and previously unrecognized kinetic implementations. Conceptually, these circuit architectures cluster into eight computational primitives underlying motion detection, four of which are previously undescribed. Many of the solutions rival or outperform classical models in both robustness and precision, and several exhibit enhanced noise tolerance. All mechanisms are biologically plausible and correspond to known physiological and anatomical motifs, offering fresh insights into motion processing and illustrating how machine learning can uncover general principles of neural computation.

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

PolegPolskyLab/DS-mechanisms

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 6534bcd01294c027960c5eaf35e71ba4a69d4f68, 14 June 2025
Languages: NEURON (19), Python (4), C (1)
Size: 27 files, 24 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NEURON (21 files), NumPy (4 files), Matplotlib (2 files), h5py (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
25 files
At the source: github.com/PolegPolskyLab/DS-mechanisms

Code availability

Simulation code can be found in the following repository: https://github.com/PolegPolskyLab/DS-mechanisms.

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;
  • 24 scripts, each with its path and the digest of its content;
  • 4 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

Source Data are provided with this paper.

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, 1 author, 3 keywords, 9 MeSH terms, 1 funder, 95 references.

Cite

This paper

Poleg-Polsky, A. (2026). Machine learning discovers numerous new computational principles supporting elementary motion detection. Nature communications, 17(1), 3424. https://doi.org/10.1038/s41467-026-70288-4

BibTeX

@article{polegpolsky2026machine,
author = {Poleg-Polsky, Alon},
title = {{Machine learning discovers numerous new computational principles supporting elementary motion detection}},
journal = {Nature communications},
year = {2026},
month = mar,
volume = {17},
number = {1},
pages = {3424},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-70288-4},
url = {https://doi.org/10.1038/s41467-026-70288-4},
pmid = {41776191},
pmcid = {PMC13076616}
}

RIS

TY - JOUR
AU - Poleg-Polsky, Alon
TI - Machine learning discovers numerous new computational principles supporting elementary motion detection
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/03/03
VL - 17
IS - 1
SP - 3424
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-70288-4
UR - https://doi.org/10.1038/s41467-026-70288-4
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-70288-4",
"type": "article-journal",
"title": "Machine learning discovers numerous new computational principles supporting elementary motion detection",
"container-title": "Nature communications",
"author": [
{
"family": "Poleg-Polsky",
"given": "Alon"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "3424",
"DOI": "10.1038/s41467-026-70288-4",
"PMID": "41776191",
"PMCID": "PMC13076616",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-70288-4",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
3
]
]
}
}

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.7554/elife.108529 [code]
Inhibitory columnar feedback neurons are involved in motion processing in &lt;i&gt;Drosophila&lt;/i&gt;.
Journal: eLife
In common: h5py, Matplotlib, NumPy, 8 references
[2] doi:10.1016/j.celrep.2026.117476 [code]
Retinal waves shape starburst amacrine cell dendrite development through a direction-selective dendritic computation.
Journal: Cell reports
In common: Matplotlib, NumPy, 6 references
[3] doi:10.1126/sciadv.aec3961 [code]
Linking functional and structural dendritic spine remodeling during fear learning and extinction in vivo.
Journal: Science advances
In common: NEURON, Matplotlib, NumPy, 3 references
[4] doi:10.7554/elife.89629 [code]
Active dendrites enable robust spiking computations despite timing jitter.
Journal: eLife
In common: NEURON, Matplotlib, NumPy, 2 references
[5] doi:10.1073/pnas.2533168123 [code]
Dendritic morphology and synaptic nonlinearities enhance functional complexity in human cortical neurons.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: NEURON, h5py, Matplotlib, 1 other tool, 1 reference
[6] doi:10.1126/sciadv.adz4123 [code]
Highly attenuated dendritic propagation of isolated synaptic potentials in vivo.
Journal: Science advances
In common: 4 references
[7] doi:10.1371/journal.pcbi.1013138 [code]
Hierarchical recurrent temporal prediction as a model of the mammalian dorsal visual pathway.
Journal: PLoS computational biology
In common: h5py, Matplotlib, NumPy, 2 references
[8] doi:10.7554/elife.95562 [code]
Spatially targeted inhibitory rhythms differentially affect neuronal integration.
Journal: eLife
In common: h5py, Matplotlib, NumPy, 2 references
[9] doi:10.1371/journal.pcbi.1014283 [code]
Spatial richness of neural magnetic fields.
Journal: PLoS computational biology
In common: NEURON, h5py, Matplotlib, 1 other tool
[10] doi:10.1016/j.isci.2026.115488 [code]
An integrated &lt;i&gt;i&lt;/i&gt; &lt;i&gt;n vitro&lt;/i&gt; platform and biophysical modeling approach for studying synaptic transmission in isolated neuronal pairs.
Journal: iScience
In common: NEURON, h5py, Matplotlib, 1 other tool

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.