def test_detect_bursts_consistent():
"""
Confirm consistency in burst detection results on a generated neural signal
"""
# Load data and ground-truth filtered signal
x = _load_example_data(data_idx=1)
Fs = 1000
f_range = (13, 30)
f_oi = np.floor(np.mean(f_range))
f_range_slope = (3, 50)
f_slope_excl = f_range
# Load past burst findings
bursting_true_deviation = np.load(os.path.dirname(neurodsp.__file__) +
'/tests/data/sample_data_1_burst_deviation.npy')
bursting_true_bosc = np.load(os.path.dirname(neurodsp.__file__) +
'/tests/data/sample_data_1_burst_bosc.npy')
# Detect bursts with different algorithms
bursting_deviation = neurodsp.detect_bursts(x, Fs, f_range, 'deviation',
dual_thresh=(0.9, 2.0))
bursting_bosc = neurodsp.detect_bursts_bosc(x, Fs, f_oi, f_range_slope, f_slope_excl)
assert np.isclose(np.sum(bursting_deviation - bursting_true_deviation), 0)
assert np.isclose(np.sum(bursting_bosc - bursting_true_bosc), 0)
def test_swm_consistent():
"""
Confirm consistency in beta bandpass filter results on a neural signal
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
Fs = 1000
# Load ground truth lagged coherence
avg_window_true = np.load(
os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_' +
str(data_idx) + '_swm.npy')
# Compute lagged coherence
L = .055
G = .2
np.random.seed(1)
avg_window, _, _ = shape.sliding_window_matching(x,
Fs,
L,
G,
max_iterations=500)
# Compute difference between current and past signals
signal_diff = avg_window - avg_window_true
assert np.allclose(np.sum(np.abs(signal_diff)), 0, atol=10**-5)
def test_interpolated_phase_consistent():
"""
Confirm consistency in beta bandpass filter results on a neural signal
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
Fs = 1000
f_range = (13, 30)
# Load ground truth phase time series
phaPTRD_true = np.load(
os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_' +
str(data_idx) + '_phaPTRD.npy')
# Compute phase time series
Ps, Ts = shape.find_extrema(x, Fs, f_range)
zeroxR, zeroxD = shape.find_zerox(x, Ps, Ts)
phaPTRD = shape.extrema_interpolated_phase(x,
Ps,
Ts,
zeroxR=zeroxR,
zeroxD=zeroxD)
# Compute difference between current and past filtered signals
signal_diff = phaPTRD - phaPTRD_true
assert np.allclose(np.sum(np.abs(signal_diff)), 0, atol=10**-5)
def test_comodulogram_consistent():
"""
Confirm consistency in estimation of pac comodulogram
with computations in previous versions
"""
# Compute pacs
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
Fs = 1000
# Parameters for comodulogram function
f_pha_bin_edges = np.arange(2, 42, 2)
f_amp_bin_edges = np.arange(20, 200, 4)
N_cycles_pha = 5
N_cycles_amp = 11
# Compute comodulogram
comod = neurodsp.compute_pac_comodulogram(x, x, Fs,
f_pha_bin_edges, f_amp_bin_edges,
N_cycles_pha=N_cycles_pha,
N_cycles_amp=N_cycles_amp,
pac_method='ozkurt')
# Load ground truth comodulogram
comod_true = np.load(os.path.dirname(neurodsp.__file__) +
'/tests/data/sample_data_' + str(data_idx) + '_comod.npy')
# Compute difference between current and past signals
assert np.allclose(np.sum(np.abs(comod - comod_true)), 0, atol=10 ** -5)
def test_cyclefeatures_consistent():
"""
Confirm consistency in peak finding
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
Fs = 1000
f_range = (13, 30)
# Load ground truth lagged coherence
df_true = pd.read_csv(
os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_' +
str(data_idx) + '_cyclefeatures.csv')
# Compute lagged coherence
true_oscillating_periods_kwargs = {
'restrict_by_amplitude_consistency': False,
'restrict_by_period_consistency': False,
'amplitude_fraction_threshold': .3
}
df = shape.features_by_cycle(
x,
Fs,
f_range,
center_extrema='T',
estimate_oscillating_periods=True,
true_oscillating_periods_kwargs=true_oscillating_periods_kwargs)
# Compute difference between calculated and ground truth values for each column
for k in df.keys():
signal_diff = df[k].values - df_true[k].values
assert np.allclose(np.sum(np.abs(signal_diff)), 0, atol=10**-5)
def test_psd():
"""
Confirm consistency in PSD computation
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
fs = 1000.
# load "ground truth" PSDs
gt_psd = np.load(
os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_' +
str(data_idx) + '_psd.npz')
# try all 3 different methods
freq, Pmean = spectral.psd(x, fs, method='mean', nperseg=fs * 2)
freq, Pmed = spectral.psd(x, fs, method='median', nperseg=fs * 2)
freqmf, Pmedfilt = spectral.psd(x, fs, method='medfilt')
# compute the difference
assert np.allclose(np.sum(np.abs(gt_psd['PSDmean'] - Pmean)),
0,
atol=10**-5)
assert np.allclose(np.sum(np.abs(gt_psd['PSDmed'] - Pmed)), 0, atol=10**-5)
assert np.allclose(np.sum(np.abs(gt_psd['PSDmedfilt'] - Pmedfilt)),
0,
atol=10**-5)
assert np.allclose(np.sum(np.abs(gt_psd['freq'] - freq)), 0, atol=10**-5)
assert np.allclose(np.sum(np.abs(gt_psd['freqmf'] - freqmf)),
0,
atol=10**-5)
def test_pac_consistent():
"""
Confirm consistency in estimation of pac
with computations in previous versions
"""
# Compute pacs
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
Fs = 1000
# Compute pacs
all_pac_methods = ['ozkurt', 'plv', 'glm', 'tort', 'canolty']
f_range_lo = (13, 30)
f_range_hi = (50, 200)
N_seconds_lo = .25
N_seconds_hi = .2
np.random.seed(0)
pacs = np.zeros(len(all_pac_methods))
for i, m in enumerate(all_pac_methods):
pacs[i] = neurodsp.compute_pac(x, x, Fs, f_range_lo, f_range_hi,
N_seconds_lo=N_seconds_lo, N_seconds_hi=N_seconds_hi,
pac_method=m)
# Load ground truth pacs
pacs_true = np.load(os.path.dirname(neurodsp.__file__) +
'/tests/data/sample_data_' + str(data_idx) + '_pacs.npy')
# Compute difference between current and past signals
assert np.allclose(np.sum(np.abs(pacs - pacs_true)), 0, atol=10 ** -5)
def test_bandpass_filter_consistent():
"""
Confirm consistency in beta bandpass filter results on a neural signal
"""
# Load data and ground-truth filtered signal
x, x_filt_true = _load_example_data(data_idx=1, filtered=True)
# filter data
Fs = 1000
f_lo = 13
f_hi = 30
x_filt = neurodsp.filter(x, Fs, 'bandpass', f_lo=f_lo, f_hi=f_hi, N_cycles=3)
# Compute difference between current and past filtered signals
signal_diff = x_filt[~np.isnan(x_filt)] - x_filt_true[~np.isnan(x_filt_true)]
assert np.allclose(np.sum(np.abs(signal_diff)), 0, atol=10 ** -5)
def test_spectralhist():
"""
Confirm SCV resampling calculation
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
fs = 1000.
# load ground truth scv
gt_sphist = np.load(os.path.dirname(neurodsp.__file__) +
'/tests/data/sample_data_' + str(data_idx) + '_sphist.npz')
freq, bins, sp_hist = spectral.spectral_hist(x, fs, nbins=10)
assert np.allclose(np.sum(np.abs(gt_sphist['freq'] - freq)), 0, atol=10 ** -5)
assert np.allclose(np.sum(np.abs(gt_sphist['bins'] - bins)), 0, atol=10 ** -5)
assert np.allclose(np.sum(np.abs(gt_sphist['sp_hist'] - sp_hist)), 0, atol=10 ** -5)
def test_scv():
"""
Confirm SCV calculation
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
fs = 1000.
# load ground truth scv
gt_scv = np.load(os.path.dirname(neurodsp.__file__) +
'/tests/data/sample_data_' + str(data_idx) + '_scv.npz')
# compute SCV
freq, SCV = spectral.scv(x, fs)
assert np.allclose(np.sum(np.abs(gt_scv['freq'] - freq)), 0, atol=10 ** -5)
assert np.allclose(np.sum(np.abs(gt_scv['SCV'] - SCV)), 0, atol=10 ** -5)
def test_laggedcoherence_consistent():
"""
Confirm consistency in beta bandpass filter results on a neural signal
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
Fs = 1000
f_range = (13, 30)
# Load ground truth lagged coherence
lc_true = np.load(os.path.dirname(neurodsp.__file__) +
'/tests/data/sample_data_' + str(data_idx) + '_laggedcoherence.npy')
# Compute lagged coherence
lag_coh_beta = neurodsp.lagged_coherence(x, f_range, Fs)
assert np.allclose(lag_coh_beta, lc_true, atol=10 ** -5)
def test_freq_by_time_consistent():
"""
Confirm consistency in beta bandpass filter results on a neural signal
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
Fs = 1000
f_range = (13, 30)
# Load ground truth frequency time series
i_f_true = np.load(os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_'+str(data_idx)+'_i_f.npy')
# Compute frequency time series
i_f = neurodsp.freq_by_time(x, Fs, f_range)
# Compute difference between current and past filtered signals
signal_diff = i_f[~np.isnan(i_f)] - i_f_true[~np.isnan(i_f_true)]
assert np.allclose(np.sum(np.abs(signal_diff)), 0, atol=10 ** -5)
def test_amp_by_time_consistent():
"""
Confirm consistency in beta bandpass filter results on a neural signal
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
Fs = 1000
f_range = (13, 30)
# Load ground truth amplitude time series
amp_true = np.load(os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_'+str(data_idx)+'_amp.npy')
# Compute amplitude time series
amp = neurodsp.amp_by_time(x, Fs, f_range)
# Compute difference between current and past filtered signals
signal_diff = amp - amp_true
assert np.allclose(np.sum(np.abs(signal_diff)), 0, atol=10 ** -5)
def test_cyclefeatures_consistent():
"""
Confirm consistency in peak finding
Previous code run:
import numpy as np
import os
import neurodsp
from neurodsp import shape
x = np.load(os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_1.npy')
df = shape.features_by_cycle(x, 1000, (13, 30), center_extrema='T',
estimate_oscillating_periods=True)
df.to_csv(os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_1_cyclefeatures.csv')
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
Fs = 1000
f_range = (13, 30)
# Load ground truth cycle features
df_true = pd.read_csv(
os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_' +
str(data_idx) + '_cyclefeatures.csv')
df = shape.features_by_cycle(x,
Fs,
f_range,
center_extrema='T',
estimate_oscillating_periods=True)
# Compute difference between calculated and ground truth values for each column
for k in df.keys():
if df[k].dtype == bool:
signal_diff = df[k].values[~np.isnan(df[k].values)].astype(
int) - df_true[k].values[~np.isnan(df_true[k].values)].astype(
int)
else:
signal_diff = df[k].values[~np.isnan(df[k].values)] - df_true[
k].values[~np.isnan(df_true[k].values)]
assert np.allclose(np.sum(np.abs(signal_diff)), 0, atol=10**-5)
def test_Ps_consistent():
"""
Confirm consistency in peak finding
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
Fs = 1000
f_range = (13, 30)
# Load ground truth lagged coherence
Ps_true = np.load(
os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_' +
str(data_idx) + '_Ps.npy')
# Compute lagged coherence
Ps, Ts = shape.find_extrema(x, Fs, f_range)
# Compute difference between current and past signals
signal_diff = Ps - Ps_true
assert np.allclose(np.sum(np.abs(signal_diff)), 0, atol=10**-5)
def test_scvrs():
"""
Confirm SCV resampling calculation
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
fs = 1000.
# load ground truth scv
gt_scvrs = np.load(
os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_' +
str(data_idx) + '_scvrs.npz')
# compute SCV and compare differences
np.random.seed(99)
freqbs, Tbs, SCVrsbs = spectral.scv_rs(x,
fs,
method='bootstrap',
rs_params=(5, 20))
assert np.allclose(np.sum(np.abs(gt_scvrs['freqbs'] - freqbs)),
0,
atol=10**-5)
assert Tbs is None
assert np.allclose(np.sum(np.abs(gt_scvrs['SCVrsbs'] - SCVrsbs)),
0,
atol=10**-5)
freqro, Tro, SCVrsro = spectral.scv_rs(x,
fs,
method='rolling',
rs_params=(4, 2))
assert np.allclose(np.sum(np.abs(gt_scvrs['freqro'] - freqro)),
0,
atol=10**-5)
assert np.allclose(np.sum(np.abs(gt_scvrs['Tro'] - Tro)), 0, atol=10**-5)
assert np.allclose(np.sum(np.abs(gt_scvrs['SCVrsro'] - SCVrsro)),
0,
atol=10**-5)
def test_timefreq_consistent():
"""
Confirm consistency in estimation of instantaneous phase, amp, and frequency
with computations in previous versions
"""
# Load data
data_idx = 1
x = _load_example_data(data_idx=data_idx)
Fs = 1000
f_range = (13, 30)
# Load ground truth phase time series
pha_true = np.load(
os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_' +
str(data_idx) + '_pha.npy')
# Load ground truth amplitude time series
amp_true = np.load(
os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_' +
str(data_idx) + '_amp.npy')
# Load ground truth frequency time series
i_f_true = np.load(
os.path.dirname(neurodsp.__file__) + '/tests/data/sample_data_' +
str(data_idx) + '_i_f.npy')
# Compute phase time series
pha = neurodsp.phase_by_time(x, Fs, f_range)
# Compute amplitude time series
amp = neurodsp.amp_by_time(x, Fs, f_range)
# Compute frequency time series
i_f = neurodsp.freq_by_time(x, Fs, f_range)
# Compute difference between current and past signals
assert np.allclose(np.sum(np.abs(pha - pha_true)), 0, atol=10**-5)
assert np.allclose(np.sum(np.abs(amp - amp_true)), 0, atol=10**-5)
assert np.allclose(np.sum(
np.abs(i_f[~np.isnan(i_f)] - i_f_true[~np.isnan(i_f_true)])),
0,
atol=10**-5)
