├── .gitignore
├── 01-behavioral_data_analysis
├── .ipynb_checkpoints
│ ├── 01-training_progress_analysis-checkpoint.ipynb
│ └── 02-fmri_performance_analysis-checkpoint.ipynb
├── 00-log_processing.ipynb
├── 01-training_progress_analysis.ipynb
├── 02-fmri_performance_analysis.ipynb
└── 03-exclusion_variability.ipynb
├── 02-fmri_data_preparation
├── 01-aCompCor_denoising.ipynb
├── 02-timeseries_extraction.ipynb
├── 03-static_FC_estimation.ipynb
├── 04-dynamic_FC_estimation.ipynb
├── 05-motion_and_outliers_control.ipynb
└── 06-FC_density_plots.ipynb
├── 03-static_FC_analyses
├── 00-degree_distribution.ipynb
├── 01-static_modularity_calculation.m
├── 02-tidying_normalized_modularity.ipynb
├── 03-normalized_modularity_stats.ipynb
├── 04-modularity-behaviour_stats.ipynb
└── load_data.py
├── 04-dynamic_FC_analyses
├── 01-multilayer_modularity_calculation.m
├── 02-module_allegiance_matrix_calculation.ipynb
├── 03-fp_dm_plotting.ipynb
├── 04-whole-brain_normalized_recr_integ.ipynb
├── 05-whole-brain_normalized_recr_integ_stats.ipynb
├── 06-whole-brain_mlm_networks_summary.ipynb
├── 07-behavioral_variability_and_recruitmnent_stats.ipynb
├── 08-multilayer_modularity_calculation_signed.m
└── 10-dm_temporal_expansion.ipynb
├── 05-glm_analysis
├── 01-first_level_GLM_analysis.ipynb
├── 02-group_level_GLM_analysis.ipynb
├── 03-changes_in_brain_activity_stats.ipynb
└── 04-activity_vs_recruitment_stats.ipynb
├── LICENCE.txt
├── README.md
├── environment.yml
├── fctools
├── __init__.py
├── denoise.py
├── figures.py
├── networks.py
└── stats.py
└── support
├── modules.txt
└── onsets_dualnback.csv
/.gitignore:
--------------------------------------------------------------------------------
1 | .ipynb_checkpoints
2 | */.ipynb_checkpoints/*
3 | */*/.ipynb_checkpoints/*.ipynb
4 |
5 |
--------------------------------------------------------------------------------
/01-behavioral_data_analysis/00-log_processing.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# **Working memory training**: processing behavioral logs\n",
8 | "**Last edited:** 12-20-2019"
9 | ]
10 | },
11 | {
12 | "cell_type": "code",
13 | "execution_count": 1,
14 | "metadata": {},
15 | "outputs": [],
16 | "source": [
17 | "import matplotlib.pyplot as plt\n",
18 | "import pandas as pd\n",
19 | "import numpy as np\n",
20 | "import json\n",
21 | "import os\n",
22 | "from scipy.stats import norm"
23 | ]
24 | },
25 | {
26 | "cell_type": "code",
27 | "execution_count": 2,
28 | "metadata": {},
29 | "outputs": [],
30 | "source": [
31 | "def convert_logfile(fname: str, task_meta: dict) -> pd.DataFrame:\n",
32 | " '''Converts logfile into concise and easy to work DataFrame\n",
33 | " \n",
34 | " Args:\n",
35 | " fname: path to log file\n",
36 | " task_meta: task metadata\n",
37 | " \n",
38 | " Returns:\n",
39 | " Table containing information about each trial. Each row contain block\n",
40 | " number, task condition, correct and actual response for both visual and\n",
41 | " auditory stimuli. \n",
42 | " '''\n",
43 | " # Setup local variables\n",
44 | " n_stims = task_meta['n_stims']\n",
45 | " n_blocks = task_meta['n_blocks']\n",
46 | " n_conditions = task_meta['n_conditions']\n",
47 | " n_trials = n_stims * n_blocks * n_conditions\n",
48 | " ttr = task_meta['ttr']\n",
49 | " \n",
50 | " # Create block and condition indices\n",
51 | " ind_block = np.repeat(np.arange(n_blocks), n_stims * n_conditions)[:, np.newaxis]\n",
52 | " ind_cond = np.tile(\n",
53 | " np.concatenate((np.ones(n_stims), 2*np.ones(n_stims))), n_blocks\n",
54 | " )[:, np.newaxis]\n",
55 | "\n",
56 | " df_ind = pd.DataFrame(\n",
57 | " np.hstack((ind_block, ind_cond)), \n",
58 | " columns=['block', 'condition']).astype('int')\n",
59 | "\n",
60 | " # Load stimulus data\n",
61 | " df = pd.read_csv(fname, delimiter='\\t', skiprows=3)\n",
62 | "\n",
63 | " stim_filter = df['Code'].str.contains('yes') | df['Code'].str.contains('no')\n",
64 | " df_stim = df.loc[stim_filter, :]\n",
65 | "\n",
66 | " # Split visual and audio stimuli\n",
67 | " df_stim_vis = df_stim.loc[df_stim['Event Type'] == 'Picture', \n",
68 | " ['xs(str)', 'Time']].reset_index(drop=True)\n",
69 | " df_stim_aud = df_stim.loc[df_stim['Event Type'] == 'Sound', \n",
70 | " 'xs(str)'].reset_index(drop=True)\n",
71 | " df_stim_vis.columns = ['ans_vis', 'stim_onset']\n",
72 | " df_stim_aud.name = 'ans_aud'\n",
73 | "\n",
74 | " # Merge visual and audio stimuli again & add response columns\n",
75 | " df_stim = pd.concat([df_ind, df_stim_vis, df_stim_aud], axis=1, sort=False)\n",
76 | " df_stim['resp_aud'], df_stim['resp_aud_time'], \\\n",
77 | " df_stim['resp_vis'], df_stim['resp_vis_time'] = np.zeros((4, n_trials), dtype='int')\n",
78 | " \n",
79 | " # Load response data\n",
80 | " resp_filer = df['Code'].isin(['1', '2'])\n",
81 | " df_resp = df.loc[resp_filer, :]\n",
82 | "\n",
83 | " # Analyze trialwise responses\n",
84 | " for i, row in df_stim.iterrows():\n",
85 | "\n",
86 | " r = df_resp.loc[(df_resp['Time'] > row['stim_onset']) & \\\n",
87 | " (df_resp['Time'] < row['stim_onset'] + ttr), \n",
88 | " ['Code', 'Time']]\n",
89 | "\n",
90 | " if '2' in r['Code'].unique():\n",
91 | " df_stim.loc[i, 'resp_aud'] = 1\n",
92 | " df_stim.loc[i, 'resp_aud_time'] = r.loc[r['Code']=='2', 'Time'].values[0] \n",
93 | " if '1' in r['Code'].unique():\n",
94 | " df_stim.loc[i, 'resp_vis'] = 1\n",
95 | " df_stim.loc[i, 'resp_vis_time'] = r.loc[r['Code']=='1', 'Time'].values[0] \n",
96 | "\n",
97 | " for modality in ['vis', 'aud']:\n",
98 | " df_stim[f'resp_{modality}_time'] -= df_stim['stim_onset'] \n",
99 | " df_stim.loc[df_stim[f'resp_{modality}_time'] < 0, \n",
100 | " f'resp_{modality}_time'] = np.nan\n",
101 | " df_stim[f'resp_{modality}_time'] /= 10\n",
102 | " df_stim[f'ans_{modality}'] = df_stim[f'ans_{modality}'].map({' yes': 1, ' no': 0})\n",
103 | "\n",
104 | " # Drop and reorder columns\n",
105 | " df_stim = df_stim[['block', 'condition', \n",
106 | " 'ans_vis', 'resp_vis', 'resp_vis_time',\n",
107 | " 'ans_aud', 'resp_aud', 'resp_aud_time']]\n",
108 | " \n",
109 | " return df_stim"
110 | ]
111 | },
112 | {
113 | "cell_type": "markdown",
114 | "metadata": {},
115 | "source": [
116 | "# Behavioral measures\n",
117 | "\n",
118 | "## Introduction\n",
119 | "\n",
120 | "We assume that each measure is calculated separately for single subject, session, task condition (1-back or 2-back) and stimuli modality (visual or auditory). Each behavioral response can be divided into one of four categories: *hit*, *miss*, *correct rejection* or *false alarm*:\n",
121 | "\n",
122 | "| Stimuli\\Response \t| Congruent \t| Incongruent \t|\n",
123 | "|------------------\t|-------------\t|-------------------\t|\n",
124 | "| Congruent \t| hit \t| miss \t|\n",
125 | "| Incongruent \t| false alarm \t| correct rejection \t|\n",
126 | "\n",
127 | "Subjects were instructed to respond with their thumb to congruent stimuli and omit response to incongruent stimuli. Note that in this task setting \"real misses\", i.e. when subject failed to respond within required time window cannot be distinguished from correct rejections and misses. Number of responses of each type was calculated on the level of entire run and for individual task blocks. Reaction time (RT) was calculated for hits and false alarms.\n",
128 | "\n",
129 | "## Measures\n",
130 | "\n",
131 | "### Accuracy\n",
132 | "\n",
133 | "Accuracy was calculated as the actual number of hits divided by the maximum number of hits.\n",
134 | "$$accuracy = \\frac{\\#hits}{N_{congruent}}$$\n",
135 | "\n",
136 | "This imperfect definition is prone to *respond to all stimuli* behavior. In this case accuracy will be one.\n",
137 | "\n",
138 | "### Penalized reaction time\n",
139 | "\n",
140 | "Penalized reaction time (PRT) tries to combine accuracy with the reaction time. Calculating PRT consists of three steps. First, all labeled reaction times are selected. Second, all reaction times for false alarms are set to 2000ms (maximal possible RT). Third, fake reaction times for misses are added to penalize for not responding. Then mean is calculated for task runs and individual blocks. Note that mean PRT over blocks is usually different than the one calculated for the enire task mean (some blocks consist of more responses than others). Formally, PRT is defined as\n",
141 | "$$prt = \\frac{1}{\\#false\\ alarms + \\#hits + \\#misses}(\\sum_{r=1}^{N_{responses}} prt_{r} + \\#misses \\times 2000\\text{ms})$$\n",
142 | "where $prt_{r}$ is 2000ms for false alarms and RT for hits.\n",
143 | "\n",
144 | "### D-prime\n",
145 | "\n",
146 | "D-prime based on signal detection theory takes into account both response sensitivity and specificity. First, *hit rate* $hr$ and *false alarm rate* $fr$ is calculated as:\n",
147 | "$$hr = \\frac{\\#hits}{\\#hits + \\#misses}$$\n",
148 | "$$fr = \\frac{\\#false\\ alarms}{\\#false\\ alarms + \\#correct\\ rejections}$$\n",
149 | "Second, to avoid problems with infinite values, all $hr$ or $fr$ values equal to 1 are set to 0.99 and all $hr$ or $fr$ values equal to 0 are set to 0.01. Finally, d-prime is calculated as difference between pdf transormed values of $hr$ and $fr$:\n",
150 | "$$d'=f(hr)-f(fr)$$\n",
151 | "where $f(x)$ is the inverse of the cumulative distribution function for Gaussian distribution.\n",
152 | "Note that mean d-prime over task blocks is not equal to mean calculated for the entire task."
153 | ]
154 | },
155 | {
156 | "cell_type": "code",
157 | "execution_count": 3,
158 | "metadata": {},
159 | "outputs": [],
160 | "source": [
161 | "def calculate_behavioral_measures(df_stim: pd.DataFrame, task_meta: dict) -> tuple:\n",
162 | " '''Calculates main three behavioral measures: accuracy, pRT and D-prime.\n",
163 | " \n",
164 | " Args: \n",
165 | " df_stim: trialwise task information\n",
166 | " task_meta: task_meta\n",
167 | " \n",
168 | " Returns:\n",
169 | " Aggregated behavioral measures for entire task. \n",
170 | " (n_measures x n_conditions x n_modalities) \n",
171 | " Aggregated behavioral measures for specific blocks.\n",
172 | " (n_measures x n_conditions x n_modalities x n_blocks)\n",
173 | " '''\n",
174 | "\n",
175 | " def _get_resp_patterns(df_signal, filt_rows, modality):\n",
176 | " '''Calculates number of hits, correct rejections, misses and false alarms.\n",
177 | "\n",
178 | " Args: \n",
179 | " modality (str): either 'vis' or 'aud'\n",
180 | "\n",
181 | " Returns:\n",
182 | " Number of hits, correct rejections, misses and false alarms.\n",
183 | "\n",
184 | " '''\n",
185 | " no_hit = df_signal.loc[filt_rows, f'hit_{modality}'].sum()\n",
186 | " no_crr = df_signal.loc[filt_rows, f'crr_{modality}'].sum()\n",
187 | " no_mis = df_signal.loc[filt_rows, f'mis_{modality}'].sum()\n",
188 | " no_fal = df_signal.loc[filt_rows, f'fal_{modality}'].sum()\n",
189 | "\n",
190 | " return (no_hit, no_crr, no_mis, no_fal)\n",
191 | "\n",
192 | " def _calculate_dprime(no_hit, no_crr, no_mis, no_fal):\n",
193 | " '''Calculates d-prime signal detection index\n",
194 | "\n",
195 | " Args: \n",
196 | " no_hit (int): number of hits\n",
197 | " no_crr (int): number of correct rejections\n",
198 | " no_mis (int): number of misses\n",
199 | " no_fal (int): number of false alarms\n",
200 | "\n",
201 | " Returns:\n",
202 | " (float) D-prime index. \n",
203 | " '''\n",
204 | "\n",
205 | " hit_rate = no_hit / (no_hit + no_mis)\n",
206 | " fal_rate = no_fal / (no_fal + no_crr)\n",
207 | "\n",
208 | " # Corner cases (infinity problem)\n",
209 | " if fal_rate == 0: fal_rate = 0.01\n",
210 | " if fal_rate == 1: fal_rate = 0.99\n",
211 | "\n",
212 | " if hit_rate == 0: hit_rate = 0.01\n",
213 | " if hit_rate == 1: hit_rate = 0.99\n",
214 | "\n",
215 | " return norm.ppf(hit_rate) - norm.ppf(fal_rate)\n",
216 | "\n",
217 | " df_signal = df_stim[['block', 'condition']].copy()\n",
218 | " n_modalities = task_meta['n_modalities']\n",
219 | " n_conditions = task_meta['n_conditions']\n",
220 | " n_blocks = task_meta['n_blocks']\n",
221 | " ttr = task_meta['ttr'] / 10\n",
222 | "\n",
223 | " # Signal theory measures\n",
224 | " for s in ['vis', 'aud']:\n",
225 | " df_signal[f'hit_{s}'] = (df_stim[f'ans_{s}'] == 1) & (df_stim[f'resp_{s}'] == 1)\n",
226 | " df_signal[f'crr_{s}'] = (df_stim[f'ans_{s}'] == 0) & (df_stim[f'resp_{s}'] == 0)\n",
227 | " df_signal[f'mis_{s}'] = (df_stim[f'ans_{s}'] == 1) & (df_stim[f'resp_{s}'] == 0)\n",
228 | " df_signal[f'fal_{s}'] = (df_stim[f'ans_{s}'] == 0) & (df_stim[f'resp_{s}'] == 1)\n",
229 | " df_signal[f'hit_time_{s}'] = df_signal[f'hit_{s}'].replace(False, np.nan) \\\n",
230 | " * df_stim[f'resp_{s}_time']\n",
231 | " df_signal[f'fal_time_{s}'] = df_signal[f'fal_{s}'].replace(False, np.nan) \\\n",
232 | " * df_stim[f'resp_{s}_time']\n",
233 | "\n",
234 | " acc_block, prt_block, dpr_block = np.zeros((3, n_conditions, n_modalities, n_blocks))\n",
235 | " acc, prt, dpr = np.zeros((3, n_conditions, n_modalities))\n",
236 | " hit_rate, fal_rate = np.zeros((2, n_conditions, n_modalities))\n",
237 | "\n",
238 | " for idx_c, condition in enumerate([1, 2]):\n",
239 | " for idx_m, modality in enumerate(['vis', 'aud']):\n",
240 | "\n",
241 | " filt_rows = (df_signal['condition'] == condition)\n",
242 | "\n",
243 | " # Count hits, correct rejections, misses and false alarms\n",
244 | " no_hit, no_crr, no_mis, no_fal = _get_resp_patterns(df_signal, filt_rows, modality)\n",
245 | "\n",
246 | " # Calculate behavioral measures (whole task)\n",
247 | " prt[idx_c, idx_m] = \\\n",
248 | " (df_signal.loc[filt_rows, f'hit_time_{modality}'].sum() + ttr * (no_fal + no_mis)) \\\n",
249 | " / (no_hit + no_fal + no_mis)\n",
250 | " dpr[idx_c, idx_m] = _calculate_dprime(no_hit, no_crr, no_mis, no_fal)\n",
251 | " \n",
252 | " # Grab also simpler measures for exclusion criteria\n",
253 | " hit_rate[idx_c, idx_m] = no_hit / (no_hit + no_mis)\n",
254 | " fal_rate[idx_c, idx_m] = no_fal / (no_fal + no_crr)\n",
255 | "\n",
256 | " for idx_b in range(n_blocks):\n",
257 | "\n",
258 | " filt_rows = (df_signal['condition'] == condition) \\\n",
259 | " & (df_signal['block'] == idx_b)\n",
260 | "\n",
261 | " # Count hits, correct rejections, misses and false alarms\n",
262 | " no_hit, no_crr, no_mis, no_fal = _get_resp_patterns(\n",
263 | " df_signal, filt_rows, modality\n",
264 | " )\n",
265 | "\n",
266 | " # Calculate behavioral measures (block level)\n",
267 | " acc_block[idx_c, idx_m, idx_b] = no_hit / (no_hit + no_mis)\n",
268 | " prt_block[idx_c, idx_m, idx_b] = \\\n",
269 | " (df_signal.loc[filt_rows, f'hit_time_{modality}'].sum() + ttr * (no_fal + no_mis)) \\\n",
270 | " / (no_hit + no_fal + no_mis)\n",
271 | " dpr_block[idx_c, idx_m, idx_b] = _calculate_dprime(no_hit, no_crr, no_mis, no_fal)\n",
272 | "\n",
273 | " acc = np.nanmean(acc_block, axis=2)\n",
274 | " \n",
275 | " return (np.stack((acc, prt, dpr, hit_rate, fal_rate)), np.stack((acc_block, prt_block, dpr_block)))"
276 | ]
277 | },
278 | {
279 | "cell_type": "markdown",
280 | "metadata": {},
281 | "source": [
282 | "Load group assignment table and exclude subjects with incomplete data."
283 | ]
284 | },
285 | {
286 | "cell_type": "code",
287 | "execution_count": 4,
288 | "metadata": {},
289 | "outputs": [
290 | {
291 | "data": {
292 | "text/html": [
293 | "\n",
294 | "\n",
307 | "
\n",
308 | " \n",
309 | " \n",
310 | " | \n",
311 | " sub | \n",
312 | " group | \n",
313 | "
\n",
314 | " \n",
315 | " \n",
316 | " \n",
317 | " | 0 | \n",
318 | " sub-01 | \n",
319 | " Control | \n",
320 | "
\n",
321 | " \n",
322 | " | 1 | \n",
323 | " sub-02 | \n",
324 | " Control | \n",
325 | "
\n",
326 | " \n",
327 | " | 3 | \n",
328 | " sub-04 | \n",
329 | " Control | \n",
330 | "
\n",
331 | " \n",
332 | " | 4 | \n",
333 | " sub-05 | \n",
334 | " Experimental | \n",
335 | "
\n",
336 | " \n",
337 | " | 5 | \n",
338 | " sub-06 | \n",
339 | " Experimental | \n",
340 | "
\n",
341 | " \n",
342 | "
\n",
343 | "