def test_HStack(par):
"""Dot-test and inversion for HStack operator with numpy array as input
"""
np.random.seed(0)
G1 = np.random.normal(0, 10, (par['ny'], par['nx'])).astype('float32')
G2 = np.random.normal(0, 10, (par['ny'], par['nx'])).astype('float32')
x = np.ones(2 * par['nx']) + par['imag'] * np.ones(2 * par['nx'])
Hop = HStack([G1, MatrixMult(G2, dtype=par['dtype'])], dtype=par['dtype'])
assert dottest(Hop,
par['ny'],
2 * par['nx'],
complexflag=0 if par['imag'] == 0 else 3)
xlsqr = lsqr(Hop, Hop * x, damp=1e-20, iter_lim=300, show=0)[0]
assert_array_almost_equal(x, xlsqr, decimal=4)
# use numpy matrix directly in the definition of the operator
H1op = HStack([G1, MatrixMult(G2, dtype=par['dtype'])], dtype=par['dtype'])
assert dottest(H1op,
par['ny'],
2 * par['nx'],
complexflag=0 if par['imag'] == 0 else 3)
# use scipy matrix directly in the definition of the operator
G1 = sp_random(par['ny'], par['nx'], density=0.4).astype('float32')
H2op = HStack([G1, MatrixMult(G2, dtype=par['dtype'])], dtype=par['dtype'])
assert dottest(H2op,
par['ny'],
2 * par['nx'],
complexflag=0 if par['imag'] == 0 else 3)
def test_VStack(par):
"""Dot-test and inversion for VStack operator"""
np.random.seed(0)
G1 = np.random.normal(0, 10, (par["ny"], par["nx"])).astype(par["dtype"])
G2 = np.random.normal(0, 10, (par["ny"], par["nx"])).astype(par["dtype"])
x = np.ones(par["nx"]) + par["imag"] * np.ones(par["nx"])
Vop = VStack(
[MatrixMult(G1, dtype=par["dtype"]), MatrixMult(G2, dtype=par["dtype"])],
dtype=par["dtype"],
)
assert dottest(
Vop, 2 * par["ny"], par["nx"], complexflag=0 if par["imag"] == 0 else 3
)
xlsqr = lsqr(Vop, Vop * x, damp=1e-20, iter_lim=300, atol=1e-8, btol=1e-8, show=0)[
0
]
assert_array_almost_equal(x, xlsqr, decimal=4)
# use numpy matrix directly in the definition of the operator
V1op = VStack([G1, MatrixMult(G2, dtype=par["dtype"])], dtype=par["dtype"])
assert dottest(
V1op, 2 * par["ny"], par["nx"], complexflag=0 if par["imag"] == 0 else 3
)
# use scipy matrix directly in the definition of the operator
G1 = sp_random(par["ny"], par["nx"], density=0.4).astype("float32")
V2op = VStack([G1, MatrixMult(G2, dtype=par["dtype"])], dtype=par["dtype"])
assert dottest(
V2op, 2 * par["ny"], par["nx"], complexflag=0 if par["imag"] == 0 else 3
)
def random_sample(self):
vec = sp_random(1,
self.sig_dim,
density=self.s / self.sig_dim,
data_rvs=stats.norm(loc=0.0, scale=1.0).rvs).A
norm = np.linalg.norm(vec)
support = list(np.nonzero(vec[0]))
return [vec[0] / norm, support]
def test_sparse(self):
"""Tests LR raises NotImplementedError for sparse data."""
np.random.seed(0)
coo_matrix = sp_random(10, 1, density=0.5)
sparse_arr = ds.array(x=coo_matrix, block_size=(5, 1))
reg = LinearRegression()
with self.assertRaises(NotImplementedError):
reg.fit(sparse_arr, sparse_arr)
dense_arr = random_array((10, 1), (5, 1))
reg.fit(dense_arr, dense_arr)
with self.assertRaises(NotImplementedError):
reg.predict(sparse_arr)
def test_Block(par):
"""Dot-test and inversion for Block operator"""
np.random.seed(0)
G11 = np.random.normal(0, 10, (par["ny"], par["nx"])).astype(par["dtype"])
G12 = np.random.normal(0, 10, (par["ny"], par["nx"])).astype(par["dtype"])
G21 = np.random.normal(0, 10, (par["ny"], par["nx"])).astype(par["dtype"])
G22 = np.random.normal(0, 10, (par["ny"], par["nx"])).astype(par["dtype"])
x = np.ones(2 * par["nx"]) + par["imag"] * np.ones(2 * par["nx"])
Bop = Block(
[
[MatrixMult(G11, dtype=par["dtype"]), MatrixMult(G12, dtype=par["dtype"])],
[MatrixMult(G21, dtype=par["dtype"]), MatrixMult(G22, dtype=par["dtype"])],
],
dtype=par["dtype"],
)
assert dottest(
Bop, 2 * par["ny"], 2 * par["nx"], complexflag=0 if par["imag"] == 0 else 3
)
xlsqr = lsqr(Bop, Bop * x, damp=1e-20, iter_lim=500, atol=1e-8, btol=1e-8, show=0)[
0
]
assert_array_almost_equal(x, xlsqr, decimal=3)
# use numpy matrix directly in the definition of the operator
B1op = Block(
[
[G11, MatrixMult(G12, dtype=par["dtype"])],
[MatrixMult(G21, dtype=par["dtype"]), G22],
],
dtype=par["dtype"],
)
assert dottest(
B1op, 2 * par["ny"], 2 * par["nx"], complexflag=0 if par["imag"] == 0 else 3
)
# use scipy matrix directly in the definition of the operator
G11 = sp_random(par["ny"], par["nx"], density=0.4).astype("float32")
B2op = Block(
[
[G11, MatrixMult(G12, dtype=par["dtype"])],
[MatrixMult(G21, dtype=par["dtype"]), G22],
],
dtype=par["dtype"],
)
assert dottest(
B2op, 2 * par["ny"], 2 * par["nx"], complexflag=0 if par["imag"] == 0 else 3
)
def test_BlockDiag(par):
"""Dot-test and inversion for BlockDiag operator
"""
np.random.seed(0)
G1 = np.random.normal(0, 10, (par['ny'], par['nx'])).astype(par['dtype'])
G2 = np.random.normal(0, 10, (par['ny'], par['nx'])).astype(par['dtype'])
x = np.ones(2 * par['nx']) + par['imag'] * np.ones(2 * par['nx'])
BDop = BlockDiag([
MatrixMult(G1, dtype=par['dtype']),
MatrixMult(G2, dtype=par['dtype'])
],
dtype=par['dtype'])
assert dottest(BDop,
2 * par['ny'],
2 * par['nx'],
complexflag=0 if par['imag'] == 0 else 3)
xlsqr = lsqr(BDop, BDop * x, damp=1e-20, iter_lim=500, show=0)[0]
assert_array_almost_equal(x, xlsqr, decimal=3)
# use numpy matrix directly in the definition of the operator
BD1op = BlockDiag([MatrixMult(G1, dtype=par['dtype']), G2],
dtype=par['dtype'])
assert dottest(BD1op,
2 * par['ny'],
2 * par['nx'],
complexflag=0 if par['imag'] == 0 else 3)
# use scipy matrix directly in the definition of the operator
G2 = sp_random(par['ny'], par['nx'], density=0.4).astype('float32')
BD2op = BlockDiag([MatrixMult(G1, dtype=par['dtype']), G2],
dtype=par['dtype'])
assert dottest(BD2op,
2 * par['ny'],
2 * par['nx'],
complexflag=0 if par['imag'] == 0 else 3)
def solve(self, b):
lin_const = lambda x: self.A @ x - b
cons = [{"type": "eq", "fun": lin_const}]
x0 = sp_random(1, self.sig_dim, density=1).A
norm = np.linalg.norm(x0)
x0 /= norm
# x0 = np.zeros(shape=[1,self.sig_dim])
res = minimize(fun=self.func,
x0=x0,
jac=self.grad_vec,
constraints=cons,
method='SLSQP',
options={'maxiter': 1000})
self.solution = {
key: res[key]
for key in res if key not in ['jac', 'hess', 'hess_inv']
}
# res = minimize(fun=self.func, x0=x0, constraints=cons)
# if not res.success:
# # raise Exception('l1 : Optimization did not converge. Quitting.')
# print('{}::solve : Optimization did not converge.'.format(self.class_name))
# return None
# self.solution = res.x
return self.solution
for i in range(self.sig_dim):
for g in self.signs_dict[i]:
for j in g:
pass
if __name__ == '__main__':
from structured_sparsity.sparsity_pattern.chain_sparse import chain_sparse
from structured_sparsity.objective_function.l1 import l1
m = 10
n = 16
gr_size = 3
nr_groups = 8
sparsity = 2
A = sp_random(m=m, n=n, density=0.5).A
sp = chain_sparse(sig_dim=n,
group_size=gr_size,
nr_groups=nr_groups,
s=sparsity)
obj_func_0 = l1(A)
obj_func_1 = group_lasso(A, [g for g in sp.groups()])
x_bar = sp.random_sample()
b = np.matmul(A, x_bar)
b.reshape([A.shape[0], 1])
print('Original signal:')
print(x_bar)
print('L1 solution:')
x_hat_0 = obj_func_0.solve(b=b)
def run_exp(config_file_path=''):
###################
## Configuration ##
###################
config = configparser.ConfigParser()
config.read(config_file_path)
mat_is_rand = config['meas_matrix'].getboolean('random')
A = None
matr_density = None
if mat_is_rand:
m = config['meas_matrix'].getint('nr_rows')
n = config['meas_matrix'].getint('nr_cols')
nr_matrices = config['meas_matrix'].getint('nr_matrices')
matr_density = config['meas_matrix'].getfloat(
'density') # Should crash here!
else:
A = config['meas_matrix']['A']
A = utils.config_str_to_np_array(A)
m = A.shape[0]
n = A.shape[1]
nr_matrices = 1
max_s = config['sparsity'].getint('max_sparsity')
nr_trials = config['experiment'].getint('nr_trials')
obj_funcs = [
x.strip() for x in config['optimization']['obj_funcs'].split(",")
]
sparsity_type = config['sparsity']['type']
####################
## The Experiment ##
####################
test_sp_range = range(1, max_s + 1)
# obj_func_res = {obj_f:[[] for i in test_sp_range] for obj_f in obj_funcs}
res_dict = {}
for mat_nr in range(nr_matrices):
if mat_is_rand:
A = sp_random(m=m, n=n, density=matr_density).A
A = np.asarray(A)
matr_str = 'meas_matr_{}'.format(mat_nr)
res_dict[matr_str] = [A, {}]
for sparsity in test_sp_range:
print('Matrix nr: {:>2}. {}: {:>2}.'.format(
mat_nr, sparsity_type, sparsity))
sp_str = sparsity_type + '={}'.format(sparsity)
res_dict[matr_str][1][sp_str] = {}
sp = sp_factory(obj_str=sparsity_type,
sig_dim=n,
config=config,
s=sparsity).run()
obj_func_classes = {
obj_f: obj_func_factory(obj_str=obj_f, A=A,
groups=sp.groups()).run()
for obj_f in obj_funcs
}
# sp_res = {obj_f:[] for obj_f in obj_funcs}
for trial in range(nr_trials):
print('.', sep=' ', end='', flush=True)
[x_bar, _] = sp.random_sample()
b = np.matmul(A, x_bar)
x_hat_dict = {
obj_f: obj_func_classes[obj_f].solve(b=b)
for obj_f in obj_funcs
}
res_dict[matr_str][1][sp_str][tuple(x_bar)] = x_hat_dict
# for obj_f in obj_funcs:
# obj_func_res[obj_f][sparsity-1] += sp_res[obj_f]
print('\n')
utils.save_nparray_with_date(data=res_dict,
file_prefix='Norm_comp_exp',
subfolder_name='output')