OSCR

Non-invasive mapping of the temporal processing hierarchy in the human visual cortex.

Code ↔ Paper

7 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 7 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] § Methods › Forward modeling approach › Step 1: Estimate pRFs and visual field maps and clusters. ↔ pRFtime/figures.py, lines 389–432 · score 0.72 · V3ab, pIPS, aIPS, V2, LO, VO
  2. [2] § Methods › Forward modeling approach › Step 5: Compare measured and predicted responses. ↔ pRFtime/core.py, lines 185–268 · score 0.67 · gamma ratios, ridge regression, cross validated, fracridge, full model, beta
  3. [3] § Methods › Forward modeling approach › Step 1: Estimate pRFs and visual field maps and clusters. ↔ pRFtime/utils.py, the whole file · a weak match · score 0.60 · binarized stimulus, Gaussian models, visual space, pRFs, eccentricity, vertex
  4. [4] § Methods › Experimental procedure and preprocessing ↔ pRFtime/core.py, lines 127–173 · score 0.60 · overlapping spheres, vertices contribution, gain matrix, weights, signal, sensors
  5. [5] § Methods › Forward modeling approach › Step 3: Predict pRFs’ responses to MEG stimuli. ↔ pRFtime/core.py, lines 92–125 · score 0.57 · binarized stimulus, pRF models, predicted response, surface, vertices, matrix
  6. [6] § Methods › Method validation › Sensor type validation. ↔ pRFtime/core.py, lines 185–268 · score 0.54 · cross validated fitting, optimal, split, full model, variance explained, concatenated
  7. [7] § Methods › Forward modeling approach › Step 1: Estimate pRFs and visual field maps and clusters. ↔ run_pipeline.ipynb, lines 1–62 · score 0.53 · population receptive field, cortical location, Gaussian models, visual space, visual field, pRFs

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 · 432 lines · 25 KB · GPL-3.0 · 4 matches

  1. import numpy as np
  2. import random
  3. from fracridge import FracRidgeRegressorCV
  4. from sklearn.metrics import r2_score
  6. # pRFtime tools
  7. from pRFtime.utils import GaussianModel # model_class preset
  10. class pRFs():
  11. """
  12. Class to create pRF-based sensor-level predictions for regions of interest (ROIs).
  13. pRFs.create_sensor_prediction() is the main function to call, which calls upon the
  14. individual subseps (see below).
  15. """
  16. def __init__(self, prf_parameters,
  17. model_class=GaussianModel,
  18. model_kwargs=None,
  19. verbose=True,
  20. # optional
  21. mask = []
  22. ):
  23. """ Initalizing the pRFs class with a pRF parameters and pRF model to use.
  24. Arguments :
  25. prf_parameters (np.ndarray) : 2D array of shape (vertices, parameters) containing
  26. the parameters necessary to reconstruct the pRF models for each vertex (cortical location).
  27. Number parameters depends on the model_class used, and the parameters it
  28. requires to construct the pRF models.
  29. For the default model_class GaussianModel, 3 parameters are required:
  30. 1) x0, 2) y0 for pRF position, and 3) sigma for pRF's position of each vertex.
  31. model_class (cls) : model class in utils.py with a .name, and functions
  32. .generate() and .predict(). Default: utils.GaussianModel.
  33. model_kwargs (dict) : Dictionary with any keyword arguments the model_class needs.
  34. verbose (str) : True (Default) to print info.
  35. Optional:
  36. mask (np.ndarray) : boolean 1D array of shape (vertices,) which is False for
  37. vertices that should be excluded from the analysis (e.g. vertices with bad fits)
  38. No pRFs will be created for those to save computation time, and not weighted in
  39. for the sensor prediction creation.
  40. Intermediate Output-Aattributes :
  41. .prf_dict (dict) : Dictionary containing at least 'prfs' with reconstructed pRF models.
  42. For GaussianModel class the resulting 'prfs' array is of shape (vertices, pixel, pixel)
  43. containing 2D Gaussian models for each cortical location.
  44. .cortex_predictions (np.ndarray) : 2D array of shape (vertices, stimuli) with
  45. cortical predictions for each pRF, containing the predicted repsonses to each stimulus.
  46. Final Output-Attributes :
  47. .sensor_predictions (np.ndarray) : 3D array of shape (rois, sensors, stimuli) with the
  48. converted sensor-level pRF-based predictions for each region of interest (ROI).
  49. """
  50. self.prf_parameters = prf_parameters
  51. self.model = model_class() # Model class - see utils.py
  52. self.model_kwargs = model_kwargs # Arguments for model class
  54. self.verbose = verbose
  55. # Optional step
  56. self.mask = mask
  57. if len(self.mask) == 0 :
  58. self.mask = np.ones((self.prf_parameters.shape[0],)).astype("bool")
  59. assert self.mask.shape[0] == self.prf_parameters.shape[0]
  61. # Initiate output variables
  62. self.prf_dict = None
  63. self.cortex_predictions = None
  64. self.sensor_predictions = None
  66. def create_prf_models(self):
  67. """ Reconstruct the pRF models for each vertex, based on the
  68. prf_parmaters and model_class provided.
  69. Output:
  70. self.prf_dict (dict) : Dictionary containing at least 'prfs' with reconstructed pRF models.
  71. For GaussianModel class the resulting 'prfs' array is of shape (vertices, pixel, pixel)
  72. containing 2D Gaussian models for each cortical location.
  73. """
  74. if self.verbose: print(f"===== `create_prf_models` =====")
  76. # --- Optional steps ---
  77. # Apply mask if needed
  78. params = np.copy(self.prf_parameters)
  79. params = params[self.mask,:]
  80. if self.verbose:
  81. print(f"(Mask) Using {params.shape[0]} of {self.prf_parameters.shape[0]} vertices...")
  82. print(f"Creating {params.shape[0]} pRF models using '{self.model.name}' model...")
  84. # --- Create pRF models for desired model ---
  85. self.prf_dict = self.model.generate(params,
  86. **self.model_kwargs) # adding prf models to current class
  88. if self.verbose:
  89. print(f"Done.")
  90. print(f"|--> .prf_dict['prfs'] = {self.prf_dict['prfs'].shape} = ((masked-)vertices, pix, pix)")
  92. def create_cortex_predictions(self, design_matrix=np.zeros((0,0,0))):
  93. """ Create predicted responses to stimuli in design_matrix based on pRF models constructed.
  94. Arguments:
  95. design_matrix (np.ndarray) : For the GaussianModel, a 3D array of shape (pix, pix, stimuli)
  96. containing binarized stimulus. Pix is same as nr_pix used for pRF creation.
  97. Output:
  98. self.cortex_predictions (np.ndarray) : 2D array of shape (vertices, stimuli)
  99. Units are arbitrary.
  100. """
  101. # Get pRFs
  102. if self.prf_dict == None: self.create_prf_models () # separate function so that pRF models accesible to visualize in self.prf_dict
  104. if self.verbose:
  105. print(f"===== `create_cortex_predictions` =====")
  106. print(f"Creating '{self.model.name}' cortex predictions...")
  108. # Use model class predict function to be specific to the model
  109. self.cortex_predictions = self.model.predict(self.prf_dict, design_matrix)
  111. # Add predictions back to full number vertices
  112. full_preds = np.zeros((self.mask.shape[0], design_matrix.shape[-1])) # = (vertices, stimuli)
  113. full_preds[self.mask] = self.cortex_predictions.copy()
  114. self.cortex_predictions = full_preds
  116. # Check for NaN (can happen for DN model for example)
  117. nan_vertices = np.unique(np.where(np.isnan(self.cortex_predictions))[0])
  118. if len(nan_vertices) > 0:
  119. if self.verbose: print(f"Setting predictions of {len(nan_vertices)} vertices with NaNs in their surface prediction to 0.")
  120. self.cortex_predictions[nan_vertices,:] = 0
  121. assert not np.any(np.isnan(self.cortex_predictions))
  123. if self.verbose:
  124. print("Done.")
  125. print(f"|--> .cortex_predictions = {self.cortex_predictions.shape} = (vertices, stimuli)")
  127. def create_sensor_predictions(self, gain_matrix=np.zeros((0,0)),
  128. design_matrix=np.zeros((0,0,0)),
  129. roi_masks=[]):
  130. """ Convert cortex predictions to sensor-level for each roi in roi_masks, using the
  131. weights provided in the gain_matrix.
  132. Arguments:
  133. gain_matrix (np.ndarray) : 2D array of shape (sensors, vertices)
  134. containing weights of how much each vertex contributes to the signal
  135. measured in a given sensor. For example obtained using the
  136. Overlapping Spheres model provided by Brainstorm (https://neuroimage.usc.edu/brainstorm/Tutorials/HeadModel).
  137. design_matrix (np.ndarray) : shape depends on stimuli used. For 2D Gaussian model
  138. and 2D visual stimulus example, e.g. (pixel, pixel, stimuli), where pixel number
  139. corresponds to pixel number of the grid used to construct the pRFs (nr_pix).
  140. roi_masks (np.ndarray) : boolean 2D array of shape (rois, vertices)
  141. which is True for vertices belonging to a given region of interest (ROI).
  142. Output :
  143. self.sensor_predictions (np.ndarray) : 3D array of shape (rois, sensors, stimulil)
  144. containing the sensor-level pRF-based predictions for each ROI.
  145. Units same as gain_matrix provided.
  146. """
  147. if self.cortex_predictions == None: self.create_cortex_predictions(design_matrix=design_matrix)
  148. assert gain_matrix.shape[-1] == self.cortex_predictions.shape[0], f"Gain matrix's second dimension must align to number of vertices ({self.cortex_predictions.shape[0]})"
  150. if self.verbose: print(f"===== `create_sensor_predictions` =====")
  152. # Convert for each ROI separately
  153. if len(roi_masks)==0:
  154. roi_masks = np.ones((self.cortex_predictions.shape[0]),).astype('bool')[np.newaxis, ...] # = (1, vertices)
  156. # --- Loop over roi masks to create each sensor prediction ---
  157. # Initiate output
  158. nr_rois, nr_vertices = roi_masks.shape
  159. nr_sensors = gain_matrix.shape[0]
  160. nr_stimuli = design_matrix.shape[-1]
  161. self.sensor_predictions = np.zeros((nr_rois, nr_sensors, nr_stimuli))
  162. if self.verbose: print(f"Creating {nr_rois}-roi sensor predictions...")
  164. for r in range(nr_rois):
  165. roi_mask = roi_mask = np.logical_and(roi_masks[r], self.mask) # = (vertices,) True where in mask and in roi
  166. if self.verbose: print(f"(Mask:) roi-{r} is using {roi_mask.sum()} of originally {roi_masks[r].sum()} vertices...")
  167. roi_hm = gain_matrix[:,roi_mask].copy() # = (sensors, masked_roi vertices)
  168. roi_sensor_preds = np.matmul(roi_hm, self.cortex_predictions[roi_mask, :]) # = (sensors, stimuli) using only vertices in (roi-)mask
  169. self.sensor_predictions[r,:,:] = roi_sensor_preds
  171. if self.verbose:
  172. print("Done.")
  173. print(f"|--> .sensor_predictions = {self.sensor_predictions.shape} = (rois, sensors, stimuli)")
  176. class Fitting():
  177. """
  178. Class to fit sensor predictions (created by pRFs class) to sensor data in a cross-validated
  179. ridge regression.
  180. Fitting.run() is the main function to call and execute all necessary substeps.
  181. Substeps could be called individually - e.g. to repeat the fitting procedure x times
  182. with new nr_sets averages to provide a Confidence Interval, using the same set of
  183. predictions.
  184. """
  185. def __init__(self, sensor_data, sensor_predictions,
  186. nr_sets=4, fracs=np.arange(0.0, 1.0, 0.1),
  187. verbose=True, **kwargs):
  188. """ Initializing object with input sensor data and settings for ridge regression.
  189. Arguments:
  190. sensor_data (list with np.ndarray) : list of length [stimuli,] each 3D arrays of
  191. shape (sensors, trials per stimulus, samples) containing the sensors responses to
  192. each stimulus presentation (trials) for each recorded timepoint (sample).
  193. sensor_predictions (np.ndarray) : 3D array of shape (rois, sensors, stimuli)
  194. containing sensor predictions to each stimuli for each ROI.
  195. Generated with pRFs.create_sensor_predictions() function.
  196. nr_sets (int, default 4) : determines in how many sets the sensor data is split for
  197. cross-validated fitting. Ridge regression will determine
  198. optimal parameters on nr_sets-1 sets, and test on the last set.
  199. E.g. to perform k-fold optimization on 3 sets, nr_sets should be 4.
  200. fracs (np.ndarray) : gamma ratios (fractions) for fracridge to test to optimize ridge regression.
  201. See https://nrdg.github.io/fracridge/ for in depth explanation.
  202. Optional kwargs:
  203. For repeatable analysis:
  204. n_set_inds_per_stim double list with (np.ndarray) : List of length [stimuli,], with list
  205. of length [nr_sets,] containing a 1D array with indices of the trials to use for a
  206. given stimulus and set. To perform analysis on same averaged data sets, otherwise, Fitting
  207. class calls upon ._generate_n_set_indices() to create a new random set of trial indices
  208. appropriate for the stimulus trials of the provided dataset.
  209. To use a subset of given data dimension:
  210. stimulus_indices (np.ndarray) : 1D array with indices of stimuli to use
  211. sensor_indices (np.ndarray) : 1D array with indices of sensors to use
  212. sample_indices (np.ndarray) : 1D array with indices of samples to use
  213. roi_indices (np.ndarray) : 1D array with indices of ROIs to use
  214. Output-Attribute:
  215. Full-model performance over time:
  216. .r2s_full_model (np.ndarray) : 1D array of shape (samples,) containing R-squared values of the
  217. variance explained of the full model (all rois/predictors) in the sensor_data.
  218. Regression parameters over time:
  219. .alphas (np.ndarray) : 1D array of shape (samples,) containing the alpha (regularization)
  220. parameter that was found optimal for a given sample.
  221. .gammas (np.ndarray) : 1D array of shape (samples,) containing the frac (gamma ratio) value
  222. that was fond optimal for a given sample.
  223. ROI performance over time:
  224. .r2s_per_roi (np.ndarray) : 2D array of shape (rois, samples) containing the R-squared values of
  225. each ROI in explaining the sensor_data at a given sample.
  226. .betas_per_roi (np.ndarray) : 2D array of shape (rois, samples) containing the regression weights
  227. of each ROI for a given sample.
  228. """
  229. self.sensor_data = sensor_data
  230. self.sensor_predictions = sensor_predictions
  231. # CV settings
  232. self.nr_sets = nr_sets
  233. self.k_folds = self.nr_sets - 1 # one of the sets if left out for independent testing of the ridge parameters found during k-fold cv
  234. self.fracs = fracs
  235. self.verbose = verbose
  237. # Unpack kwargs
  238. for key, value in kwargs.items():
  239. setattr(self, key, value)
  241. # Get info on dimensions (depending on whether users wants slicing)
  242. if not hasattr(self, 'stimulus_indices'):
  243. self.stimulus_indices = np.arange(len(sensor_data)) # all stimuli in dataset
  244. if not hasattr(self, 'sensor_indices'):
  245. self.sensor_indices = np.arange(sensor_data[0].shape[0]) # all sensors in dataset
  246. if not hasattr(self, 'sample_indices'):
  247. self.sample_indices = np.arange(sensor_data[0].shape[-1]) # all samples in dataset
  248. if not hasattr(self, 'roi_indices'):
  249. self.roi_indices = np.arange(sensor_predictions.shape[0])
  251. self.nr_stimuli = len(self.stimulus_indices)
  252. self.nr_sensors = len(self.sensor_indices)
  253. self.nr_samples = len(self.sample_indices)
  254. self.nr_rois = len(self.roi_indices)
  255. self.nr_datapoints = int(self.nr_stimuli * self.nr_sensors)
  257. # Preset intermediate variables
  258. if not hasattr(self, 'n_set_inds_per_stim'):
  259. self.n_set_inds_per_stim = None # for indices for data averaging
  260. self.average_data = None # for averaged sensor data
  261. self.k_fold_indices = None # for k-fold regression
  262. self.predictions = None # for reshaped (concatenated) predictions
  263. # Results
  264. self.gammas = None
  265. self.alphas = None
  266. self.r2s_full_model = None
  267. self.r2s_per_roi = None
  268. self.betas_per_roi = None
  270. # ======================================================
  271. def run(self):
  272. """ Execute the full fitting pipeline in sequence. """
  273. self._reshape_predictions()
  274. self._generate_n_set_indices()
  275. self._average_data()
  276. self._prepare_k_fold_indices()
  277. self._fit_data()
  278. # ======================================================
  280. # ----- Private Methods -----
  281. def _reshape_predictions(self):
  282. """ Step 1: Reshape predictions and concatenate over (subselected) stimuli and sensors.
  283. Output:
  284. .predictions (rois, stimuli*sensors) with concatenated sensor predictions per ROI
  285. """
  286. self.predictions = np.array([np.concatenate(np.array([[self.sensor_predictions[roi,sensor,stim] for stim in self.stimulus_indices]
  287. for sensor in self.sensor_indices]))
  288. for roi in self.roi_indices]) # = (rois, stimuli*sensors)
  290. if self.verbose: print(f"1: Predictions reshaped to: {self.predictions.shape} (rois, stimuli*sensors)")
  292. def _generate_n_set_indices(self):
  293. """ Step 2: Create n sets of random indices for trial averaging of data.
  294. The function accounts for the fact that different stimuli might have
  295. different number of trials; i.e. shuffles trial indices per stimulus and cuts into n_sets needed.
  296. 'n_set_inds_per_stim' can instead be given to object upon initiation.
  297. Output:
  298. .n_set_inds_per_stim (double list with array) [stimuli,][nr_sets,](trialsperstim)
  299. so each stimulus (with potentially different number of trials), has now n sets
  300. of randomly shuffled trialsthat can be used for averaging
  301. """
  303. if self.n_set_inds_per_stim != None:
  304. # Check shape required
  305. assert len(self.n_set_inds_per_stim)==self.nr_stimuli and len(self.n_set_inds_per_stim[0])==self.nr_sets, \
  306. f"'n_set_inds_per_stim' should be double list [nr_stimuli,] each [nr_sets,] with each 1D array of indices for trial averaging."
  308. if self.verbose: print(f"2: Using {self.nr_sets}-sets of indices for data averaging.") # provided - or from previous call of object
  309. else:
  310. # Create indices for averaging data to n_sets
  311. n_set_inds_per_stim = []
  312. for stim in self.stimulus_indices:
  313. nr_trials = self.sensor_data[stim].shape[1]
  314. cur_inds = np.arange(nr_trials)
  315. random.shuffle(cur_inds)
  316. inds_per_n = np.array_split(cur_inds, self.nr_sets)
  317. n_set_inds_per_stim.append(inds_per_n)
  318. self.n_set_inds_per_stim = n_set_inds_per_stim # [nr_stimuli,][n_sets,](trialsperstim/n_sets,)
  320. if self.verbose: print(f"|- Generated {self.nr_sets} sets of indices for random data averaging for each stimulus.")
  322. def _average_data(self):
  323. """ Step 3: Perform data averaging using the generated indices.
  324. Output:
  325. .average_data [nr_sets,][samples,](stimuli*sensors); each average over specific set of
  326. trials for a given set, concatenated for stimuli and sensors to fit all datapoints at
  327. a given sample.
  328. """
  329. if self.average_data == None: # skip if already in object
  330. n_set_avg_per_sample = []
  331. for n in range(self.nr_sets):
  332. # Take average over subset of trials per stim
  333. avg_per_stim = [np.mean(self.sensor_data[stim][:, self.n_set_inds_per_stim[s][n], :], axis=1)
  334. for s, stim in enumerate(self.stimulus_indices)] # = [stimuli,](sensors,samples) -> averaged over trial's n sets' trial indices
  335. # Concatenate averages over (subselected) stimuli and sensors and order by samples
  336. concavg_per_sample = [np.concatenate( np.array([[avg_per_stim[stim][sensor,sample] for stim in self.stimulus_indices]
  337. for sensor in self.sensor_indices]) )
  338. for sample in self.sample_indices]
  339. n_set_avg_per_sample.append(concavg_per_sample)
  340. self.average_data = n_set_avg_per_sample
  342. if self.verbose: print(f"3: Data averaging for {self.nr_sets} sets completed.")
  344. def _prepare_k_fold_indices(self):
  345. """ Step 4: Generate k-fold indices for CV iterator in ridge regression.
  346. Output:
  347. .k_fold_indices : list [k_folds,] with each tuple (ktrain_inds, ktest_inds),
  348. where ktrain_inds (datapoints, k_folds-1)
  349. and ktest_inds (datapoints)
  350. and each k_fold item has a different test set that is used
  351. """
  353. if self.verbose: print(f"4: Using {self.k_folds}-fold CV to define ridge parameters on training set...")
  355. ks = np.arange(self.k_folds)
  356. test_ks = ks[::-1] # we leave out one set for testing parameters within one fold; i.e. every fold has a different test set and we make it loop from last to first index
  357. train_ks = [np.where(np.invert(ks == test_k))[0]
  358. for test_k in test_ks]
  359. inds_per_set = [np.arange((self.nr_datapoints*k), (self.nr_datapoints*(k+1)))
  360. for k in range(self.k_folds)] # = [k,](datapoints,) -> indices total up to nr_datapoints*k
  361. k_fold_indices = []
  362. for fold in range(self.k_folds):
  363. # First x rows are concatenated for training
  364. ktrain_inds = np.concatenate([inds_per_set[cur_k] for cur_k in train_ks[fold]]) # = (datapoints*k_folds-1,)
  365. # Last rows of indices is used for test of current fold
  366. ktest_inds = inds_per_set[test_ks[fold]]
  367. # Save both as tuple
  368. k_fold_indices.append((ktrain_inds, ktest_inds))
  369. self.k_fold_indices = k_fold_indices
  371. if self.verbose: print(f"|- K-fold indices prepared.")
  373. def _fit_data(self):
  374. """ Step 5: Loop over samples to fit predictions on data.
  375. Output:
  376. Full-model performance over time:
  377. .r2s_full_model (np.ndarray) : 1D array of shape (samples,) containing R-squared values of the
  378. variance explained of the full model (all rois/predictors) in the sensor_data.
  379. Regression parameters over time:
  380. .alphas (np.ndarray) : 1D array of shape (samples,) containing the alpha (regularization)
  381. parameter that was found optimal for a given sample.
  382. .gammas (np.ndarray) : 1D array of shape (samples,) containing the frac (gamma ratio) value
  383. that was fond optimal for a given sample.
  384. ROI performance over time:
  385. .r2s_per_roi (np.ndarray) : 2D array of shape (rois, samples) containing the R-squared values of
  386. each ROI in explaining the sensor_data at a given sample.
  387. .betas_per_roi (np.ndarray) : 2D array of shape (rois, samples) containing the regression weights
  388. of each ROI for a given sample.
  389. """
  391. if self.verbose: print(f"5: Fitting {self.nr_rois} rois, {self.nr_samples} samples and {self.nr_datapoints} datapoints ({self.nr_stimuli} stimuli * {self.nr_sensors} sensors) ...")
  393. # --- Reshape predictions --- (we fit the same X for all samples)
  394. X_test = self.predictions.T # = (datapoints, rois)
  395. X_train = np.vstack([X_test for k in range(self.k_folds)]) # (datapoints*k_folds, rois)
  397. # --- Initiate shaped output ---
  398. self.gammas = np.zeros((self.nr_samples,))
  399. self.alphas = np.zeros((self.nr_samples,))
  400. self.r2s_full_model = np.zeros((self.nr_samples,))
  401. self.r2s_per_roi = np.zeros((self.nr_rois, self.nr_samples))
  402. self.betas_per_roi = np.zeros((self.nr_rois, self.nr_samples))
  404. # --- Loop over samples ---
  405. for sample in range(self.nr_samples): # data is already shaped, so we loop through all (subselected) samples
  407. # Select current samples' data averages
  408. y_test = self.average_data[-1][sample] # = (stimuli*sensors,)
  409. y_train = np.concatenate([self.average_data[k][sample] for k in range(self.k_folds)]) # = ((stimuli*sensors)*k_folds,)
  411. # Use training data (y_train) for k-fold validation (our own random average sets we created)
  412. frr = FracRidgeRegressorCV(cv=self.k_fold_indices)
  413. frr.fit(X_train, y_train, frac_grid=self.fracs)
  414. self.frr = frr
  415. # Calculate full model performance with chosen parameters (gamma, alpha, betas) on left out test set
  416. yhat = frr.predict(X_test)
  417. self.r2s_full_model[sample] = r2_score(y_test, yhat) # = float
  418. # Save belonging parameters
  419. self.gammas[sample] = frr.best_frac_ # = float
  420. self.alphas[sample] = frr.alpha_[0][0] # = float
  421. self.betas_per_roi[:,sample] = frr.coef_
  423. # Calculate performance PER ROI (aka regressors / predictor)
  424. r2s = []
  425. for r in range(self.nr_rois): # again loop over all, since already subselected
  426. yhat_other = yhat - (X_test[:,r] * self.betas_per_roi[r][sample])
  427. rss = np.sum( (y_test - yhat)**2 ) # = float // aka y_test - yhat_pther - yhat_roi
  428. tss = np.sum( (y_test - yhat_other)**2 ) # to account for other rois in data when computing roi
  429. r2s.append( 1 - (rss/tss) )
  430. self.r2s_per_roi[:,sample] = np.array(r2s)
  432. if self.verbose: print(f"|- Fitting process completed.")

core.py at commit d415a5a, under GPL-3.0 · at the source

Overview

Authors: Katharina Eickhoff1,2,3, Arjan Hillebrand4,5,6, Tomas Knapen1,2,3, Maartje C. de Jong1,2, Serge O. Dumoulin1,2,3,7
ORCID iDs: Katharina Eickhoff, Tomas Knapen, Maartje C. de Jong, Serge O. Dumoulin
  1. Spinoza Centre for Neuroimaging, Amsterdam, the Netherlands
  2. Computational Cognitive Neuroscience and Neuroimaging, Netherlands Institute for Neuroscience, Amsterdam, the Netherlands
  3. Experimental and Applied Psychology, Vrije Universiteit, Amsterdam, the Netherlands
  4. Clinical Neurophysiology and Magnetoencephalography Centre, Amsterdam UMC, Amsterdam, the Netherlands
  5. Amsterdam Neuroscience, Brain Imaging, Amsterdam, the Netherlands
  6. Amsterdam Neuroscience, Systems and Network Neuroscience, Amsterdam, the Netherlands
  7. Experimental Psychology, Utrecht University, Utrecht, the Netherlands
Institutions: Netherlands Institute for Neuroscience (Netherlands); Spinoza Centre for Neuroimaging (Netherlands); Vrije Universiteit Amsterdam (Netherlands); Amsterdam Neuroscience (Netherlands); Amsterdam University Medical Centers (Netherlands); Utrecht University (Netherlands)
Journal: PLoS computational biology, volume 22, issue 7, article e1014434
Dates: received 26 May 2025; accepted 11 June 2026; published online 10 July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pcbi.1014434 · PMID 42430453 · PMCID PMC13379088 · OpenAlex W4410325642
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.05.12.653426
Status: code verified
Categories: fMRI (modality), MEG (modality), human (organism), systems (subfield)
Methods: Statistics, Machine learning, Preprocessing, Connectivity, Physiology & signal measures
MeSH: Brain Mapping*, Visual Cortex*, Visual Perception*, Adult, Computational Biology, Female, Humans, Magnetic Resonance Imaging, Magnetoencephalography, Male, Models, Neurological, Visual Fields (* major topic)
Journal subjects: Biology and Life Sciences, Neuroscience, Brain Mapping, Functional Magnetic Resonance Imaging, Medicine and Health Sciences, Diagnostic Medicine, Diagnostic Radiology, Magnetic Resonance Imaging, Research and Analysis Methods, Imaging Techniques, Radiology and Imaging, Neuroimaging, Cognitive Science, Cognitive Psychology, Perception, Sensory Perception, Vision, Psychology, Social Sciences, Computer and Information Sciences, Software Engineering, Preprocessing, Engineering and Technology, Equipment, Measurement Equipment, Magnetometers, Magnetoencephalography, Physiology, Sensory Physiology, Visual System, Sensory Systems, Anatomy, Brain, Visual Cortex
Topic: Neural Networks and Applications (Artificial Intelligence, Computer Science), according to OpenAlex
Funding: Nederlandse Organisatie voor Wetenschappelijk Onderzoek (016.Vici.185.050)
Citations: not cited yet (Europe PMC); 78 references in the paper

Abstract

Vision, and brain processing more broadly, is inherently dynamic across space and time, so understanding brain function requires consideration of both spatial and temporal dimensions. However, simultaneously capturing the fine spatial details and the rapid temporal dynamics of visual processing remains a major challenge, resulting in a gap in our understanding of spatiotemporal dynamics. Here, we introduce a forward modeling technique that bridges high-spatial resolution fMRI with high-temporal resolution MEG, enabling us to non-invasively estimate different levels of the visual hierarchy in humans and their involvement in visual processing with millisecond precision. Using fMRI, levels of the visual hierarchy were identified by measuring individuals’ population receptive fields and determining visual field maps. We predicted how much the activity patterns in each visual field map would contribute to brain responses measured with MEG. By comparing these predicted responses with the measured MEG responses, we assessed how much a given visual field map contributed to the measured MEG response, and, most importantly, when. We combined information from all MEG sensors and revealed a cortical processing hierarchy across visual field maps. We validated the method using cross-validations and demonstrated that the model generalized across MEG sensor types, stimulus shapes, and was robust to the number of visual field maps included in the model. The primary visual cortex captured most of the variance in the MEG sensors and did so earlier in time than extrastriate regions. We effectively combined the advantages of two very different neuroimaging techniques, opening avenues for answering research questions that require recordings with high spatiotemporal detail. By bridging traditionally separate areas of research, our approach helps close longstanding gaps in our understanding of brain function.

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

kateic/pRFtime

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: d415a5afb9b87860f688762ea0c9b1443a1f6d47, 13 May 2025
Languages: Python (5), Jupyter (1)
Size: 8 files, 6 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: README, license file, environment (setup.py), 1 notebook
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (4 files), Matplotlib (2 files), NetworkX (2 files), seaborn (2 files), scikit-learn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
8 files
At the source: github.com/kateic/pRFtime

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;
  • 6 scripts, each with its path and the digest of its content;
  • 7 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data Availability

The code used for the analysis is publicly available at https://github.com/kateic/pRFtime. The minimal anonymized data necessary to replicate these study findings have been deposited in DANS Data Station Life Sciences (https://doi.org/10.17026/LS/AKGXRM; K. Eickhoff; A. Hillebrand; T. Knapen; M.C. de Jong; S.O. Dumoulin, 2026, “Replication Data for: Non-invasive mapping of the temporal processing hierarchy in the human visual cortex”). The raw MRI and MEG data is considered personal data pursuant to the General Data Protection Regulation (GDPR) and can only be shared as a de-identified data set based on and subject to the Netherlands Institute for Neurosciences of the Royal Netherlands Academy of Sciences policies.

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

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 12 MeSH terms, 1 funder, 78 references.

Cite

This paper

Eickhoff, K., Hillebrand, A., Knapen, T., de Jong, M. C., & Dumoulin, S. O. (2026). Non-invasive mapping of the temporal processing hierarchy in the human visual cortex. PLoS computational biology, 22(7), e1014434. https://doi.org/10.1371/journal.pcbi.1014434

BibTeX

@article{eickhoff2026non,
author = {Eickhoff, Katharina and Hillebrand, Arjan and Knapen, Tomas and de Jong, Maartje C. and Dumoulin, Serge O.},
title = {{Non-invasive mapping of the temporal processing hierarchy in the human visual cortex}},
journal = {PLoS computational biology},
year = {2026},
month = jul,
volume = {22},
number = {7},
pages = {e1014434},
publisher = {PLOS},
issn = {1553-734X},
doi = {10.1371/journal.pcbi.1014434},
url = {https://doi.org/10.1371/journal.pcbi.1014434},
pmid = {42430453},
pmcid = {PMC13379088}
}

RIS

TY - JOUR
AU - Eickhoff, Katharina
AU - Hillebrand, Arjan
AU - Knapen, Tomas
AU - de Jong, Maartje C.
AU - Dumoulin, Serge O.
TI - Non-invasive mapping of the temporal processing hierarchy in the human visual cortex
T2 - PLoS computational biology
J2 - PLoS Comput Biol
PY - 2026
DA - 2026/07/10
VL - 22
IS - 7
SP - e1014434
SN - 1553-734X
PB - PLOS
DO - 10.1371/journal.pcbi.1014434
UR - https://doi.org/10.1371/journal.pcbi.1014434
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pcbi.1014434",
"type": "article-journal",
"title": "Non-invasive mapping of the temporal processing hierarchy in the human visual cortex",
"container-title": "PLoS computational biology",
"author": [
{
"family": "Eickhoff",
"given": "Katharina"
},
{
"family": "Hillebrand",
"given": "Arjan"
},
{
"family": "Knapen",
"given": "Tomas"
},
{
"family": "de Jong",
"given": "Maartje C."
},
{
"family": "Dumoulin",
"given": "Serge O."
}
],
"container-title-short": "PLoS Comput Biol",
"volume": "22",
"issue": "7",
"page": "e1014434",
"DOI": "10.1371/journal.pcbi.1014434",
"PMID": "42430453",
"PMCID": "PMC13379088",
"ISSN": "1553-734X",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pcbi.1014434",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
10
]
]
}
}

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.1162/imag.a.1210 [code]
Modeling 2D spatio-tactile population receptive fields of the fingertip in human primary somatosensory cortex.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: fMRI, systems, 7 references
[2] doi:10.1371/journal.pcbi.1013007 [code]
Traveling waves in the human visual cortex: An MEG-EEG model-based approach
Journal: n/a
In common: Matplotlib, NumPy, MEG, fMRI, systems, 5 references
[3] doi:10.21203/rs.3.rs-9940836/v1 [code]
Representational Tuning Models: Parametric Encoding Within Arbitrary Stimulus Domains
Journal: Research Square (preprint)
In common: seaborn, scikit-learn, Matplotlib, 1 other tool, fMRI, systems, 4 references
[4] doi:10.7554/elife.108408 [code]
Frequency and laminar profile of feature-specific visual activity revealed by interleaved EEG-fMRI.
Journal: eLife
In common: seaborn, Matplotlib, NumPy, fMRI, systems, 4 references
[5] doi:10.1038/s41467-026-75662-w [code]
Distinct Roles of Deep and Superficial Cortical Layers in Tone Prediction, Comparison, and Adaptation in Human Auditory Cortices.
Journal: Nature communications
In common: seaborn, scikit-learn, Matplotlib, 1 other tool, 4 references
[6] doi:10.1093/cercor/bhag075 [code]
Cortical dynamics of icon perception: effects of concreteness and attractiveness.
Journal: Cerebral cortex (New York, N.Y. : 1991)
In common: scikit-learn, Matplotlib, NumPy, MEG, 4 references
[7] doi:10.1016/j.neuroimage.2026.122051 [code]
Determining hemispheric language dominance from MEG beta-power modulations: Concordance with fMRI.
Journal: NeuroImage
In common: scikit-learn, Matplotlib, NumPy, MEG, fMRI, 3 references
[8] doi:10.1167/jov.26.8.4 [code]
The neural processes of illusory occlusion in object recognition.
Journal: Journal of vision
In common: seaborn, scikit-learn, Matplotlib, 1 other tool, 3 references
[9] doi:10.7554/elife.109640
Concurrent category-selective neural activity across the ventral occipito-temporal cortex supports a non-hierarchical view of human visual recognition.
Journal: eLife
In common: 5 references
[10] doi:10.1371/journal.pbio.3003831 [code]
Disinhibitory signaling enables flexible coding of top-down information in cortical networks.
Journal: PLoS biology
In common: NetworkX, scikit-learn, Matplotlib, 1 other tool, systems, 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.