OSCR

Cognitive load weakens neural speech tracking without altering response timing.

Code ↔ Paper

8 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 8 matches
  1. [1] § Methods › Source estimation of TRF weights difference ↔ plot_scripts/plot_trf_sourcelocation.py, lines 80–153 · score 0.87 · ad hoc, Norm, SNR, depth, loose, MNE
  2. [2] § Methods › EEG recording and preprocessing ↔ calculate_scripts/calculate_power.py, lines 20–27 · score 0.70 · 0.5–4 Hz, frequency bands, 4–8 Hz, power, beta, gamma
  3. [3] § Methods › Region of interest ↔ plot_scripts/plot_connectivity.py, lines 51–137 · score 0.69 · selected electrodes, occipital, map, parietal, frontal, brain
  4. [4] § Methods › Network topology analysis ↔ plot_scripts/plot_connectivity.py, lines 1238–1289 · score 0.67 · global efficiency, clustering coefficient, shortest, density, thresholded, metrics
  5. [5] § Methods › Key difference subnetwork extraction ↔ plot_scripts/plot_connectivity.py, lines 906–946 · score 0.62 · largest connected component, surface, subnetwork, nodes, Edges, weights
  6. [6] § Methods › Source estimation of TRF weights difference ↔ plot_scripts/plot_trf_sourcelocation.py, lines 1–19 · score 0.57 · source localization, MNE, template, Python, fsaverage, TRF
  7. [7] § Results › Graph metrics indicate a more clustered and more strongly small-world delta-band topology under HCL ↔ plot_scripts/plot_connectivity.py, lines 1238–1289 · score 0.57 · clustering coefficient, Global efficiency, metrics, density, thresholded, edge
  8. [8] § Results › Cognitive load reduces the speech-envelope information recoverable from the EEG ↔ plot_scripts/plot_pcc.py, lines 41–43 · score 0.55 · Pearson correlation coefficient, ADT Network, decoding

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 · 1,445 lines · 65 KB · no license · 4 matches

  1. import numpy as np
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  4. import seaborn as sns
  5. from scipy import stats
  6. from scipy.signal import welch
  7. from scipy.stats import permutation_test
  8. import mne
  9. from mne_connectivity.spectral import spectral_connectivity_epochs
  10. import networkx as nx
  11. from nilearn import datasets, plotting, surface
  12. from nilearn.surface import vol_to_surf
  13. import warnings
  14. import math
  15. from statsmodels.stats.multitest import multipletests
  16. import json
  17. warnings.filterwarnings('ignore')
  19. # Set English font
  20. plt.rcParams['font.family'] = 'Times New Roman'
  22. class BrainConnectivityAnalyzer:
  23. def __init__(self, data_path='results/delta/eeg_delta.npy'):
  24. """Initialize Analyzer"""
  25. self.data_path = data_path
  26. self.data = None
  27. self.low_load_data = None
  28. self.high_load_data = None
  29. self.channel_names = None
  30. self.sfreq = 128 # Sampling frequency
  31. self.connectivity_matrices = {}
  32. self.statistical_results = {}
  33. self.network_metrics = {}
  35. # Define regions of interest and channel mapping
  36. self.regions = {
  37. 'Frontal': ['Fp1', 'Fp2', 'F7', 'F8', 'F3', 'F4'],
  38. 'Central': ['C3', 'C4'],
  39. 'Parietal': ['P3', 'P4'],
  40. 'Temporal': ['T7', 'T8', 'P7', 'P8'],
  41. 'Occipital': ['O1', 'O2']
  42. }
  44. # All selected channels
  45. self.selected_channels = [ch for region in self.regions.values() for ch in region]
  46. print(f"Selected channels ({len(self.selected_channels)}): {self.selected_channels}")
  48. # Load channel info
  49. self.load_channel_info()
  51. def load_channel_info(self):
  52. """Load channel info, keep only selected electrodes"""
  53. ch_pos = {'Fp1': [-0.026133014404070235, 0.08078401376909139, -0.00400108454195971],
  54. 'Fpz': [0.0, 0.08498123361344626, -0.0017860385037488254],
  55. 'Fp2': [0.026133014404070235, 0.08078401376909139, -0.00400108454195971],
  56. 'AF7': [-0.049709431314887954, 0.0686910763510323, -0.005958898227616103],
  57. 'AF3': [-0.03148279679848069, 0.07615276676848455, 0.020846813167733094],
  58. 'AF4': [0.03148279679848069, 0.07615276676848455, 0.020846813167733094],
  59. 'AF8': [0.04966890402811598, 0.06872089942163155, -0.00595297869371352],
  60. 'F7': [-0.06842333502695395, 0.04987137794892023, -0.0074895183600262386],
  61. 'F5': [-0.06305822186454818, 0.05403788811325115, 0.018846813167733094],
  62. 'F3': [-0.048200427317538846, 0.05755106339309903, 0.039869711671018535],
  63. 'F1': [-0.026042093389975367, 0.0599127302448179, 0.054380824988956196],
  64. 'Fz': [0.0, 0.06073848094846255, 0.059462903831491894],
  65. 'F2': [0.02602543804214761, 0.059874412766011756, 0.05443097712368926],
  66. 'F4': [0.04814259646845235, 0.05758402610681053, 0.0398919834378528],
  67. 'F6': [0.06304473912257513, 0.05402633404653858, 0.018846813167733094],
  68. 'F8': [0.06838359029760958, 0.049926526811881665, -0.007485085070400889],
  69. 'FT7': [-0.08041001431187064, 0.026207503532593573, -0.008508604877055598],
  70. 'FC5': [-0.07624736450995313, 0.028762823435357604, 0.024166906986885676],
  71. 'FC3': [-0.059274978176089226, 0.030955284953191532, 0.05247139502329684],
  72. 'FC1': [-0.03235137713122826, 0.03243618389873952, 0.07159806122933911],
  73. 'FCz': [0.0, 0.03292788363525597, 0.07836296624875198],
  74. 'FC2': [0.03235137713122826, 0.03243618389873952, 0.07159806122933911],
  75. 'FC4': [0.059274978176089226, 0.030955284953191532, 0.05247139502329684],
  76. 'FC6': [0.07624736450995313, 0.028762823435357604, 0.024166906986885676],
  77. 'FT8': [0.08041001431187064, 0.026207503532593573, -0.008508604877055598],
  78. 'T7': [-0.08453853863965728, 5.176482896376251e-18, -0.008845082513531118],
  79. 'C5': [-0.08083154804902482, 4.9495048294181866e-18, 0.02629183979865601],
  80. 'C3': [-0.06317128071259069, 3.868125336135656e-18, 0.056871691491734856],
  81. 'C1': [-0.03453737403184571, 2.114804227952738e-18, 0.07766704445892345],
  82. 'Cz': [0.0, 5.204748896376251e-18, 0.085],
  83. 'C2': [0.03460920316454118, 2.11920249382479e-18, 0.07763506331752111],
  84. 'C4': [0.06316731016557851, 3.867882210251189e-18, 0.05687610154050295],
  85. 'C6': [0.08083154804902482, 4.9495048294181866e-18, 0.02629183979865601],
  86. 'T8': [0.08453853863965728, 5.176482896376251e-18, -0.008845082513531118],
  87. 'TP7': [-0.08041001431187064, -0.02620750353259356, -0.008508604877055598],
  88. 'CP5': [-0.07624736450995313, -0.028762823435357594, 0.024166906986885676],
  89. 'CP3': [-0.05927497817608923, -0.03095528495319151, 0.05247139502329684],
  90. 'CP1': [-0.03235137713122826, -0.032436183898739514, 0.07159806122933911],
  91. 'CP2': [0.03235137713122826, -0.032436183898739514, 0.07159806122933911],
  92. 'CP4': [0.05927497817608923, -0.03095528495319151, 0.05247139502329684],
  93. 'CP6': [0.07624736450995313, -0.028762823435357594, 0.024166906986885676],
  94. 'TP8': [0.08038510202811598, -0.026284771809974194, -0.008505652714920988],
  95. 'P7': [-0.06842333502695394, -0.049871377948920236, -0.0074895183600262386],
  96. 'P5': [-0.06305822186454818, -0.05403788811325114, 0.018846813167733094],
  97. 'P3': [-0.04820042731753886, -0.057551063393099025, 0.039869711671018535],
  98. 'P1': [-0.026042093389975374, -0.05991273024481789, 0.054380824988956196],
  99. 'Pz': [7.438318627860717e-18, -0.06073848094846255, 0.059462903831491894],
  100. 'P2': [0.026025438042147617, -0.05987441276601174, 0.05443097712368926],
  101. 'P4': [0.04814259646845235, -0.05758402610681054, 0.0398919834378528],
  102. 'P6': [0.06304473912257513, -0.054026334046538574, 0.018846813167733094],
  103. 'P8': [0.0683835902976096, -0.04992652681188165, -0.007485085070400889],
  104. 'PO7': [-0.04970943131488796, -0.0686910763510323, -0.005958898227616103],
  105. 'PO5': [-0.042951551117820216, -0.07280389857511523, 0.008930565565948855],
  106. 'PO3': [-0.03148279679848071, -0.07615276676848454, 0.020846813167733094],
  107. 'POz': [9.677837321860717e-18, -0.07902553885914161, 0.059462903831491894],
  108. 'PO4': [0.03148279679848071, -0.07615276676848454, 0.020846813167733094],
  109. 'PO6': [0.042951551117820216, -0.07280389857511523, 0.008930565565948855],
  110. 'PO8': [0.04966890402811598, -0.06872089942163155, -0.00595297869371352],
  111. 'O1': [-0.026133014404070225, -0.0807840137690914, -0.00400108454195971],
  112. 'Oz': [1.0407199573230042e-17, -0.08498123361344626, -0.0017860385037488254],
  113. 'O2': [0.026133014404070225, -0.0807840137690914, -0.00400108454195971]}
  115. # Keep only selected electrodes
  116. ch_pos = {k: v for k, v in ch_pos.items() if k in self.selected_channels}
  117. self.channel_names = list(ch_pos.keys())
  118. self.channel_positions = ch_pos
  120. # Create brain region color map
  121. self.region_colors = {
  122. 'Frontal': 'red',
  123. 'Central': 'blue',
  124. 'Parietal': 'green',
  125. 'Temporal': 'purple',
  126. 'Occipital': 'orange'
  127. }
  129. # Assign region color to each channel
  130. self.channel_colors = []
  131. for ch in self.channel_names:
  132. for region, channels in self.regions.items():
  133. if ch in channels:
  134. self.channel_colors.append(self.region_colors[region])
  135. break
  137. print(f"Set {len(self.channel_names)} channels")
  139. def load_data(self):
  140. """Load data, keep only selected electrodes"""
  141. print("Loading data...")
  142. self.data = np.load(self.data_path)
  143. print(f"Original data shape: {self.data.shape}")
  145. # Data format is (19, 12, 30720, 61) - (subjects, trials, time_points, channels)
  146. # Keep only selected electrodes
  147. # Get all original channel names
  148. original_channels = list(self.channel_positions.keys()) # Original 61 channels order
  150. # Find indices of selected electrodes in original data
  151. selected_indices = [original_channels.index(ch) for ch in self.selected_channels]
  153. # Extract selected electrodes from data
  154. self.data = self.data[:, :, :, selected_indices]
  155. print(f"Filtered data shape: {self.data.shape}")
  157. # Separate low and high cognitive load data
  158. self.low_load_data = self.data[:, :6, :, :] # First 6 trials
  159. self.high_load_data = self.data[:, 6:, :, :] # Last 6 trials
  161. print(f"Low cognitive load data shape: {self.low_load_data.shape}")
  162. print(f"High cognitive load data shape: {self.high_load_data.shape}")
  164. def preprocess_data(self, window_size=1024, overlap=0.5):
  165. """Preprocess data"""
  166. print("Preprocessing data...")
  168. # Calculate window parameters
  169. step_size = int(window_size * (1 - overlap))
  171. # Check if data length is sufficient
  172. data_length = self.low_load_data.shape[2] # Number of time points (3rd dimension)
  173. print(f"Data length: {data_length} time points")
  174. print(f"Window size: {window_size} time points")
  175. print(f"Step size: {step_size} time points")
  177. if data_length < window_size:
  178. print(f"Warning: Data length ({data_length}) is smaller than window size ({window_size})")
  179. print("Adjusting window size...")
  180. window_size = min(window_size, data_length // 2)
  181. step_size = int(window_size * (1 - overlap))
  182. print(f"Adjusted window size: {window_size}")
  183. print(f"Adjusted step size: {step_size}")
  185. # Segment for each subject and trial
  186. self.low_load_segments = []
  187. self.high_load_segments = []
  189. for subj in range(self.low_load_data.shape[0]):
  190. low_load_subj_segments = []
  191. high_load_subj_segments = []
  193. for trial in range(self.low_load_data.shape[1]):
  194. # Low cognitive load - Data format is (time_points, channels)
  195. data = self.low_load_data[subj, trial, :, :] # (3720, 16)
  196. segments = []
  197. for start in range(0, data.shape[0] - window_size + 1, step_size):
  198. segment = data[start:start + window_size, :] # (1024, 16)
  199. segments.append(segment)
  200. low_load_subj_segments.extend(segments)
  202. # High cognitive load - Data format is (time_points, channels)
  203. data = self.high_load_data[subj, trial, :, :] # (3720, 16)
  204. segments = []
  205. for start in range(0, data.shape[0] - window_size + 1, step_size):
  206. segment = data[start:start + window_size, :] # (1024, 16)
  207. segments.append(segment)
  208. high_load_subj_segments.extend(segments)
  210. # Add all segments of current subject to total list
  211. self.low_load_segments.append(low_load_subj_segments)
  212. self.high_load_segments.append(high_load_subj_segments)
  214. if len(self.low_load_segments) == 0 or len(self.high_load_segments) == 0:
  215. raise ValueError("No data segments generated! Please check window size and data length.")
  217. self.low_load_segments = np.array(self.low_load_segments)
  218. self.high_load_segments = np.array(self.high_load_segments)
  220. print(f"Segment data shape: {self.low_load_segments.shape}")
  222. def compute_connectivity(self, method='coh', fmin=4, fmax=8, batch_size=50):
  223. """Compute connectivity matrix"""
  224. print("Computing connectivity matrix...")
  226. # Check channel count match
  227. print(f"Number of channel names: {len(self.channel_names)}")
  228. print(f"Number of channels in segment data: {self.low_load_segments.shape[-1]}") # 3rd dimension is channels
  230. # Create MNE Info object
  231. print("Creating MNE Info object...")
  233. # Ensure channel names are strings
  234. channel_names = [str(ch) for ch in self.channel_names]
  235. print(f"Channel name type check: {type(channel_names[0])}")
  236. print(f"Channel name example: {channel_names[:5]}")
  238. # Create Info object, explicitly specify channel type
  239. ch_types = ['eeg'] * len(channel_names)
  240. info = mne.create_info(ch_names=channel_names, sfreq=self.sfreq, ch_types=ch_types)
  242. print(f"MNE Info object channel count: {len(info.ch_names)}")
  243. print(f"MNE Info object channel names: {info.ch_names[:5]}...")
  245. # Compute low cognitive load connectivity
  246. low_load_conn = []
  247. n_segments = len(self.low_load_segments)
  249. for sub_seg in self.low_load_segments:
  250. # Convert data from μV to V (1μV = 1e-6 V)
  251. data_v = sub_seg * 1e-6 # Convert to Volts
  252. low_load_epochs = mne.EpochsArray(np.transpose(data_v,(0,2,1)), info)
  253. try:
  254. con = spectral_connectivity_epochs(
  255. low_load_epochs, method=method, mode='multitaper',
  256. fmin=fmin, fmax=fmax, faverage=True,
  257. mt_adaptive=True, mt_bandwidth=None, mt_low_bias=True,
  258. cwt_freqs=None, cwt_n_cycles=7, sfreq=self.sfreq,
  259. tmin=None, tmax=None,
  260. names=None, n_jobs=1, verbose=False)
  261. low_load_conn.append(np.reshape(con.get_data(),(len(channel_names), len(channel_names))))
  262. except Exception as e:
  263. print(f"Failed to compute connectivity: {e}")
  265. low_load_conn=np.array(low_load_conn)
  269. high_load_conn = []
  270. for sub_seg in self.high_load_segments:
  271. # Convert data from μV to V (1μV = 1e-6 V)
  272. data_v = sub_seg * 1e-6 # Convert to Volts
  273. high_load_epochs = mne.EpochsArray(np.transpose(data_v,(0,2,1)), info)
  274. try:
  275. con = spectral_connectivity_epochs(
  276. high_load_epochs, method=method, mode='multitaper',
  277. fmin=fmin, fmax=fmax, faverage=True,
  278. mt_adaptive=True, mt_bandwidth=None, mt_low_bias=True,
  279. cwt_freqs=None, cwt_n_cycles=7, sfreq=self.sfreq,
  280. tmin=None, tmax=None,
  281. names=None, n_jobs=1, verbose=False)
  282. high_load_conn.append(np.reshape(con.get_data(),(len(channel_names), len(channel_names))))
  283. except Exception as e:
  284. print(f"Failed to compute connectivity: {e}")
  286. high_load_conn=np.array(high_load_conn)
  289. print(low_load_conn.shape)
  290. print(high_load_conn.shape)
  292. # Check range of connectivity values
  293. print(f"Low load connectivity range: {np.min(low_load_conn):.6f} - {np.max(low_load_conn):.6f}")
  294. print(f"High load connectivity range: {np.min(high_load_conn):.6f} - {np.max(high_load_conn):.6f}")
  295. print(f"Low load connectivity mean: {np.mean(low_load_conn):.6f}")
  296. print(f"High load connectivity mean: {np.mean(high_load_conn):.6f}")
  298. # Compute average connectivity matrix
  299. self.connectivity_matrices['low_load'] = np.mean(low_load_conn, axis=0)
  300. self.connectivity_matrices['high_load'] = np.mean(high_load_conn, axis=0)
  302. # Save original connectivity data for statistical test
  303. self.low_load_conn = low_load_conn
  304. print(f"low_load_conn: {low_load_conn}")
  305. print(f"low_load_conn.shape: {self.low_load_conn}")
  306. self.high_load_conn = high_load_conn
  308. print("Connectivity matrix computation completed")
  310. def statistical_test(self, alpha=0.05):
  311. """Statistical test - using permutation test (lower triangle)"""
  312. print("Performing paired permutation test (lower triangle)...")
  314. # Get matrix shape
  315. matrix_shape = self.connectivity_matrices['low_load'].shape
  316. n_channels = matrix_shape[0]
  318. # Only consider lower triangle (exclude diagonal) to avoid duplicate calculation of symmetric connections
  319. lower_tri_indices = np.tril_indices(n_channels, k=-1) # k=-1 excludes diagonal
  321. # Prepare data - extract only lower triangle part
  322. low_data_lower = []
  323. high_data_lower = []
  325. for subj_low, subj_high in zip(self.low_load_conn, self.high_load_conn):
  326. low_data_lower.append(subj_low[lower_tri_indices])
  327. high_data_lower.append(subj_high[lower_tri_indices])
  329. low_data_lower = np.array(low_data_lower) # (subjects, lower_tri_connections)
  330. high_data_lower = np.array(high_data_lower)
  333. n_subjects, n_connections = low_data_lower.shape
  335. # Compute paired difference matrix
  336. diff_matrix = low_data_lower - high_data_lower # (subjects, connections)
  338. # Compute original statistic (mean of paired differences)
  339. original_stat_lower = np.mean(diff_matrix, axis=0)
  341. # Perform permutation test
  342. print("Performing paired permutation test...")
  344. n_permutations = 5000
  345. p_values_lower = np.zeros(n_connections)
  347. for i in range(n_connections):
  348. # Perform paired permutation test for each connection
  349. low_conn = low_data_lower[:, i] # Low load data
  350. high_conn = high_data_lower[:, i] # High load data
  352. # Compute original statistic (mean of paired differences)
  353. original_stat_conn = np.mean(low_conn - high_conn)
  355. # Perform paired permutation
  356. perm_stats = []
  357. for _ in range(n_permutations):
  358. # Randomly swap low and high load labels for each subject
  359. # This maintains the integrity of the pairing
  360. perm_low = np.zeros_like(low_conn)
  361. perm_high = np.zeros_like(high_conn)
  363. for subj in range(n_subjects):
  364. if np.random.random() < 0.5:
  365. # Keep original order
  366. perm_low[subj] = low_conn[subj]
  367. perm_high[subj] = high_conn[subj]
  368. else:
  369. # Swap order
  370. perm_low[subj] = high_conn[subj]
  371. perm_high[subj] = low_conn[subj]
  373. # Compute statistic after permutation
  374. perm_stat = np.mean(perm_low - perm_high)
  375. perm_stats.append(perm_stat)
  377. # Compute p-value
  378. perm_stats = np.array(perm_stats)
  379. # Two-tailed test: calculate proportion of extreme values
  380. extreme_count = np.sum(np.abs(perm_stats) >= np.abs(original_stat_conn))
  381. p_values_lower[i] = extreme_count / n_permutations
  383. # FDR correction
  384. # _, p_corrected_lower, _, _ = multipletests(p_values_lower, alpha=alpha, method='fdr_bh')
  385. # print(f"p_corrected_lower: {p_corrected_lower}")
  386. p_corrected_lower = p_values_lower
  387. print(f"p_corrected_lower: {p_corrected_lower}")
  388. print(len(p_corrected_lower))
  390. # Create full matrix
  391. p_values = np.zeros(matrix_shape)
  392. p_corrected = np.zeros(matrix_shape)
  393. effect_sizes = np.zeros(matrix_shape)
  394. significant = np.zeros(matrix_shape, dtype=bool)
  396. # Fill lower triangle results into full matrix
  397. p_values[lower_tri_indices] = p_values_lower
  398. p_corrected[lower_tri_indices] = p_corrected_lower
  399. effect_sizes[lower_tri_indices] = original_stat_lower
  400. significant[lower_tri_indices] = p_corrected_lower < alpha
  402. # Copy to upper triangle (symmetric)
  403. p_values = p_values + p_values.T - np.diag(np.diag(p_values))
  404. p_corrected = p_corrected + p_corrected.T - np.diag(np.diag(p_corrected))
  405. effect_sizes = effect_sizes + effect_sizes.T - np.diag(np.diag(effect_sizes))
  406. significant = significant | significant.T
  407. print(significant)
  409. self.statistical_results = {
  410. 'p_values': p_values,
  411. 'p_corrected': p_corrected,
  412. 'effect_sizes': effect_sizes,
  413. 'significant': significant
  414. }
  416. print(f"Number of significant connections: {np.sum(self.statistical_results['significant'])}")
  418. def statistical_test_t_test(self, alpha=0.1):
  419. """Statistical test using paired T-test (lower triangle matrix)"""
  421. # Get matrix shape
  422. matrix_shape = self.connectivity_matrices['low_load'].shape
  423. n_channels = matrix_shape[0]
  425. # Only consider lower triangle (exclude diagonal)
  426. lower_tri_indices = np.tril_indices(n_channels, k=-1) # k=-1 excludes diagonal
  428. # Prepare data - extract only lower triangle part
  429. low_data_lower = []
  430. high_data_lower = []
  432. for subj_low, subj_high in zip(self.low_load_conn, self.high_load_conn):
  433. low_data_lower.append(subj_low[lower_tri_indices])
  434. high_data_lower.append(subj_high[lower_tri_indices])
  436. low_data_lower = np.array(low_data_lower) # (subjects, lower_tri_connections)
  437. high_data_lower = np.array(high_data_lower)
  440. n_subjects, n_connections = low_data_lower.shape
  442. # Use paired t-test for statistical testing
  443. p_values_lower = np.zeros(n_connections)
  444. effect_sizes_lower = np.zeros(n_connections)
  445. t_stats_lower = np.zeros(n_connections)
  447. for i in range(n_connections):
  448. # Perform paired t-test for each connection
  449. t_stat, p_val = stats.ttest_rel(low_data_lower[:, i], high_data_lower[:, i])
  450. t_stats_lower[i] = t_stat
  451. p_values_lower[i] = p_val
  452. effect_sizes_lower[i] = np.mean(low_data_lower[:, i] - high_data_lower[:, i])
  454. # FDR correction
  455. # _, p_corrected_lower, _, _ = multipletests(p_values_lower, alpha=alpha, method='fdr_bh')
  456. p_corrected_lower = p_values_lower
  459. # Create full matrix
  460. p_values = np.zeros(matrix_shape)
  461. p_corrected = np.zeros(matrix_shape)
  462. effect_sizes = np.zeros(matrix_shape)
  463. t_stats = np.zeros(matrix_shape)
  464. significant = np.zeros(matrix_shape, dtype=bool)
  466. # Fill lower triangle results into full matrix
  467. p_values[lower_tri_indices] = p_values_lower
  468. p_corrected[lower_tri_indices] = p_corrected_lower
  469. effect_sizes[lower_tri_indices] = effect_sizes_lower
  470. t_stats[lower_tri_indices] = t_stats_lower
  471. significant[lower_tri_indices] = p_corrected_lower < alpha
  473. # Copy to upper triangle (symmetric)
  474. p_values = p_values + p_values.T - np.diag(np.diag(p_values))
  475. print(p_values)
  476. p_corrected = p_corrected + p_corrected.T - np.diag(np.diag(p_corrected))
  477. effect_sizes = effect_sizes + effect_sizes.T - np.diag(np.diag(effect_sizes))
  478. t_stats = t_stats + t_stats.T - np.diag(np.diag(t_stats))
  479. significant = significant | significant.T
  481. self.t_test_results = {
  482. 'p_values': p_values,
  483. 'p_corrected': p_corrected,
  484. 'effect_sizes': effect_sizes,
  485. 't_stats': t_stats,
  486. 'significant': significant
  487. }
  489. print(f"Number of T-test significant connections: {np.sum(self.t_test_results['significant'])}")
  491. def compare_test_results(self):
  492. """Compare results of Permutation Test and T-Test"""
  494. perm_sig = self.statistical_results['significant']
  495. ttest_sig = self.t_test_results['significant']
  497. # Calculate overlap
  498. overlap = np.sum(perm_sig & ttest_sig)
  499. perm_only = np.sum(perm_sig & ~ttest_sig)
  500. ttest_only = np.sum(~perm_sig & ttest_sig)
  501. neither = np.sum(~perm_sig & ~ttest_sig)
  503. print(f"Permutation test significant connections: {np.sum(perm_sig)}")
  504. print(f"T-test significant connections: {np.sum(ttest_sig)}")
  505. print(f"Connections significant in both methods: {overlap}")
  506. print(f"Significant only in Permutation test: {perm_only}")
  507. print(f"Significant only in T-test: {ttest_only}")
  508. print(f"Not significant in either: {neither}")
  510. # Create matrix showing only lower triangle
  511. def create_lower_tri_matrix(matrix):
  512. n = matrix.shape[0]
  513. lower_tri_matrix = np.zeros_like(matrix)
  514. lower_tri_indices = np.tril_indices(n, k=-1)
  515. lower_tri_matrix[lower_tri_indices] = matrix[lower_tri_indices]
  516. return lower_tri_matrix
  518. # Plot comparison
  519. fig, axes = plt.subplots(1, 3, figsize=(18, 6))
  521. # Permutation test results (lower triangle only)
  522. perm_effect_lower = create_lower_tri_matrix(
  523. self.statistical_results['effect_sizes'] * self.statistical_results['significant']
  524. )
  525. im1 = axes[0].imshow(perm_effect_lower, cmap='RdBu_r', aspect='auto')
  526. axes[0].set_title('Channel-wise Permutation Test')
  527. axes[0].set_xlabel('Channel')
  528. axes[0].set_ylabel('Channel')
  529. plt.colorbar(im1, ax=axes[0])
  531. # T-test results (lower triangle only)
  532. ttest_effect_lower = create_lower_tri_matrix(
  533. self.t_test_results['effect_sizes'] * self.t_test_results['significant']
  534. )
  535. im2 = axes[1].imshow(ttest_effect_lower, cmap='RdBu_r', aspect='auto')
  536. axes[1].set_title('Channel-wise T-Test')
  537. axes[1].set_xlabel('Channel')
  538. axes[1].set_ylabel('Channel')
  539. plt.colorbar(im2, ax=axes[1])
  541. # Difference plot (lower triangle only)
  542. diff_sig = perm_sig.astype(int) - ttest_sig.astype(int)
  543. diff_sig_lower = create_lower_tri_matrix(diff_sig)
  544. im3 = axes[2].imshow(diff_sig_lower, cmap='RdBu_r', aspect='auto')
  545. axes[2].set_title('Method Difference\n(1=Perm Test Only, -1=T-Test Only, 0=Both)')
  546. axes[2].set_xlabel('Channel')
  547. axes[2].set_ylabel('Channel')
  548. plt.colorbar(im3, ax=axes[2])
  550. plt.tight_layout()
  551. plt.savefig('results/test_comparison.png', dpi=300, bbox_inches='tight')
  552. plt.show()
  554. def plot_connectivity_matrices(self):
  555. """Plot connectivity matrices"""
  556. fig, axes = plt.subplots(2, 2, figsize=(10, 8))
  558. # Create matrix showing only lower triangle
  559. def create_lower_tri_matrix(matrix):
  560. n = matrix.shape[0]
  561. lower_tri_matrix = np.zeros_like(matrix)
  562. lower_tri_indices = np.tril_indices(n, k=-1) # k=-1 excludes diagonal
  563. lower_tri_matrix[lower_tri_indices] = matrix[lower_tri_indices]
  564. return lower_tri_matrix
  566. # Low cognitive load connectivity matrix (lower triangle only)
  567. low_load_lower = create_lower_tri_matrix(self.connectivity_matrices['low_load'])
  568. im1 = axes[0,0].imshow(low_load_lower,
  569. cmap='RdBu_r', aspect='auto')
  570. axes[0,0].set_title('LCW Connectivity Matrix')
  571. axes[0,0].set_xlabel('Channel')
  572. axes[0,0].set_ylabel('Channel')
  573. plt.colorbar(im1, ax=axes[0,0])
  575. # High cognitive load connectivity matrix (lower triangle only)
  576. high_load_lower = create_lower_tri_matrix(self.connectivity_matrices['high_load'])
  577. im2 = axes[0,1].imshow(high_load_lower,
  578. cmap='RdBu_r', aspect='auto')
  579. axes[0,1].set_title('HCW Connectivity Matrix')
  580. axes[0,1].set_xlabel('Channel')
  581. axes[0,1].set_ylabel('Channel')
  582. plt.colorbar(im2, ax=axes[0,1])
  584. # Difference matrix (lower triangle only)
  585. diff_matrix = self.connectivity_matrices['high_load'] - self.connectivity_matrices['low_load']
  586. diff_lower = create_lower_tri_matrix(diff_matrix)
  587. im3 = axes[1,0].imshow(diff_lower, cmap='RdBu_r', aspect='auto')
  588. axes[1,0].set_title('Difference Matrix (HCW - LCW)')
  589. axes[1,0].set_xlabel('Channel')
  590. axes[1,0].set_ylabel('Channel')
  591. plt.colorbar(im3, ax=axes[1,0])
  593. # Significant matrix (lower triangle only)
  594. significant_matrix = diff_matrix * self.statistical_results['significant']
  595. significant_lower = create_lower_tri_matrix(significant_matrix)
  596. im4 = axes[1,1].imshow(significant_lower, cmap='RdBu_r', aspect='auto')
  597. axes[1,1].set_title('Significant Difference Matrix')
  598. axes[1,1].set_xlabel('Channel')
  599. axes[1,1].set_ylabel('Channel')
  600. plt.colorbar(im4, ax=axes[1,1])
  602. plt.tight_layout()
  603. plt.savefig('results/delta/connectivity_matrices_wpli.svg', format='svg', bbox_inches='tight')
  604. plt.show()
  606. def plot_network_graph(self):
  607. """Plot network graph, colored by brain region, using only lower triangle matrix"""
  608. fig, axes = plt.subplots(1, 3, figsize=(18, 6))
  610. # Create brain region legend
  611. legend_elements = [plt.Line2D([0], [0], marker='o', color='w',
  612. markerfacecolor=color, markersize=10, label=region)
  613. for region, color in self.region_colors.items()]
  615. # Create network graph
  616. for i, (title, matrix) in enumerate([
  617. ('LCW Network', self.connectivity_matrices['low_load']),
  618. ('HCW Network', self.connectivity_matrices['high_load']),
  619. ('Significant Difference Network', self.statistical_results['significant'] *
  620. self.statistical_results['effect_sizes']) # Use effect size instead of difference
  621. ]):
  622. G = nx.Graph()
  624. # Add nodes, project 3D coordinates to 2D
  625. for j, ch in enumerate(self.channel_names):
  626. pos_3d = self.channel_positions[ch]
  627. pos_2d = (pos_3d[0], pos_3d[1])
  628. G.add_node(ch, pos=pos_2d)
  630. # Use only lower triangle (excluding diagonal) for stats and threshold
  631. n_ch = len(self.channel_names)
  632. lower_tri_indices = np.tril_indices(n_ch, k=-1)
  633. matrix_lower = matrix[lower_tri_indices]
  634. matrix_abs_lower = np.abs(matrix_lower)
  635. max_val = np.max(matrix_abs_lower)
  636. mean_val = np.mean(matrix_abs_lower)
  637. std_val = np.std(matrix_abs_lower)
  639. # Increase threshold: use mean + 2 std devs, and not exceed 90% of max value
  640. threshold = min(mean_val, max_val * 0.9)
  641. # Further ensure threshold is not too low
  642. if threshold < max_val * 0.3:
  643. threshold = max_val * 0.3
  645. print(f"{title} - Max: {max_val:.4f}, Mean: {mean_val:.4f}, Threshold: {threshold:.4f}")
  647. # Iterate only lower triangle, add edges
  648. edge_count = 0
  649. for j in range(n_ch):
  650. for k in range(0, j): # Only iterate lower triangle
  651. weight = matrix[j, k]
  653. if 'Significant' in title:
  654. # Significant network: show all non-zero connections (i.e. significant connections)
  655. if weight != 0:
  656. G.add_edge(self.channel_names[j], self.channel_names[k], weight=weight)
  657. edge_count += 1
  658. else:
  659. # Other networks: use threshold filtering
  660. if abs(weight) > threshold:
  661. G.add_edge(self.channel_names[j], self.channel_names[k], weight=weight)
  662. edge_count += 1
  664. print(f"{title} - Added {edge_count} edges")
  666. # Add extra info for significant network
  667. if 'Significant' in title:
  668. significant_count = np.sum(self.statistical_results['significant'])
  669. print(f"Significant Network - Total statistically significant connections: {significant_count}")
  670. print(f"Significant Network - Actual plotted connections: {edge_count}")
  671. print(f"Significant Network - Non-zero elements in matrix: {np.sum(matrix != 0)}")
  672. if edge_count != significant_count:
  673. print(f"Warning: Plotted connection count ({edge_count}) does not match significant connection count ({significant_count})!")
  674. print(f"Possible reason: Some connections became 0 after multiplying significant matrix with difference matrix")
  676. # Check specific case for O2 and F3
  677. try:
  678. o2_idx = self.channel_names.index('O2')
  679. f3_idx = self.channel_names.index('F3')
  680. # Print index for all electrodes
  681. for i, ch in enumerate(self.channel_names):
  682. print(f"{ch}: {i}")
  684. # Check significance
  685. print(o2_idx, f3_idx)
  686. is_significant = self.statistical_results['significant'][o2_idx, f3_idx]
  687. # Check effect size
  688. effect_size = self.statistical_results['effect_sizes'][o2_idx, f3_idx]
  689. # Check p-value
  690. p_value = self.statistical_results['p_corrected'][o2_idx, f3_idx]
  691. # Check value after multiplication
  692. multiplied_value = matrix[o2_idx, f3_idx]
  694. print(f"O2-F3 Connection Details:")
  695. print(f" Significant: {is_significant}")
  696. print(f" Effect Size: {effect_size:.6f}")
  697. print(f" P-value: {p_value:.6f}")
  698. print(f" Value after multiplication: {multiplied_value:.6f}")
  699. print(f" Is plotted: {multiplied_value != 0}")
  701. except ValueError:
  702. print("O2 or F3 not in electrode list")
  704. # Plot network
  705. pos = nx.get_node_attributes(G, 'pos')
  706. weights = [G[u][v]['weight'] for u, v in G.edges()]
  708. # Plot nodes (colored by region)
  709. nx.draw_networkx_nodes(G, pos, ax=axes[i], node_size=300,
  710. node_color=self.channel_colors)
  712. # Plot edges
  713. if len(weights) > 0:
  714. nx.draw_networkx_edges(G, pos, ax=axes[i],
  715. edge_color=weights, edge_cmap=plt.cm.RdBu_r,
  716. width=2)
  717. # Add labels
  718. nx.draw_networkx_labels(G, pos, ax=axes[i], font_size=8)
  720. axes[i].set_title(f'{title}\n(Threshold: {threshold:.3f}, Edge Count: {edge_count})')
  722. # Add legend
  723. fig.legend(handles=legend_elements, loc='lower center', ncol=5)
  725. plt.tight_layout()
  726. plt.subplots_adjust(bottom=0.15) # Leave space for legend
  727. plt.savefig('results/delta/network_graphs.svg', format='svg', bbox_inches='tight')
  728. plt.show()
  730. # def plot_brain_surface(self):
  731. # """在脑表面绘制关键连接，仅使用下三角矩阵"""
  733. # fig, axes = plt.subplots(1, 2, figsize=(15, 6))
  735. # significant_connections = self.statistical_results['significant']
  736. # effect_sizes = self.statistical_results['effect_sizes']
  738. # # 只考虑下三角
  739. # n_ch = effect_sizes.shape[0]
  740. # lower_tri_indices = np.tril_indices(n_ch, k=-1)
  741. # effect_sizes_lower = effect_sizes[lower_tri_indices]
  742. # significant_lower = significant_connections[lower_tri_indices]
  744. # # 找到下三角中最强的连接
  745. # max_connections = 20
  746. # abs_effect = np.abs(effect_sizes_lower)
  747. # top_indices_flat = np.argsort(abs_effect)[-max_connections:]
  749. # # 创建连接强度矩阵（只填下三角）
  750. # connection_strength = np.zeros_like(effect_sizes)
  751. # for idx in top_indices_flat:
  752. # i = lower_tri_indices[0][idx]
  753. # j = lower_tri_indices[1][idx]
  754. # if significant_connections[i, j]:
  755. # connection_strength[i, j] = effect_sizes[i, j]
  756. # # 不复制到上三角，保持只显示下三角
  758. # # 绘制连接强度热图（只显示下三角）
  759. # def create_lower_tri_matrix(matrix):
  760. # n = matrix.shape[0]
  761. # lower_tri_matrix = np.zeros_like(matrix)
  762. # lower_tri_indices = np.tril_indices(n, k=-1)
  763. # lower_tri_matrix[lower_tri_indices] = matrix[lower_tri_indices]
  764. # return lower_tri_matrix
  766. # connection_strength_lower = create_lower_tri_matrix(connection_strength)
  767. # im1 = axes[0].imshow(connection_strength_lower, cmap='RdBu_r', aspect='auto')
  768. # axes[0].set_title('Key Connection Strength Distribution')
  769. # axes[0].set_xlabel('Channel')
  770. # axes[0].set_ylabel('Channel')
  771. # plt.colorbar(im1, ax=axes[0])
  773. # # 绘制连接数量统计（只统计下三角）
  774. # connection_counts = np.sum(significant_connections, axis=1)
  775. # axes[1].bar(range(len(connection_counts)), connection_counts)
  776. # axes[1].set_title('Number of Significant Connections per Channel')
  777. # axes[1].set_xlabel('Channel Index')
  778. # axes[1].set_ylabel('Connection Count')
  780. # plt.tight_layout()
  781. # plt.savefig('results/brain_connectivity_summary.png', dpi=300, bbox_inches='tight')
  782. # plt.show()
  783. def project_electrodes_to_surface(self):
  784. """Project electrode positions onto cortical surface"""
  785. print("Projecting electrode positions onto cortical surface...")
  787. # Load cortical surface
  788. fsaverage = datasets.fetch_surf_fsaverage()
  789. left_pial = surface.load_surf_mesh(fsaverage['pial_left'])
  790. right_pial = surface.load_surf_mesh(fsaverage['pial_right'])
  792. # Merge left and right hemispheres
  793. all_vertices = np.vstack([left_pial[0], right_pial[0]])
  794. all_faces = np.vstack([left_pial[1], right_pial[1] + len(left_pial[0])])
  796. # Create KDTree for nearest neighbor search
  797. from scipy.spatial import cKDTree
  798. kdtree = cKDTree(all_vertices)
  800. # Project each electrode to the nearest cortical point
  801. projected_positions = {}
  802. for ch, pos in self.channel_positions.items():
  803. # Convert position to mm (assuming original is meters)
  804. pos_mm = np.array(pos) * 1000
  806. # Find nearest cortical point
  807. distance, idx = kdtree.query(pos_mm)
  808. projected_pos = all_vertices[idx]
  810. # Move slightly outward to avoid embedding
  811. normal = projected_pos - np.mean(all_vertices, axis=0)
  812. normal /= np.linalg.norm(normal)
  813. projected_pos += normal * 2 # Move outward by 2mm
  815. projected_positions[ch] = projected_pos
  817. return projected_positions
  818. def plot_brain_surface(self, top_n=20):
  819. """Plot key connections on brain surface (Top view only) - Plot only statistically significant connections"""
  820. print("Plotting key brain surface connections (Top view only)...")
  822. # Project electrode positions to cortical surface
  823. projected_positions = self.project_electrodes_to_surface()
  825. # Get significant connections
  826. significant = self.statistical_results['significant']
  827. effect_sizes = self.statistical_results['effect_sizes']
  829. # Consider only significant connections
  830. significant_indices = np.where(significant)
  832. if len(significant_indices[0]) == 0:
  833. print("No significant connections to plot")
  834. return
  836. # Extract effect sizes of significant connections
  837. significant_effects = effect_sizes[significant_indices]
  839. # Find top_n connections with largest effect sizes
  840. top_indices = np.argsort(np.abs(significant_effects))[-top_n:]
  842. # Create connection strength matrix
  843. connection_strength = np.zeros_like(effect_sizes)
  844. for idx in top_indices:
  845. i = significant_indices[0][idx]
  846. j = significant_indices[1][idx]
  847. connection_strength[i, j] = effect_sizes[i, j]
  848. connection_strength[j, i] = effect_sizes[i, j] # Symmetric position
  850. # Create figure (Top view only)
  851. fig = plt.figure(figsize=(6, 6))
  852. ax = fig.add_subplot(1, 1, 1, projection='3d')
  854. # Load cortical surface
  855. fsaverage = datasets.fetch_surf_fsaverage()
  857. # Plot left hemisphere
  858. vertices, faces = surface.load_surf_mesh(fsaverage['pial_left'])
  859. ax.plot_trisurf(vertices[:, 0], vertices[:, 1], vertices[:, 2],
  860. triangles=faces, color='lightgray', alpha=0.2)
  861. # Plot right hemisphere
  862. vertices, faces = surface.load_surf_mesh(fsaverage['pial_right'])
  863. ax.plot_trisurf(vertices[:, 0], vertices[:, 1], vertices[:, 2],
  864. triangles=faces, color='lightgray', alpha=0.2)
  866. # Set top view
  867. ax.view_init(elev=90, azim=0)
  868. ax.set_title('Top View')
  869. ax.set_axis_off()
  871. # Plot electrode positions (using projected positions)
  872. for ch, pos in projected_positions.items():
  873. ax.scatter(pos[0], pos[1], pos[2], s=50, color='blue', alpha=0.8)
  875. # Plot key connections (using projected positions)
  876. for i in range(len(self.channel_names)):
  877. for j in range(i+1, len(self.channel_names)):
  878. if abs(connection_strength[i, j]) > 0:
  879. ch_i = self.channel_names[i]
  880. ch_j = self.channel_names[j]
  881. pos_i = projected_positions[ch_i]
  882. pos_j = projected_positions[ch_j]
  884. # Set color and width based on effect size
  885. effect = connection_strength[i, j]
  886. color = 'red' if effect < 0 else 'blue' # Negative value means enhanced in high load, positive means reduced
  887. width = 1 + 3 * abs(effect) / np.max(np.abs(connection_strength))
  889. # Plot connection line
  890. ax.plot([pos_i[0], pos_j[0]],
  891. [pos_i[1], pos_j[1]],
  892. [pos_i[2], pos_j[2]],
  893. color=color, linewidth=width, alpha=0.7)
  895. # # Add legend
  896. # plt.figtext(0.5, 0.05,
  897. # f"Red: High Load Connection Enhanced | Blue: High Load Connection Reduced",
  898. # ha='center', fontsize=12)
  900. plt.tight_layout()
  901. plt.subplots_adjust(bottom=0.1) # Leave space for legend
  902. plt.savefig('results/delta/brain_key_connections_topview.svg', format='svg', bbox_inches='tight')
  903. plt.show()
  904. print("Brain surface key connections plot (Top view) saved")
  906. def plot_key_subnetwork(self, min_connections=5, max_nodes=20):
  907. """Plot key subnetwork - using electrode positions projected to cortex"""
  908. print("Plotting key subnetwork...")
  910. # Project electrode positions to cortex
  911. projected_positions = self.project_electrodes_to_surface()
  913. # Get significant connections and effect sizes
  914. significant = self.statistical_results['significant']
  915. effect_sizes = self.statistical_results['effect_sizes']
  917. # Create network graph
  918. G = nx.Graph()
  920. # Add nodes (using projected positions)
  921. for i, ch in enumerate(self.channel_names):
  922. region = self.get_region(ch)
  923. G.add_node(ch, pos=projected_positions[ch], region=region)
  925. # Add significant connections as edges
  926. n_channels = len(self.channel_names)
  927. for i in range(n_channels):
  928. for j in range(i+1, n_channels):
  929. if significant[i, j]:
  930. weight = effect_sizes[i, j]
  931. G.add_edge(self.channel_names[i], self.channel_names[j], weight=weight)
  933. # Check if there are significant connections
  934. if G.number_of_edges() == 0:
  935. print("No significant connections to plot")
  936. return
  938. # Extract largest connected component
  939. largest_cc = max(nx.connected_components(G), key=len)
  940. subgraph = G.subgraph(largest_cc).copy()
  942. print(f"Largest connected component contains {len(subgraph.nodes())} nodes and {len(subgraph.edges())} edges")
  944. # If subnetwork is too large, extract core subnetwork
  945. if len(subgraph.nodes()) > max_nodes:
  946. print(f"Subnetwork too large ({len(subgraph.nodes())} nodes), extracting core subnetwork...")
  948. # Compute node centrality
  949. centrality = nx.betweenness_centrality(subgraph, weight='weight')
  951. # Select nodes with highest centrality
  952. top_nodes = sorted(centrality, key=centrality.get, reverse=True)[:max_nodes]
  953. subgraph = subgraph.subgraph(top_nodes).copy()
  955. # Keep only connections between these nodes
  956. for u, v in list(subgraph.edges()):
  957. if u not in top_nodes or v not in top_nodes:
  958. subgraph.remove_edge(u, v)
  960. # Check if subnetwork meets minimum connection requirement
  961. if len(subgraph.edges()) < min_connections:
  962. print(f"Subnetwork connections insufficient ({len(subgraph.edges())}), adding more connections...")
  964. # Add extra connections with largest effect sizes
  965. all_edges = sorted(G.edges(data=True), key=lambda x: abs(x[2]['weight']), reverse=True)
  967. for u, v, data in all_edges:
  968. if u in subgraph and v in subgraph and not subgraph.has_edge(u, v):
  969. subgraph.add_edge(u, v, weight=data['weight'])
  970. if len(subgraph.edges()) >= min_connections:
  971. break
  973. print(f"Final subnetwork: {len(subgraph.nodes())} nodes, {len(subgraph.edges())} edges")
  975. # Create figure
  976. fig = plt.figure(figsize=(10, 6))
  978. # Load cortical surface
  979. fsaverage = datasets.fetch_surf_fsaverage()
  981. # Create three views: Left, Right, Top
  982. views = [
  983. {'title': 'Left Hemisphere', 'hemi': 'left', 'view': 'lateral'},
  984. {'title': 'Right Hemisphere', 'hemi': 'right', 'view': 'lateral'},
  985. {'title': 'Top View', 'hemi': 'both', 'view': 'dorsal'}
  986. ]
  988. axes = []
  989. for i in range(3):
  990. axes.append(fig.add_subplot(1, 3, i+1, projection='3d'))
  992. # Plot for each view
  993. for i, view in enumerate(views):
  994. ax = axes[i]
  996. # Plot cortical surface
  997. if view['hemi'] == 'left':
  998. vertices, faces = surface.load_surf_mesh(fsaverage['pial_left'])
  999. ax.plot_trisurf(vertices[:, 0], vertices[:, 1], vertices[:, 2],
  1000. triangles=faces, color='lightgray', alpha=0.1)
  1001. elif view['hemi'] == 'right':
  1002. vertices, faces = surface.load_surf_mesh(fsaverage['pial_right'])
  1003. ax.plot_trisurf(vertices[:, 0], vertices[:, 1], vertices[:, 2],
  1004. triangles=faces, color='lightgray', alpha=0.1)
  1005. else: # Both hemispheres
  1006. # Left hemisphere
  1007. vertices, faces = surface.load_surf_mesh(fsaverage['pial_left'])
  1008. ax.plot_trisurf(vertices[:, 0], vertices[:, 1], vertices[:, 2],
  1009. triangles=faces, color='lightgray', alpha=0.1)
  1010. # Right hemisphere
  1011. vertices, faces = surface.load_surf_mesh(fsaverage['pial_right'])
  1012. ax.plot_trisurf(vertices[:, 0], vertices[:, 1], vertices[:, 2],
  1013. triangles=faces, color='lightgray', alpha=0.1)
  1015. # Set view
  1016. if view['view'] == 'lateral':
  1017. ax.view_init(elev=10, azim=180 if view['hemi'] == 'left' else 0)
  1018. elif view['view'] == 'dorsal':
  1019. ax.view_init(elev=90, azim=0)
  1021. ax.set_title(view['title'])
  1022. ax.set_axis_off()
  1024. # Plot subnetwork nodes
  1025. node_colors = []
  1026. for node in subgraph.nodes():
  1027. region = subgraph.nodes[node]['region']
  1028. node_colors.append(self.region_colors[region])
  1030. pos = subgraph.nodes[node]['pos']
  1031. ax.scatter(pos[0], pos[1], pos[2], s=150,
  1032. color=self.region_colors[region], alpha=0.9,
  1033. edgecolors='black', zorder=10)
  1035. # Add node labels
  1036. ax.text(pos[0], pos[1], pos[2], node,
  1037. fontsize=9, ha='center', va='center', zorder=11)
  1039. # Plot subnetwork connections
  1040. max_weight = max(abs(data['weight']) for _, _, data in subgraph.edges(data=True))
  1042. for u, v, data in subgraph.edges(data=True):
  1043. pos_u = subgraph.nodes[u]['pos']
  1044. pos_v = subgraph.nodes[v]['pos']
  1046. # Set color and width based on weight
  1047. weight = data['weight']
  1048. color = 'red' if weight < 0 else 'blue' # Negative means enhanced in high load, positive means reduced
  1049. width = 1 + 4 * abs(weight) / max_weight
  1051. # Plot connection line
  1052. ax.plot([pos_u[0], pos_v[0]],
  1053. [pos_u[1], pos_v[1]],
  1054. [pos_u[2], pos_v[2]],
  1055. color=color, linewidth=width, alpha=0.8, zorder=5)
  1057. # Add legend
  1058. legend_elements = [plt.Line2D([0], [0], marker='o', color='w',
  1059. markerfacecolor=color, markersize=10, label=region)
  1060. for region, color in self.region_colors.items()]
  1062. plt.figlegend(handles=legend_elements, loc='lower center', ncol=5, fontsize=10)
  1064. # Add color explanation
  1065. # plt.figtext(0.5, 0.02,
  1066. # "Red: High Load Connection Enhanced | Blue: High Load Connection Reduced",
  1067. # ha='center', fontsize=12)
  1069. plt.tight_layout()
  1070. plt.subplots_adjust(bottom=0.15) # Leave space for legend
  1071. plt.savefig('results/delta/key_subnetwork.svg', format='svg', bbox_inches='tight')
  1072. plt.show()
  1073. print("Key subnetwork plot saved")
  1075. # Return subnetwork info
  1076. return subgraph
  1078. def analyze_subnetwork(self, subgraph):
  1079. """Analyze key subnetwork characteristics"""
  1080. print("\nAnalyzing key subnetwork...")
  1082. # Basic stats
  1083. n_nodes = subgraph.number_of_nodes()
  1084. n_edges = subgraph.number_of_edges()
  1085. density = nx.density(subgraph)
  1087. print(f"Nodes: {n_nodes}, Edges: {n_edges}, Density: {density:.4f}")
  1089. # Node distribution
  1090. region_counts = {}
  1091. for node in subgraph.nodes():
  1092. region = subgraph.nodes[node]['region']
  1093. region_counts[region] = region_counts.get(region, 0) + 1
  1095. print("\nNode region distribution:")
  1096. for region, count in region_counts.items():
  1097. print(f"{region}: {count} nodes ({count/n_nodes*100:.1f}%)")
  1099. # Connection characteristics
  1100. positive_edges = 0
  1101. negative_edges = 0
  1102. total_weight = 0
  1104. for u, v, data in subgraph.edges(data=True):
  1105. weight = data['weight']
  1106. total_weight += abs(weight)
  1107. if weight > 0:
  1108. positive_edges += 1
  1109. else:
  1110. negative_edges += 1
  1112. print(f"\nConnection characteristics:")
  1113. print(f"Enhanced connections: {positive_edges} ({positive_edges/n_edges*100:.1f}%)")
  1114. print(f"Reduced connections: {negative_edges} ({negative_edges/n_edges*100:.1f}%)")
  1115. print(f"Total connection strength: {total_weight:.4f}")
  1117. # Central node analysis
  1118. centrality = nx.betweenness_centrality(subgraph, weight='weight')
  1119. top_nodes = sorted(centrality.items(), key=lambda x: x[1], reverse=True)[:5]
  1121. print("\nNodes with highest centrality:")
  1122. for node, cent in top_nodes:
  1123. region = subgraph.nodes[node]['region']
  1124. print(f"{node} ({region}): {cent:.4f}")
  1126. # Plot subnetwork graph
  1127. plt.figure(figsize=(10, 6))
  1129. # Node positions
  1130. pos = nx.get_node_attributes(subgraph, 'pos')
  1131. pos_2d = {node: (p[0], p[1]) for node, p in pos.items()} # Use x,y coordinates
  1133. # Node colors
  1134. node_colors = [self.region_colors[subgraph.nodes[node]['region']] for node in subgraph.nodes()]
  1136. # Edge colors and widths
  1137. edge_colors = []
  1138. edge_widths = []
  1139. max_weight = max(abs(data['weight']) for _, _, data in subgraph.edges(data=True))
  1141. for u, v, data in subgraph.edges(data=True):
  1142. if data['weight'] < 0: # Negative means enhanced in high load
  1143. edge_colors.append('red')
  1144. else: # Positive means reduced in high load
  1145. edge_colors.append('blue')
  1146. edge_widths.append(1 + 3 * abs(data['weight']) / max_weight)
  1148. # Plot network
  1149. nx.draw_networkx_nodes(subgraph, pos_2d, node_size=800,
  1150. node_color=node_colors, alpha=0.9,
  1151. edgecolors='black')
  1153. nx.draw_networkx_edges(subgraph, pos_2d, edge_color=edge_colors,
  1154. width=edge_widths, alpha=0.7)
  1156. nx.draw_networkx_labels(subgraph, pos_2d, font_size=10)
  1158. # Add legend
  1159. legend_elements = [plt.Line2D([0], [0], marker='o', color='w',
  1160. markerfacecolor=color, markersize=10, label=region)
  1161. for region, color in self.region_colors.items()]
  1163. plt.legend(handles=legend_elements, loc='best')
  1165. plt.title("Key Subnetwork")
  1166. plt.axis('off')
  1167. plt.tight_layout()
  1168. plt.savefig('results/delta/subnetwork_graph.svg', format='svg', bbox_inches='tight')
  1169. plt.show()
  1171. return {
  1172. 'n_nodes': n_nodes,
  1173. 'n_edges': n_edges,
  1174. 'density': density,
  1175. 'region_distribution': region_counts,
  1176. 'positive_edges': positive_edges,
  1177. 'negative_edges': negative_edges,
  1178. 'top_nodes': top_nodes
  1179. }
  1182. def compute_network_metrics(self):
  1183. """Calculate network metrics for each subject, then statistics (mean & std), using only lower triangle matrix"""
  1184. print("Computing network metrics (per subject)...")
  1186. metrics = {}
  1187. metrics_detail = {}
  1189. for condition in ['low_load', 'high_load']:
  1190. # Get connectivity matrices for all subjects
  1191. if condition == 'low_load':
  1192. subj_conn = self.low_load_conn
  1193. else:
  1194. subj_conn = self.high_load_conn
  1196. n_subjects = subj_conn.shape[0]
  1197. n_ch = subj_conn.shape[1]
  1198. lower_tri_indices = np.tril_indices(n_ch, k=-1)
  1200. # Use connectivity values from all subjects to calculate global threshold (ensure consistency)
  1201. all_matrix_lower = []
  1202. for subj in range(n_subjects):
  1203. matrix = subj_conn[subj]
  1204. matrix_lower = matrix[lower_tri_indices]
  1205. all_matrix_lower.append(matrix_lower)
  1206. all_matrix_lower = np.concatenate(all_matrix_lower)
  1207. matrix_abs_lower = np.abs(all_matrix_lower)
  1208. max_val = np.max(matrix_abs_lower)
  1209. mean_val = np.mean(matrix_abs_lower)
  1210. std_val = np.std(matrix_abs_lower)
  1211. threshold = min(mean_val, max_val * 0.5)
  1212. if threshold > max_val * 0.3:
  1213. threshold = max_val * 0.1
  1216. print(f"{condition} Network Metrics Calculation - Threshold: {threshold:.4f}")
  1218. # Calculate metrics for each subject
  1219. density_list = []
  1220. clustering_list = []
  1221. path_length_list = []
  1222. efficiency_list = []
  1223. edge_count_list = []
  1225. for subj in range(n_subjects):
  1226. matrix = subj_conn[subj]
  1227. G = nx.Graph()
  1228. edge_count = 0
  1229. # Iterate only lower triangle (excluding diagonal)
  1230. for i in range(n_ch):
  1231. for j in range(0, i):
  1232. if matrix[i, j] > threshold:
  1233. G.add_edge(i, j, weight=matrix[i, j])
  1234. edge_count += 1
  1236. edge_count_list.append(edge_count)
  1238. # Calculate metrics
  1239. if len(G.edges()) > 0:
  1240. # Density
  1241. density = nx.density(G)
  1242. # Clustering coefficient
  1243. clustering = nx.average_clustering(G)
  1244. # Average path length
  1245. try:
  1246. path_length = nx.average_shortest_path_length(G)
  1247. except:
  1248. path_length = np.nan
  1249. # Global efficiency
  1250. try:
  1251. efficiency = nx.global_efficiency(G)
  1252. except:
  1253. efficiency = np.nan
  1254. else:
  1255. density = 0
  1256. clustering = 0
  1257. path_length = np.nan
  1258. efficiency = np.nan
  1260. density_list.append(density)
  1261. clustering_list.append(clustering)
  1262. path_length_list.append(path_length)
  1263. efficiency_list.append(efficiency)
  1265. # Calculate mean and std
  1266. metrics[condition] = {
  1267. 'Density': np.nanmean(density_list),
  1268. 'Clustering': np.nanmean(clustering_list),
  1269. 'Path_Length': np.nanmean(path_length_list),
  1270. 'Efficiency': np.nanmean(efficiency_list),
  1271. 'Edge_Count': np.nanmean(edge_count_list),
  1272. 'Threshold': threshold,
  1273. 'Density_std': np.nanstd(density_list),
  1274. 'Clustering_std': np.nanstd(clustering_list),
  1275. 'Path_Length_std': np.nanstd(path_length_list),
  1276. 'Efficiency_std': np.nanstd(efficiency_list),
  1277. 'Edge_Count_std': np.nanstd(edge_count_list)
  1278. }
  1279. # Also save detailed metrics for each subject
  1280. metrics_detail[condition] = {
  1281. 'Density': density_list,
  1282. 'Clustering': clustering_list,
  1283. 'Path_Length': path_length_list,
  1284. 'Efficiency': efficiency_list,
  1285. 'Edge_Count': edge_count_list
  1286. }
  1288. self.network_metrics = metrics
  1289. self.network_metrics_detail = metrics_detail
  1291. # Plot metrics comparison (mean + std)
  1292. fig, axes = plt.subplots(2, 3, figsize=(6, 4))
  1293. metric_names = ['Density', 'Clustering', 'Path_Length', 'Efficiency', 'Edge_Count', 'Threshold']
  1295. for i, metric in enumerate(metric_names):
  1296. ax = axes[i//3, i%3]
  1297. low_val = metrics['low_load'][metric]
  1298. high_val = metrics['high_load'][metric]
  1299. if metric != 'Threshold':
  1300. low_std = metrics['low_load'][metric + '_std']
  1301. high_std = metrics['high_load'][metric + '_std']
  1302. t, p = stats.ttest_rel(np.array(self.network_metrics_detail['low_load'][metric]), np.array(self.network_metrics_detail['high_load'][metric]))
  1303. print(f"{metric} t-test: {t:.3f}, p={p:.3f}")
  1304. # Plot bars for LCW and HCW, blue for LCW, red for HCW, alpha 0.5, width 0.3, no fill
  1305. bars = []
  1306. bar_lcw = ax.bar(
  1307. ['LCW'], [low_val], yerr=[low_std], capsize=4,
  1308. color='none', edgecolor='blue', alpha=0.5, width=0.3, label='LCW'
  1309. )
  1310. bar_hcw = ax.bar(
  1311. ['HCW'], [high_val], yerr=[high_std], capsize=4,
  1312. color='none', edgecolor='red', alpha=0.5, width=0.3, label='HCW'
  1313. )
  1314. bars = [bar_lcw[0], bar_hcw[0]]
  1315. else:
  1316. # No error bar for threshold
  1317. bar_lcw = ax.bar(
  1318. ['LCW'], [low_val], color='none', edgecolor='blue', alpha=0.5, width=0.3, label='LCW'
  1319. )
  1320. bar_hcw = ax.bar(
  1321. ['HCW'], [high_val], color='none', edgecolor='red', alpha=0.5, width=0.3, label='HCW'
  1322. )
  1323. bars = [bar_lcw[0], bar_hcw[0]]
  1324. ax.set_title(metric)
  1325. #ax.set_ylabel('Value')
  1326. # # Add value labels
  1327. # for bar, val in zip(bars, [low_val, high_val]):
  1328. # if not np.isnan(val):
  1329. # ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01,
  1330. # f'{val:.3f}', ha='center', va='bottom', fontsize=12)
  1331. # # Add legend only once
  1332. # if i == 0:
  1333. # ax.legend(['LCW', 'HCW'])
  1335. plt.tight_layout()
  1336. plt.savefig('results/delta/network_metrics.svg', format='svg', bbox_inches='tight')
  1337. plt.show()
  1339. def save_results_table(self):
  1340. """Save results table"""
  1341. print("Saving results table...")
  1343. # Create results DataFrame
  1344. results_data = []
  1346. # Save only lower triangle (excluding diagonal) connectivity results
  1347. for i in range(1, len(self.channel_names)):
  1348. for j in range(i):
  1349. results_data.append({
  1350. 'Channel_From': self.channel_names[i],
  1351. 'Channel_To': self.channel_names[j],
  1352. 'Region_From': self.get_region(self.channel_names[i]),
  1353. 'Region_To': self.get_region(self.channel_names[j]),
  1354. 'Low_Load_Connectivity': self.connectivity_matrices['low_load'][i, j],
  1355. 'High_Load_Connectivity': self.connectivity_matrices['high_load'][i, j],
  1356. 'Difference': (self.connectivity_matrices['high_load'][i, j] -
  1357. self.connectivity_matrices['low_load'][i, j]),
  1358. 'P_Value': self.statistical_results['p_values'][i, j],
  1359. 'P_Corrected': self.statistical_results['p_corrected'][i, j],
  1360. 'Significant': self.statistical_results['significant'][i, j],
  1361. 'Effect_Size': self.statistical_results['effect_sizes'][i, j]
  1362. })
  1363. # Create DataFrame
  1364. df = pd.DataFrame(results_data)
  1366. # Save to CSV
  1367. df.to_csv('results/delta/connectivity_results.csv', index=False)
  1369. # Save network metrics
  1370. metrics_df = pd.DataFrame(self.network_metrics).T
  1371. metrics_df.to_csv('results/delta/network_metrics.csv')
  1373. print("Results table saved to results/ directory")
  1375. def get_region(self, channel_name):
  1376. """Get brain region for a channel"""
  1377. for region, channels in self.regions.items():
  1378. if channel_name in channels:
  1379. return region
  1380. return 'Unknown'
  1382. def run_analysis(self, window_size=1024, overlap=0.5, method='wpli',
  1383. fmin=4, fmax=8, alpha=0.2, batch_size=50):
  1384. """Run full analysis"""
  1385. print("Starting brain network connectivity analysis...")
  1387. # Load data
  1388. self.load_data()
  1390. # Preprocess
  1391. self.preprocess_data(window_size, overlap)
  1393. # Compute connectivity
  1394. self.compute_connectivity(method, fmin, fmax, batch_size)
  1396. # Statistical test
  1397. self.statistical_test(alpha)
  1399. # Paired T-test comparison
  1400. self.statistical_test_t_test(alpha)
  1402. # Compare two test methods
  1403. self.compare_test_results()
  1405. # Plot results
  1406. self.plot_connectivity_matrices()
  1407. self.plot_network_graph()
  1408. self.plot_brain_surface()
  1410. # Compute network metrics
  1411. self.compute_network_metrics()
  1415. # Save results
  1416. self.save_results_table()
  1418. # Plot key subnetwork
  1419. subgraph = self.plot_key_subnetwork(min_connections=10, max_nodes=15)
  1421. # Analyze subnetwork characteristics
  1422. if subgraph:
  1423. subnetwork_stats = self.analyze_subnetwork(subgraph)
  1425. # Save subnetwork analysis results
  1426. with open('results/delta/subnetwork_analysis.json', 'w') as f:
  1427. json.dump(subnetwork_stats, f, indent=4)
  1430. print("Analysis completed!")
  1432. # Main program
  1433. if __name__ == "__main__":
  1434. # Create analyzer
  1435. analyzer = BrainConnectivityAnalyzer()
  1437. # Run analysis
  1438. analyzer.run_analysis(
  1439. window_size=512, # 8 second window (128Hz sampling rate)
  1440. overlap=0, # 50% overlap
  1441. method='pli', # Coherence
  1442. fmin=1, # alpha band lower limit
  1443. fmax=4, # alpha band upper limit
  1444. alpha=0.05, # Significance level
  1445. )

plot_connectivity.py at commit 64e7e01, no license · at the source

Overview

Authors: Ruixiang Liu1, Huan Zhang1, Chang Liu1, Xinmeng Xu1, Xu Zhao1, Xuewen Wang1, Fulong Zhang1, Xianzheng Sha1, Limin Sun2, Zhi Wang1, Shuo Li3, Shijie Chang1
ORCID iDs: Ruixiang Liu, Zhi Wang, Shuo Li, Shijie Chang
  1. Department of Biomedical Engineering, China Medical University,Shenyang, Liaoning China
  2. Shanghai Institute of Microsystem and Information Technology, Chinese Academy of Sciences,Shanghai, China
  3. School of Life Science, China Medical University,Shenyang, Liaoning China
Institutions: China Medical University (China); Chinese Academy of Sciences (China)
Journal: Communications biology, volume 9, issue 1, article 1139
Dates: received 19 December 2025; accepted 22 May 2026; published online 29 May 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s42003-026-10394-7 · PMID 42215620 · PMCID PMC13507231 · OpenAlex W7162762835
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), human (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Preprocessing, Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Evoked potentials, Graphs, fMRI & imaging
Keywords: Cognitive control, Network models
MeSH: Cognition*, Reaction Time*, Speech*, Speech Perception*, Adult, Electroencephalography, Female, Humans, Male, Neural Networks, Computer, Young Adult (* major topic)
Topic: Neuroscience and Music Perception (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: This work was supported by the National Key Research and Development Program of China (no. 2022YFF1202800), the General Research Program of Liaoning Provincial Department of Education (no. JYTMS20230133), and the Natural Science Foundation of Liaoning Province (no. 2021-YGJC14)
Citations: not cited yet (Europe PMC); 45 references in the paper

Abstract

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

Repositories

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

ruix6/cognitiveload_audio_analysis

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 64e7e019d149d2fd24d558df25a47e2ffee5e273, 17 December 2025
Languages: Python (11)
Size: 38 files, 11 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, environment (requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (10 files), SciPy (10 files), Matplotlib (8 files), MNE-Python (6 files), pandas (5 files), seaborn (5 files), MNE-Connectivity (1 file), NetworkX (1 file), Nilearn (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
12 files
At the source: github.com/ruix6/cognitiveload_audio_analysis

Zenodo 20161055

License: CC-BY-4.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 0 files, 0 scripts
Software Heritage: not checked
Found in: “Code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
At the source:

Code availability statement

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

Read it in the paper: doi.org/10.1038/s42003-026-10394-7.

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:

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

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

  • it says that the data are available on request

Read it in the paper: doi.org/10.1038/s42003-026-10394-7.

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

Recorded: type, language, journal, volume, issue, pages, dates, 12 authors, 2 keywords, 11 MeSH terms, 1 funder, 45 references.

Cite

This paper

Liu, R., Zhang, H., Liu, C., Xu, X., Zhao, X., Wang, X., Zhang, F., Sha, X., Sun, L., Wang, Z., Li, S., & Chang, S. (2026). Cognitive load weakens neural speech tracking without altering response timing. Communications biology, 9(1), 1139. https://doi.org/10.1038/s42003-026-10394-7

BibTeX

@article{liu2026cognitive,
author = {Liu, Ruixiang and Zhang, Huan and Liu, Chang and Xu, Xinmeng and Zhao, Xu and Wang, Xuewen and Zhang, Fulong and Sha, Xianzheng and Sun, Limin and Wang, Zhi and Li, Shuo and Chang, Shijie},
title = {{Cognitive load weakens neural speech tracking without altering response timing}},
journal = {Communications biology},
year = {2026},
month = may,
volume = {9},
number = {1},
pages = {1139},
publisher = {Nature Publishing Group},
issn = {2399-3642},
doi = {10.1038/s42003-026-10394-7},
url = {https://doi.org/10.1038/s42003-026-10394-7},
pmid = {42215620},
pmcid = {PMC13507231}
}

RIS

TY - JOUR
AU - Liu, Ruixiang
AU - Zhang, Huan
AU - Liu, Chang
AU - Xu, Xinmeng
AU - Zhao, Xu
AU - Wang, Xuewen
AU - Zhang, Fulong
AU - Sha, Xianzheng
AU - Sun, Limin
AU - Wang, Zhi
AU - Li, Shuo
AU - Chang, Shijie
TI - Cognitive load weakens neural speech tracking without altering response timing
T2 - Communications biology
J2 - Commun Biol
PY - 2026
DA - 2026/05/29
VL - 9
IS - 1
SP - 1139
SN - 2399-3642
PB - Nature Publishing Group
DO - 10.1038/s42003-026-10394-7
UR - https://doi.org/10.1038/s42003-026-10394-7
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s42003-026-10394-7",
"type": "article-journal",
"title": "Cognitive load weakens neural speech tracking without altering response timing",
"container-title": "Communications biology",
"author": [
{
"family": "Liu",
"given": "Ruixiang"
},
{
"family": "Zhang",
"given": "Huan"
},
{
"family": "Liu",
"given": "Chang"
},
{
"family": "Xu",
"given": "Xinmeng"
},
{
"family": "Zhao",
"given": "Xu"
},
{
"family": "Wang",
"given": "Xuewen"
},
{
"family": "Zhang",
"given": "Fulong"
},
{
"family": "Sha",
"given": "Xianzheng"
},
{
"family": "Sun",
"given": "Limin"
},
{
"family": "Wang",
"given": "Zhi"
},
{
"family": "Li",
"given": "Shuo"
},
{
"family": "Chang",
"given": "Shijie"
}
],
"container-title-short": "Commun Biol",
"volume": "9",
"issue": "1",
"page": "1139",
"DOI": "10.1038/s42003-026-10394-7",
"PMID": "42215620",
"PMCID": "PMC13507231",
"ISSN": "2399-3642",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s42003-026-10394-7",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
29
]
]
}
}

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.1093/nc/niag029 [code]
A data-driven approach to identifying and evaluating connectivity-based neural correlates of conscious visual perception.
Journal: Neuroscience of consciousness
In common: MNE-Connectivity, MNE-Python, Nilearn, 7 other tools, cognitive, 1 reference
[2] doi:10.1097/j.pain.0000000000004044 [code]
No effect of rhythmic visual stimulation on experimental pain perception.
Journal: Pain
In common: MNE-Connectivity, MNE-Python, Nilearn, 6 other tools, EEG, cognitive, 1 reference
[3] doi:10.1093/braincomms/fcag261 [code]
Cortical speech envelope tracking reflects lesion-symptom profiles in post-stroke aphasia.
Journal: Brain communications
In common: cognitive, 8 references
[4] doi:10.1162/imag.a.1245 [code]
Towards precision EEG connectomics: Evaluating the benefits of dense sampling.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MNE-Connectivity, MNE-Python, Nilearn, 6 other tools, EEG, 1 reference
[5] doi:10.1523/eneuro.0041-26.2026 [code]
Ocular Speech Tracking Persists in Blindness, but Its Dynamics and Oculo-Cerebral Connectivity Depend on Visual Status.
Journal: eNeuro
In common: MNE-Connectivity, MNE-Python, statsmodels, 5 other tools, cognitive, 2 references
[6] doi:10.3389/fncom.2026.1786996 [code]
Schumann-anchored golden ratio organization of human neural oscillations.
Journal: Frontiers in computational neuroscience
In common: MNE-Connectivity, MNE-Python, NetworkX, 6 other tools, EEG, 1 reference
[7] doi:10.3390/s26134019 [code]
NeuroStat: An Open-Source EEG Connectivity Platform for Randomised Controlled Trials.
Journal: Sensors (Basel, Switzerland)
In common: MNE-Connectivity, MNE-Python, NetworkX, 4 other tools, EEG, 3 references
[8] doi:10.1016/j.ibneur.2026.05.013 [code]
Anticipatory slow potentials before auditory feedback show posterior predominance but limited condition effects in speech-in-noise.
Journal: IBRO neuroscience reports
In common: MNE-Python, statsmodels, pandas, 3 other tools, EEG, cognitive, 4 references
[9] doi:10.1038/s41597-026-07350-9 [code]
An open multi-center MEG-EEG dataset for studying conscious visual perception.
Journal: Scientific data
In common: MNE-Connectivity, MNE-Python, Nilearn, 6 other tools, EEG
[10] doi:10.1038/s41597-026-07377-y [code]
An open-access multi-site fMRI dataset for investigating conscious visual perception.
Journal: Scientific data
In common: MNE-Connectivity, MNE-Python, Nilearn, 6 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.