def plot_atom_usage(X, kernels, n_nonzero_coefs, n_jobs, figname):
r, code = multivariate_sparse_encode(X,
kernels,
n_nonzero_coefs=n_nonzero_coefs,
n_jobs=n_jobs,
verbose=2)
n_kernels = len(kernels)
amplitudes = zeros(n_kernels)
for i in range(len(code)):
for s in range(n_nonzero_coefs):
amplitudes[int(code[i][s, 2])] += abs(code[i][s, 0])
decomposition_weight = hstack([code[i][:, 2] for i in range(len(code))])
decomposition_weight.sort()
weight, _ = histogram(decomposition_weight, len(kernels), normed=False)
order = weight.argsort()
plot_kernels(kernels,
len(kernels),
order=order,
label=weight,
amp=amplitudes,
figname='EEG-kernels' + figname,
row=6)
plot_coef_hist(decomposition_weight, figname)
plot_weight_hist(amplitudes, figname)
plot_reconstruction_samples(X, r, code, kernels, 3, figname)
def test_multivariate_OMP():
n_samples = 10
n_features = 100
n_dims = 90
n_kernels = 8
n_nonzero_coefs = 3
kernel_init_len = n_features
verbose = False
dico, signals, decomposition = _generate_testbed(
kernel_init_len, n_nonzero_coefs, n_kernels, n_samples, n_features, n_dims
)
r, d = multivariate_sparse_encode(signals, dico, n_nonzero_coefs, n_jobs=1)
if verbose is True:
for i in range(n_samples):
# original signal decomposition, sorted by amplitude
sorted_decomposition = np.zeros_like(decomposition[i]).view("float, int, int")
for j in range(decomposition[i].shape[0]):
sorted_decomposition[j] = tuple(decomposition[i][j, :].tolist())
sorted_decomposition.sort(order=["f0"], axis=0)
for j in reversed(sorted_decomposition):
print(j)
# decomposition found by OMP, also sorted
sorted_d = np.zeros_like(d[i]).view("float, int, int")
for j in range(d[i].shape[0]):
sorted_d[j] = tuple(d[i][j, :].tolist())
sorted_d.sort(order=["f0"], axis=0)
for j in reversed(sorted_d):
print(j)
assert_array_almost_equal(
reconstruct_from_code(d, dico, n_features), signals, decimal=3
)
def _verif_OMP():
n_samples = 1000
n_nonzero_coefs = 3
for n_features in range(5, 50, 5):
kernel_init_len = n_features - n_features / 2
n_dims = n_features / 2
n_kernels = n_features * 5
dico, signals, _ = _generate_testbed(
kernel_init_len, n_nonzero_coefs, n_kernels, n_samples, n_features, n_dims
)
r, d = multivariate_sparse_encode(signals, dico, n_nonzero_coefs, n_jobs=1)
reconstructed = reconstruct_from_code(d, dico, n_features)
residual_energy = 0.0
for sig, rec in zip(signals, reconstructed):
residual_energy += ((sig - rec) ** 2).sum(1).mean()
print(
"Mean energy of the",
n_samples,
"residuals for",
(n_features, n_dims),
"features and",
n_kernels,
"kernels of",
(kernel_init_len, n_dims),
" is",
residual_energy / n_samples,
)
def test_multivariate_OMP():
n_samples = 10
n_features = 100
n_dims = 90
n_kernels = 8
n_nonzero_coefs = 3
kernel_init_len = n_features
verbose = False
dico, signals, decomposition = _generate_testbed(kernel_init_len,
n_nonzero_coefs,
n_kernels,
n_samples, n_features,
n_dims)
r, d = multivariate_sparse_encode(signals, dico, n_nonzero_coefs,
n_jobs = 1)
if verbose == True:
for i in range(n_samples):
# original signal decomposition, sorted by amplitude
sorted_decomposition = np.zeros_like(decomposition[i]).view('float, int, int')
for j in range(decomposition[i].shape[0]):
sorted_decomposition[j] = tuple(decomposition[i][j,:].tolist())
sorted_decomposition.sort(order=['f0'], axis=0)
for j in reversed(sorted_decomposition): print (j)
# decomposition found by OMP, also sorted
sorted_d = np.zeros_like(d[i]).view('float, int, int')
for j in range(d[i].shape[0]):
sorted_d[j] = tuple(d[i][j,:].tolist())
sorted_d.sort(order=['f0'], axis=0)
for j in reversed(sorted_d): print (j)
assert_array_almost_equal(reconstruct_from_code(d, dico, n_features),
signals, decimal=3)
def test_sparse_encode():
n_kernels = 8
dico = MultivariateDictLearning(n_kernels=n_kernels, random_state=0,
max_iter=2, n_nonzero_coefs=1)
dico = dico.fit(X)
_, code = multivariate_sparse_encode(X, dico, n_nonzero_coefs=1,
n_jobs=-1, verbose=3)
assert_true(len(code[0]) <= 1)
def test_sparse_encode():
n_samples, n_features, n_dims = 10, 5, 3
X = [rng_global.randn(n_features, n_dims) for i in range(n_samples)]
n_kernels = 8
dico = MultivariateDictLearning(
n_kernels=n_kernels, random_state=0, max_iter=2, n_nonzero_coefs=1
)
dico = dico.fit(X)
_, code = multivariate_sparse_encode(X, dico, n_nonzero_coefs=1, n_jobs=-1, verbose=3)
assert len(code[0]) <= 1
def _test_with_pydico_reload():
import pickle
n_nonzero_coefs = 3
with open("skmdla.pck", "w") as f:
o = pickle.load(f)
f.close()
dico = o["dico"]
signals = o["signals"]
_ = o["decomposition"]
r, d = multivariate_sparse_encode(signals, dico, n_nonzero_coefs, n_jobs=1, verbose=4)
def _test_with_pydico_reload():
import pickle
n_kernels = 8
n_nonzero_coefs = 3
kernel_init_len = n_features
with open('skmdla.pck', 'w') as f:
o = pickle.load(f)
f.close()
dico = o['dico']
signals = o['signals']
decomposition = o['decomposition']
r, d = multivariate_sparse_encode(signals, dico, n_nonzero_coefs,
n_jobs = 1, verbose=4)
def _test_with_pydico_reload():
import pickle
n_kernels = 8
n_nonzero_coefs = 3
kernel_init_len = n_features
with open('skmdla.pck', 'w') as f:
o = pickle.load(f)
f.close()
dico = o['dico']
signals = o['signals']
decomposition = o['decomposition']
r, d = multivariate_sparse_encode(signals,
dico,
n_nonzero_coefs,
n_jobs=1,
verbose=4)
def _test_with_pydico():
import pickle, shutil
n_kernels = 8
n_nonzero_coefs = 3
kernel_init_len = n_features
dico, signals, decomposition = _generate_testbed(kernel_init_len,
n_nonzero_coefs, n_kernels)
o = {'signals':signals, 'dico':dico, 'decomposition':decomposition}
with open('skmdla.pck', 'w') as f:
pickle.dump(o, f)
f.close()
shutil.copy('skmdla.pck', '../RC/skmdla.pck')
print (signals)
print (dico)
r, d = multivariate_sparse_encode(signals, dico, n_nonzero_coefs,
n_jobs = 1, verbose=4)
def decomposition_random_dictionary(Gaussian=True, rng=None, n_features=65, n_dims=1):
"""Generate a dataset from a random dictionary and compute decomposition
A dataset of n_samples examples is generated from a random dictionary,
each sample containing a random mixture of n_nonzero_coef atoms and has
a dimension of n_features by n_dims. All the examples are decomposed with
sparse multivariate OMP, written as:
(Eq. 1) min_a ||x - Da ||^2 s.t. ||a||_0 <= k
with x in R^(n_features x n_dims), D in R^(n_features x n_kernels) and
a in R^n_kernels.
Returns a ndarray of (n_nonzero_coefs, n_samples) containing all the
root mean square error (RMSE) computed as the residual of the decomposition
for all samples for sparsity constraint values of (Eq. 1) going from 1
to n_nonzero_coefs.
"""
n_samples = 100
kernel_init_len = n_features
n_kernels = 50
n_jobs = 1
dictionary, X, code = _generate_testbed(
kernel_init_len=kernel_init_len,
n_nonzero_coefs=n_nonzero_coefs,
n_kernels=n_kernels,
n_samples=n_samples,
n_features=n_features,
n_dims=n_dims,
rng=rng_global,
Gaussian=Gaussian,
)
rmse = zeros(shape=(n_nonzero_coefs, n_samples))
for k in range(n_nonzero_coefs):
for idx, s in enumerate(X):
r, _ = multivariate_sparse_encode(
array(s, ndmin=3),
dictionary,
n_nonzero_coefs=k + 1,
n_jobs=n_jobs,
verbose=1,
)
rmse[k, idx] = norm(r[0], "fro") / norm(s, "fro") * 100
return rmse
def plot_atom_usage(X, kernels, n_nonzero_coefs, n_jobs, figname):
r, code = multivariate_sparse_encode(X, kernels,
n_nonzero_coefs=n_nonzero_coefs,
n_jobs=n_jobs, verbose=2)
n_kernels=len(kernels)
amplitudes = zeros(n_kernels)
for i in range(len(code)):
for s in range(n_nonzero_coefs):
amplitudes[int(code[i][s,2])] += abs(code[i][s,0])
decomposition_weight = hstack([code[i][:,2] for i in range(len(code))])
decomposition_weight.sort()
weight, _ = histogram(decomposition_weight, len(kernels), normed=False)
order = weight.argsort()
plot_kernels(kernels, len(kernels), order=order, label=weight,
amp=amplitudes, figname='EEG-kernels'+figname, row=6)
plot_coef_hist(decomposition_weight, figname)
plot_weight_hist(amplitudes, figname)
plot_reconstruction_samples(X, r, code, kernels, 3, figname)
def _test_with_pydico():
import pickle
import shutil
n_features = 5
n_kernels = 8
n_nonzero_coefs = 3
kernel_init_len = n_features
dico, signals, decomposition = _generate_testbed(
kernel_init_len, n_nonzero_coefs, n_kernels
)
o = {"signals": signals, "dico": dico, "decomposition": decomposition}
with open("skmdla.pck", "w") as f:
pickle.dump(o, f)
f.close()
shutil.copy("skmdla.pck", "../RC/skmdla.pck")
print(signals)
print(dico)
r, d = multivariate_sparse_encode(signals, dico, n_nonzero_coefs, n_jobs=1, verbose=4)
def decomposition_random_dictionary(Gaussian=True, rng=None, n_features=65, n_dims=1):
"""Generate a dataset from a random dictionary and compute decomposition
A dataset of n_samples examples is generated from a random dictionary,
each sample containing a random mixture of n_nonzero_coef atoms and has
a dimension of n_features by n_dims. All the examples are decomposed with
sparse multivariate OMP, written as:
(Eq. 1) min_a ||x - Da ||^2 s.t. ||a||_0 <= k
with x in R^(n_features x n_dims), D in R^(n_features x n_kernels) and
a in R^n_kernels.
Returns a ndarray of (n_nonzero_coefs, n_samples) containing all the
root mean square error (RMSE) computed as the residual of the decomposition
for all samples for sparsity constraint values of (Eq. 1) going from 1
to n_nonzero_coefs.
"""
n_samples = 100
kernel_init_len = n_features
n_kernels = 50
n_jobs = 1
dictionary, X, code = _generate_testbed(
kernel_init_len=kernel_init_len,
n_nonzero_coefs=n_nonzero_coefs,
n_kernels=n_kernels,
n_samples=n_samples,
n_features=n_features,
n_dims=n_dims,
rng=rng_global,
Gaussian=Gaussian,
)
rmse = zeros(shape=(n_nonzero_coefs, n_samples))
for k in range(n_nonzero_coefs):
for idx, s in enumerate(X):
r, _ = multivariate_sparse_encode(
array(s, ndmin=3), dictionary, n_nonzero_coefs=k + 1, n_jobs=n_jobs, verbose=1
)
rmse[k, idx] = norm(r[0], "fro") / norm(s, "fro") * 100
return rmse
def _verif_OMP():
n_samples = 1000
n_nonzero_coefs = 3
for n_features in range (5, 50, 5):
kernel_init_len = n_features - n_features/2
n_dims = n_features/2
n_kernels = n_features*5
dico, signals, decomposition = _generate_testbed(kernel_init_len,
n_nonzero_coefs,
n_kernels,
n_samples, n_features,
n_dims)
r, d = multivariate_sparse_encode(signals, dico, n_nonzero_coefs,
n_jobs = 1)
reconstructed = reconstruct_from_code(d, dico, n_features)
residual_energy = 0.
for sig, rec in zip(signals, reconstructed):
residual_energy += ((sig-rec)**2).sum(1).mean()
print ('Mean energy of the', n_samples, 'residuals for', (n_features, n_dims), 'features and', n_kernels, 'kernels of', (kernel_init_len, n_dims),' is', residual_energy/n_samples)
def _test_with_pydico():
import pickle, shutil
n_samples, n_features, n_dims = 10, 5, 3
n_kernels = 8
n_nonzero_coefs = 3
kernel_init_len = n_features
dico, signals, decomposition = _generate_testbed(kernel_init_len,
n_nonzero_coefs,
n_kernels)
o = {'signals': signals, 'dico': dico, 'decomposition': decomposition}
with open('skmdla.pck', 'w') as f:
pickle.dump(o, f)
f.close()
shutil.copy('skmdla.pck', '../RC/skmdla.pck')
print(signals)
print(dico)
r, d = multivariate_sparse_encode(signals,
dico,
n_nonzero_coefs,
n_jobs=1,
verbose=4)