OSCR

Fixation duration on natural scenes is explained by memory encoding not processing demand.

Code ↔ Paper

31 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 31 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Results › Theta–gamma coupling in neural dynamics during longer fixations ↔ avs_gazetime/pac/pac_plotting_and_stats.ipynb, lines 79–105 · score 0.97 · dorsolateral prefrontal cortex, medial prefrontal cortex, inferior frontal cortex, frontal eye field, orbitofrontal cortex, mPFC
  2. [2] § Results › Theta–gamma coupling in neural dynamics during longer fixations ↔ avs_gazetime/pac/pac_plotting_and_stats.ipynb, lines 79–105 · score 0.95 · dorsolateral prefrontal cortex, medial prefrontal cortex, inferior frontal cortex, frontal eye field, orbitofrontal cortex, mPFC
  3. [3] § Methods › Analysis › PAC analysis ↔ avs_gazetime/pac/pac_functions.py, lines 53–96 · score 0.90 · Kullback Leibler divergence, probability distribution, phase bin, binned amplitudes, gamma amplitude, division
  4. [4] § Methods › Analysis › PAC analysis ↔ avs_gazetime/pac/pac_functions.py, lines 278–348 · score 0.84 · extracted PAC windows, Hilbert transform, windows relative, offset locked, fixation offset, fixation end
  5. [5] § Methods › Analysis › PAC analysis ↔ avs_gazetime/pac/full_pac_map.py, lines 86–131 · score 0.80 · amplitude filters, amplitude bands, PAC matrices, phase frequency, Amplitude frequencies, bandwidths
  6. [6] § Methods › Analysis › Semantic category analysis ↔ avs_gazetime/ease_of_recognition/semantic_category_analysis.py, lines 76–166 · score 0.76 · semantic categories, classified fixation, animal, manmade, probability, inanimate
  7. [7] § Methods › Analysis › PAC analysis ↔ avs_gazetime/pac/pac_functions.py, lines 192–230 · score 0.76 · swaps segments, random cut point, single cut, surrogate, epoch, PAC
  8. [8] § Methods › Analysis › Caption relevance assessment ↔ avs_gazetime/fix2cap/fix2cap_quality_controls.py, lines 296–425 · score 0.73 · Inter rater reliability, agreement, binary, fair, Cohen, scene
  9. [9] § Methods › Analysis › MEG pattern change analysis ↔ avs_gazetime/dynamics/dynamics_plotting_tools.py, lines 149–294 · score 0.72 · dynamics reached, handle oscillations, halfway point, tolerance, detection, masked
  10. [10] § Methods › Analysis › Ease-of-recognition decoding ↔ avs_gazetime/decoding/duration_decoder.py, lines 245–330 · score 0.70 · ridge regression, clipping outliers, cross validation, Decoder, decoded, channel
  11. [11] § Results › Consistent latency of MEG pattern stabilization regardless of fixation duration ↔ avs_gazetime/decoding/plot_entropy_predictions.py, lines 1–22 · score 0.67 · entropy predicts, MEG decoding, classification entropy, random intercept, ease, quartiles
  12. [12] § Methods › Analysis › Ease-of-recognition analysis ↔ avs_gazetime/ease_of_recognition/entropy_tools.py, lines 116–200 · score 0.66 · absolute entropy, log transformed, relative entropy, layer, ecoset, classification
  13. [13] § Methods › Analysis › MEG pattern change analysis ↔ avs_gazetime/dynamics/dynamics_plotting_tools.py, lines 149–294 · score 0.66 · search window, halfway point, fixation end, edge, detection, oscillations
  14. [14] § Methods › Analysis › PAC analysis ↔ avs_gazetime/pac/params_pac.py, lines 1–12 · score 0.66 · 40–140 Hz, offset locked, 3–8 Hz, ERF, correlation, saccade
  15. [15] § Methods › Analysis › Ease-of-recognition decoding ↔ avs_gazetime/decoding/entropy_decoder.py, lines 250–321 · score 0.65 · dummy baseline, cross validation, sliding, regression, decoded, Decoder
  16. [16] § Methods › Analysis › Ease-of-recognition analysis ↔ avs_gazetime/decoding/decoding_params.py, lines 20–28 · score 0.65 · crop trained, AlexNet, Inception, Resnet50, VGG16, networks
  17. [17] § Methods › Analysis › PAC analysis ↔ avs_gazetime/pac/pac_dataloader.py, lines 54–92 · score 0.64 · saccade onset, median ERF, fixation onset, flattened, correlation, channel
  18. [18] § Methods › Analysis › Patch memorability analysis ↔ avs_gazetime/memorability/saccade_amplitude_analysis.py, lines 83–197 · score 0.63 · upcoming saccade, saccade amplitude, memorability scores, matched, fixation
  19. [19] § Methods › Analysis › Ease-of-recognition analysis ↔ avs_gazetime/ease_of_recognition/get_activations_thingsvision.py, lines 1–23 · score 0.62 · Inception v3, fixation crop, Resnet50, VGG16, ecoset, trained
  20. [20] § Methods › Data acquisition and preprocessing › ROI definition ↔ avs_gazetime/pac/run_pac_cross_freq.sh, lines 61–108 · score 0.61 · infFC, dlPFC, OFC, HC, definition, ROIs
  21. [21] § Methods › Data acquisition and preprocessing › Stimuli and experiment ↔ avs_gazetime/scenes/semantic_clusters/semantic_scene_space.py, lines 130–172 · score 0.60 · semantic embeddings, semantic clusters, NSD, COCO, subset, scenes
  22. [22] § Results › Theta–gamma coupling in neural dynamics during longer fixations ↔ avs_gazetime/pac/run_pac_cross_freq.sh, lines 61–108 · score 0.60 · infFC, dlPFC, frequency PAC, OFC, HC
  23. [23] § Results › Memorable fixation targets receive longer fixation durations ↔ avs_gazetime/ease_of_recognition/semantic_category_analysis.py, lines 367–513 · score 0.60 · absolute memorability, semantic categories, relative memorability, Linear mixed, inanimate, models
  24. [24] § Results › Easier rather than challenging targets receive longer fixations ↔ avs_gazetime/decoding/decoding_params.py, lines 20–28 · score 0.57 · ResNet50, AlexNet, Inception, VGG16, network, trained
  25. [25] § Results › Theta–gamma coupling in neural dynamics during longer fixations ↔ avs_gazetime/pac/illustrate_offset_locking.py, lines 267–274 · score 0.55 · offset locked, shorter fixations, fixation offset, longer fixations, window, PAC
  26. [26] § Results › Theta–gamma coupling in neural dynamics during longer fixations ↔ avs_gazetime/pac/pac_functions.py, lines 232–276 · score 0.55 · single cut surrogate, phase amplitude relationships, gamma, Theta
  27. [27] § Methods › Analysis › Patch memorability analysis ↔ avs_gazetime/ease_of_recognition/semantic_category_analysis.py, lines 76–166 · score 0.55 · fixation patch, memorability score, sequence, network, quantiles, predicting
  28. [28] § Methods › Analysis › Patch memorability analysis ↔ avs_gazetime/memorability/mem_tools.py, lines 16–132 · score 0.54 · ResMem scores, memorability score, sequence, behavioral, fixation duration, memory
  29. [29] § Methods › Data acquisition and preprocessing › Source reconstruction ↔ avs_gazetime/dynamics/dynamics_functions.py, the whole file · a weak match · score 0.53 · covariance matrices, norm, gradiometer, dimensional, epochs, MEG
  30. [30] § Results › Easier rather than challenging targets receive longer fixations ↔ avs_gazetime/decoding/duration_decoder.py, lines 172–243 · score 0.52 · trained ridge regression, decoders, R2, validation, duration
  31. [31] § Methods › Data acquisition and preprocessing › Stimuli and experiment ↔ avs_gazetime/scenes/semantic_clusters/semantic_scene_space.py, lines 130–172 · score 0.50 · semantic embedding space, COCO, fitting, Scenes

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 · 817 lines · 33 KB · no license · 4 matches

  1. """
  2. Module for computing phase-amplitude coupling (PAC).
  3. """
  4. import numpy as np
  5. import matplotlib.pyplot as plt
  6. import seaborn as sns
  7. import os
  8. import scipy.stats as stats
  9. from scipy.signal import hilbert
  10. from mne.filter import filter_data
  11. from joblib import Parallel, delayed
  12. from tqdm import tqdm
  13. from avs_gazetime.utils.simple_timing import simple_timer, tic, toc
  15. # Import optimized n_jobs settings
  16. from avs_gazetime.pac.pac_dataloader import optimize_n_jobs
  18. # Get optimized parallel job settings
  19. PARALLEL_JOBS = optimize_n_jobs()
  21. def circular_linear_correlation(phase_data, amplitude_data):
  22. """
  23. Compute the circular-linear correlation coefficient between phase and amplitude.
  25. Parameters:
  26. - phase_data: np.ndarray
  27. Array of phase angles (in radians) for the lower frequency oscillations.
  28. - amplitude_data: np.ndarray
  29. Array of amplitude values for the higher frequency oscillations.
  31. Returns:
  32. - rho: float
  33. Circular-linear correlation coefficient.
  34. """
  35. # Ensure data are numpy arrays
  36. phase_data = np.asarray(phase_data)
  37. amplitude_data = np.asarray(amplitude_data)
  39. # Convert phase data to complex numbers using sine and cosine
  40. sin_phase = np.sin(phase_data)
  41. cos_phase = np.cos(phase_data)
  43. # Compute correlations
  44. rca = np.corrcoef(cos_phase, amplitude_data)[0, 1]
  45. rsa = np.corrcoef(sin_phase, amplitude_data)[0, 1]
  46. rcs = np.corrcoef(sin_phase, cos_phase)[0, 1]
  48. # Calculate the circular-linear correlation coefficient
  49. rho = np.sqrt(rca**2 + rsa**2 - 2 * rca * rsa * rcs) / np.sqrt(1 - rcs**2)
  51. return rho
  53. def compute_modulation_index(theta_phase, gamma_amplitude, n_bins=18):
  54. """
  55. Compute the Modulation Index based on the Kullback-Leibler distance
  56. for phase-amplitude coupling as suggested by Tort et al. (2010).
  58. Parameters:
  59. - theta_phase: np.ndarray
  60. Array of theta phases for a specific channel (in radians).
  61. - gamma_amplitude: np.ndarray
  62. Array of gamma amplitudes for the same channel.
  63. - n_bins: int
  64. Number of phase bins to use for coupling calculation.
  66. Returns:
  67. - mi: float
  68. The Modulation Index value.
  69. """
  70. # Create phase bins
  71. phase_bins = np.linspace(-np.pi, np.pi, n_bins + 1)
  73. # Initialize the binned amplitude array
  74. binned_amplitude = np.zeros(n_bins)
  76. # Compute the mean gamma amplitude for each phase bin
  77. for i in range(n_bins):
  78. # Find indices for the current phase bin
  79. indices = np.where((theta_phase >= phase_bins[i]) & (theta_phase < phase_bins[i + 1]))
  80. # Calculate the mean amplitude in the current bin
  81. if len(indices[0]) > 0:
  82. binned_amplitude[i] = np.mean(gamma_amplitude[indices])
  84. # Normalize the binned amplitude to get a probability distribution
  85. binned_amplitude += 1e-10 # Avoid division by zero
  86. binned_amplitude /= binned_amplitude.sum()
  88. # Calculate Kullback-Leibler divergence from uniform distribution
  89. uniform_distribution = np.ones(n_bins) / n_bins # Uniform distribution
  90. kl_divergence = np.sum(binned_amplitude * np.log(binned_amplitude / uniform_distribution))
  92. # Normalize the KL divergence to get the Modulation Index (MI)
  93. max_entropy = np.log(n_bins) # Maximum entropy for uniform distribution
  94. mi = kl_divergence / max_entropy # Normalize by max entropy
  96. return mi
  98. def direct_pac_ozturk(theta_phase, gamma_amplitude):
  99. """
  100. Compute the PAC value using the method proposed by Ozturk et al. (2019).
  102. Parameters:
  103. - theta_phase: np.ndarray
  104. Array of theta phases for a specific channel.
  105. - gamma_amplitude: np.ndarray
  106. Array of gamma amplitudes for the same channel.
  108. Returns:
  109. - pac: float
  110. The PAC value.
  111. """
  112. # Compute the direct PAC estimate
  113. sum_aH_eiL = np.sum(gamma_amplitude * np.exp(1j * theta_phase))
  114. sum_aH2 = np.sum(gamma_amplitude**2)
  116. direct_pac = np.abs(sum_aH_eiL) / np.sqrt(sum_aH2)
  117. return direct_pac
  119. def compute_phase_shuffle_bootstrap(theta_phase, gamma_amplitude, pac_function, n_bootstraps, rng):
  120. """
  121. Compute bootstrap samples by randomly shuffling phase data.
  123. Parameters:
  124. - theta_phase: np.ndarray
  125. Array of theta phases.
  126. - gamma_amplitude: np.ndarray
  127. Array of gamma amplitudes.
  128. - pac_function: callable
  129. Function to compute PAC.
  130. - n_bootstraps: int
  131. Number of bootstrap samples.
  132. - rng: numpy.random.Generator
  133. Random number generator.
  135. Returns:
  136. - baseline_bootstrap: np.ndarray
  137. Array of bootstrap PAC values.
  138. """
  139. baseline_bootstrap = np.zeros(n_bootstraps)
  141. for b in range(n_bootstraps):
  142. # For 1D arrays
  143. if theta_phase.ndim == 1:
  144. shuffled_indices = rng.permutation(len(theta_phase))
  145. baseline_bootstrap[b] = pac_function(theta_phase[shuffled_indices], gamma_amplitude)
  146. # For 2D arrays (epochs, times)
  147. else:
  148. # Shuffle each epoch independently
  149. shuffled_phase = np.zeros_like(theta_phase)
  150. for epoch in range(theta_phase.shape[0]):
  151. shuffled_indices = rng.permutation(theta_phase.shape[1])
  152. shuffled_phase[epoch] = theta_phase[epoch, shuffled_indices]
  153. baseline_bootstrap[b] = pac_function(shuffled_phase, gamma_amplitude)
  155. return baseline_bootstrap
  158. def compute_session_aware_bootstrap(theta_phase, gamma_amplitude, pac_function, sessions, n_bootstraps, rng):
  159. """
  160. Compute bootstrap samples while preserving session structure.
  162. Parameters:
  163. - theta_phase: np.ndarray
  164. Array of theta phases.
  165. - gamma_amplitude: np.ndarray
  166. Array of gamma amplitudes.
  167. - pac_function: callable
  168. Function to compute PAC.
  169. - sessions: np.ndarray
  170. Array of session indices.
  171. - n_bootstraps: int
  172. Number of bootstrap samples.
  173. - rng: numpy.random.Generator
  174. Random number generator.
  176. Returns:
  177. - baseline_bootstrap: np.ndarray
  178. Array of bootstrap PAC values.
  179. """
  180. baseline_bootstrap = np.zeros(n_bootstraps)
  181. for b in range(n_bootstraps):
  182. # Shuffle within each session
  183. shuffled_indices = np.zeros(theta_phase.shape[0], dtype=int)
  184. for s in np.unique(sessions):
  185. session_indices = np.where(sessions == s)[0]
  186. shuffled_indices[session_indices] = session_indices[rng.permutation(len(session_indices))]
  187. # Compute the PAC value with shuffled phases
  188. baseline_bootstrap[b] = pac_function(theta_phase[shuffled_indices], gamma_amplitude)
  189. return baseline_bootstrap
  190. #@simple_timer
  192. def generate_single_cut_surrogate(data, random_seed=None):
  193. """
  194. Generate a single-point cut surrogate for a time series.
  196. This method cuts the time series at a single randomly chosen point and
  197. exchanges the two resulting segments, minimizing distortion of the
  198. original dynamics while destroying the specific relationship between
  199. different time points.
  201. Parameters:
  202. -----------
  203. data : np.ndarray
  204. Time series data to generate surrogate from with shape (epochs, times).
  205. random_seed : int or None
  206. Seed for the random number generator.
  208. Returns:
  209. --------
  210. surrogate : np.ndarray
  211. Surrogate time series with same shape as input data.
  212. """
  213. # Set random seed if provided
  214. rng = np.random.RandomState(random_seed)
  216. # Create a copy of the original data
  217. surrogate = data.copy()
  219. # Get the number of epochs and timepoints
  220. n_epochs, n_times = data.shape
  222. # For each epoch, cut at a different random point and swap segments
  223. for i in range(n_epochs):
  224. # Choose a random cut point (not at the edges)
  225. cut_point = rng.randint(1, n_times - 1)
  227. # Swap the two segments for this specific epoch
  228. surrogate[i] = np.concatenate((data[i, cut_point:], data[i, :cut_point]))
  230. return surrogate
  232. def compute_single_cut_bootstrap(theta_phase, gamma_amplitude, pac_function, n_bootstraps, rng):
  233. """
  234. Compute bootstrap samples using the single-point cut method.
  236. This applies the single-point cut method to the phase data only,
  237. while keeping the amplitude data intact, as we want to test
  238. specifically for phase-amplitude relationships.
  240. Parameters:
  241. - theta_phase: np.ndarray
  242. Array of theta phases with shape (epochs, times).
  243. - gamma_amplitude: np.ndarray
  244. Array of gamma amplitudes with shape (epochs, times).
  245. - pac_function: callable
  246. Function to compute PAC.
  247. - n_bootstraps: int
  248. Number of bootstrap samples.
  249. - rng: numpy.random.Generator
  250. Random number generator.
  252. Returns:
  253. - baseline_bootstrap: np.ndarray
  254. Array of bootstrap PAC values.
  255. """
  256. baseline_bootstrap = np.zeros(n_bootstraps)
  258. for b in range(n_bootstraps):
  259. # Generate a seed for each bootstrap iteration
  260. seed = rng.choice(np.arange(1, 10000))
  262. # Generate surrogate using single-point cut method
  263. surrogate_phase = generate_single_cut_surrogate(theta_phase, seed)
  265. # Flatten the 2D arrays to 1D for PAC computation if needed
  266. # This is necessary if the PAC function expects 1D arrays
  267. if pac_function.__name__ == 'compute_modulation_index':
  268. # For modulation index, we need to flatten the arrays
  269. flattened_phase = surrogate_phase.flatten()
  270. flattened_amplitude = gamma_amplitude.flatten()
  271. baseline_bootstrap[b] = pac_function(flattened_phase, flattened_amplitude)
  272. else:
  273. # For other PAC methods, we pass the 2D arrays directly
  274. baseline_bootstrap[b] = pac_function(surrogate_phase, gamma_amplitude)
  276. return baseline_bootstrap
  278. #@simple_timer
  279. def compute_pac_hilbert(data, sfreq, channel, theta_band=(5, 10), gamma_band=(60, 140),
  280. times=None, time_window=(0.150, 0.400), n_bootstraps=200,
  281. plot=False, verbose=True, durations=None,
  282. method='modulation_index', sessions=None, random_seed=42,
  283. surrogate_style='phase_shuffle', theta_data_prefiltered=None,
  284. gamma_data_prefiltered=None, offset_locked=False, post_fixation_extension = 0.075): # 75ms post-fixation extension):
  285. """
  286. Compute phase-amplitude coupling using the Hilbert transform for a specific channel.
  288. Parameters:
  289. - data: np.ndarray
  290. The MEG/EEG data array of shape (n_epochs, n_channels, n_times).
  291. Only used if theta_data_prefiltered and gamma_data_prefiltered are None.
  292. - sfreq: float
  293. The sampling frequency of the data.
  294. - channel: int
  295. The channel index to compute PAC for.
  296. - theta_band: tuple
  297. Frequency range for theta band (low_freq, high_freq).
  298. - gamma_band: tuple
  299. Frequency range for gamma band (low_freq, high_freq).
  300. - times: np.ndarray
  301. Array of time points corresponding to the data.
  302. - time_window: tuple
  303. Time window in seconds to isolate for PAC computation.
  304. - n_bootstraps: int
  305. Number of bootstraps for baseline computation.
  306. - plot: bool
  307. Whether to plot the PAC results.
  308. - verbose: bool
  309. Whether to print detailed diagnostics.
  310. - durations: np.ndarray
  311. Array of durations for each epoch.
  312. - method: str
  313. Method to use for PAC computation ('modulation_index', 'circular_linear_corr', or 'direct_pac').
  314. - sessions: np.ndarray
  315. Array of session indices to optionally guide the baseline computation.
  316. - random_seed: int
  317. Seed for random number generator to ensure reproducibility.
  318. - surrogate_style: str
  319. Method to generate surrogate data ('phase_shuffle', 'session_aware', or 'single_cut').
  320. - theta_data_prefiltered: np.ndarray or None
  321. Pre-filtered theta data of shape (n_epochs, n_channels, n_times). If provided,
  322. skips filtering step for theta band.
  323. - gamma_data_prefiltered: np.ndarray or None
  324. Pre-filtered gamma data of shape (n_epochs, n_channels, n_times). If provided,
  325. skips filtering step for gamma band.
  326. - offset_locked: bool
  327. If True, extract PAC window relative to fixation offset (end) instead of onset.
  328. Requires durations to be provided. The PAC window will be the last N samples
  329. before fixation end, where N = (time_window[1] - time_window[0]) * sfreq.
  330. - post_fixation_extension: float
  331. Additional time in seconds to extend the PAC window beyond fixation offset. only for offset_locked=True.
  333. Returns:
  334. - z_scores: float
  335. Z-scored phase-amplitude coupling value for the specified channel.
  336. """
  337. # Validate input parameters
  338. if method not in ['modulation_index', 'circular_linear_corr', 'direct_pac']:
  339. raise ValueError("Invalid method. Choose from 'modulation_index', 'circular_linear_corr', or 'direct_pac'.")
  341. if surrogate_style not in ['phase_shuffle', 'session_aware', 'single_cut']:
  342. raise ValueError("Invalid surrogate_style. Choose from 'phase_shuffle', 'session_aware', or 'single_cut'.")
  344. if verbose:
  345. print(f"Filtering data for channel {channel} in theta band {theta_band} and gamma band {gamma_band}")
  346. print(f"Time window: {time_window}")
  347. print("Data shape:", data.shape)
  348. print(f"Using surrogate style: {surrogate_style}")
  350. # Select appropriate PAC function based on method
  351. if method == 'modulation_index':
  352. pac_function = compute_modulation_index
  353. elif method == 'direct_pac':
  354. pac_function = direct_pac_ozturk
  355. else: # circular_linear_corr
  356. pac_function = circular_linear_correlation
  358. if verbose:
  359. print(theta_band, gamma_band)
  360. if data is not None:
  361. print(data.shape)
  363. # Use pre-filtered data if provided, otherwise filter now
  364. if theta_data_prefiltered is not None and gamma_data_prefiltered is not None:
  365. if verbose:
  366. print(f"Using pre-filtered data for channel {channel}")
  367. theta_data = theta_data_prefiltered[:, channel, :]
  368. gamma_data = gamma_data_prefiltered[:, channel, :]
  369. else:
  370. if verbose:
  371. print(f"Filtering data for channel {channel}")
  373. # Critical: compute bandwidths and set explicit transition bandwidths
  374. phase_bandwidth = theta_band[1] - theta_band[0]
  375. amp_bandwidth = gamma_band[1] - gamma_band[0]
  379. tic("filter theta")
  380. # Filter data for theta and gamma bands (causal filter, minimum phase)
  381. theta_data = filter_data(
  382. data[:, channel, :].astype(float),
  383. sfreq,
  384. theta_band[0],
  385. theta_band[1],
  386. method='fir',
  387. phase='minimum',
  388. n_jobs=PARALLEL_JOBS["filter"],
  389. verbose=0,
  390. )
  391. toc("filter theta")
  393. tic("filter gamma")
  394. gamma_data = filter_data(
  395. data[:, channel, :].astype(float),
  396. sfreq,
  397. gamma_band[0],
  398. gamma_band[1],
  399. method='fir',
  400. phase='minimum',
  401. n_jobs=PARALLEL_JOBS["filter"],
  402. verbose=0,
  403. )
  404. toc("filter gamma")
  406. if verbose:
  407. print(f"Theta data shape: {theta_data.shape}, Gamma data shape: {gamma_data.shape}")
  409. # Identify valid epochs (epochs that are long enough)
  410. # For offset-locked PAC, we need duration >= PAC window duration
  411. # For onset-locked PAC, we need duration > time_window[1]
  412. window_duration = time_window[1] - time_window[0]
  414. if offset_locked:
  415. valid_epochs = durations + post_fixation_extension >= window_duration
  416. if np.sum(valid_epochs) == 0:
  417. print(durations)
  418. raise ValueError(f"No valid epochs found. All epochs are shorter than the PAC window duration ({window_duration}s).")
  419. else:
  420. valid_epochs = durations > time_window[1]
  421. if np.sum(valid_epochs) == 0:
  422. raise ValueError("No valid epochs found. All epochs are shorter than the time window.")
  424. # Apply valid epoch mask
  425. theta_data = theta_data[valid_epochs, :]
  426. gamma_data = gamma_data[valid_epochs, :]
  427. valid_durations = durations[valid_epochs]
  429. # Print information about valid epochs
  430. if verbose:
  431. print(f"Valid epochs: {np.sum(valid_epochs)}")
  432. print(f"Offset-locked: {offset_locked}")
  434. # Update sessions array if provided
  435. if sessions is not None:
  436. sessions = sessions[valid_epochs]
  438. # Compute the Hilbert transform to get phase and amplitude
  439. theta_phase = np.angle(hilbert(theta_data, axis=1))
  440. gamma_amplitude = np.abs(hilbert(gamma_data, axis=1))
  442. # Apply time window extraction
  443. if offset_locked:
  444. # For offset-locked: Extract window ending at fixation offset + 75ms
  445. # This allows fixations as short as (window_duration - 75ms)
  446. n_samples = int(window_duration * sfreq)
  449. # Extract the last n_samples for each epoch
  450. theta_phase_windowed = np.zeros((theta_phase.shape[0], n_samples))
  451. gamma_amplitude_windowed = np.zeros((gamma_amplitude.shape[0], n_samples))
  453. for i in range(theta_phase.shape[0]):
  454. # Find the sample index corresponding to fixation end time
  455. # Duration is relative to fixation onset (t=0 in times vector)
  456. fixation_end_time = valid_durations[i]
  458. # PAC window ends at fixation_offset + 75ms
  459. pac_window_end_time = fixation_end_time + post_fixation_extension
  461. # Find the index in times vector closest to PAC window end
  462. end_idx = np.argmin(np.abs(times - pac_window_end_time))
  464. # Calculate window start: N samples before PAC window end
  465. start_idx = end_idx - n_samples
  467. # Ensure we don't exceed data bounds
  468. start_idx = max(0, start_idx)
  469. actual_end_idx = min(theta_phase.shape[1] - 1, end_idx)
  471. # Extract the window
  472. window_length = actual_end_idx - start_idx
  473. theta_phase_windowed[i, :window_length] = theta_phase[i, start_idx:actual_end_idx]
  474. gamma_amplitude_windowed[i, :window_length] = gamma_amplitude[i, start_idx:actual_end_idx]
  477. theta_phase = theta_phase_windowed
  478. gamma_amplitude = gamma_amplitude_windowed
  480. # Create a pseudo time mask for plotting (not used in offset mode)
  481. times_mask = np.ones(n_samples, dtype=bool)
  483. if verbose:
  484. print(f"Extracted window ending at fixation offset + 75ms")
  485. print(f" Window duration: {window_duration}s ({n_samples} samples)")
  486. print(f" Allows fixations >= {(window_duration - post_fixation_extension)*1000:.0f}ms")
  487. else:
  488. # For onset-locked: Use standard time masking
  489. times_mask = (times >= time_window[0]) & (times <= time_window[1])
  490. theta_phase = theta_phase[:, times_mask]
  491. gamma_amplitude = gamma_amplitude[:, times_mask]
  493. # Plot median of theta and gamma data if requested
  494. if plot:
  495. # For offset-locked, create adjusted times array for plotting
  496. if offset_locked:
  497. plot_times = np.linspace(-window_duration, 0, len(times_mask))
  498. else:
  499. plot_times = times
  500. plot_median_theta_gamma(theta_data, gamma_data, plot_times, times_mask, channel,
  501. theta_band, gamma_band,
  502. PLOTS_DIR=os.environ.get('PLOTS_DIR', './plots'))
  504. if verbose:
  505. print("Theta phase shape:", theta_phase.shape, "min:", np.min(theta_phase), "max:", np.max(theta_phase))
  506. print("Gamma amplitude shape:", gamma_amplitude.shape, "min:", np.min(gamma_amplitude), "max:", np.max(gamma_amplitude))
  507. print(f"Computing PAC values for channel {channel} using {method} method and {surrogate_style} surrogate style")
  509. # Plot phase histograms if requested
  510. if plot:
  511. plot_theta_phase_histogram(theta_phase, channel,
  512. PLOTS_DIR=os.environ.get('PLOTS_DIR', './plots'))
  513. plot_pac_histogram(theta_phase, gamma_amplitude, channel,
  514. PLOTS_DIR=os.environ.get('PLOTS_DIR', './plots'))
  516. # Compute PAC values
  517. # Flatten arrays for PAC computation if needed
  518. if method == 'modulation_index':
  519. theta_phase_flat = theta_phase.flatten()
  520. gamma_amplitude_flat = gamma_amplitude.flatten()
  521. pac_value = pac_function(theta_phase_flat, gamma_amplitude_flat)
  522. else:
  523. pac_value = pac_function(theta_phase, gamma_amplitude)
  525. if verbose:
  526. print(f"PAC value: {pac_value}")
  528. # Compute the baseline distribution with bootstrapping
  529. rng = np.random.default_rng(seed=random_seed)
  530. tic("baseline")
  532. # Choose surrogate method based on surrogate_style
  533. if surrogate_style == 'session_aware' and sessions is not None:
  534. # Session-aware shuffling
  535. if method == 'modulation_index':
  536. # For modulation index, use flattened arrays
  537. baseline_bootstrap = compute_session_aware_bootstrap(
  538. theta_phase_flat, gamma_amplitude_flat, pac_function, sessions, n_bootstraps, rng)
  539. else:
  540. baseline_bootstrap = compute_session_aware_bootstrap(
  541. theta_phase, gamma_amplitude, pac_function, sessions, n_bootstraps, rng)
  542. elif surrogate_style == 'single_cut':
  543. # Single-point cut method (Aru et al.)
  544. baseline_bootstrap = compute_single_cut_bootstrap(
  545. theta_phase, gamma_amplitude, pac_function, n_bootstraps, rng)
  546. else:
  547. # Regular phase shuffling
  548. if method == 'modulation_index':
  549. # For modulation index, use flattened arrays
  550. baseline_bootstrap = compute_phase_shuffle_bootstrap(
  551. theta_phase_flat, gamma_amplitude_flat, pac_function, n_bootstraps, rng)
  552. else:
  553. baseline_bootstrap = compute_phase_shuffle_bootstrap(
  554. theta_phase, gamma_amplitude, pac_function, n_bootstraps, rng)
  556. baseline_bootstrap = np.array(baseline_bootstrap)
  557. toc("baseline")
  559. # Fit a normal distribution to calculate mean and std
  560. tic("fit normal")
  561. baseline_normal = stats.norm.fit(baseline_bootstrap)
  562. baseline_mean, baseline_std = baseline_normal
  563. toc("fit normal")
  565. if verbose:
  566. print(f"Baseline bootstrap shape: {baseline_bootstrap.shape}")
  567. print(f"Baseline mean: {baseline_mean}")
  568. print(f"Baseline std: {baseline_std}")
  570. # Compute the z-score
  571. z_score = (pac_value - baseline_mean) / baseline_std
  573. # Plot results if requested
  574. if plot:
  575. plot_pac_results(baseline_bootstrap, baseline_mean, baseline_std, pac_value,
  576. channel, theta_band, gamma_band, surrogate_style,
  577. PLOTS_DIR=os.environ.get('PLOTS_DIR', './plots'))
  579. return z_score
  581. def compute_full_cross_frequency_pac_matrix(data, sfreq, significant_channels, theta_band, gamma_band, times,
  582. time_window, n_bootstraps=200, method='modulation_index',
  583. random_seed=42, steps_theta=1, steps_gamma=10, durations=None,
  584. sessions=None, surrogate_style='phase_shuffle', offset_locked=False):
  585. """
  586. Compute the full cross-frequency PAC matrix for all significant channels.
  588. Parameters:
  589. -----------
  590. data: np.ndarray
  591. MEG/EEG data array of shape (n_epochs, n_channels, n_times).
  592. sfreq: float
  593. Sampling frequency.
  594. significant_channels: list
  595. List of channel indices for which to compute PAC matrices.
  596. theta_band: tuple
  597. Frequency range for theta band.
  598. gamma_band: tuple
  599. Frequency range for gamma band.
  600. times: np.ndarray
  601. Time points corresponding to the data.
  602. time_window: tuple
  603. Time window for analysis.
  604. n_bootstraps: int
  605. Number of bootstraps for baseline computation.
  606. method: str
  607. Method for PAC computation ('modulation_index', 'circular_linear_corr', or 'direct_pac').
  608. random_seed: int
  609. Random seed for reproducibility.
  610. steps_theta: int
  611. Step size for theta frequency sweep.
  612. steps_gamma: int
  613. Step size for gamma frequency sweep.
  614. durations: np.ndarray
  615. Durations for each epoch.
  616. sessions: np.ndarray
  617. Session indices for each epoch.
  618. surrogate_style: str
  619. Method to generate surrogate data ('phase_shuffle', 'session_aware', or 'single_cut').
  620. offset_locked: bool
  621. If True, extract PAC window relative to fixation offset (end) instead of onset.
  623. Returns:
  624. --------
  625. fill_pac_results: dict
  626. Dictionary with channel indices as keys and PAC matrices as values.
  627. """
  628. # Compute the full cross-frequency PAC matrix for all significant channels
  629. theta_frequencies = np.arange(theta_band[0], theta_band[1]+1, steps_theta)
  630. gamma_frequencies = np.arange(gamma_band[0], gamma_band[1]+1, steps_gamma)
  632. # Prepare a results dict with channel as key and pac matrix as value
  633. fill_pac_results = {}
  635. for channel in significant_channels:
  636. pac_matrix = np.zeros((len(theta_frequencies), len(gamma_frequencies)))
  637. # Precompute the theta-gamma pairs to use joblib
  638. theta_gamma_pairs = []
  639. matrix_ids = []
  641. for i, theta_freq in enumerate(theta_frequencies):
  642. # Fixed bandwidth of 2 Hz for phase (±1 Hz around center frequency)
  643. low_theta = theta_freq - 1
  644. high_theta = theta_freq + 1
  646. for j, gamma_freq in enumerate(gamma_frequencies):
  647. # Variable bandwidth for amplitude based on phase frequency
  648. # Bandwidth = 2 × center frequency of the phase signal (see Aru et al. 2015)
  649. amp_bandwidth = 4 * theta_freq
  651. amp_bandwidth = max(10, amp_bandwidth) # Minimum bandwidth of 10 Hz
  653. low_gamma = gamma_freq - amp_bandwidth/2
  654. high_gamma = gamma_freq + amp_bandwidth/2
  656. # Ensure the frequency bounds are valid
  657. low_gamma = max(5, low_gamma) # Prevent negative or zero frequencies
  659. matrix_ids.append((i, j))
  660. theta_gamma_pairs.append((low_theta, high_theta, low_gamma, high_gamma))
  662. # Use joblib to parallelize the computation
  663. pac_values = Parallel(n_jobs=PARALLEL_JOBS["cross_freq"], verbose=1)(
  664. delayed(compute_pac_hilbert)(
  665. data, sfreq, channel, theta_band=(low_theta, high_theta), gamma_band=(low_gamma, high_gamma),
  666. times=times, time_window=time_window, n_bootstraps=n_bootstraps, method=method, durations=durations,
  667. sessions=sessions, random_seed=random_seed, verbose=False, surrogate_style=surrogate_style,
  668. offset_locked=offset_locked
  669. ) for low_theta, high_theta, low_gamma, high_gamma in tqdm(theta_gamma_pairs, desc="Computing PAC matrix", unit="pair")
  670. )
  672. # Fill the pac matrix
  673. for i, pac_value in enumerate(pac_values):
  674. pac_matrix[matrix_ids[i]] = pac_value
  676. fill_pac_results[channel] = pac_matrix
  678. return fill_pac_results
  680. # Utility functions for plotting
  681. def plot_median_theta_gamma(theta_data, gamma_data, times, times_mask, channel,
  682. theta_band, gamma_band, PLOTS_DIR='./plots'):
  683. """Plot the median of theta and gamma data over epochs."""
  684. # Ensure plot directory exists
  685. os.makedirs(os.path.join(PLOTS_DIR, "pac"), exist_ok=True)
  687. # Calculate median and 95% confidence intervals
  688. theta_median = np.median(theta_data, axis=0)
  689. gamma_median = np.median(gamma_data, axis=0)
  691. # Calculate bootstrap confidence intervals
  692. n_bootstraps = 1000
  693. theta_bootstraps = []
  694. gamma_bootstraps = []
  696. for _ in range(n_bootstraps):
  697. bootstrap_idx = np.random.choice(theta_data.shape[0], theta_data.shape[0], replace=True)
  698. theta_bootstraps.append(np.median(theta_data[bootstrap_idx], axis=0))
  699. gamma_bootstraps.append(np.median(gamma_data[bootstrap_idx], axis=0))
  701. theta_bootstraps = np.array(theta_bootstraps)
  702. gamma_bootstraps = np.array(gamma_bootstraps)
  704. theta_lower = np.percentile(theta_bootstraps, 2.5, axis=0)
  705. theta_upper = np.percentile(theta_bootstraps, 97.5, axis=0)
  706. gamma_lower = np.percentile(gamma_bootstraps, 2.5, axis=0)
  707. gamma_upper = np.percentile(gamma_bootstraps, 97.5, axis=0)
  709. # Create figure with two subplots
  710. sns.set_context("poster")
  711. fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10), sharex=True)
  713. # Plot theta data
  714. ax1.plot(times, theta_median, color='blue', label=f'Theta ({theta_band[0]}-{theta_band[1]} Hz)')
  715. ax1.fill_between(times, theta_lower, theta_upper, color='blue', alpha=0.3)
  716. ax1.axvspan(times[times_mask][0], times[times_mask][-1], color='gray', alpha=0.2, label='Analysis Window')
  717. ax1.set_ylabel('Amplitude')
  718. ax1.set_title(f'Median Theta Band Activity - Channel {channel}')
  719. ax1.legend(loc='upper right')
  720. ax1.grid(True, linestyle='--', alpha=0.7)
  722. # Plot gamma data
  723. ax2.plot(times, gamma_median, color='red', label=f'Gamma ({gamma_band[0]}-{gamma_band[1]} Hz)')
  724. ax2.fill_between(times, gamma_lower, gamma_upper, color='red', alpha=0.3)
  725. ax2.axvspan(times[times_mask][0], times[times_mask][-1], color='gray', alpha=0.2, label='Analysis Window')
  726. ax2.set_xlabel('Time (s)')
  727. ax2.set_ylabel('Amplitude')
  728. ax2.set_title(f'Median Gamma Band Activity - Channel {channel}')
  729. ax2.legend(loc='upper right')
  730. ax2.grid(True, linestyle='--', alpha=0.7)
  732. # Adjust layout and save
  733. plt.tight_layout()
  734. ch_name = f"MEG{channel + 1}"
  735. fname = f"median_theta_gamma_channel_{channel}.png"
  736. fig.savefig(os.path.join(PLOTS_DIR, "pac", fname))
  737. plt.close(fig)
  739. def plot_theta_phase_histogram(theta_phase, channel, PLOTS_DIR='./plots'):
  740. """Plot histogram of theta phase values."""
  741. # Ensure plot directory exists
  742. os.makedirs(os.path.join(PLOTS_DIR, "pac"), exist_ok=True)
  744. sns.set_context("poster")
  745. fig, ax = plt.subplots(1, 1, figsize=(8, 8))
  747. hist, bins = np.histogram(theta_phase.flatten(), bins=36)
  748. ax.bar(bins[:-1], hist)
  749. ax.set_xlabel("phase [rad]")
  750. ax.set_ylabel("count")
  751. ax.set_title("Theta phase histogram")
  753. fig.tight_layout()
  754. fname = f"theta_phase_hist_channel_{channel}.png"
  755. print("Saving histogram to", os.path.join(PLOTS_DIR, "pac", fname))
  756. fig.savefig(os.path.join(PLOTS_DIR, "pac", fname))
  757. plt.close(fig)
  759. def plot_pac_histogram(theta_phase, gamma_amplitude, channel, PLOTS_DIR='./plots'):
  760. """Plot histogram of gamma amplitude binned by theta phase."""
  761. # Ensure plot directory exists
  762. os.makedirs(os.path.join(PLOTS_DIR, "pac"), exist_ok=True)
  764. # Compute mean gamma amplitude per phase bin
  765. n_bins = 18
  766. phase_bins = np.linspace(-np.pi, np.pi, n_bins + 1)
  767. binned_amplitude = np.zeros(n_bins)
  769. for i in range(n_bins):
  770. indices = np.where((theta_phase >= phase_bins[i]) & (theta_phase < phase_bins[i + 1]))
  771. if len(indices[0]) > 0:
  772. binned_amplitude[i] = np.mean(gamma_amplitude[indices])
  774. # Normalize
  775. binned_amplitude += 1e-10 # Avoid division by zero
  776. binned_amplitude /= binned_amplitude.sum()
  778. # Plot
  779. fig, ax = plt.subplots(1, 1, figsize=(8, 8))
  780. ax.bar(np.arange(len(binned_amplitude)), binned_amplitude)
  781. ax.set_xlabel("phase bin")
  782. ax.set_ylabel("gamma amplitude [normalized]")
  783. ax.set_title("PAC histogram")
  785. fig.tight_layout()
  786. fname = f"mi_hist_{channel}.png"
  787. fig.savefig(os.path.join(PLOTS_DIR, "pac", fname))
  788. plt.close(fig)
  790. def plot_pac_results(baseline_bootstrap, baseline_mean, baseline_std, pac_values,
  791. channel, theta_band, gamma_band, PLOTS_DIR='./plots'):
  792. """Plot PAC results against baseline distribution."""
  793. # Ensure plot directory exists
  794. os.makedirs(os.path.join(PLOTS_DIR, "pac"), exist_ok=True)
  796. sns.set_context("poster")
  798. # Z-score the values
  799. baseline_bootstrap_z = (baseline_bootstrap - baseline_mean) / baseline_std
  800. pac_zscores = (pac_values - baseline_mean) / baseline_std
  802. # Plot
  803. fig, ax = plt.subplots(1, 1, figsize=(8, 8))
  804. ax.hist(baseline_bootstrap_z, bins=20, color="gray", alpha=0.5, label="baseline")
  805. ax.axvline(pac_zscores, color="r", label="PAC value")
  806. ax.axvline(np.mean(baseline_bootstrap_z), color="k", linestyle="--", label="baseline mean")
  807. ax.legend(frameon=False)
  808. ax.set_xlabel("PAC [z-scored]")
  810. # Channel name
  811. ch_name = f"MEG{channel + 1}"
  812. ax.set_title(f"theta-gamma PAC for channel {ch_name}")
  814. fig.tight_layout()
  815. fname = f"PAC_channel_{channel}_theta_{theta_band[0]}-{theta_band[1]}_gamma_{gamma_band[0]}-{gamma_band[1]}.png"
  816. fig.savefig(os.path.join(PLOTS_DIR, "pac", fname))
  817. plt.close(fig)

pac_functions.py at commit cd97339, no license · at the source

Overview

Authors: Philip Sulewski1,2, Carmen Amme1, Martin N. Hebart2,3,4, Peter König1,5, Tim C. Kietzmann1
ORCID iDs: Philip Sulewski, Martin N. Hebart, Peter König, Tim C. Kietzmann
  1. Institute of Cognitive Science, Osnabrück University,Osnabrück, Germany
  2. Vision and Computational Cognition Group, Max Planck Institute for Human Cognitive and Brain Sciences,Leipzig, Germany
  3. Department of Medicine, Justus Liebig University Giessen,Giessen, Germany
  4. Center for Mind, Brain and Behavior, Universities of Marburg, Giessen and Darmstadt,Marburg, Germany
  5. Department of Neurophysiology and Pathophysiology, Center of Experimental Medicine, University Medical Center Hamburg-Eppendorf,Hamburg, Germany
Institutions: Osnabrück University (Germany); Max Planck Institute for Human Cognitive and Brain Sciences (Germany); Justus-Liebig-Universität Gießen (Germany); Philipps University of Marburg (Germany); University Medical Center Hamburg-Eppendorf (Germany)
Journal: Nature neuroscience, volume 29, issue 6, pages 1488-1497
Dates: received 2 July 2025; accepted 27 March 2026; published online 25 May 2026; in print 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41593-026-02285-1 · PMID 42185573 · PMCID PMC13246442 · OpenAlex W7162332816
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: MEG (modality), human (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Connectivity, Statistics, Machine learning, Smoothing, state filtering, decompositions, Preprocessing, fMRI & imaging, Physiology & signal measures
Keywords: Learning and memory, Decision, Visual system, Attention, Computational neuroscience
MeSH: Brain*, Fixation, Ocular*, Memory*, Visual Perception*, Adult, Eye Movements, Female, Humans, Magnetoencephalography, Male, Neural Networks, Computer, Photic Stimulation, Time Factors, Young Adult (* major topic)
Topic: Visual Attention and Saliency Detection (Computer Vision and Pattern Recognition, Computer Science), according to OpenAlex
Funding: Studienstiftung des deutschen Volkes, the Federal Ministry of Education and Research (BMBF) Max Planck Society (MPG; Max-Planck-School of Cognition) Deutsche Forschungsgemeinschaft (DFG; German Research Foundation) - GRK 2340; Max Planck Society research group grant (to M.N.H.), the ERC Starting Grant COREDIM (ERC-2021-STG-101039712 to M.N.H.), a LOEWE Start Professorship from the Hessian Ministry of Higher Education, Research, Science and the Arts (to M.N.H.), and the Deutsche Forschungsgemeinschaft under Germany's Excellence Strategy (EXC 3066/1 “The Adaptive Mind”, Project No. 533717223 to M.N.H.); ERC Starting Grant TIME (101039524 to T.C.K.), The Osnabrück HPC received support from the Deutsche Forschungsgemeinschaft (456666331)
Citations: cited by 1 paper (Europe PMC); 60 references in the paper

Abstract

Before each of around 200,000 eye movements we make each day, the brain decides how long to fixate before shifting gaze to new information. Here we investigate this process using a large-scale scene-viewing experiment (4,080 natural scenes, five participants) that combines magnetoencephalography, eye tracking and a semantic captioning task. Using multivariate analysis of magnetoencephalography source-space patterns, behavioral analyses and artificial neural network (ANN) modeling, we show that longer fixations do not reflect prolonged visual processing but relate to downstream memory encoding. First, temporal variability of ventral stream representational dynamics did not explain variability in fixation duration. Second, fixation durations were anticorrelated with ANN-estimated patch classification difficulty. Third, fixation durations correlate positively with ANN-predicted patch memorability and caption-inclusion and co-occur with increased theta–gamma phase–amplitude coupling, particularly in frontal and hippocampal regions. These results indicate that eye-movement timing decisions are shaped by memory-encoding demands rather than by perceptual processing limits.

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

KietzmannLab/memdur

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: cd97339edc602335963a53e6e8880f25726c8645, 18 February 2026
Languages: Python (71), Shell (11), Jupyter (1)
Size: 88 files, 83 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, environment (setup.py, avs_gazetime/fix2cap/setup.py), 1 notebook
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (50 files), pandas (41 files), Matplotlib (30 files), seaborn (29 files), SciPy (22 files), statsmodels (12 files), MNE-Python (11 files), scikit-learn (9 files), h5py (4 files), Pillow (4 files), PyTorch (4 files), scikit-image (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
84 files
At the source: github.com/KietzmannLab/memdur

Code availability

The complete analysis code is publicly available via GitHub at https://github.com/KietzmannLab/memdur.

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

All derived data necessary to reproduce the analyses and figures are available via GRO.data at 10.25625/DDJ5C3 (ref. 60). 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 2, 28 September 2026

  • Publisher: n/a → Nature Portfolio

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 5 keywords, 14 MeSH terms, 3 funders, 52 references.

Cite

This paper

Sulewski, P., Amme, C., Hebart, M. N., König, P., & Kietzmann, T. C. (2026). Fixation duration on natural scenes is explained by memory encoding not processing demand. Nature neuroscience, 29(6), 1488-1497. https://doi.org/10.1038/s41593-026-02285-1

BibTeX

@article{sulewski2026fixation,
author = {Sulewski, Philip and Amme, Carmen and Hebart, Martin N. and König, Peter and Kietzmann, Tim C.},
title = {{Fixation duration on natural scenes is explained by memory encoding not processing demand}},
journal = {Nature neuroscience},
year = {2026},
month = may,
volume = {29},
number = {6},
pages = {1488--1497},
publisher = {Nature Portfolio},
issn = {1097-6256},
doi = {10.1038/s41593-026-02285-1},
url = {https://doi.org/10.1038/s41593-026-02285-1},
pmid = {42185573},
pmcid = {PMC13246442}
}

RIS

TY - JOUR
AU - Sulewski, Philip
AU - Amme, Carmen
AU - Hebart, Martin N.
AU - König, Peter
AU - Kietzmann, Tim C.
TI - Fixation duration on natural scenes is explained by memory encoding not processing demand
T2 - Nature neuroscience
J2 - Nat Neurosci
PY - 2026
DA - 2026/05/25
VL - 29
IS - 6
SP - 1488
EP - 1497
SN - 1097-6256
PB - Nature Portfolio
DO - 10.1038/s41593-026-02285-1
UR - https://doi.org/10.1038/s41593-026-02285-1
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41593-026-02285-1",
"type": "article-journal",
"title": "Fixation duration on natural scenes is explained by memory encoding not processing demand",
"container-title": "Nature neuroscience",
"author": [
{
"family": "Sulewski",
"given": "Philip"
},
{
"family": "Amme",
"given": "Carmen"
},
{
"family": "Hebart",
"given": "Martin N."
},
{
"family": "König",
"given": "Peter"
},
{
"family": "Kietzmann",
"given": "Tim C."
}
],
"container-title-short": "Nat Neurosci",
"volume": "29",
"issue": "6",
"page": "1488-1497",
"DOI": "10.1038/s41593-026-02285-1",
"PMID": "42185573",
"PMCID": "PMC13246442",
"ISSN": "1097-6256",
"publisher": "Nature Portfolio",
"URL": "https://doi.org/10.1038/s41593-026-02285-1",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
25
]
]
}
}

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.1523/jneurosci.0038-26.2026 [code]
Multidimensional Feature Tuning in Category Selective Areas of Human Visual Cortex.
Journal: The Journal of neuroscience : the official journal of the Society for Neuroscience
In common: h5py, Pillow, statsmodels, 7 other tools, 2 references, author Martin N Hebart
[2] doi:10.1038/s42003-026-10169-0 [code]
Shared representations in brains and models reveal a two-route cortical organization during scene perception.
Journal: Communications biology
In common: h5py, Pillow, statsmodels, 7 other tools, cognitive, 5 references
[3] doi:10.1038/s41597-025-05174-7 [code]
A large-scale MEG and EEG dataset for object recognition in naturalistic scenes
Journal: n/a
In common: MNE-Python, h5py, Pillow, 7 other tools, MEG, 4 references
[4] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: scikit-image, h5py, Pillow, 8 other tools, cognitive, 3 references
[5] doi:10.1162/imag.a.1309 [code]
Probing the content of semantic representations in body-selective regions.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: h5py, Pillow, statsmodels, 7 other tools, 4 references
[6] doi:10.1038/s41597-026-07248-6 [code]
A large-scale fMRI dataset for vision-language semantic association.
Journal: Scientific data
In common: scikit-image, h5py, Pillow, 6 other tools, 5 references
[7] doi:10.3389/fncom.2026.1786996 [code]
Schumann-anchored golden ratio organization of human neural oscillations.
Journal: Frontiers in computational neuroscience
In common: MNE-Python, h5py, Pillow, 7 other tools, 3 references
[8] doi:10.1038/s41467-026-76098-y [code]
A single computational objective can produce specialization of streams in visual cortex.
Journal: Nature communications
In common: scikit-image, h5py, Pillow, 8 other tools, 2 references
[9] doi:10.1162/imag.a.1299 [code]
A modular semantic-structural pipeline for visual decoding from primate spiking data via selective temporal integration.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: scikit-image, h5py, Pillow, 7 other tools, 3 references
[10] doi:10.1007/s12021-026-09803-3 [code]
NeuroFusion: A Unified Framework for Generalized Visual Stimulus Decoding from fMRI Across Datasets and Subjects.
Journal: Neuroinformatics
In common: MNE-Python, scikit-image, h5py, 7 other tools, 2 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.