def ca_tfr_baseline(data, list_pick, size): freqs = np.arange(1, 40, 1) n_cycles = freqs / 2 first = tfr_multitaper(data[0], freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, average=True, picks=list_pick) power_baseline = np.empty( [len(data), len(list_pick), len(freqs), first._data.shape[2]]) for i in range(len(data)): power_baseline[i] = tfr_multitaper(data[i], freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, average=True, picks=list_pick)._data baseline_pool = pool_into_one2(power_baseline) baseline_pool = bootstrapping2(baseline_pool, size) return baseline_pool
def plot_erds(data, freqs, n_cycles, baseline, times=(None, None)): tfr = tfr_multitaper(data, freqs, n_cycles, average=False, return_itc=False) tfr.apply_baseline(baseline, mode="percent") tfr.crop(*times) figs = [] n_rows, n_cols = _get_rows_cols(data.info["nchan"]) widths = n_cols * [10] + [1] # each map has width 10, each colorbar width 1 for event in data.event_id: # separate figures for each event ID fig, axes = plt.subplots(n_rows, n_cols + 1, gridspec_kw={"width_ratios": widths}) tfr_avg = tfr[event].average() vmin, vmax = -1, 2 # default for ERDS maps cmap = center_cmap(plt.cm.RdBu, vmin, vmax) for ch, ax in enumerate(axes[..., :-1].flat): # skip last column tfr_avg.plot([ch], vmin=vmin, vmax=vmax, cmap=(cmap, False), axes=ax, colorbar=False, show=False) ax.set_title(data.ch_names[ch], fontsize=10) ax.axvline(0, linewidth=1, color="black", linestyle=":") ax.set(xlabel="t (s)", ylabel="f (Hz)") ax.label_outer() for ax in axes[..., -1].flat: # colorbars in last column fig.colorbar(axes.flat[0].images[-1], cax=ax) fig.suptitle(f"ERDS ({event})") figs.append(fig) return figs
def spectrogram_multitaper(dat, fs): dat = dat.reshape([1, 1, 2500]) # Canal, segmento, muestras n_epochs = len(dat) montage = mne.channels.read_montage('standard_1020', ch_names=['Fp1']) info = mne.create_info(['Fp1'], fs, montage=montage, ch_types='eeg') #raw=mne.io.RawArray(eegdata,info) events = np.array( [np.arange(n_epochs), np.ones(n_epochs), np.ones(n_epochs)]).T.astype(int) # Construct Epochs. # eegdata: epochs, channels, samples event_id, tmin, tmax = 1, 0, 5 #eegdata=eegdata[np.newaxis,:,:] epochs = mne.EpochsArray(dat, info, None, 0.0, event_id) freqs = np.logspace(*np.log10([0.5, 50]), num=100) n_cycles = freqs / 1. # different number of cycle per frequency time_bandwidth = 4.0 #power, itc = tfr_morlet(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=True,return_itc=True, n_jobs=1) #power.plot([0], baseline=(-0.5, 0), mode='mean', title=power.ch_names[0],colorbar=True) power, itc = tfr_multitaper(epochs, freqs=freqs, n_cycles=n_cycles, time_bandwidth=time_bandwidth, return_itc=True, n_jobs=1) #power.plot([0], baseline=(-0.5, 0), mode='mean', title=power.ch_names[0],colorbar=True) return power
def itc(t, epochs, cond, channels): # channels in the format of [4, 26, 25, 30, 31], auditory channels # itc_data_mean_all = itc_data.mean(axis = 0) # CHANGE AS NEEDED: average across all channels # computation of inter-trial-coherence (itc) freqs = np.arange(1., 50., 1.) # CHANGE AS NEEDED n_cycles = freqs/4. # time resolution is 0.25 s (1 s has "freq" number of cycles) time_bandwidth = 2.0 # number of taper = time_bandwidth product - 1 # usually n_cycles and time_bandwidth are fixed, which determines the frequency resolution power, itc = tfr_multitaper(epochs, freqs = freqs, n_cycles = n_cycles, time_bandwidth = time_bandwidth, return_itc = True, n_jobs = 4) # itc.plot([channel number], mode = 'mean') # itc.plot_topo(baseline = (-0.5, 0), mode = 'zscore') itc_copy = itc.copy() itc_data = itc_copy.data # averaging across channels itc_data_mean = itc_data[channels, :, :].mean(axis = 0) np.savez(froot+'/'+'itcCz' + '/'+subj+'_'+'itc'+str(cond), itc = itc_data, t = t, freqs = freqs, itc_avg = itc_data_mean); # npzFile = np.load(fpath+'/'+'itc_power.npz'), npzFiles.files, npzFile['itc'] # if bad channels were added manually, select good channels power_copy = power.copy() power_data = power_copy.data np.savez(froot+'/'+'powerCz' + '/'+subj+'_'+'power'+str(cond), power = power_data, t = t, freqs = freqs); plot_spectrogram(itc_data_mean, t, freqs, cond) pl.savefig(froot + '/ITCfigures/' + subj + '/' + subj + '_spectrogram_' + cond + '.png') return itc_data_mean
def mt_hga_julien(epoch, f=100., n_cycles=12, time_bandwidth=4., **kw): """Extract high-gamma activity (HGA) around a central frequency. The HGA is extracted using the `mne.time_frequency.tfr_multitaper` function but the parameters provided by Julien Bastin. Parameters ---------- epoch : mne.Epochs Instance of mne.Epochs f : float | 100. The central high-gamma frequency n_cycles : int | 12 The number of cycles to use for the frequency resolution. time_bandwidth : float | 20. Time x (Full) Bandwidth product. karg : dict | {} Additional arguments are passed to the `tfr_multitaper` function. Returns ------- tf : AverageTFR | EpochsTFR The averaged or single-trial HGA. """ assert isinstance(f, (int, float)) freq = np.array([f]) tf = tfr_multitaper(epoch, freq, .2 * freq, return_itc=False, time_bandwidth=time_bandwidth, **kw) return tf
def cal_tfr2(data, index, mean, std, list_pick): freqs = np.arange(1, 40, 1) n_cycles = freqs / 2 # power_pfcs_pretrials_intact = tfr_multitaper(ctrl_encmain_le[0], freqs=freqs, n_cycles=n_cycles, use_fft=True,return_itc=False, average=True,picks=["P1","P3","P5","P7","P9","PO3","PO7","O"]) data[index] = data[index].resample(sfreq=256, npad=1715, pad='constant', window='hann') power_data = tfr_multitaper(data[index], freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, average=True, picks=list_pick) power_mean = np.empty([8, 2]) for ch in range(power_data.data.shape[0]): for fr in range(power_data.data.shape[1]): power_data.data[ch, fr] = np.divide( np.subtract(power_data.data[ch, fr, :], mean[ch, fr]), std[ch, fr]) return power_data
def erds_plot(epochs): # compute ERDS maps ########################################################### # idx = np.array(list(range(7, 11)) + list(range(12, 15)) + list(range(17, 21)) + list(range(32, 41))) # chans = np.array(epochs.ch_names)[idx].tolist() epochs.pick_channels(["C3","Cz","C4"]) event_ids = epochs.event_id tmin, tmax = -1, 4 freqs = np.arange(60, 90, 1) # frequencies from 2-35Hz n_cycles = freqs # use constant t/f resolution vmin, vmax = -1, 1.5 # set min and max ERDS values in plot # vmin, vmax = -0.5, 0.5 # set min and max ERDS values in plot baseline = [-1, 0.3] # baseline interval (in s) cmap = center_cmap(plt.cm.RdBu, vmin, vmax) # zero maps to white kwargs = dict(n_permutations=100, step_down_p=0.05, seed=1, buffer_size=None, out_type='mask') # for cluster test # Run TF decomposition overall epochs tfr = tfr_multitaper(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, average=False, decim=2) tfr.crop(tmin, tmax) tfr.apply_baseline(baseline, mode="percent") for event in event_ids: # select desired epochs for visualization tfr_ev = tfr[event] fig, axes = plt.subplots(1, 4, figsize=(12, 4), gridspec_kw={"width_ratios": [10, 10, 10, 1]}) for ch, ax in enumerate(axes[:-1]): # for each channel # positive clusters _, c1, p1, _ = pcluster_test(tfr_ev.data[:, ch, ...], tail=1, **kwargs) # negative clusters _, c2, p2, _ = pcluster_test(tfr_ev.data[:, ch, ...], tail=-1, **kwargs) # note that we keep clusters with p <= 0.05 from the combined clusters # of two independent tests; in this example, we do not correct for # these two comparisons c = np.stack(c1 + c2, axis=2) # combined clusters p = np.concatenate((p1, p2)) # combined p-values mask = c[..., p <= 0.05].any(axis=-1) # plot TFR (ERDS map with masking) tfr_ev.average().plot([ch], vmin=vmin, vmax=vmax, cmap=(cmap, False), axes=ax, colorbar=False, show=False, mask=mask, mask_style="mask") ax.set_title(epochs.ch_names[ch], fontsize=10) ax.axvline(0, linewidth=1, color="black", linestyle=":") # event if not ax.is_first_col(): ax.set_ylabel("") ax.set_yticklabels("") fig.colorbar(axes[0].images[-1], cax=axes[-1]) fig.suptitle("ERDS ({})".format(event)) fig.show()
def multitaper_analysis(epochs): """ Parameters ---------- epochs : list of epochs Returns ------- result : numpy array The result of the multitaper analysis. """ frequencies = np.arange(6., 90., 2.) n_cycles = frequencies / 2. time_bandwidth = 4 # Same time-smoothing as (1), 7 tapers. power, plv = tfr_multitaper(epochs, freqs=frequencies, n_cycles=n_cycles, time_bandwidth=time_bandwidth, return_itc=True) return power, plv
def extract_frequencies(subject, freqs, decim): """Filter TNT epochs using multitaper. Input ----- * subject: str Subject reference. freqs: array like Frequency range to extract. decim: int Decimation parameter Output ------ Save -tfr.h5 in the '/All_frequencies_multitaper' directory """ n_cycles = freqs / 2 # TNT tnt, tnt_df = data_tnt(subject) this_tfr = tfr_multitaper(tnt, freqs, n_cycles=n_cycles, n_jobs=6, decim=decim, average=False, return_itc=False) this_tfr = this_tfr.crop(-0.5, 3.0) this_tfr = this_tfr.apply_baseline(mode='percent', baseline=(-0.5, 0)) np.save(path + 'TNT/All_frequencies_multitaper/' + subject + '.npy', this_tfr._data) tnt_df.to_csv(path + 'TNT/All_frequencies_multitaper/' + subject + '.txt')
def compute_erds(epoch_trains, triggers, trf_window): """ Compute and display the Event-Related desynchronisations/synchronisations """ freqs = np.arange(2, 40, 1) # frequencies from 2-40Hz n_cycles = freqs / 2 # use constant t/f resolution # Run TF decomposition overall epochs tfr = {} for ev in triggers: tfr[ev] = tfr_multitaper(epoch_trains[ev], freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, average=True, decim=2) tfr[ev].crop(trf_window[0], trf_window[1]) #Plotting plot_erds(tfr, epoch_trains, triggers)
def __init__(self, epochs, freqs, n_cycles, method='multitaper', time_bandwidth=4., n_fft=512, width=1, picks=None): """ Initialize the class with an instance of EpochsTFR corresponding to the method """ self.picks = picks self.cmap = 'inferno' self.info = epochs.info if method == 'multitaper': from mne.time_frequency import tfr_multitaper self.tfr, _ = tfr_multitaper(epochs, freqs, n_cycles, time_bandwidth=time_bandwidth, picks=self.picks) if method == 'morlet': from mne.time_frequency import tfr_morlet self.tfr, _ = tfr_morlet(epochs, freqs, n_cycles, picks=self.picks) if method == 'stockwell': from mne.time_frequency import tfr_stockwell # The stockwell function does not handle picks like the two other # ones ... picked_ch_names = [epochs.info['ch_names'][i] for i in self.picks] picked = epochs.copy().pick_channels(picked_ch_names) self.tfr = tfr_stockwell(picked, fmin=freqs[0], fmax=freqs[-1], n_fft=n_fft, width=width)
def get_events(fif,f,validation_windowsize=2,l_threshold=0.4,h_threshold=3.4,channelList = None): raw = mne.io.read_raw_fif(fif,preload=True) anno = pd.read_csv(f) model = Filter_based_and_thresholding(l_freq=8,h_freq=20) if channelList == None: channelList = ['F3','F4','C3','C4','O1','O2'] else: channelList = raw.ch_names[:32] model.channelList = channelList model.get_raw(raw,) model.get_epochs(resample=256) model.get_annotation(anno) model.validation_windowsize = 3 model.syn_channels = int(len(channelList)/2) model.find_onset_duration(0.4,3.4) model.sleep_stage_check() model.make_manuanl_label() event_interval = model.epochs.events[:,0] / 1000 event_interval = np.vstack([event_interval, event_interval + 3]).T sleep_stage_interval = np.array(model.stage_on_off) row_idx = [sum([getOverlap(interval,temp) for temp in sleep_stage_interval]) != 0 for interval in event_interval] labels = model.manual_labels[row_idx] data = model.epochs.get_data()[row_idx] info = model.epochs.info events = model.epochs.events[row_idx] events[:,0] = events[:,0] / model.epochs.info['sfreq'] events[:,-1] = labels event_id = {'spindle':1,'non spindle':0} epochs_ = mne.EpochsArray(data,info,events=events,tmin=0,event_id=event_id,) freqs = np.arange(8,21,1) n_cycles = freqs / 2. time_bandwidth = 2.0 # Least possible frequency-smoothing (1 taper) power = tfr_multitaper(epochs_,freqs,n_cycles=n_cycles,time_bandwidth=time_bandwidth,return_itc=False,average=False,) power.info['event'] = events del raw return power,epochs_,model
def __init__(self, epochs, freqs, n_cycles, method='multitaper', time_bandwidth=4., n_fft=512, width=1, picks=None): """ Initialize the class with an instance of EpochsTFR corresponding to the method """ from backend.util import eeg_to_montage self.cmap = 'jet' self.info = epochs.info if picks is not None: self.picks = picks else: self.picks = list(range(0, len(epochs.info['ch_names']))) for bad in epochs.info['bads']: try: bad_pick = epochs.info['ch_names'].index(bad) self.picks.remove(bad_pick) except Exception as e: print(e) montage = eeg_to_montage(epochs) if montage is not None: # First we create variable head_pos for a correct plotting self.pos = montage.get_pos2d() scale = 0.85 / (self.pos.max(axis=0) - self.pos.min(axis=0)) center = 0.5 * (self.pos.max(axis=0) + self.pos.min(axis=0)) self.head_pos = {'scale': scale, 'center': center} # Handling of possible channels without any known coordinates no_coord_channel = False try: names = montage.ch_names indices = [ names.index(epochs.info['ch_names'][i]) for i in self.picks ] self.pos = self.pos[indices, :] except Exception as e: print(e) no_coord_channel = True # If there is not as much positions as the number of Channels # we have to eliminate some channels from the data of topomaps if no_coord_channel: from mne.channels import read_montage from numpy import array index = 0 self.pos = [] # positions # index in the self.data of channels with coordinates self.with_coord = [] for i in self.picks: ch_name = epochs.info['ch_names'][i] try: ch_montage = read_montage(montage.kind, ch_names=[ch_name]) coord = ch_montage.get_pos2d() self.pos.append(coord[0]) self.with_coord.append(index) except Exception as e: print(e) index += 1 self.pos = array(self.pos) else: self.with_coord = [i for i in range(len(self.picks))] else: # If there is no montage available self.head_pos = None self.with_coord = [] if method == 'multitaper': from mne.time_frequency import tfr_multitaper self.tfr, _ = tfr_multitaper(epochs, freqs, n_cycles, time_bandwidth=time_bandwidth, picks=self.picks) if method == 'morlet': from mne.time_frequency import tfr_morlet self.tfr, _ = tfr_morlet(epochs, freqs, n_cycles, picks=self.picks) if method == 'stockwell': from mne.time_frequency import tfr_stockwell # The stockwell function does not handle picks like the two other # ones ... picked_ch_names = [epochs.info['ch_names'][i] for i in self.picks] picked = epochs.copy().pick_channels(picked_ch_names) self.tfr = tfr_stockwell(picked, fmin=freqs[0], fmax=freqs[-1], n_fft=n_fft, width=width)
count = 2 else: #Stack trials X_data = np.vstack((X_data, X_cond)) # In[] # Calculated TFR for a particular clase in a particular condition for the selected subjects print("Calculated " + TFR_method + " for Class: " + Classes +" in Condition: " + Cond ) print("with the information of Subjects: " + str(N_S_list )) # Create a subject with all trials X_S._data = X_data if TFR_method == "Multitaper": power , itc = tfr_multitaper(X_S, freqs=freqs, n_cycles=n_cycles, use_fft=use_fft, return_itc=return_itc, decim=decim, n_jobs=n_jobs, average=average,picks=picks) if save_bool: Ensure_dir(save_dir) file_name = save_dir + TFR_method + "_" + Cond + "_" + Classes + "_power-tfr.h5" power.save(fname = file_name, overwrite = overwrite) if return_itc: file_name = save_dir + TFR_method + "_" + Cond + "_" + Classes + "_itc-tfr.h5" itc.save(fname = file_name, overwrite = overwrite) elif TFR_method == "Morlet": power , itc = tfr_morlet(X_S, freqs=freqs, n_cycles=n_cycles, use_fft=use_fft, return_itc=return_itc, decim=decim, n_jobs=n_jobs, average=average,zero_mean=zero_mean,picks=picks)
# First we'll use the multitaper method for calculating the TFR. # This creates several orthogonal tapering windows in the TFR estimation, # which reduces variance. We'll also show some of the parameters that can be # tweaked (e.g., ``time_bandwidth``) that will result in different multitaper # properties, and thus a different TFR. You can trade time resolution or # frequency resolution or both in order to get a reduction in variance. freqs = np.arange(5., 100., 3.) vmin, vmax = -3., 3. # Define our color limits. ############################################################################### # **(1) Least smoothing (most variance/background fluctuations).** n_cycles = freqs / 2. time_bandwidth = 2.0 # Least possible frequency-smoothing (1 taper) power = tfr_multitaper(epochs, freqs=freqs, n_cycles=n_cycles, time_bandwidth=time_bandwidth, return_itc=False) # Plot results. Baseline correct based on first 100 ms. power.plot([0], baseline=(0., 0.1), mode='mean', vmin=vmin, vmax=vmax, title='Sim: Least smoothing, most variance') ############################################################################### # **(2) Less frequency smoothing, more time smoothing.** n_cycles = freqs # Increase time-window length to 1 second. time_bandwidth = 4.0 # Same frequency-smoothing as (1) 3 tapers. power = tfr_multitaper(epochs, freqs=freqs, n_cycles=n_cycles, time_bandwidth=time_bandwidth, return_itc=False) # Plot results. Baseline correct based on first 100 ms. power.plot([0], baseline=(0., 0.1), mode='mean', vmin=vmin, vmax=vmax, title='Sim: Less frequency smoothing, more time smoothing')
explanation='2 Channels (C3, C4) Merged \nPSD of All Stages', picks='csd', saving_directory=saving_directory) #Multi-taper Parameters freqs = np.arange(0.1, 48, 0.1) # frequencies from 2-35Hz n_cycles = freqs # use constant t/f resolution vmin, vmax = -1, 1.5 # set min and max ERDS values in plot n_cycles = freqs * 2 # use constant t/f resolution #========= 6 Channels ========== fig, ax = plt.subplots(3, 1, figsize=(12, 4)) #gridspec_kw={"width_ratios": [5, 5]}) merged_icacsd_6channels.load_data() power = tfr_multitaper(merged_icacsd_6channels['Lucid'], freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, time_bandwidth = 8.0, decim=2,\ average=True) power.apply_baseline([-0.2, 0], mode='mean') avg_power = np.mean(power._data, 0) power._data = np.expand_dims(avg_power, axis=0) #expand dimension from axis=0 [1,x,y] power.plot([0], vmin=vmin, vmax=vmax, axes=ax[0], colorbar=False, show=False) power = tfr_multitaper(merged_icacsd_6channels['REM'], freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, time_bandwidth = 8.0, decim=2,\ average=True) power.apply_baseline([-0.2, 0], mode='mean') avg_power = np.mean(power._data, 0) power._data = np.expand_dims(avg_power, axis=0) #expand dimension from axis=0 [1,x,y] power.plot([0], vmin=vmin, vmax=vmax, axes=ax[1], colorbar=False, show=False) power = tfr_multitaper(merged_icacsd_6channels['Wake'], freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, time_bandwidth = 8.0, decim=2,\
model.sleep_stage_check() model.make_manuanl_label() event_interval = model.epochs.events[:,0] / 1000 event_interval = np.vstack([event_interval, event_interval + 3]).T sleep_stage_interval = np.array(model.stage_on_off) row_idx = [sum([getOverlap(interval,temp) for temp in sleep_stage_interval]) != 0 for interval in event_interval] labels = model.manual_labels[row_idx] data = model.epochs.get_data()[row_idx] info = model.epochs.info events = model.epochs.events[row_idx] events[:,0] = events[:,0] / model.epochs.info['sfreq'] events[:,-1] = labels event_id = {'spindle':1,'non spindle':0} epochs_ = mne.EpochsArray(data,info,events=events,tmin=0,event_id=event_id,) power = tfr_multitaper(model.epochs,freqs,n_cycles=n_cycles,time_bandwidth=time_bandwidth,return_itc=False,average=False,) data = power.data power = tfr_multitaper(epochs_,freqs,n_cycles=n_cycles,time_bandwidth=time_bandwidth,return_itc=False,average=False,) data_ = power.data labels_ = epochs_.events[:,-1] labels = model.manual_labels clf = Pipeline([('vectorizer',Vectorizer()), ('scaler',StandardScaler()), ('est',exported_pipeline)]) #fpr,tpr=[],[];AUC=[];confM=[];sensitivity=[];specificity=[] #for train, test in cv.split(data_,labels_): # C = np.array(list(dict(Counter(labels_[train])).values())) # ratio_threshold = C.min() / C.sum()
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=baseline, reject=dict(grad=4000e-13)) ############################################################################### # Calculate power freqs = np.arange(5., 50., 2.) # define frequencies of interest n_cycles = freqs / 2. # 0.5 second time windows for all frequencies # Choose time x (full) bandwidth product time_bandwidth = 4.0 # With 0.5 s time windows, this gives 8 Hz smoothing power, itc = tfr_multitaper(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=True, time_bandwidth=time_bandwidth, return_itc=True, n_jobs=1) # Plot results (with baseline correction only for power) power.plot([0], baseline=(-0.5, 0), mode='mean', title='MEG 1142 - Power') itc.plot([0], title='MEG 1142 - Intertrial Coherence')
def mt_hga_split(epoch, time_bandwidth=4., hga_start=60, hga_end=160, n_hga=None, norm='1/f', **kw): """Extract high-gamma activity (HGA) using a splited method. Step by step procedure : * Define a lineary spaced frequency vector (e.g. [60, 160]]) * Extract each sub-gamma band * Normalize each sub-band * Take the mean across sub-bands to obtain the final HG Parameters ---------- epoch : mne.Epochs Instance of mne.Epochs time_bandwidth : float | 4. Time x (Full) Bandwidth product. hga_start : float | 60. Lower boundary of the gamma band hga_end : float | 160. Higher boundary of the gamma band n_hga : int | None Number of HG sub-bands between (hga_start, hga_end) norm : {'1/f', 'constant'} | None Normalization method before taking the mean across sub-gamma bands kw : dict | {} Additional arguments are passed to the `tfr_multitaper` function. Returns ------- tf : AverageTFR | EpochsTFR The averaged or single-trial HGA. """ need_average = kw.get('average', False) if 'average' in kw.keys(): del kw['average'] # noqa # Define a linear frequency vector if not isinstance(n_hga, int): n_hga = int(np.round((hga_end - hga_start) / 10)) freqs = np.linspace(hga_start, hga_end, n_hga, endpoint=True) n_cycles = .2 * freqs # Compute multitaper tf = tfr_multitaper(epoch, freqs, n_cycles, return_itc=False, time_bandwidth=time_bandwidth, average=False, **kw) # Get the data and apply a 1/f normalization tf_data = tf.data if norm == '1/f': tf_data *= freqs.reshape(1, 1, -1, 1) elif norm == 'constant': tf_data -= tf_data.mean(3, keepdims=True) # Mean the data across sub-gamma bands tf_data = tf_data.mean(2, keepdims=True) freqs = np.array([tf.freqs.mean()]) # Rebuilt the EpochsTFR etf = EpochsTFR(tf.info, tf_data, tf.times, freqs) return etf.average() if need_average else etf
eves, [ 5, ], tmin=-0.5, proj=True, tmax=6.0, baseline=(-0.5, 0.0), reject=dict(eeg=200e-6)) freqs = np.arange(2, 80, 2) # define frequencies of interest n_cycles = freqs / float(5) # different number of cycle per frequency n_cycles[freqs < 5] = 1 # epochs.subtract_evoked() powerL, itcL = tfr_multitaper(epochsL, freqs=freqs, n_cycles=n_cycles, time_bandwidth=2.0, n_jobs=-1) powerL.data = 20 * np.log10(powerL.data) powerL.plot_topo(dB=False, baseline=(-0.5, 0.)) powerR, itcR = tfr_multitaper(epochsR, freqs=freqs, n_cycles=n_cycles, time_bandwidth=2.0, n_jobs=-1) powerR.data = 20 * np.log10(powerR.data) powerL.plot_topo(dB=False, baseline=(-0.5, 0.)) powerLR = powerR - powerL powerLR.plot_topo(dB=False, baseline=(-0.5, 0.))
# epoch data ################################################################## tmin, tmax = -1, 4 # define epochs around events (in s) event_ids = dict(hands=2, feet=3) # map event IDs to tasks epochs = mne.Epochs(raw, events, event_ids, tmin - 0.5, tmax + 0.5, picks=picks, baseline=None, preload=True) # compute ERDS maps ########################################################### freqs = np.arange(2, 36, 1) # frequencies from 2-35Hz n_cycles = freqs # use constant t/f resolution vmin, vmax = -1, 1.5 # set min and max ERDS values in plot cmap = center_cmap(plt.cm.RdBu, vmin, vmax) # zero maps to white for event in event_ids: power = tfr_multitaper(epochs[event], freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, decim=2) power.crop(tmin, tmax) fig, ax = plt.subplots(1, 4, figsize=(12, 4), gridspec_kw={"width_ratios": [10, 10, 10, 1]}) for i in range(3): power.plot([i], baseline=[-1, 0], mode="percent", vmin=vmin, vmax=vmax, cmap=(cmap, False), axes=ax[i], colorbar=False, show=False) ax[i].set_title(epochs.ch_names[i], fontsize=10) ax[i].axvline(0, linewidth=1, color="black", linestyle=":") # event if i > 0: ax[i].set_ylabel("") ax[i].set_yticklabels("") fig.colorbar(ax[0].collections[0], cax=ax[-1]) fig.suptitle("ERDS ({})".format(event)) fig.show()
pickle.dump([raw_data, fake_epochs, new_periods], open('Lucireta_lucidneighbour_interval','wb')) #%% =============== FILD Load Data for Spectrogram Analysis ============ from mne.time_frequency import tfr_multitaper os.chdir('/home/caghangir/Desktop/PhD/Lucid Dream EEG/Extracted Dataset/Lucid Neighbour Interval') FILD_raw_data, FILD_epoch, FILD_periods = pickle.load(open('FILD_lucidneighbour_interval','rb')) temp_epoch = FILD_epoch[0] #Multi-taper Parameters freqs = np.arange(2, 48, 0.1) # frequencies from 2-35Hz n_cycles = freqs # use constant t/f resolution vmin, vmax = -1, 1.5 # set min and max ERDS values in plot n_cycles = freqs * 2 # use constant t/f resolution power = tfr_multitaper(temp_epoch, freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, time_bandwidth = 8.0, decim=2,\ average=True) baseline_period = 5 #second beginner = power.times[0] finish = power.times[-1] states = lucidity_period_fild[0][1] difference = states[1] - states[0] power.apply_baseline([beginner, beginner+20], mode='mean') avg_power = np.mean(power._data, 0) power._data = np.expand_dims(avg_power, axis=0) #expand dimension from axis=0 [1,x,y] power._data = np.absolute(power._data) ** (1/2.) power._data = 10 * np.log10(power._data) # power._data = power._data[power._data < 0] = 0 #%% =============== Erlacher Load Data for Spectrogram Analysis ============
# set up pick list: MEG - bad channels picks = mne.pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False, exclude='bads') # Read epochs epochs = mne.Epochs(raw, events, event_id, tmin - 2, tmax, picks=picks, baseline=(tmin, tmax)) # Compute ERDS maps freqs = np.arange(5, 8, .1) n_cycles = freqs # use constant t/f resolution power = tfr_multitaper(epochs, freqs=freqs, n_cycles=n_cycles, return_itc=False) #ch = range(2, 306, 3) ch = [68] power.plot(ch, baseline=(-1., 0.), mode='mean')
event_id=condlist, tmin=-0.4, proj=True, tmax=1.0, baseline=(-0.2, 0.0), reject=dict(grad=5000e-13, mag=5e-12)) evokeds += [ epochs.average(), ] fstem = subj + ssstag + '_' + para if doTFR: freqs = np.arange(5., 70., 1.) n_cycles = freqs * 0.2 power, itc = tfr_multitaper(epochs, freqs, n_cycles, time_bandwidth=2.0, n_jobs=-1) fname_pow = fstem + '_pow_' + condstem + '-tfr.h5' fname_itc = fstem + '_itc_' + condstem + '-tfr.h5' power.save(respath + fname_pow, overwrite=True) itc.save(respath + fname_itc, overwrite=True) if saveEpochs: fname_epochs = fstem + '_' + condstem + '-epo.fif' epochs.save(respath + fname_epochs) # Now save overall onset N100 epochs = mne.Epochs(raw, eves, event_id=condlists,
epochs = mne.Epochs(raw, events, event_ids, tmin - 0.5, tmax + 0.5, picks=picks, baseline=None, preload=True) # compute ERDS maps ########################################################### freqs = np.arange(2, 36, 1) # frequencies from 2-35Hz n_cycles = freqs # use constant t/f resolution vmin, vmax = -1, 1.5 # set min and max ERDS values in plot baseline = [-1, 0] # baseline interval (in s) cmap = center_cmap(plt.cm.RdBu, vmin, vmax) # zero maps to white kwargs = dict(n_permutations=100, step_down_p=0.05, seed=1, buffer_size=None) # for cluster test # Run TF decomposition overall epochs tfr = tfr_multitaper(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, average=False, decim=2) tfr.crop(tmin, tmax) tfr.apply_baseline(baseline, mode="percent") for event in event_ids: # select desired epochs for visualization tfr_ev = tfr[event] fig, axes = plt.subplots(1, 4, figsize=(12, 4), gridspec_kw={"width_ratios": [10, 10, 10, 1]}) for ch, ax in enumerate(axes[:-1]): # for each channel # positive clusters _, c1, p1, _ = pcluster_test(tfr_ev.data[:, ch, ...], tail=1, **kwargs) # negative clusters _, c2, p2, _ = pcluster_test(tfr_ev.data[:, ch, ...], tail=-1, **kwargs)
baseline=None, preload=True) # compute ERDS maps ########################################################### freqs = np.arange(2, 36, 1) # frequencies from 2-35Hz n_cycles = freqs # use constant t/f resolution vmin, vmax = -1, 1.5 # set min and max ERDS values in plot baseline = [-1, 0] # baseline interval (in s) cmap = center_cmap(plt.cm.RdBu, vmin, vmax) # zero maps to white kwargs = dict(n_permutations=100, step_down_p=0.05, seed=1) # for cluster test for event in event_ids: tfr = tfr_multitaper(epochs[event], freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, average=False, decim=2) tfr.crop(tmin, tmax) tfr.apply_baseline(baseline, mode="percent") fig, axes = plt.subplots(1, 4, figsize=(12, 4), gridspec_kw={"width_ratios": [10, 10, 10, 1]}) for ch, ax in enumerate(axes[:-1]): # for each channel # positive clusters _, c1, p1, _ = pcluster_test(tfr.data[:, ch, ...], tail=1, **kwargs) # negative clusters _, c2, p2, _ = pcluster_test(tfr.data[:, ch, ...], tail=-1, **kwargs)
# Stuff to reject reject = dict(eog=150e-6) # Frequency Analysis freqs = numpy.arange(2, 32) # define frequencies of interest n_cycles = freqs / 2.0 # 0.5 second time windows for all frequencies # Choose time x (full) bandwidth product time_bandwidth = 4.0 # With 0.5 s time windows, this gives 8 Hz smoothing # Extract epochs # for x in range(0, 3): event_id = dict(aud_l=121, aud_r=1000) # event trigger and conditions epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=baseline, preload=False, reject=reject) power = tfr_multitaper(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=True, time_bandwidth=time_bandwidth, return_itc=False, n_jobs=1) # mne.viz.plot_epochs(epochs, picks=None, scalings=None, n_epochs=20, n_channels=61, title=None, show=True, block=False) evoked = epochs['aud_l'].average() mne.viz.plot_evoked(evoked, picks=None, exclude='bads', unit=True, show=False, ylim=None, xlim='tight', proj=False, hline=None, units=None, scalings=None, titles=None, axes = ax[0], gfp=False) # plot(evoked.data) # draw() # plt.pause(0.7) mne.viz.plot_evoked_image(evoked, picks=None, exclude='bads', unit=True, show=False, clim=None, xlim='tight', proj=False, units=None, scalings=None, titles=None, axes=ax[1], cmap='RdBu_r') power.plot([0], baseline=(-0.5, 0), mode='mean', axes = ax[2]) show() # evoked.plot(axes = ax) # draw() # ax.cla() # plt.pause(0.5)
#first_event_sample = 100 #event_id = dict(sin50hz=1) #for k in range(n_epochs): # events[k, :] = first_event_sample + k * n_times, 0, event_id['sin50hz'] # #epochs = EpochsArray(data=data, info=info, events=events, event_id=event_id, # reject=reject) freqs = np.arange(5., 100., 3.) vmin, vmax = -3., 3. # Define our color limits. n_cycles = freqs / 2. time_bandwidth = 2.0 # Least possible frequency-smoothing (1 taper) power = tfr_multitaper(epochs, freqs=freqs, n_cycles=n_cycles, time_bandwidth=time_bandwidth, return_itc=False) # Plot results. Baseline correct based on first 100 ms. power.plot([0], baseline=(0., 0.1), mode='mean', vmin=vmin, vmax=vmax, title='Sim: Least smoothing, most variance') #freqs = np.arange(0, 20., 2.) #vmin, vmax = -300., 300. # Define our color limits. # # ##
raw_fif.filter(8,20,) # filer between 8 - 20 Hz, leaving most of the parameters default sfreq = raw_fif.info['sfreq'] # get sampling frequency info = raw_fif.info info.normalize_proj() raw_fif.info = info info = raw_fif.info df = pd.read_csv(f) # read the annotation table idx_row = df['Annotation'].apply(spindle) # find the spindle rows df_spindle = df[idx_row] # only take the spindle rows and form a data frame df_spindle = df_spindle.drop_duplicates(['Onset']) events_={'start':(df_spindle['Onset'].values - 0.5)*sfreq, 'empty':np.zeros(df_spindle.shape[0],dtype=int), 'code':np.ones(df_spindle.shape[0],dtype=int)} events_=pd.DataFrame(events_,dtype=int) events_=events_.drop_duplicates(['start']) events_=events_[['start','empty','code']].values.astype(int) epochs_spindle = mne.Epochs(raw_fif,events_,tmin=0,tmax=2,event_id=1,baseline=None,detrend=0,preload=True) del raw_fif # save memory freqs = np.arange(8,21,1) n_cycles = freqs / 2. time_bandwidth = 2.0 # Least possible frequency-smoothing (1 taper) power = tfr_multitaper(epochs_spindle,freqs,n_cycles=n_cycles,time_bandwidth=time_bandwidth,return_itc=False,average=False,) power.save(saving_dir + 'sub%s_%s'%(sub,day) + '-tfr.h5',overwrite=True) del power