def epochs_specgram(subject_epochs, subject, specgram_avg, tfr):
frequencies = np.arange(4, 30, 2)
for electrode in ch_names:
if electrode not in specgram_avg:
specgram_avg[electrode] = {}
tfr[electrode] = {}
for code, epochs in subject_epochs.items():
if code not in specgram_avg[electrode]:
specgram_avg[electrode][code] = []
tfr[electrode][code] = []
electrode_epochs = epochs.copy().pick_channels([electrode]).get_data()
electrode_epochs = electrode_epochs.reshape(electrode_epochs.shape[0], electrode_epochs.shape[2]).squeeze()
f, t, Sxx = signal.spectrogram(electrode_epochs, fs = epochs.info['sfreq'], nperseg=512, noverlap = 384)
Sxx_mean = np.log(Sxx.mean(axis = 0))
specgram_avg[electrode][code].append(Sxx_mean)
tfr_epochs = tfr_morlet(epochs.copy().pick_channels([electrode]), frequencies, n_cycles=4.,decim = 5,
average=False, return_itc=False, n_jobs=1)
tfr[electrode][code].append(tfr_epochs)
return specgram_avg, f,t, tfr
def plot_evoked_freq(epochs, name='name', figs=[]):
print('plotting evoked on frequency domain')
# Plot overall psd
f = epochs.plot_psd(fmax=50, spatial_colors=True, average=True, show=False)
f.set_figheight(2.5)
f.suptitle(name)
figs.append(f)
# Plot psd topomaps for Delta, Theta, Alpha, Beta, Gamma band
f = epochs.plot_psd_topomap(normalize=True, show=False)
f.set_figheight(2.5)
f.suptitle(name)
figs.append(f)
# Calculate tfr_morlet power and itc
power, itc = tfr_morlet(epochs, freqs=freqs, n_cycles=n_cycles,
use_fft=True, return_itc=True,
n_jobs=n_jobs, verbose=1)
# Plot wavelet power
timefreqs = ((0.3, 1), (0.4, 1), (0.5, 1))
f = power.plot_joint(baseline=(-0.2, 0), mode='mean', timefreqs=timefreqs,
show=False)
f.suptitle(name)
figs.append(f)
return figs
def power_(epochs):
epochs = epochs
freqs = np.arange(4, 30, 1)
n_cycles = freqs / 2
power, itc = tfr_morlet(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=True,
return_itc=True, decim=1, n_jobs=1,picks=['POz','Oz','O1','O2'])
return power
def compute_power(epochs: Epochs, config: dict) -> AverageTFR:
"""
Computes Time-Frequency Representation (TFR) using complex Morlet wavelets
averaged over epochs. Power is written to an HDF5 file.
Parameters
----------
epochs
config
"""
fmin = config["morlet"]["fmin"]
fmax = config["morlet"]["fmax"]
step = config["morlet"]["step"]
freqs = np.logspace(*np.log10([fmin, fmax]), num=step)
n_cycles = freqs / 2.0
power = tfr_morlet(
epochs.average() if config["is_evoked"] else epochs.copy(),
freqs=freqs,
n_cycles=n_cycles,
use_fft=True,
return_itc=False,
decim=config["morlet"]["decim"],
average=True,
n_jobs=-1,
)
return power
def test_csd_morlet():
"""Test computing cross-spectral density using Morlet wavelets."""
epochs = _generate_coherence_data()
sfreq = epochs.info['sfreq']
# Compute CSDs by a variety of methods
freqs = [10, 15, 22]
n_cycles = [20, 30, 44]
times = [(None, None), (1, 9)]
as_arrays = [False, True]
parameters = product(times, as_arrays)
for (tmin, tmax), as_array in parameters:
if as_array:
csd = csd_array_morlet(epochs.get_data(),
sfreq,
freqs,
t0=epochs.tmin,
n_cycles=n_cycles,
tmin=tmin,
tmax=tmax,
ch_names=epochs.ch_names)
else:
csd = csd_morlet(epochs,
frequencies=freqs,
n_cycles=n_cycles,
tmin=tmin,
tmax=tmax)
if tmin is None and tmax is None:
assert csd.tmin == 0 and csd.tmax == 9.98
else:
assert csd.tmin == tmin and csd.tmax == tmax
_test_csd_matrix(csd)
# CSD diagonals should contain PSD
tfr = tfr_morlet(epochs, freqs, n_cycles, return_itc=False)
power = np.mean(tfr.data, 2)
csd = csd_morlet(epochs, frequencies=freqs, n_cycles=n_cycles)
assert_allclose(csd._data[[0, 3, 5]] * sfreq, power)
# Test using plain convolution instead of FFT
csd = csd_morlet(epochs,
frequencies=freqs,
n_cycles=n_cycles,
use_fft=False)
assert_allclose(csd._data[[0, 3, 5]] * sfreq, power)
# Test baselining warning
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
epochs_nobase = epochs.copy()
epochs_nobase.baseline = None
epochs_nobase.info['highpass'] = 0
csd = csd_morlet(epochs_nobase, frequencies=[10], decim=20)
assert len(w) == 1
def mne_wavelet_plot(epochs):
freqs = np.logspace(*np.log10([2, 42]), num=15)
n_cycles = freqs / 4. # different number of cycle per frequency
power, itc = tfr_morlet(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=True,
return_itc=True, decim=3, n_jobs=1)
channel_picks = 0
# epochs.plot_image(picks=[channel_picks], evoked=True, combine='mean')
power.plot(picks=[channel_picks], baseline=(0, 0.05), mode='logratio', title=power.ch_names[channel_picks])
def compute_tfr(epochsAllMove,epoch_times,freqs = np.arange(6, 123, 3),crop_val=0.5,decim=30):
#Time-frequency analysis (from https://plot.ly/ipython-notebooks/mne-tutorial/ -> Time-frequency analysis)
n_cycles = freqs / 4. # different number of cycle per frequency
#Compute power for move trials
print('Computing power...')
power = tfr_morlet(epochsAllMove, freqs=freqs, n_cycles=n_cycles, use_fft=False,
return_itc=False, decim=decim, n_jobs=1,average=False)
print('Power computation complete!')
power.crop(epoch_times[0]+crop_val, epoch_times[1]-crop_val) #trim epoch to avoid edge effects
power.data = 10*np.log10(power.data) #convert to log scale
power.data[np.isinf(power.data)]=0 #set infinite values to 0
return power
def power_(epochs):
epochs = epochs
freqs = np.arange(4, 30, 1)
n_cycles = freqs / 2.
power = tfr_morlet(epochs,
freqs=freqs,
n_cycles=n_cycles,
use_fft=True,
return_itc=False,
decim=5,
n_jobs=1,
average=False,
picks=['Pz', 'Cz', 'Fz'])
return power
def write_TF(Name_begin, patient_f, patient_idx):
channel_df = pd.read_csv(os.path.join(PATH, patient_f)[:-9] +
"_channels.tsv",
sep="\t",
encoding='unicode_escape')
dat = io.read_raw_edf(os.path.join(PATH, patient_f))
ttl_idx = [idx for idx, ch in enumerate(dat.ch_names)
if "POL DC10" in ch][0]
mov_bin = preprocess_mov(dat.get_data()[ttl_idx, :])
idx_ecog = []
for ch in channel_df["name"]:
PATH_save = 'C:\\Users\\ICN_admin\\Dropbox (Brain Modulation Lab)\\Shared Lab Folders\\CRCNS\\PD_ButtonPress\\derivatives\\'+\
"sub_"+subjects[patient_idx] +"_ch_"+ch[4:]+'.npy'
if os.path.exists(PATH_save) is True:
continue
if ch.startswith(Name_begin) is False or \
channel_df.iloc[channel_df[channel_df.name == ch].index[0]]["status"] != "good":
continue
idx_ecog = [
idx for idx, ch_ in enumerate(dat.ch_names) if ch_.startswith(ch)
][0]
info = create_info(ch_names=[ch[4:]], sfreq=2000, ch_types='ecog')
epochs = calc_epochs(dat.get_data()[idx_ecog, :],
mov_bin,
info,
threshold=0.5,
epoch_lim=2500 * 2)
freqs = np.arange(7, 200, 1)
power = tfr_morlet(epochs,
freqs=freqs,
n_cycles=5,
return_itc=False,
zero_mean=True,
picks=0)
dat_ = power.data[
0, :, 1000:
9000] # cut off borders due to Wavelet transform; 500ms till 4s post movement
dat_z = stats.zscore(dat_, axis=1)
#plt.imshow(dat_z, aspect='auto', extent=[-2,2,200,0])#, cmap='hot')
#cbar = plt.colorbar()
#cbar.set_label('Normalized spectral power [VAR]')
#plt.clim(-1.5,1.5)
#plt.gca().invert_yaxis()
#plt.title(Name_begin[4:] + " " + subjects[patient_idx])
#plt.show()
np.save(PATH_save, dat_z)
def compute_tfr(epochsAllMove,eventType,epoch_times,freqs = np.arange(6, 123, 3),crop_val=0.5,decim=30):
"""
Computes spectrogram using Morlet wavelets (log-scaled).
"""
n_cycles = freqs / 4. # different number of cycle per frequency
#Compute power for move trials
print('Computing power...')
power = tfr_morlet(epochsAllMove[eventType], freqs=freqs, n_cycles=n_cycles, use_fft=False,
return_itc=False, decim=decim, n_jobs=1,average=False)
print('Power computation complete!')
power.crop(epoch_times[0]+crop_val, epoch_times[1]-crop_val) #trim epoch to avoid edge effects
power.data = 10*np.log10(power.data+\
np.finfo(np.float32).eps) #convert to log scale
power.data[np.isinf(power.data)]=0 #set infinite values to 0
return power
def test_csd_morlet():
"""Test computing cross-spectral density using Morlet wavelets."""
epochs = _generate_coherence_data()
sfreq = epochs.info['sfreq']
# Compute CSDs by a variety of methods
freqs = [10, 15, 22]
n_cycles = [20, 30, 44]
times = [(None, None), (1, 9)]
as_arrays = [False, True]
parameters = product(times, as_arrays)
for (tmin, tmax), as_array in parameters:
if as_array:
csd = csd_array_morlet(epochs.get_data(), sfreq, freqs,
t0=epochs.tmin, n_cycles=n_cycles,
tmin=tmin, tmax=tmax,
ch_names=epochs.ch_names)
else:
csd = csd_morlet(epochs, frequencies=freqs, n_cycles=n_cycles,
tmin=tmin, tmax=tmax)
if tmin is None and tmax is None:
assert csd.tmin == 0 and csd.tmax == 9.98
else:
assert csd.tmin == tmin and csd.tmax == tmax
_test_csd_matrix(csd)
# CSD diagonals should contain PSD
tfr = tfr_morlet(epochs, freqs, n_cycles, return_itc=False)
power = np.mean(tfr.data, 2)
csd = csd_morlet(epochs, frequencies=freqs, n_cycles=n_cycles)
assert_allclose(csd._data[[0, 3, 5]] * sfreq, power)
# Test using plain convolution instead of FFT
csd = csd_morlet(epochs, frequencies=freqs, n_cycles=n_cycles,
use_fft=False)
assert_allclose(csd._data[[0, 3, 5]] * sfreq, power)
# Test baselining warning
epochs_nobase = epochs.copy()
epochs_nobase.baseline = None
epochs_nobase.info['highpass'] = 0
with pytest.warns(RuntimeWarning, match='baseline'):
csd = csd_morlet(epochs_nobase, frequencies=[10], decim=20)
def compute_morlet(epochs, fmin, fmax, n_bins):
EOG_chs = ['E1', 'E8', 'E25', 'E32', 'E126', 'E127']
Unwanted = ['E43', 'E48', 'E49', 'E128', 'E113', 'E120', 'E125', 'E119']
All_chs = epochs.info['ch_names'][0:129]
EEG_chs = [ele for ele in All_chs if ele not in Unwanted]
EEG_chs = [ele for ele in EEG_chs if ele not in EOG_chs]
freqs = np.logspace(*np.log10([fmin, fmax]), num=n_bins)
n_cycles = freqs / 2. # different number of cycle per frequency
morlet = tfr_morlet(epochs,
freqs=freqs,
n_cycles=n_cycles,
use_fft=False,
return_itc=False,
decim=3,
n_jobs=1,
picks=EEG_chs,
average=False)
return morlet
def test_get_inst_data():
"""Test _get_inst_data."""
raw = read_raw_fif(fname_raw)
raw.crop(tmax=1.)
assert_array_equal(_get_inst_data(raw), raw._data)
raw.pick_channels(raw.ch_names[:2])
epochs = make_fixed_length_epochs(raw, 0.5)
assert_array_equal(_get_inst_data(epochs), epochs._data)
evoked = epochs.average()
assert_array_equal(_get_inst_data(evoked), evoked.data)
evoked.crop(tmax=0.1)
picks = list(range(2))
freqs = [50., 55.]
n_cycles = 3
tfr = tfr_morlet(evoked, freqs, n_cycles, return_itc=False, picks=picks)
assert_array_equal(_get_inst_data(tfr), tfr.data)
pytest.raises(TypeError, _get_inst_data, 'foo')
def test_get_inst_data():
"""Test _get_inst_data"""
raw = read_raw_fif(fname_raw, add_eeg_ref=False)
raw.crop(tmax=1.)
assert_equal(_get_inst_data(raw), raw._data)
raw.pick_channels(raw.ch_names[:2])
epochs = _segment_raw(raw, 0.5)
assert_equal(_get_inst_data(epochs), epochs._data)
evoked = epochs.average()
assert_equal(_get_inst_data(evoked), evoked.data)
evoked.crop(tmax=0.1)
picks = list(range(2))
freqs = np.array([50., 55.])
n_cycles = 3
tfr = tfr_morlet(evoked, freqs, n_cycles, return_itc=False, picks=picks)
assert_equal(_get_inst_data(tfr), tfr.data)
assert_raises(TypeError, _get_inst_data, 'foo')
def test_get_inst_data():
"""Test _get_inst_data."""
raw = read_raw_fif(fname_raw)
raw.crop(tmax=1.)
assert_equal(_get_inst_data(raw), raw._data)
raw.pick_channels(raw.ch_names[:2])
epochs = _segment_raw(raw, 0.5)
assert_equal(_get_inst_data(epochs), epochs._data)
evoked = epochs.average()
assert_equal(_get_inst_data(evoked), evoked.data)
evoked.crop(tmax=0.1)
picks = list(range(2))
freqs = np.array([50., 55.])
n_cycles = 3
tfr = tfr_morlet(evoked, freqs, n_cycles, return_itc=False, picks=picks)
assert_equal(_get_inst_data(tfr), tfr.data)
assert_raises(TypeError, _get_inst_data, 'foo')
def morlet_analysis(epochs, n_cycles=4):
"""
Parameters
----------
epochs : list of epochs
Returns
-------
result : numpy array
The result of the multitaper analysis.
"""
frequencies = np.arange(6., 30., 2.)
# n_cycles = frequencies / 2.
power, plv = tfr_morlet(epochs, freqs=frequencies, n_cycles=n_cycles,
return_itc=True,
verbose=True)
return power, plv
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 _compute_tfr_morlet(epo_fpath, freqs, n_cycles):
assert os.path.exists(epo_fpath)
epochs = read_epochs(epo_fpath)
power = tfr_morlet(epochs,
freqs=freqs,
n_cycles=n_cycles,
use_fft=True,
return_itc=False,
decim=3,
n_jobs=1)
data_path, basename, ext = split_filename(epo_fpath)
tfr_fname = os.path.abspath(basename + '-tfr.h5')
print((power.data.shape))
print(('*** save {} ***'.format(tfr_fname)))
write_tfrs(tfr_fname, power, overwrite=True)
return tfr_fname
def plotTFMaps(self):
if self.data:
if self.n_cycles == 'scale':
number = self.freqs / 2.
else:
number = self.n_cycles
power = tfr_morlet(self.data,
freqs=self.freqs,
n_cycles=number,
return_itc=False)
if (self.b1.isChecked() == True):
power.plot([self.channel],
baseline=(self.baselineA, self.baselineB),
mode=self.mode,
title=power.ch_names[self.channel])
if (self.b2.isChecked() == True):
power.plot_topo(baseline=(self.baselineA, self.baselineB),
mode=self.mode,
title='Average power')
def EEG_to_TF_mne(dataset):
ch_names = [str(i) for i in range(global_vars.get('eeg_chans'))]
ch_types = ['eeg' for i in range(global_vars.get('eeg_chans'))]
info = mne.create_info(ch_names=ch_names,
sfreq=global_vars.get('frequency'),
ch_types=ch_types)
freqs = np.arange(1, global_vars.get('max_tf_freq'),
1) # frequencies of interest
n_cycles = freqs / 4. # different number of cycle per frequency
for segment in dataset.keys():
TF_list = []
epochs = mne.EpochsArray(dataset[segment].X,
info=info,
baseline=(0, 0.5))
for idx in range(len(dataset[segment].X)):
power = tfr_morlet(epochs[idx],
freqs=freqs,
n_cycles=n_cycles,
return_itc=False,
decim=3,
n_jobs=1)
TF_list.append(power.data.astype(np.float32))
dataset[segment].X = np.stack(TF_list, axis=0)
def tf_single_trial(epochs, log):
# Window of interest
fmin = 8
fmax = 12
tmin = -0.1
tmax = 0.1
# TF parameters
freqs = np.arange(fmin, fmax, 0.1) # frequencies of interest
n_cycles = 4.
power = tfr_morlet(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=True, average=False,
return_itc=False, n_jobs=n_jobs)
power.apply_baseline(baseline=(-0.95, -0.75), mode='mean')
for ix_r, r in enumerate(sorted(rois)):
roi = rois[r]
pow_subj_c = power.copy()
roi_pow = pow_subj_c.pick_channels(roi)
tr_pow = np.mean(roi_pow.crop(tmin, tmax).data, axis=(1, 2, 3))
log.loc[epochs.selection, r] = tr_pow
return log
def test_tfr():
with tempfile.TemporaryDirectory() as dirpath:
sample_folder = mne.datasets.sample.data_path()
sample_fname = os.path.join(sample_folder, 'MEG', 'sample',
'sample_audvis_raw.fif')
name = 'TestTFR'
cond_name = 'cond_1'
tfr_dir = os.path.join(dirpath, 'tfr')
raw = mne.io.read_raw_fif(sample_fname, preload=True)
events = find_events(raw, id_=1)
freqs = [8, 9, 10, 11, 12]
n_cycles = 2
mne_tfr = tfr_morlet(mne.Epochs(raw, events),
freqs,
n_cycles,
return_itc=False)
# As meggie-style tfrs can be based on multiple mne TFR objects,
# content is dict-type. conditions-param is added to avoid accidents
# in content loading..
content = {cond_name: mne_tfr}
params = {'conditions': [cond_name]}
# Create meggie-TFR object
# and save it to tfr directory
tfr = TFR(name, tfr_dir, params, content=content)
ensure_folders([tfr_dir])
tfr.save_content()
# Creating meggie-TFR object with same name and folder should allow
# accessing the saved content.
loaded_tfr = TFR(name, tfr_dir, params)
assert (loaded_tfr.content[cond_name].nave == 72)
def get_power(file = 'data/caroltrio_eeg_2019.06.20_23.57.27.edf', show = False):
'''
Get power according to time and frequency
Parameters
----------
file : EEG file
Return
------
raw : raw cleaned of eog arteact
power, times
'''
ncycle_dict = {'data/caroltrio_eeg_2019.06.20_23.57.27.edf':50, 'data/caroltrio_eeg_2019.03.16_14.07.07.edf': 20}
raw = import_file(file)
raw = run_preprocessing_eog(raw, show = show)
epochs = creating_epochs(raw, duration = raw.times[-1])
freqs = np.arange(2,30, 4)
n_cycles = freqs*ncycle_dict[file] # different number of cycle per frequency
power, _ = tfr_morlet(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=True,
return_itc=True, decim=3, n_jobs=1)
power.plot([4],dB = True,tmin = 60, title=power.ch_names[0])#, vmin = -50)
if file == 'data/caroltrio_eeg_2019.06.20_23.57.27.edf':
power.crop(tmax = 1467)
else :
power.crop(tmax = 583)
times = np.linspace(0, power.times[-1], num = power.data[0].shape[1])
return raw, power, times
def procesamiento(raw, picks, canales):
n_cycles = 5
freqs = np.arange(8, 34, 3)
events = mne.find_events(raw, stim_channel = 'STI 014')
event_id = dict(aud_l=1)
tmin = 0
tmax = 0.5
baseline = (None, 0)
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=baseline, preload=False)
power = tfr_morlet(epochs, freqs=freqs, n_cycles=n_cycles, return_itc=False, decim=3, n_jobs=1)
promedio = power.data[0]
for i in range(1, canales):
promedio = promedio + power.data[i]
promedio = promedio / canales
promedio1 = promedio[0]
for i in range(1, 8):
promedio1 = promedio1 + promedio[i]
promedio1 = promedio1 / 8
promedio2 = 0
for i in range(0, len(promedio1)):
promedio2 = promedio2 + promedio1[i]
promedio2 = promedio2 / len(promedio[0])
print 'Potencia promedio: ', promedio2
return power
axs[1].set_xlabel('Frequency (Hz)')
axs[0].legend()
axs[1].legend()
plt.show();
# With this visualization we can clearly see distinct peaks at 30hz and 20hz in the PSD, corresponding to the frequency of the visual stimulation. The peaks are much larger at the POz electrode, but still visible at TP9 and TP10
####################################################################################################
# Spectrogram
# -----------
# We can also look for SSVEPs in the spectrogram, which uses color to represent the power of frequencies in the EEG signal over time
frequencies = np.logspace(1, 1.75, 60)
tfr, itc = tfr_morlet(epochs['30 Hz'], freqs=frequencies,picks='all',
n_cycles=15, return_itc=True)
tfr.plot(picks=[4], baseline=(-0.5, -0.1), mode='logratio',
title='POz - 30 Hz stim');
tfr, itc = tfr_morlet(epochs['20 Hz'], freqs=frequencies,picks='all',
n_cycles=15, return_itc=True)
tfr.plot(picks=[4], baseline=(-0.5, -0.1), mode='logratio',
title='POz - 20 Hz stim');
plt.tight_layout()
# Once again we can see clear SSVEPs at 30hz and 20hz
def plotERP(
self,
event_code1=769,
event_code2=770,
filename="",
bad_ch=[
'Channel 14', "Channel 15", "EMG1", "Channel 17", "Channel 18",
"Channel 19", "T10"
],
):
tmin, tmax = -1., 4.
event_id = dict(class1=event_code1, class2=event_code2)
# load file
raw_fnames = [filename]
raw_files = [
read_raw_edf(f, preload=True, stim_channel='auto')
for f in raw_fnames
]
raw = concatenate_raws(raw_files)
montage = channels.read_montage('standard_1020')
raw.set_montage(montage)
raw.info['bads'] = bad_ch
events = find_events(raw, shortest_event=0)
# select what to print and what to exclude
picks = pick_types(raw.info,
meg=False,
eeg=True,
stim=False,
eog=False,
exclude='bads')
reject = dict(eeg=180e-6)
evoked_no_ref = Epochs(raw,
events,
event_id,
tmin,
tmax,
proj=True,
picks=picks,
baseline=(-0.5, 0),
reject=reject,
preload=True).average()
title = 'EEG'
evoked_no_ref.plot(titles=dict(eeg=title),
time_unit='s',
spatial_colors=True)
# define frequencies of interest (log-spaced)
freqs = np.logspace(*np.log10([6, 35]), num=8)
n_cycles = freqs / 2. # different number of cycle per frequency
power, itc = tfr_morlet(epochs,
freqs=freqs,
n_cycles=n_cycles,
use_fft=True,
return_itc=True,
decim=3,
n_jobs=1)
power.plot_joint(baseline=(-0.5, 0),
mode='logratio',
tmin=tmin,
tmax=tmax,
timefreqs=[(.5, 10), (1.3, 8)])
def test_compute_csd():
"""Test computing cross-spectral density from ndarray."""
epochs = _get_real_data()
tmin = 0.04
tmax = 0.15
tmp = np.where(np.logical_and(epochs.times >= tmin,
epochs.times <= tmax))[0]
picks_meeg = mne.pick_types(epochs[0].info, meg=True, eeg=True, eog=False,
ref_meg=False, exclude='bads')
epochs_data = [e[picks_meeg][:, tmp].copy() for e in epochs]
n_trials = len(epochs)
n_series = len(picks_meeg)
X = np.concatenate(epochs_data, axis=0)
X = np.reshape(X, (n_trials, n_series, -1))
X_list = epochs_data
sfreq = epochs.info['sfreq']
# Check data types and sizes are checked
diff_types = [np.random.randn(3, 5), "error"]
err_data = [np.random.randn(3, 5), np.random.randn(2, 4)]
with warnings.catch_warnings(record=True): # deprecation
raises(ValueError, csd_array, err_data, sfreq)
raises(ValueError, csd_array, diff_types, sfreq)
raises(ValueError, csd_array, np.random.randn(3), sfreq)
# Check that wrong parameters are recognized
raises(ValueError, csd_array, X, sfreq, mode='notamode')
raises(ValueError, csd_array, X, sfreq, fmin=20, fmax=10)
raises(ValueError, csd_array, X, sfreq, fmin=20, fmax=20.1)
# Test deprecation warning
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter('always')
csd_mt = csd_array(X, sfreq, mode='multitaper', fmin=8, fmax=12)
assert len([w for w in ws
if issubclass(w.category, DeprecationWarning)]) == 1
with warnings.catch_warnings(record=True): # deprecation
csd_fourier = csd_array(X, sfreq, mode='fourier', fmin=8, fmax=12)
# Test as list too
with warnings.catch_warnings(record=True): # deprecation
csd_mt_list = csd_array(X_list, sfreq, mode='multitaper',
fmin=8, fmax=12)
csd_fourier_list = csd_array(X_list, sfreq, mode='fourier', fmin=8,
fmax=12)
assert_array_equal(csd_mt._data, csd_mt_list._data)
assert_array_equal(csd_fourier._data, csd_fourier_list._data)
assert_array_equal(csd_mt.frequencies, csd_mt_list.frequencies)
assert_array_equal(csd_fourier.frequencies, csd_fourier_list.frequencies)
# Check shape of the CSD matrix
n_chan = len(epochs.ch_names)
csd_mt_data = csd_mt.get_data()
csd_fourier_data = csd_fourier.get_data()
assert csd_mt_data.shape == (n_chan, n_chan)
assert csd_fourier_data.shape == (n_chan, n_chan)
# Check if the CSD matrix is hermitian
assert_array_equal(np.tril(csd_mt_data).T.conj(),
np.triu(csd_mt_data))
assert_array_equal(np.tril(csd_fourier_data).T.conj(),
np.triu(csd_fourier_data))
# Computing induced power for comparison
epochs.crop(tmin=0.04, tmax=0.15)
tfr = tfr_morlet(epochs, freqs=[10], n_cycles=0.6, return_itc=False)
power = np.mean(tfr.data, 2)
# Maximum PSD should occur for specific channel
max_ch_power = power.argmax()
max_ch_mt = csd_mt_data.diagonal().argmax()
max_ch_fourier = csd_fourier_data.diagonal().argmax()
assert max_ch_mt == max_ch_power
assert max_ch_fourier == max_ch_power
# Maximum CSD should occur for specific channel
ch_csd_mt = np.abs(csd_mt_data[max_ch_power])
ch_csd_mt[max_ch_power] = 0.
max_ch_csd_mt = np.argmax(ch_csd_mt)
ch_csd_fourier = np.abs(csd_fourier_data[max_ch_power])
ch_csd_fourier[max_ch_power] = 0.
max_ch_csd_fourier = np.argmax(ch_csd_fourier)
assert max_ch_csd_mt == max_ch_csd_fourier
# Check a list of CSD matrices is returned for multiple frequencies within
# a given range when fsum=False
with warnings.catch_warnings(record=True): # deprecation
csd_fsum = csd_array(X, sfreq, mode='fourier', fmin=8, fmax=20,
fsum=True)
csds = csd_array(X, sfreq, mode='fourier', fmin=8, fmax=20,
fsum=False)
assert csds._data.shape[1] == 2
assert len(csds.frequencies) == 2
assert_array_equal(csd_fsum.frequencies[0], csds.frequencies)
assert_array_equal(csd_fsum._data, csds._data.sum(axis=1, keepdims=True))
###############################################################################
# Time-frequency analysis: power and inter-trial coherence
# --------------------------------------------------------
#
# We now compute time-frequency representations (TFRs) from our Epochs.
# We'll look at power and inter-trial coherence (ITC).
#
# To this we'll use the function :func:`mne.time_frequency.tfr_morlet`
# but you can also use :func:`mne.time_frequency.tfr_multitaper`
# or :func:`mne.time_frequency.tfr_stockwell`.
# define frequencies of interest (log-spaced)
freqs = np.logspace(*np.log10([6, 35]), num=8)
n_cycles = freqs / 2. # different number of cycle per frequency
power, itc = tfr_morlet(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=True,
return_itc=True, decim=3, n_jobs=1)
###############################################################################
# Inspect power
# -------------
#
# .. note::
# The generated figures are interactive. In the topo you can click
# on an image to visualize the data for one sensor.
# You can also select a portion in the time-frequency plane to
# obtain a topomap for a certain time-frequency region.
power.plot_topo(baseline=(-0.5, 0), mode='logratio', title='Average power')
power.plot([82], baseline=(-0.5, 0), mode='logratio', title=power.ch_names[82])
fig, axis = plt.subplots(1, 2, figsize=(7, 4))
power.plot_topomap(ch_type='grad', tmin=0.5, tmax=1.5, fmin=8, fmax=12,
import numpy as np
from my_settings import (epochs_folder, tf_folder)
from mne.time_frequency import tfr_morlet
import sys
subject = sys.argv[1]
freqs = np.arange(8, 13, 1) # define frequencies of interest
n_cycles = 4. # freqs / 2. # different number of cycle per frequency
sides = ["left", "right"]
conditions = ["ctl", "ent"]
epochs = mne.read_epochs(
epochs_folder + "%s_trial_start-epo.fif" % subject,
preload=False)
for cond in conditions:
for side in sides:
power, itc = tfr_morlet(epochs[cond + "/" + side],
freqs=freqs,
n_cycles=n_cycles,
use_fft=True,
return_itc=False,
decim=2,
average=False,
n_jobs=1)
power.save(tf_folder + "%s_%s_%s-4-tfr.h5" % (subject, cond, side),
overwrite=True)
itc.save(tf_folder + "%s_%s_%s-4-tfr.h5" % (subject, cond, side),
overwrite=True)
epochs.pick_channels([ch_name])
evoked = epochs.average()
# Factor to down-sample the temporal dimension of the TFR computed by
# tfr_morlet. Decimation occurs after frequency decomposition and can
# be used to reduce memory usage (and possibly computational time of downstream
# operations such as nonparametric statistics) if you don't need high
# spectrotemporal resolution.
decim = 5
frequencies = np.arange(8, 30, 2) # define frequencies of interest
sfreq = raw.info['sfreq'] # sampling in Hz
tfr_epochs = tfr_morlet(epochs, frequencies, n_cycles=4., decim=decim,
average=False, return_itc=False, n_jobs=1)
# Baseline power
tfr_epochs.apply_baseline(mode='logratio', baseline=(-.100, 0))
# Crop in time to keep only what is between 0 and 400 ms
evoked.crop(0., 0.5)
tfr_epochs.crop(0., 0.5)
epochs_power = tfr_epochs.data[:, 0, :, :] # take the 1 channel
###############################################################################
# Compute statistic
# -----------------
threshold = 2.5
T_obs, clusters, cluster_p_values, H0 = \
decim = 2
freqs = np.arange(7, 30, 3) # define frequencies of interest
n_cycles = freqs / freqs[0]
zero_mean = False # don't correct morlet wavelet to be of mean zero
# To have a true wavelet zero_mean should be True but here for illustration
# purposes it helps to spot the evoked response.
###############################################################################
# Create TFR representations for all conditions
# ---------------------------------------------
epochs_power = list()
for condition in [epochs[k] for k in event_id]:
this_tfr = tfr_morlet(condition,
freqs,
n_cycles=n_cycles,
decim=decim,
average=False,
zero_mean=zero_mean,
return_itc=False)
this_tfr.apply_baseline(mode='ratio', baseline=(None, 0))
this_power = this_tfr.data[:, 0, :, :] # we only have one channel.
epochs_power.append(this_power)
###############################################################################
# Setup repeated measures ANOVA
# -----------------------------
#
# We will tell the ANOVA how to interpret the data matrix in terms of factors.
# This is done via the factor levels argument which is a list of the number
# factor levels for each factor.
def test_compute_csd():
"""Test computing cross-spectral density from ndarray. """
epochs = _get_data(mode='real')
tmin = 0.04
tmax = 0.15
tmp = np.where(np.logical_and(epochs.times >= tmin,
epochs.times <= tmax))[0]
picks_meeg = mne.pick_types(epochs[0].info, meg=True, eeg=True, eog=False,
ref_meg=False, exclude='bads')
epochs_data = [e[picks_meeg][:, tmp].copy() for e in epochs]
n_trials = len(epochs)
n_series = len(picks_meeg)
X = np.concatenate(epochs_data, axis=0)
X = np.reshape(X, (n_trials, n_series, -1))
X_list = epochs_data
sfreq = epochs.info['sfreq']
# Check data types and sizes are checked
diff_types = [np.random.randn(3, 5), "error"]
err_data = [np.random.randn(3, 5), np.random.randn(2, 4)]
assert_raises(ValueError, csd_array, err_data, sfreq)
assert_raises(ValueError, csd_array, diff_types, sfreq)
assert_raises(ValueError, csd_array, np.random.randn(3), sfreq)
# Check that wrong parameters are recognized
assert_raises(ValueError, csd_array, X, sfreq, mode='notamode')
assert_raises(ValueError, csd_array, X, sfreq, fmin=20, fmax=10)
assert_raises(ValueError, csd_array, X, sfreq, fmin=20, fmax=20.1)
data_csd_mt, freqs_mt = csd_array(X, sfreq, mode='multitaper',
fmin=8, fmax=12)
data_csd_fourier, freqs_fft = csd_array(X, sfreq, mode='fourier',
fmin=8, fmax=12)
# Test as list too
data_csd_mt_list, freqs_mt_list = csd_array(X_list, sfreq,
mode='multitaper',
fmin=8, fmax=12)
data_csd_fourier_list, freqs_fft_list = csd_array(X_list, sfreq,
mode='fourier',
fmin=8, fmax=12)
assert_array_equal(data_csd_mt, data_csd_mt_list)
assert_array_equal(data_csd_fourier, data_csd_fourier_list)
assert_array_equal(freqs_mt, freqs_mt_list)
assert_array_equal(freqs_fft, freqs_fft_list)
# Check shape of the CSD matrix
n_chan = len(epochs.ch_names)
assert_equal(data_csd_mt.shape, (n_chan, n_chan))
assert_equal(data_csd_fourier.shape, (n_chan, n_chan))
# Check if the CSD matrix is hermitian
assert_array_equal(np.tril(data_csd_mt).T.conj(),
np.triu(data_csd_mt))
assert_array_equal(np.tril(data_csd_fourier).T.conj(),
np.triu(data_csd_fourier))
# Computing induced power for comparison
epochs.crop(tmin=0.04, tmax=0.15)
tfr = tfr_morlet(epochs, freqs=[10], n_cycles=0.6, return_itc=False)
power = np.mean(tfr.data, 2)
# Maximum PSD should occur for specific channel
max_ch_power = power.argmax()
max_ch_mt = data_csd_mt.diagonal().argmax()
max_ch_fourier = data_csd_fourier.diagonal().argmax()
assert_equal(max_ch_mt, max_ch_power)
assert_equal(max_ch_fourier, max_ch_power)
# Maximum CSD should occur for specific channel
ch_csd_mt = np.abs(data_csd_mt[max_ch_power])
ch_csd_mt[max_ch_power] = 0.
max_ch_csd_mt = np.argmax(ch_csd_mt)
ch_csd_fourier = np.abs(data_csd_fourier[max_ch_power])
ch_csd_fourier[max_ch_power] = 0.
max_ch_csd_fourier = np.argmax(ch_csd_fourier)
assert_equal(max_ch_csd_mt, max_ch_csd_fourier)
# Check a list of CSD matrices is returned for multiple frequencies within
# a given range when fsum=False
csd_fsum, freqs_fsum = csd_array(X, sfreq, mode='fourier', fmin=8,
fmax=20, fsum=True)
csds, freqs = csd_array(X, sfreq, mode='fourier', fmin=8, fmax=20,
fsum=False)
csd_sum = np.sum(csds, axis=2)
assert_equal(csds.shape[2], 2)
assert_equal(len(freqs), 2)
assert_array_equal(freqs_fsum, freqs)
assert_array_equal(csd_fsum, csd_sum)
# Factor to down-sample the temporal dimension of the TFR computed by
# tfr_morlet.
decim = 2
freqs = np.arange(7, 30, 3) # define frequencies of interest
n_cycles = freqs / freqs[0]
zero_mean = False # don't correct morlet wavelet to be of mean zero
# To have a true wavelet zero_mean should be True but here for illustration
# purposes it helps to spot the evoked response.
###############################################################################
# Create TFR representations for all conditions
# ---------------------------------------------
epochs_power = list()
for condition in [epochs[k] for k in event_id]:
this_tfr = tfr_morlet(condition, freqs, n_cycles=n_cycles,
decim=decim, average=False, zero_mean=zero_mean,
return_itc=False)
this_tfr.apply_baseline(mode='ratio', baseline=(None, 0))
this_power = this_tfr.data[:, 0, :, :] # we only have one channel.
epochs_power.append(this_power)
###############################################################################
# Setup repeated measures ANOVA
# -----------------------------
#
# We will tell the ANOVA how to interpret the data matrix in terms of factors.
# This is done via the factor levels argument which is a list of the number
# factor levels for each factor.
n_conditions = len(epochs.event_id)
n_replications = epochs.events.shape[0] // n_conditions
# Take only one channel
ch_name = 'MEG 1332'
epochs.pick_channels([ch_name])
evoked = epochs.average()
# Factor to down-sample the temporal dimension of the TFR computed by
# tfr_morlet. Decimation occurs after frequency decomposition and can
# be used to reduce memory usage (and possibly computational time of downstream
# operations such as nonparametric statistics) if you don't need high
# spectrotemporal resolution.
decim = 5
freqs = np.arange(8, 40, 2) # define frequencies of interest
sfreq = raw.info['sfreq'] # sampling in Hz
tfr_epochs = tfr_morlet(epochs, freqs, n_cycles=4., decim=decim,
average=False, return_itc=False, n_jobs=1)
# Baseline power
tfr_epochs.apply_baseline(mode='logratio', baseline=(-.100, 0))
# Crop in time to keep only what is between 0 and 400 ms
evoked.crop(0., 0.4)
tfr_epochs.crop(0., 0.4)
epochs_power = tfr_epochs.data[:, 0, :, :] # take the 1 channel
###############################################################################
# Compute statistic
# -----------------
threshold = 2.5
T_obs, clusters, cluster_p_values, H0 = \
#mne.io.Raw.plot(raw=raw_memmaped, duration=2, start=20, n_channels=20, scalings={'eeg': 8000}, remove_dc=True)
id = 1
events_mne = np.c_[np.array(events), np.zeros(len(events), dtype=int), id * np.ones(len(events), dtype=int)]
baseline = (-2.5, -2.3)
event_id = dict(left_paw=id)
epochs = mne.Epochs(raw_memmaped, events_mne, event_id, -3, 3, proj=True, picks=None, baseline=baseline, preload=True, reject=None)
averaged = epochs.average()
power = pickle.load( open(os.path.join(path, "Analysis\\tfr_power.p"), "rb"))
n_cycles = 3
frequencies = np.arange(5, 60, 3)
from mne.time_frequency import tfr_morlet
power, phase_lock = tfr_morlet(epochs, freqs=frequencies, n_cycles=n_cycles, decim=3000, n_jobs=10)
import gui_tfr_viewer
gui_tfr_viewer.TFR_Viewer(power)
box = (0, 0.8, 0, 1.1)
w, h = [.09, .05]
pos = [[ut.normList([x, y], normalizeTo=0.8, vMin=1, vMax=8)[0], ut.normList([x, y], vMin=1, vMax=16)[1], w, h] for [n, s, (x,y)] in cp.sort_index(0, by='Numbers', ascending=True).values]
layout = mne.layouts.Layout(box, pos, cp.sort_index(0, by='Numbers', ascending=True).Strings, cp.sort_index(0, by='Numbers', ascending=True).Numbers, '128ch')
power.plot_topo(picks=None, tmin=-3, tmax=3, fmin=5, fmax=60, vmin=-3e10, vmax=3e10, layout=layout, layout_scale=None)
ax.set_title('Sim: Using S transform, width = {:0.1f}'.format(width))
plt.tight_layout()
###############################################################################
# Morlet Wavelets
# ===============
#
# Finally, show the TFR using morlet wavelets, which are a sinusoidal wave
# with a gaussian envelope. We can control the balance between spectral and
# temporal resolution with the ``n_cycles`` parameter, which defines the
# number of cycles to include in the window.
fig, axs = plt.subplots(1, 3, figsize=(15, 5), sharey=True)
all_n_cycles = [1, 3, freqs / 2.]
for n_cycles, ax in zip(all_n_cycles, axs):
power = tfr_morlet(epochs, freqs=freqs,
n_cycles=n_cycles, return_itc=False)
power.plot([0], baseline=(0., 0.1), mode='mean', vmin=vmin, vmax=vmax,
axes=ax, show=False, colorbar=False)
n_cycles = 'scaled by freqs' if not isinstance(n_cycles, int) else n_cycles
ax.set_title('Sim: Using Morlet wavelet, n_cycles = %s' % n_cycles)
plt.tight_layout()
###############################################################################
# Calculating a TFR without averaging over epochs
# -----------------------------------------------
#
# It is also possible to calculate a TFR without averaging across trials.
# We can do this by using ``average=False``. In this case, an instance of
# :class:`mne.time_frequency.EpochsTFR` is returned.
n_cycles = freqs / 2.
# output
tfr_path = bp.tfr.fpath(subject=subj)
# itc_path_low = bp.itc.fpath(subject=subj, task="low")
# tfr_path_high = bp.tfr.fpath(subject=subj, task="high")
# itc_path_high = bp.itc.fpath(subject=subj, task="high")
ep = read_epochs(ep_path)
freqs = np.arange(**cfg.tfr_config["freqs"])
n_cycles = freqs / 2.0
ep_tfr = tfr_morlet(
ep["answer"],
average=False,
return_itc=False,
freqs=freqs,
n_cycles=n_cycles,
decim=cfg.tfr_config["decim"],
use_fft=cfg.tfr_config["use_fft"],
)
# ep_tfr_high, ep_itc_high = tfr_morlet(
# ep["answer/high"],
# average=True,
# return_itc=True,
# freqs=freqs,
# n_cycles=n_cycles,
# decim=cfg.tfr_config["decim"],
# use_fft=cfg.tfr_config["use_fft"],
# )
tfr_path.parent.mkdir(exist_ok=True, parents=True)
# Time-Frequency: Induced power and inter trial coherence
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#
# Define parameters:
import numpy as np # noqa
n_cycles = 2 # number of cycles in Morlet wavelet
freqs = np.arange(7, 30, 3) # frequencies of interest
##############################################################################
# Compute induced power and phase-locking values and plot gradiometers:
from mne.time_frequency import tfr_morlet # noqa
power, itc = tfr_morlet(epochs,
freqs=freqs,
n_cycles=n_cycles,
return_itc=True,
decim=3,
n_jobs=1)
power.plot([power.ch_names.index('MEG 1332')])
##############################################################################
# Inverse modeling: MNE and dSPM on evoked and raw data
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#
# Import the required functions:
from mne.minimum_norm import apply_inverse, read_inverse_operator # noqa
##############################################################################
# Read the inverse operator:
def test_compute_epochs_csd():
"""Test computing cross-spectral density from epochs
"""
epochs, epochs_sin = _get_data()
# Check that wrong parameters are recognized
assert_raises(ValueError, compute_epochs_csd, epochs, mode='notamode')
assert_raises(ValueError, compute_epochs_csd, epochs, fmin=20, fmax=10)
assert_raises(ValueError, compute_epochs_csd, epochs, fmin=20, fmax=20.1)
assert_raises(ValueError, compute_epochs_csd, epochs, tmin=0.15, tmax=0.1)
assert_raises(ValueError, compute_epochs_csd, epochs, tmin=0, tmax=10)
assert_raises(ValueError, compute_epochs_csd, epochs, tmin=10, tmax=11)
data_csd_mt = compute_epochs_csd(epochs, mode='multitaper', fmin=8,
fmax=12, tmin=0.04, tmax=0.15)
data_csd_fourier = compute_epochs_csd(epochs, mode='fourier', fmin=8,
fmax=12, tmin=0.04, tmax=0.15)
# Check shape of the CSD matrix
n_chan = len(data_csd_mt.ch_names)
assert_equal(data_csd_mt.data.shape, (n_chan, n_chan))
assert_equal(data_csd_fourier.data.shape, (n_chan, n_chan))
# Check if the CSD matrix is hermitian
assert_array_equal(np.tril(data_csd_mt.data).T.conj(),
np.triu(data_csd_mt.data))
assert_array_equal(np.tril(data_csd_fourier.data).T.conj(),
np.triu(data_csd_fourier.data))
# Computing induced power for comparison
epochs.crop(tmin=0.04, tmax=0.15)
tfr = tfr_morlet(epochs, freqs=[10], n_cycles=0.6, return_itc=False)
power = np.mean(tfr.data, 2)
# Maximum PSD should occur for specific channel
max_ch_power = power.argmax()
max_ch_mt = data_csd_mt.data.diagonal().argmax()
max_ch_fourier = data_csd_fourier.data.diagonal().argmax()
assert_equal(max_ch_mt, max_ch_power)
assert_equal(max_ch_fourier, max_ch_power)
# Maximum CSD should occur for specific channel
ch_csd_mt = [np.abs(data_csd_mt.data[max_ch_power][i])
if i != max_ch_power else 0 for i in range(n_chan)]
max_ch_csd_mt = np.argmax(ch_csd_mt)
ch_csd_fourier = [np.abs(data_csd_fourier.data[max_ch_power][i])
if i != max_ch_power else 0 for i in range(n_chan)]
max_ch_csd_fourier = np.argmax(ch_csd_fourier)
assert_equal(max_ch_csd_mt, max_ch_csd_fourier)
# Check a list of CSD matrices is returned for multiple frequencies within
# a given range when fsum=False
csd_fsum = compute_epochs_csd(epochs, mode='fourier', fmin=8, fmax=20,
fsum=True)
csds = compute_epochs_csd(epochs, mode='fourier', fmin=8, fmax=20,
fsum=False)
freqs = [csd.frequencies[0] for csd in csds]
csd_sum = np.zeros_like(csd_fsum.data)
for csd in csds:
csd_sum += csd.data
assert(len(csds) == 2)
assert(len(csd_fsum.frequencies) == 2)
assert_array_equal(csd_fsum.frequencies, freqs)
assert_array_equal(csd_fsum.data, csd_sum)
def test_csd_epochs():
"""Test computing cross-spectral density from epochs."""
epochs = _get_real_data()
# Check that wrong parameters are recognized
with warnings.catch_warnings(record=True): # deprecation
raises(ValueError, csd_epochs, epochs, mode='notamode')
raises(ValueError, csd_epochs, epochs, fmin=20, fmax=10)
raises(ValueError, csd_epochs, epochs, fmin=20, fmax=20.1)
raises(ValueError, csd_epochs, epochs, tmin=0.15, tmax=0.1)
raises(ValueError, csd_epochs, epochs, tmin=0, tmax=10)
raises(ValueError, csd_epochs, epochs, tmin=10, tmax=11)
# Test deprecation warning
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter('always')
csd_mt = csd_epochs(epochs, mode='multitaper', fmin=8, fmax=12,
tmin=0.04, tmax=0.15)
assert len([w for w in ws
if issubclass(w.category, DeprecationWarning)]) == 1
with warnings.catch_warnings(record=True): # deprecation
csd_fourier = csd_epochs(epochs, mode='fourier', fmin=8, fmax=12,
tmin=0.04, tmax=0.15)
# Check shape of the CSD matrix
n_chan = len(csd_mt.ch_names)
csd_mt_data = csd_mt.get_data()
csd_fourier_data = csd_fourier.get_data()
assert csd_mt_data.shape == (n_chan, n_chan)
assert csd_fourier_data.shape == (n_chan, n_chan)
# Check if the CSD matrix is hermitian
assert_array_equal(np.tril(csd_mt_data).T.conj(),
np.triu(csd_mt_data))
assert_array_equal(np.tril(csd_fourier_data).T.conj(),
np.triu(csd_fourier_data))
# Computing induced power for comparison
epochs.crop(tmin=0.04, tmax=0.15)
tfr = tfr_morlet(epochs, freqs=[10], n_cycles=0.6, return_itc=False)
power = np.mean(tfr.data, 2)
# Maximum PSD should occur for specific channel
max_ch_power = power.argmax()
max_ch_mt = csd_mt_data.diagonal().argmax()
max_ch_fourier = csd_fourier_data.diagonal().argmax()
assert max_ch_mt == max_ch_power
assert max_ch_fourier == max_ch_power
# Maximum CSD should occur for specific channel
ch_csd_mt = np.abs(csd_mt_data[max_ch_power])
ch_csd_mt[max_ch_power] = 0.
max_ch_csd_mt = np.argmax(ch_csd_mt)
ch_csd_fourier = np.abs(csd_fourier_data[max_ch_power])
ch_csd_fourier[max_ch_power] = 0.
max_ch_csd_fourier = np.argmax(ch_csd_fourier)
assert max_ch_csd_mt == max_ch_csd_fourier
# Check a list of CSD matrices is returned for multiple frequencies within
# a given range when fsum=False
with warnings.catch_warnings(record=True): # deprecation
csd_fsum = csd_epochs(epochs, mode='fourier', fmin=8, fmax=20,
fsum=True)
csds = csd_epochs(epochs, mode='fourier', fmin=8, fmax=20, fsum=False)
assert len(csd_fsum.frequencies) == 1
assert len(csds.frequencies) == 2
assert_array_equal(csd_fsum.frequencies[0], csds.frequencies)
csd_sum = csds._data.sum(axis=1, keepdims=True)
assert_array_equal(csd_fsum._data, csd_sum)
def test_compute_csd():
"""Test computing cross-spectral density from ndarray."""
epochs = _get_real_data()
tmin = 0.04
tmax = 0.15
tmp = np.where(np.logical_and(epochs.times >= tmin,
epochs.times <= tmax))[0]
picks_meeg = mne.pick_types(epochs[0].info,
meg=True,
eeg=True,
eog=False,
ref_meg=False,
exclude='bads')
epochs_data = [e[picks_meeg][:, tmp].copy() for e in epochs]
n_trials = len(epochs)
n_series = len(picks_meeg)
X = np.concatenate(epochs_data, axis=0)
X = np.reshape(X, (n_trials, n_series, -1))
X_list = epochs_data
sfreq = epochs.info['sfreq']
# Check data types and sizes are checked
diff_types = [np.random.randn(3, 5), "error"]
err_data = [np.random.randn(3, 5), np.random.randn(2, 4)]
raises(ValueError, csd_array, err_data, sfreq)
raises(ValueError, csd_array, diff_types, sfreq)
raises(ValueError, csd_array, np.random.randn(3), sfreq)
# Check that wrong parameters are recognized
raises(ValueError, csd_array, X, sfreq, mode='notamode')
raises(ValueError, csd_array, X, sfreq, fmin=20, fmax=10)
raises(ValueError, csd_array, X, sfreq, fmin=20, fmax=20.1)
# Test deprecation warning
with warnings.catch_warnings(record=True) as ws:
warnings.simplefilter('always')
csd_mt = csd_array(X, sfreq, mode='multitaper', fmin=8, fmax=12)
assert len([w for w in ws
if issubclass(w.category, DeprecationWarning)]) == 1
csd_fourier = csd_array(X, sfreq, mode='fourier', fmin=8, fmax=12)
# Test as list too
csd_mt_list = csd_array(X_list, sfreq, mode='multitaper', fmin=8, fmax=12)
csd_fourier_list = csd_array(X_list,
sfreq,
mode='fourier',
fmin=8,
fmax=12)
assert_array_equal(csd_mt._data, csd_mt_list._data)
assert_array_equal(csd_fourier._data, csd_fourier_list._data)
assert_array_equal(csd_mt.frequencies, csd_mt_list.frequencies)
assert_array_equal(csd_fourier.frequencies, csd_fourier_list.frequencies)
# Check shape of the CSD matrix
n_chan = len(epochs.ch_names)
csd_mt_data = csd_mt.get_data()
csd_fourier_data = csd_fourier.get_data()
assert csd_mt_data.shape == (n_chan, n_chan)
assert csd_fourier_data.shape == (n_chan, n_chan)
# Check if the CSD matrix is hermitian
assert_array_equal(np.tril(csd_mt_data).T.conj(), np.triu(csd_mt_data))
assert_array_equal(
np.tril(csd_fourier_data).T.conj(), np.triu(csd_fourier_data))
# Computing induced power for comparison
epochs.crop(tmin=0.04, tmax=0.15)
tfr = tfr_morlet(epochs, freqs=[10], n_cycles=0.6, return_itc=False)
power = np.mean(tfr.data, 2)
# Maximum PSD should occur for specific channel
max_ch_power = power.argmax()
max_ch_mt = csd_mt_data.diagonal().argmax()
max_ch_fourier = csd_fourier_data.diagonal().argmax()
assert max_ch_mt == max_ch_power
assert max_ch_fourier == max_ch_power
# Maximum CSD should occur for specific channel
ch_csd_mt = np.abs(csd_mt_data[max_ch_power])
ch_csd_mt[max_ch_power] = 0.
max_ch_csd_mt = np.argmax(ch_csd_mt)
ch_csd_fourier = np.abs(csd_fourier_data[max_ch_power])
ch_csd_fourier[max_ch_power] = 0.
max_ch_csd_fourier = np.argmax(ch_csd_fourier)
assert max_ch_csd_mt == max_ch_csd_fourier
# Check a list of CSD matrices is returned for multiple frequencies within
# a given range when fsum=False
csd_fsum = csd_array(X, sfreq, mode='fourier', fmin=8, fmax=20, fsum=True)
csds = csd_array(X, sfreq, mode='fourier', fmin=8, fmax=20, fsum=False)
assert csds._data.shape[1] == 2
assert len(csds.frequencies) == 2
assert_array_equal(csd_fsum.frequencies[0], csds.frequencies)
assert_array_equal(csd_fsum._data, csds._data.sum(axis=1, keepdims=True))
sesh = session_list[j]
epoch_power = list()
epoch_itc = list()
for i in range(n_subj):
ch_name = ['FZ'] ###change this to PZ or CZ or FZ
subj = subj_list[i]
import warnings
warnings.filterwarnings('ignore')
fname = word_epoch_dir + "%s_%s_%s_word-epo.fif" % (subj, sesh,
fname_suffix)
this_epoch = mne.read_epochs(fname, preload=True)
this_epoch.pick_channels(ch_name)
this_epoch = this_epoch[word]
power, itc = tfr_morlet(this_epoch,
freqs=freqs,
decim=decim,
n_cycles=n_cycles,
use_fft=True,
return_itc=True)
power.apply_baseline(mode='ratio', baseline=(-0.2, 0))
itc.apply_baseline(mode='ratio', baseline=(-0.2, 0))
epoch_power.append(power.data)
print np.shape(epoch_power)
epoch_itc.append(itc.data)
epochs_power = np.append(epochs_power, epoch_power, axis=1)
epochs_itc = np.append(epochs_itc, epoch_itc, axis=1)
print "epochs_power", np.shape(epochs_power)
n_conditions = 4 #number of conditions
n_replications = n_subj
factor_levels = [2, 2] # number of levels in each factor
picks=picks, baseline=(None, 0),
reject=reject, preload=True)
epochs_condition_2.pick_channels([ch_name])
###############################################################################
# Factor to downsample the temporal dimension of the TFR computed by
# tfr_morlet. Decimation occurs after frequency decomposition and can
# be used to reduce memory usage (and possibly comptuational time of downstream
# operations such as nonparametric statistics) if you don't need high
# spectrotemporal resolution.
decim = 2
freqs = np.arange(7, 30, 3) # define frequencies of interest
n_cycles = 1.5
tfr_epochs_1 = tfr_morlet(epochs_condition_1, freqs,
n_cycles=n_cycles, decim=decim,
return_itc=False, average=False)
tfr_epochs_2 = tfr_morlet(epochs_condition_2, freqs,
n_cycles=n_cycles, decim=decim,
return_itc=False, average=False)
tfr_epochs_1.apply_baseline(mode='ratio', baseline=(None, 0))
tfr_epochs_2.apply_baseline(mode='ratio', baseline=(None, 0))
epochs_power_1 = tfr_epochs_1.data[:, 0, :, :] # only 1 channel as 3D matrix
epochs_power_2 = tfr_epochs_2.data[:, 0, :, :] # only 1 channel as 3D matrix
###############################################################################
# Compute statistic
# -----------------
