def test_dss0(n_bad_chans):
"""Test dss0.
Find the linear combinations of multichannel data that
maximize repeatability over trials. Data are time * channel * trials.
Uses dss0().
`n_bad_chans` set the values of the first corresponding number of channels
to zero.
"""
n_samples = 300
data, source = create_data(n_samples=n_samples, n_bad_chans=n_bad_chans)
# apply DSS to clean them
c0, _ = tscov(data)
c1, _ = tscov(np.mean(data, 2))
[todss, _, pwr0, pwr1] = dss.dss0(c0, c1)
z = fold(np.dot(unfold(data), todss), epoch_size=n_samples)
best_comp = np.mean(z[:, 0, :], -1)
scale = np.ptp(best_comp) / np.ptp(source)
assert_allclose(np.abs(best_comp), np.abs(np.squeeze(source)) * scale,
atol=1e-6) # use abs as DSS component might be flipped
def test_cca():
"""Test CCA."""
# Compare results with Matlab
# x = np.random.randn(1000, 11)
# y = np.random.randn(1000, 9)
# x = demean(x).squeeze()
# y = demean(y).squeeze()
mat = loadmat('./tests/data/ccadata.mat')
x = mat['x']
y = mat['y']
A2 = mat['A2']
B2 = mat['B2']
A1, B1, R = nt_cca(x, y) # if mean(A1(:).*A2(:))<0; A2=-A2; end
X1 = np.dot(x, A1)
Y1 = np.dot(y, B1)
C1 = tscov(np.hstack((X1, Y1)))[0]
# Sklearn CCA
cca = CCA(n_components=9, scale=False, max_iter=1e6)
X2, Y2 = cca.fit_transform(x, y)
# C2 = tscov(np.hstack((X2, Y2)).T)[0]
# import matplotlib.pyplot as plt
# f, (ax1, ax2) = plt.subplots(2, 1)
# ax1.imshow(C1)
# ax2.imshow(C2)
# plt.show()
# assert_almost_equal(C1, C2, decimal=4)
# Compare with matlab
X2 = np.dot(x, A2)
Y2 = np.dot(y, B2)
C2 = tscov(np.hstack((X2, Y2)))[0]
assert_almost_equal(C1, C2)
def test_dss0(n_bad_chans):
"""Test dss0.
Find the linear combinations of multichannel data that
maximize repeatability over trials. Data are time * channel * trials.
Uses dss0().
`n_bad_chans` set the values of the first corresponding number of channels
to zero.
"""
# create synthetic data
n_samples = 100 * 3
n_chans = 30
n_trials = 100
noise_dim = 20 # dimensionality of noise
# source
source = np.hstack(
(np.zeros((n_samples // 3, )),
np.sin(2 * np.pi * np.arange(n_samples // 3) / (n_samples / 3)).T,
np.zeros((n_samples // 3, ))))[np.newaxis].T
s = source * np.random.randn(1, n_chans) # 300 * 30
s = s[:, :, np.newaxis]
s = np.tile(s, (1, 1, 100))
# set first `n_bad_chans` to zero
s[:, :n_bad_chans] = 0.
# noise
noise = np.dot(unfold(np.random.randn(n_samples, noise_dim, n_trials)),
np.random.randn(noise_dim, n_chans))
noise = fold(noise, n_samples)
# mix signal and noise
SNR = 0.1
data = noise / rms(noise.flatten()) + SNR * s / rms(s.flatten())
# apply DSS to clean them
c0, _ = tscov(data)
c1, _ = tscov(np.mean(data, 2))
[todss, _, pwr0, pwr1] = dss.dss0(c0, c1)
z = fold(np.dot(unfold(data), todss), epoch_size=n_samples)
best_comp = np.mean(z[:, 0, :], -1)
scale = np.ptp(best_comp) / np.ptp(source)
assert_allclose(np.abs(best_comp),
np.abs(np.squeeze(source)) * scale,
atol=1e-6) # use abs as DSS component might be flipped
def test_tscov():
"""Test time-shift covariance."""
x = 2 * np.eye(3) + 0.1 * np.random.rand(3)
x = x - np.mean(x, 0)
# Compare 0-lag case with numpy.cov()
c1, n1 = tscov(x, [0])
c2 = np.cov(x, bias=True)
assert_almost_equal(c1 / n1, c2)
# Compare 0-lag case with numpy.cov()
x = 2 * np.eye(3)
c1, n1 = tscov(x, [0, -1])
assert_almost_equal(
c1,
np.array([[4, 0, 0, 4, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 4, 0, 0, 4],
[4, 0, 0, 4, 0, 0], [0, 0, 0, 0, 4, 0], [0, 0, 4, 0, 0, 4]]))
c2, n2 = tsxcov(x, x, [0, -1])
def test_correlated():
"""Test x & y perfectly correlated."""
x = np.random.randn(1000, 10)
y = np.random.randn(1000, 10)
y = x[:, np.random.permutation(10)] # +0.000001*y;
[A1, B1, R1] = nt_cca(x, y)
C = tscov(np.hstack((np.dot(x, A1), np.dot(y, B1))))[0]
# import matplotlib.pyplot as plt
# f, ax1 = plt.subplots(1, 1)
# im = ax1.imshow(C)
# plt.colorbar(im)
# plt.show()
for i in np.arange(C.shape[0]):
assert_almost_equal(C[i, i], C[i, (i + 10) % 10], decimal=4)
assert_almost_equal(C[i, i], C[i, (i - 10) % 10], decimal=4)
# Noise
noise = np.dot(unfold(np.random.randn(n_samples, noise_dim, n_trials)),
np.random.randn(noise_dim, n_chans))
noise = fold(noise, n_samples)
# Mix signal and noise
SNR = 0.1
data = noise / rms(noise.flatten()) + SNR * s / rms(s.flatten())
###############################################################################
# Apply DSS to clean them
# -----------------------------------------------------------------------------
# Compute original and biased covariance matrices
c0, _ = tscov(data)
# In this case the biased covariance is simply the covariance of the mean over
# trials
c1, _ = tscov(np.mean(data, 2))
# Apply DSS
[todss, _, pwr0, pwr1] = dss.dss0(c0, c1)
z = fold(np.dot(unfold(data), todss), epoch_size=n_samples)
# Find best components
best_comp = np.mean(z[:, 0, :], -1)
###############################################################################
# Plot results
# -----------------------------------------------------------------------------
def func(y):
return np.mean(x - (y[0] * np.sin(t + y[1]) + y[2])[:, None], 1)
est_std, est_phase, est_mean = leastsq(
func, [guess_std, guess_phase, guess_mean])[0]
data_fit = est_std * np.sin(t + est_phase) + est_mean
return np.tile(data_fit, (x.shape[1], 1)).T
# 1) Apply STAR
# -----------------------------------------------------------------------------
y, w, _ = star.star(x, 2)
# 2) Apply DSS on raw data
# -----------------------------------------------------------------------------
c0, _ = tscov(x)
c1, _ = tscov(x - _sine_fit(x))
[todss, _, pwr0, pwr1] = dss.dss0(c0, c1)
z1 = normcol(np.dot(x, todss))
# 3) Apply DSS on STAR-ed data
# -----------------------------------------------------------------------------
c0, _ = tscov(y)
c1, _ = tscov(y - _sine_fit(y))
[todss, _, pwr0, pwr1] = dss.dss0(c0, c1)
z2 = normcol(np.dot(y, todss))
# Plots
# -----------------------------------------------------------------------------
f, (ax0, ax1, ax2, ax3) = plt.subplots(4, 1, figsize=(7, 9))
ax0.plot(target, lw=.5)
