OSCR

Stimulus dependencies-rather than next-word prediction-can explain pre-onset brain encoding in naturalistic listening designs.

Code ↔ Paper

3 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 3 matches
  1. [1] § Methods › Data ↔ lingpred_new/io.py, lines 79–223 · score 0.66 · 0.1–40 Hz, baseline correction, filtered, word onset, Sherlock, window
  2. [2] § Methods › Control system one: self-predictability analysis ↔ lingpred_new/plotting.py, lines 744–892 · score 0.60 · incorrect predictions, unpredicted words, GloVe, split, vectors, model
  3. [3] § Methods › MEG encoding modelling › Source selection ↔ lingpred_new/io.py, lines 79–223 · score 0.56 · post onset encoding, post word onset, window, activation, 500 ms, pre

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 · 699 lines · 25 KB · MIT · 2 matches

  1. import glob
  2. import shutil
  3. import os
  4. import sys
  5. from pathlib import Path
  6. import numpy as np
  7. import pickle
  8. from typing import Sequence,Union,Optional
  9. import imp
  10. import pandas as pd
  11. import tgt
  12. import mne
  13. import mne_bids
  14. import h5py
  15. from itertools import compress
  17. from scipy.io import loadmat
  20. PROJ_ROOT = '/project/3018059.03'
  22. # -----------------------------------------------------------#
  23. # Routine to load text #
  24. # -----------------------------------------------------------#
  26. def get_text_per_session(dataset: str, session: int, subject: int):
  28. """
  29. Loads text for a given dataset, session, and subject.
  31. Parameters
  32. ----------
  33. dataset : str
  34. Name of the dataset. Options: "Gwilliams" or "Armani"
  35. session : int
  36. Session for which the text is supposed to be loaded.
  37. - `range(11)` for Armani
  38. - `range(4)` for Gwilliams
  39. subject :
  40. Subject for whom the text is supposed to be loaded.
  42. Returns
  43. -------
  44. str
  45. The text for all runs as a single string.
  46. """
  48. if dataset =='Armani':
  49. runs = _runs_in_session(sess_i=session,sub_i=subject)
  51. text_all_runs = ''
  53. for run in runs:
  54. this_run_text = _load_full_text(sess_i = session, run_i = run ,without_breaks=True)
  55. text_all_runs = text_all_runs + ' ' + this_run_text
  56. return text_all_runs
  58. if dataset == 'Gwilliams':
  60. if str(session) =='0':
  61. textname = 'lw1.txt'
  62. if str(session) == '1':
  63. textname = 'cable_spool_fort.txt'
  64. if str(session) =='2':
  65. textname = 'easy_money.txt'
  66. if str(session) == '3':
  67. textname = 'the_black_willow.txt'
  69. fname = '/project/3018059.03/Lingpred/data/Gwilliams/stimuli/text/' + textname
  71. with open(fname, 'r') as file:
  72. text = file.read()
  73. return text
  75. # -----------------------------------------------------------#
  76. # NEW ROUTINES TO LOAD GWILLIAMS OR ARMANI MEG DATA #
  77. # -----------------------------------------------------------#
  79. def get_neural_data(dataset: str, sessions: list, subject: int, task = 'compr', datatype='source', channels=None, window_size=100, band=(0.1, 40), baseline=None):
  81. """
  82. Computes the average activation at each channel and lag relative to word onset.
  85. Parameters
  86. ----------
  87. dataset : str
  88. Either "Gwilliams", "Sherlock", or "Armani".
  89. subject : str or int
  90. Subject identifier. For Armani dataset: e.g., "001". For Gwilliams dataset: e.g., "01".
  91. task : str or int
  92. Task identifier. For Armani dataset: "compr". For Gwilliams dataset: 0, 1, 2, or 3, corresponding to:
  93. - 0 = lw1
  94. - 1 = cable spool fort
  95. - 2 = easy money
  96. - 3 = black willow
  97. channels : str, optional
  98. Can be 'None', 'language', 'signal', 'pre-onset', or 'post-onset'.
  99. - `None`: Returns all channels.
  100. - `'language'`: Returns only language-related channels.
  101. - `'signal'` (subject-specific): Returns only channels with relevant encoding (max value > 25% of max overall value).
  102. - `'pre-onset'` (subject-specific): Returns only channels with predominantly pre-word-onset encoding.
  103. - `'post-onset'` (subject-specific): Returns only channels with predominantly post-word-onset encoding.
  104. window_size : int, optional
  105. Window size for averaging the neural data with lag = 25 ms. If `None`, no averaging is performed.
  106. band : tuple of float
  107. Bandpass filter range to be used. Can be (0.5, 8) or (1, 40).
  108. baseline : bool or None
  109. Whether to perform baseline correction. If `None`, no correction is performed.
  111. Returns
  112. -------
  113. numpy.ndarray
  114. An array containing the average activation at each channel and lag relative to word onset.
  115. The returned array has shape (nr_channels, nr_epochs, nr_lags).
  116. pandas.DataFrame
  117. A dataframe containing the word of each epoch, the onset time, and additional information.
  118. list
  119. A list of dropped epochs.
  120. """
  123. if dataset == "Gwilliams":
  124. task = task
  126. sessions = sessions
  127. #get_sessions(dataset, subject) # These methods are still missing
  129. if channels == 'language':
  130. sources = get_language_channels(dataset)
  132. if channels == 'signal':
  133. sources = get_signal_channels(dataset, subject)
  135. if channels == 'pre-onset':
  136. sources = get_signal_channels(dataset, subject, pre=True)
  138. if channels == 'post-onset':
  139. sources = get_signal_channels(dataset, subject, post=True)
  141. else: sources = None # this includes all channels
  143. for session in sessions:
  145. bad_epochs_all_runs = [] # list with indices of dropped epochs
  146. length_all_epochs = 0 # constant to be added to the indices for each run
  148. runs = get_runs(dataset, subject, session) # This now only returns [1] for Gwilliams & Armani
  150. for run in runs:
  152. # load raw data and get a dataframe for annotations incl. word ID and onset/offset
  153. raw_data = load_raw_data(dataset, subject, session, run, task, datatype=datatype, band=band)
  154. annotations_df = get_words_onsets_offsets(raw_data, dataset, subject, session, run)
  155. onset_words = annotations_df.onset
  158. # create events
  159. events = np.c_[onset_words * raw_data.info['sfreq'],
  160. np.zeros((len(onset_words), 1)),
  161. np.ones((len(onset_words), 1))].astype(int)
  163. # now down-sample the data to 200Hz for computational reasons:
  164. # by passing the events array we make sure our timing is not jittered:
  165. raw_data, events = raw_data.resample(sfreq=200, events=events)
  168. # create epochs
  169. epochs = mne.Epochs(raw_data,
  170. events,
  171. tmin=-2,
  172. tmax=2,
  173. baseline=baseline, # (-2, 0) would be the default baseline
  174. picks=sources,
  175. metadata = annotations_df,
  176. event_repeated='drop',
  177. preload=True)
  180. # get indices of bad epochs:
  181. bad_epochs_this_run = [index + length_all_epochs for index, dl in enumerate(epochs.drop_log) if len(dl)]
  182. print(bad_epochs_this_run)
  183. length_all_epochs = length_all_epochs + len(epochs) + len(bad_epochs_this_run)
  184. bad_epochs_all_runs = bad_epochs_all_runs + bad_epochs_this_run
  187. # get average per lag
  188. if window_size:
  189. data_per_lag = get_mean_data_lag(epochs, window_size) # array of shape (nr_epochs, nr_channels, nr_lags)
  190. else:
  191. data_per_lag = epochs.get_data()
  194. # stack on top for all runs in one session & append annotations dataframe
  195. if run == runs[0] : # first run in session
  196. data_per_lag_all_runs = data_per_lag
  197. comb_annotation_df = epochs.metadata
  198. else:
  199. data_per_lag_all_runs = np.vstack((data_per_lag_all_runs, # array of shape:
  200. data_per_lag)) # (nr_all_epochs, nr_channels, nr_lags)
  201. comb_annotation_df = comb_annotation_df.append(epochs.metadata)
  203. print(bad_epochs_all_runs)
  205. # stack on top for all sessions & append annotations dataframe
  206. if session == 1 or len(sessions)==1:
  207. data_per_lag_all_sess = data_per_lag_all_runs
  208. annotation_df_all_sess = comb_annotation_df
  209. else:
  210. data_per_lag_all_sess = np.vstack((data_per_lag_all_sess, # array of shape:
  211. data_per_lag_all_runs)) # (nr_all_epochs, nr_channels, nr_lags)
  212. annotation_df_all_sess = annotation_df_all_sess.append(comb_annotation_df)
  214. # for subject 3, session 8 words 3841-4170 are scrambled: and need to be dropped from the df and the neural data:
  215. if session==8 and subject==3:
  216. annotation_df_all_sess.drop(index=annotation_df_all_sess[3841:4170].index, inplace=True)
  217. np.delete(data_per_lag_all_sess, np.arange(3841,4170))
  219. # change shape of the array such that one can easily loop over the channels: (nr_channels, nr_all_epochs, nr_lags)
  220. data_per_lag_all_sess = np.swapaxes(data_per_lag_all_sess,0,1)
  222. # return array with neural data and annotation data frame:
  223. return data_per_lag_all_sess, annotation_df_all_sess, bad_epochs_all_runs
  227. # ------------------------------------------------------------#
  228. # Associated New Auxiliary Functions: #
  229. # ------------------------------------------------------------#
  231. def drop_nans(y, X):
  233. '''
  234. Removes words containing NaN values from the neural data and GPT layer activations.
  236. Parameters
  237. ----------
  238. y : numpy.ndarray
  239. Neural data array of shape (channels, words, lags), containing the averaged MEG data.
  240. X : numpy.ndarray
  241. GPT layer activations, an array of shape (words, dimensions + 1).
  242. nan_ids : list of int
  243. List containing the indices of words that contain NaN values.
  245. Returns
  246. -------
  247. numpy.ndarray
  248. The `y` array with words containing NaNs removed.
  249. numpy.ndarray
  250. The `X` array with words containing NaNs removed.
  251. '''
  253. # get NaN values in neural data:
  254. nan_ids = get_nans(y)
  256. y = np.swapaxes(y,0,1) # swap axes such that rows == words
  258. # drop rows containing NaNs in y and X
  259. y = np.delete(y, nan_ids, axis=0)
  260. X = np.delete(X, nan_ids, axis=0)
  262. y = np.swapaxes(y,0,1) # swap axes such that rows == channels
  264. # print shapes
  265. print(X.shape, y.shape)
  267. return y, X
  270. def get_nans(neural_data):
  271. """
  272. Identifies words containing NaN values in the neural data.
  274. Parameters
  275. ----------
  276. neural_data : numpy.ndarray
  277. Array of shape (channels, words, lags), containing the averaged MEG data.
  279. Returns
  280. -------
  281. list of int
  282. List containing the indices of words that contain NaN values (to be dropped).
  283. """
  285. # initialise counter and index list
  286. count = 0
  287. nan_ids = []
  289. # loop over words (rows) to find rows containing NaNs
  290. for i, word in enumerate(neural_data[0]): # just do this for one channel
  291. if np.any(np.any(np.isnan(word))):
  292. count+=1
  293. nan_ids.append(i)
  294. print('There are {} words with NaNs which will be dropped.'.format(count))
  296. return nan_ids
  299. def get_language_channels(dataset: str, get_areas=False):
  300. '''
  301. Retrieves the list of channel names related to the language system for a given dataset.
  303. Parameters
  304. ----------
  305. dataset : str
  306. The dataset name. Can be either 'sherlock', 'Armani', or 'Gwilliams'.
  308. Returns
  309. -------
  310. list of str
  311. A list of channel names related to the language system.
  312. '''
  314. if dataset=='sherlock' or dataset=='Armani':
  315. source_info = ASH_load_source_info()
  316. ch_names = source_info['lbls_language']
  318. if get_areas:
  319. ch_names = list(compress(source_info['areas'], source_info['language_mask']))
  321. else: raise VallueError('get_language_channels is only implemented for the Armani dataset')
  323. return ch_names
  326. def get_lags(window_size, lag=0.025, start=-2, end=2):
  328. '''
  329. Returns an list of shape (nr_lags, 3) each row containing (lag_index, start_window, end_window) in sec
  330. '''
  332. starts = np.round(np.arange(start, end-window_size+lag, lag), 3)
  333. ends = np.round([s + window_size for s in starts], 3)
  335. arr = [[nr, start, end] for nr, (start, end) in enumerate(zip(starts, ends))]
  337. return arr
  340. def get_mean_data_lag(epochs, window_size):
  341. '''
  342. Param: MNE epochs object
  343. Returns average data for each window: array of shape (nr_epochs, nr_channels, nr_lags)
  344. '''
  346. # transform window_size from ms to s (round to 2 decimals to ensure precision, i.e. 0.05, 0.10, 0.15, 0.2)
  347. window_size = round(window_size/1000, 2)
  349. lags = get_lags(window_size=window_size)
  351. nr_lags = len(lags)
  353. for i in range(nr_lags):
  354. nr, start, end = lags[i]
  355. data = epochs.get_data(tmin=start, tmax=end) # ndarray of shape (nr_ep, nr_ch, nr_data)
  356. mean_data = np.mean(data, axis=2) # ndarray of shape (nr_epochs, nr_channels)
  357. del data
  358. if i==0:
  359. com_data = mean_data
  360. else:
  361. com_data = np.dstack([com_data, mean_data])
  363. return com_data # array of shape (nr_epochs, nr_channels, nr_lags)
  366. def load_raw_data(dataset: str, subject: int, session: int, run: int, task: str, datatype='raw', band=(1, 40)):
  367. """
  368. Loads raw data object using the MNE.
  370. Parameters
  371. ----------
  372. dataset : str
  373. The dataset name. Can be "Gwilliams", "sherlock", or "Armani".
  374. subject : str or int
  375. The subject identifier for which the data should be loaded.
  376. session : str or int
  377. The session for which the data should be loaded.
  378. task : str
  379. The task for which the data should be loaded. '0' for Gwilliams and 'compr' for Armani.
  380. band : tuple of float
  381. A tuple specifying the frequency band of the filtered Sherlock data.
  382. datatype : str
  383. The type of data to load:
  384. - `'filtered'` if the dataset is Gwilliams (filtered sensor data).
  385. - `'source'` if the dataset is Armani (filtered source data).
  387. Returns
  388. -------
  389. mne.io.Raw
  390. An MNE raw object with the filtered data for Gwilliams and source localized data for Armani.
  391. """
  394. # set root to path:
  395. if dataset=="Gwilliams":
  396. root='/project/3018059.03/Lingpred/data/Gwilliams/derived/'
  398. sess = str(session)
  399. if subject < 10:
  400. sub = '0' + str(subject)
  401. else:
  402. sub = str(subject)
  404. elif dataset=="Armani":
  405. root='/project/3018059.03/Lingpred/data/Armani/'
  407. sub = '00' + str(subject)
  409. if session < 10:
  410. sess = '00' + str(session)
  411. else:
  412. sess = '0' + str(session)
  415. # set path to raw data:
  416. if datatype == 'raw':
  418. datatype = 'meg'
  419. bids_path = mne_bids.BIDSPath(subject=sub,
  420. session=sess,
  421. task=task,
  422. datatype=datatype,
  423. root=root)
  426. # load data:
  427. if dataset=="Armani":
  429. # if we want the raw source localised data we need to load it from the source foulder:
  430. if datatype=='source':
  432. # file name, e.g.: 1-1_lcmv-data_0.1-40raw.fif
  433. fname = str(subject) + '-' + str(session) + '_lcmv-data_' + str(band[0]) + '-' + str(band[1]) + 'raw.fif'
  435. # handle naming of session 10
  436. if session < 10:
  437. session = '0'+ str(session)
  439. # full file path
  440. fif_path = root + 'sub-00' + str(subject) + '/ses-0' + str(session) + '/source/' + fname
  442. #read data
  443. raw = mne.io.read_raw_fif(fif_path)
  446. # else if we want raw data:
  447. else:
  448. raw = mne.io.read_raw_ctf(bids_path)
  451. if dataset=="Gwilliams":
  453. # if we want the filtered data:
  454. if datatype=='filtered':
  456. band=(0.1, 40)
  458. # file name, e.g.: 1-1_lcmv-data_0.1-40raw.fif
  459. fname = str(subject)+'-'+sess+'_filtered_data_'+str(band[0])+'-'+str(band[1])+'_task-'+task+'_'+'raw.fif'
  461. # full file path
  462. folder = '/project/3018059.03/data/Gwilliams/'
  463. fif_path = folder + 'sub-' + sub + '/ses-' + sess + '/filtered/' + fname
  465. # return False if the file doesn't exist
  466. if not Path(fif_path).is_file():
  467. return False
  469. #read data
  470. raw = mne.io.read_raw_fif(fif_path)
  472. # if we want the raw data:
  473. else:
  474. raw = mne_bids.read_raw_bids(bids_path)
  476. if dataset not in ['Gwilliams', 'Armani']:
  477. raise ValueError('Dataset variable must be either "Gwilliams", or "Armani"')
  479. # load raw data
  480. raw.load_data()
  482. return raw
  485. def get_words_onsets_offsets(raw_data, dataset:str, subject:int, session:int, run:int):
  486. """
  487. Loads word onset offsets for a given dataset, subject, session, and run.
  489. Parameters
  490. ----------
  491. raw_data : mne.io.Raw
  492. The raw data object.
  493. dataset : str
  494. The dataset name. Can be "Gwilliams", "Armani", or "Sherlock".
  495. subject : str or int
  496. The subject identifier for which the offsets should be loaded.
  497. session : str or int
  498. The session for which the offsets should be loaded.
  499. run : str or int
  500. The run for which the offsets should be loaded.
  502. Returns
  503. -------
  504. pandas.DataFrame
  505. A DataFrame containing at least two columns: 'word' and 'onset'.
  506. """
  508. if dataset == 'Gwilliams':
  510. df = raw_data.annotations.to_data_frame()
  511. df = pd.DataFrame(df.description.apply(eval).to_list())
  512. onsets = raw_data.annotations.onset
  514. # make a column for the onsets:
  515. df['onset'] = onsets
  517. # keep only word onset data
  518. df_words = df[df['kind']=='word']
  520. # keep only words which are part of the story (no pseudowords or wordlists)
  521. df_words = df_words[df_words['condition']=='sentence']
  523. # deal with shift:
  524. word_onsets = df.loc[df_words.index + 1].onset.values
  526. df_words['onset'] = word_onsets
  529. elif dataset == 'Armani':
  531. # handle naming of session 10:
  532. if session < 10:
  533. sess = '00' + str(session)
  534. else:
  535. sess = '0' + str(session)
  537. # get path to events file:
  538. dir_path = '/project/3018059.03/Lingpred/data/Armani/'
  539. filepath = 'sub-00' + str(subject) +'/' + 'ses-' + sess +'/'+ 'meg/'
  540. filename = 'sub-00' + str(subject) + '_ses-' + sess + '_task-compr_events.tsv'
  542. # read pandas DataFrame
  543. annotations = pd.read_csv(dir_path+filepath+filename, sep='\t')
  545. # type of event is separated by runs: there are at max 7 runs in each session:
  546. onset_names_list = ['word_onset_01', 'word_onset_02', 'word_onset_03', 'word_onset_04',
  547. 'word_onset_05', 'word_onset_06', 'word_onset_07', 'word_onset_08']
  549. # get only words, rename columns (identically to Gwilliams) and clean data frame
  550. df_words = annotations[annotations.type.isin(onset_names_list)]
  551. df_words = df_words[df_words.value != 'sp']
  552. df_words.rename(columns={'value':'word'}, inplace=True)
  553. df_words = clean_events(df_words, subject, session, dataset)
  555. else: raise ValueError('Dataset variable must be either "Gwilliams", or "Armani"')
  557. return df_words
  561. def get_phonemes_onsets_offsets(dataset:str, subject:int, session:int, run:int,
  562. only_word_inital_phonemes=True, correct_wav_onset=True):
  563. """
  564. Loads phoneme onset offsets for a given dataset, subject, session, and run.
  566. Parameters
  567. ----------
  568. raw_data : mne.io.Raw
  569. The raw data object.
  570. dataset : str
  571. The dataset name. Can be "Gwilliams", "Armani", or "Sherlock".
  572. subject : str or int
  573. The subject identifier for which the offsets should be loaded.
  574. session : str or int
  575. The session for which the offsets should be loaded.
  576. run : str or int
  577. The run for which the offsets should be loaded.
  578. only_word_initial_phonemes : bool, optional
  579. Whether to retrieve only word-initial phonemes. Defaults to `False`.
  581. Returns
  582. -------
  583. pandas.DataFrame
  584. A DataFrame containing at least two columns: 'phoneme' and 'onset'.
  585. """
  587. if dataset == 'Armani':
  589. # handle naming of session 10:
  590. if session < 10:
  591. sess = '00' + str(session)
  592. else:
  593. sess = '0' + str(session)
  595. # get path to events file:
  596. dir_path = '/project/3018059.03/Lingpred/data/Armani/'
  597. filepath = 'sub-00' + str(subject) +'/' + 'ses-' + sess +'/'+ 'meg/'
  598. filename = 'sub-00' + str(subject) + '_ses-' + sess + '_task-compr_events.tsv'
  600. # read pandas DataFrame for the entire session:
  601. annotations = pd.read_csv(dir_path+filepath+filename, sep='\t')
  603. # get list with word_onsets for this run:
  604. word_onset_name = ['word_onset_0{}'.format(run)]
  605. df_words = annotations[annotations.type.isin(word_onset_name)]
  606. df_words = df_words[df_words.value != 'sp']
  607. word_onsets = df_words.onset
  609. if correct_wav_onset:
  610. # now look for the timing of the audio onset for this run:
  611. index_first_word = df_words.index[0] # index for the first word in this run
  613. for i in np.arange(index_first_word, -1, -1): # interate from there backwards
  614. if annotations.iloc[i].type == 'wav_onset': # to the most recent wave onset
  615. audio_onset = annotations.iloc[i].onset # and get it's onset time
  616. break # break out of for loop
  618. # get list with phoneme_onsets for this run::
  619. onset_name = ['phoneme_onset_0{}'.format(run)]
  621. # get only phonemes and clean data frame
  622. df_phonemes = annotations[annotations.type.isin(onset_name)]
  624. if only_word_inital_phonemes:
  625. df_phonemes = df_phonemes[df_phonemes.onset.isin(word_onsets)]
  626. else: df_phonemes = df_phonemes[df_phonemes.value != 'sp']
  628. if correct_wav_onset:
  629. #convert times to audio onset times:
  630. df_phonemes.onset = df_phonemes.onset - audio_onset
  632. # add a column with the offsets:
  633. offsets = df_phonemes.onset + df_phonemes.duration
  634. df_phonemes['offset'] = offsets
  636. else: raise ValueError('Dataset variable must be "Armani"')
  638. return df_phonemes
  640. # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  641. # DUMMY FUNCTIONS: TO BE IMPLEMENTED ONCE WE HAVE SOURCE LEVEL DATA FOR ALL DATASETS:
  642. # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  644. # this function may be necessary to remove events which are not in the GPT-2 word embeddings
  645. def clean_events(annotations_words, subject, session, dataset):
  647. return annotations_words
  650. def get_sessions(dataset, subject):
  652. if dataset =='Armani':
  653. return np.arange(1,11) # Armani has 10 sessions: from 1-10
  654. else:
  655. raise ValueError("Only defined for the Armeni dataset at the moment.")
  659. # get's runs when using Micha'methods, otherwise returns [1] as a list
  660. def get_runs(dataset, subject, session):
  662. if dataset == "Armani":
  663. return _runs_in_session(session,sub_i=subject)
  664. else:
  665. return [1]
  668. def _load_full_text(sess_i,run_i,without_breaks=True):
  669. ASH_sess2runs=lambda x : {1:7,2:7,4:8,6:7,8:7}.get(x,6)
  670. """Load the full text as a single string for each run."""
  671. sess_str='0'+str(sess_i) if sess_i<10 else str(sess_i)
  672. fname=PROJ_ROOT/'Lingpred'/'data' / 'Armani' /'stimuli'/ "{}_{}.txt".format(sess_str,run_i)
  673. with open(fname, 'r') as file:
  674. full_text = file.read().replace('\n', ' ') if without_breaks else file.read()
  675. full_text=full_text.replace(' ',' ')
  676. return(full_text)
  679. def _runs_in_session(sess_i:int,sub_i:Union[None,int])->list:
  680. """from session number (and, optionally, subject number), get list of runs"""
  681. def _sess2nruns(sess_i,sub_i=None):
  682. """
  683. (subject number has to be given to account for aborted runs in pilot sub, and sub-003).
  684. (in subj3-sess8, run3 (run 7 !?) is missing)
  685. """
  686. if sub_i is None: sub_i=1
  688. if sub_i<0:
  689. sess2runs=lambda x : {1:3,2:7,4:7,6:7,8:7}.get(x,6)
  690. elif sub_i==3:
  691. sess2runs=lambda x : {1:7,2:7,4:8,6:7}.get(x,6)
  692. else:
  693. sess2runs=lambda x : {1:7,2:7,4:8,6:7,8:7}.get(x,6)
  695. return(sess2runs(sess_i))
  697. runs=list(range(1, 1 + _sess2nruns(sess_i,sub_i=sub_i)))
  698. return(runs)

io.py at commit 95c6375, under MIT · at the source

Overview

Authors: Inés Schönmann1, Jakub Szewczyk1,2, Floris P de Lange1, Micha Heilbron1,3
ORCID iDs: Inés Schönmann, Jakub Szewczyk, Floris P de Lange, Micha Heilbron
  1. Donders Institute for Brain Cognition and Behaviour, Nijmegen, Netherlands
  2. Institute of Psychology, Jagiellonian University, Kraków, Poland
  3. Amsterdam Brain and Cognition, University of Amsterdam, Amsterdam, Netherlands
Institutions: Donders Institute for Brain, Cognition and Behaviour (Netherlands); Jagiellonian University (Poland); University of Amsterdam (Netherlands)
Journal: eLife, volume 14, article RP106543
Dates: published online 10 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.7554/elife.106543 · PMID 41960890 · PMCID PMC13068430 · OpenAlex W4409527720
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), cognitive (subfield)
Methods: Statistics, Machine learning, Preprocessing, Spectral & time-frequency, fMRI & imaging, Connectivity
Keywords: Human
MeSH: Brain*, Speech Perception*, Humans, Language (* major topic)
Topic: Neurobiology of Language and Bilingualism (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: POLONEZ BIS (project No. 2022/47/P/HS6/02294); European Research Council (101000942, 945339, Skłodowska-Curie grant agreement No. 945339, No. 101000942 SURPRISE); Dutch Research Council (NWO) (VI.C.231.043)
Citations: cited by 10 papers (Europe PMC); 42 references in the paper

Abstract

The human brain is thought to constantly predict future words during language processing. Recently, a new approach emerged that aims to capture neural prediction directly by using vector representations of words (embeddings) to predict brain activity prior to word onset. Two findings have been proposed as hallmarks of neural next-word prediction: (i) significant encoding prior to word onset and (ii) its modulation by word predictability. However, natural language is rife with temporal correlations, where upcoming words share statistical information with preceding ones. This raises a critical question: Do these hallmarks emerge from the brain actively predicting future content, or might they be equally well explained by the regression model exploiting these inherent stimulus dependencies? To distinguish between these alternatives, we applied the same encoding analysis to passive control systems, i.e., representational systems that encode the stimulus but cannot predict upcoming words. We show that both hallmarks emerge in two such control systems, namely in word embeddings themselves and in speech acoustics. We further show that proposed methods to correct for these dependencies are insufficient, as the effects persist even after such corrections. Together, these results suggest that pre-onset prediction of brain activity might reflect dependencies in natural language rather than predictive computations. This questions the extent to which this new encoding-based method can be used to study prediction in the brain.

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

InesSchoenmann/Lingpred

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 95c6375f8b014233febd116eddd6fecb03baccd3, 9 July 2026
Languages: Python (12), Jupyter (6)
Size: 122 files, 18 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, license file, 6 notebooks
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (12 files), pandas (7 files), Matplotlib (4 files), SciPy (4 files), h5py (3 files), MNE-Python (3 files), seaborn (3 files), MNE-BIDS (2 files), scikit-learn (2 files), PyTorch (1 file), Hugging Face Transformers (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
20 files
At the source: github.com/InesSchoenmann/Lingpred

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

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

Data

Datasets cited

Data availability

The main dataset used here, Armeni et al., 2019’s few-subject MEG dataset, was made available with the original publication at https://doi.org/10.1038/s41597-022-01382-7. The additional multi-subject dataset by Gwilliams et al., 2022 is available at https://doi.org/10.17605/OSF.IO/AG3KJ. The stimuli and model features used in Goldstein et al., 2022b are available at https://openneuro.org/datasets/ds005574/versions/1.0.2 and the audio is available at https://www.thisamericanlife.org/631/so-a-monkey-and-a-horse-walk-into-a-bar/act-one-0. The code used for modelling analyses and plotting is available at https://github.com/InesSchoenmann/Lingpred (copy archived at Schoenmann, 2026).

The following previously published datasets were used:

Armeni K, Güçlü U, van Gerven M, Schoffelen J-M. 2022. A 10-hour within-participant magnetoencephalography narrative dataset to test models of naturalistic language comprehension. Donders Data Repository.

Zada Z, Nastase SA, Aubrey B, Jalon I, Goldstein A, Michelmann S, Wang H, Hasenfratz L, Doyle W, Friedman D, Dugan P, Melloni L, Devore S, Devinsky O, Flinker A, Hasson U. 2025. The "Podcast" ECoG dataset. OpenNeuro.

Gwilliams L, Flick G, Marantz A, Pylkkänen L, Poeppel D, King JR. 2022. MASC-MEG. Open Science Framework.

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

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 29 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 4 authors, 1 keyword, 4 MeSH terms, 3 funders, 40 references.

Cite

This paper

Schönmann, I., Szewczyk, J., de Lange, F. P., & Heilbron, M. (2026). Stimulus dependencies-rather than next-word prediction-can explain pre-onset brain encoding in naturalistic listening designs. eLife, 14, RP106543. https://doi.org/10.7554/elife.106543

BibTeX

@article{schonmann2026stimulus,
author = {Schönmann, Inés and Szewczyk, Jakub and de Lange, Floris P and Heilbron, Micha},
title = {{Stimulus dependencies-rather than next-word prediction-can explain pre-onset brain encoding in naturalistic listening designs}},
journal = {eLife},
year = {2026},
month = apr,
volume = {14},
pages = {RP106543},
publisher = {eLife Sciences Publications, Ltd},
issn = {2050-084X},
doi = {10.7554/elife.106543},
url = {https://doi.org/10.7554/elife.106543},
pmid = {41960890},
pmcid = {PMC13068430}
}

RIS

TY - JOUR
AU - Schönmann, Inés
AU - Szewczyk, Jakub
AU - de Lange, Floris P
AU - Heilbron, Micha
TI - Stimulus dependencies-rather than next-word prediction-can explain pre-onset brain encoding in naturalistic listening designs
T2 - eLife
J2 - Elife
PY - 2026
DA - 2026/04/10
VL - 14
SP - RP106543
SN - 2050-084X
PB - eLife Sciences Publications, Ltd
DO - 10.7554/elife.106543
UR - https://doi.org/10.7554/elife.106543
LA - en
ER -

CSL-JSON

{
"id": "10.7554/elife.106543",
"type": "article-journal",
"title": "Stimulus dependencies-rather than next-word prediction-can explain pre-onset brain encoding in naturalistic listening designs",
"container-title": "eLife",
"author": [
{
"family": "Schönmann",
"given": "Inés"
},
{
"family": "Szewczyk",
"given": "Jakub"
},
{
"family": "de Lange",
"given": "Floris P"
},
{
"family": "Heilbron",
"given": "Micha"
}
],
"container-title-short": "Elife",
"volume": "14",
"page": "RP106543",
"DOI": "10.7554/elife.106543",
"PMID": "41960890",
"PMCID": "PMC13068430",
"ISSN": "2050-084X",
"publisher": "eLife Sciences Publications, Ltd",
"URL": "https://doi.org/10.7554/elife.106543",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
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.1227 [code]
Large language models reveal the neural tracking of linguistic context in attended and unattended multi-talker speech.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Hugging Face Transformers, MNE-Python, h5py, 7 other tools, cognitive, 6 references
[2] doi:10.7554/elife.101204 [code]
Larger language models better align with neural representations of natural language.
Journal: eLife
In common: Hugging Face Transformers, PyTorch, scikit-learn, 3 other tools, 7 references
[3] doi:10.1038/s41467-026-72253-7 [code]
Spurious alignment between large language models and brains can emerge from non-robust methods and overlooked confounds.
Journal: Nature communications
In common: Hugging Face Transformers, h5py, PyTorch, 6 other tools, 5 references
[4] doi:10.1073/pnas.2422097122
Hierarchical dynamic coding coordinates speech comprehension in the human brain
Journal: n/a
In common: OSF ag3kj, cognitive, 5 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: MNE-Python, seaborn, scikit-learn, 4 other tools, cognitive, author Floris P de Lange
[6] doi:10.1167/jov.26.5.7 [code]
Representations in vision and language converge in a shared, multidimensional space of perceived similarities.
Journal: Journal of vision
In common: h5py, PyTorch, seaborn, 5 other tools, cognitive, 3 references
[7] doi:10.1162/nol.a.244 [code]
A Novel Approach to Map the Causal Impact of Brain Stimulation on Semantic Processing With Language Models.
Journal: Neurobiology of language (Cambridge, Mass.)
In common: Hugging Face Transformers, MNE-Python, PyTorch, 4 other tools, 3 references
[8] doi:10.1016/j.isci.2026.117180 [code]
Developmental changes in similarity between neural representations of mental arithmetic and artificial neural networks.
Journal: iScience
In common: Hugging Face Transformers, h5py, PyTorch, 6 other tools, 2 references
[9] doi:10.1038/s41598-026-41532-0 [code]
Prediction, syntax and semantic grounding in the brain and large language models.
Journal: Scientific reports
In common: Hugging Face Transformers, MNE-Python, PyTorch, 6 other tools, cognitive, 1 reference
[10] 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-BIDS, MNE-Python, h5py, 7 other tools

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.