def compare_peak_pw(fm1, fm2, band_def): """Compare the power of detected peaks.""" pw1 = get_band_peak_fm(fm1, band_def)[1] pw2 = get_band_peak_fm(fm2, band_def)[1] return pw1 - pw2
def calc_cf_power_ratio(fm, low_band, high_band): """Calculate band ratio from FOOOF derived peaks. Parameters ---------- fm : fooof object used to find ratio low_band : list of [float, float] Band definition for the lower band. high_band : list of [float, float] Band definition for the upper band. Outputs ------- fooof_ratio : float Oscillation power ratio. """ low_peak = get_band_peak_fm(fm, low_band) high_peak = get_band_peak_fm(fm, high_band) fooof_ratio = low_peak[1] / high_peak[1] return fooof_ratio
# # The :func:`~.get_band_peak_fm` function takes in a # :class:`~.FOOOF` object and extracts peak(s) from a requested frequency range. # # You can optionally specify: # # - whether to return one peak from the specified band, in which case the highest peak is # returned, or whether to return all peaks from within the band # - whether to apply a minimum threshold to extract peaks, for example, to extract # peaks only above some minimum power threshold # ################################################################################################### # Extract any alpha band peaks from the power spectrum model alpha = get_band_peak_fm(fm, bands.alpha) print(alpha) ################################################################################################### # Extracting peaks from FOOOFGroup Objects # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # # Similarly, the :func:`~.get_band_peak_fg` function can be used # to select peaks from specified frequency ranges, from :class:`~fooof.FOOOFGroup` objects. # # Note that you can also apply a threshold to extract group peaks but, as discussed below, # this approach will always only extract at most one peak per individual model fit from # the FOOOFGroup object. # ###################################################################################################
def main(): ################################################# ## SETUP # Initialize subject order run log subj_list = [] ## Get list of subject files subj_files = listdir(DATA_PATH) subj_files = [file for file in subj_files if EXT.lower() in file.lower()] subj_files = sorted(subj_files) ## Set up FOOOF Objects # Initialize FOOOF settings & objects objects fooof_settings = FOOOFSettings(peak_width_limits=PEAK_WIDTH_LIMITS, max_n_peaks=MAX_N_PEAKS, min_peak_height=MIN_PEAK_HEIGHT, peak_threshold=PEAK_THRESHOLD, aperiodic_mode=APERIODIC_MODE) fm = FOOOF(*fooof_settings, verbose=False) fg = FOOOFGroup(*fooof_settings, verbose=False) # Save out a settings file fg.save('0-FOOOF_Settings', pjoin(RESULTS_PATH, 'FOOOF'), save_settings=True) # Set up the dictionary to store all the FOOOF results fg_dict = dict() for load_label in LOAD_LABELS: fg_dict[load_label] = dict() for side_label in SIDE_LABELS: fg_dict[load_label][side_label] = dict() for seg_label in SEG_LABELS: fg_dict[load_label][side_label][seg_label] = [] ## Initialize group level data stores n_subjs, n_conds, n_times = len(subj_files), 3, N_TIMES group_fooof_alpha_freqs = np.zeros(shape=[n_subjs]) group_indi_alpha_freqs = np.zeros(shape=[n_subjs]) dropped_components = np.ones(shape=[n_subjs, 50]) * 999 dropped_trials = np.ones(shape=[n_subjs, 1500]) * 999 canonical_group_avg_data = np.zeros(shape=[n_subjs, n_conds, n_times]) canonical_icf_group_avg_data = np.zeros(shape=[n_subjs, n_conds, n_times]) # Set channel types ch_types = { 'LHor': 'eog', 'RHor': 'eog', 'IVer': 'eog', 'SVer': 'eog', 'LMas': 'misc', 'RMas': 'misc', 'Nose': 'misc', 'EXG8': 'misc' } ################################################# ## RUN ACROSS ALL SUBJECTS # Run analysis across each subject for s_ind, subj_file in enumerate(subj_files): # Get subject label and print status subj_label = subj_file.split('.')[0] subj_list.append(subj_label) print('\nCURRENTLY RUNNING SUBJECT: ', subj_label, '\n') ################################################# ## LOAD / ORGANIZE / SET-UP DATA # Load subject of data, apply apply fixes for channels, etc eeg_data = mne.io.read_raw_bdf(pjoin(DATA_PATH, subj_file), preload=True, verbose=False) # Fix channel name labels eeg_data.info['ch_names'] = [chl[2:] for chl in \ eeg_data.ch_names[:-1]] + [eeg_data.ch_names[-1]] for ind, chi in enumerate(eeg_data.info['chs']): eeg_data.info['chs'][ind]['ch_name'] = eeg_data.info['ch_names'][ ind] # Update channel types eeg_data.set_channel_types(ch_types) # Set reference - average reference eeg_data = eeg_data.set_eeg_reference(ref_channels='average', projection=False, verbose=False) # Set channel montage chs = mne.channels.make_standard_montage('standard_1020') eeg_data.set_montage(chs, verbose=False) # Get event information & check all used event codes evs = mne.find_events(eeg_data, shortest_event=1, verbose=False) # Pull out sampling rate srate = eeg_data.info['sfreq'] ################################################# ## Pre-Processing: ICA # High-pass filter data for running ICA eeg_data.filter(l_freq=1., h_freq=None, fir_design='firwin') if RUN_ICA: print("\nICA: CALCULATING SOLUTION\n") # ICA settings method = 'fastica' n_components = 0.99 random_state = 47 reject = {'eeg': 20e-4} # Initialize ICA object ica = ICA(n_components=n_components, method=method, random_state=random_state) # Fit ICA ica.fit(eeg_data, reject=reject) # Save out ICA solution ica.save(pjoin(RESULTS_PATH, 'ICA', subj_label + '-ica.fif')) # Otherwise: load previously saved ICA to apply else: print("\nICA: USING PRECOMPUTED\n") ica = read_ica(pjoin(RESULTS_PATH, 'ICA', subj_label + '-ica.fif')) # Find components to drop, based on correlation with EOG channels drop_inds = [] for chi in EOG_CHS: inds, _ = ica.find_bads_eog(eeg_data, ch_name=chi, threshold=2.5, l_freq=1, h_freq=10, verbose=False) drop_inds.extend(inds) drop_inds = list(set(drop_inds)) # Set which components to drop, and collect record of this ica.exclude = drop_inds dropped_components[s_ind, 0:len(drop_inds)] = drop_inds # Apply ICA to data eeg_data = ica.apply(eeg_data) ################################################# ## SORT OUT EVENT CODES # Extract a list of all the event labels all_trials = [it for it2 in EV_DICT.values() for it in it2] # Create list of new event codes to be used to label correct trials (300s) all_trials_new = [it + 100 for it in all_trials] # This is an annoying way to collapse across the doubled event markers from above all_trials_new = [it - 1 if not ind % 2 == 0 else it \ for ind, it in enumerate(all_trials_new)] # Get labelled dictionary of new event names ev_dict2 = { ke: va for ke, va in zip(EV_DICT.keys(), set(all_trials_new)) } # Initialize variables to store new event definitions evs2 = np.empty(shape=[0, 3], dtype='int64') lags = np.array([]) # Loop through, creating new events for all correct trials t_min, t_max = -0.4, 3.0 for ref_id, targ_id, new_id in zip(all_trials, CORR_CODES * 6, all_trials_new): t_evs, t_lags = mne.event.define_target_events( evs, ref_id, targ_id, srate, t_min, t_max, new_id) if len(t_evs) > 0: evs2 = np.vstack([evs2, t_evs]) lags = np.concatenate([lags, t_lags]) # Sort event codes evs2 = np.sort(evs2, 0) ################################################# ## FOOOF - resting state data # Calculate PSDs over first 2 minutes of data fmin, fmax = 1, 50 tmin, tmax = 5, 125 psds, freqs = mne.time_frequency.psd_welch(eeg_data, fmin=fmin, fmax=fmax, tmin=tmin, tmax=tmax, n_fft=int(2 * srate), n_overlap=int(srate), n_per_seg=int(2 * srate), verbose=False) # Fit FOOOF across all channels fg.fit(freqs, psds, FREQ_RANGE) # Collect individual alpha peak from fooof ch_ind = eeg_data.ch_names.index(CHL) tfm = fg.get_fooof(ch_ind, False) fooof_freq, _, _ = get_band_peak_fm(tfm, BANDS.alpha) group_fooof_alpha_freqs[s_ind] = fooof_freq # Save out FOOOF results fg.save(subj_label + '_fooof', pjoin(RESULTS_PATH, 'FOOOF'), save_data=True, save_results=True) ################################################# ## ALPHA FILTERING - CANONICAL ALPHA # CANONICAL: Filter data to canonical alpha band: 8-12 Hz alpha_data = eeg_data.copy() alpha_data.filter(8, 12, fir_design='firwin', verbose=False) alpha_data.apply_hilbert(envelope=True, verbose=False) ################################################# ## ALPHA FILTERING - INDIVIDUALIZED PEAK ALPHA # Get individual power spectrum of interest cur_psd = psds[ch_ind, :] # Get the peak within the alpha range al_freqs, al_psd = trim_spectrum(freqs, cur_psd, [7, 14]) icf_ind = np.argmax(al_psd) subj_icf = al_freqs[icf_ind] # Collect individual alpha peak group_indi_alpha_freqs[s_ind] = subj_icf # CANONICAL: Filter data to individualized alpha alpha_icf_data = eeg_data.copy() alpha_icf_data.filter(subj_icf - 2, subj_icf + 2, fir_design='firwin', verbose=False) alpha_icf_data.apply_hilbert(envelope=True, verbose=False) ################################################# ## EPOCH TRIALS # Set epoch timings tmin, tmax = -0.85, 1.1 baseline = (-0.5, -0.35) # Epoch trials - raw data for trial rejection epochs = mne.Epochs(eeg_data, evs2, ev_dict2, tmin=tmin, tmax=tmax, baseline=None, preload=True, verbose=False) # Epoch trials - canonical alpha filtered version epochs_alpha = mne.Epochs(alpha_data, evs2, ev_dict2, tmin=tmin, tmax=tmax, baseline=baseline, preload=True, verbose=False) # Epoch trials - individualized alpha filtered version epochs_alpha_icf = mne.Epochs(alpha_icf_data, evs2, ev_dict2, tmin=tmin, tmax=tmax, baseline=baseline, preload=True, verbose=False) ################################################# ## PRE-PROCESSING: AUTO-REJECT if RUN_AUTOREJECT: print('\nAUTOREJECT: CALCULATING SOLUTION\n') # Initialize and run autoreject across epochs ar = AutoReject(n_jobs=4, verbose=False) ar.fit(epochs) # Save out AR solution ar.save(pjoin(RESULTS_PATH, 'AR', subj_label + '-ar.hdf5'), overwrite=True) # Otherwise: load & apply previously saved AR solution else: print('\nAUTOREJECT: USING PRECOMPUTED\n') ar = read_auto_reject( pjoin(RESULTS_PATH, 'AR', subj_label + '-ar.hdf5')) ar.verbose = 'tqdm' # Apply autoreject to the original epochs object it was learnt on epochs, rej_log = ar.transform(epochs, return_log=True) # Apply autoreject to the copies of the data - apply interpolation, then drop same epochs _apply_interp(rej_log, epochs_alpha, ar.threshes_, ar.picks_, ar.dots, ar.verbose) epochs_alpha.drop(rej_log.bad_epochs) _apply_interp(rej_log, epochs_alpha_icf, ar.threshes_, ar.picks_, ar.dots, ar.verbose) epochs_alpha_icf.drop(rej_log.bad_epochs) # Collect which epochs were dropped dropped_trials[s_ind, 0:sum(rej_log.bad_epochs)] = np.where( rej_log.bad_epochs)[0] ################################################# ## SET UP CHANNEL CLUSTERS # Set channel clusters - take channels contralateral to stimulus presentation # Note: channels will be used to extract data contralateral to stimulus presentation le_chs = ['P3', 'P5', 'P7', 'P9', 'O1', 'PO3', 'PO7'] # Left Side Channels le_inds = [epochs.ch_names.index(chn) for chn in le_chs] ri_chs = ['P4', 'P6', 'P8', 'P10', 'O2', 'PO4', 'PO8'] # Right Side Channels ri_inds = [epochs.ch_names.index(chn) for chn in ri_chs] ################################################# ## TRIAL-RELATED ANALYSIS: CANONICAL ALPHA ## Pull out channels of interest for each load level # Channels extracted are those contralateral to stimulus presentation # Canonical Data lo1_a = np.concatenate([ epochs_alpha['LeLo1']._data[:, ri_inds, :], epochs_alpha['RiLo1']._data[:, le_inds, :] ], 0) lo2_a = np.concatenate([ epochs_alpha['LeLo2']._data[:, ri_inds, :], epochs_alpha['RiLo2']._data[:, le_inds, :] ], 0) lo3_a = np.concatenate([ epochs_alpha['LeLo3']._data[:, ri_inds, :], epochs_alpha['RiLo3']._data[:, le_inds, :] ], 0) ## Calculate average across trials and channels - add to group data collection # Canonical data canonical_group_avg_data[s_ind, 0, :] = np.mean(lo1_a, 1).mean(0) canonical_group_avg_data[s_ind, 1, :] = np.mean(lo2_a, 1).mean(0) canonical_group_avg_data[s_ind, 2, :] = np.mean(lo3_a, 1).mean(0) ################################################# ## TRIAL-RELATED ANALYSIS: INDIVIDUALIZED ALPHA # Individualized Alpha Data lo1_a_icf = np.concatenate([ epochs_alpha_icf['LeLo1']._data[:, ri_inds, :], epochs_alpha_icf['RiLo1']._data[:, le_inds, :] ], 0) lo2_a_icf = np.concatenate([ epochs_alpha_icf['LeLo2']._data[:, ri_inds, :], epochs_alpha_icf['RiLo2']._data[:, le_inds, :] ], 0) lo3_a_icf = np.concatenate([ epochs_alpha_icf['LeLo3']._data[:, ri_inds, :], epochs_alpha_icf['RiLo3']._data[:, le_inds, :] ], 0) ## Calculate average across trials and channels - add to group data collection # Canonical data canonical_icf_group_avg_data[s_ind, 0, :] = np.mean(lo1_a_icf, 1).mean(0) canonical_icf_group_avg_data[s_ind, 1, :] = np.mean(lo2_a_icf, 1).mean(0) canonical_icf_group_avg_data[s_ind, 2, :] = np.mean(lo3_a_icf, 1).mean(0) ################################################# ## FOOOFING TRIAL AVERAGED DATA # Loop loop loads & trials segments for seg_label, seg_time in zip(SEG_LABELS, SEG_TIMES): tmin, tmax = seg_time[0], seg_time[1] # Calculate PSDs across trials, fit FOOOF models to averages for le_label, ri_label, load_label in zip( ['LeLo1', 'LeLo2', 'LeLo3'], ['RiLo1', 'RiLo2', 'RiLo3'], LOAD_LABELS): ## Calculate trial wise PSDs for left & right side trials trial_freqs, le_trial_psds = periodogram( epochs[le_label]. _data[:, :, _time_mask(epochs.times, tmin, tmax, srate)], srate, window='hann', nfft=4 * srate) trial_freqs, ri_trial_psds = periodogram( epochs[ri_label]. _data[:, :, _time_mask(epochs.times, tmin, tmax, srate)], srate, window='hann', nfft=4 * srate) ## FIT ALL CHANNELS VERSION if FIT_ALL_CHANNELS: ## Average spectra across trials within a given load & side le_avg_psd_contra = AVG_FUNC(le_trial_psds[:, ri_inds, :], 0) le_avg_psd_ipsi = AVG_FUNC(le_trial_psds[:, le_inds, :], 0) ri_avg_psd_contra = AVG_FUNC(ri_trial_psds[:, le_inds, :], 0) ri_avg_psd_ipsi = AVG_FUNC(ri_trial_psds[:, ri_inds, :], 0) ## Combine spectra across left & right trials for given load ch_psd_contra = np.vstack( [le_avg_psd_contra, ri_avg_psd_contra]) ch_psd_ipsi = np.vstack([le_avg_psd_ipsi, ri_avg_psd_ipsi]) ## Fit FOOOFGroup to all channels, average & and collect results fg.fit(trial_freqs, ch_psd_contra, FREQ_RANGE) afm = average_fg(fg, BANDS) fg_dict[load_label]['Contra'][seg_label].append(afm.copy()) fg.fit(trial_freqs, ch_psd_ipsi, FREQ_RANGE) afm = average_fg(fg, BANDS) fg_dict[load_label]['Ipsi'][seg_label].append(afm.copy()) ## COLLAPSE ACROSS CHANNELS VERSION else: ## Average spectra across trials and channels within a given load & side le_avg_psd_contra = AVG_FUNC( AVG_FUNC(le_trial_psds[:, ri_inds, :], 0), 0) le_avg_psd_ipsi = AVG_FUNC( AVG_FUNC(le_trial_psds[:, le_inds, :], 0), 0) ri_avg_psd_contra = AVG_FUNC( AVG_FUNC(ri_trial_psds[:, le_inds, :], 0), 0) ri_avg_psd_ipsi = AVG_FUNC( AVG_FUNC(ri_trial_psds[:, ri_inds, :], 0), 0) ## Collapse spectra across left & right trials for given load avg_psd_contra = AVG_FUNC( np.vstack([le_avg_psd_contra, ri_avg_psd_contra]), 0) avg_psd_ipsi = AVG_FUNC( np.vstack([le_avg_psd_ipsi, ri_avg_psd_ipsi]), 0) ## Fit FOOOF, and collect results fm.fit(trial_freqs, avg_psd_contra, FREQ_RANGE) fg_dict[load_label]['Contra'][seg_label].append(fm.copy()) fm.fit(trial_freqs, avg_psd_ipsi, FREQ_RANGE) fg_dict[load_label]['Ipsi'][seg_label].append(fm.copy()) ################################################# ## SAVE OUT RESULTS # Save out subject run log with open(pjoin(RESULTS_PATH, 'Group', 'subj_run_list.txt'), 'w') as f_obj: for item in subj_list: f_obj.write('{} \n'.format(item)) # Save out group data np.save(pjoin(RESULTS_PATH, 'Group', 'canonical_group'), canonical_group_avg_data) np.save(pjoin(RESULTS_PATH, 'Group', 'canonical_icf_group'), canonical_icf_group_avg_data) np.save(pjoin(RESULTS_PATH, 'Group', 'dropped_trials'), dropped_trials) np.save(pjoin(RESULTS_PATH, 'Group', 'dropped_components'), dropped_components) np.save(pjoin(RESULTS_PATH, 'Group', 'indi_alpha_peaks'), group_indi_alpha_freqs) np.save(pjoin(RESULTS_PATH, 'Group', 'fooof_alpha_peaks'), group_fooof_alpha_freqs) # Save out second round of FOOOFing for load_label in LOAD_LABELS: for side_label in SIDE_LABELS: for seg_label in SEG_LABELS: fg = combine_fooofs(fg_dict[load_label][side_label][seg_label]) fg.save('Group_' + load_label + '_' + side_label + '_' + seg_label, pjoin(RESULTS_PATH, 'FOOOF'), save_results=True)
def get_all_data(df, chs, block=0, state='ec', verbose=False): """This function will return a DataFrame populated with all subjects, channels, spectral parameters, band ratios, and age - all from the ChildMind dataset. Parameters ---------- df : Dataframe Container holding subjects' psds. chs : list of int Channels corresponding to each psd. block : int Which block to populate data for. state : {'ec', 'eo'} Whether to run for eyes closed or eyes open data. verbose : bool Whether to print out updates. Outputs ------- DataFrame """ res = pd.DataFrame() for filename in df.ID.values: try: # Load current subjects data curr_data = np.load( dp.make_file_path(dp.eeg_psds, filename + '_' + state + '_psds', 'npz')) freqs = curr_data['arr_0'] for ch in chs: # Initialize collection of subject info curr_row = dict() curr_row["Subj_ID"] = filename curr_row["Chan_ID"] = ch ps = curr_data['arr_1'][block][ch] # Initialize and fit FOOOF model fm = FOOOF(*FOOOF_SETTINGS, verbose=False) fm.fit(freqs, ps) # Extract and add periodic and aperiodic metrics from FOOOF theta_params = get_band_peak_fm(fm, BANDS['theta']) beta_params = get_band_peak_fm(fm, BANDS['beta']) alpha_params = get_band_peak_fm(fm, BANDS['alpha']) ap = fm.aperiodic_params_ curr_row = _add_params(curr_row, theta_params, beta_params, alpha_params, ap) # Extract and add FOOOF model fit metrics curr_row["fit_error"] = fm.error_ curr_row["fit_r2"] = fm.r_squared_ curr_row["fit_n_peaks"] = fm.peak_params_.shape[0] # Calculate and add band ratio measures tbr = calc_band_ratio(freqs, ps, BANDS['theta'], BANDS['beta']) tar = calc_band_ratio(freqs, ps, BANDS['theta'], BANDS['alpha']) abr = calc_band_ratio(freqs, ps, BANDS['alpha'], BANDS['beta']) curr_row["TBR"] = tbr curr_row["TAR"] = tar curr_row["ABR"] = abr # Extract and add age of the subject ages = df[df['ID'] == filename].Age.values[0] curr_row["Age"] = ages # Collect subject data into group dataframe curr_row = pd.Series(curr_row) res = res.append(curr_row, ignore_index=True) except FileNotFoundError: if verbose: print("FileNotFound: ", filename) return res