def test_DtD():
n_atoms = 10
n_channels = 5
n_times_atom = 50
random_state = 42
rng = check_random_state(random_state)
uv = rng.randn(n_atoms, n_channels + n_times_atom)
D = get_D(uv, n_channels)
assert np.allclose(compute_DtD(uv, n_channels=n_channels), compute_DtD(D))
def test_gradients(loss):
"""Check that the gradients have the correct shape.
"""
n_trials, n_channels, n_times = 5, 3, 100
n_atoms, n_times_atom = 10, 15
n_checks = 5
if loss == "dtw":
n_checks = 1
loss_params = dict(gamma=.01)
n_times_valid = n_times - n_times_atom + 1
X = np.random.randn(n_trials, n_channels, n_times)
z = np.random.randn(n_trials, n_atoms, n_times_valid)
uv = np.random.randn(n_atoms, n_channels + n_times_atom)
D = get_D(uv, n_channels)
if loss == "whitening":
loss_params['ar_model'], X = whitening(X)
# Test gradient D
assert D.shape == _gradient_d(X, z, D, loss, loss_params=loss_params).shape
def pobj(ds):
return _objective(X, z, ds.reshape(n_atoms, n_channels, -1), loss,
loss_params=loss_params)
def grad(ds):
return _gradient_d(X, z, ds, loss=loss, flatten=True,
loss_params=loss_params)
gradient_checker(pobj, grad, np.prod(D.shape), n_checks=n_checks,
grad_name="gradient D for loss '{}'".format(loss),
rtol=1e-4)
# Test gradient z
assert z[0].shape == _gradient_zi(
X, z, D, loss, loss_params=loss_params).shape
def pobj(zs):
return _objective(X[:1], zs.reshape(1, n_atoms, -1), D, loss,
loss_params=loss_params)
def grad(zs):
return gradient_zi(X[0], zs, D, loss=loss, flatten=True,
loss_params=loss_params)
gradient_checker(pobj, grad, n_atoms * n_times_valid, n_checks=n_checks,
debug=True, grad_name="gradient z for loss '{}'"
.format(loss), rtol=1e-4)
def run_cbpdn(X, ds_init, reg, n_iter, random_state, label, n_channels):
# use only one thread in fft
import sporco.linalg
sporco.linalg.pyfftw_threads = 1
n_atoms, n_channels_n_times_atom = ds_init.shape
n_times_atom = n_channels_n_times_atom - n_channels
ds_init = get_D(ds_init, n_channels)
if X.ndim == 2:
ds_init = np.swapaxes(ds_init, 0, 1)[:, None, :]
X = np.swapaxes(X, 0, 1)[:, None, :]
single_channel = True
else:
ds_init = np.swapaxes(ds_init, 0, 2)
X = np.swapaxes(X, 0, 2)
single_channel = False
options = {
'Verbose': VERBOSE > 0,
'MaxMainIter': n_iter,
'CBPDN': dict(NonNegCoef=True),
'CCMOD': dict(ZeroMean=False),
'DictSize': ds_init.shape,
}
# wohlberg / convolutional basis pursuit
opt = ConvBPDNDictLearn.Options(options)
cbpdn = ConvBPDNDictLearn(ds_init, X, reg, opt, dimN=1)
results = cbpdn.solve()
times = np.cumsum(cbpdn.getitstat().Time)
d_hat, pobj = results
if single_channel:
d_hat = d_hat.squeeze().T
n_atoms, n_times_atom = d_hat.shape
else:
d_hat = d_hat.squeeze()
if d_hat.ndim == 2:
d_hat = d_hat[:, None]
d_hat = d_hat.swapaxes(0, 2)
n_atoms, n_channels, n_times_atom = d_hat.shape
z_hat = cbpdn.getcoef().squeeze().swapaxes(0, 2)
times = np.concatenate([[0], times])
# z_hat.shape = (n_atoms, n_trials, n_times)
z_hat = z_hat[:, :, :-n_times_atom + 1]
return pobj, times, d_hat, z_hat
def run_multivariate(X, D_init, reg, n_iter, random_state,
label, n_channels):
n_atoms, n_channels_n_times_atom = D_init.shape
n_times_atom = n_channels_n_times_atom - n_channels
D_init = get_D(D_init, n_channels)
solver_z_kwargs = dict(max_iter=500, tol=1e-1)
return learn_d_z_multi(
X, n_atoms, n_times_atom, reg=reg, n_iter=n_iter,
uv_constraint='separate', rank1=False, D_init=D_init,
solver_d='l-bfgs', solver_d_kwargs=dict(max_iter=50),
solver_z="lgcd", solver_z_kwargs=solver_z_kwargs, use_sparse_z=False,
name="dense-{}-{}".format(n_channels, random_state),
random_state=random_state, n_jobs=1, verbose=VERBOSE,
raise_on_increase=False)
def test_consistency(loss, func):
"""Check that the result are the same for the full rank D and rank 1 uv.
"""
n_trials, n_channels, n_times = 5, 3, 30
n_atoms, n_times_atom = 4, 7
loss_params = dict(gamma=.01)
n_times_valid = n_times - n_times_atom + 1
X = np.random.randn(n_trials, n_channels, n_times)
z = np.random.randn(n_trials, n_atoms, n_times_valid)
uv = np.random.randn(n_atoms, n_channels + n_times_atom)
D = get_D(uv, n_channels)
if loss == "whitening":
loss_params['ar_model'], X = whitening(X)
val_D = func(X, z, D, loss, loss_params=loss_params)
val_uv = func(X, z, uv, loss, loss_params=loss_params)
assert np.allclose(val_D, val_uv)
