OSCR

Centralized brain networks controlling antennal grooming coordination.

Code ↔ Paper

40 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 40 matches · 4 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § Methods › Connectome analysis › Assigning neurons to groups ↔ src/prepare_data/Figure4_graph_tools.py, lines 253–315 · score 0.90 · MNfl, MNnm, T1 leg motor, neck premotor neurons, leg premotor neurons, leg motor neuron
  2. [2] § Results › A computational perturbation screen identifies key neurons for grooming ↔ src/Figure6.ipynb, lines 394–515 · score 0.83 · Global activity, bilateral neural silencing, unilateral neural activation, Neural perturbations, asymmetric JO, aMN4
  3. [3] § Methods › Data analysis › Analysis of perturbation experiments ↔ src/prepare_data/Figure3_prepare_data.py, lines 498–583 · score 0.80 · freely moving body, kinematic variable, head rotation, head fixed, body parts, head roll
  4. [4] § Methods › Connectome analysis › Constructing the antennal grooming network ↔ src/prepare_data/Figure4_generate_grooming_network.py, lines 340–402 · score 0.79 · super_class, FAFB connectome, foundational network, sensory neurons, brain, threshold
  5. [5] § Methods › Data analysis › Analysis of perturbation experiments ↔ src/prepare_data/Figure3_prepare_data.py, lines 352–436 · score 0.75 · freely moving body, pitched antenna, head fixed, amputee, body part, head roll
  6. [6] § Methods › Data processing › 2D & 3D pose estimation ↔ charuco_board/design/checkboard_config.py, the whole file · a weak match · score 0.72 · ChArUco board, OpenCV, bit, squares, dictionary
  7. [7] § Methods › Data processing › 2D & 3D pose estimation ↔ charuco_board/check_charuco.py, the whole file · a weak match · score 0.69 · ChArUco board, OpenCV, reconstruction, Anipose, calibrated
  8. [8] § Results › A computational perturbation screen identifies key neurons for grooming ↔ src/Figure6.ipynb, lines 394–515 · score 0.69 · neural silencing, neural activation, asymmetric JO, aMN4, clusters, activity
  9. [9] § Results › Proprioception does not play a major role in body-part coordination ↔ src/prepare_data/Figure3_prepare_data.py, lines 846–954 · score 0.69 · freely moving body, kinematic variable, head rotations, body part, head fixed, head roll
  10. [10] § Methods › Connectome analysis › Constructing the antennal grooming network ↔ src/common.py, lines 710–730 · score 0.67 · degree_centrality, eigenvector_centrality, NetworkX, scores
  11. [11] § Methods › Connectome analysis › Assigning neurons to groups ↔ src/prepare_data/Figure4_graph_tools.py, lines 253–315 · score 0.66 · neck premotor neurons, leg motor neurons, shared premotor neurons, neck motor neurons, VNC, foreleg
  12. [12] § Results › Body-part coordination enhances sustained foreleg-antennal contact ↔ src/EDFigure4.ipynb, lines 129–186 · score 0.66 · reduced collisions, left tarsus, right tibia, kinematic replay, head pitch, simulation
  13. [13] § Methods › Connectome analysis › Assigning neurons to groups ↔ src/Figure4.ipynb, lines 564–597 · score 0.65 · postsynaptic neurons, presynaptic neurons, leg premotor, modules, sensory, JO
  14. [14] § Methods › Kinematic replay and antennal contact detection ↔ src/EDFigure4.ipynb, lines 266–318 · score 0.65 · zero forces, contact force, collision pair, segments, tarsus, antennae
  15. [15] § Results › Simulating a connectome-derived antennal grooming network ↔ src/EDFigure13.ipynb, lines 50–85 · score 0.65 · unilateral selectivity, right neuron, left neuron, Neural responses, aDNs, aBNs
  16. [16] § Results › A centralized brain network links multiple motor modules ↔ src/EDFigure7.ipynb, lines 45–119 · score 0.64 · parameter sweep, monosynaptically connected, neck motor neurons, grooming neurons, descending, interneurons
  17. [17] § Results › Antennal grooming arises from tripartite coordination ↔ src/Figure1.ipynb, lines 424–503 · score 0.63 · uniR, grooming subtype, bilateral, Unilateral, positioned, behaviors
  18. [18] § Methods › Kinematic replay and antennal contact detection ↔ src/Figure2.ipynb, lines 57–177 · score 0.63 · collision diagrams, collision pair, leg segment, contact, replay, tarsus
  19. [19] § Methods › Connectome analysis › Graph visualizations ↔ src/prepare_data/Figure4_graph_tools.py, lines 38–71 · score 0.63 · source node, target node, NetworkX, graph, edge
  20. [20] § Results › Antennal grooming arises from tripartite coordination ↔ src/Figure1.ipynb, lines 424–503 · score 0.63 · uniR, subtypes, bilateral, unilateral, behavioral, grooming
  21. [21] § Results › A centralized brain network links multiple motor modules ↔ src/prepare_data/Figure4_graph_tools.py, lines 341–393 · score 0.62 · shared premotor neurons, antennal motor neurons, motor modules, synapses, neck, network
  22. [22] § Methods › Data processing › 3D pose alignment & inverse kinematics ↔ kinematics3d/constants.py, the whole file · a weak match · score 0.61 · Thorax Coxa, Tibia Tarsus, Claw, wing, tip
  23. [23] § Results › A centralized brain network links multiple motor modules ↔ src/prepare_data/Figure4_generate_grooming_network.py, lines 340–402 · score 0.61 · parameter sweep, brain connectome, sensory neurons, motor neurons, threshold, network
  24. [24] § Methods › Statistical analysis ↔ src/Figure7.ipynb, lines 73–128 · score 0.60 · Mann Whitney, stimulus transition, windows, median, fly
  25. [25] § Methods › Connectome-constrained neural network modeling › Adjacency matrix preparation ↔ src/prepare_data/Figure5_prepare_data.py, lines 34–47 · score 0.60 · distance matrix, cluster neurons, DBSCAN, algorithm
  26. [26] § Methods › Connectome-constrained neural network modeling › Model parameters and training ↔ src/prepare_data/connectome_utils.py, lines 389–410 · score 0.59 · pre synaptic, synaptic connection, post synaptic, neurotransmitter, neurons
  27. [27] § Methods › Data analysis › Dimensionality reduction using PCA ↔ src/EDFigure2.ipynb, lines 105–175 · score 0.59 · coxa trochanter, Tibia Tarsus joints, overlap, optogenetically, positions, foreleg
  28. [28] § Results › Simulating a connectome-derived antennal grooming network ↔ src/Figure5.ipynb, lines 185–219 · score 0.58 · unilateral selectivity, right neuron, left neuron, aDNs, aBNs, USI
  29. [29] § Results › Coupled circuit motifs enable robust unilateral coordination ↔ src/Figure6.ipynb, lines 779–908 · score 0.58 · neck premotor, leg premotor, shared premotor, DN33, clusters, motifs
  30. [30] § Methods › Data processing › 3D pose alignment & inverse kinematics ↔ src/EDFigure2.ipynb, lines 105–175 · score 0.57 · coxa trochanter, femur tibia, joint, positioning, leg, pose
  31. [31] § Results › Body-part coordination enhances sustained foreleg-antennal contact ↔ src/Figure2.ipynb, lines 225–365 · score 0.56 · Simes Hochberg, Contact duration, head pitch, boxes, segments, tarsus
  32. [32] § Methods › Data analysis › Transitions between behaviors ↔ src/prepare_data/Figure4_graph_tools.py, lines 495–608 · score 0.55 · directed graph, NetworkX, transition, edges, row, node
  33. [33] § Methods › Connectome analysis › Assigning neurons to groups ↔ src/prepare_data/Figure4_graph_tools.py, lines 396–442 · score 0.54 · identify central neurons, NetworkX, motor neurons, layers, synapses, premotor
  34. [34] § Methods › Connectome analysis › Graph visualizations ↔ src/Figure4.ipynb, lines 98–179 · score 0.54 · pre synaptic neuron, post synaptic neuron, node, exported, widths, connectivity
  35. [35] § Methods › Data analysis › Transitions between behaviors ↔ src/EDFigure9.ipynb, lines 52–167 · score 0.54 · directed graph, NetworkX, transition, edges, row, node
  36. [36] § Results › Coupled circuit motifs enable robust unilateral coordination ↔ src/Figure7.ipynb, lines 73–128 · score 0.53 · Mann Whitney, stimulus transition, windows, intervals, medians, Figure 7
  37. [37] § Methods › Kinematic replay and antennal contact detection ↔ src/Figure2.ipynb, lines 57–177 · score 0.53 · kinematic replay, collision pair, simulations, contact, antennal
  38. [38] § Methods › Data processing › 2D & 3D pose estimation ↔ dlc_fxns/06_extract_outlier_refine.py, the whole file · a weak match · score 0.53 · outlier frames, DeepLabCut, amputation, pose
  39. [39] § Methods › Kinematic replay and antennal contact detection ↔ src/common.py, lines 343–407 · score 0.52 · kinematic replay, collision pair, 0–1, simulations, contact, antennal
  40. [40] § Results › Simulating a connectome-derived antennal grooming network ↔ src/prepare_data/EDFigure9_random_graphs.py, lines 1–46 · score 0.52 · random seeds, adjacency matrix, edges, pre, post, neck

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 · 737 lines · 26 KB · Apache-2.0 · 6 matches

  1. """ Graph tools. """
  3. import copy
  4. import itertools
  6. import numpy as np
  7. import pandas as pd
  8. import networkx as nx
  9. import matplotlib.pyplot as plt
  11. import neuprint
  12. from neuprint import Client
  14. import Figure4_neurons as neurons
  16. MY_TOKEN = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6InBnaXplbW96ZGlsQGdtYWlsLmNvbSIsImxldmVsIjoibm9hdXRoIiwiaW1hZ2UtdXJsIjoiaHR0cHM6Ly9saDMuZ29vZ2xldXNlcmNvbnRlbnQuY29tL2EvQUNnOG9jTENyNEoyQWozazFqTjFGTzQtcmpIVnhZU2xGV3Y5NHptSUtndDVicVRuPXM5Ni1jP3N6PTUwP3N6PTUwIiwiZXhwIjoxODkyMTQ5OTA0fQ.1jPbQ350OHMCitI6zQy5SQIBtc6A2hdY5ErwYwqpn-A'
  18. def signal_flow(A):
  19. """
  20. Implementation of the signal flow metric from Varshney et al 2011
  21. Source: A Connectome of an insect brain, Winding, Pedigo et al 2023
  22. """
  23. A = A.copy()
  24. # A = remove_loops(A)
  25. W = (A + A.T) / 2
  27. D = np.diag(np.sum(W, axis=1))
  29. L = D - W
  31. b = np.sum(W * np.sign(A - A.T), axis=1)
  32. L_pinv = np.linalg.pinv(L)
  33. z = L_pinv @ b
  35. return z
  38. def get_all_shortest_paths(
  39. graph, source_nodes, target_nodes, edge_property="syn_count_inv"
  40. ):
  41. """Get all simple paths between source and target nodes"""
  42. all_paths = []
  43. for source_n, target_n in itertools.product(source_nodes, target_nodes):
  44. if not source_n in graph.nodes or not target_n in graph.nodes:
  45. continue
  47. if nx.has_path(graph, source_n, target_n) and source_n != target_n:
  48. # If there is a direct edge, remove it and find the shortest path
  49. edge_list = []
  50. while graph.has_edge(source_n, target_n):
  51. edge_data = graph.get_edge_data(
  52. source_n, target_n
  53. ) # Store the edge data if needed
  54. edge_list.append((source_n, target_n, edge_data))
  55. graph.remove_edge(source_n, target_n)
  57. try:
  58. path = nx.shortest_path(
  59. graph, source=source_n, target=target_n, weight=edge_property
  60. )
  61. except nx.NetworkXNoPath:
  62. path = []
  64. # Add the edge back to the graph
  65. for edge in edge_list:
  66. source_n, target_n, edge_data = edge
  67. graph.add_edge(source_n, target_n, **edge_data)
  69. all_paths.append(path)
  71. return all_paths
  74. def get_all_simple_paths(graph, source_nodes, target_nodes, cutoff=4):
  75. """Get all simple paths between source and target nodes"""
  76. all_paths = []
  77. for source_n, target_n in itertools.product(source_nodes, target_nodes):
  78. if not source_n in graph.nodes or not target_n in graph.nodes:
  79. continue
  80. if nx.has_path(graph, source_n, target_n):
  81. all_paths.extend(
  82. [
  83. p
  84. for p in nx.all_simple_paths(
  85. graph, source_n, target_n, cutoff=cutoff
  86. )
  87. ]
  88. )
  89. return all_paths
  92. def threshold_prune_paths(
  93. graph,
  94. paths,
  95. threshold=0.05,
  96. edge_property="syn_count_perc",
  97. exclude_nodes=None,
  98. ):
  99. """Thresholds the paths based on the threshold value"""
  100. thresholded_paths = [
  101. p
  102. for p in paths
  103. if (len(p) > 1)
  104. and (
  105. nx.path_weight(graph, path=list(p), weight=edge_property) / (len(p) - 1)
  106. >= threshold
  107. )
  108. ]
  109. # we prune the paths that include specific nodes
  110. if exclude_nodes is None:
  111. return thresholded_paths
  113. return [p for p in thresholded_paths if not set(p).intersection(set(exclude_nodes))]
  116. def get_adj_matrix_from_conn(
  117. connectivity_df,
  118. neuron_groups,
  119. ):
  120. """Get the adjacency matrix from the connectivity dataframe between neuronal groups."""
  121. adjacency_matrix_perc = np.zeros((len(neuron_groups), len(neuron_groups)))
  122. adjacency_matrix_syn = np.zeros((len(neuron_groups), len(neuron_groups)))
  124. for i, (name_pre, nodes_pre) in enumerate(neuron_groups.items()):
  125. for j, (name_post, nodes_post) in enumerate(neuron_groups.items()):
  127. number_of_synapses_total = (
  128. connectivity_df[connectivity_df.pre_root_id.isin(nodes_pre)]
  129. .syn_count.abs()
  130. .sum()
  131. )
  132. number_of_synapses = (
  133. connectivity_df[
  134. (connectivity_df.pre_root_id.isin(nodes_pre))
  135. & (connectivity_df.post_root_id.isin(nodes_post))
  136. ]
  137. .syn_count.abs()
  138. .sum()
  139. )
  140. w_perc = (number_of_synapses / (number_of_synapses_total + 1e-5)) * 100
  142. adjacency_matrix_perc[i, j] = w_perc
  143. adjacency_matrix_syn[i, j] = number_of_synapses / (
  144. len(nodes_pre) * len(nodes_post)
  145. )
  147. return {
  148. "perc": adjacency_matrix_perc,
  149. "syn": adjacency_matrix_syn,
  150. }
  153. def get_upstream(connectivity_df, neuron_ids):
  154. """Gets the upstream partners of a list of neurons"""
  155. neuron_ids = list(neuron_ids) if not isinstance(neuron_ids, list) else neuron_ids
  156. return connectivity_df[
  157. connectivity_df.post_root_id.isin(neuron_ids)
  158. ].pre_root_id.unique()
  161. def threshold_connection(
  162. connectivity_df,
  163. pre_root_ids,
  164. post_root_ids,
  165. threshold_col_name="syn_count_perc",
  166. threshold=0.05,
  167. # verbose=False,
  168. ):
  169. """Thresholds the connections based on the threshold value"""
  170. pre_root_ids = (
  171. list(pre_root_ids) if not isinstance(pre_root_ids, list) else pre_root_ids
  172. )
  173. post_root_ids = (
  174. list(post_root_ids) if not isinstance(post_root_ids, list) else post_root_ids
  175. )
  176. thresholded_neurons = {}
  177. # for each pre root id, look at the synapse percentage
  178. for pre_id in pre_root_ids:
  179. sum_perc = connectivity_df[
  180. (connectivity_df.pre_root_id == pre_id)
  181. & (connectivity_df.post_root_id.isin(post_root_ids))
  182. ][threshold_col_name].sum()
  183. # if sum percentage is more than the threshold of the total synapses onto motor neurons
  184. if sum_perc >= threshold:
  185. thresholded_neurons[pre_id] = sum_perc
  186. # if verbose:
  187. # print(pre_id, neurons.ALL_NEURONS_REV_JO[pre_id]["name"], sum_perc)
  189. return thresholded_neurons
  192. def shuffle_postsyn_conn(adj_matrix, random_seed=0):
  193. """Shuffle the postsynaptic connection.
  194. This will ensure that a neuron will have
  195. the same number of synapses.
  196. """
  197. np.random.seed(random_seed)
  198. shuffled_adj = np.zeros_like(adj_matrix)
  199. for row in range(adj_matrix.shape[0]):
  200. shuffled_adj[row, :] = np.random.choice(
  201. adj_matrix[row, :], size=adj_matrix.shape[1], replace=False
  202. )
  204. return shuffled_adj
  207. def make_a_random_graph(
  208. original_connectivity,
  209. motor_neuron_ids,
  210. seed=1,
  211. ):
  212. """Randomize the connections in a graph."""
  213. np.random.seed(seed)
  215. all_segment_ids = set(original_connectivity.pre_root_id.tolist()).union(
  216. set(original_connectivity.post_root_id.tolist())
  217. )
  218. all_segment_ids_wo_mns = all_segment_ids.difference(set(motor_neuron_ids))
  219. random_conn = copy.deepcopy(original_connectivity)
  221. random_conn["pre_root_id"] = np.random.choice(
  222. list(all_segment_ids_wo_mns), len(random_conn)
  223. )
  224. random_conn["post_root_id"] = np.random.choice(
  225. list(all_segment_ids), len(random_conn)
  226. )
  227. random_conn["syn_count"] = np.random.permutation(random_conn["syn_count"].values)
  229. random_conn["total_synapses"] = random_conn.groupby("pre_root_id")[
  230. "syn_count"
  231. ].transform("sum")
  232. #  Normalize syn_count by dividing it with total_synapses
  233. random_conn["syn_count_perc"] = (
  234. random_conn["syn_count"] / random_conn["total_synapses"]
  235. )
  236. random_conn["syn_count_inv"] = 1 / random_conn["syn_count"].values
  238. return random_conn
  241. def get_premotor_neurons(connectivity_df, motor_neuron_ids, threshold=0.05):
  242. """Get the premotor neurons in the brain dataset, defined by a connectivity threshold."""
  243. mn_upstream = get_upstream(connectivity_df, motor_neuron_ids)
  244. mn_ups_percentage = threshold_connection(
  245. connectivity_df,
  246. mn_upstream,
  247. motor_neuron_ids,
  248. threshold=0.05,
  249. )
  250. return mn_ups_percentage
  253. def get_prem_neurons_vnc():
  254. """Get the premotor neurons in the VNC, returns three dataframes: connectivity of neck, foreleg, and shared premotor neurons with their respective motor neurons."""
  256. c = Client("neuprint.janelia.org", dataset="manc:v1.2.1", token=MY_TOKEN)
  257. c.fetch_version()
  258. # Get the leg motor neurons
  259. neuron_df_npt1_left, _ = neuprint.fetch_neurons(
  260. neuprint.NeuronCriteria(outputRois=["LegNp(T1)(L)"])
  261. )
  263. neuron_df_npt1_right, _ = neuprint.fetch_neurons(
  264. neuprint.NeuronCriteria(outputRois=["LegNp(T1)(R)"])
  265. )
  267. # Concat the two dfs
  268. neuron_df_npt1 = pd.concat(
  269. [neuron_df_npt1_left, neuron_df_npt1_right], axis=0
  270. ).dropna(subset=["instance", "type"])
  272. # Search for the motor neurons
  273. t1_leg_mn_df = neuron_df_npt1[neuron_df_npt1.instance.str.contains("MNfl")]
  275. # Find the leg premotor neurons
  276. # Example: Fetch all upstream connections TO a set of neurons
  277. leg_mns = t1_leg_mn_df.bodyId.values
  278. leg_prem_df, leg_prem_conn_df = neuprint.fetch_adjacencies(
  279. sources=None, targets=leg_mns, min_total_weight=10
  280. )
  281. # drop if the bodyId_pre is in the leg motor neurons
  282. leg_prem_conn_df = leg_prem_conn_df[~leg_prem_conn_df.bodyId_pre.isin(leg_mns)]
  283. leg_prem_conn_clean_df = (
  284. leg_prem_conn_df.groupby(["bodyId_pre", "bodyId_post"]).sum().reset_index()
  285. )
  286. # Get the neck motor neurons
  287. neuron_df, _ = neuprint.fetch_neurons(neuprint.NeuronCriteria())
  288. neuron_df = neuron_df.dropna(subset=["instance", "type"])
  289. # search for the neck motor neurons
  290. neck_mn_df = neuron_df[neuron_df.instance.str.contains("MNnm")]
  292. # Get the neck premotor neurons
  293. neck_mns = neck_mn_df.bodyId.values
  294. neck_prem_df, neck_prem_conn_df = neuprint.fetch_adjacencies(
  295. sources=None, targets=neck_mns, min_total_weight=10
  296. )
  298. neck_prem_conn_df = neck_prem_conn_df[~neck_prem_conn_df.bodyId_pre.isin(neck_mns)]
  299. neck_prem_conn_clean_df = (
  300. neck_prem_conn_df.groupby(["bodyId_pre", "bodyId_post"]).sum().reset_index()
  301. )
  302. neck_prem_neurons = neck_prem_conn_clean_df.bodyId_pre.unique()
  303. neck_prem_df = neuron_df[neuron_df.bodyId.isin(neck_prem_neurons)]
  305. leg_prem_neurons = leg_prem_conn_clean_df.bodyId_pre.unique()
  306. leg_prem_df = neuron_df[neuron_df.bodyId.isin(leg_prem_neurons)]
  308. both_prem_neurons = np.intersect1d(leg_prem_neurons, neck_prem_neurons)
  309. common_prem_df = neuron_df[neuron_df.bodyId.isin(both_prem_neurons)]
  311. print(
  312. f"Neurons ({len(both_prem_neurons)}) projecting onto leg and neck motor neurons in the VNC are: {both_prem_neurons}"
  313. )
  315. return neck_prem_df, leg_prem_df, common_prem_df
  318. def update_motor_modules(
  319. motor_module_neurons, anten_prem_set, neck_prem_set, leg_prem_set
  320. ):
  321. # Shared prem neurons: those at the intersection of at least two premotor neuron types
  322. neck_anten_leg_prem = neck_prem_set & anten_prem_set & leg_prem_set
  323. neck_anten_prem = neck_prem_set & anten_prem_set - neck_anten_leg_prem
  324. neck_leg_prem = neck_prem_set & leg_prem_set - neck_anten_leg_prem
  325. anten_leg_prem = anten_prem_set & leg_prem_set - neck_anten_leg_prem
  327. shared_prem = neck_anten_leg_prem.union(
  328. neck_anten_prem, neck_leg_prem, anten_leg_prem
  329. )
  330. all_prem_neurons = neck_prem_set.union(anten_prem_set, leg_prem_set)
  332. motor_module_neurons["leg_prem"] = list(leg_prem_set - shared_prem)
  333. motor_module_neurons["neck_prem"] = list(neck_prem_set - shared_prem)
  334. motor_module_neurons["anten_prem"] = list(anten_prem_set - shared_prem)
  335. motor_module_neurons["shared_prem"] = list(shared_prem)
  336. motor_module_neurons["all_prem"] = list(all_prem_neurons)
  338. return motor_module_neurons
  341. def get_panel_m(
  342. grooming_network, motor_module_neurons, shared_prem, anten_prem_set, neck_prem_set
  343. ):
  344. # Look at how much of information to MNs come from shared vs. other prem neurons
  345. # total number of synapses onto neck mns
  346. neck_mns_upstream_synapses = grooming_network[
  347. grooming_network.post_root_id.isin(motor_module_neurons["neck_mn"])
  348. ].syn_count.sum()
  349. # number of synapses from shared prem onto neck mns
  350. neck_mns_shared_prem_input = grooming_network[
  351. (grooming_network.post_root_id.isin(motor_module_neurons["neck_mn"]))
  352. & (grooming_network.pre_root_id.isin(shared_prem))
  353. ].syn_count.sum()
  354. # number of synapses from ind. prem onto neck mns
  355. neck_mns_ind_input = grooming_network[
  356. (grooming_network.post_root_id.isin(motor_module_neurons["neck_mn"]))
  357. & (grooming_network.pre_root_id.isin(neck_prem_set - shared_prem))
  358. ].syn_count.sum()
  360. neck_input_percen = {
  361. "shared": 100 * neck_mns_shared_prem_input / neck_mns_upstream_synapses,
  362. "ind": 100 * neck_mns_ind_input / neck_mns_upstream_synapses,
  363. }
  365. print(
  366. f"""Neck motor neurons receive {neck_input_percen["shared"]:.2f}% of their input from shared premotor neurons"""
  367. )
  369. # Same for the antennal motor neurons
  370. # total number of synapses onto anten mns
  371. anten_mns_upstream_synapses = grooming_network[
  372. grooming_network.post_root_id.isin(motor_module_neurons["anten_mn"])
  373. ].syn_count.sum()
  374. # number of synapses from shared prem onto anten mns
  375. anten_mns_shared_prem_input = grooming_network[
  376. (grooming_network.post_root_id.isin(motor_module_neurons["anten_mn"]))
  377. & (grooming_network.pre_root_id.isin(shared_prem))
  378. ].syn_count.sum()
  379. # number of synapses from ind prem onto anten mns
  380. anten_mns_ind_input = grooming_network[
  381. (grooming_network.post_root_id.isin(motor_module_neurons["anten_mn"]))
  382. & (grooming_network.pre_root_id.isin(anten_prem_set - shared_prem))
  383. ].syn_count.sum()
  385. anten_input_percen = {
  386. "shared": 100 * anten_mns_shared_prem_input / anten_mns_upstream_synapses,
  387. "ind": 100 * anten_mns_ind_input / anten_mns_upstream_synapses,
  388. }
  390. print(
  391. f"""Antennal motor neurons receive {anten_input_percen["shared"]:.2f}% of their input from shared premotor neurons"""
  392. )
  393. return neck_input_percen, anten_input_percen
  396. def identify_central_neurons(grooming_network, motor_module_neurons):
  397. """To identify central neurons, we look at all simple paths from the JOF to the premotor/motor neurons and take those with a connection strength more than a threshold."""
  399. graph_table = nx.from_pandas_edgelist(
  400. grooming_network,
  401. source="pre_root_id",
  402. target="post_root_id",
  403. edge_attr=["syn_count", "syn_count_perc"],
  404. create_using=nx.DiGraph(),
  405. )
  407. cutoff = 4 # based on the layer algorithm max depth
  408. threshold = 0.05 # average synapse count percentage
  410. jof2prem_simple_paths = get_all_simple_paths(
  411. graph_table,
  412. # From
  413. motor_module_neurons["jo_f"],
  414. # To
  415. motor_module_neurons["all_prem"]
  416. + motor_module_neurons["neck_mn"]
  417. + motor_module_neurons["anten_mn"],
  418. cutoff=cutoff,
  419. )
  420. # Prune those with low connection strength
  421. jof2prem_simple_paths_pruned = threshold_prune_paths(
  422. graph_table,
  423. jof2prem_simple_paths,
  424. threshold=threshold,
  425. edge_property="syn_count_perc",
  426. exclude_nodes=motor_module_neurons["jo_e"]
  427. + motor_module_neurons["jo_c"]
  428. + motor_module_neurons["bm_ant"],
  429. )
  430. # Exclude sensory and motor module neurons
  431. central_neurons = set(
  432. itertools.chain.from_iterable(jof2prem_simple_paths_pruned)
  433. ).difference(
  434. set(
  435. motor_module_neurons["jo_f"]
  436. + motor_module_neurons["all_prem"]
  437. + motor_module_neurons["neck_mn"]
  438. + motor_module_neurons["anten_mn"]
  439. )
  440. )
  442. return list(central_neurons)
  445. def get_conn_between_groups(grooming_network, motor_module_neurons):
  446. """Calculate the connectivity percentage between neuron groups."""
  447. input_dictionary = {
  448. "sensory": motor_module_neurons["jo_f"],
  449. "central": motor_module_neurons["central"],
  450. "anten prem": motor_module_neurons["anten_prem"],
  451. "neck prem": motor_module_neurons["neck_prem"],
  452. "leg prem": motor_module_neurons["leg_prem"],
  453. "shared prem": motor_module_neurons["shared_prem"],
  454. }
  456. prem_mn_dictionary = {
  457. "central": motor_module_neurons["central"],
  458. "anten prem": motor_module_neurons["anten_prem"],
  459. "neck prem": motor_module_neurons["neck_prem"],
  460. "leg prem": motor_module_neurons["leg_prem"],
  461. "shared prem": motor_module_neurons["shared_prem"],
  462. "anten mn": motor_module_neurons["anten_mn"],
  463. "neck mn": motor_module_neurons["neck_mn"],
  464. }
  466. input_central_to_prem_array = np.zeros(
  467. (len(input_dictionary) + 1, len(prem_mn_dictionary))
  468. )
  469. # For each premotor neuron type, get the percentage of synapses going to each premotor neuron type
  470. input_central_to_prem_perc = {}
  471. for j, to_prem_type in enumerate(prem_mn_dictionary):
  472. total_synapses = grooming_network[
  473. grooming_network.post_root_id.isin(prem_mn_dictionary[to_prem_type])
  474. ].syn_count.sum()
  475. for i, from_prem_type in enumerate(input_dictionary):
  476. btw_synapses = grooming_network[
  477. (grooming_network.pre_root_id.isin(input_dictionary[from_prem_type]))
  478. & (grooming_network.post_root_id.isin(prem_mn_dictionary[to_prem_type]))
  479. ].syn_count.sum()
  481. # percentage
  482. if total_synapses == 0:
  483. perc = 0
  484. else:
  485. perc = 100 * btw_synapses / total_synapses
  487. # prem_to_prem_perc[(from_prem_type, to_prem_type)] = perc
  488. input_central_to_prem_array[i, j] = perc
  490. # Other
  491. input_central_to_prem_array[-1, :] = 100 - input_central_to_prem_array.sum(axis=0)
  492. return input_central_to_prem_array
  495. def draw_graph(
  496. adjacency_matrix,
  497. neuron_group_names_pre,
  498. neuron_group_names_post,
  499. pos_custom,
  500. node_colors,
  501. title="",
  502. fig_name=None,
  503. edge_label=False,
  504. normalize_edge_weight=False,
  505. threshold=0,
  506. connectionstyle="arc3,rad=0.1",
  507. export_path=None,
  508. ):
  510. # Plot a graph from the adjacency matrix
  511. neuron_names_pre = [name.replace("_", " ") for name in neuron_group_names_pre]
  512. neuron_names_post = [name.replace("_", " ") for name in neuron_group_names_post]
  513. neuron_names = np.unique(neuron_names_pre + neuron_names_post)
  515. fig, ax = plt.subplots(figsize=(2.4, 2.8), dpi=300)
  516. edge_color = []
  517. edge_weight = []
  518. edges = []
  520. # create directed graph from transition dataframe
  521. G = nx.DiGraph()
  523. for neuron in neuron_names:
  524. G.add_node(neuron)
  526. for row in range(adjacency_matrix.shape[0]):
  527. for column in range(adjacency_matrix.shape[1]):
  528. if np.abs(adjacency_matrix[row, column]) > threshold:
  529. # print(
  530. # f"{neuron_names_pre[row]} -> {neuron_names_post[column]}: {adjacency_matrix[row, column]}"
  531. # )
  532. G.add_edge(
  533. neuron_names_pre[row],
  534. neuron_names_post[column],
  535. weight=np.abs(adjacency_matrix[row, column]),
  536. )
  538. edge_color.append(
  539. "darkblue" if adjacency_matrix[row, column] < 0 else "darkred"
  540. )
  541. edges.append((neuron_names_pre[row], neuron_names_post[column]))
  542. edge_weight.append(adjacency_matrix[row, column])
  544. edge_weight = np.array(edge_weight)
  545. # print(edge_weight.min(), edge_weight.max())
  546. if normalize_edge_weight:
  547. edge_weight -= edge_weight.min() - 0.2
  548. edge_weight /= edge_weight.max() - edge_weight.min() - 0.2
  549. edge_weight *= 4.5
  551. # create node and edge labels
  552. node_labels = {
  553. node: node.replace(" ", "\n").replace("OTHER", "").replace("NEURONS", "")
  554. for node in G.nodes()
  555. }
  556. edge_labels = {(u, v): round(d["weight"], 1) for u, v, d in G.edges(data=True)}
  558. # create graph layout and draw nodes, edges, and labels
  559. pos = pos_custom
  561. node_size = 300
  562. nx.draw_networkx_nodes(
  563. G,
  564. pos,
  565. nodelist=neuron_names,
  566. node_size=node_size,
  567. node_shape="s",
  568. node_color=[node_colors[name] for name in G.nodes()],
  569. alpha=1,
  570. edgecolors="black",
  571. )
  572. # print(G.edges())
  573. nx.draw_networkx_edges(
  574. G,
  575. pos,
  576. # node_size=node_size,
  577. edgelist=edges,
  578. width=edge_weight,
  579. arrows=True,
  580. edge_color="black", # edge_color,
  581. connectionstyle=connectionstyle,
  582. alpha=1,
  583. )
  584. nx.draw_networkx_labels(G, pos, labels=node_labels, font_size=5)
  586. if edge_label:
  587. nx.draw_networkx_edge_labels(
  588. G,
  589. pos,
  590. edge_labels=edge_labels,
  591. font_size=3,
  592. rotate=False,
  593. label_pos=0.35,
  594. )
  596. # display graph
  597. plt.axis("off")
  598. ax.margins(0.1)
  599. ax.set_title(title)
  601. if fig_name is not None and export_path is not None:
  602. fig.savefig(
  603. export_path / f"{fig_name}.png", bbox_inches="tight", facecolor="white"
  604. )
  606. # plt.show()
  608. return G, edge_weight
  611. def order_signal_flow(grooming_network):
  612. """Takes the connectivity table of a network, and orders nodes based on their signal flow score (i.e., input to output)."""
  613. graph_table = nx.from_pandas_edgelist(
  614. grooming_network,
  615. source="pre_root_id",
  616. target="post_root_id",
  617. edge_attr=["syn_count", "syn_count_perc"],
  618. create_using=nx.DiGraph(),
  619. )
  620. # make the adj matrix
  621. adj_matrix_unsigned = nx.to_numpy_array(graph_table, weight=None)
  623. # apply the signal flow algorithm
  624. z = signal_flow(adj_matrix_unsigned)
  626. sort_inds = np.argsort(z)[::-1]
  627. adj_sorted_unsigned = adj_matrix_unsigned[np.ix_(sort_inds, sort_inds)]
  629. # get list of node names
  630. nodes = np.array(list(graph_table.nodes()))[sort_inds]
  632. # sort z too
  633. z_sorted = z[sort_inds]
  635. return adj_sorted_unsigned, nodes, z_sorted
  638. def layer_neurons(nodes, signal_flow_score, no_layers=10):
  639. """Divide the neurons into layers based on their signal flow score."""
  640. layer_bounds = np.linspace(
  641. signal_flow_score.max(), signal_flow_score.min(), no_layers
  642. )
  643. layer_neurons = {}
  645. for layer_no in range(len(layer_bounds) - 1):
  646. layer_neurons[layer_no + 1] = nodes[
  647. np.logical_and(
  648. layer_bounds[layer_no] >= signal_flow_score,
  649. signal_flow_score >= layer_bounds[layer_no + 1],
  650. )
  651. ]
  653. return layer_neurons, layer_bounds
  656. def get_connectivity_between_layers(layer_neurons, grooming_network):
  657. """ Computes the number of synapses between layers. """
  658. layers = list(layer_neurons.keys())
  659. # connectivity between the layers
  660. layer_by_layer = np.zeros((len(layers), len(layers)))
  661. layer_by_layer_inh = np.zeros((len(layers), len(layers)))
  662. layer_by_layer_exc = np.zeros((len(layers), len(layers)))
  664. for layer1 in sorted(layers):
  665. layer1_neurons = layer_neurons[layer1]
  666. for layer2 in sorted(layers):
  667. layer2_neurons = layer_neurons[layer2]
  668. synapses = grooming_network[
  669. grooming_network.pre_root_id.isin(layer1_neurons)
  670. & grooming_network.post_root_id.isin(layer2_neurons)
  671. ]
  673. synapses_inh = synapses[synapses.nt_type.isin(["GABA", "GLUT"])].syn_count.sum()
  674. synapses_exc = synapses[
  675. synapses.nt_type.isin(["ACH", "SER", "DA", "OCT"])
  676. ].syn_count.sum()
  678. synapses_total = synapses.syn_count.sum()
  679. assert synapses_total == synapses_inh + synapses_exc
  681. layer_by_layer[layer1 - 1, layer2 - 1] = synapses_total
  682. layer_by_layer_inh[layer1 - 1, layer2 - 1] = synapses_inh
  683. layer_by_layer_exc[layer1 - 1, layer2 - 1] = synapses_exc
  685. return layer_by_layer, layer_by_layer_inh, layer_by_layer_exc
  688. def classify_central_neurons(grooming_network, neuron_groups):
  689. """ Classify central neurons based on their projections onto premotor neurons."""
  690. central_neurons = neuron_groups["central"]
  691. shared_prem = neuron_groups["shared_prem"]
  692. neck_prem = neuron_groups["neck_prem"]
  693. anten_prem = neuron_groups["anten_prem"]
  694. leg_prem = neuron_groups["leg_prem"]
  696. # neck upstream and central
  697. shared_prem_upstream = set(grooming_network[
  698. grooming_network.pre_root_id.isin(central_neurons) &
  699. grooming_network.post_root_id.isin(shared_prem)
  700. ].pre_root_id.unique())
  702. neck_prem_upstream = set(grooming_network[
  703. grooming_network.pre_root_id.isin(central_neurons) &
  704. grooming_network.post_root_id.isin(neck_prem)
  705. ].pre_root_id.unique()) - shared_prem_upstream
  707. anten_prem_upstream = set(grooming_network[
  708. grooming_network.pre_root_id.isin(central_neurons) &
  709. grooming_network.post_root_id.isin(anten_prem)
  710. ].pre_root_id.unique()) - shared_prem_upstream
  712. leg_prem_upstream = set(grooming_network[
  713. grooming_network.pre_root_id.isin(central_neurons) &
  714. grooming_network.post_root_id.isin(leg_prem)
  715. ].pre_root_id.unique()) - shared_prem_upstream
  717. central_array_projection = np.zeros((len(central_neurons), 5))
  719. for central_id, central_neuron in enumerate(central_neurons):
  720. if central_neuron in anten_prem_upstream:
  721. central_array_projection[central_id, 0] = 1
  722. if central_neuron in neck_prem_upstream:
  723. central_array_projection[central_id, 1] = 1
  724. if central_neuron in leg_prem_upstream:
  725. central_array_projection[central_id, 2] = 1
  726. if central_neuron in shared_prem_upstream:
  727. central_array_projection[central_id, 3] = 1
  728. # if not in any premotor neuron
  729. if (
  730. central_neuron not in shared_prem_upstream
  731. and central_neuron not in neck_prem_upstream
  732. and central_neuron not in anten_prem_upstream
  733. and central_neuron not in leg_prem_upstream
  734. ):
  735. central_array_projection[central_id, 4] = 1
  737. return central_array_projection

Figure4_graph_tools.py at commit 65787ac, under Apache-2.0 · at the source

Overview

Authors: Pembe Gizem Özdil1,2,3, Jonathan Arreguit2, Clara Scherrer1, Femke Hurtak1, Auke Ijspeert2, Pavan Ramdya1
ORCID iDs: Pembe Gizem Özdil, Jonathan Arreguit, Femke Hurtak, Auke Ijspeert, Pavan Ramdya
  1. Neuroengineering Laboratory, Brain Mind Institute & Interfaculty Institute of Bioengineering, EPFL, Lausanne, Switzerland
  2. Biorobotics Laboratory, Institute of Bioengineering, EPFL, Lausanne, Switzerland
  3. Kempner Institute, Harvard University, Allston, MA USA
Institutions: Harvard University (United States); École Polytechnique Fédérale de Lausanne (Switzerland)
Journal: Nature communications, volume 17, issue 1, article 5617
Dates: received 27 January 2025; accepted 7 April 2026; published online 23 April 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-72152-x · PMID 42026054 · PMCID PMC13314972 · OpenAlex W7155399663
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: computational modeling (no new data) (modality), drosophila (organism), systems (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, Preprocessing, Evoked potentials, Connectivity, Machine learning, fMRI & imaging
Keywords: Motor control, Network models, Sensorimotor processing
MeSH: Arthropod Antennae*, Brain*, Drosophila melanogaster*, Grooming*, Nerve Net*, Animals, Biomechanical Phenomena, Connectome, Interneurons, Locomotion (* major topic)
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: NIH HHS (P40 OD018537); Swiss National Science Foundation (181239, 175667); European Research Council (951477)
Citations: cited by 1 paper (Europe PMC); 119 references in the paper

Abstract

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

Repositories

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

gizemozd/anipose

License: BSD-2-Clause
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: eb23f2ddde8d50b030c2195f475ab8aef370bfd5, 16 July 2022
Languages: Python (24), JavaScript (1), Shell (1)
Size: 77 files, 26 scripts
Software Heritage: archived
Found in: the text, “2D & 3D pose estimation”
Holds: README, license file, environment (setup.py, docs/sphinx/requirements.txt), documentation
Not found: CITATION.cff, tests, continuous integration
Tools: NumPy (19 files), pandas (18 files), OpenCV (15 files), SciPy (10 files), DeepLabCut (2 files), Matplotlib (2 files), scikit-learn (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
28 files
At the source: github.com/gizemozd/anipose/tree/master

NeLy-EPFL/kinematics3d

License: Apache-2.0
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 7b2621bf9c677266b68d755822356ffe1868524d, 16 July 2025
Languages: Python (25), Shell (1)
Size: 51 files, 26 scripts
Software Heritage: not archived
Found in: the text, “2D & 3D pose estimation”
Holds: README, license file, environment (setup.py)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: DeepLabCut (10 files), TensorFlow (6 files), Matplotlib (4 files), NumPy (4 files), OpenCV (3 files), pandas (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
28 files
At the source: github.com/NeLy-EPFL/kinematics3d

NeLy-EPFL/antennal-grooming

License: Apache-2.0
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 65787ac7fa35aa5520addb6d3e4ac27887bbaf60, 4 May 2026
Languages: Jupyter (18), Python (11), Shell (2)
Size: 57 files, 31 scripts
Software Heritage: archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt), 18 notebooks
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (27 files), pandas (23 files), Matplotlib (22 files), seaborn (15 files), NetworkX (12 files), SciPy (11 files), scikit-learn (4 files), h5py (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
33 files
At the source: github.com/NeLy-EPFL/antennal-grooming

Code availability statement

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

Read it in the paper: doi.org/10.1038/s41467-026-72152-x.

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:

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

Datasets cited

Data availability statement

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

Read it in the paper: doi.org/10.1038/s41467-026-72152-x.

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

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 3 keywords, 10 MeSH terms, 3 funders, 99 references.

Cite

This paper

Özdil, P. G., Arreguit, J., Scherrer, C., Hurtak, F., Ijspeert, A., & Ramdya, P. (2026). Centralized brain networks controlling antennal grooming coordination. Nature communications, 17(1), 5617. https://doi.org/10.1038/s41467-026-72152-x

BibTeX

@article{ozdil2026centralized,
author = {Özdil, Pembe Gizem and Arreguit, Jonathan and Scherrer, Clara and Hurtak, Femke and Ijspeert, Auke and Ramdya, Pavan},
title = {{Centralized brain networks controlling antennal grooming coordination}},
journal = {Nature communications},
year = {2026},
month = apr,
volume = {17},
number = {1},
pages = {5617},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-72152-x},
url = {https://doi.org/10.1038/s41467-026-72152-x},
pmid = {42026054},
pmcid = {PMC13314972}
}

RIS

TY - JOUR
AU - Özdil, Pembe Gizem
AU - Arreguit, Jonathan
AU - Scherrer, Clara
AU - Hurtak, Femke
AU - Ijspeert, Auke
AU - Ramdya, Pavan
TI - Centralized brain networks controlling antennal grooming coordination
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/04/23
VL - 17
IS - 1
SP - 5617
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-72152-x
UR - https://doi.org/10.1038/s41467-026-72152-x
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-72152-x",
"type": "article-journal",
"title": "Centralized brain networks controlling antennal grooming coordination",
"container-title": "Nature communications",
"author": [
{
"family": "Özdil",
"given": "Pembe Gizem"
},
{
"family": "Arreguit",
"given": "Jonathan"
},
{
"family": "Scherrer",
"given": "Clara"
},
{
"family": "Hurtak",
"given": "Femke"
},
{
"family": "Ijspeert",
"given": "Auke"
},
{
"family": "Ramdya",
"given": "Pavan"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "5617",
"DOI": "10.1038/s41467-026-72152-x",
"PMID": "42026054",
"PMCID": "PMC13314972",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-72152-x",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
23
]
]
}
}

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

Similar papers

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

[1] doi:10.1038/s41586-026-10735-w [code]
Distributed control circuits across a brain-and-cord connectome.
Journal: Nature
In common: NetworkX, seaborn, scikit-learn, 4 other tools, drosophila, 26 references
[2] doi:10.7554/elife.96084 [code]
Organization of circuits linking descending input to motor output in the &lt;i&gt;Drosophila&lt;/i&gt; Male Adult Nerve Cord connectome.
Journal: eLife
In common: drosophila, systems, 19 references
[3] doi:10.3389/fnsys.2026.1822122 [code]
Convergence-divergence circuits for multimodal integration of innate and learned opponent valences.
Journal: Frontiers in systems neuroscience
In common: TensorFlow, NetworkX, h5py, 6 other tools, systems, 10 references
[4] doi:10.7554/elife.107867 [code]
Peripheral anatomy and central connectivity of proprioceptive sensory neurons in the &lt;i&gt;Drosophila&lt;/i&gt; wing.
Journal: eLife
In common: seaborn, scikit-learn, pandas, 3 other tools, drosophila, 9 references
[5] doi:10.1371/journal.pbio.3003959 [code]
Recurrent synapses between CO2-sensitive olfactory sensory neurons enable robust CO2 detection in Aedes aegypti mosquitoes.
Journal: PLoS biology
In common: statsmodels, seaborn, scikit-learn, 4 other tools, drosophila, 8 references
[6] doi:10.1038/s41467-026-72057-9 [code]
Sex-specific behavioral feedback modulates sensorimotor processing and drives flexible social behavior.
Journal: Nature communications
In common: TensorFlow, OpenCV, h5py, 7 other tools, drosophila, systems, 4 references
[7] doi:10.1016/j.isci.2026.117359 [code]
Connectomic mapping of pharyngeal and gut sensory circuits in adult &lt;i&gt;Drosophila&lt;/i&gt;.
Journal: iScience
In common: statsmodels, seaborn, pandas, 3 other tools, drosophila, systems, 7 references
[8] doi:10.1038/s41593-026-02232-0 [code]
Entorhinal cortex represents task-relevant remote locations independently of CA1.
Journal: Nature neuroscience
In common: DeepLabCut, NetworkX, OpenCV, 8 other tools, systems, 1 reference
[9] doi:10.1038/s41593-026-02262-8 [code]
Cheese3D enables sensitive detection and analysis of whole-face movement in mice.
Journal: Nature neuroscience
In common: DeepLabCut, OpenCV, h5py, 6 other tools, systems, 2 references
[10] doi:10.1126/sciadv.aeh7220 [code]
Central complex representations of self-movement are sufficient to compute wind direction in flight.
Journal: Science advances
In common: TensorFlow, statsmodels, seaborn, 5 other tools, 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.