OSCR

An Intraoperative EEG Biomarker for Postoperative Delirium Predicting Based on Interpretable Deep Learning Framework.

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] § Results › Best Temporal Filter Captures an EEG Signature of POD Individuals ↔ plot/Figure4.ipynb, lines 254–318 · score 0.69 · gradient boosting machine, multilayer perceptron, random forest, 10 %, training, accuracies
  2. [2] § Results › Best Temporal Filter Captures an EEG Signature of POD Individuals ↔ plot/figure_3.ipynb, lines 282–359 · score 0.69 · gradient boosting machine, multilayer perceptron, random forest, 10 %, training, accuracies
  3. [3] § Materials and Methods › Filter Analysis ↔ plot/Figure4.ipynb, lines 254–318 · score 0.68 · multilayer perceptron, gradient boosting, random forest, training, model
  4. [4] § Materials and Methods › Filter Analysis ↔ plot/figure_3.ipynb, lines 282–359 · score 0.68 · multilayer perceptron, gradient boosting, random forest, training, model
  5. [5] § Results › A Novel EEG Waveform as a Potential Biomarker for POD Early Warning ↔ plot/Figure5.ipynb, lines 187–248 · score 0.63 · power spectral density, confidence interval, target wave, 12 Hz
  6. [6] § Results › A Novel EEG Waveform as a Potential Biomarker for POD Early Warning ↔ plot/Figure5.ipynb, lines 561–662 · score 0.58 · biomarker events, confidence intervals, brain regions, bootstrap, min, POD
  7. [7] § Results › A Novel EEG Waveform as a Potential Biomarker for POD Early Warning ↔ plot/Figure5.ipynb, lines 561–662 · score 0.53 · confidence interval, brain regions, event, bootstrap, min, biomarkers
  8. [8] § Results › A Novel EEG Waveform as a Potential Biomarker for POD Early Warning ↔ supp_plot/supp_figure_4.ipynb, lines 74–140 · score 0.52 · power spectral density, target wave, PSD, POD, 12 Hz

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

Jupyter notebook · 662 lines · 25 KB · no license · 3 matches

  1. # %% [markdown]
  2. # # Figure 5
  4. # %%
  5. import numpy as np
  6. import pandas as pd
  7. import matplotlib.pyplot as plt
  8. import seaborn as sns
  9. import torch
  10. import torch.nn.functional as F
  11. from scipy import stats
  12. import os
  13. import pickle
  14. from sklearn.preprocessing import StandardScaler
  15. import mne
  16. from matplotlib.colors import Normalize
  17. from matplotlib.colors import TwoSlopeNorm
  18. from scipy.stats import bootstrap
  19. import matplotlib as mpl
  21. # %% [markdown]
  22. # # Figure 5A
  24. # %%
  25. import os
  26. import pickle
  27. import numpy as np
  28. import matplotlib.pyplot as plt
  29. import matplotlib.patches as patches
  31. def highlight_interval_visualization(load_path, signal_data_path, subject_ids, save_root, sampling_rate=125):
  32. """
  33. Visualizes highlighted intervals and signal data for different channel positions.
  34. A plot is generated for each minute of data.
  36. Arguments:
  37. - load_path: str, path to the highlighted interval data (pickle format).
  38. - signal_data_path: str, path to processed signal data (pickle format, organized by channel).
  39. - subject_ids: list, list of subject IDs to visualize.
  40. - save_root: str, directory to save the generated images.
  41. - sampling_rate: int, the EEG data sampling rate (default is 125Hz).
  43. Returns:
  44. - None: This function saves visualization results as image files in the specified folder.
  45. """
  47. # Load the highlight regions and signal data from the provided paths
  48. with open(load_path, 'rb') as file:
  49. highlight_regions_per_channel = pickle.load(file)
  51. with open(signal_data_path, 'rb') as file:
  52. signal_data = pickle.load(file)
  54. # Configure plot appearance
  55. plt.rcParams.update({
  56. 'font.family': 'Times New Roman', # Recommended journal font
  57. 'font.size': 12,
  58. 'axes.labelsize': 14,
  59. 'axes.linewidth': 1.5,
  60. 'legend.fontsize': 10,
  61. 'xtick.labelsize': 12,
  62. 'ytick.labelsize': 12,
  63. 'pdf.fonttype': 42,
  64. 'ps.fonttype': 42,
  65. 'figure.dpi': 300
  66. })
  68. # Process each subject
  69. for subject_id in subject_ids:
  70. # Extract highlight intervals for the current subject
  71. subject_highlight = {}
  72. for channel, highlights in highlight_regions_per_channel.items():
  73. highlight_data = next((item for item in highlights if item['subject_id'] == subject_id), None)
  74. if highlight_data:
  75. subject_highlight[channel] = highlight_data['highlight_intervals']
  77. # Extract signal data for the current subject
  78. subject_signal = {}
  79. for channel, signals in signal_data.items():
  80. signal_data_item = next((item for item in signals if item['subject_id'] == subject_id), None)
  81. if signal_data_item:
  82. subject_signal[channel] = signal_data_item['processed_data']
  84. # Calculate the number of minutes of signal data
  85. num_samples_per_minute = sampling_rate * 10
  86. total_samples = len(next(iter(subject_signal.values()))) # Get the number of samples from one channel
  87. num_minutes = total_samples // num_samples_per_minute
  89. # Generate one plot for each minute
  90. for minute in range(num_minutes):
  91. fig, ax = plt.subplots(figsize=(6.5, 8)) # Standard size for Nature journal (inches)
  92. plt.subplots_adjust(left=0.15, right=0.95, top=0.93, bottom=0.08) # Adjust layout margins
  94. num_channels = len(subject_signal)
  95. bar_height = 0.8
  97. # Plot the signal data for each channel
  98. for channel_id, signal in subject_signal.items():
  99. signal_start = minute * num_samples_per_minute
  100. signal_end = (minute + 1) * num_samples_per_minute
  101. signal_segment = signal[signal_start:signal_end]
  102. signal_segment = normalize_signal(signal_segment)
  103. time_segment = np.linspace(signal_start / sampling_rate, signal_end / sampling_rate, len(signal_segment))
  105. # Plot the signal waveform for the current channel
  106. ax.plot(time_segment, signal_segment + channel_id - 0.5,
  107. color="#2f2f2f", alpha=0.95, linewidth=1.2, solid_capstyle='round')
  109. # Plot the highlighted intervals for the current channel
  110. if channel_id not in subject_highlight:
  111. continue
  112. channel_highlights = subject_highlight[channel_id]
  113. for highlight in channel_highlights:
  114. start, end = highlight
  115. start_time = start / sampling_rate
  116. end_time = end / sampling_rate
  118. # Check if the highlight interval falls within the current minute's time window
  119. if start_time >= signal_start / sampling_rate and end_time <= signal_end / sampling_rate:
  120. ax.add_patch(patches.Rectangle(
  121. (start_time, channel_id - 0.5),
  122. end_time - start_time,
  123. bar_height,
  124. color='orange',
  125. alpha=0.45,
  126. edgecolor="orange",
  127. linewidth=0.7,
  128. linestyle="-"
  129. ))
  131. # Customize the plot appearance
  132. channel_labels = ["Fp1", "Fp2", "Fz", "F3", "F4", "F7", "F8", "FCz", "FC3", "FC4", "FT7", "FT8", "Cz",
  133. "C3", "C4", "T3", "T4", "CP3", "CP4", "TP7", "TP8", "Pz", "P3", "P4", "T5", "T6", "Oz", "O1", "O2"]
  134. ax.set_xlim(minute * 10, (minute + 1) * 10)
  135. ax.set_ylim(-0.5, num_channels - 0.5)
  136. ax.set_yticks(range(num_channels))
  137. ax.set_yticklabels(channel_labels, fontstyle='italic', color="black")
  138. ax.yaxis.set_tick_params(width=0.5)
  139. ax.xaxis.set_tick_params(width=0.5)
  140. ax.set_xlabel("Time (s)", labelpad=3)
  141. ax.set_ylabel("EEG Channels", labelpad=3)
  142. ax.spines['right'].set_visible(False)
  143. ax.spines['top'].set_visible(False)
  144. ax.spines['left'].set_linewidth(0.5)
  145. ax.spines['bottom'].set_linewidth(0.5)
  146. ax.invert_yaxis()
  148. # Title the plot
  149. ax.set_title(f"Subject {subject_id} | Time window: {minute + 1}", fontweight='semibold', pad=12)
  151. # Save the plot as an image
  152. save_path = os.path.join(save_root, f"{subject_id}_second_{minute + 1}.png")
  153. plt.savefig(save_path, dpi=600, bbox_inches='tight', pil_kwargs={'compression': 'tiff_lzw'})
  154. plt.close()
  156. def normalize_signal(signal):
  157. """Normalize the signal data to be between -1 and 1."""
  158. return (signal - np.min(signal)) / (np.max(signal) - np.min(signal)) * 2 - 1
  160. # If necessary, please contact the corresponding author to obtain the data.
  162. # %% [markdown]
  163. # # Figure 5B
  165. # %%
  167. # 读取 .npz 文件
  168. data = np.load('../dataset/figure5_B_plot_variables.npz')
  170. # 获取文件中的变量
  171. freqs_tar = data['freqs_tar']
  172. psd_tar = data['psd_tar']
  173. ci_lower_tar = data['ci_lower_tar']
  174. ci_upper_tar = data['ci_upper_tar']
  175. freqs_ori = data['freqs_ori']
  176. psd_ori = data['psd_ori']
  177. ci_lower_ori = data['ci_lower_ori']
  178. ci_upper_ori = data['ci_upper_ori']
  179. mean_psd_tar = data['mean_psd_tar']
  180. mean_psd_ori = data['mean_psd_ori']
  181. freqs_show = data['freqs_show']
  182. sig_freqs = data['sig_freqs']
  183. pvals_corrected = data['pvals_corrected']
  184. ci_lower_diff = data['ci_lower_diff']
  185. ci_upper_diff = data['ci_upper_diff']
  187. # %%
  188. import matplotlib.pyplot as plt
  189. import numpy as np
  191. # Define frequency limit and mask for frequency range
  192. freq_limit = 30
  193. freq_mask = freqs_tar <= freq_limit
  194. freqs_show = freqs_tar[freq_mask]
  196. # Update plotting parameters for a professional look
  197. plt.rcParams.update({
  198. 'font.family': 'DejaVu Sans',
  199. 'font.size': 12, # Base font size
  200. 'axes.labelsize': 14, # Axis label font size
  201. 'axes.linewidth': 1.5, # Axis line width
  202. 'legend.fontsize': 10, # Legend font size
  203. 'xtick.labelsize': 12, # X-axis tick label font size
  204. 'ytick.labelsize': 12, # Y-axis tick label font size
  205. 'pdf.fonttype': 42, # Ensure the output text is editable
  206. 'ps.fonttype': 42,
  207. 'figure.dpi': 300 # High resolution for the figure
  208. })
  210. # Create the plot with specified figure size
  211. fig, ax = plt.subplots(figsize=(4.3*1.5, 3*1.5))
  213. # Plot the target wave (mean and confidence intervals)
  214. ax.plot(freqs_tar[freq_mask], mean_psd_tar, color='orange', alpha=0.75, label='Target wave', zorder=1)
  215. ax.fill_between(freqs_tar[freq_mask], ci_lower_tar, ci_upper_tar, color='orange', alpha=0.25)
  217. # Plot the original signal (mean and confidence intervals)
  218. ax.plot(freqs_tar[freq_mask], mean_psd_ori, color='gray', alpha=0.75, label='Original signal', zorder=2)
  219. ax.fill_between(freqs_tar[freq_mask], ci_lower_ori, ci_upper_ori, color='gray', alpha=0.25)
  221. # Plot the confidence interval of the difference between target and original signals
  222. ax.fill_between(freqs_tar[freq_mask], ci_lower_diff, ci_upper_diff, color='red', alpha=0.25, label='95% CI of difference', zorder=3)
  224. # Highlight the significant frequencies with stars
  225. sig_freqs = freqs_show[pvals_corrected < 0.05] # Frequencies with p-values < 0.05
  226. sig_freqs = sig_freqs[sig_freqs < 16] # Limit to frequencies below 16 Hz
  227. if len(sig_freqs) > 0:
  228. ax.plot(sig_freqs, [np.max([mean_psd_tar, mean_psd_ori]) * 1.1] * len(sig_freqs),
  229. lw=0, marker='*', color='k', markersize=8, label='p < 0.05')
  231. # Adjust plot formatting
  232. ax.set_xlim(-0.5, freq_limit + 0.5)
  233. ax.set_xlabel('Frequency (Hz)') # X-axis label
  234. ax.set_ylabel('Power (a.u.)') # Y-axis label with units
  236. # Customize grid if needed (commented out for clarity)
  237. # ax.grid(True, linestyle=':', alpha=0.6) # Optional grid lines for better visualization
  239. # Add legend
  240. legend = ax.legend(frameon=True, loc='upper right')
  241. legend.get_frame().set_linewidth(1.2) # Set legend border width
  242. legend.get_frame().set_edgecolor('whitesmoke') # Set legend border color
  244. # Adjust layout to fit the plot nicely
  245. plt.tight_layout()
  247. # Show the plot (if running interactively)
  248. # plt.show()
  251. # %%
  252. from scipy.signal import butter, filtfilt, welch
  253. from scipy.stats import t
  255. # Define the mapping of regions to channels in a dictionary
  256. net_dict = {
  257. 'Forehead': list(range(0, 2)),
  258. 'Frontal': list(range(2, 12)),
  259. 'Center': [12, 13, 14, 17, 18],
  260. 'Temporal': [15, 16, 19, 20, 24, 25],
  261. 'Parietal': [21, 22, 23],
  262. 'Occipital': [26, 27, 28],
  263. 'All': list(range(0, 29)) # Mapping includes all channels
  264. }
  266. fs = 125 # Sampling frequency
  268. def calculate_power_per_subject(detection_datas, region_dict):
  269. """
  270. Calculate the total power of EEG signals in different frequency bands for each subject,
  271. averaged over specified highlight intervals for each region.
  273. Arguments:
  274. - detection_datas: Data for the EEG signals with highlight intervals.
  275. - region_dict: Mapping of regions to channel indices.
  277. Returns:
  278. - subject_region_mean_intervals: List of dictionaries with average power for each region per subject.
  279. """
  280. subject_region_mean_intervals = []
  282. # Iterate over each subject's data
  283. for j, subject_data in enumerate(detection_datas[0]): # Assuming the subject data is in the first element
  284. subject_id = subject_data['subject_id']
  286. # Store the region-wise mean power for each subject
  287. region_mean_per_subject = {}
  289. # Iterate through the regions and their channels
  290. for region, channels in region_dict.items():
  291. highlight_intervals_per_region = []
  293. # Iterate through each channel in the region
  294. for channel in channels:
  295. highlight_intervals = detection_datas[channel][j]['highlight_intervals']
  297. # Process each highlight interval
  298. for highlight_interval in highlight_intervals:
  299. # Normalize the highlight interval
  300. segment_normalized = highlight_interval / np.max(np.abs(highlight_interval))
  302. # Calculate the power spectrum using Welch's method
  303. frequencies, psd = welch(segment_normalized, fs=fs, nperseg=100)
  305. # Calculate the total power of the signal
  306. total_power = np.trapz(psd, frequencies) / len(highlight_interval) * fs
  307. highlight_intervals_per_region.append(total_power)
  309. # Compute the average power for the region across channels
  310. region_mean_per_subject[region] = np.mean(highlight_intervals_per_region)
  312. # Store the region-wise power results for the subject
  313. subject_region_mean_intervals.append(region_mean_per_subject)
  315. return subject_region_mean_intervals
  317. def calculate_center_frequency_per_subject(detection_datas, region_dict):
  318. """
  319. Calculate the center frequency of EEG signals for each subject, averaged over highlight intervals
  320. for each region.
  322. Arguments:
  323. - detection_datas: Data for the EEG signals with highlight intervals.
  324. - region_dict: Mapping of regions to channel indices.
  326. Returns:
  327. - subject_region_mean_intervals: List of dictionaries with average center frequency for each region per subject.
  328. """
  329. subject_region_mean_intervals = []
  331. # Iterate over each subject's data
  332. for j, subject_data in enumerate(detection_datas[0]):
  333. subject_id = subject_data['subject_id']
  335. # Store the region-wise center frequency for each subject
  336. region_mean_per_subject = {}
  338. # Iterate through the regions and their channels
  339. for region, channels in region_dict.items():
  340. highlight_intervals_per_region = []
  342. # Iterate through each channel in the region
  343. for channel in channels:
  344. highlight_intervals = detection_datas[channel][j]['highlight_intervals']
  346. # Process each highlight interval
  347. for highlight_interval in highlight_intervals:
  348. # Calculate the power spectral density using Welch's method
  349. frequencies, psd = welch(highlight_interval, fs=fs, nperseg=100)
  351. # Calculate the center frequency as the weighted average of the frequencies
  352. center_frequency = np.sum(frequencies * psd) / np.sum(psd)
  353. highlight_intervals_per_region.append(center_frequency)
  355. # Compute the average center frequency for the region across channels
  356. region_mean_per_subject[region] = np.mean(highlight_intervals_per_region)
  358. # Store the region-wise center frequency results for the subject
  359. subject_region_mean_intervals.append(region_mean_per_subject)
  361. return subject_region_mean_intervals
  363. def calculate_highlight_intervals_per_subject(detection_datas, region_dict):
  364. """
  365. Calculate the number of highlight intervals for each region in the EEG data for each subject.
  367. Arguments:
  368. - detection_datas: Data for the EEG signals with highlight intervals.
  369. - region_dict: Mapping of regions to channel indices.
  371. Returns:
  372. - subject_region_mean_intervals: List of dictionaries with the number of highlight intervals per region per subject.
  373. """
  374. subject_region_mean_intervals = []
  376. # Iterate over each subject's data
  377. for j, subject_data in enumerate(detection_datas[0]):
  378. subject_id = subject_data['subject_id']
  380. # Store the region-wise highlight interval count for each subject
  381. region_mean_per_subject = {}
  383. # Iterate through the regions and their channels
  384. for region, channels in region_dict.items():
  385. highlight_intervals_per_region = []
  387. # Iterate through each channel in the region
  388. for channel in channels:
  389. highlight_intervals = detection_datas[channel][j]['highlight_intervals']
  391. # Count the number of highlight intervals for the channel
  392. highlight_intervals_per_region.append(len(highlight_intervals))
  394. # Compute the average number of highlight intervals for the region
  395. region_mean_per_subject[region] = np.mean(highlight_intervals_per_region)
  397. # Store the region-wise highlight interval counts for the subject
  398. subject_region_mean_intervals.append(region_mean_per_subject)
  400. return subject_region_mean_intervals
  402. def extract_region_means(subject_region_means, region_name):
  403. """
  404. Extract the region-specific means for all subjects.
  406. Arguments:
  407. - subject_region_means: List of dictionaries containing region-wise means for each subject.
  408. - region_name: The region to extract means for.
  410. Returns:
  411. - np.array: Array of region-specific means across subjects.
  412. """
  413. return np.array([subject[region_name] for subject in subject_region_means])
  415. def mean_difference(data, n_group_A):
  416. """
  417. Calculate the difference in means between two groups.
  419. Arguments:
  420. - data: Combined data from both groups.
  421. - n_group_A: The number of samples in group A.
  423. Returns:
  424. - The difference in means between the two groups.
  425. """
  426. group_A = data[:n_group_A]
  427. group_B = data[n_group_A:]
  428. return np.mean(group_A) - np.mean(group_B)
  430. def bootstrap_region_comparison(subject_region_mean_A, subject_region_mean_B, region_dict, confidence_level=0.95, n_resamples=10000):
  431. """
  432. Perform a bootstrap test to compare the means of two groups for each region.
  434. Arguments:
  435. - subject_region_mean_A: Region means for group A.
  436. - subject_region_mean_B: Region means for group B.
  437. - region_dict: Mapping of regions to channel indices.
  438. - confidence_level: Confidence level for the bootstrap test (default is 0.95).
  439. - n_resamples: Number of bootstrap resamples (default is 10,000).
  441. Returns:
  442. - results: Dictionary with mean differences, confidence intervals, and p-values for each region.
  443. """
  444. results = {}
  446. # Iterate over each region in the dictionary
  447. for region in region_dict.keys():
  448. # Extract region means for both groups
  449. group_A = extract_region_means(subject_region_mean_A, region)
  450. group_B = extract_region_means(subject_region_mean_B, region)
  452. # Record the sample size of group A
  453. n_group_A = len(group_A)
  455. # Combine data from both groups
  456. data = np.concatenate([group_A, group_B])
  458. # Perform the bootstrap test
  459. res = bootstrap(
  460. (data,),
  461. lambda x: mean_difference(x, n_group_A),
  462. confidence_level=confidence_level,
  463. n_resamples=n_resamples,
  464. method='BCa',
  465. paired=False,
  466. alternative='two-sided'
  467. )
  469. # Save the results for this region
  470. results[region] = {
  471. "mean_difference": mean_difference(data, n_group_A),
  472. "confidence_interval": res.confidence_interval,
  473. "p_value": (res.confidence_interval.low > 0) or (res.confidence_interval.high < 0)
  474. }
  476. return results
  479. # %% [markdown]
  480. # # Figure 5C
  482. # %%
  485. results = np.load('../dataset/figure5_C_results.npz', allow_pickle=True)
  486. for region, result in results.items():
  487. result = result.item()
  488. print(f" Region: {region}")
  489. print(f" Mean Difference: {result['mean_difference']}")
  490. print(f" Confidence Interval: {result['confidence_interval']}")
  491. print(f" Significant: {result['p_value']}\n")
  494. violin_data = np.load('../dataset/figure5_C_violin_data.npy', allow_pickle=True)
  495. df_violin = pd.DataFrame(violin_data, columns=["Region", "Group", "Center Frequecy(Hz)"])
  496. # 设置期刊级绘图参数
  497. plt.rcParams.update({
  498. 'font.family': 'DejaVu Sans',
  499. 'font.size': 10,
  500. 'axes.titlesize': 12,
  501. 'axes.labelsize': 11,
  502. 'xtick.labelsize': 10,
  503. 'ytick.labelsize': 10,
  504. 'legend.fontsize': 10,
  505. 'figure.dpi': 300,
  506. 'axes.linewidth': 0.8 # 坐标轴线宽
  507. })
  509. fig, ax = plt.subplots(figsize=(13, 4), constrained_layout=True)
  511. clinical_palette = {"POD": "#E64B35", "non-POD": "#3C5488"}
  513. # 增强型箱线图设计
  514. box = sns.boxplot(
  515. x='Region',
  516. y='Center Frequecy(Hz)',
  517. hue='Group',
  518. data=df_violin,
  519. palette=clinical_palette,
  520. width=0.6,
  521. linewidth=1.2,
  522. flierprops={
  523. 'marker': 'o',
  524. 'markersize': 4,
  525. 'markerfacecolor': 'none',
  526. 'markeredgecolor': 'gray',
  527. 'markeredgewidth': 0.5
  528. },
  529. # boxprops={'facecolor': 'none', 'edgecolor': 'black'},
  530. whiskerprops={'linewidth': 1.2},
  531. medianprops={'color': 'black', 'linewidth': 1.5},
  532. ax=ax
  533. )
  535. # 坐标轴优化
  536. ax.set_ylim(3, 9.5)
  537. ax.set_ylabel("Center Frequecy(Hz)", labelpad=10)
  538. ax.set_xlabel("Brain Regions", labelpad=10)
  539. ax.yaxis.grid(True, linestyle='--', alpha=0.6)
  541. # 高级图例设计
  542. handles, labels = ax.get_legend_handles_labels()
  543. legend = ax.legend(
  544. handles[:2],
  545. ['POD', 'Non-POD'],
  546. frameon=True,
  547. loc='upper right',
  548. bbox_to_anchor=(1.18, 1), # 图例外置防止重叠
  549. ncol=1,
  550. # title='Experimental Group',
  551. title_fontproperties={'weight': 'bold'},
  552. edgecolor='none',
  553. borderpad=0.8
  554. )
  556. # 优化视觉层次
  557. sns.despine(offset=5, trim=True) # 移除顶部和右侧轴线
  558. plt.savefig('/mnt/dataset1/UnonoU/POD-biomarker/plot/figure_5_C', dpi=300, bbox_inches='tight')
  559. plt.show()
  561. # %% [markdown]
  562. # # Figure 5E
  564. # %%
  565. # subject_region_mean_A = calculate_highlight_intervals_per_subject(detection_datas_A, net_dict)
  566. # subject_region_mean_B = calculate_highlight_intervals_per_subject(detection_datas_B, net_dict)
  567. # results = bootstrap_region_comparison(subject_region_mean_A, subject_region_mean_B, net_dict, confidence_level=0.999, n_resamples=1000)
  568. # violin_data = []
  569. # for region in regions:
  570. # data_A = [subject[region] for subject in subject_region_mean_A]
  571. # data_B = [subject[region] for subject in subject_region_mean_B]
  573. # for value in data_A:
  574. # violin_data.append((region, 'POD', value/10))
  575. # for value in data_B:
  576. # violin_data.append((region, 'non-POD', value/10))
  577. # df_violin = pd.DataFrame(violin_data, columns=["Region", "Group", "Biomarker Event Frequency (event/min)"])
  579. results = np.load('../dataset/figure5_E_results_99.9.npz', allow_pickle=True)
  580. print('P<0.001')
  581. for region, result in results.items():
  582. result = result.item()
  583. print(f" Region: {region}")
  584. print(f" Mean Difference: {result['mean_difference']}")
  585. print(f" Confidence Interval: {result['confidence_interval']}")
  586. print(f" Significant: {result['p_value']}\n")
  588. results = np.load('../dataset/figure5_E_results_99.npz', allow_pickle=True)
  589. print('P<0.01')
  590. for region, result in results.items():
  591. result = result.item()
  592. print(f" Region: {region}")
  593. print(f" Mean Difference: {result['mean_difference']}")
  594. print(f" Confidence Interval: {result['confidence_interval']}")
  595. print(f" Significant: {result['p_value']}\n")
  597. violin_data = np.load('../dataset/figure5_E_violin_data.npy', allow_pickle=True)
  598. df_violin = pd.DataFrame(violin_data, columns=["Region", "Group", "Biomarker Event Frequency (event/min)"])
  599. # 设置期刊级绘图参数
  600. plt.rcParams.update({
  601. 'font.family': 'DejaVu Sans',
  602. 'font.size': 10,
  603. 'axes.titlesize': 12,
  604. 'axes.labelsize': 11,
  605. 'xtick.labelsize': 10,
  606. 'ytick.labelsize': 10,
  607. 'legend.fontsize': 10,
  608. 'figure.dpi': 300,
  609. 'axes.linewidth': 0.8 # 坐标轴线宽
  610. })
  612. fig, ax = plt.subplots(figsize=(12, 4), constrained_layout=True)
  614. clinical_palette = {"POD": "#E64B35", "non-POD": "#3C5488"}
  616. # 增强型箱线图设计
  617. box = sns.boxplot(
  618. x='Region',
  619. y='Biomarker Event Frequency (event/min)',
  620. hue='Group',
  621. data=df_violin,
  622. palette=clinical_palette,
  623. width=0.6,
  624. linewidth=1.2,
  625. flierprops={
  626. 'marker': 'o',
  627. 'markersize': 4,
  628. 'markerfacecolor': 'none',
  629. 'markeredgecolor': 'gray',
  630. 'markeredgewidth': 0.5
  631. },
  632. # boxprops={'facecolor': 'none', 'edgecolor': 'black'},
  633. whiskerprops={'linewidth': 1.2},
  634. medianprops={'color': 'black', 'linewidth': 1.5},
  635. ax=ax
  636. )
  638. # 坐标轴优化
  639. # ax.set_ylim(3, 9.5)
  640. ax.set_ylabel("Biomarker Event Frequency (event/min)", labelpad=10)
  641. ax.set_xlabel("Brain Regions", labelpad=10)
  642. ax.yaxis.grid(True, linestyle='--', alpha=0.6)
  644. # 高级图例设计
  645. handles, labels = ax.get_legend_handles_labels()
  646. legend = ax.legend(
  647. handles[:2],
  648. ['POD', 'Non-POD'],
  649. frameon=True,
  650. loc='upper right',
  651. bbox_to_anchor=(1.18, 1), # 图例外置防止重叠
  652. ncol=1,
  653. # title='Experimental Group',
  654. title_fontproperties={'weight': 'bold'},
  655. edgecolor='none',
  656. borderpad=0.8
  657. )
  659. # 优化视觉层次
  660. sns.despine(offset=5, trim=True) # 移除顶部和右侧轴线
  661. plt.savefig('/mnt/dataset1/UnonoU/POD-biomarker/plot/figure_5_E', dpi=300, bbox_inches='tight')
  662. plt.show()

Figure5.ipynb at commit 0f9c56d, no license · at the source

Overview

Authors: Yinuo Zhang1, Yan Zhu1, Xinxin Zhang2,3,4, Xinke Shen1, Xuemiao Tang2,5, Zhihong Lu2,3,4, Chong Lei2,3,4, Mengyu Li2,3,4, Hailong Dong2,3,4, Zhichao Liang1,6, Quanying Liu1, Guangchao Zhao2,3,4
ORCID iDs: Guangchao Zhao
  1. Department of Biomedical Engineering, Southern University of Science and Technology, Shenzhen, Guangdong, China
  2. Department of Anesthesiology and Perioperative Medicine, Xijing Hospital, The Fourth Military Medical University, Xi'an, China
  3. Key Laboratory of Anesthesiology (The Fourth Military Medical University), Ministry of Education, Xi'an, China
  4. Shaanxi Provincial Clinical Research Center for Anesthesiology Medicine, Xi'an, China
  5. Department of Anesthesiology, The Third People's Hospital of Chengdu, Chengdu, Sichuan, China
  6. Center for Neurocognition and Social Behavior, Artificial Intelligence Research Institute, Shenzhen University of Advanced Technology, Shenzhen, Guangdong, China
Institutions: Southern University of Science and Technology (China); Xijing Hospital (China); Air Force Medical University (China); Third People's Hospital of Chengdu (China); Shenzhen University of Advanced Technology (China)
Journal: MedComm, volume 7, issue 9, article e70980
Dates: received 20 October 2025; accepted 23 June 2026; published online 6 September 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1002/mco2.70980 · PMID 42707129 · PMCID PMC13547085 · OpenAlex W7210277326
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: EEG (modality), human (organism), other condition (population), clinical / translational (subfield)
Methods: Spectral & time-frequency, Preprocessing, Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning
Keywords: interpretable deep learning framework, multichannel EEG recording, postoperative delirium, spatiotemporal convolutional network
Topic: Intensive Care Unit Cognitive Disorders (Critical Care and Intensive Care Medicine, Medicine), according to OpenAlex
Funding: National Natural Science Foundation of China (2021ZD0200500, 82221001, 82271211, 82293643, 62472206, 82430040, 3254100307); Southern University of Science and Technology; Shenzhen Science and Technology Innovation Commission (KJZD20230923115221044, RCBS20231211090748082); National Science and Technology Major Project (2021ZD0200500, 2025ZD0218300); Basic and Applied Basic Research Foundation of Guangdong Province (2025A1515011645, 2026A1515010121, 2026B1515020099)
Citations: not cited yet (Europe PMC); 36 references in the paper

Abstract

Postoperative delirium (POD) is a common complication in older surgical patients and substantially worsens clinical outcomes, yet existing intraoperative electroencephalography (EEG) monitoring tools lack spatial and temporal specificity, creating a need for interpretable biomarkers. We prospectively analyzed 32‐channel intraoperative EEG from 71 patients aged ≥ 60 undergoing noncardiac surgery, trained an interpretable spatiotemporal convolutional network (ST‐CN), derived a best temporal filter (BTF), and evaluated model performance with region‐specific tests and independent external validation. The ST‐CN classified POD with 97.52% accuracy and an ROC of 0.996. The BTF alone discriminated POD with an AUC of 0.911 and achieved 85.12% accuracy using frontal EEG alone. It captured a distinct 2–12 Hz (δ–θ–α) oscillation in a spindle‐like envelope, which occurred at a significantly higher rate in POD patients (4.62 ± 0.15 vs. 3.88 ± 0.13 waves/min in the frontal region) and differed in central frequency and spectral power. Independent external validation further confirmed robust generalizability, with frontal EEG achieving 89.01% accuracy and an AUC of 0.950. This framework enables accurate, interpretable POD risk stratification and identifies a reproducible frontal EEG biomarker, supporting objective intraoperative early warning and individualized perioperative care.

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

ncclab-sustech/POD-biomarker

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 0f9c56db9a968774970f1494373a6581407b2c88, 13 September 2025
Languages: Jupyter (8), Python (5)
Size: 166 files, 13 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README, 8 notebooks
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (11 files), Matplotlib (9 files), PyTorch (8 files), scikit-learn (7 files), MNE-Python (3 files), pandas (3 files), SciPy (3 files), seaborn (3 files)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
14 files
At the source: github.com/ncclab-sustech/POD-biomarker.git

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;
  • 13 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 analysis code has been uploaded to GitHub, the code is available at https://github.com/ncclab‐sustech/POD‐biomarker.git (https://github.com/ncclab-sustech/POD-biomarker.git). Detailed experimental protocols and analysis code are provided in Section 4 Materials and Methods. The data that support the findings of this study are available upon reasonable request from the corresponding author.

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 3, 28 September 2026

  • Funding: added National Natural Science Foundation of China: 2021ZD0200500, 82221001, 82271211, 82293643, 62472206, 82430040, 3254100307; Southern University of Science and Technology; Shenzhen Municipal Science and Technology Innovation Council: KJZD20230923115221044, RCBS20231211090748082; National Science and Technology Major Project: 2021ZD0200500, 2025ZD0218300; Basic and Applied Basic Research Foundation of Guangdong Province: 2025A1515011645, 2026A1515010121, 2026B1515020099

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 12 authors, 4 keywords, 36 references.

Cite

This paper

Zhang, Y., Zhu, Y., Zhang, X., Shen, X., Tang, X., Lu, Z., Lei, C., Li, M., Dong, H., Liang, Z., Liu, Q., & Zhao, G. (2026). An Intraoperative EEG Biomarker for Postoperative Delirium Predicting Based on Interpretable Deep Learning Framework. MedComm, 7(9), e70980. https://doi.org/10.1002/mco2.70980

BibTeX

@article{zhang2026intraoperative,
author = {Zhang, Yinuo and Zhu, Yan and Zhang, Xinxin and Shen, Xinke and Tang, Xuemiao and Lu, Zhihong and Lei, Chong and Li, Mengyu and Dong, Hailong and Liang, Zhichao and Liu, Quanying and Zhao, Guangchao},
title = {{An Intraoperative EEG Biomarker for Postoperative Delirium Predicting Based on Interpretable Deep Learning Framework}},
journal = {MedComm},
year = {2026},
month = sep,
volume = {7},
number = {9},
pages = {e70980},
publisher = {Wiley},
issn = {2688-2663},
doi = {10.1002/mco2.70980},
url = {https://doi.org/10.1002/mco2.70980},
pmid = {42707129},
pmcid = {PMC13547085}
}

RIS

TY - JOUR
AU - Zhang, Yinuo
AU - Zhu, Yan
AU - Zhang, Xinxin
AU - Shen, Xinke
AU - Tang, Xuemiao
AU - Lu, Zhihong
AU - Lei, Chong
AU - Li, Mengyu
AU - Dong, Hailong
AU - Liang, Zhichao
AU - Liu, Quanying
AU - Zhao, Guangchao
TI - An Intraoperative EEG Biomarker for Postoperative Delirium Predicting Based on Interpretable Deep Learning Framework
T2 - MedComm
J2 - MedComm (2020)
PY - 2026
DA - 2026/09/06
VL - 7
IS - 9
SP - e70980
SN - 2688-2663
PB - Wiley
DO - 10.1002/mco2.70980
UR - https://doi.org/10.1002/mco2.70980
LA - en
ER -

CSL-JSON

{
"id": "10.1002/mco2.70980",
"type": "article-journal",
"title": "An Intraoperative EEG Biomarker for Postoperative Delirium Predicting Based on Interpretable Deep Learning Framework",
"container-title": "MedComm",
"author": [
{
"family": "Zhang",
"given": "Yinuo"
},
{
"family": "Zhu",
"given": "Yan"
},
{
"family": "Zhang",
"given": "Xinxin"
},
{
"family": "Shen",
"given": "Xinke"
},
{
"family": "Tang",
"given": "Xuemiao"
},
{
"family": "Lu",
"given": "Zhihong"
},
{
"family": "Lei",
"given": "Chong"
},
{
"family": "Li",
"given": "Mengyu"
},
{
"family": "Dong",
"given": "Hailong"
},
{
"family": "Liang",
"given": "Zhichao"
},
{
"family": "Liu",
"given": "Quanying"
},
{
"family": "Zhao",
"given": "Guangchao"
}
],
"container-title-short": "MedComm (2020)",
"volume": "7",
"issue": "9",
"page": "e70980",
"DOI": "10.1002/mco2.70980",
"PMID": "42707129",
"PMCID": "PMC13547085",
"ISSN": "2688-2663",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/mco2.70980",
"language": "en",
"issued": {
"date-parts": [
[
2026,
9,
6
]
]
}
}

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

Similar papers

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

[1] doi:10.3389/fmed.2026.1794626 [code]
Divergent periodic and aperiodic EEG signatures of Propofol versus sevoflurane anesthesia: a comparative neurophysiological study.
Journal: Frontiers in medicine
In common: seaborn, scikit-learn, pandas, 3 other tools, EEG, clinical / translational, 2 references
[2] doi:10.3389/fncom.2026.1786996 [code]
Schumann-anchored golden ratio organization of human neural oscillations.
Journal: Frontiers in computational neuroscience
In common: MNE-Python, seaborn, scikit-learn, 4 other tools, EEG, 1 reference
[3] doi:10.1371/journal.pcbi.1014302 [code]
Trial-level sequence modeling reveals hidden dynamics of dual-task interference.
Journal: PLoS computational biology
In common: MNE-Python, PyTorch, seaborn, 5 other tools, EEG
[4] doi:10.1162/imag.a.1207 [code]
Investigating the temporal dynamics and modeling of mid-level feature representations in humans.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MNE-Python, PyTorch, seaborn, 5 other tools, EEG
[5] doi:10.1371/journal.pone.0347671 [code]
RMETNet: A cross-subject motor imagery EEG signal classification model based on TSLANet and riemannian geometry features.
Journal: PloS one
In common: MNE-Python, PyTorch, seaborn, 5 other tools, EEG
[6] doi:10.1002/hbm.70528 [code]
Explainable AI Insights Into EEG Classification and Its Alignment to Neural Correlates.
Journal: Human brain mapping
In common: MNE-Python, PyTorch, seaborn, 5 other tools, EEG
[7] doi:10.1038/s41597-025-05174-7 [code]
A large-scale MEG and EEG dataset for object recognition in naturalistic scenes
Journal: n/a
In common: MNE-Python, PyTorch, seaborn, 5 other tools, EEG
[8] doi:10.3390/diagnostics16081186 [code]
The Perioperative Neurocognitive Disorder Prediction Based on AI-Assisted EEG Dynamic Features in Anesthetized Mice.
Journal: Diagnostics (Basel, Switzerland)
In common: EEG, clinical / translational, 1 reference, author Guangchao Zhao
[9] doi:10.3389/fpsyg.2026.1774068 [code]
Analysis of cognitive mechanisms in phoneme perception and pronunciation errors among Korean language learners.
Journal: Frontiers in psychology
In common: MNE-Python, PyTorch, seaborn, 5 other tools, EEG
[10] doi:10.1186/s13634-026-01330-2 [code]
Leednet: a lightweight network for event detection in EEG signals.
Journal: Journal on advances in signal processing
In common: MNE-Python, PyTorch, seaborn, 5 other tools, EEG

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.