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)
