def test_Simplex(par): """Simplex projection and proximal/dual proximal of related indicator """ for engine in ['numpy', 'numba']: x = np.abs(np.random.normal(0., 1., par['nx']).astype(par['dtype'])) sim = Simplex(n=par['nx'], radius=np.sum(x), engine=engine) sim1 = Simplex(n=par['nx'], radius=np.sum(x) - 0.1, engine=engine) # evaluation assert sim(x) == True assert sim1(x) == False # prox / dualprox tau = 2. assert moreau(sim, x, tau) assert moreau(sim1, x, tau)
def test_Constant(par): """Constant functional and proximal/dual proximal """ quad = Quadratic(c=5.) # prox / dualprox tau = 2. x = np.random.normal(0., 1., par['nx']).astype(par['dtype']) assert moreau(quad, x, tau)
def test_Box(par): """Box projection and proximal/dual proximal of related indicator """ box = Box(-1, 1) x = np.random.normal(0., 1., par['nx']).astype(par['dtype']) # prox / dualprox tau = 2. assert moreau(box, x, tau)
def test_DotProduct(par): """Dot product functional and proximal/dual proximal """ quad = Quadratic(b=np.ones(par['nx'])) # prox / dualprox tau = 2. x = np.random.normal(0., 1., par['nx']).astype(par['dtype']) assert moreau(quad, x, tau)
def test_Orthogonal(par): """L1 functional with Orthogonal operator and proximal/dual proximal """ l1 = L1() orth = Orthogonal(l1, Identity(par['nx']), b=np.arange(par['nx'])) # prox / dualprox tau = 2. x = np.random.normal(0., 1., par['nx']).astype(par['dtype']) assert moreau(orth, x, tau)
def test_Quadratic(par): """Quadratic functional and proximal/dual proximal """ A = np.random.normal(0, 1, (par['nx'], par['nx'])) A = A.T @ A quad = Quadratic(Op=MatrixMult(A), b=np.ones(par['nx']), niter=500) # prox / dualprox tau = 2. x = np.random.normal(0., 1., par['nx']).astype(par['dtype']) assert moreau(quad, x, tau)
def test_L1(par): """L1 norm and proximal/dual proximal """ l1 = L1(sigma=par['sigma']) # norm x = np.random.normal(0., 1., par['nx']).astype(par['dtype']) assert l1(x) == par['sigma'] * np.sum(np.abs(x)) # prox / dualprox tau = 2. assert moreau(l1, x, tau)
def test_L1Ball(par): """L1 Ball projection and proximal/dual proximal of related indicator """ l1 = L1Ball(par['nx'], 1) x = np.random.normal(0., 1., par['nx']).astype(par['dtype']) + 1. # evaluation assert l1(x) == False xp = l1.prox(x, 1.) assert l1(xp) == True # prox / dualprox tau = 2. assert moreau(l1, x, tau)
def test_EuclBall(par): """Euclidean Ball projection and proximal/dual proximal of related indicator """ eucl = EuclideanBall(np.zeros(par['nx']), 1) x = np.random.normal(0., 1., par['nx']).astype(par['dtype']) + 1. # evaluation assert eucl(x) == False xp = eucl.prox(x, 1.) assert eucl(xp) == True # prox / dualprox tau = 2. assert moreau(eucl, x, tau)
def test_Affine(par): """Affine set projection and proximal/dual proximal of related indicator """ Op = Identity(par['nx']) b = np.random.normal(0., 1., par['nx']) aff = AffineSet(Op, b, 10) # prox tau = 2. x = np.ones(par['nx']) assert_array_almost_equal(aff.prox(x, tau), b) # prox / dualprox assert moreau(aff, x, tau)
def test_NuclBall(par): """Nuclear Ball projection and proximal/dual proximal of related indicator """ nuc = NuclearBall((par['nx'], par['ny']), 1) x = np.random.normal(0., 1., (par['nx'], par['ny'])).astype(par['dtype']) \ + np.eye(par['nx'], par['ny']) # evaluation assert nuc(x) == False xp = nuc.prox(x, 1.) assert nuc(xp, 1e-4) == True # prox / dualprox tau = 2. assert moreau(nuc, x.ravel(), tau)
def test_L21(par): """L21 norm and proximal/dual proximal on 2d array (compare it with N L2 norms on the columns of the 2d array """ l21 = L21(ndim=2, sigma=par['sigma']) # norm x = np.random.normal(0., 1., 2 * par['nx']).astype(par['dtype']) l21_ = par['sigma'] * np.sum( np.linalg.norm(x.reshape(2, par['nx']), axis=0)) assert_array_almost_equal(l21(x), l21_) # prox / dualprox tau = 2. assert moreau(l21, x, tau)
def test_Euclidean(par): """Euclidean norm and proximal/dual proximal """ eucl = Euclidean(sigma=par['sigma']) # norm x = np.random.normal(0., 1., par['nx']).astype(par['dtype']) assert eucl(x) == par['sigma'] * np.linalg.norm(x) # grad assert_array_almost_equal(eucl.grad(x), par['sigma'] * x / np.linalg.norm(x)) # prox / dualprox tau = 2. assert moreau(eucl, x, tau)
def test_VStack(par): """L2 functional with VStack operator of multiple L1s """ nxs = [par['nx'] // 4] * 4 nxs[-1] = par['nx'] - np.sum(nxs[:-1]) l2 = L2() vstack = VStack([l2] * 4, nxs) # functional x = np.random.normal(0., 1., par['nx']).astype(par['dtype']) assert_array_almost_equal(l2(x), vstack(x), decimal=4) # gradient assert_array_almost_equal(l2.grad(x), vstack.grad(x), decimal=4) # prox / dualprox tau = 2. assert_array_equal(l2.prox(x, tau), vstack.prox(x, tau)) # moreau assert moreau(vstack, x, tau)
def test_Simplex_multi(par): """Simplex projection and proximal/dual proximal for 2d array """ dims = (par['ny'], par['nx']) otheraxis = 1 if par['axis'] == 0 else 0 for engine in ['numpy', 'numba']: x = np.abs(np.random.normal(0., 1., dims).astype(par['dtype'])) sim = Simplex(n=par['ny'] * par['nx'], radius=5., dims=dims, axis=par['axis'], maxiter=50, engine=engine) # prox tau = 2. y = sim.prox(x.ravel(), tau) assert_array_almost_equal(np.sum(y.reshape(dims), axis=par['axis']), 5. * np.ones(dims[otheraxis]), decimal=1) # prox / dualprox assert moreau(sim, x.ravel(), tau)