def test_wavelets_with_event_data_chopper(self):
wf_session = MorletWaveletFilter(
time_series=self.session_eegs[:, :, :self.session_eegs.shape[2] / 4],
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
verbose=True
)
pow_wavelet_session, phase_wavelet_session = wf_session.filter()
sedc = DataChopper(events=self.base_events, session_data=pow_wavelet_session, start_time=self.start_time,
end_time=self.end_time, buffer_time=self.buffer_time)
chopped_session_pow_wavelet = sedc.filter()
# removing buffer
chopped_session_pow_wavelet = chopped_session_pow_wavelet[:, :, :, 500:-500]
wf = MorletWaveletFilter(time_series=self.base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
verbose=True
)
pow_wavelet, phase_wavelet = wf.filter()
pow_wavelet = pow_wavelet[:, :, :, 500:-500]
assert_array_almost_equal(
(chopped_session_pow_wavelet.data - pow_wavelet.data) / pow_wavelet.data,
np.zeros_like(pow_wavelet),
decimal=5
)
def test_classifier(self):
m2b = MonopolarToBipolarMapper(time_series=self.base_eegs, bipolar_pairs=self.bipolar_pairs)
bp_eegs = m2b.filter()
wf = MorletWaveletFilter(time_series=bp_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
verbose=True
)
pow_wavelet, phase_wavelet = wf.filter()
pow_wavelet = pow_wavelet.remove_buffer(duration=1.0)
print pow_wavelet
np.log10(pow_wavelet.data, out=pow_wavelet.data)
print pow_wavelet
mean_powers = pow_wavelet.mean(dim='time')
print mean_powers
# sess_pow_mat_post[ev,i,:] = np.nanmean(pow_ev_stripped, axis=1)
print
def test_MorletWaveletFilter(self):
mwf = MorletWaveletFilter(time_series=self.time_series,
freqs=np.array([10., 20., 40.]),
width=4)
power, phase = mwf.filter()
assert power.shape == (3, 1000)
assert phase.shape == (3, 1000)
def compute_wavelets(evs):
bp_eegs = get_bp_data(evs)
wf = MorletWaveletFilter(time_series=bp_eegs,
freqs=freqs,
output='power',
frequency_dim_pos=0,
verbose=True
)
pow_wavelet, phase_wavelet = wf.filter()
pow_wavelet = pow_wavelet.remove_buffer(duration=buffer_time)
return pow_wavelet
def test_wavelets(self):
eegs = self.eegs[:, :, :-1]
base_eegs = self.base_eegs
wf = MorletWaveletFilter(
time_series=base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
)
pow_wavelet, phase_wavelet = wf.filter()
print('pow_wavelet=', pow_wavelet)
from ptsa.wavelet import phase_pow_multi
pow_wavelet_ptsa_orig = phase_pow_multi(freqs=np.logspace(
np.log10(3), np.log10(180), 8),
dat=eegs,
to_return='power')
print('pow_wavelets_ptsa_orig=', pow_wavelet_ptsa_orig)
# import matplotlib;
# matplotlib.use('Qt4Agg')
#
#
# import matplotlib.pyplot as plt
# plt.get_current_fig_manager().window.raise_()
#
wavelet_1 = pow_wavelet[0, 0, 0, 500:-500]
wavelet_2 = pow_wavelet_ptsa_orig[0, 0, 0, 500:-500]
#
# plt.plot(np.arange(wavelet_1.shape[0])-1,wavelet_1,'k')
# plt.plot(np.arange(wavelet_2.shape[0])-1,wavelet_2,'r--')
#
# plt.show()
assert_array_equal(eegs, base_eegs.data)
# assert_array_equal(wavelet_1, wavelet_2)
# assert_array_almost_equal((wavelet_1-wavelet_2)/wavelet_1, np.zeros_like(wavelet_1), decimal=4)
# assert_array_almost_equal((pow_wavelet_ptsa_orig-pow_wavelet)/pow_wavelet_ptsa_orig, np.zeros_like(pow_wavelet), decimal=4)
assert_array_almost_equal(
(pow_wavelet_ptsa_orig - pow_wavelet) / pow_wavelet_ptsa_orig,
np.zeros_like(pow_wavelet),
decimal=6)
freq_num = 7
assert_array_equal((pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500] -
pow_wavelet[freq_num, :, :, 500:-500]) /
pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500],
np.zeros_like(pow_wavelet[freq_num, :, :,
500:-500]))
def test_wavelets(self):
eegs = self.eegs[:, :, :-1]
base_eegs = self.base_eegs
wf = MorletWaveletFilter(time_series=base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
)
pow_wavelet, phase_wavelet = wf.filter()
print 'pow_wavelet=',pow_wavelet
from ptsa.wavelet import phase_pow_multi
pow_wavelet_ptsa_orig = phase_pow_multi(freqs=np.logspace(np.log10(3), np.log10(180), 8), dat=eegs,to_return='power')
print 'pow_wavelets_ptsa_orig=',pow_wavelet_ptsa_orig
# import matplotlib;
# matplotlib.use('Qt4Agg')
#
#
# import matplotlib.pyplot as plt
# plt.get_current_fig_manager().window.raise_()
#
wavelet_1 = pow_wavelet[0,0,0,500:-500]
wavelet_2 = pow_wavelet_ptsa_orig[0,0,0,500:-500]
#
# plt.plot(np.arange(wavelet_1.shape[0])-1,wavelet_1,'k')
# plt.plot(np.arange(wavelet_2.shape[0])-1,wavelet_2,'r--')
#
# plt.show()
assert_array_equal(eegs, base_eegs.data)
# assert_array_equal(wavelet_1, wavelet_2)
# assert_array_almost_equal((wavelet_1-wavelet_2)/wavelet_1, np.zeros_like(wavelet_1), decimal=4)
# assert_array_almost_equal((pow_wavelet_ptsa_orig-pow_wavelet)/pow_wavelet_ptsa_orig, np.zeros_like(pow_wavelet), decimal=4)
assert_array_almost_equal(
(pow_wavelet_ptsa_orig-pow_wavelet)/pow_wavelet_ptsa_orig,
np.zeros_like(pow_wavelet), decimal=6)
freq_num = 7
assert_array_equal(
(pow_wavelet_ptsa_orig[freq_num,:,:,500:-500]-pow_wavelet[freq_num,:,:,500:-500])/pow_wavelet_ptsa_orig[freq_num,:,:,500:-500],
np.zeros_like(pow_wavelet[freq_num,:,:,500:-500]))
def compute_continuous_wavelets(dataroot):
session_reader = EEGReader(session_dataroot=dataroot, channels=monopolar_channels)
session_eegs = session_reader.read()
m2b = MonopolarToBipolarMapper(time_series=session_eegs, bipolar_pairs=bipolar_pairs)
session_bp_eegs = m2b.filter()
wf = MorletWaveletFilter(time_series=session_bp_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
verbose=True
)
pow_wavelet_session, phase_wavelet_session = wf.filter()
return pow_wavelet_session
def test_wavelets_python_cpp(self):
from ptsa.data.filters import MorletWaveletFilterCpp
print('hello')
wf = MorletWaveletFilter(
time_series=self.base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
)
pow_wavelet, phase_wavelet = wf.filter()
wf_cpp = MorletWaveletFilterCpp(time_series=self.base_eegs,
freqs=np.logspace(
np.log10(3), np.log10(180), 8),
output='power',
cpus=4)
pow_wavelet_cpp, phase_wavelet_cpp = wf_cpp.filter()
decimal = 2
freq_num = 0
from scipy.stats import describe
desc_cpp = describe(pow_wavelet_cpp[freq_num, :, :, 500:-500])
desc_py = describe(pow_wavelet[freq_num, :, :, 500:-500])
try:
assert_array_almost_equal(
(pow_wavelet_cpp[freq_num, :, :, 500:-500] -
pow_wavelet[freq_num, :, :, 500:-500]) /
pow_wavelet_cpp[freq_num, :, :, 500:-500],
np.zeros_like(pow_wavelet_cpp[freq_num, :, :, 500:-500]),
decimal=decimal)
except AssertionError:
print(
'WARNING: Cpp and Python wavelets are not within 1%. Will try weaker test '
)
mean_min = np.min((desc_cpp.mean - desc_py.mean) / desc_cpp.mean)
mean_max = np.max((desc_cpp.mean - desc_py.mean) / desc_cpp.mean)
print('mean_max=', mean_max)
print('mean_min=', mean_min)
self.assertTrue(np.abs(mean_max) < 0.05)
self.assertTrue(np.abs(mean_min) < 0.05)
def test_classifier(self):
m2b = MonopolarToBipolarMapper(time_series=self.base_eegs, bipolar_pairs=self.bipolar_pairs)
bp_eegs = m2b.filter()
wf = MorletWaveletFilter(time_series=bp_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
verbose=True
)
pow_wavelet, phase_wavelet = wf.filter()
pow_wavelet = pow_wavelet.remove_buffer(duration=1.0)
print(pow_wavelet)
np.log10(pow_wavelet.data, out=pow_wavelet.data)
print(pow_wavelet)
mean_powers = pow_wavelet.mean(dim='time')
print(mean_powers)
def test_wavelets_python_cpp(self):
from ptsa.data.filters import MorletWaveletFilterCpp
print('hello')
wf = MorletWaveletFilter(time_series=self.base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
)
pow_wavelet, phase_wavelet = wf.filter()
wf_cpp = MorletWaveletFilterCpp(time_series=self.base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
cpus=4
)
pow_wavelet_cpp, phase_wavelet_cpp = wf_cpp.filter()
decimal = 2
freq_num=0
from scipy.stats import describe
desc_cpp = describe(pow_wavelet_cpp[freq_num,:,:,500:-500])
desc_py = describe(pow_wavelet[freq_num,:,:,500:-500])
try:
assert_array_almost_equal(
(pow_wavelet_cpp[freq_num,:,:,500:-500]-pow_wavelet[freq_num,:,:,500:-500])/pow_wavelet_cpp[freq_num,:,:,500:-500],
np.zeros_like(pow_wavelet_cpp[freq_num,:,:,500:-500]), decimal=decimal)
except AssertionError:
print('WARNING: Cpp and Python wavelets are not within 1%. Will try weaker test ')
mean_min = np.min((desc_cpp.mean-desc_py.mean)/desc_cpp.mean)
mean_max = np.max((desc_cpp.mean-desc_py.mean)/desc_cpp.mean)
print('mean_max=',mean_max)
print('mean_min=',mean_min)
self.assertTrue(np.abs(mean_max)<0.05)
self.assertTrue(np.abs(mean_min)<0.05)
def test_wavelets_resample(self):
eegs = self.eegs[:, :, :-1]
base_eegs = self.base_eegs
wf = MorletWaveletFilter(time_series=base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
)
pow_wavelet, phase_wavelet = wf.filter()
resample_filter = ResampleFilter(time_series=pow_wavelet, resamplerate=100.0)
pow_wavelet_resampled = resample_filter.filter()
print pow_wavelet_resampled
pow_wavelet_resampled_direct = pow_wavelet.resampled(resampled_rate=100.0)
print pow_wavelet_resampled_direct
def test_wavelets_with_event_data_chopper(self):
wf_session = MorletWaveletFilter(
time_series=self.session_eegs[:, :, :self.session_eegs.shape[2] / 4],
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
verbose=True
)
pow_wavelet_session, phase_wavelet_session = wf_session.filter()
sedc = DataChopper(events=self.base_events, session_data=pow_wavelet_session, start_time=self.start_time,
end_time=self.end_time, buffer_time=self.buffer_time)
chopped_session_pow_wavelet = sedc.filter()
# removing buffer
chopped_session_pow_wavelet = chopped_session_pow_wavelet[:, :, :, 500:-500]
wf = MorletWaveletFilter(time_series=self.base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
verbose=True
)
pow_wavelet, phase_wavelet = wf.filter()
pow_wavelet = pow_wavelet[:, :, :, 500:-500]
assert_array_almost_equal(
(chopped_session_pow_wavelet.data - pow_wavelet.data) / pow_wavelet.data,
np.zeros_like(pow_wavelet),
decimal=5
)
def test_wavelets_synthetic_data(self):
samplerate = 1000.
frequency = 180.0
modulation_frequency = 80.0
duration = 1.0
n_points = int(np.round(duration * samplerate))
x = np.arange(n_points, dtype=np.float)
y = np.sin(x * (2 * np.pi * frequency / n_points))
y_mod = np.sin(x * (2 * np.pi * frequency / n_points)) * np.sin(
x * (2 * np.pi * modulation_frequency / n_points))
ts = TimeSeriesX(y, dims=['time'], coords=[x])
ts['samplerate'] = samplerate
ts.attrs['samplerate'] = samplerate
frequencies = [10.0, 30.0, 50.0, 80., 120., 180., 250.0, 300.0, 500.]
for frequency in frequencies:
wf = MorletWaveletFilter(time_series=ts,
freqs=np.array([frequency]),
output='both',
frequency_dim_pos=0,
verbose=True)
pow_wavelet, phase_wavelet = wf.filter()
from ptsa.wavelet import phase_pow_multi
pow_wavelet_ptsa_orig = phase_pow_multi(freqs=[frequency],
samplerates=samplerate,
dat=ts.data,
to_return='power')
assert_array_almost_equal(
(pow_wavelet_ptsa_orig - pow_wavelet) / pow_wavelet_ptsa_orig,
np.zeros_like(pow_wavelet),
decimal=6)
def test_wavelets_resample(self):
eegs = self.eegs[:, :, :-1]
base_eegs = self.base_eegs
wf = MorletWaveletFilter(
time_series=base_eegs,
freqs=np.logspace(np.log10(3), np.log10(180), 8),
output='power',
frequency_dim_pos=0,
)
pow_wavelet, phase_wavelet = wf.filter()
resample_filter = ResampleFilter(time_series=pow_wavelet,
resamplerate=100.0)
pow_wavelet_resampled = resample_filter.filter()
print(pow_wavelet_resampled)
pow_wavelet_resampled_direct = pow_wavelet.resampled(
resampled_rate=100.0)
print(pow_wavelet_resampled_direct)
def test_wavelets_synthetic_data(self):
samplerate = 1000.
frequency = 180.0
modulation_frequency = 80.0
duration = 1.0
n_points = int(np.round(duration*samplerate))
x = np.arange(n_points, dtype=np.float)
y = np.sin(x*(2*np.pi*frequency/n_points))
y_mod = np.sin(x*(2*np.pi*frequency/n_points))* np.sin(x*(2*np.pi*modulation_frequency/n_points))
ts = TimeSeriesX(y, dims=['time'], coords=[x])
ts['samplerate']=samplerate
ts.attrs['samplerate'] = samplerate
frequencies = [ 10.0, 30.0, 50.0, 80., 120., 180., 250.0 , 300.0, 500.]
for frequency in frequencies:
wf = MorletWaveletFilter(time_series=ts,
freqs=np.array([frequency]),
output='both',
frequency_dim_pos=0,
verbose=True
)
pow_wavelet, phase_wavelet = wf.filter()
from ptsa.wavelet import phase_pow_multi
pow_wavelet_ptsa_orig = phase_pow_multi(freqs=[frequency],samplerates=samplerate, dat=ts.data,to_return='power')
assert_array_almost_equal(
(pow_wavelet_ptsa_orig-pow_wavelet)/pow_wavelet_ptsa_orig,
np.zeros_like(pow_wavelet), decimal=6)
def test_wavelets_cpp(self):
eegs = self.eegs[:, :, :-1]
base_eegs = self.base_eegs
sys.path.append('/Users/m/src/morlet_git_install')
import morlet
num_freqs = 8
f_min = 3.0
f_max = 180.0
signal_length = base_eegs.shape[-1]
morlet_transform = morlet.MorletWaveletTransform()
samplerate = float(base_eegs['samplerate'])
morlet_transform.init(5, f_min, f_max, num_freqs, samplerate , signal_length)
signal = base_eegs[0:1,0:1,:]
signal_orig_eegs = eegs[0:1,0:1,:]
pow_wavelets_cpp = np.empty(shape=(base_eegs.shape[-1]*num_freqs,), dtype=np.float)
# for i in xrange(num_of_iterations):
# morlet_transform.multiphasevec(signal,powers)
morlet_transform.multiphasevec(signal.data.flatten(),pow_wavelets_cpp)
pow_wavelets_cpp = pow_wavelets_cpp.reshape(8,pow_wavelets_cpp.shape[0]/8)
wf = MorletWaveletFilter(time_series=signal,
freqs=np.logspace(np.log10(f_min), np.log10(f_max), num_freqs),
output='power',
frequency_dim_pos=0,
)
pow_wavelet, phase_wavelet = wf.filter()
from ptsa.wavelet import phase_pow_multi
pow_wavelet_ptsa_orig = phase_pow_multi(freqs=np.logspace(np.log10(3), np.log10(180), 8), dat=signal_orig_eegs,to_return='power')
freq_num = 0
decimal = 1
assert_array_almost_equal(
(np.squeeze(pow_wavelet[freq_num,:,:,500:-500])-np.squeeze(pow_wavelet_ptsa_orig[freq_num,:,:,500:-500]))/np.squeeze(pow_wavelet_ptsa_orig[freq_num,:,:,500:-500]),
np.zeros_like(np.squeeze(pow_wavelet_ptsa_orig[freq_num,:,:,500:-500])), decimal=decimal)
assert_array_almost_equal(
(pow_wavelets_cpp[freq_num,500:-500]-np.squeeze(pow_wavelet[freq_num,:,:,500:-500]))/pow_wavelets_cpp[freq_num,500:-500],
np.zeros_like(pow_wavelets_cpp[freq_num,500:-500]), decimal=decimal)
#
assert_array_almost_equal(
(pow_wavelets_cpp[freq_num,500:-500]-np.squeeze(pow_wavelet_ptsa_orig[freq_num,:,:,500:-500]))/pow_wavelets_cpp[freq_num,500:-500],
np.zeros_like(np.squeeze(pow_wavelet_ptsa_orig[freq_num,:,:,500:-500])), decimal=decimal)
from ptsa.wavelet import phase_pow_multi
def test_wavelets_cpp(self):
eegs = self.eegs[:, :, :-1]
base_eegs = self.base_eegs
# if not sys.platform.startswith('win'):
# sys.path.append('/Users/m/src/morlet_git_install')
import ptsa.extensions.morlet as morlet
num_freqs = 8
f_min = 3.0
f_max = 180.0
signal_length = base_eegs.shape[-1]
morlet_transform = morlet.MorletWaveletTransform()
samplerate = float(base_eegs['samplerate'])
morlet_transform.init(5, f_min, f_max, num_freqs, samplerate,
signal_length)
signal = base_eegs[0:1, 0:1, :]
signal_orig_eegs = eegs[0:1, 0:1, :]
pow_wavelets_cpp = np.empty(shape=(base_eegs.shape[-1] * num_freqs, ),
dtype=np.float)
# for i in xrange(num_of_iterations):
# morlet_transform.multiphasevec(signal,powers)
morlet_transform.multiphasevec(signal.data.flatten(), pow_wavelets_cpp)
pow_wavelets_cpp = pow_wavelets_cpp.reshape(
8, pow_wavelets_cpp.shape[0] / 8)
wf = MorletWaveletFilter(
time_series=signal,
freqs=np.logspace(np.log10(f_min), np.log10(f_max), num_freqs),
output='power',
frequency_dim_pos=0,
)
pow_wavelet, phase_wavelet = wf.filter()
from ptsa.wavelet import phase_pow_multi
pow_wavelet_ptsa_orig = phase_pow_multi(freqs=np.logspace(
np.log10(3), np.log10(180), 8),
dat=signal_orig_eegs,
to_return='power')
freq_num = 0
decimal = 1
assert_array_almost_equal(
(np.squeeze(pow_wavelet[freq_num, :, :, 500:-500]) -
np.squeeze(pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500])) /
np.squeeze(pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500]),
np.zeros_like(
np.squeeze(pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500])),
decimal=decimal)
assert_array_almost_equal(
(pow_wavelets_cpp[freq_num, 500:-500] -
np.squeeze(pow_wavelet[freq_num, :, :, 500:-500])) /
pow_wavelets_cpp[freq_num, 500:-500],
np.zeros_like(pow_wavelets_cpp[freq_num, 500:-500]),
decimal=decimal)
#
assert_array_almost_equal(
(pow_wavelets_cpp[freq_num, 500:-500] -
np.squeeze(pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500])) /
pow_wavelets_cpp[freq_num, 500:-500],
np.zeros_like(
np.squeeze(pow_wavelet_ptsa_orig[freq_num, :, :, 500:-500])),
decimal=decimal)
from ptsa.wavelet import phase_pow_multi
def test_MorletWaveletFilter(self):
mwf = MorletWaveletFilter(time_series=self.time_series,freqs=np.array([10.,20.,40.]),width=4)
power,phase= mwf.filter()
assert power.shape == (3,1000)
assert phase.shape == (3,1000)
