OSCR

Toward reliable machine learning models for neural circuit inference: A diagnostic study of CNNs on spike trains.

Code ↔ Paper

18 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 18 matches
  1. [1] § Methods and materials › Design, optimization, and training of Convolutional Neural Networks › Training procedures. ↔ scripts/07_train_weight_cnn.py, lines 76–111 · score 0.87 · cosine annealing learning, weight decay, Huber loss, rate scheduler, Optimization, dual
  2. [2] § Methods and materials › Design, optimization, and training of Convolutional Neural Networks › Training procedures. ↔ scripts/06_train_connectivity_cnn.py, lines 80–117 · score 0.75 · logits loss, training epoch, training loader, patience, scheduler, optimized
  3. [3] § Methods and materials › Neural simulation framework › Poisson spike train generation and bursting activity. ↔ PointNeuron_Simulation/signals.py, lines 229–257 · score 0.71 · geometric distribution, bursting activity, burst spiking, spike trains, ISI, uniform
  4. [4] § Methods and materials › Neural simulation framework › Poisson spike train generation and bursting activity. ↔ PointNeuron_Simulation/signals.py, lines 229–257 · score 0.68 · longer bursts, shorter bursts, initiations, spike train, smaller, window
  5. [5] § Methods and materials › Design, optimization, and training of Convolutional Neural Networks › Training procedures. ↔ scripts/07_train_weight_cnn.py, lines 76–111 · score 0.64 · training epoch, training loader, patience, scheduler, optimized, batches
  6. [6] § Methods and materials › Design, optimization, and training of Convolutional Neural Networks › Training sample generation. ↔ PointNeuron_Simulation/connectivity.py, lines 31–178 · score 0.63 · connectivity matrix, postsynaptic neuron, presynaptic neuron, class, network, simulation
  7. [7] § Results › Diagnostic analysis of CNN connectivity inference across perturbations ↔ scripts/4_0_indi_confi_fmm_Calu.ipynb, lines 1063–1191 · score 0.62 · focused window, normalized entropy, dip depth, KL divergence, peak height, threshold
  8. [8] § Methods and materials › In vitro HD-MEA/patch-clamp dataset › Spike-train feature extraction. ↔ PointNeuron_Simulation/utils.py, lines 525–593 · score 0.60 · Inter spike interval, spike trains, variation, quantified, ISI, coefficient
  9. [9] § Methods and materials › Neural simulation framework › Network simulation. ↔ PointNeuron_Simulation/neuron.py, lines 95–134 · score 0.58 · added bursting activity, Poisson processes, spike trains, synaptic, neurons, simulated
  10. [10] § Methods and materials › Neural simulation framework › Poisson spike train generation and bursting activity. ↔ PointNeuron_Simulation/neuron.py, lines 95–134 · score 0.57 · absolute refractory period, spike train, bursts, Poisson, window, activity
  11. [11] § Results › Diagnostic analysis of CNN-based synaptic weight inference across perturbations and the effect of pooled training ↔ scripts/4_0_indi_confi_fmm_Calu.ipynb, lines 313–441 · score 0.56 · weightCNN, connCNN, feature map, baseline models, FMM, predicted
  12. [12] § Methods and materials › Neural simulation framework › Leaky integrate-and-fire model. ↔ PointNeuron_Simulation/simulation.py, lines 100–147 · score 0.55 · refractory period, transient, reversal, reset, leak, postsynaptic
  13. [13] § Methods and materials › Model ranking by balanced perturbation performance ↔ scripts/4-1-FMM_Indi_Conn.ipynb, lines 70–183 · score 0.55 · binomial resampling, bootstrap, CI, ranking, perturbation, model
  14. [14] § Methods and materials › Neural simulation framework › Poisson spike train generation and bursting activity. ↔ PointNeuron_Simulation/utils.py, lines 525–593 · score 0.54 · inter spike intervals, spike trains, ISIs, Poisson, burst
  15. [15] § Results › Illustration of the controlled benchmarking of CNN robustness across biophysical perturbations ↔ scripts/4-1-FMM_Indi_Conn.ipynb, lines 1–66 · score 0.53 · BP0.5, dip depth, KL divergence, training baseline, peak height, baseline model
  16. [16] § Methods and materials › Neural simulation framework › Leaky integrate-and-fire model. ↔ PointNeuron_Simulation/neuron.py, lines 20–93 · score 0.53 · membrane capacitance, reversal, reset, leak, fire, neuron
  17. [17] § Methods and materials › CCG indicators ↔ scripts/4_0_indi_confi_fmm_Calu.ipynb, lines 1063–1191 · score 0.50 · focus window, KL divergence, tails, bins, excitatory, dip
  18. [18] § Results › Diagnostic analysis of CNN-based synaptic weight inference across perturbations and the effect of pooled training ↔ scripts/4-1-FMM_Indi_Conn.ipynb, lines 1276–1310 · score 0.50 · XGBoost, Boosting, SHAP, interactions, predict, baseline

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 · 1,200 lines · 60 KB · no license · 3 matches

  1. # %% [markdown]
  2. # # Info
  3. #
  4. # Author: Xiaoqian Sun </br>
  5. # Created: 07/28/2025 </br>
  6. # Function: Analysis on Signal Level
  7. # - create a vector of indicators to describe CCGs
  8. # - correlate each indicator with perturbation strength
  9. # - regress model performance on these indicators
  10. # - cluster perturbations by CCG types to identify which combinations are most harmful
  11. #
  12. # ### Entropy
  13. # Entropy doesn't care whether bins are positive or negative. It only cares how unevenly values are distributed after normalization to a probability distribution.
  14. # Measures the overall unpredictability of a distribution
  15. # - A flat (uniform) CCG → high entropy (close to log₂(N))
  16. # - A sharp peak or dip → lower entropy (because values are unevenly distributed)
  17. #
  18. # ### KL Divergence
  19. # KL divergence highlights how far the actual shape is from "flat randomness." Unlike entropy, KL requires defining a reference distribution (here, uniform).
  20. # - If bins are all equal → KL divergence is 0
  21. # - If a few bins dominate (e.g., a peak or dip near 0 ms) → KL divergence increases
  22. #
  23. # ### Intuition
  24. # - Entropy is absolute — it measures how spread out the probability mass is.
  25. # - KL divergence is relative — it measures how far the current distribution is from a baseline (like uniform).
  27. # %%
  28. import os
  29. import numpy as np
  30. import pandas as pd
  31. import seaborn as sns
  32. from Functions import *
  33. import matplotlib.pyplot as plt
  34. from scipy.stats import entropy
  35. from scipy.special import rel_entr
  36. from scipy.ndimage import gaussian_filter1d
  38. import warnings
  39. warnings.filterwarnings('ignore')
  41. # %% [markdown]
  42. # # Path & Common File & Parameters
  44. # %%
  45. # path --------------------------------------------------
  46. root_path = r'/Users/xiaoqiansun/Desktop/InferConnectivity'
  47. work_path = os.getcwd()
  49. dataloader_path = os.path.join(work_path, 'dataloader')
  51. result_path = os.path.join(work_path, 'Result')
  52. allRuns_path = os.path.join(result_path, 'all120Runs')
  54. resultAnalysis_path = os.path.join(work_path, 'resultAnalysis')
  55. indiSave_path = os.path.join(resultAnalysis_path, 'indi'); os.makedirs(indiSave_path, exist_ok=True)
  56. confiSave_path = os.path.join(resultAnalysis_path, 'fmm_confi'); os.makedirs(confiSave_path, exist_ok=True)
  58. data_path = os.path.join(root_path, 'Dataset', 'm2post')
  59. info_df = pd.read_csv(os.path.join(dataloader_path, 'binInfo.csv')).iloc[:, 1:]
  60. bin_size=1; timebins = info_df['t']
  62. # Para --------------------------------------------------
  63. # baseline_types = ['E3', 'E5', 'E8', 'g0.5', 'g1.5']
  64. baseline_types = ['E3', 'E5', 'E8', 'g0.5', 'g1.5', 'BP0.5', 'mu165', 'mu180', 'tau5', 'tau40']
  65. perturbations = ['mu', 'tau', 'BP', 'EI', 'Weight']
  67. indicators_exc = ['peak_height', 'peak_lag', 'peak_halfMax_width', 'peak_to_noise', 'temporal_span', 'entropy', 'norm_entropy', 'norm_entropy_window', 'kl_divergence_window']
  68. indicators_inh = ['dip_depth', 'dip_lag', 'dip_halfMax_width', 'dip_to_noise', 'temporal_span', 'entropy', 'norm_entropy', 'norm_entropy_window', 'kl_divergence_window']
  70. cmap= 'coolwarm'; cm_cmap='PuBu';
  71. mC='firebrick'; bC='steelblue'; ccgColor='k'
  72. coolwarm_blue = '#3B4CC0'; coolwarm_red = '#B40426'
  73. coolwarm_softblue = '#6BAED6'; coolwarm_softred = '#E07A7A’; correctGREEN= '#2E7D32'
  76. # %% [markdown]
  77. # # Indicator - Just Ran Once
  79. # %%
  80. # bs_Idx = 1
  81. # baselineType = baseline_types[bs_Idx]
  82. # baselineName = 'baseline'#'baseline_E3'
  84. # base_mu = 150
  85. # base_tau = 15
  86. # base_BP = 1.0
  87. # base_EI = 0.5
  88. # base_g = 1.0
  89. # dataPrefix = '_'+baselineType
  90. # bs_featureDic = [{'mu':base_mu, 'tau':base_tau, 'BP':base_BP, 'EI':base_EI, 'g': base_g}]
  92. # print(' - baseline', dataPrefix, 'with base values:', bs_featureDic)
  94. # %%
  95. # mus = [150+2*i for i in range(16)]
  96. # mu_prefix = ['mu'+str(mu) for mu in mus]
  97. # mu_tests = ['mu'+dataPrefix+str(mu) for mu in mus] if ('mu' not in dataPrefix and 'E5' not in dataPrefix) else mu_prefix
  98. # mu_featureDics = [{'mu':mu, 'tau':base_tau, 'BP':base_BP, 'EI':base_EI, 'g':base_g } for mu in mus]
  101. # taus = [5*i for i in range(1, 11)]
  102. # tau_prefix = ['tau'+str(tau) for tau in taus]
  103. # tau_tests = ['tau'+dataPrefix+str(tau) for tau in taus] if ('tau' not in dataPrefix and 'E5' not in dataPrefix) else tau_prefix
  104. # tau_featureDics = [{'mu':base_mu, 'tau':tau, 'BP':base_BP, 'EI':base_EI, 'g':base_g } for tau in taus]
  107. # BPs = [0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
  108. # BP_prefix = ['BP'+str(BP) for BP in BPs]
  109. # BP_tests = ['BP'+dataPrefix+str(BP) for BP in BPs] if ('BP' not in dataPrefix and 'E5' not in dataPrefix) else BP_prefix
  110. # BP_featureDics = [{'mu':base_mu, 'tau':base_tau, 'BP':BP, 'EI':base_EI, 'g':base_g } for BP in BPs]
  113. # EIs = [0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
  114. # EI_prefix = ['EI'+str(EI) for EI in EIs]
  115. # EI_tests = ['EI'+dataPrefix+str(EI) for EI in EIs] if ('E' not in dataPrefix and 'E5' not in dataPrefix) else EI_prefix
  116. # EI_featureDics = [{'mu':base_mu, 'tau':base_tau, 'BP':base_BP, 'EI':EI, 'g':base_g } for EI in EIs]
  119. # gs = [0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0]
  120. # gbar_prefix = ['g'+str(g) for g in gs]
  121. # gbar_tests = ['g'+dataPrefix+str(g) for g in gs] if ('g' not in dataPrefix and 'E5' not in dataPrefix) else gbar_prefix
  122. # g_featureDics = [{'mu':base_mu, 'tau':base_tau, 'BP':base_BP, 'EI':base_EI, 'g': g} for g in gs]
  125. # file_test_list = [baselineName] + mu_tests + tau_tests + BP_tests + EI_tests + gbar_tests
  126. # file_prefix_list = ['baseline'] + mu_prefix + tau_prefix + BP_prefix + EI_prefix + gbar_prefix
  127. # file_featureDics = bs_featureDic + mu_featureDics + tau_featureDics + BP_featureDics + EI_featureDics + g_featureDics
  129. # print(len(file_prefix_list), '= 1 baseline + 48 perturbations')
  131. # %%
  132. # indicator_exc_list = []; indicator_inh_list = []
  133. # for i in range(len(file_test_list)):
  134. # fileTest = file_test_list[i]
  135. # featureDic = file_featureDics[i]
  136. # try:
  137. # ccg, ws, ls, ss = read_ccg(data_path, fileTest+'_CCG.csv')
  139. # for nIdx in range(len(ccg)):
  140. # w = ws[nIdx]; sname = ss[nIdx]
  141. # if w > 0:
  142. # indi = ccg_indicators(ccg[nIdx], connection_type='exc', smoothSigma=0.5, bin_size=1, peak_window_ms=10, ifVerbose=False,ifPlot=False,ifSave=False)
  143. # indi.update(featureDic); indi['Weight'] = w; indi['sample']=sname; indi['test']=fileTest
  144. # indicator_exc_list.append(indi)
  145. # elif w < 0:
  146. # indi = ccg_indicators(ccg[nIdx], connection_type='inh', smoothSigma=0.5, bin_size=1, peak_window_ms=10, ifVerbose=False,ifPlot=False,ifSave=False)
  147. # indi.update(featureDic); indi['Weight'] = w; indi['sample']=sname; indi['test']=fileTest
  148. # indicator_inh_list.append(indi)
  149. # except Exception as e:
  150. # print(fileTest, '--', e)
  152. # break
  154. # indicatorExc_df=pd.DataFrame(indicator_exc_list);# indicatorExc_df.to_csv(os.path.join(indiSave_path, baselineType+'_indicator_exc.csv'))
  155. # indicatorInh_df=pd.DataFrame(indicator_inh_list);# indicatorInh_df.to_csv(os.path.join(indiSave_path, baselineType+'_indicator_inh.csv'))
  156. # print(indicatorExc_df.shape, indicatorInh_df.shape); indicatorInh_df.tail(5)
  158. # %% [markdown]
  159. # # ----------------------------------------------------------------------
  160. #
  161. # # FMM, Confi, Indi
  163. # %% [markdown]
  164. # ### loader best M
  166. # %%
  167. baseline_types = ['E3', 'E5', 'E8', 'g0.5', 'g1.5', 'BP0.5', 'mu165', 'mu180', 'tau5', 'tau40']
  170. model, optimizer, scheduler, criterion = init_conn_model()
  171. connCNNE3,_ = load_conn_model(model,optimizer,scheduler,savePath=allRuns_path, filename='ConnCNN_E3_100.0.pth')
  173. model, optimizer, scheduler, criterion = init_conn_model()
  174. connCNNE5,_ = load_conn_model(model,optimizer,scheduler,savePath=allRuns_path, filename='ConnCNN_E5_100.0.pth')
  176. model, optimizer, scheduler, criterion = init_conn_model()
  177. connCNNE8,_ = load_conn_model(model,optimizer,scheduler,savePath=allRuns_path, filename='ConnCNN_E8_100.0.pth')
  179. model, optimizer, scheduler, criterion = init_conn_model()
  180. connCNNg05,_ = load_conn_model(model,optimizer,scheduler,savePath=allRuns_path, filename='ConnCNN_g0.5_100.0.pth')
  182. model, optimizer, scheduler, criterion = init_conn_model()
  183. connCNNg15,_ = load_conn_model(model,optimizer,scheduler,savePath=allRuns_path, filename='ConnCNN_g1.5_100.0.pth')
  185. model, optimizer, scheduler, criterion = init_conn_model()
  186. connCNNBP05,_ = load_conn_model(model,optimizer,scheduler,savePath=allRuns_path, filename='ConnCNN_BP0.5_100.0.pth')
  188. model, optimizer, scheduler, criterion = init_conn_model()
  189. connCNNmu165,_ = load_conn_model(model,optimizer,scheduler,savePath=allRuns_path, filename='ConnCNN_mu165_100.0.pth')
  191. model, optimizer, scheduler, criterion = init_conn_model()
  192. connCNNmu180,_ = load_conn_model(model,optimizer,scheduler,savePath=allRuns_path, filename='ConnCNN_mu180_100.0.pth')
  194. model, optimizer, scheduler, criterion = init_conn_model()
  195. connCNNtau5,_ = load_conn_model(model,optimizer,scheduler,savePath=allRuns_path, filename='ConnCNN_tau5_100.0.pth')
  197. model, optimizer, scheduler, criterion = init_conn_model()
  198. connCNNtau40,_ = load_conn_model(model,optimizer,scheduler,savePath=allRuns_path, filename='ConnCNN_tau40_100.0.pth')
  201. baseline_connCNN_models = [connCNNE3, connCNNE5, connCNNE8, connCNNg05, connCNNg15,
  202. connCNNBP05, connCNNmu165, connCNNmu180, connCNNtau5, connCNNtau40]
  204. # %%
  205. model, optimizer, scheduler, criterion = init_weight_model()
  206. weighCNNE3,_ = load_model(model,optimizer,scheduler,savePath=allRuns_path, filename='w_E3_0.0096.pth')
  208. model, optimizer, scheduler, criterion = init_weight_model()
  209. weighCNNE5,_ = load_model(model,optimizer,scheduler,savePath=allRuns_path, filename='w_E5_0.0016.pth')
  211. model, optimizer, scheduler, criterion = init_weight_model()
  212. weighCNNE8,_ = load_model(model,optimizer,scheduler,savePath=allRuns_path, filename='w_E8_0.0003.pth')
  214. model, optimizer, scheduler, criterion = init_weight_model()
  215. weighCNNg05,_ = load_model(model,optimizer,scheduler,savePath=allRuns_path, filename='w_g0.5_0.0001.pth')
  217. model, optimizer, scheduler, criterion = init_weight_model()
  218. weighCNNg15,_ = load_model(model,optimizer,scheduler,savePath=allRuns_path, filename='w_g1.5_0.0024.pth')
  220. model, optimizer, scheduler, criterion = init_weight_model()
  221. weighCNNBP05,_ = load_model(model,optimizer,scheduler,savePath=allRuns_path, filename='w_BP0.5_0.0001.pth')
  223. model, optimizer, scheduler, criterion = init_weight_model()
  224. weighCNNmu165,_ = load_model(model,optimizer,scheduler,savePath=allRuns_path, filename='w_mu165_0.0033.pth')
  226. model, optimizer, scheduler, criterion = init_weight_model()
  227. weighCNNmu180,_ = load_model(model,optimizer,scheduler,savePath=allRuns_path, filename='w_mu180_0.0005.pth')
  229. model, optimizer, scheduler, criterion = init_weight_model()
  230. weighCNNtau5,_ = load_model(model,optimizer,scheduler,savePath=allRuns_path, filename='w_tau5_0.0001.pth')
  232. model, optimizer, scheduler, criterion = init_weight_model()
  233. weighCNNtau40,_ = load_model(model,optimizer,scheduler,savePath=allRuns_path, filename='w_tau40_0.0002.pth')
  235. baseline_weightCNN_models = [weighCNNE3, weighCNNE5, weighCNNE8, weighCNNg05, weighCNNg15,
  236. weighCNNBP05, weighCNNmu165, weighCNNmu180, weighCNNtau5, weighCNNtau40]
  238. # %% [markdown]
  239. # ### perbs list
  241. # %%
  242. mu_prefix = ['mu'+str(150+2*i) for i in range(16)]
  243. muE3_prefix = ['mu_E3'+str(150+2*i) for i in range(16)]
  244. muE8_prefix = ['mu_E8'+str(150+2*i) for i in range(16)]
  245. mug05_prefix = ['mu_g0.5'+str(150+2*i) for i in range(16)]
  246. mug15_prefix = ['mu_g1.5'+str(150+2*i) for i in range(16)]
  247. muBP05_prefix = ['mu_BP0.5'+str(150+2*i) for i in range(16)]
  248. mutau5_prefix = ['mu_tau5'+str(150+2*i) for i in range(16)]
  249. mutau40_prefix = ['mu_tau40'+str(150+2*i) for i in range(16)]
  252. tau_prefix = ['tau'+str(5*i) for i in range(1, 11)]
  253. tauE3_prefix = ['tau_E3'+str(5*i) for i in range(1, 11)]
  254. tauE8_prefix = ['tau_E8'+str(5*i) for i in range(1, 11)]
  255. taug05_prefix = ['tau_g0.5'+str(5*i) for i in range(1, 11)]
  256. taug15_prefix = ['tau_g1.5'+str(5*i) for i in range(1, 11)]
  257. tauBP05_prefix = ['tau_BP0.5'+str(5*i) for i in range(1, 11)]
  258. taumu165_prefix = ['tau_mu165'+str(5*i) for i in range(1, 11)]
  259. taumu180_prefix = ['tau_mu180'+str(5*i) for i in range(1, 11)]
  262. BPs = [0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
  263. BP_prefix = ['BP'+str(bp) for bp in BPs]
  264. BPE3_prefix = ['BP_E3'+str(bp) for bp in BPs]
  265. BPE8_prefix = ['BP_E8'+str(bp) for bp in BPs]
  266. BPg05_prefix = ['BP_g0.5'+str(bp) for bp in BPs]
  267. BPg15_prefix = ['BP_g1.5'+str(bp) for bp in BPs]
  268. BPmu165_prefix = ['BP_mu165'+str(bp) for bp in BPs]
  269. BPmu180_prefix = ['BP_mu180'+str(bp) for bp in BPs]
  270. BPtau5_prefix = ['BP_tau5'+str(bp) for bp in BPs]
  271. BPtau40_prefix = ['BP_tau40'+str(bp) for bp in BPs]
  274. EIatio=[0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
  275. EI_prefix = ['EI'+str(ei) for ei in EIatio]
  276. EIg05_prefix = ['EI_g0.5'+str(ei) for ei in EIatio] ; EIg05_prefix.remove('EI_g0.50.3')
  277. EIg15_prefix = ['EI_g1.5'+str(ei) for ei in EIatio]
  278. EIBP05_prefix = ['EI_BP0.5'+str(ei) for ei in EIatio]
  279. EImu165_prefix = ['EI_mu165'+str(ei) for ei in EIatio]
  280. EImu180_prefix = ['EI_mu180'+str(ei) for ei in EIatio]
  281. EItau5_prefix = ['EI_tau5'+str(ei) for ei in EIatio]
  282. EItau40_prefix = ['EI_tau40'+str(ei) for ei in EIatio]
  285. gbars = [0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0]
  286. gbar_prefix = ['g'+str(g) for g in gbars]
  287. gbarE3_prefix = ['g_E3'+str(g) for g in gbars] ; gbarE3_prefix.remove('g_E30.4')
  288. gbarE8_prefix = ['g_E8'+str(g) for g in gbars]
  289. gbarBP05_prefix = ['g_BP0.5'+str(g) for g in gbars]; gbarBP05_prefix.remove('g_BP0.50.4')
  290. gbarmu165_prefix = ['g_mu165'+str(g) for g in gbars]; gbarmu165_prefix.remove('g_mu1650.4')
  291. gbarmu180_prefix = ['g_mu180'+str(g) for g in gbars]; gbarmu180_prefix.remove('g_mu1800.4')
  292. gbartau5_prefix = ['g_tau5'+str(g) for g in gbars]; gbartau5_prefix.remove('g_tau50.4')
  293. gbartau40_prefix = ['g_tau40'+str(g) for g in gbars]; gbartau40_prefix.remove('g_tau400.4')
  296. file_prefix_E5_list = mu_prefix + tau_prefix + BP_prefix + EI_prefix + gbar_prefix
  297. file_prefix_E3_list = muE3_prefix + tauE3_prefix + BPE3_prefix + EI_prefix + gbarE3_prefix
  298. file_prefix_E8_list = muE8_prefix + tauE8_prefix + BPE8_prefix + EI_prefix + gbarE8_prefix
  299. file_prefix_g05_list = mug05_prefix + taug05_prefix + BPg05_prefix + EIg05_prefix + gbar_prefix
  300. file_prefix_g15_list = mug15_prefix + taug15_prefix + BPg15_prefix + EIg15_prefix + gbar_prefix
  301. file_prefix_BP05_list = muBP05_prefix + tauBP05_prefix + BP_prefix + EIBP05_prefix + gbarBP05_prefix
  302. file_prefix_mu165_list = mu_prefix + taumu165_prefix + BPmu165_prefix + EImu165_prefix + gbarmu165_prefix
  303. file_prefix_mu180_list = mu_prefix + taumu180_prefix + BPmu180_prefix + EImu180_prefix + gbarmu180_prefix
  304. file_prefix_tau5_list = mutau5_prefix + tau_prefix + BPtau5_prefix + EItau5_prefix + gbartau5_prefix
  305. file_prefix_tau40_list = mutau40_prefix + tau_prefix + BPtau40_prefix + EItau40_prefix + gbartau40_prefix
  308. file_prefix_lists = [file_prefix_E3_list, file_prefix_E5_list, file_prefix_E8_list, file_prefix_g05_list, file_prefix_g15_list,
  309. file_prefix_BP05_list, file_prefix_mu165_list, file_prefix_mu180_list, file_prefix_tau5_list, file_prefix_tau40_list]
  310. perturbation_loader_lists = [ [load_oneLoader(dataloader_path, file_prefix+'_loader.pkl') for file_prefix in file_prefix_list] for file_prefix_list in file_prefix_lists ]
  313. # %% [markdown]
  314. # ### calculation
  316. # %%
  317. criterionC = nn.BCEWithLogitsLoss()
  318. criterionW = HuberLossWithWeight()
  319. fm_mean_cols = ['conv1_fm0_mean', 'conv1_fm1_mean', 'conv1_fm2_mean', 'conv1_fm3_mean', 'conv2_fm0_mean', 'conv2_fm1_mean']
  321. for bIdx in range(len(baseline_types)):
  323. predSummary_list = []
  325. # retrive the best baseline model ---------------------------------------------------------------
  326. bsType = baseline_types[bIdx]
  327. connCNN_Model = baseline_connCNN_models[bIdx]
  328. weightCNN_Model = baseline_weightCNN_models[bIdx]
  331. # predict on baseline-test set -------------------------------------------------------------------
  332. train_loader, val_loader, test_loader = load_dataloaders(dataloader_path, 'baseline_'+bsType+'_loader.pkl')
  334. # pred with connCNN ------------
  335. avg_connect_loss, accu, pred_list,confi_list, label_list, w_list, sCInfo_list = evaluateConnCNN_wConfi_model(connCNN_Model, test_loader, criterionC)
  337. # pred with weightCNN ----------
  338. avg_wegiht_loss, predW_list, gtW_list, label0_loss, label1_loss, sWInfo_list = evaluateWeightCNN_model(weightCNN_Model, test_loader, criterionW)
  340. # feature map mean -------------
  341. conn_fmMean_list = []; weight_fmMean_list = []
  342. conn_fmMean_pre_list = []; weight_fmMean_pre_list = []
  343. conn_fmMean_postBN_list = []; weight_fmMean_postBN_list = []
  344. for ccgs, cs, ws, ss in test_loader:
  345. for m in range(len(ccgs)):
  347. # pre activation (raw featureMaps)
  348. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps(connCNN_Model, ccgs[m]) # connCNN
  349. conn_fmMean_pre_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  350. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps(weightCNN_Model, ccgs[m])# weightCNN
  351. weight_fmMean_pre_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  353. # postBN (featureMaps after BatchNorm, but before tanh)
  354. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_postBN(connCNN_Model, ccgs[m]) # connCNN
  355. conn_fmMean_postBN_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  356. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_postBN(weightCNN_Model, ccgs[m])# weightCNN
  357. weight_fmMean_postBN_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  359. # post activation (featureMaps after BatchNorm & tanh)
  360. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_post_activation(connCNN_Model, ccgs[m]) # connCNN
  361. conn_fmMean_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  362. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_post_activation(weightCNN_Model, ccgs[m])# weightCNN
  363. weight_fmMean_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  366. predSummary = pd.DataFrame([label_list, pred_list, confi_list, gtW_list, predW_list, sCInfo_list, ['baseline_'+bsType]*len(sCInfo_list)],
  367. index=['connLabel', 'predLabel', 'confi', 'gtWeights', 'predWeights', 'sample', 'test']).T
  368. connPre_FMM = pd.DataFrame(np.array(conn_fmMean_pre_list), columns=['pre_conn_'+col for col in fm_mean_cols])
  369. connPost_FMM = pd.DataFrame(np.array(conn_fmMean_list), columns=['post_conn_'+col for col in fm_mean_cols])
  370. connPostBN_FMM = pd.DataFrame(np.array(conn_fmMean_postBN_list), columns=['postBN_conn_'+col for col in fm_mean_cols])
  372. weightPre_FMM = pd.DataFrame(np.array(weight_fmMean_pre_list), columns=['pre_weight_'+col for col in fm_mean_cols])
  373. weightPost_FMM = pd.DataFrame(np.array(weight_fmMean_list), columns=['post_weight_'+col for col in fm_mean_cols])
  374. weightPostBN_FMM = pd.DataFrame(np.array(weight_fmMean_postBN_list), columns=['postBN_weight_'+col for col in fm_mean_cols])
  376. predSummary = pd.concat([predSummary, connPre_FMM, connPost_FMM, connPostBN_FMM, weightPre_FMM, weightPost_FMM, weightPostBN_FMM], axis=1); predSummary_list.append(predSummary)
  380. # predict on associated perturbations ------------------------------------------------------------
  381. file_prefix_list = file_prefix_lists[bIdx]
  382. perturbation_loader = perturbation_loader_lists[bIdx]
  383. for fileIdx in range(len(file_prefix_list)):
  384. perb_type = file_prefix_list[fileIdx]
  385. perb_loader = perturbation_loader[fileIdx]
  387. # pred with connCNN ------------
  388. avg_connect_loss, accu, pred_list,confi_list, label_list, w_list, sCInfo_list = evaluateConnCNN_wConfi_model(connCNN_Model, perb_loader, criterionC)
  390. # pred with weightCNN ----------
  391. avg_wegiht_loss, predW_list, gtW_list, label0_loss, label1_loss, sWInfo_list = evaluateWeightCNN_model(weightCNN_Model, perb_loader, criterionW)
  393. assert np.array_equal(sCInfo_list, sWInfo_list), bsType+' '+perb_type+" sInfo Arrays are not equal"
  395. # get feature map mean on each ccg -------------
  396. conn_fmMean_list = []; weight_fmMean_list = []
  397. conn_fmMean_pre_list = []; weight_fmMean_pre_list = []
  398. conn_fmMean_postBN_list = []; weight_fmMean_postBN_list = []
  399. for ccgs, cs, ws, ss in perb_loader:
  400. for m in range(len(ccgs)):
  402. # pre activation (raw featureMaps)
  403. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps(connCNN_Model, ccgs[m]) # connCNN
  404. conn_fmMean_pre_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  405. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps(weightCNN_Model, ccgs[m])# weightCNN
  406. weight_fmMean_pre_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  408. # postBN (featureMaps after BatchNorm, but before tanh)
  409. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_postBN(connCNN_Model, ccgs[m]) # connCNN
  410. conn_fmMean_postBN_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  411. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_postBN(weightCNN_Model, ccgs[m])# weightCNN
  412. weight_fmMean_postBN_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  414. # post activation (featureMaps after BatchNorm & tanh)
  415. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_post_activation(connCNN_Model, ccgs[m])
  416. conn_fmMean_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  417. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_post_activation(weightCNN_Model, ccgs[m])
  418. weight_fmMean_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  421. predSummary = pd.DataFrame([label_list, pred_list, confi_list, gtW_list, predW_list, sCInfo_list, [perb_type]*len(sCInfo_list)],
  422. index=['connLabel', 'predLabel', 'confi', 'gtWeights', 'predWeights', 'sample', 'test']).T
  423. connPre_FMM = pd.DataFrame(np.array(conn_fmMean_pre_list), columns=['pre_conn_'+col for col in fm_mean_cols])
  424. connPost_FMM = pd.DataFrame(np.array(conn_fmMean_list), columns=['post_conn_'+col for col in fm_mean_cols])
  425. connPostBN_FMM = pd.DataFrame(np.array(conn_fmMean_postBN_list), columns=['postBN_conn_'+col for col in fm_mean_cols])
  427. weightPre_FMM = pd.DataFrame(np.array(weight_fmMean_pre_list), columns=['pre_weight_'+col for col in fm_mean_cols])
  428. weightPost_FMM = pd.DataFrame(np.array(weight_fmMean_list), columns=['post_weight_'+col for col in fm_mean_cols])
  429. weightPostBN_FMM = pd.DataFrame(np.array(weight_fmMean_postBN_list), columns=['postBN_weight_'+col for col in fm_mean_cols])
  431. predSummary = pd.concat([predSummary, connPre_FMM, connPost_FMM, connPostBN_FMM, weightPre_FMM, weightPost_FMM, weightPostBN_FMM], axis=1); predSummary_list.append(predSummary)
  434. bspredSummary = pd.concat(predSummary_list)
  435. bspredSummary.to_csv(os.path.join(confiSave_path, bsType+'_confi_w_perbs.csv'))
  438. # baseline_types = ['E3', 'E5', 'E8', 'g0.5', 'g1.5', 'BP0.5', 'mu165', 'mu180', 'tau5', 'tau40']
  440. print('Done')
  441. bspredSummary.tail(2)
  443. # %% [markdown]
  444. # ### combine FMM, Confi, Indictors
  446. # %%
  447. # baseline_types = ['E3', 'E5', 'E8', 'g0.5', 'g1.5', 'BP0.5', 'mu165', 'mu180', 'tau5', 'tau40']
  449. for bIdx in range(len(baseline_types)):
  450. bsType = baseline_types[bIdx]
  451. bspredSummary = pd.read_csv(os.path.join(confiSave_path, bsType+'_confi_w_perbs.csv')).iloc[:, 1:]
  453. exc_indicator_df = pd.read_csv(os.path.join(indiSave_path, bsType+'_indicator_exc.csv')).iloc[:, 1:]
  454. inh_indicator_df = pd.read_csv(os.path.join(indiSave_path, bsType+'_indicator_inh.csv')).iloc[:, 1:]
  456. # merge
  457. pred_indi_exc = pd.merge(bspredSummary, exc_indicator_df, on='sample', how='inner')
  458. pred_indi_exc = pred_indi_exc.drop(columns=['test_y']); pred_indi_exc = pred_indi_exc.rename(columns={'test_x': 'test'})
  459. pred_indi_exc.to_csv(os.path.join(resultAnalysis_path, bsType+'_confi_fmm_indi_exc.csv'))
  461. pred_indi_inh = pd.merge(bspredSummary, inh_indicator_df, on='sample', how='inner')
  462. pred_indi_inh = pred_indi_inh.drop(columns=['test_y']); pred_indi_inh = pred_indi_inh.rename(columns={'test_x': 'test'})
  463. pred_indi_inh.to_csv(os.path.join(resultAnalysis_path, bsType+'_confi_fmm_indi_inh.csv'))
  466. print('Done')
  467. print(pred_indi_exc.shape); pred_indi_exc.head(2)
  469. # %% [markdown]
  470. # ## Best Model Accu/Loss
  472. # %%
  473. import re
  474. def clean_test_value(val):
  475. # Remove patterns like _g0.5 or _BP0.5
  476. return re.sub(r'_g0\.5|_BP0\.5|_g1\.5|_mu165|_mu180|_tau5|_tau40|_E3|_E8', '', val)
  479. mus = [150+2*i for i in range(16)]; mu_prefix = ['mu'+str(mu) for mu in mus]
  480. taus = [5*i for i in range(1, 11)]; tau_prefix = ['tau'+str(tau) for tau in taus]
  481. BPs = [0.5, 0.6, 0.7, 0.8, 0.9, 1.0]; BP_prefix = ['BP'+str(BP) for BP in BPs]
  482. EIs = [0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]; EI_prefix = ['EI'+str(EI) for EI in EIs]
  483. gs = [0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0]; gbar_prefix = ['g'+str(g) for g in gs]
  484. perturbs_list = mu_prefix + tau_prefix + BP_prefix + EI_prefix + gbar_prefix
  486. model_list = ['mu150', 'mu165', 'mu180', 'tau5', 'tau15', 'tau40', 'BP0.5', 'BP1.0', 'E3', 'E5', 'E8', 'g0.5', 'g1.0', 'g1.5']
  488. # %%
  489. accu_list = []; loss_list = []
  490. for bIdx in range(len(baseline_types)):
  491. bsType = baseline_types[bIdx]
  492. bspredSummary = pd.read_csv(os.path.join(confiSave_path, bsType+'_confi_w_perbs.csv')).iloc[:, 1:]
  493. bspredSummary['hit'] = (bspredSummary['connLabel']==bspredSummary['predLabel']).astype(int)
  494. bspredSummary['mse'] = (bspredSummary['gtWeights'] - bspredSummary['predWeights']) ** 2
  496. bspredSummary['test'] = bspredSummary['test'].apply(clean_test_value)
  498. mean_accu = bspredSummary.groupby('test')['hit'].mean()*100
  499. mean_accu = mean_accu[~mean_accu.index.str.contains('baseline')]
  500. mean_accu = mean_accu.reindex(perturbs_list)
  501. accu_list.append(mean_accu)
  503. mean_loss = bspredSummary.groupby('test')['mse'].mean()
  504. mean_loss = mean_loss[~mean_loss.index.str.contains('baseline')]
  505. mean_loss = mean_loss.reindex(perturbs_list)
  506. loss_list.append(mean_loss)
  509. bestM_accu = pd.concat(accu_list, axis=1); bestM_accu.columns = baseline_types; bestM_accu = bestM_accu.T
  510. bestM_accu.loc['mu150'] = bestM_accu.loc['E5']; bestM_accu.loc['tau15'] = bestM_accu.loc['E5'];
  511. bestM_accu.loc['BP1.0'] = bestM_accu.loc['E5']; bestM_accu.loc['g1.0'] = bestM_accu.loc['E5'];
  512. bestM_accu.loc['g1.5'] = bestM_accu.loc['E5']; bestM_accu = bestM_accu.loc[model_list]
  513. bestM_accu.to_csv(os.path.join(allRuns_path, 'bestM_heatmap','bestM_accu.csv'))
  516. bestM_loss = pd.concat(loss_list, axis=1); bestM_loss.columns = baseline_types; bestM_loss = bestM_loss.T
  517. bestM_loss.loc['mu150'] = bestM_loss.loc['E5']; bestM_loss.loc['tau15'] = bestM_loss.loc['E5'];
  518. bestM_loss.loc['BP1.0'] = bestM_loss.loc['E5']; bestM_loss.loc['g1.0'] = bestM_loss.loc['E5'];
  519. bestM_loss.loc['g1.5'] = bestM_loss.loc['E5']; bestM_loss = bestM_loss.loc[model_list]
  520. bestM_loss.to_csv(os.path.join(allRuns_path, 'bestM_heatmap','bestM_loss.csv'))
  522. # %%
  523. cmap_accu = 'coolwarm_r'; cmap_loss = 'coolwarm';
  525. plt.figure(figsize=(12, 8))
  526. sns.heatmap(bestM_accu, annot=False, cmap=cmap_accu, cbar_kws={'label': 'Accuracy (%)'}, linecolor='lightgrey', linewidths=0.5 )
  527. plt.xlabel("Perturbation", fontweight='bold'); plt.ylabel("Best CNN", fontweight='bold')
  528. plt.tight_layout(); plt.savefig(os.path.join(allRuns_path, 'bestM_heatmap', 'accu.png'), bbox_inches='tight', pad_inches=0.1); plt.close()
  530. fig, ax = plt.subplots(figsize=(12, 8))
  531. sns.heatmap(bestM_loss, annot=False, cmap=cmap_loss, cbar_kws={'label': 'Loss'}, linecolor='lightgrey', linewidths=0.5, vmax=0.01 )
  532. plt.xlabel("Perturbation", fontweight='bold'); plt.ylabel("Best CNN", fontweight='bold')
  533. plt.tight_layout(); plt.savefig(os.path.join(allRuns_path, 'bestM_heatmap', 'loss.png'), bbox_inches='tight', pad_inches=0.1); plt.close()
  536. # %% [markdown]
  537. # # ----------------------------------------------------------------------
  538. # # FMM, Confi, Indi, allBaselines
  540. # %% [markdown]
  541. # ### load model
  543. # %%
  544. model, optimizer, scheduler, criterion = init_conn_model()
  545. connCNN,_ = load_conn_model(model,optimizer,scheduler,savePath=os.path.join(result_path, 'allBaselineTrain_Testing'), filename='c_100.0.pth')
  547. model, optimizer, scheduler, criterion = init_weight_model()
  548. weighCNN,_ = load_model(model,optimizer,scheduler,savePath=os.path.join(result_path, 'allBaselineTrain_Testing'), filename='w_0.006.pth')
  552. # %% [markdown]
  553. # ### perb list
  555. # %%
  556. mus = [150+2*i for i in range(16)]
  557. mu_prefix = ['mu'+str(mu) for mu in mus]; mu_featureDic = [{'mu':mu, 'tau':15, 'BP':1, 'EI':0.5, 'g':1} for mu in mus]
  558. muE3_prefix = ['mu_E3'+str(mu) for mu in mus]; muE3_featureDic = [{'mu':mu, 'tau':15, 'BP':1, 'EI':0.3, 'g':1} for mu in mus]
  559. muE8_prefix = ['mu_E8'+str(mu) for mu in mus]; muE8_featureDic = [{'mu':mu, 'tau':15, 'BP':1, 'EI':0.8, 'g':1} for mu in mus]
  561. mug05_prefix = ['mu_g0.5'+str(mu) for mu in mus]; mug05_featureDic = [{'mu':mu, 'tau':15, 'BP':1, 'EI':0.5, 'g':0.5} for mu in mus]
  562. mug15_prefix = ['mu_g1.5'+str(mu) for mu in mus]; mug15_featureDic = [{'mu':mu, 'tau':15, 'BP':1, 'EI':0.5, 'g':1.5} for mu in mus]
  564. muBP05_prefix = ['mu_BP0.5'+str(mu) for mu in mus]; muBP05_featureDic = [{'mu':mu, 'tau':15, 'BP':0.5, 'EI':0.5, 'g':1} for mu in mus]
  566. mutau5_prefix = ['mu_tau5'+str(mu) for mu in mus]; mutau5_featureDic = [{'mu':mu, 'tau':5, 'BP':1, 'EI':0.5, 'g':1} for mu in mus]
  567. mutau40_prefix = ['mu_tau40'+str(mu) for mu in mus]; mutau40_featureDic = [{'mu':mu, 'tau':40, 'BP':1, 'EI':0.5, 'g':1} for mu in mus]
  570. taus = [5*i for i in range(1, 11)]
  571. tau_prefix = ['tau'+str(taus) for taus in taus]; tau_featureDic = [{'mu':150, 'tau':tau, 'BP':1, 'EI':0.5, 'g':1} for tau in taus]
  572. tauE3_prefix = ['tau_E3'+str(taus) for taus in taus]; tauE3_featureDic = [{'mu':150, 'tau':tau, 'BP':1, 'EI':0.3, 'g':1} for tau in taus]
  573. tauE8_prefix = ['tau_E8'+str(taus) for taus in taus]; tauE8_featureDic = [{'mu':150, 'tau':tau, 'BP':1, 'EI':0.8, 'g':1} for tau in taus]
  574. taug05_prefix = ['tau_g0.5'+str(taus) for taus in taus]; taug05_featureDic = [{'mu':150, 'tau':tau, 'BP':1, 'EI':0.5, 'g':0.5} for tau in taus]
  575. taug15_prefix = ['tau_g1.5'+str(taus) for taus in taus]; taug15_featureDic = [{'mu':150, 'tau':tau, 'BP':1, 'EI':0.5, 'g':1.5} for tau in taus]
  576. tauBP05_prefix = ['tau_BP0.5'+str(taus) for taus in taus]; tauBP05_featureDic = [{'mu':150, 'tau':tau, 'BP':0.5, 'EI':0.5, 'g':1} for tau in taus]
  577. taumu165_prefix = ['tau_mu165'+str(taus) for taus in taus]; taumu165_featureDic = [{'mu':165, 'tau':tau, 'BP':1, 'EI':0.5, 'g':1} for tau in taus]
  578. taumu180_prefix = ['tau_mu180'+str(taus) for taus in taus]; taumu180_featureDic = [{'mu':180, 'tau':tau, 'BP':1, 'EI':0.5, 'g':1} for tau in taus]
  581. BPs = [0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
  582. BP_prefix = ['BP'+str(bp) for bp in BPs]; BP_featureDic = [{'mu':150, 'tau':15, 'BP':bp, 'EI':0.5, 'g':1} for bp in BPs]
  583. BPE3_prefix = ['BP_E3'+str(bp) for bp in BPs]; BPE3_featureDic = [{'mu':150, 'tau':15, 'BP':bp, 'EI':0.3, 'g':1} for bp in BPs]
  584. BPE8_prefix = ['BP_E8'+str(bp) for bp in BPs]; BPE8_featureDic = [{'mu':150, 'tau':15, 'BP':bp, 'EI':0.8, 'g':1} for bp in BPs]
  585. BPg05_prefix = ['BP_g0.5'+str(bp) for bp in BPs]; BPg05_featureDic = [{'mu':150, 'tau':15, 'BP':bp, 'EI':0.5, 'g':0.5} for bp in BPs]
  586. BPg15_prefix = ['BP_g1.5'+str(bp) for bp in BPs]; BPg15_featureDic = [{'mu':150, 'tau':15, 'BP':bp, 'EI':0.5, 'g':1.5} for bp in BPs]
  587. BPmu165_prefix = ['BP_mu165'+str(bp) for bp in BPs]; BPmu165_featureDic = [{'mu':165, 'tau':15, 'BP':bp, 'EI':0.5, 'g':1} for bp in BPs]
  588. BPmu180_prefix = ['BP_mu180'+str(bp) for bp in BPs]; BPmu180_featureDic = [{'mu':180, 'tau':15, 'BP':bp, 'EI':0.5, 'g':1} for bp in BPs]
  589. BPtau5_prefix = ['BP_tau5'+str(bp) for bp in BPs]; BPtau5_featureDic = [{'mu':150, 'tau':5, 'BP':bp, 'EI':0.5, 'g':1} for bp in BPs]
  590. BPtau40_prefix = ['BP_tau40'+str(bp) for bp in BPs]; BPtau40_featureDic = [{'mu':150, 'tau':40, 'BP':bp, 'EI':0.5, 'g':1} for bp in BPs]
  593. EIatio=[0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
  594. EI_prefix = ['EI'+str(ei) for ei in EIatio]; EI_featureDic = [{'mu':150, 'tau':15, 'BP':1, 'EI':ei, 'g':1} for ei in EIatio]
  595. EIg05_prefix = ['EI_g0.5'+str(ei) for ei in EIatio if ei !=0.3]; EIg05_featureDic = [{'mu':150, 'tau':15, 'BP':1, 'EI':ei, 'g':0.5} for ei in EIatio if ei !=0.3]
  596. EIg15_prefix = ['EI_g1.5'+str(ei) for ei in EIatio]; EIg15_featureDic = [{'mu':150, 'tau':15, 'BP':1, 'EI':ei, 'g':1.5} for ei in EIatio]
  597. EIBP05_prefix = ['EI_BP0.5'+str(ei) for ei in EIatio]; EIBP05_featureDic = [{'mu':150, 'tau':15, 'BP':0.5, 'EI':ei, 'g':1} for ei in EIatio]
  598. EImu165_prefix = ['EI_mu165'+str(ei) for ei in EIatio]; EImu165_featureDic = [{'mu':165, 'tau':15, 'BP':1, 'EI':ei, 'g':1} for ei in EIatio]
  599. EImu180_prefix = ['EI_mu180'+str(ei) for ei in EIatio]; EImu180_featureDic = [{'mu':180, 'tau':15, 'BP':1, 'EI':ei, 'g':1} for ei in EIatio]
  600. EItau5_prefix = ['EI_tau5'+str(ei) for ei in EIatio]; EItau5_featureDic = [{'mu':150, 'tau':5, 'BP':1, 'EI':ei, 'g':1} for ei in EIatio]
  601. EItau40_prefix = ['EI_tau40'+str(ei) for ei in EIatio]; EItau40_featureDic = [{'mu':150, 'tau':40, 'BP':1, 'EI':ei, 'g':1} for ei in EIatio]
  604. gbars = [0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0]
  605. gbar_prefix = ['g'+str(g) for g in gbars]; gbar_featureDic = [{'mu':150, 'tau':15, 'BP':1, 'EI':0.5, 'g':g} for g in gbars]
  606. gbarE3_prefix = ['g_E3'+str(g) for g in gbars if g!= 0.4]; gbarE3_featureDic = [{'mu':150, 'tau':15, 'BP':1, 'EI':0.3, 'g':g} for g in gbars if g!= 0.4]
  607. gbarE8_prefix = ['g_E8'+str(g) for g in gbars]; gbarE8_featureDic = [{'mu':150, 'tau':15, 'BP':1, 'EI':0.8, 'g':g} for g in gbars]
  608. gbarBP05_prefix = ['g_BP0.5'+str(g) for g in gbars if g!= 0.4]; gbarBP05_featureDic = [{'mu':150, 'tau':15, 'BP':0.5, 'EI':0.5, 'g':g} for g in gbars if g!= 0.4]
  609. gbarmu165_prefix = ['g_mu165'+str(g) for g in gbars if g!= 0.4]; gbarmu165_featureDic = [{'mu':165, 'tau':15, 'BP':1, 'EI':0.5, 'g':g} for g in gbars if g!= 0.4]
  610. gbarmu180_prefix = ['g_mu180'+str(g) for g in gbars if g!= 0.4]; gbarmu180_featureDic = [{'mu':180, 'tau':15, 'BP':1, 'EI':0.5, 'g':g} for g in gbars if g!= 0.4]
  611. gbartau5_prefix = ['g_tau5'+str(g) for g in gbars if g!= 0.4]; gbartau5_featureDic = [{'mu':150, 'tau':5, 'BP':1, 'EI':0.5, 'g':g} for g in gbars if g!= 0.4]
  612. gbartau40_prefix = ['g_tau40'+str(g) for g in gbars if g!= 0.4]; gbartau40_featureDic = [{'mu':150, 'tau':40, 'BP':1, 'EI':0.5, 'g':g} for g in gbars if g!= 0.4]
  616. file_prefix_E5_list = mu_prefix + tau_prefix + BP_prefix + EI_prefix + gbar_prefix
  617. file_prefix_E3_list = muE3_prefix + tauE3_prefix + BPE3_prefix + EI_prefix + gbarE3_prefix
  618. file_prefix_E8_list = muE8_prefix + tauE8_prefix + BPE8_prefix + EI_prefix + gbarE8_prefix
  619. file_prefix_g05_list = mug05_prefix + taug05_prefix + BPg05_prefix + EIg05_prefix + gbar_prefix
  620. file_prefix_g15_list = mug15_prefix + taug15_prefix + BPg15_prefix + EIg15_prefix + gbar_prefix
  621. file_prefix_BP05_list = muBP05_prefix + tauBP05_prefix + BP_prefix + EIBP05_prefix + gbarBP05_prefix
  622. file_prefix_mu165_list = mu_prefix + taumu165_prefix + BPmu165_prefix + EImu165_prefix + gbarmu165_prefix
  623. file_prefix_mu180_list = mu_prefix + taumu180_prefix + BPmu180_prefix + EImu180_prefix + gbarmu180_prefix
  624. file_prefix_tau5_list = mutau5_prefix + tau_prefix + BPtau5_prefix + EItau5_prefix + gbartau5_prefix
  625. file_prefix_tau40_list = mutau40_prefix + tau_prefix + BPtau40_prefix + EItau40_prefix + gbartau40_prefix
  628. file_featureDic_E5_list = mu_featureDic + tau_featureDic + BP_featureDic + EI_featureDic + gbar_featureDic
  629. file_featureDic_E3_list = muE3_featureDic + tauE3_featureDic + BPE3_featureDic + EI_featureDic + gbarE3_featureDic
  630. file_featureDic_E8_list = muE8_featureDic + tauE8_featureDic + BPE8_featureDic + EI_featureDic + gbarE8_featureDic
  631. file_featureDic_g05_list = mug05_featureDic + taug05_featureDic + BPg05_featureDic + EIg05_featureDic + gbar_featureDic
  632. file_featureDic_g15_list = mug15_featureDic + taug15_featureDic + BPg15_featureDic + EIg15_featureDic + gbar_featureDic
  633. file_featureDic_BP05_list = muBP05_featureDic + tauBP05_featureDic + BP_featureDic + EIBP05_featureDic + gbarBP05_featureDic
  634. file_featureDic_mu165_list = mu_featureDic + taumu165_featureDic + BPmu165_featureDic + EImu165_featureDic + gbarmu165_featureDic
  635. file_featureDic_mu180_list = mu_featureDic + taumu180_featureDic + BPmu180_featureDic + EImu180_featureDic + gbarmu180_featureDic
  636. file_featureDic_tau5_list = mutau5_featureDic + tau_featureDic + BPtau5_featureDic + EItau5_featureDic + gbartau5_featureDic
  637. file_featureDic_tau40_list = mutau40_featureDic + tau_featureDic + BPtau40_featureDic + EItau40_featureDic + gbartau40_featureDic
  640. all_file_prefix_list = file_prefix_E3_list + file_prefix_E5_list + file_prefix_E8_list + file_prefix_g05_list + file_prefix_g15_list +\
  641. file_prefix_BP05_list + file_prefix_mu165_list + file_prefix_mu180_list + file_prefix_tau5_list + file_prefix_tau40_list
  642. print(len(all_file_prefix_list), 'perturbations in total')
  643. all_perturbation_loader = [load_oneLoader(dataloader_path, file_prefix+'_loader.pkl') for file_prefix in all_file_prefix_list]
  646. # %% [markdown]
  647. # ### calculation
  649. # %%
  650. criterionC = nn.BCEWithLogitsLoss()
  651. criterionW = HuberLossWithWeight()
  652. fm_mean_cols = ['conv1_fm0_mean', 'conv1_fm1_mean', 'conv1_fm2_mean', 'conv1_fm3_mean', 'conv2_fm0_mean', 'conv2_fm1_mean']
  654. predSummary_list = []
  656. # retrive the best baseline model ---------------------------------------------------------------
  657. bsType = 'all'
  658. connCNN_Model = connCNN
  659. weightCNN_Model = weighCNN
  662. # predict on baseline-test set -------------------------------------------------------------------
  663. train_loader, val_loader, test_loader = load_dataloaders(dataloader_path, 'baseline_'+bsType+'_loader.pkl')
  665. # pred with connCNN ------------
  666. avg_connect_loss, accu, pred_list,confi_list, label_list, w_list, sCInfo_list = evaluateConnCNN_wConfi_model(connCNN_Model, test_loader, criterionC)
  667. # pred with weightCNN ----------
  668. avg_wegiht_loss, predW_list, gtW_list, label0_loss, label1_loss, sWInfo_list = evaluateWeightCNN_model(weightCNN_Model, test_loader, criterionW)
  670. # feature map mean -------------
  671. conn_fmMean_list = []; weight_fmMean_list = []
  672. conn_fmMean_pre_list = []; weight_fmMean_pre_list = []
  673. conn_fmMean_postBN_list = []; weight_fmMean_postBN_list = []
  674. for ccgs, cs, ws, ss in test_loader:
  675. for m in range(len(ccgs)):
  677. # pre activation (raw featureMaps)
  678. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps(connCNN_Model, ccgs[m]) # connCNN
  679. conn_fmMean_pre_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  680. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps(weightCNN_Model, ccgs[m])# weightCNN
  681. weight_fmMean_pre_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  683. # postBN (featureMaps after BatchNorm, but before tanh)
  684. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_postBN(connCNN_Model, ccgs[m]) # connCNN
  685. conn_fmMean_postBN_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  686. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_postBN(weightCNN_Model, ccgs[m])# weightCNN
  687. weight_fmMean_postBN_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  689. # post activation (featureMaps after BatchNorm & tanh)
  690. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_post_activation(connCNN_Model, ccgs[m]) # connCNN
  691. conn_fmMean_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  692. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_post_activation(weightCNN_Model, ccgs[m])# weightCNN
  693. weight_fmMean_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  696. predSummary = pd.DataFrame([label_list, pred_list, confi_list, gtW_list, predW_list, sCInfo_list, ['baseline_'+bsType]*len(sCInfo_list)],
  697. index=['connLabel', 'predLabel', 'confi', 'gtWeights', 'predWeights', 'sample', 'test']).T
  698. connPre_FMM = pd.DataFrame(np.array(conn_fmMean_pre_list), columns=['pre_conn_'+col for col in fm_mean_cols])
  699. connPost_FMM = pd.DataFrame(np.array(conn_fmMean_list), columns=['post_conn_'+col for col in fm_mean_cols])
  700. connPostBN_FMM = pd.DataFrame(np.array(conn_fmMean_postBN_list), columns=['postBN_conn_'+col for col in fm_mean_cols])
  702. weightPre_FMM = pd.DataFrame(np.array(weight_fmMean_pre_list), columns=['pre_weight_'+col for col in fm_mean_cols])
  703. weightPost_FMM = pd.DataFrame(np.array(weight_fmMean_list), columns=['post_weight_'+col for col in fm_mean_cols])
  704. weightPostBN_FMM = pd.DataFrame(np.array(weight_fmMean_postBN_list), columns=['postBN_weight_'+col for col in fm_mean_cols])
  706. predSummary = pd.concat([predSummary, connPre_FMM, connPost_FMM, connPostBN_FMM, weightPre_FMM, weightPost_FMM, weightPostBN_FMM], axis=1); predSummary_list.append(predSummary)
  710. # predict on associated perturbations ------------------------------------------------------------
  711. for fileIdx in range(len(all_file_prefix_list)):
  712. perb_type = all_file_prefix_list[fileIdx]
  713. perb_loader = all_perturbation_loader[fileIdx]
  715. # pred with connCNN ------------
  716. avg_connect_loss, accu, pred_list,confi_list, label_list, w_list, sCInfo_list = evaluateConnCNN_wConfi_model(connCNN_Model, perb_loader, criterionC)
  718. # pred with weightCNN ----------
  719. avg_wegiht_loss, predW_list, gtW_list, label0_loss, label1_loss, sWInfo_list = evaluateWeightCNN_model(weightCNN_Model, perb_loader, criterionW)
  721. assert np.array_equal(sCInfo_list, sWInfo_list), bsType+' '+perb_type+" sInfo Arrays are not equal"
  723. # get feature map mean on each ccg -------------
  724. conn_fmMean_list = []; weight_fmMean_list = []
  725. conn_fmMean_pre_list = []; weight_fmMean_pre_list = []
  726. conn_fmMean_postBN_list = []; weight_fmMean_postBN_list = []
  727. for ccgs, cs, ws, ss in perb_loader:
  728. for m in range(len(ccgs)):
  730. # pre activation (raw featureMaps)
  731. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps(connCNN_Model, ccgs[m]) # connCNN
  732. conn_fmMean_pre_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  733. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps(weightCNN_Model, ccgs[m])# weightCNN
  734. weight_fmMean_pre_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  736. # postBN (featureMaps after BatchNorm, but before tanh)
  737. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_postBN(connCNN_Model, ccgs[m]) # connCNN
  738. conn_fmMean_postBN_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  739. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_postBN(weightCNN_Model, ccgs[m])# weightCNN
  740. weight_fmMean_postBN_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  742. # post activation (featureMaps after BatchNorm & tanh)
  743. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_post_activation(connCNN_Model, ccgs[m])
  744. conn_fmMean_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  745. fm_conv1, fm_conv2, activation_1, activation_2 = cal_feature_maps_post_activation(weightCNN_Model, ccgs[m])
  746. weight_fmMean_list.append(fm_conv1.mean(dim=1).tolist() + fm_conv2.mean(dim=1).tolist())
  749. predSummary = pd.DataFrame([label_list, pred_list, confi_list, gtW_list, predW_list, sCInfo_list, [perb_type]*len(sCInfo_list)],
  750. index=['connLabel', 'predLabel', 'confi', 'gtWeights', 'predWeights', 'sample', 'test']).T
  751. connPre_FMM = pd.DataFrame(np.array(conn_fmMean_pre_list), columns=['pre_conn_'+col for col in fm_mean_cols])
  752. connPost_FMM = pd.DataFrame(np.array(conn_fmMean_list), columns=['post_conn_'+col for col in fm_mean_cols])
  753. connPostBN_FMM = pd.DataFrame(np.array(conn_fmMean_postBN_list), columns=['postBN_conn_'+col for col in fm_mean_cols])
  755. weightPre_FMM = pd.DataFrame(np.array(weight_fmMean_pre_list), columns=['pre_weight_'+col for col in fm_mean_cols])
  756. weightPost_FMM = pd.DataFrame(np.array(weight_fmMean_list), columns=['post_weight_'+col for col in fm_mean_cols])
  757. weightPostBN_FMM = pd.DataFrame(np.array(weight_fmMean_postBN_list), columns=['postBN_weight_'+col for col in fm_mean_cols])
  759. predSummary = pd.concat([predSummary, connPre_FMM, connPost_FMM, connPostBN_FMM, weightPre_FMM, weightPost_FMM, weightPostBN_FMM], axis=1); predSummary_list.append(predSummary)
  762. allBaseline_bspredSummary = pd.concat(predSummary_list)
  763. allBaseline_bspredSummary.to_csv(os.path.join(confiSave_path, 'allBaselines_confi_w_perbs.csv'))
  764. allBaseline_bspredSummary.head(2)
  767. # %% [markdown]
  768. # ### combine FMM, Confi, Indictors
  770. # %%
  771. # perb_exc_all, perb_inh_all = [], []
  773. # for bIdx in range(len(baseline_types)):
  774. # bsType = baseline_types[bIdx]
  775. # bspredSummary = pd.read_csv(os.path.join(confiSave_path, bsType+'_confi_w_perbs.csv')).iloc[:, 1:]
  777. # exc_indicator_df = pd.read_csv(os.path.join(indiSave_path, bsType+'_indicator_exc.csv')).iloc[:, 1:]
  778. # perb_exc_all.append(exc_indicator_df)
  779. # inh_indicator_df = pd.read_csv(os.path.join(indiSave_path, bsType+'_indicator_inh.csv')).iloc[:, 1:]
  780. # perb_inh_all.append(inh_indicator_df)
  783. perb_exc_indis = pd.concat(perb_exc_all, ignore_index=True); print(perb_exc_indis.shape)
  784. perb_inh_indis = pd.concat(perb_inh_all, ignore_index=True); print(perb_einhindis.shape)
  786. allBaseline_pred_indi_exc = pd.merge(allBaseline_bspredSummary, perb_exc_indis, on='sample', how='inner')
  787. allBaseline_pred_indi_exc = allBaseline_pred_indi_exc.drop(columns=['test_y']); allBaseline_pred_indi_exc = allBaseline_pred_indi_exc.rename(columns={'test_x': 'test'})
  788. allBaseline_pred_indi_inh = pd.merge(allBaseline_bspredSummary, perb_inh_indis, on='sample', how='inner')
  789. allBaseline_pred_indi_inh = allBaseline_pred_indi_inh.drop(columns=['test_y']); allBaseline_pred_indi_inh = allBaseline_pred_indi_inh.rename(columns={'test_x': 'test'})
  791. print('allBaseline_pred_indi_exc.shape:', allBaseline_pred_indi_exc.shape)
  792. print('allBaseline_pred_indi_inh.shape:', allBaseline_pred_indi_inh.shape)
  794. allBaseline_pred_indi_exc.to_csv(os.path.join(resultAnalysis_path, 'allBaselines_confi_fmm_indi_exc.csv'))
  795. allBaseline_pred_indi_inh.to_csv(os.path.join(resultAnalysis_path, 'allBaselines_confi_fmm_indi_inh.csv'))
  797. print('Done')
  798. allBaseline_pred_indi_inh.head(2)
  800. # %%
  803. # %% [markdown]
  804. # # ----------------------------------------------------------------------
  805. # # Test - Indicator Cal
  807. # %%
  808. i=0
  809. fileTest = file_test_list[i]
  810. featureDic = file_featureDics[i]
  811. bs_ccg, ws, ls, ss = read_ccg(data_path, fileTest+'_CCG.csv')
  813. # %%
  814. _ = ccg_indicators(bs_ccg[0], connection_type='exc', smoothSigma=0.5, bin_size=1, peak_window_ms=10, ifVerbose=True, ifPlot=True, timebins=timebins, ifSave=False)
  815. print(_); print('---------------------------------------')
  818. _ = ccg_indicators(bs_ccg[20], connection_type='inh', smoothSigma=0.5, bin_size=1, peak_window_ms=10, ifVerbose=True, ifPlot=True, timebins=timebins, ifSave=False)
  819. print(_); print('---------------------------------------')
  821. # %% [markdown]
  822. # ### Digest - exc
  824. # %%
  825. i=0
  826. fileTest = file_test_list[i]
  827. featureDic = file_featureDics[i]
  828. bs_ccg, ws, ls, ss = read_ccg(data_path, fileTest+'_CCG.csv')
  829. print('looking at', fileTest, ccg.shape)
  830. ws[20]
  832. # %%
  833. bin_size = 1
  834. peak_window_ms = 10
  835. center = len(ccg) // 2
  836. baseline = np.mean(np.concatenate([ccg[:10], ccg[-10:]]))
  839. ccg = bs_ccg[0] #327
  841. # peak
  842. search_bins = int(peak_window_ms / bin_size)
  843. search_region = ccg[center-search_bins : center+search_bins+1]
  845. peak_idx_rel = np.argmax(search_region)
  846. peak_idx = center - search_bins + peak_idx_rel
  847. peak_val = ccg[peak_idx]
  848. half_val = peak_val / 2
  849. peak_lag = (peak_idx - center) * bin_size
  851. print('peak happens at bin', peak_idx, '=', peak_val, 'with time lag =', peak_lag )
  853. plt.figure(figsize=(4,2))
  854. plt.bar(timebins, ccg, color=ccgColor, width=1); plt.title('raw'); plt.show()
  856. # %%
  857. # peak width (full width at half max)
  858. half_val = peak_height / 2
  859. left, right = peak_idx, peak_idx
  860. while left > 0 and ccg[left] > half_val:
  861. left -= 1
  862. while right < len(ccg) - 1 and ccg[right] > half_val:
  863. right += 1
  864. peak_width = (right - left) * bin_size
  866. print('peak drop to half in', peak_width, 'bins')
  867. print(ccg[peak_idx:peak_idx+peak_width])
  869. # %%
  870. # noise estimation from tails ----------------------------------
  871. tail_bins = np.r_[np.arange(25), np.arange(len(ccg) - 25, len(ccg))]
  872. noise_floor = np.mean(ccg[tail_bins])
  873. noise_std = np.std(ccg[tail_bins])
  874. peak_to_noise = ((peak_val - noise_floor) / (noise_std + 1e-10))
  876. print('peak_to_noise =', peak_to_noise)
  878. # %%
  879. # entropy
  880. ccg_smooth = gaussian_filter1d(ccg, sigma=0.5)
  881. ccg_prob = ccg_smooth / (np.sum(ccg_smooth) + 1e-10)
  882. ccg_entropy = entropy(ccg_prob, base=2)
  883. ccg_entropy_norm = ccg_entropy / np.log2(len(ccg))
  884. print('entropy =', ccg_entropy, 'norm entropy =', ccg_entropy_norm)
  886. fig, ax = plt.subplots(1, 3, figsize=(12, 2))
  887. ax[0].bar(timebins, ccg, color=ccgColor, width=1); ax[0].set_title('raw')
  888. ax[1].bar(timebins, ccg_smooth, color=ccgColor, width=1); ax[1].set_title('smoothed')
  889. ax[2].bar(timebins, ccg_prob, color=ccgColor, width=1); ax[2].set_title('prob')
  890. plt.tight_layout(); plt.show()
  892. # %%
  893. # KL divergence only within ±10 bins of the center
  894. peak_window_ms = 10
  896. window_bins = int(peak_window_ms / bin_size)
  897. kl_window = ccg[center - window_bins:center + window_bins + 1]
  899. P = kl_window / (np.sum(kl_window) + 1e-10)
  900. U = np.ones_like(P) / len(P)
  901. kl_div = np.sum(rel_entr(P, U)) / np.log(2) # in bits
  902. print('kl_div =', kl_div)
  905. fig, ax = plt.subplots(1, 2, figsize=(12, 2))
  906. ax[0].bar(timebins, ccg, color=ccgColor, width=1); ax[0].set_title('raw')
  907. ax[1].bar(timebins, ccg, color=ccgColor, width=1);
  908. ax[1].bar(timebins[center - window_bins:center + window_bins + 1], kl_window, color='r', width=1);ax[1].set_title('shifted-focused')
  909. plt.tight_layout(); plt.show()
  911. # %%
  912. # entropy only within ±10 bins of the center
  914. ccg_entropy_focus = entropy(P, base=2)
  915. ccg_entropy_focus_norm = ccg_entropy_focus / np.log2(len(kl_window))
  916. print('ccg_entropy_focus =', ccg_entropy_focus, 'ccg_entropy_focus_norm =', ccg_entropy_focus_norm)
  919. # %%
  920. # Temporal span above noise threshold
  921. thresh = noise_floor + 2 * noise_std
  922. left_span, right_span = peak_idx, peak_idx
  923. while left_span > 0 and ccg_smooth[left_span] > thresh:
  924. left_span -= 1
  925. while right_span < len(ccg_smooth) - 1 and ccg_smooth[right_span] > thresh:
  926. right_span += 1
  927. temporal_span = (right_span - left_span) * bin_size
  929. print('from', left_span, 'to', right_span, 'bins, we have ccg above 0.25*peak/dip')
  931. fig, ax = plt.subplots(1, 2, figsize=(8, 2))
  932. ax[0].bar(timebins, ccg, color=ccgColor, width=1); ax[0].set_title('raw')
  933. ax[1].bar(timebins, ccg_smooth, color=ccgColor, width=1); ax[1].set_title('smoothed')
  934. ax[1].bar(timebins[left_span:right_span], ccg_smooth[left_span:right_span],
  935. color=mC, width=1, alpha=0.4, label='temporal span'); ax[1].legend(loc=1)
  936. plt.tight_layout(); plt.show()
  938. # %% [markdown]
  939. # ### Digest - inh
  941. # %%
  942. bin_size = 1
  943. ccg = bs_ccg[20]
  946. peak_window_ms = 10
  947. search_bins = int(peak_window_ms / bin_size)
  948. search_region = ccg[center-search_bins : center+search_bins+1]
  949. baseline = np.mean(np.concatenate([ccg[:10], ccg[-10:]]))
  952. # peak
  953. # center = len(ccg) // 2
  954. # peak_height = np.min(ccg)
  955. # peak_idx = np.argmin(ccg)
  956. # peak_lag = (peak_idx - center) * bin_size
  958. peak_idx_rel = np.argmin(search_region)
  959. peak_idx = center - search_bins + peak_idx_rel
  960. peak_val = ccg[peak_idx]
  961. peak_lag = (peak_idx - center) * bin_size
  963. print('dip peak happens at bin', peak_idx, '=', peak_val, 'with time lag =', peak_lag )
  965. plt.figure(figsize=(4,2))
  966. plt.bar(timebins, ccg, color=ccgColor, width=1); plt.title('raw'); plt.show()
  968. # %%
  969. # peak width (full width at half max)
  970. # half_val = peak_height / 2
  971. # left, right = peak_idx, peak_idx
  972. # while left > 0 and ccg[left] < half_val:
  973. # left -= 1
  974. # while right < len(ccg) - 1 and ccg[right] < half_val:
  975. # right += 1
  976. # peak_width = (right - left) * bin_size
  978. half_val = (peak_val + baseline) / 2
  979. left, right = peak_idx, peak_idx
  980. while left > 0 and (ccg[left] < half_val):
  981. left -= 1
  982. while right < len(ccg) - 1 and (ccg[right] < half_val):
  983. right += 1
  984. peak_width = (right - left) * bin_size
  985. print('peak drop to half in', peak_width, 'bins')
  986. print(ccg[peak_idx:peak_idx+peak_width])
  988. # %%
  989. # noise estimation from tails ----------------------------------
  990. tail_bins = np.r_[np.arange(25), np.arange(len(ccg) - 25, len(ccg))]
  991. noise_floor = np.mean(ccg[tail_bins])
  992. noise_std = np.std(ccg[tail_bins])
  993. peak_to_noise = ((peak_val - noise_floor) / (noise_std + 1e-10)) if connection_type == 'exc' else ((noise_floor - peak_val) / (noise_std + 1e-10))
  996. # %%
  999. # %%
  1000. # entropy
  1001. ccg_smooth = gaussian_filter1d(ccg, sigma=0.5)
  1002. ccg_shifted = ccg_smooth - np.min(ccg_smooth) # shift to make in nonnegative
  1003. ccg_prob = ccg_shifted / (np.sum(ccg_shifted) + 1e-10)
  1004. ccg_entropy = entropy(ccg_prob, base=2)
  1005. ccg_entropy_norm =ccg_entropy / np.log2(len(ccg_smooth))
  1006. print('entropy =', ccg_entropy)
  1007. print('normed entropy =', ccg_entropy_norm)
  1010. fig, ax = plt.subplots(1, 4, figsize=(12, 2))
  1011. ax[0].bar(timebins, ccg, color=ccgColor, width=1); ax[0].set_title('raw')
  1012. ax[1].bar(timebins, ccg_smooth, color=ccgColor, width=1); ax[1].set_title('smoothed')
  1013. ax[2].bar(timebins, ccg_shifted, color=ccgColor, width=1); ax[2].set_title('shifted')
  1014. ax[3].bar(timebins, ccg_prob, color=ccgColor, width=1); ax[3].set_title('prob')
  1015. plt.tight_layout(); plt.show()
  1017. # %%
  1018. peak_window_ms = 10
  1020. window_bins = int(peak_window_ms / bin_size)
  1021. kl_window = ccg[center - window_bins:center + window_bins + 1]
  1023. # inh
  1024. kl_window =np.max(kl_window) - kl_window
  1027. P = kl_window / (np.sum(kl_window) + 1e-10)
  1028. U = np.ones_like(P) / len(P)
  1029. kl_div = np.sum(rel_entr(P, U)) # in bits
  1030. print('kl_div =', kl_div)
  1033. fig, ax = plt.subplots(1, 3, figsize=(12, 2))
  1034. ax[0].bar(timebins, ccg, color=ccgColor, width=1); ax[0].set_title('raw')
  1035. ax[1].bar(timebins, ccg, color=ccgColor, width=1);
  1036. ax[1].bar(timebins[center - window_bins:center + window_bins + 1], ccg[center - window_bins:center + window_bins + 1], color='r', width=1);ax[1].set_title('focused')
  1037. ax[2].bar(timebins[center - window_bins:center + window_bins + 1], kl_window, color='r', width=1);ax[2].set_title('shifted-focused')
  1039. plt.tight_layout(); plt.show()
  1041. # %%
  1042. # Temporal span above noise threshold
  1043. thresh = 0.25 * peak_height
  1044. left_span, right_span = peak_idx, peak_idx
  1045. while left_span > 0 and ccg_smooth[left_span] < thresh:
  1046. left_span -= 1
  1047. while right_span < len(ccg_smooth) - 1 and ccg_smooth[right_span] < thresh:
  1048. right_span += 1
  1049. temporal_span = (right_span - left_span) * bin_size
  1051. print('from', left_span, 'to', right_span, 'bins, we have ccg above 0.25*peak/dip')
  1053. fig, ax = plt.subplots(1, 2, figsize=(8, 2))
  1054. ax[0].bar(timebins, ccg, color=ccgColor, width=1); ax[0].set_title('raw')
  1055. ax[1].bar(timebins, ccg_smooth, color=ccgColor, width=1); ax[1].set_title('smoothed')
  1056. ax[1].bar(timebins[left_span:right_span], ccg_smooth[left_span:right_span],
  1057. color=mC, width=1, alpha=0.4, label='temporal span'); ax[1].legend(loc=1)
  1058. plt.tight_layout(); plt.show()
  1060. # %%
  1063. # %% [markdown]
  1064. # ### Function
  1066. # %%
  1067. def ccg_indicators(ccg, connection_type='exc', smoothSigma=0.5, bin_size=1, peak_window_ms=10, ifVerbose=False, ifPlot=False, timebins=None, figsize=(8,2), barColor='lightslategrey', spanColor='firebrick', ifSave=True, savePath=None, filename=None):
  1068. '''
  1069. Calculate signal indicators for CCGs.
  1070. For excitatory connections (peaks) and inhibitory connections (dips), adjusts indicators accordingly.
  1072. Returns: a dictionary with standardized keys:
  1073. - peak_height or dip_depth
  1074. - peak_to_noise or dip_to_noise
  1075. - peak_halfMax_width or dip_halfMax_width
  1076. - peak_lag or dip_lag
  1077. - entropy
  1078. - temporal_span
  1079. '''
  1082. ccg = np.array(ccg, dtype=np.float32)
  1083. N = len(ccg); center = N // 2
  1084. baseline = np.mean(np.concatenate([ccg[:10], ccg[-10:]]))
  1087. # search for peak/dip -----------------------------------------
  1088. # restrict to [-peak_window_ms, peak_window_ms] range around the center, e.g., -10ms ~ 10ms
  1089. search_bins = int(peak_window_ms / bin_size)
  1090. search_region = ccg[center-search_bins : center+search_bins+1]
  1091. if connection_type == 'exc':
  1092. peak_idx_rel = np.argmax(search_region)
  1093. peak_idx = center - search_bins + peak_idx_rel
  1094. peak_val = ccg[peak_idx]
  1095. direction = 'peak'
  1096. elif connection_type == 'inh':
  1097. peak_idx_rel = np.argmin(search_region)
  1098. peak_idx = center - search_bins + peak_idx_rel
  1099. peak_val = ccg[peak_idx]
  1100. direction = 'dip'
  1101. else:
  1102. raise ValueError("connection_type must be 'exc' or 'inh'")
  1104. peak_lag = (peak_idx - center) * bin_size
  1107. # half-max width -----------------------------------------------
  1108. half_val = peak_val / 2 if connection_type == 'exc' else (peak_val + baseline) / 2
  1109. left, right = peak_idx, peak_idx
  1110. while left > 0 and ((ccg[left] > half_val) if connection_type == 'exc' else (ccg[left] < half_val)):
  1111. left -= 1
  1112. while right < len(ccg) - 1 and ((ccg[right] > half_val) if connection_type == 'exc' else (ccg[right] < half_val)):
  1113. right += 1
  1114. peak_width = (right - left) * bin_size
  1117. # noise estimation from tails ----------------------------------
  1118. tail_bins = np.r_[np.arange(25), np.arange(len(ccg) - 25, len(ccg))]
  1119. noise_floor = np.mean(ccg[tail_bins])
  1120. noise_std = np.std(ccg[tail_bins])
  1121. peak_to_noise = ((peak_val - noise_floor) / (noise_std + 1e-10)) if connection_type == 'exc' else ((noise_floor - peak_val) / (noise_std + 1e-10))
  1124. # smooth for entropy and temporal span --------------------------
  1125. ccg_smooth = gaussian_filter1d(ccg, sigma=smoothSigma)
  1126. ccg_prob = ccg_smooth / (np.sum(ccg_smooth) + 1e-10)
  1127. ccg_entropy = entropy(ccg_prob, base=2)
  1128. ccg_entropy_norm = ccg_entropy / np.log2(N)
  1130. # KL Divergence (+- 10ms window) ---------------------------------
  1131. window_bins = int(peak_window_ms / bin_size)
  1132. kl_window = ccg[center - window_bins:center + window_bins + 1]
  1133. P = kl_window / (np.sum(kl_window) + 1e-10)
  1134. U = np.ones_like(P) / len(P)
  1135. kl_div = np.sum(rel_entr(P, U)) / np.log(2) # in bits
  1137. # entropy (+- 10ms window) -----------------------------------------
  1138. window_entropy = entropy(P, base=2)
  1139. window_entropy_norm = window_entropy / np.log2(len(P))
  1142. # temporal span based on threshold
  1143. thresh = noise_floor + 2 * noise_std if connection_type == 'exc' else noise_floor - 2 * noise_std
  1144. left_span, right_span = peak_idx, peak_idx
  1145. while left_span > 0 and ((ccg_smooth[left_span] > thresh) if connection_type == 'exc' else (ccg_smooth[left_span] < thresh)):
  1146. left_span -= 1
  1147. while right_span < len(ccg_smooth) - 1 and ((ccg_smooth[right_span] > thresh) if connection_type == 'exc' else (ccg_smooth[right_span] < thresh)):
  1148. right_span += 1
  1149. temporal_span = (right_span - left_span) * bin_size
  1151. if ifVerbose:
  1152. print(f"{direction} occurs at bin {peak_idx} = {peak_val} with lag = {peak_lag}")
  1153. print(f"{direction} drops to half in {peak_width} bins")
  1154. print(f"Tails: mean = {round(noise_floor, 3)}, std = {round(noise_std, 3)}, {direction}_to_noise = {round(peak_to_noise, 3)}")
  1155. print(f"Temporal span above threshold ({thresh:.2f}) = {temporal_span} bins around center")
  1156. print(f"Entropy = {round(ccg_entropy, 3)}")
  1157. print(f"Normalized entropy = {ccg_entropy_norm:.3f}")
  1158. print(f"Normalized entropy (±{peak_window_ms} ms) = {window_entropy_norm:.3f}")
  1159. print(f"KL divergence (±{peak_window_ms} ms) = {kl_div:.3f}")
  1162. if ifPlot:
  1163. fig, ax = plt.subplots(1, 3, figsize=figsize)
  1164. ax[0].bar(timebins, ccg, color=barColor, width=1); ax[0].set_title('raw')
  1165. ax[1].bar(timebins, ccg_smooth, color=barColor, width=1); ax[1].set_title('smoothed')
  1166. ax[1].bar(timebins[left_span:right_span], ccg_smooth[left_span:right_span],
  1167. color=spanColor, width=1, alpha=0.4, label='temporal span'); ax[1].legend(loc=1)
  1168. ax[2].bar(timebins[center-window_bins : center+window_bins+1], kl_window, color='g', width=1);ax[2].set_title('+-10 focus window')
  1169. plt.tight_layout()
  1170. if ifSave:
  1171. if not os.path.exists(savePath):
  1172. os.makedirs(savePath)
  1173. plt.savefig(os.path.join(savePath, filename))
  1174. plt.close()
  1175. else:
  1176. plt.show()
  1178. # Return unified dictionary with consistent key naming
  1179. result = {
  1180. f"{direction}_height" if direction == 'peak' else "dip_depth": peak_val,
  1181. f"{direction}_lag": peak_lag,
  1182. f"{direction}_halfMax_width": peak_width,
  1183. f"{direction}_to_noise": peak_to_noise,
  1184. "temporal_span": temporal_span,
  1185. "entropy": ccg_entropy,
  1186. "norm_entropy": ccg_entropy_norm,
  1187. 'norm_entropy_window': window_entropy_norm,
  1188. "kl_divergence_window": kl_div
  1189. }
  1191. return result
  1195. # %%
  1196. direction='dip'
  1197. f"{direction}_height" if direction == 'peak' else "dip_depth"
  1199. # %%

4_0_indi_confi_fmm_Calu.ipynb at commit 6bcacec, no license · at the source

Overview

Authors: Xiaoqian Sun1, Hui Lu2,3, Chen Zeng4, Rahul Simha1
ORCID iDs: Xiaoqian Sun, Chen Zeng
  1. Department of Computer Science, School of Engineering and Applied Science, The George Washington University, Washington, District of Columbia, United States of America
  2. The GW Institute for Neuroscience, The George Washington University, Washington, District of Columbia, United States of America
  3. Department of Pharmacology and Physiology, School of Medicine and Health Sciences, The George Washington University, Washington, District of Columbia, United States of America
  4. Department of Physics, Columbian College of Arts and Sciences, The George Washington University, Washington, District of Columbia, United States of America
Institutions: George Washington University (United States)
Journal: PLoS computational biology, volume 22, issue 8, article e1014615
Dates: received 9 February 2026; accepted 22 July 2026; published online 10 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pcbi.1014615 · PMID 42574490 · PMCID PMC13475989 · OpenAlex W7202112642
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: extracellular electrophysiology (units, LFP) (modality), human (organism)
Methods: Connectivity, Machine learning, Statistics, Single-unit activity, calcium imaging
MeSH: Action Potentials*, Convolutional Neural Networks*, Machine Learning*, Models, Neurological*, Nerve Net*, Animals, Computational Biology, Computer Simulation, Humans, Neurons, Synapses (* major topic)
Topic: Advanced Memory and Neural Computing (Electrical and Electronic Engineering, Engineering), according to OpenAlex
Funding: George Washington University (2018–2023 Cross-Disciplinary Research Fund); National Institutes of Health (R01NS118197); NINDS NIH HHS (R01 NS118197)
Citations: not cited yet (Europe PMC); 51 references in the paper

Abstract

Understanding neuronal topology—how neurons are connected—is essential for uncovering neural computation principles and functional organization. However, accurately reconstructing such connectivity remains challenging due to the indirect nature of neural recordings and the complexity of network dynamics. As a first step towards this problem, a growing body of work has explored inferring monosynaptic connectivity directly from spike data. Among these, convolutional neural networks have shown promise when applied to spike-train cross-correlograms. Nevertheless, their ability to generalize across realistic experimental variability and the internal features that drive their predictions remain poorly understood. In this paper, we present a systematic benchmarking and diagnostic study of neural-network-based synaptic inference using simulations across a broad range of biophysical regimes. We show that connectivity classification and synaptic weight estimation, though often combined, rely on distinct internal representations and exhibit markedly different generalization behavior: robust connectivity models emphasize global structure in spike-train correlations, whereas weight estimation models are more sensitive to local signal amplitude and generalize less predictably. Importantly, we find that training on pooled, biologically grounded simulation data substantially improves robustness across parameter perturbations, outperforming models trained under narrow conditions. We further validate these findings in both simulated network data and an in vitro dataset from high‑density microelectrode array recordings with patch‑clamp‑verified ground‑truth connections. Models trained on diverse simulated circuits generalize effectively to novel network architectures and the experimental dataset. Together, these results demonstrate that incorporating biologically realistic diversity during training is critical for developing reliable machine-learning tools for large-scale synaptic inference from neural recordings.

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

Repositories

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

XiaoqianSun0104/OmniCNN_Infer_Connectivity

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 6bcacec66af1098cbbc01c6bd95a0b73512dd4ff, 16 May 2026
Languages: Python (17), Shell (2), Jupyter (2)
Size: 77 files, 21 scripts
Software Heritage: not archived
Found in: the text, “Computational resources and implementation”
Holds: README, environment (environment.yml, requirements.txt), documentation, 2 notebooks
Not found: license file, CITATION.cff, tests, continuous integration
Tools: NumPy (16 files), pandas (14 files), Matplotlib (10 files), seaborn (6 files), NEURON (4 files), PyTorch (4 files), scikit-learn (4 files), SciPy (4 files), SHAP (2 files), statsmodels (1 file), XGBoost (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
22 files
At the source: github.com/XiaoqianSun0104/OmniCNN_Infer_Connectivity

shigerushinomoto/CoNNECT

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: cf768743818419f3d12c9ba7a6e33d9fff3c0ab7, 12 August 2022
Languages: Python (4)
Size: 11 files, 4 scripts
Software Heritage: not archived
Found in: the text, “Comparison with existing methods on HD-MEA data”
Holds: README, license file, environment (modules/setup.py)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (4 files), Keras (1 file), TensorFlow (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
6 files
At the source: github.com/shigerushinomoto/CoNNECT

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:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 25 scripts, each with its path and the digest of its content;
  • 18 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

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

Data

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

Data Availability

All author-generated code used for network simulations, cross-correlogram computation, model training, and benchmarking analyses is publicly available at: https://github.com/XiaoqianSun0104/OmniCNN_Infer_Connectivity. Simulation data supporting the findings of this study can be regenerated using the provided scripts and parameter configurations. Processed example outputs and scripts required to reproduce the analyses are available within the repository. The in vitro high-density microelectrode array dataset analyzed in this study was obtained from the previously published dataset of Donner et al. (2024) and is publicly available at: https://renkulab.io/projects/christian.donner/deepephys-data.

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

Versions

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

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 11 MeSH terms, 3 funders, 47 references.

Cite

This paper

Sun, X., Lu, H., Zeng, C., & Simha, R. (2026). Toward reliable machine learning models for neural circuit inference: A diagnostic study of CNNs on spike trains. PLoS computational biology, 22(8), e1014615. https://doi.org/10.1371/journal.pcbi.1014615

BibTeX

@article{sun2026toward,
author = {Sun, Xiaoqian and Lu, Hui and Zeng, Chen and Simha, Rahul},
title = {{Toward reliable machine learning models for neural circuit inference: A diagnostic study of CNNs on spike trains}},
journal = {PLoS computational biology},
year = {2026},
month = aug,
volume = {22},
number = {8},
pages = {e1014615},
publisher = {PLOS},
issn = {1553-734X},
doi = {10.1371/journal.pcbi.1014615},
url = {https://doi.org/10.1371/journal.pcbi.1014615},
pmid = {42574490},
pmcid = {PMC13475989}
}

RIS

TY - JOUR
AU - Sun, Xiaoqian
AU - Lu, Hui
AU - Zeng, Chen
AU - Simha, Rahul
TI - Toward reliable machine learning models for neural circuit inference: A diagnostic study of CNNs on spike trains
T2 - PLoS computational biology
J2 - PLoS Comput Biol
PY - 2026
DA - 2026/08/10
VL - 22
IS - 8
SP - e1014615
SN - 1553-734X
PB - PLOS
DO - 10.1371/journal.pcbi.1014615
UR - https://doi.org/10.1371/journal.pcbi.1014615
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pcbi.1014615",
"type": "article-journal",
"title": "Toward reliable machine learning models for neural circuit inference: A diagnostic study of CNNs on spike trains",
"container-title": "PLoS computational biology",
"author": [
{
"family": "Sun",
"given": "Xiaoqian"
},
{
"family": "Lu",
"given": "Hui"
},
{
"family": "Zeng",
"given": "Chen"
},
{
"family": "Simha",
"given": "Rahul"
}
],
"container-title-short": "PLoS Comput Biol",
"volume": "22",
"issue": "8",
"page": "e1014615",
"DOI": "10.1371/journal.pcbi.1014615",
"PMID": "42574490",
"PMCID": "PMC13475989",
"ISSN": "1553-734X",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pcbi.1014615",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
10
]
]
}
}

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

Similar papers

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

[1] doi:10.1038/s41598-026-42580-2 [code]
Comparing effective and functional connectivity.
Journal: Scientific reports
In common: pandas, SciPy, Matplotlib, 1 other tool, 9 references
[2] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: SHAP, XGBoost, Keras, 9 other tools
[3] doi:10.3389/fnsys.2026.1822122 [code]
Convergence-divergence circuits for multimodal integration of innate and learned opponent valences.
Journal: Frontiers in systems neuroscience
In common: NEURON, Keras, TensorFlow, 7 other tools, 2 references
[4] doi:10.3390/s26175327 [code]
Subject Identity Confounds qEEG Emotion Recognition on DEAP and DREAMER.
Journal: Sensors (Basel, Switzerland)
In common: SHAP, XGBoost, Keras, 8 other tools
[5] doi:10.1038/s41598-026-48613-0 [code]
An snRNA-seq aging clock for the fruit fly head sheds light on sex-biased aging.
Journal: Scientific reports
In common: SHAP, XGBoost, Keras, 8 other tools
[6] doi:10.1126/sciadv.aed3650 [code]
Truthful visualizations for mass spectrometry imaging enable high-spatial-resolution interactive &lt;i&gt;m/z&lt;/i&gt; mapping and exploration.
Journal: Science advances
In common: SHAP, XGBoost, Keras, 7 other tools
[7] doi:10.1038/s41467-026-72057-9 [code]
Sex-specific behavioral feedback modulates sensorimotor processing and drives flexible social behavior.
Journal: Nature communications
In common: Keras, TensorFlow, statsmodels, 7 other tools, 1 reference
[8] doi:10.1038/s41467-026-75700-7 [code]
Gene regulatory innovations from transposable elements in primate cerebellum development.
Journal: Nature communications
In common: SHAP, Keras, TensorFlow, 7 other tools
[9] doi:10.1186/s13059-026-04125-8 [code]
MLMarker: a machine learning framework for tissue inference and biomarker discovery.
Journal: Genome biology
In common: SHAP, XGBoost, statsmodels, 7 other tools
[10] doi:10.1016/j.bpj.2026.06.005 [code]
Curvature-based machine-learning method for automated segmentation of dendritic spines.
Journal: Biophysical journal
In common: SHAP, XGBoost, Keras, 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.