def _convert_to_epochs(raw_data): """Converts the raw object to an Epochs Input: - raw_data: instance of mne.RawArray, that has been previously cropped to tmin=in_bed_time returns: mne.Epochs """ return mne.make_fixed_length_epochs( raw=raw_data, duration=EPOCH_DURATION, preload=True, verbose=False, )
def plot_topo_hack(normalized_topo): ref_sens = mne.io.read_raw_fif('/fast/ICA/CAMCAN/sub-CC621184_ses-rest_task-rest_proc-sss_300srate.fif') ref_sens.crop(0, 2) ref_sens.pick_types(meg='mag') ref_sens.load_data() epochs = mne.make_fixed_length_epochs(ref_sens) evoked = epochs.average() if normalized_topo.shape.__len__() == 1: evoked._data[:,0]=normalized_topo evoked.plot_topomap(times=evoked.times[0], colorbar=False) else: evoked._data[:,:25]=normalized_topo evoked.plot_topomap(times=evoked.times[0:25], ncols=5, nrows=5, colorbar=False)
def creating_epochs(raw, tmin=0, tmax=60, verbose=True, duration=0.5): '''Function to transform dataset into epochs Parameters ---------- raw : raw file to transform tmin : minimum time to take into account (default = 0) tmax: maximum time to take into account (default = 60) duration : duration of each epoch (default = 0.5) Return ------ Epoch object (mne) ''' epochs = make_fixed_length_epochs(raw.crop(tmin=tmin, tmax=tmax), duration=duration, verbose=verbose) return epochs
def creating_epochs(raw, tmin=0, verbose=True, duration=0.5): ''' Plot EEG Parameters ---------- raw : Raw file tmin: minimum time to consider duration : length of epochs Return ------ Epochs ''' epochs = make_fixed_length_epochs(raw.crop(tmin=tmin), duration=duration, verbose=verbose) return epochs
raw.crop(tmax=150).resample(100).pick('meg') ecg_proj, _ = compute_proj_ecg(raw, ch_name='MEG 0511') # No ECG chan raw.add_proj(ecg_proj) raw.apply_proj() ############################################################################### # To create fixed length epochs, we simply call the function and provide it # with the appropriate parameters indicating the desired duration of epochs in # seconds, whether or not to preload data, whether or not to reject epochs that # overlap with raw data segments annotated as bad, whether or not to include # projectors, and finally whether or not to be verbose. Here, we choose a long # epoch duration (30 seconds). To conserve memory, we set ``preload`` to # ``False``. epochs = mne.make_fixed_length_epochs(raw, duration=30, preload=False) ############################################################################### # Characteristics of Fixed Length Epochs # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # Fixed length epochs are generally unsuitable for event-related analyses. This # can be seen in an image map of our fixed length # epochs. When the epochs are averaged, as seen at the bottom of the plot, # misalignment between onsets of event-related activity results in noise. event_related_plot = epochs.plot_image(picks=['MEG 1142']) ############################################################################### # For information about creating epochs for event-related analyses, please see # :ref:`tut-epochs-class`. #
# Apply common average reference on EEG channels raw.pick_types(meg=False, eeg=True).apply_proj() # Select two EEG channels for the example, preferably without artifact at the # beginning, to have a reliable calibration ch_names = ['EEG 010', 'EEG 015'] # Apply band-pass filter between 1 and 35 Hz raw.filter(1., 35., method='iir', picks=ch_names) # Epoch time-series with a sliding window duration = 2.5 # duration of epochs interval = 0.2 # interval between successive epochs epochs = make_fixed_length_epochs(raw, duration=duration, overlap=duration - interval, verbose=False) epochs_data = 5e5 * epochs.get_data(picks=ch_names) # Estimate spatial covariance matrices covs = Covariances(estimator='lwf').transform(epochs_data) ############################################################################### # Offline Calibration of Potato # ----------------------------- # # 2D projection of the z-score map of the Riemannian potato, for 2x2 covariance # matrices (in blue if clean, in red if artifacted) and their reference matrix # (in black). The colormap defines the z-score and a chosen isocontour defines # the potato. It reproduces Fig 1 of reference [2]_.
# Riemannian potato # ----------------- # # Riemannian potato (RP) [2]_ selects all channels and filter between 1 and # 35 Hz. # RP definition z_th = 2.0 # z-score threshold low_freq, high_freq = 1., 35. rp = Potato(metric='riemann', threshold=z_th) # EEG processing for RP rp_sig = filter_bandpass(raw, low_freq, high_freq) # band-pass filter rp_epochs = make_fixed_length_epochs( # epoch time-series rp_sig, duration=duration, overlap=duration - interval, verbose=False) rp_covs = Covariances(estimator='scm').transform(rp_epochs.get_data()) # RP training train_covs = 45 # nb of matrices for training train_set = range(train_covs) rp.fit(rp_covs[train_set]) ############################################################################### # Riemannian potato field # ----------------------- # # Riemannian potato field (RPF) [1]_ combines several potatoes of low # dimensionality, each one designed to capture a different kind of artifact
# %% # We will now load in the raw data from the bdf file downloaded from OpenNeuro # and, since this is resting-state data without any events, make regularly # spaced events with which to epoch the raw data. In the averaged plot, # we can see that there may be some eyeblink # artifact contamination but, overall, the data is typical of # resting-state EEG. raw_fname = op.join(target_dir, f'sub-{subject_id}', 'ses-off', 'eeg', 'sub-pd14_ses-off_task-rest_eeg.bdf') raw = mne.io.read_raw_bdf(raw_fname, preload=True) dig_montage = mne.channels.make_standard_montage('biosemi32') raw.drop_channels( [ch for ch in raw.ch_names if ch not in dig_montage.ch_names]) raw.set_montage(dig_montage) # use the standard montage epochs = mne.make_fixed_length_epochs(raw, duration=3, preload=True) # plot the data epochs.average().detrend().plot_joint() # %% # Autoreject without any other preprocessing # ------------------------------------------ # Now, we'll naively apply autoreject as our first preprocessing step. # # As we can see in the plot of the rejected epochs, there are many eyeblinks # that caused the epoch to be dropped. This resulted in a lot of the data # being lost. # # The data looks fairly clean already and we don't want to interpolate # more than a few sensors since we only have 32 to start, so the
def ica_raw(raw, montage): """Automatic artifacts identification - raw data is modified in place Parameters: ----------: raw: mne.io.Raw raw object of EEG data after processing by previous steps (filter and bad channels removal) montage: str montage Returns: ---------- raw: mne.io.Raw instance of raw data after removing artifacts (eog) output_dict_ica: dictionary dictionary with relevant ica information """ # set montage # return if value is invalid try: raw.set_montage(montage) except ValueError: print("Invalid value for the 'montage' parameter. Allowed values are\ 'EGI_256', 'GSN-HydroCel-128', 'GSN-HydroCel-129', 'GSN-HydroCel-256',\ 'GSN-HydroCel-257', 'GSN-HydroCel-32', 'GSN-HydroCel-64_1.0',\ 'GSN-HydroCel-65_1.0', 'biosemi128', 'biosemi16', 'biosemi160',\ 'biosemi256', 'biosemi32', 'biosemi64', 'easycap-M1', 'easycap-M10',\ 'mgh60', 'mgh70', 'standard_1005', 'standard_1020',\ 'standard_alphabetic', 'standard_postfixed', 'standard_prefixed',\ 'standard_primed', 'artinis-octamon', and 'artinis-brite23'.") montage_error = "Invalid value for the 'montage' parameter. Allowed values are 'EGI_256', \ 'GSN-HydroCel-128', 'GSN-HydroCel-129', 'GSN-HydroCel-256',\ 'GSN-HydroCel-257', 'GSN-HydroCel-32', 'GSN-HydroCel-64_1.0',\ 'GSN-HydroCel-65_1.0', 'biosemi128', 'biosemi16', 'biosemi160',\ 'biosemi256', 'biosemi32', 'biosemi64', 'easycap-M1', 'easycap-M10',\ 'mgh60', 'mgh70', 'standard_1005', 'standard_1020',\ 'standard_alphabetic', 'standard_postfixed', 'standard_prefixed',\ 'standard_primed', 'artinis-octamon', and 'artinis-brite23'." ica_details = {"ERROR": montage_error} return raw, {"Ica": ica_details} # prepica - step1 - filter # High-pass with 1. Hz raw_filtered_1 = raw.copy() raw_filtered_1 = raw_filtered_1.load_data().filter(l_freq=1, h_freq=None) # prepica - step2 - segment continuous EEG into arbitrary 1-second epochs epochs_prep = mne.make_fixed_length_epochs(raw_filtered_1, duration=1.0, preload=True, overlap=0.0) # compute the number of original epochs epochs_original = epochs_prep.__len__() # drop epochs that are excessively “noisy” reject_criteria = dict(eeg=1000e-6) # 1000 µV epochs_prep.drop_bad(reject=reject_criteria) # compute the number of epochs after removal epochs_bads_removal = epochs_prep.__len__() epochs_bads = epochs_original - epochs_bads_removal # ica method = 'picard' max_iter = 500 fit_params = dict(fastica_it=5) ica = mne.preprocessing.ICA(n_components=None, method=method, max_iter=max_iter, fit_params=fit_params) ica.fit(epochs_prep) # exclude eog # Note: should be edited later for "ch_name" eog_indices, eog_scores = ica.find_bads_eog(epochs_prep, ch_name='FC1') ica.exclude = eog_indices # reapplying the matrix back to raw data -- modify in place raw_icaed = ica.apply(raw.load_data()) ica_details = {"original epochs": epochs_original, "bad epochs": epochs_bads, "bad epochs rate": epochs_bads / epochs_original, "eog indices": eog_indices, "eog_scores": eog_scores} return raw_icaed, {"Ica": ica_details}
analy_duration = 60 between_duration = 60 filelist = listdir(proc_dir) epolen = 10 min_bad = 25 picks = ["Fz", "AFz", "Fp1", "Fp2", "FC1", "FC2", "Cz"] n_jobs = 8 subjs = ["1001", "1002"] conds = ["Stim"] for subj in subjs: for cond in conds: raw = mne.io.Raw("{}of_EPI_{}_{}-raw.fif".format(proc_dir, subj, cond), preload=True) epo = mne.make_fixed_length_epochs(raw, duration=epolen) power = tfr_morlet(epo, [0.75], n_cycles=3, picks=picks, average=False, return_itc=False, n_jobs=n_jobs) tfr = np.zeros(0) for epo_tfr in power.__iter__(): tfr = np.concatenate((tfr, np.mean(epo_tfr[:, 0, ], axis=0))) tfr_aschan = np.zeros(len(raw)) tfr_aschan[:len(tfr)] = tfr winner_std = np.inf for tfr_upper_thresh in tfr_thresh_range:
def main(filename=None, subjid=None, trans=None, info=None, line_freq=None, emptyroom_filename=None, subjects_dir=None): raw = hcp.read_raw(subjid, 'rest', hcp_path='/data/EnigmaMeg/HCP/HCP_MEG') raw.load_data() eraw = hcp.read_raw(subjid, 'noise_empty_room',hcp_path='/data/EnigmaMeg/HCP/HCP_MEG') eraw.load_data() hcp.preprocessing.apply_ref_correction(raw) hcp.preprocessing.apply_ref_correction(eraw) #Below may be useful for testing ICA components #ica_mat = hcp.read_ica(subjid, 'rest') #annotations_dict=hcp.read_annot(subjid, 'rest') #hcp.preprocessing.apply_ica_hcp(raw, ica_mat, annotations_dict['ica']['ecg_eog_ic']) ## Load and prefilter continuous data #raw=load_data(filename) #eraw=load_data(emptyroom_filename) if type(raw)==mne.io.ctf.ctf.RawCTF: raw.apply_gradient_compensation(3) ## Test SSS bad channel detection for non-Elekta data # !!!!!!!!!!! Currently no finecal or crosstalk used !!!!!!!!!!!!!!! # if filename[-3:]=='fif': # raw_bads_dict = assess_bads(filename) # eraw_bads_dict = assess_bads(emptyroom_filename, is_eroom=True) # raw.info['bads']=raw_bads_dict['noisy'] + raw_bads_dict['flat'] # eraw.info['bads']=eraw_bads_dict['noisy'] + eraw_bads_dict['flat'] resample_freq=300 raw.resample(resample_freq) eraw.resample(resample_freq) raw.filter(0.5, 140) eraw.filter(0.5, 140) if line_freq==None: try: line_freq = raw.info['line_freq'] # this isn't present in all files except: raise(ValueError('Could not determine line_frequency')) notch_freqs = np.arange(line_freq, resample_freq/2, line_freq) raw.notch_filter(notch_freqs) ## Create Epochs and covariance epochs = mne.make_fixed_length_epochs(raw, duration=4.0, preload=True) epochs.apply_baseline(baseline=(0,None)) cov = mne.compute_covariance(epochs) er_epochs=mne.make_fixed_length_epochs(eraw, duration=4.0, preload=True) er_epochs.apply_baseline(baseline=(0,None)) er_cov = mne.compute_covariance(er_epochs) os.environ['SUBJECTS_DIR']=subjects_dir src = mne.read_source_spaces(info.src_filename) bem = mne.read_bem_solution(info.bem_sol_filename) fwd = mne.make_forward_solution(epochs.info, trans, src, bem) data_info = epochs.info from mne.beamformer import make_lcmv, apply_lcmv_epochs filters = make_lcmv(epochs.info, fwd, cov, reg=0.01, noise_cov=er_cov, pick_ori='max-power', weight_norm='unit-noise-gain', rank=None) labels_lh=mne.read_labels_from_annot(subjid, parc='aparc_sub', subjects_dir=subjects_dir, hemi='lh') labels_rh=mne.read_labels_from_annot(subjid, parc='aparc_sub', subjects_dir=subjects_dir, hemi='rh') labels=labels_lh + labels_rh results_stcs = apply_lcmv_epochs(epochs, filters, return_generator=True)#, max_ori_out='max_power') #Monkey patch of mne.source_estimate to perform 15 component SVD label_ts = mod_source_estimate.extract_label_time_course(results_stcs, labels, fwd['src'], mode='pca15_multitaper') #Convert list of numpy arrays to ndarray (Epoch/Label/Sample) label_stack = np.stack(label_ts) #HACK HARDCODED FREQ BINS freq_bins = np.linspace(1,45,177) ######################################3######### FIX #Initialize label_power = np.zeros([len(labels), len(freq_bins)]) alpha_peak = np.zeros(len(labels)) #Create PSD for each label for label_idx in range(len(labels)): print(str(label_idx)) current_psd = label_stack[:,label_idx, :].mean(axis=0) label_power[label_idx,:] = current_psd spectral_image_path = os.path.join(info.outfolder, 'Spectra_'+ labels[label_idx].name + '.png') try: tmp_fmodel = calc_spec_peak(freq_bins, current_psd, out_image_path=spectral_image_path) #FIX FOR MULTIPLE ALPHA PEAKS potential_alpha_idx = np.where((8.0 <= tmp_fmodel.peak_params[:,0] ) & \ (tmp_fmodel.peak_params[:,0] <= 12.0 ) )[0] if len(potential_alpha_idx) != 1: alpha_peak[label_idx] = np.nan #############FIX ###########################3 FIX else: alpha_peak[label_idx] = tmp_fmodel.peak_params[potential_alpha_idx[0]][0] except: alpha_peak[label_idx] = np.nan #Fix <<<<<<<<<<<<<< #Save the label spectrum to assemble the relative power freq_bin_names=[str(binval) for binval in freq_bins] label_spectra_dframe = pd.DataFrame(label_power, columns=[freq_bin_names]) label_spectra_dframe.to_csv( os.path.join(info.outfolder, 'label_spectra.csv') , index=False) # with open(os.path.join(info.outfolder, 'label_spectra.npy'), 'wb') as f: # np.save(f, label_power) relative_power = label_power / label_power.sum(axis=1, keepdims=True) #Define bands bands = [[1,3], [3,6], [8,12], [13,35], [35,55]] band_idxs = get_freq_idx(bands, freq_bins) #initialize output band_means = np.zeros([len(labels), len(bands)]) #Loop over all bands, select the indexes assocaited with the band and average for mean_band, band_idx in enumerate(band_idxs): band_means[:, mean_band] = relative_power[:, band_idx].mean(axis=1) output_filename = os.path.join(info.outfolder, 'Band_rel_power.csv') bands_str = [str(i) for i in bands] label_names = [i.name for i in labels] output_dframe = pd.DataFrame(band_means, columns=bands_str, index=label_names) output_dframe['AlphaPeak'] = alpha_peak output_dframe.to_csv(output_filename, sep='\t')
def test_beamformer(): #Load filenames from test datasets from enigmeg.test_data.get_test_data import datasets test_dat = datasets().ctf meg_filename = test_dat['meg_rest'] subjid = test_dat['subject'] subjects_dir = test_dat['SUBJECTS_DIR'] trans_fname = test_dat['trans'] src_fname = test_dat['src'] bem = test_dat['bem'] outfolder = './tmp' #<<< Change this ############################ raw = mne.io.read_raw_ctf(meg_filename, preload=True) trans = mne.read_trans(trans_fname) # info.subjid, info.subjects_dir = subjid, subjects_dir raw.apply_gradient_compensation(3) raw.resample(300) raw.filter(1.0, None) raw.notch_filter([60,120]) eraw.notch_filter([60,120]) epochs = mne.make_fixed_length_epochs(raw, duration=4.0, preload=True) data_cov = mne.compute_covariance(epochs, method='empirical') eroom_filename = test_dat['meg_eroom'] eroom_raw = mne.io.read_raw_ctf(eroom_filename, preload=True) eroom_raw.resample(300) eroom_raw.notch_filter([60,120]) eroom_raw.filter(1.0, None) eroom_epochs = mne.make_fixed_length_epochs(eroom_raw, duration=4.0) noise_cov = mne.compute_covariance(eroom_epochs) fwd = mne.make_forward_solution(epochs.info, trans, src_fname, bem) from mne.beamformer import make_lcmv, apply_lcmv_epochs filters = make_lcmv(epochs.info, fwd, data_cov, reg=0.01, noise_cov=noise_cov, pick_ori='max-power', weight_norm='unit-noise-gain', rank=None) labels_lh=mne.read_labels_from_annot(subjid, parc='aparc', subjects_dir=subjects_dir, hemi='lh') labels_rh=mne.read_labels_from_annot(subjid, parc='aparc', subjects_dir=subjects_dir, hemi='rh') labels=labels_lh + labels_rh # labels[1].center_of_mass() results_stcs = apply_lcmv_epochs(epochs, filters, return_generator=True)#, max_ori_out='max_power') #Monkey patch of mne.source_estimate to perform 15 component SVD label_ts = mod_source_estimate.extract_label_time_course(results_stcs, labels, fwd['src'], mode='pca15_multitaper') #Convert list of numpy arrays to ndarray (Epoch/Label/Sample) label_stack = np.stack(label_ts) # label_stack = np.mean(label_stack, axis=0) # freq_bins, _ = label_psd(label_stack[:,0, :], raw.info['sfreq']) freq_bins = np.linspace(1,45,177) ######################################3######### FIX #Initialize label_power = np.zeros([len(labels), len(freq_bins)]) alpha_peak = np.zeros(len(labels)) #Create PSD for each label for label_idx in range(len(labels)): print(str(label_idx)) current_psd = label_stack[:,label_idx, :].mean(axis=0) label_power[label_idx,:] = current_psd spectral_image_path = os.path.join(outfolder, 'Spectra_'+ labels[label_idx].name + '.png') try: tmp_fmodel = calc_spec_peak(freq_bins, current_psd, out_image_path=spectral_image_path) #FIX FOR MULTIPLE ALPHA PEAKS potential_alpha_idx = np.where((8.0 <= tmp_fmodel.peak_params[:,0] ) & \ (tmp_fmodel.peak_params[:,0] <= 12.0 ) )[0] if len(potential_alpha_idx) != 1: alpha_peak[label_idx] = np.nan #############FIX ###########################3 FIX else: alpha_peak[label_idx] = tmp_fmodel.peak_params[potential_alpha_idx[0]][0] except: alpha_peak[label_idx] = np.nan #Fix <<<<<<<<<<<<<<