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')