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]])
def comodulogram(po, pos, sig1, sig2, name, save=1, plot=1, vmax=0.01, mtrx=False):
ax1 = py.subplot(gs[pos[2]:pos[3], pos[0]:pos[1]])
set_axis(ax1, -0.05, 1.05, letter= po)
estimator = Comodulogram(fs=Fs, low_fq_range= np.linspace(0.1, 4, 13),
high_fq_range=np.linspace(30, 150, 25),
low_fq_width=0.5, method = 'tort',#method='duprelatour',
progress_bar=True, n_jobs=4)
estimator.fit(sig1, sig2)
low_fq=0.1
high_fq=4
low_mod=30
high_mod=150
if mtrx:
im = py.imshow(mtrx, extent=[low_fq, high_fq, low_mod, high_mod],
vmax=vmax, aspect='auto', origin='lower', cmap='Blues')
else:
im = py.imshow(estimator.comod_.T, extent=[low_fq, high_fq, low_mod, high_mod],
vmax=vmax, aspect='auto', origin='lower', cmap='Blues')
py.ylim(30, 130)
py.xlabel('Driving Frequency (Hz)', fontsize = 13)
py.ylabel('Modulated high Frequency (Hz)', fontsize = 13)
py.xticks(fontsize=14)
py.yticks(fontsize=14)
cax2 = make_axes_locatable(ax1).append_axes("right", size="5%", pad=0)
cbar = py.colorbar(im, cax = cax2)#, format=mpl.ticker.FuncFormatter(fmt))
cbar.ax.set_title('MI', fontsize = 13)
cbar.ax.tick_params(labelsize=9)
return estimator.comod_.T
def compute_pt_tp(n_jobs, n_perm, title=''):
"""Compute Pactools and Tensorpac."""
cpt, meth_comp, soft = [], [], []
for meth in ['MVL', 'MI', 'PLV']:
# ---------------------------------------------------------------------
# get the method name
meth_pt = METH['PACTOOLS'][meth]
meth_tp = METH['TENSORPAC'][meth]
if n_perm > 0:
idpac = (meth_tp, 2, 4)
else:
idpac = (meth_tp, 0, 0)
# ---------------------------------------------------------------------
# PACTOOLS
pt_start = tst()
estimator = Comodulogram(fs=sf,
low_fq_range=f_pha_pt,
low_fq_width=f_pha_pt_width,
high_fq_range=f_amp_pt,
high_fq_width=f_amp_pt_width,
method=meth_pt,
progress_bar=False,
n_jobs=n_jobs,
n_surrogates=n_perm)
estimator.fit(data)
pt_end = tst()
# ---------------------------------------------------------------------
# TENSORPAC
tp_start = tst()
p_obj = Pac(idpac=idpac,
f_pha=f_pha_tp,
f_amp=f_amp_tp,
verbose='error')
pac = p_obj.filterfit(sf, data, n_jobs=n_jobs, n_perm=n_perm).mean(-1)
tp_end = tst()
# ---------------------------------------------------------------------
# shape shape checking
assert estimator.comod_.shape == pac.T.shape
# saving the results
cpt += [pt_end - pt_start, tp_end - tp_start]
meth_comp += [meth] * 2
soft += ['Pactools', 'Tensorpac']
# -------------------------------------------------------------------------
df = pd.DataFrame({
"Computing time": cpt,
"PAC method": meth_comp,
"Software": soft
})
sns.barplot(x="PAC method", y="Computing time", hue="Software", data=df)
plt.title(title, fontsize=14, fontweight='bold')
scale = data_clean.std()
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()
# 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()
# To make the most of parallel computing, we split the data into trials.
data = data.reshape(50, -1)
data /= data.std()
###############################################################################
# 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)
comod.plot()
plt.show()
###############################################################################
# We fit a CSC model on the data.
from alphacsc import learn_d_z
params = dict(
n_atoms=3,
n_times_atom=int(sfreq * 1.0), # 1000. ms
reg=5.,
n_iter=10,
solver_z='l-bfgs',
solver_z_kwargs=dict(factr=1e9),
low_fq_range=low_fq_range,
low_fq_width=1,
high_fq_range=high_fq_range,
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):
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
# The pac signal has 24 - 80 Hz pac as designed, the spurious pac has 10 - 60 Hz
# spurious pac and the final signal has no pac, just background noise.
####################################################################################################
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.
#
####################################################################################################