OSCR

Subunit-specific behavioral modulation of sensory tuning in the visual cortex.

Code ↔ Paper

The paper beside its authors' code: matches between them have not been computed for this paper yet.

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 · 531 lines · 20 KB · no license

  1. import math
  2. import os
  4. import matplotlib as mpl
  5. import matplotlib.pyplot as plt
  6. import numpy as np
  7. import pandas as pd
  8. import seaborn as sns
  9. from alive_progress import alive_it
  10. from matplotlib.ticker import MaxNLocator
  12. os.chdir('/Users/mayerj/repos/behavioral-visual-tuning')
  13. import src.globals as g
  14. import src.utils as ut
  15. from src.data_pipeline import tuning_data
  18. def buffer_array_with_nans(original_array, target_length):
  19. """
  20. Buffers an array with NaNs to a target length.
  21. :param original_array:
  22. :param target_length:
  23. :return:
  24. """
  25. original_array = np.asarray(original_array)
  26. buffered_array = np.full(target_length, np.nan)
  27. original_length = original_array.shape[0]
  29. if target_length < original_length:
  30. warnings.warn(f"Target length {target_length} is less than original length {original_length}")
  31. return
  32. else:
  33. buffered_array[:original_length] = original_array[:]
  34. return buffered_array
  37. def get_xticks(nan_buffer, num_traces=3):
  38. x_ticks_all = []
  39. for i in range(num_traces):
  40. x_ticks = list(np.arange(0, 121, 30) + (120 * i) + (nan_buffer * i))
  41. x_ticks = np.append(x_ticks, np.nan)
  42. x_ticks_all += list(x_ticks)
  43. return x_ticks_all
  46. def get_ax_vspan(nan_buffer, num_traces=3):
  47. ax_vspan_all = []
  48. for i in range(num_traces):
  49. span = np.asarray([30, 90]) + (120 * i) + (nan_buffer * i)
  50. ax_vspan_all.append(span)
  51. return ax_vspan_all
  54. def compute_nan_std_pos_from_sweeps(sweeps):
  55. """
  56. Compute the std of non-negative values across all sweeps for one cell.
  57. """
  58. arrays = [np.asarray(v, dtype=float).ravel() for v in sweeps if v is not None]
  59. if not arrays:
  60. return np.nan
  61. all_vals = np.concatenate(arrays)
  62. all_vals_pos = np.where(all_vals < 0, 0, all_vals)
  63. return np.nanstd(all_vals_pos)
  66. def prepare_raw_traces_from_sweeps(
  67. sweeps,
  68. dx,
  69. stim_table,
  70. conditions=None,
  71. num_conditions=3,
  72. nan_buffer=10,
  73. random_state=None,
  74. ):
  75. """
  76. Args:
  77. sweeps: sequence/Series of dF/F arrays per sweep for one cell.
  78. dx: sequence/Series of dx arrays aligned to sweeps.
  79. stim_table: DataFrame aligned to sweeps with temporal_frequency/orientation columns.
  80. conditions: optional DataFrame or list of dicts with temporal_frequency/orientation and optional trial.
  81. num_conditions: number of random conditions to sample when conditions is None.
  82. nan_buffer: number of NaNs to append between concatenated traces.
  83. random_state: seed for reproducible sampling.
  85. Returns:
  86. raw_dffs, transformed_dff, raw_dxs, condition_info
  87. """
  88. sweeps_series = pd.Series(sweeps).reset_index(drop=True)
  89. dx_series = pd.Series(dx).reset_index(drop=True)
  90. stim_df = stim_table.reset_index(drop=True)
  92. required_cols = {"temporal_frequency", "orientation"}
  93. missing = required_cols - set(stim_df.columns)
  94. if missing:
  95. raise ValueError(f"stim_table is missing required columns: {sorted(missing)}")
  97. df = pd.concat(
  98. [
  99. sweeps_series.rename("dff"),
  100. dx_series.rename("dx"),
  101. stim_df,
  102. ],
  103. axis=1,
  104. )
  106. rng = np.random.default_rng(random_state)
  108. if conditions is None:
  109. if "blank_sweep" in df.columns:
  110. cond_df = df.query("blank_sweep == 0")[["temporal_frequency", "orientation"]]
  111. else:
  112. cond_df = df[["temporal_frequency", "orientation"]]
  113. cond_df = cond_df.sample(num_conditions, random_state=random_state).reset_index(drop=True)
  114. use_trial_col = False
  115. else:
  116. cond_df = pd.DataFrame(conditions)
  117. use_trial_col = "trial" in cond_df.columns
  119. nan_std_pos = compute_nan_std_pos_from_sweeps(sweeps_series)
  121. raw_dffs = []
  122. raw_dxs = []
  123. condition_info = []
  125. for _, row in cond_df.iterrows():
  126. cond_rows = df.query(
  127. "temporal_frequency == @row.temporal_frequency and orientation == @row.orientation"
  128. )
  129. if cond_rows.empty:
  130. continue
  132. if use_trial_col:
  133. trial_idx = int(row.trial)
  134. trial_idx = max(0, min(trial_idx, len(cond_rows) - 1))
  135. else:
  136. trial_idx = int(rng.integers(0, len(cond_rows)))
  138. dff = np.asarray(cond_rows["dff"].iloc[trial_idx], dtype=float)
  139. dff = np.append(dff, [np.nan] * nan_buffer)
  140. raw_dffs.append(dff)
  142. dx_vals = np.asarray(cond_rows["dx"].iloc[trial_idx], dtype=float)
  143. dx_vals = np.append(dx_vals, [np.nan] * nan_buffer)
  144. raw_dxs.append(dx_vals)
  146. condition_info.append((row.temporal_frequency, row.orientation, int(trial_idx)))
  148. raw_dffs = np.asarray(raw_dffs).flatten()
  149. raw_dxs = np.asarray(raw_dxs).flatten()
  151. transformed_dff = np.where(raw_dffs < 0, 0, raw_dffs)
  152. if nan_std_pos and not np.isnan(nan_std_pos):
  153. transformed_dff = transformed_dff / nan_std_pos
  155. return raw_dffs, transformed_dff, raw_dxs, condition_info
  158. def plot_raw_transformed_traces(experiment_id='', cell_indices=None, path=None, condition_and_trials=None,
  159. restarts=10):
  160. assert cell_indices is not None
  161. assert path is not None
  163. if condition_and_trials is not None:
  164. iterate_num = 1 # only one plot per cell and condition instead of random restarts
  165. else:
  166. iterate_num = restarts
  168. dataset = tuning_data.ExperimentData(experiment_id)
  170. nan_buffer = 10
  171. font_size = 16
  172. mpl.rcParams['font.size'] = font_size
  174. figs = []
  175. for j in range(iterate_num):
  177. for i_enum, i in enumerate(cell_indices):
  179. if condition_and_trials is not None:
  180. conditions = condition_and_trials[i_enum]
  181. num_conditions = len(conditions)
  182. conditions = pd.DataFrame(conditions, columns=['temporal_frequency', 'orientation', 'trial'])
  183. non_rand_trial = True
  185. else:
  186. num_conditions = 3
  187. conditions = get_random_conditions_to_be_concatenated(dataset, num_conditions)
  188. non_rand_trial = False
  190. df_ = load_raw_cell_data(path=path, cell_index=i)
  191. nan_std_pos = compute_std_pos_one_cell(df_)
  193. raw_dffs_, transformed_dff_, raw_dxs_, condition_info_ = get_dff_transformeddff_dx_for_conditions(dataset,
  194. conditions,
  195. cell_index=i,
  196. nan_buffer=nan_buffer,
  197. nan_std_pos=nan_std_pos,
  198. non_rand_trial=non_rand_trial)
  200. fig = plot_concated_traces(raw_dffs_, transformed_dff_, raw_dxs_, nan_buffer=nan_buffer,
  201. title=f'{experiment_id} | {i}\n{condition_info_}',
  202. num_traces=num_conditions, svg=False, show=False)
  204. figs.append(fig)
  206. return figs
  209. def get_random_conditions_to_be_concatenated(dataset, num_conditions=3):
  210. return dataset.stim_table.query('blank_sweep == 0').sample(num_conditions) # exclude static frequencies
  213. def load_raw_cell_data(path, cell_index):
  214. test = ut.load_pickle(path) # f'{path}/raw_cells')
  216. # df_test contains all responses of a cell during the trial periods, separated in 2D bins
  217. df_test = pd.DataFrame.from_dict(test[cell_index], orient='index').T
  218. df_test.fillna(value=np.nan, inplace=True)
  219. return df_test
  222. def compute_std_pos_one_cell(df_test):
  223. # convert to 3d numpy array
  224. max_len = math.ceil(df_test.map(lambda x: len(x) if not np.isnan(x).any() else x).max().max())
  225. df_buffered = df_test.map(
  226. lambda x: buffer_array_with_nans(x, max_len) if not np.isnan(x).any() else np.full(max_len, np.nan))
  227. nd_arr = np.array(df_buffered.values.tolist())
  229. # compute standard deviation of positive values for whole cell
  230. nd_arr_pos = np.where(nd_arr < 0, 0, nd_arr) # replace non-negative values with 0
  231. nan_std_pos = np.nanstd(nd_arr_pos)
  232. return nan_std_pos
  235. def get_dff_transformeddff_dx_for_conditions(dataset, conditions, cell_index, nan_buffer, nan_std_pos,
  236. non_rand_trial=False):
  237. raw_dffs = []
  238. raw_dxs = []
  239. condition_info = [] # temp_freq, ori, trial
  241. for index, row in conditions.iterrows():
  243. df = dataset.sweep_response.iloc[
  244. dataset.stim_table.query(f'temporal_frequency == {row.temporal_frequency} '
  245. f'and orientation == {row.orientation}').index]
  247. if non_rand_trial:
  248. randint = int(row.trial) # trial number for this condition, not random
  249. else:
  250. # choose random trial of the 15 avaialable trials for each condition
  251. randint = np.random.randint(0, len(df))
  253. dff = df[str(cell_index)].iloc[randint] # randint-th trial for this cell
  254. dff = np.append(dff, [np.nan] * nan_buffer)
  255. raw_dffs.append(dff)
  257. dx = df['dx'].iloc[randint]
  258. dx = np.append(dx, [np.nan] * nan_buffer)
  259. raw_dxs.append(dx)
  261. condition_info.append((row.temporal_frequency, row.orientation, randint))
  263. raw_dxs = np.asarray(raw_dxs).flatten()
  265. raw_dffs = np.array(raw_dffs).flatten()
  267. transformed_dff = np.where(raw_dffs < 0, 0, raw_dffs) # replace non-negative values with 0
  268. transformed_dff = transformed_dff / nan_std_pos
  270. return raw_dffs, transformed_dff, raw_dxs, condition_info
  273. def plot_concated_traces(raw_dffs, transformed_dff, raw_dxs, nan_buffer, num_traces=3, title='', svg=False, show=False):
  274. x_ticks_all = get_xticks(nan_buffer, num_traces)
  275. x_labels = [-1, 0, 1, 2, 3, " "]
  276. ax_vspan_all = get_ax_vspan(nan_buffer, num_traces)
  278. fig, ax = plt.subplots(3, 1, figsize=(5 * num_traces, 6),
  279. sharex=True, sharey=False,
  280. gridspec_kw={'height_ratios': [1, 1, 0.5]})
  282. plt.xticks(x_ticks_all, x_labels * num_traces, rotation=0)
  283. plt.xlabel("Time in trial (s)")
  285. for span in ax_vspan_all:
  286. ax[0].axvspan(span[0], span[1], color='gray', alpha=0.3, lw=0)
  287. ax[1].axvspan(span[0], span[1], color='gray', alpha=0.3, lw=0)
  289. ax[0].axhline(0, color='gray', lw=0.75, ls='-')
  290. ax[0].set_ylabel('DF/F')
  292. ax[1].axhline(0, color='gray', lw=0.75, ls='-')
  293. ax[1].set_ylabel('DF/F\ntransformed')
  295. i = num_traces
  296. ax[0].plot(raw_dffs[0:120 * i + (i * nan_buffer)], lw=1.5, color='k')
  297. ax[1].plot(transformed_dff[0:120 * i + (i * nan_buffer)], lw=1.5, color='k')
  299. ax[2].plot(raw_dxs[0:120 * i + (i * nan_buffer)], lw=1.5, color='#0075B8') # #a719ca dimgray
  300. ax[2].set_ylabel('velocity\n(cm/s)')
  301. # ax[2].set_ylim(-5, 25)
  302. # ax[2].set_yticks([0, 10, 20])
  304. if title:
  305. plt.suptitle('(temp_fr, orientation, trial)\n' + title)
  307. plt.tight_layout()
  308. if show:
  309. plt.show()
  310. elif svg:
  311. plt.savefig("dff_raw_transformed_velo.svg")
  313. plt.close()
  314. return fig
  318. def plot_single_cell_tuning_figure(experiment_id, cell_index, show=True):
  319. """
  320. Notebook-friendly version of plot_single_cell_to_pdf.
  321. Returns (fig, ax) and optionally shows.
  322. """
  323. dataset = tuning_data.ExperimentData(str(experiment_id))
  324. i = cell_index
  326. style = {
  327. "linewidth": 3,
  328. "ori_axis_label": "Direction (deg)",
  329. "ori_tick_labels": g.HELPER.ORIENTATION_LABELS,
  330. "ori_color": "#E30613",
  331. "ori_color2": "#931912",
  332. "velo_axis_label": "Velocity (cm/s)",
  333. "velo_tick_labels": g.HELPER.VELOCITY_LABELS,
  334. "velo_color": "#009FE3",
  335. "cmap": "Greys",
  336. }
  338. with plt.style.context("seaborn-v0_8-poster"):
  339. fig, ax = plt.subplots(
  340. 4, 2, figsize=(10.5, 14),
  341. gridspec_kw={"height_ratios": [1, 0.3, 0.3, 0.3], "width_ratios": [1, 0.5]}
  342. )
  344. a, b, c, d = (0, 0), (1, 0), (2, 0), (3, 0)
  346. ax[0, 0].set_xticks(range(0, 8))
  347. ax[0, 0].set_yticks(range(0, 8))
  349. for j in range(1, 4):
  350. ax[j, 0].spines["top"].set_visible(False)
  351. ax[j, 0].spines["right"].set_visible(False)
  352. ax[j, 0].spines["bottom"].set_visible(False)
  353. ax[j, 0].spines["left"].set_visible(False)
  354. ax[j, 0].grid(False)
  355. ax[j, 0].set_ylabel("mean\nresponse")
  356. ax[j, 0].set_xticks(range(0, 8))
  358. for l in range(1, 4):
  359. ax[l, 1].axis("off")
  361. # joint tuning
  362. sns.heatmap(
  363. dataset.tuning_2d_transformed_experiment[:, :, i],
  364. cmap=style["cmap"], square=True, cbar=False, ax=ax[a]
  365. )
  366. ax[a].set_title(f"{experiment_id} | cell {cell_index}")
  367. ax[a].set_ylabel(style["ori_axis_label"])
  368. ax[a].set_yticklabels(style["ori_tick_labels"], rotation=0)
  369. ax[a].set_xlabel(style["velo_axis_label"])
  370. ax[a].set_xticklabels(style["velo_tick_labels"], rotation=45)
  372. # single tuning
  373. margin = 0.25
  374. velo = np.mean(dataset.tuning_2d_transformed_experiment[:, :, i], axis=0)
  375. vmin = np.min(velo) - margin * 0.5
  376. vmax = np.max(velo) + margin * 0.5
  377. ax[b].plot(velo, linewidth=style["linewidth"], c=style["velo_color"])
  378. ax[b].set_ylim(vmin, vmax)
  379. ax[b].set_xlabel(style["velo_axis_label"])
  380. ax[b].set_xticklabels(style["velo_tick_labels"], rotation=45)
  382. ori = np.mean(dataset.tuning_2d_transformed_experiment[:, :, i], axis=1)
  383. ori_stat = dataset.tuning_2d_transformed_experiment[:, :1, i]
  384. omin = np.min([np.min(ori_stat), np.min(ori)]) - margin
  385. omax = np.max([np.max(ori_stat), np.max(ori)]) + margin
  386. ax[c].plot(ori, linewidth=style["linewidth"], c=style["ori_color"])
  387. ax[c].set_ylim(omin, omax)
  388. ax[c].set_xlabel(style["ori_axis_label"])
  389. ax[c].set_xticklabels(style["ori_tick_labels"], rotation=90)
  391. ori_loco = np.mean(dataset.tuning_2d_transformed_experiment[:, 1:, i], axis=1)
  392. ori_loco_std = np.std(dataset.tuning_2d_transformed_experiment[:, 1:, i], axis=1)
  393. ax[d].plot(ori_loco, linewidth=style["linewidth"], c=style["ori_color2"], label="Locomotion")
  394. ax[d].errorbar(
  395. np.arange(len(ori_loco)), ori_loco, yerr=ori_loco_std,
  396. linewidth=style["linewidth"], c=style["ori_color2"]
  397. )
  398. ax[d].plot(ori_stat, linewidth=style["linewidth"], c=style["ori_color"], zorder=4, label="Stationary")
  399. ax[d].set_xlabel(style["ori_axis_label"])
  400. ax[d].set_xticklabels(style["ori_tick_labels"], rotation=90)
  401. ax[d].set_ylim(omin, omax)
  402. ax[d].legend(loc="center left", bbox_to_anchor=(1, 0.5))
  404. # colorbar panel
  405. sns.heatmap(
  406. dataset.tuning_2d_transformed_experiment[:, :, i],
  407. cmap=style["cmap"], square=True, cbar=True,
  408. cbar_kws={"shrink": 0.8, "label": "mean response"},
  409. ax=ax[0, 1],
  410. )
  411. cbar = ax[0, 1].collections[0].colorbar
  412. cbar.outline.set_edgecolor("black")
  413. cbar.outline.set_linewidth(1)
  414. ax[0, 1].set_xticks([])
  415. ax[0, 1].set_yticks([])
  417. plt.tight_layout()
  418. if show:
  419. plt.show()
  421. return fig, ax
  424. def plot_single_cell_tuning_figure_minimal(experiment_id, cell_index, show=True):
  425. """
  426. Smaller notebook-friendly variant based on plot_single_cell_to_pdf2 styling.
  427. """
  428. dataset = tuning_data.ExperimentData(str(experiment_id))
  429. i = cell_index
  431. style = {
  432. "linewidth": 3,
  433. "ori_axis_label": "Direction (deg)",
  434. "ori_tick_labels": g.HELPER.ORIENTATION_LABELS,
  435. "ori_tick_rotation": 90,
  436. "ori_color": "#E30613",
  437. "ori_color2": "#931912",
  438. "velo_axis_label": "Velocity (cm/s)",
  439. "velo_tick_labels": [0, "", "", "", "", "", "", 20],
  440. "velo_tick_rotation": 0,
  441. "velo_color": "#009FE3",
  442. "cmap": "Greys",
  443. "font_size": 25,
  444. }
  446. with plt.style.context("seaborn-v0_8-poster"):
  447. fig, ax = plt.subplots(
  448. 4, 2, figsize=(10.5, 15.5),
  449. gridspec_kw={"height_ratios": [1, 0.35, 0.35, 0.35], "width_ratios": [1, 0.5]}
  450. )
  452. ax[0, 0].set_xticks(range(0, 8))
  453. ax[0, 0].set_yticks(range(0, 8))
  455. for j in range(1, 4):
  456. ax[j, 0].spines["top"].set_visible(False)
  457. ax[j, 0].spines["right"].set_visible(False)
  458. ax[j, 0].spines["bottom"].set_visible(False)
  459. ax[j, 0].spines["left"].set_visible(False)
  460. ax[j, 0].grid(False)
  461. ax[j, 0].set_ylabel("mean\nresponse", fontsize=style["font_size"])
  462. ax[j, 0].set_xticks(range(0, 8))
  463. ax[j, 0].axhline(0, color="grey", linewidth=3)
  465. for l in range(1, 4):
  466. ax[l, 1].axis("off")
  468. sns.heatmap(
  469. dataset.tuning_2d_transformed_experiment[:, :, i],
  470. cmap=style["cmap"], square=True, cbar=False, ax=ax[0, 0]
  471. )
  472. ax[0, 0].set_title(f"{experiment_id} | cell {cell_index}")
  473. ax[0, 0].set_ylabel(style["ori_axis_label"], fontsize=style["font_size"])
  474. ax[0, 0].set_yticklabels(style["ori_tick_labels"], rotation=0, fontsize=style["font_size"])
  475. ax[0, 0].set_xlabel(style["velo_axis_label"], fontsize=style["font_size"])
  476. ax[0, 0].set_xticklabels(
  477. style["velo_tick_labels"], rotation=style["velo_tick_rotation"], fontsize=style["font_size"]
  478. )
  480. margin = 0.25
  482. velo = np.mean(dataset.tuning_2d_transformed_experiment[:, :, i], axis=0)
  483. vmax = np.max(velo)
  484. ax[1, 0].axhline(vmax, color="grey", linewidth=3)
  485. ax[1, 0].plot(velo, linewidth=style["linewidth"], c=style["velo_color"])
  486. ax[1, 0].set_ylim(0, vmax + margin * 0.5)
  487. ax[1, 0].set_xlabel(style["velo_axis_label"], fontsize=style["font_size"])
  488. ax[1, 0].set_xticklabels(
  489. style["velo_tick_labels"], rotation=style["velo_tick_rotation"], fontsize=style["font_size"]
  490. )
  492. ori = np.mean(dataset.tuning_2d_transformed_experiment[:, :, i], axis=1)
  493. omax = np.max(ori)
  494. ax[2, 0].axhline(omax, color="grey", linewidth=3)
  495. ax[2, 0].plot(ori, linewidth=style["linewidth"], c=style["ori_color"])
  496. ax[2, 0].set_ylim(0, omax + margin)
  497. ax[2, 0].set_xlabel(style["ori_axis_label"], fontsize=style["font_size"])
  498. ax[2, 0].set_xticklabels(
  499. style["ori_tick_labels"], rotation=style["ori_tick_rotation"], fontsize=style["font_size"]
  500. )
  502. ori_stat = dataset.tuning_2d_transformed_experiment[:, :1, i]
  503. ori_loco = np.mean(dataset.tuning_2d_transformed_experiment[:, 1:, i], axis=1)
  504. omax2 = np.max([np.max(ori_stat), np.max(ori_loco)])
  505. ax[3, 0].axhline(omax2, color="grey", linewidth=3)
  506. ax[3, 0].plot(ori_loco, linewidth=style["linewidth"], c=style["ori_color2"], label="Locomotion")
  507. ax[3, 0].plot(ori_stat, linewidth=style["linewidth"], c=style["ori_color"], zorder=4, label="Stationary")
  508. ax[3, 0].set_xlabel(style["ori_axis_label"], fontsize=style["font_size"])
  509. ax[3, 0].set_xticklabels(
  510. style["ori_tick_labels"], rotation=style["ori_tick_rotation"], fontsize=style["font_size"]
  511. )
  512. ax[3, 0].set_ylim(0, omax2 + margin)
  513. ax[3, 0].legend(loc="center left", bbox_to_anchor=(1, 0.5))
  515. sns.heatmap(
  516. dataset.tuning_2d_transformed_experiment[:, :, i],
  517. cmap=style["cmap"], square=True, cbar=True,
  518. cbar_kws={"shrink": 0.8, "label": "mean response"},
  519. ax=ax[0, 1],
  520. )
  521. cbar = ax[0, 1].collections[0].colorbar
  522. cbar.outline.set_edgecolor("black")
  523. cbar.outline.set_linewidth(1)
  524. ax[0, 1].set_xticks([])
  525. ax[0, 1].set_yticks([])
  527. plt.tight_layout()
  528. if show:
  529. plt.show()
  531. return fig, ax

demo_plotting.py at commit 97b2e4a, no license · at the source

Overview

Authors: Julia M. Mayer1,2, Wiktor F. Młynarski1,3
ORCID iDs: Julia M. Mayer, Wiktor F. Młynarski
  1. Faculty of Biology, Ludwig Maximilian University of Munich, Munich, Germany
  2. Graduate School of Systemic Neurosciences, Munich, Germany
  3. Bernstein Center for Computational Neuroscience Munich, Munich, Germany
Institutions: Ludwig-Maximilians-Universität München (Germany); Bernstein Center for Computational Neuroscience Munich (Germany)
Journal: PLoS computational biology, volume 22, issue 4, article e1014123
Dates: received 3 September 2025; accepted 12 March 2026; published online 6 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pcbi.1014123 · PMID 41941411 · PMCID PMC13082715 · OpenAlex W7150916594
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: computational modeling (no new data) (modality), mouse (organism), systems (subfield)
Methods: Connectivity, Machine learning, Statistics, Single-unit activity, calcium imaging
MeSH: Behavior, Animal*, Models, Neurological*, Sensory Receptor Cells*, Visual Cortex*, Animals, Computational Biology, Computer Simulation, Locomotion, Mice (* major topic)
Journal subjects: Biology and Life Sciences, Neuroscience, Neuronal Tuning, Cell Biology, Cellular Types, Animal Cells, Neurons, Cellular Neuroscience, Cognitive Science, Cognitive Psychology, Perception, Sensory Perception, Psychology, Social Sciences, Behavior, Anatomy, Brain, Visual Cortex, Medicine and Health Sciences, Animal Behavior, Zoology, Physiology, Biological Locomotion, Running, Vision
Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Citations: cited by 2 papers (Europe PMC); 40 references in the paper

Abstract

Activity of sensory neurons is influenced not only by external stimuli but also by the animal’s behavioral state. It is well documented that behavior influences the general properties of neural activity, such as response gain. However, it is not known whether it could affect the sensory tuning of individual neurons in a more refined way and what the functional benefit of such nuanced modulation might be. Here, we investigate this in the mouse visual cortex using the data made available by the Allen Brain Observatory. Our analysis indicates that locomotion can modulate not only the gain of the entire neuronal response, but also more selectively control responses to specific stimuli. This modulation results in changes of neuronal tuning in different behavioral states. Using numerical simulations, we demonstrate that such patterns of gain modulation can multiplex behavioral information in sensory populations without compromising the accuracy of sensory coding. In that way, the visual cortex could instantiate an accurate, joint representation of sensory and movement-related signals and support computations that simultaneously require both types of information.

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

Repository

Its files are read in the Code ↔ Paper reader above.

Mlynarski-Group/behavioral-visual-tuning

License: none: the authors keep all their rights
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 97b2e4ad341253b7fc6ca34457ea8df2751cbd15, 7 January 2026
Languages: Python (1)
Size: 5 files, 1 script
Software Heritage: not archived
Found in: “Data Availability”
Holds: README, environment (requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: Matplotlib (1 file), NumPy (1 file), pandas (1 file), seaborn (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
2 files
At the source: github.com/Mlynarski-Group/behavioral-visual-tuning

The paper's code and data availability statement is in the Data section.

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;
  • 1 script, each with its path and the digest of its content;
  • no match between paragraphs and code yet;
  • 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

The code is available on the group’s GitHub account: https://github.com/Mlynarski-Group/behavioral-visual-tuning.

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

Recorded: type, language, journal, volume, issue, pages, dates, 2 authors, 9 MeSH terms, 36 references.

Cite

This paper

Mayer, J. M., & Młynarski, W. F. (2026). Subunit-specific behavioral modulation of sensory tuning in the visual cortex. PLoS computational biology, 22(4), e1014123. https://doi.org/10.1371/journal.pcbi.1014123

BibTeX

@article{mayer2026subunit,
author = {Mayer, Julia M. and Młynarski, Wiktor F.},
title = {{Subunit-specific behavioral modulation of sensory tuning in the visual cortex}},
journal = {PLoS computational biology},
year = {2026},
month = apr,
volume = {22},
number = {4},
pages = {e1014123},
publisher = {PLOS},
issn = {1553-734X},
doi = {10.1371/journal.pcbi.1014123},
url = {https://doi.org/10.1371/journal.pcbi.1014123},
pmid = {41941411},
pmcid = {PMC13082715}
}

RIS

TY - JOUR
AU - Mayer, Julia M.
AU - Młynarski, Wiktor F.
TI - Subunit-specific behavioral modulation of sensory tuning in the visual cortex
T2 - PLoS computational biology
J2 - PLoS Comput Biol
PY - 2026
DA - 2026/04/06
VL - 22
IS - 4
SP - e1014123
SN - 1553-734X
PB - PLOS
DO - 10.1371/journal.pcbi.1014123
UR - https://doi.org/10.1371/journal.pcbi.1014123
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pcbi.1014123",
"type": "article-journal",
"title": "Subunit-specific behavioral modulation of sensory tuning in the visual cortex",
"container-title": "PLoS computational biology",
"author": [
{
"family": "Mayer",
"given": "Julia M."
},
{
"family": "Młynarski",
"given": "Wiktor F."
}
],
"container-title-short": "PLoS Comput Biol",
"volume": "22",
"issue": "4",
"page": "e1014123",
"DOI": "10.1371/journal.pcbi.1014123",
"PMID": "41941411",
"PMCID": "PMC13082715",
"ISSN": "1553-734X",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pcbi.1014123",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
6
]
]
}
}

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

Similar papers

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

[1] doi:10.1126/sciadv.aed4172 [code]
Locomotion optimizes sensory representations through a computational principle shared by rodents and primates.
Journal: Science advances
In common: pandas, Matplotlib, NumPy, 10 references, author Wiktor F. Młynarski
[2] doi:10.1371/journal.pcbi.1014157 [code]
Modeling spatial contrast sensitivity in responses of primate retinal ganglion cells to natural movies.
Journal: PLoS computational biology
In common: pandas, NumPy, computational modeling (no new data), 4 references
[3] doi:10.1126/sciadv.adv5652 [code]
The anterior cingulate cortex modulates pupil-linked arousal.
Journal: Science advances
In common: seaborn, pandas, Matplotlib, 1 other tool, systems, 4 references
[4] doi:10.1038/s41467-026-71725-0 [code]
Interactions across hemispheres in prefrontal cortex reflect global cognitive processing.
Journal: Nature communications
In common: pandas, Matplotlib, NumPy, 5 references
[5] doi:10.1038/s41467-026-71667-7
Behavioural states control binocular vision through input-specific mechanisms.
Journal: Nature communications
In common: mouse, 6 references
[6] doi:10.1038/s41467-026-75347-4 [code]
Sleep reveals dynamics integrating and segregating movement and stimulus representations in V1.
Journal: Nature communications
In common: pandas, Matplotlib, NumPy, systems, mouse, 4 references
[7] doi:10.1038/s41467-026-74227-1 [code]
Age-related changes in behavioural and neural variability in a decision-making task.
Journal: Nature communications
In common: seaborn, pandas, Matplotlib, 1 other tool, mouse, 3 references
[8] doi:10.1523/jneurosci.0987-25.2026 [code]
Cell-Type-Specific Synaptic Scaling Mechanisms Differentially Contribute to Associative Learning.
Journal: The Journal of neuroscience : the official journal of the Society for Neuroscience
In common: seaborn, pandas, Matplotlib, 1 other tool, 3 references
[9] doi:10.1371/journal.pone.0356243 [code]
Functional organization and natural scene responses across mouse visual cortical areas revealed with encoding manifolds.
Journal: PloS one
In common: pandas, Matplotlib, NumPy, mouse, 3 references
[10] doi:10.1016/j.neuron.2026.07.016 [code]
Inferring brain-wide interactions using data-constrained recurrent neural network models.
Journal: Neuron
In common: Matplotlib, NumPy, computational modeling (no new data), systems, mouse, 3 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.