def plot_compare_lfp_power_coh_vs_loc(dataset, brain_area_1 = [0], brain_area_2 = [0], axs = None, method = 'duprelatour'): if ~(method in all_pac_methods): method = 'duprelatour' bands ={ 'theta':{'low': 4, 'high':8}, 'beta' :{'low': 13, 'high':30}, 'gamma':{'low': 30, 'high':70}} [brain_area1, name1] = get_brain_area_by_name(dataset, brain_area_1) [brain_area2, name2] = get_brain_area_by_name(dataset, brain_area_2) n_columns = len(bands.keys()) n_lines = 2 frq_res = 50 fig, axs = plt.subplots( n_lines, n_columns, figsize=(4 * n_columns, 3 * n_lines)) axs = axs.ravel() fs = dataset['sampling_rate'] for i, (area, name) in enumerate(zip([brain_area1,brain_area1], [name1,name2])): for index, band in enumerate(bands): low_fq_range = np.linspace(bands[band]['low'], bands[band]['high'], frq_res) low_fq_width = 1.0 signal = np.mean(dataset['lfp']['amplifier_data'][area,:], axis = 0) estimator = Comodulogram(fs=fs, low_fq_range=low_fq_range, low_fq_width=low_fq_width, method=method, progress_bar=False) estimator.fit(signal) estimator.plot(titles= [band +'@'+name], axs=[axs[index + i * n_columns]])
data_clean /= scale data_dirty /= scale ############################################################################### # This sample contains CFC between 3 Hz and 80 Hz. This phenomenon can be # described with a comodulogram, computed for instance with the `pactools # <http://pactools.github.io/>`_ Python library. from pactools import Comodulogram comod = Comodulogram(fs=sfreq, low_fq_range=np.arange(0.2, 10.2, 0.2), low_fq_width=2., method='duprelatour') comod.fit(data_clean) comod.plot() plt.show() ############################################################################### # Here we define the plotting function which display the learned atoms. def plot_atoms(d_hat): n_atoms, n_times_atom = d_hat.shape n_columns = min(6, n_atoms) n_rows = int(np.ceil(n_atoms // n_columns)) figsize = (4 * n_columns, 3 * n_rows) fig, axes = plt.subplots(n_rows, n_columns, figsize=figsize, sharey=True) axes = axes.ravel() # Plot the temporal pattern of the atom
# on which time window around each event. # select the time interval around the events tmin, tmax = -5, 15 # select the channels (phase_channel, amplitude_channel) ixs = (8, 10) ############################################################################### # Then, we create the inputs with the function raw_to_mask, which creates the # input arrays and the mask arrays. These arrays are then given to a # comodulogram instance with the `fit` method, and the `plot` method draws the # results. # create the input array for Comodulogram.fit low_sig, high_sig, mask = raw_to_mask(raw, ixs=ixs, events=events, tmin=tmin, tmax=tmax) # create the instance of Comodulogram estimator = Comodulogram(fs=raw.info['sfreq'], low_fq_range=np.linspace(1, 10, 20), low_fq_width=2., method='tort', progress_bar=True) # compute the comodulogram estimator.fit(low_sig, high_sig, mask) # plot the results estimator.plot(tight_layout=False) plt.show()
high_fq=high_fq, low_fq=low_fq, low_fq_width=low_fq_width, noise_level=noise_level, random_state=0) low_fq_range = np.linspace(1, 10, 50) methods = [ 'ozkurt', 'canolty', 'tort', 'penny', 'vanwijk', 'duprelatour', 'colgin', 'sigl', 'bispectrum' ] n_lines = 3 n_columns = int(np.ceil(len(methods) / float(n_lines))) fig, axs = plt.subplots(n_lines, n_columns, figsize=(4 * n_columns, 3 * n_lines)) axs = axs.ravel() for ax, method in zip(axs, methods): print('%s... ' % (method, )) estimator = Comodulogram(fs=fs, low_fq_range=low_fq_range, low_fq_width=low_fq_width, method=method, progress_bar=False) estimator.fit(signal) estimator.plot(titles=[REFERENCES[method]], axs=[ax]) plt.show()
axs[1].set_title(dar.get_title(name=True)) ############################################################################### # To compute a comodulogram, we perform the same steps for each low frequency: # * Extract the low frequency # * Fit a DAR model # * Potentially with a model selection using the BIC # * And quantify the PAC accross the spectrum. # # Everything is handled by the class :class:`~pactools.Comodulogram`, by giving # a (non-fitted) DAR model in the parameter ``method``. # Giving ``method='duprelatour'`` will default to # ``DAR(ordar=10, ordriv=1, criterion=None)``, without BIC selection. # Here we do not give the default set of parameter. Note that the BIC selection # will be performed independantly for each model (i.e. at each low frequency). dar = DAR(ordar=20, ordriv=2, criterion='bic') low_fq_range = np.linspace(1, 10, 50) estimator = Comodulogram(fs=fs, low_fq_range=low_fq_range, low_fq_width=low_fq_width, method=dar, progress_bar=False, random_state=0) fig, ax = plt.subplots(1, 1, figsize=(6, 4)) estimator.fit(signal) estimator.plot(axs=[ax]) ax.set_title('Comodulogram') plt.show()
high_fq_range = np.linspace(low_fq_range[-1], 100., 60) low_fq_width = 4. # Hz # A good rule of thumb is n_surrogates = 10 / p_value. Example: 10 / 0.05 = 200 # Here we use 10 to be fast n_surrogates = 10 p_value = 0.05 n_jobs = 11 # prepare the plot axes n_lines = 2 n_columns = int(np.ceil(len(methods) / float(n_lines))) figsize = (4 * n_columns, 3 * n_lines) fig, axs = plt.subplots(nrows=n_lines, ncols=n_columns, figsize=figsize) axs = axs.ravel() for ax, method in zip(axs, methods): # compute the comodulograms estimator = Comodulogram(fs=fs, low_fq_range=low_fq_range, high_fq_range=high_fq_range, low_fq_width=low_fq_width, method=method, n_surrogates=n_surrogates, n_jobs=n_jobs) estimator.fit(signal) # plot the comodulogram with contour levels estimator.plot(contour_method='comod_max', contour_level=p_value, axs=[ax], titles=[REFERENCES[method]]) fig.tight_layout() plt.show()
# input the ordar and ordriv from DAR model method = 'duprelatour' estimator = Comodulogram(fs=fs, low_fq_range=low_fq_range, low_fq_width=low_fq_width, method=method, n_surrogates=n_surrogates, high_fq_range=high_fq_range, progress_bar=True, n_jobs=n_jobs) estimator.fit(signal) # plot the significance level on top of the comodulogram fig, axs = plt.subplots(1, 2, figsize=(10, 4)) # suffers from multiple testing and assumes normality # titles=['With a z-score on each couple of frequency'] z_score = 4. estimator.plot(contour_method='z_score', contour_level=z_score, axs=[axs[0]]) # does not assume normality nor does it suffer from multiple testing # titles=['With a p-value on the distribution of maxima'] p_value = 0.05 estimator.plot(contour_method='comod_max', contour_level=p_value, axs=[axs[1]]) # save and show resuting comodulogram figure = filename.replace('.csv', '.jpeg') out_fig = os.path.join(out_dir, figure) plt.tight_layout() plt.savefig(out_fig) plt.show()
high_fq_width=1, method='duprelatour', progress_bar=True, n_jobs=-1, n_surrogates=n_surrogates) Data = signal.lfilter( b, a, np.loadtxt("SavedData\\" + x, comments="%", delimiter=",", usecols=(0, 1, 2)).T, 1) Data = np.array_split(Data[1][100:], len(Data[1]) / (250 * 70)) q = estimator.fit(Data[0]) p_value = 0.05 estimator.plot( contour_method='comod_max', contour_level=p_value, titles=['With a p-value on the distribution of maxima']) mx.append(estimator.get_maximum_pac()) estimator.save("Subject" + str(i) + x.split("_")[-2], overwrite=True) plt.title("Subject" + str(i) + x.split("_")[-2]) plt.savefig("pics\\" + str(x) + '.png') plt.show() #%% def nmi(active, passive): nmi = np.zeros(active.shape) for i, row in enumerate(active): for j, value in enumerate(row): nmi[i][j] = (active[i][j] - passive[i][j]) / passive[i][j]
# is Gaussian. # # # The other method presented here considers the ditribution of comodulogram # maxima. For each surrogate comodulogram, we compute the maximum PAC value. # From the obtained empirical distribution of maxima, we compute the # 95-percentile, which corresponds to a p-value of 0.05. # # This method does not assume the distribution to be Gaussian, nor suffers from # multiple-testing issues. This is the default method in the `plot` method. fig, axs = plt.subplots(1, 2, figsize=(10, 4)) z_score = 4. estimator.plot(contour_method='z_score', contour_level=z_score, titles=['With a z-score on each couple of frequency'], axs=[axs[0]]) p_value = 0.05 estimator.plot(contour_method='comod_max', contour_level=p_value, titles=['With a p-value on the distribution of maxima'], axs=[axs[1]]) plt.show() ############################################################################### # References # # [Canolty et al, 2006] # Canolty, R. T., Edwards, E., Dalal, S. S., Soltani, M., Nagarajan,
def pac_frequencies(ts, sf, method='duprelatour', n_values=10, drive_precision=0.05, max_drive_freq=6, min_drive_freq=3, sig_precision=1, max_sig_freq=50, min_sig_freq=8, low_fq_width=0.5, high_fq_width=1, plot=False): """Short summary. Parameters ---------- ts : type Description of parameter `ts`. sf : type Description of parameter `sf`. method : type Description of parameter `method`. n_values : type Description of parameter `n_values`. drive_precision : type Description of parameter `drive_precision`. max_drive_freq : type Description of parameter `max_drive_freq`. min_drive_freq : type Description of parameter `min_drive_freq`. sig_precision : type Description of parameter `sig_precision`. max_sig_freq : type Description of parameter `max_sig_freq`. min_sig_freq : type Description of parameter `min_sig_freq`. low_fq_width : type Description of parameter `low_fq_width`. high_fq_width : type Description of parameter `high_fq_width`. plot : type Description of parameter `plot`. Returns ------- type Description of returned object. """ drive_steps = int(((max_drive_freq - min_drive_freq) / drive_precision) + 1) low_fq_range = np.linspace(min_drive_freq, max_drive_freq, drive_steps) sig_steps = int(((max_sig_freq - min_sig_freq) / sig_precision) + 1) high_fq_range = np.linspace(min_sig_freq, max_sig_freq, sig_steps) estimator = Comodulogram(fs=sf, low_fq_range=low_fq_range, low_fq_width=low_fq_width, high_fq_width=high_fq_width, high_fq_range=high_fq_range, method=method, progress_bar=False) estimator.fit(ts) indexes = top_n_indexes(estimator.comod_, n_values)[::-1] pac_freqs = [] pac_coupling = [] for i in indexes: pac_freqs.append([low_fq_range[i[0]], high_fq_range[i[1]]]) pac_coupling.append([estimator.comod_[i[0]], estimator.comod_[i[1]]]) if plot is True: estimator.plot() return pac_freqs, pac_coupling
# Plot the modulation extracted by the optimal model dar.plot(ax=axs[1]) axs[1].set_title(dar.get_title(name=True)) ############################################################################### # To compute a comodulogram, we need to perform the same steps for each # low frequency: extract the low frequency, fit a DAR model, potentially with # a model selection with the BIC, and quantify the PAC accross the spectrum. # # Everything is handled by the function ``Comodulogram``, by giving a # (non-fitted) DAR model in the parameter ``method``. # Giving ``method='duprelatour'`` will default to # ``DAR(ordar=10, ordriv=1, criterion=None)``, without BIC selection. # Here we give a different set of parameter, and the BIC selection will be # performed independantly for each model (i.e. at each low frequency). dar = DAR(ordar=20, ordriv=2, criterion='bic') low_fq_range = np.linspace(1, 10, 50) estimator = Comodulogram(fs=fs, low_fq_range=low_fq_range, low_fq_width=low_fq_width, method=dar, progress_bar=False, random_state=0) estimator.fit(signal) estimator.plot(axs=[axs[2]]) axs[2].set_title('Comodulogram') plt.show()
#################################################################################################### fig, axs = plt.subplots(nrows=3, figsize=(10, 12), sharex=True) titles = ['Signal with PAC', 'Signal with Spurious PAC', 'Signal with no PAC'] for sig, ax, title in zip((sig_pac, sig_spurious_pac, sig_no_pac), axs, titles): # Check PAC within only channel; high and low sig are the same # Use the duprelatour driven autoregressive model to fit the data estimator = Comodulogram(fs=fs, low_fq_range=np.arange(1, 41), low_fq_width=2., method='duprelatour', progress_bar=False) # Compute the comodulogram estimator.fit(sig) # Plot the results estimator.plot(axs=[ax], tight_layout=False, titles=[title]) #################################################################################################### # # Plot time series for each recording # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # # Now let's see how each signal looks in time. The third plot of spikes is # added to pink noise to make the second plot which is the spurious pac. # This is so that where the spikes occur can be noted in the spurious pac plot. # #################################################################################################### time = np.arange(0, n_seconds, 1/fs)