def test_CompositionOperator_direct3(self):
ig = self.ig
data = self.data
G = GradientOperator(domain_geometry=ig)
Id1 = 2 * IdentityOperator(ig)
Id2 = IdentityOperator(ig)
d = CompositionOperator(G, Id2)
out1 = G.direct(data)
d_out = d.direct(data)
d1 = Id2.direct(data)
d2 = G.direct(d1)
numpy.testing.assert_array_almost_equal(
d2.get_item(0).as_array(),
d_out.get_item(0).as_array())
numpy.testing.assert_array_almost_equal(
d2.get_item(1).as_array(),
d_out.get_item(1).as_array())
G2Id = G.compose(2 * Id2)
d2g = G2Id.direct(data)
numpy.testing.assert_array_almost_equal(
d2g.get_item(0).as_array(), 2 * d_out.get_item(0).as_array())
numpy.testing.assert_array_almost_equal(
d2g.get_item(1).as_array(), 2 * d_out.get_item(1).as_array())
def test_NestedBlockDataContainer2(self):
M, N = 2, 3
ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N)
ag = ig
u = ig.allocate(1)
op1 = GradientOperator(ig)
op2 = IdentityOperator(ig, ag)
operator = BlockOperator(op1, op2, shape=(2, 1))
d1 = op1.direct(u)
d2 = op2.direct(u)
d = operator.direct(u)
dd = operator.domain_geometry()
ww = operator.range_geometry()
c1 = d + d
c2 = 2 * d
c3 = d / (d + 0.0001)
c5 = d.get_item(0).power(2).sum()
def test_PowerMethod(self):
print("test_BlockOperator")
N, M = 200, 300
niter = 10
ig = ImageGeometry(N, M)
Id = IdentityOperator(ig)
G = GradientOperator(ig)
uid = Id.domain_geometry().allocate(ImageGeometry.RANDOM, seed=1)
a = LinearOperator.PowerMethod(Id, niter, uid)
#b = LinearOperator.PowerMethodNonsquare(Id, niter, uid)
b = LinearOperator.PowerMethod(Id, niter)
print("Edo impl", a[0])
print("None impl", b[0])
#self.assertAlmostEqual(a[0], b[0])
self.assertNumpyArrayAlmostEqual(a[0], b[0], decimal=6)
a = LinearOperator.PowerMethod(G, niter, uid)
b = LinearOperator.PowerMethod(G, niter)
#b = LinearOperator.PowerMethodNonsquare(G, niter, uid)
print("Edo impl", a[0])
#print ("old impl", b[0])
self.assertNumpyArrayAlmostEqual(a[0], b[0], decimal=2)
def test_IdentityOperator(self):
ig = ImageGeometry(10, 20, 30)
img = ig.allocate()
print(img.shape, ig.shape)
self.assertTrue(img.shape == (30, 20, 10))
self.assertEqual(img.sum(), 0)
Id = IdentityOperator(ig)
y = Id.direct(img)
numpy.testing.assert_array_equal(y.as_array(), img.as_array())
def test_IdentityOperator(self):
print("test_IdentityOperator")
ig = ImageGeometry(10, 20, 30)
img = ig.allocate()
# img.fill(numpy.ones((30,20,10)))
self.assertTrue(img.shape == (30, 20, 10))
#self.assertEqual(img.sum(), 2*float(10*20*30))
self.assertEqual(img.sum(), 0.)
Id = IdentityOperator(ig)
y = Id.direct(img)
numpy.testing.assert_array_equal(y.as_array(), img.as_array())
def test_SumOperator(self):
# numpy.random.seed(1)
ig = self.ig
data = self.data
Id1 = 2 * IdentityOperator(ig)
Id2 = IdentityOperator(ig)
c = SumOperator(Id1, Id2)
out = c.direct(data)
numpy.testing.assert_array_almost_equal(out.as_array(),
3 * data.as_array())
def test_CompositionOperator_adjoint5(self):
ig = self.ig
data = self.data
G = GradientOperator(domain_geometry=ig)
Id1 = 3 * IdentityOperator(ig)
Id = Id1 - IdentityOperator(ig)
d = G.compose(Id)
da = d.direct(data)
out1 = G.adjoint(da)
out2 = d.adjoint(da)
numpy.testing.assert_array_almost_equal(out2.as_array(),
2 * out1.as_array())
def test_PDHG_strongly_convex_gamma_g(self):
ig = ImageGeometry(3,3)
data = ig.allocate('random')
f = L2NormSquared(b=data)
g = L2NormSquared()
operator = IdentityOperator(ig)
# sigma, tau
sigma = 1.0
tau = 1.0
pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau,
max_iteration=5, gamma_g=0.5)
pdhg.run(1, verbose=0)
self.assertAlmostEquals(pdhg.theta, 1.0/ np.sqrt(1 + 2 * pdhg.gamma_g * tau))
self.assertAlmostEquals(pdhg.tau, tau * pdhg.theta)
self.assertAlmostEquals(pdhg.sigma, sigma / pdhg.theta)
pdhg.run(4, verbose=0)
self.assertNotEqual(pdhg.sigma, sigma)
self.assertNotEqual(pdhg.tau, tau)
# check negative strongly convex constant
with self.assertRaises(ValueError):
pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau,
max_iteration=5, gamma_g=-0.5)
# check strongly convex constant not a number
with self.assertRaises(ValueError):
pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau,
max_iteration=5, gamma_g="-0.5")
def test_CGLS(self):
print("Test CGLS")
#ig = ImageGeometry(124,153,154)
ig = ImageGeometry(10, 2)
numpy.random.seed(2)
initial = ig.allocate(0.)
b = ig.allocate('random')
# b = initial.copy()
# fill with random numbers
# b.fill(numpy.random.random(initial.shape))
# b = ig.allocate()
# bdata = numpy.reshape(numpy.asarray([i for i in range(20)]), (2,10))
# b.fill(bdata)
identity = IdentityOperator(ig)
alg = CGLS(initial=initial, operator=identity, data=b)
alg.max_iteration = 200
alg.run(20, verbose=0)
self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
alg = CGLS(initial=initial,
operator=identity,
data=b,
max_iteration=200,
update_objective_interval=2)
self.assertTrue(alg.max_iteration == 200)
self.assertTrue(alg.update_objective_interval == 2)
alg.run(20, verbose=0)
self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
def setUp(self, *args, **kwargs):
M, N, K = 3, 4, 5
self.ig = ImageGeometry(M, N, K)
self.x = self.ig.allocate('random', seed=1)
self.b = self.ig.allocate('random', seed=2)
self.eta = self.ig.allocate(0.1)
self.operator = IdentityOperator(self.ig)
scalar = 0.25
self.f1 = L2NormSquared()
self.f2 = L1Norm()
self.f3 = scalar * L2NormSquared()
self.f4 = scalar * L1Norm()
self.f5 = scalar * L2NormSquared(b=self.b)
self.f6 = scalar * L1Norm(b=self.b)
self.f7 = ZeroFunction()
self.f8 = 5 * ConstantFunction(10)
self.f9 = LeastSquares(self.operator, self.b, c=scalar)
self.f10 = 0.5 * KullbackLeibler(b=self.b, eta=self.eta)
self.f11 = KullbackLeibler(b=self.b, eta=self.eta)
self.f12 = 10
self.list1 = [self.f1, self.f2, self.f3, self.f4, self.f5, \
self.f6, self.f7, self.f8, self.f9, self.f10, self.f11, self.f12]
def test_FISTA_Norm2Sq(self):
print("Test FISTA Norm2Sq")
ig = ImageGeometry(127, 139, 149)
b = ig.allocate(ImageGeometry.RANDOM)
# fill with random numbers
initial = ig.allocate(ImageGeometry.RANDOM)
identity = IdentityOperator(ig)
#### it seems FISTA does not work with Nowm2Sq
norm2sq = LeastSquares(identity, b)
#norm2sq.L = 2 * norm2sq.c * identity.norm()**2
#norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity)
opt = {'tol': 1e-4, 'memopt': False}
if debug_print:
print("initial objective", norm2sq(initial))
alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction())
alg.max_iteration = 2
alg.run(20, verbose=0)
self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
alg = FISTA(initial=initial,
f=norm2sq,
g=ZeroFunction(),
max_iteration=2,
update_objective_interval=3)
self.assertTrue(alg.max_iteration == 2)
self.assertTrue(alg.update_objective_interval == 3)
alg.run(20, verbose=0)
self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
def test_FISTA_catch_Lipschitz(self):
if debug_print:
print("Test FISTA catch Lipschitz")
ig = ImageGeometry(127, 139, 149)
initial = ImageData(geometry=ig)
initial = ig.allocate()
b = initial.copy()
# fill with random numbers
b.fill(numpy.random.random(initial.shape))
initial = ig.allocate(ImageGeometry.RANDOM)
identity = IdentityOperator(ig)
#### it seems FISTA does not work with Nowm2Sq
norm2sq = LeastSquares(identity, b)
if debug_print:
print('Lipschitz', norm2sq.L)
# norm2sq.L = None
#norm2sq.L = 2 * norm2sq.c * identity.norm()**2
#norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity)
opt = {'tol': 1e-4, 'memopt': False}
if debug_print:
print("initial objective", norm2sq(initial))
try:
alg = FISTA(initial=initial, f=L1Norm(), g=ZeroFunction())
self.assertTrue(False)
except ValueError as ve:
print(ve)
self.assertTrue(True)
def test_ScaledBlockOperatorScalarList(self):
ig = [ ImageGeometry(2,3) , \
#ImageGeometry(10,20,30) , \
ImageGeometry(2,3 ) ]
x = [g.allocate() for g in ig]
ops = [IdentityOperator(g) for g in ig]
# test limit as non Scaled
scalar = numpy.asarray([1 for _ in x])
k = BlockOperator(*ops)
K = scalar * k
val = 1
X = BlockDataContainer(*x) + val
Y = K.T.direct(X)
self.assertTrue(Y.shape == (1, 1))
zero = numpy.zeros(X.get_item(0).shape)
xx = numpy.asarray([val for _ in x])
numpy.testing.assert_array_equal(
Y.get_item(0).as_array(), (scalar * xx).sum() + zero)
scalar = numpy.asarray([i + 1 for i, el in enumerate(x)])
#scalar = numpy.asarray([6,0])
k = BlockOperator(*ops)
K = scalar * k
X = BlockDataContainer(*x) + val
Y = K.T.direct(X)
self.assertTrue(Y.shape == (1, 1))
zero = numpy.zeros(X.get_item(0).shape)
xx = numpy.asarray([val for _ in x])
numpy.testing.assert_array_equal(
Y.get_item(0).as_array(), (scalar * xx).sum() + zero)
def test_Function(self):
numpy.random.seed(10)
N = 3
ig = ImageGeometry(N, N)
ag = ig
op1 = GradientOperator(ig)
op2 = IdentityOperator(ig, ag)
# Form Composite Operator
operator = BlockOperator(op1, op2, shape=(2, 1))
# Create functions
noisy_data = ag.allocate(ImageGeometry.RANDOM)
d = ag.allocate(ImageGeometry.RANDOM)
alpha = 0.5
# scaled function
g = alpha * L2NormSquared(b=noisy_data)
# Compare call of g
a2 = alpha * (d - noisy_data).power(2).sum()
#print(a2, g(d))
self.assertEqual(a2, g(d))
# Compare convex conjugate of g
a3 = 0.5 * d.squared_norm() + d.dot(noisy_data)
self.assertAlmostEqual(a3, g.convex_conjugate(d), places=7)
def test_ScaledBlockOperatorSingleScalar(self):
ig = [ ImageGeometry(10,20,30) , \
ImageGeometry(10,20,30) , \
ImageGeometry(10,20,30) ]
x = [g.allocate() for g in ig]
ops = [IdentityOperator(g) for g in ig]
val = 1
# test limit as non Scaled
scalar = 1
k = BlockOperator(*ops)
K = scalar * k
X = BlockDataContainer(*x) + val
Y = K.T.direct(X)
self.assertTrue(Y.shape == (1, 1))
zero = numpy.zeros(X.get_item(0).shape)
xx = numpy.asarray([val for _ in x])
numpy.testing.assert_array_equal(
Y.get_item(0).as_array(), ((scalar * xx).sum() + zero))
scalar = 0.5
k = BlockOperator(*ops)
K = scalar * k
X = BlockDataContainer(*x) + 1
Y = K.T.direct(X)
self.assertTrue(Y.shape == (1, 1))
zero = numpy.zeros(X.get_item(0).shape)
numpy.testing.assert_array_equal(
Y.get_item(0).as_array(), scalar * (len(x) + zero))
def test_GD(self):
print("Test GD")
ig = ImageGeometry(12, 13, 14)
initial = ig.allocate()
# b = initial.copy()
# fill with random numbers
# b.fill(numpy.random.random(initial.shape))
b = ig.allocate('random')
identity = IdentityOperator(ig)
norm2sq = LeastSquares(identity, b)
rate = norm2sq.L / 3.
alg = GD(initial=initial,
objective_function=norm2sq,
rate=rate,
atol=1e-9,
rtol=1e-6)
alg.max_iteration = 1000
alg.run(verbose=0)
self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
alg = GD(initial=initial,
objective_function=norm2sq,
rate=rate,
max_iteration=20,
update_objective_interval=2,
atol=1e-9,
rtol=1e-6)
alg.max_iteration = 20
self.assertTrue(alg.max_iteration == 20)
self.assertTrue(alg.update_objective_interval == 2)
alg.run(20, verbose=0)
self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array())
def test_PowerMethod(self):
# 2x2 real matrix, dominant eigenvalue = 2
M1 = numpy.array([[1, 0], [1, 2]], dtype=float)
M1op = MatrixOperator(M1)
res1 = M1op.PowerMethod(M1op, 100)
numpy.testing.assert_almost_equal(res1, 2., decimal=4)
# Test with the norm
res2 = M1op.norm()
numpy.testing.assert_almost_equal(res1, res2, decimal=4)
# 2x3 real matrix, dominant eigenvalue = 4.711479432297657
M1 = numpy.array([[1., 0., 3], [1, 2., 3]])
M1op = MatrixOperator(M1)
res1 = M1op.PowerMethod(M1op, 100)
numpy.testing.assert_almost_equal(res1, 4.711479432297657, decimal=4)
# 2x3 complex matrix, (real eigenvalues), dominant eigenvalue = 5.417602365823937
M1 = numpy.array([[2, 1j, 0], [2j, 5j, 0]])
M1op = MatrixOperator(M1)
res1 = M1op.PowerMethod(M1op, 100)
numpy.testing.assert_almost_equal(res1, 5.417602365823937, decimal=4)
# 3x3 complex matrix, (real+complex eigenvalue), dominant eigenvalue = 3.1624439599276974
M1 = numpy.array([[2, 0, 0], [1, 2j, 1j], [3, 3 - 1j, 3]])
M1op = MatrixOperator(M1)
res1 = M1op.PowerMethod(M1op, 100)
numpy.testing.assert_almost_equal(res1, 3.1624439599276974, decimal=4)
# Gradient Operator (float)
ig = ImageGeometry(30, 30)
Grad = GradientOperator(ig)
res1 = Grad.PowerMethod(Grad, 500, tolerance=1e-6)
numpy.testing.assert_almost_equal(res1, numpy.sqrt(8), decimal=2)
# Gradient Operator (complex)
ig = ImageGeometry(30, 30, dtype=numpy.complex)
Grad = GradientOperator(ig)
res1 = Grad.PowerMethod(Grad, 500, tolerance=1e-6)
numpy.testing.assert_almost_equal(res1, numpy.sqrt(8), decimal=2)
# Identity Operator
Id = IdentityOperator(ig)
res1 = Id.PowerMethod(Id, 100)
numpy.testing.assert_almost_equal(res1, 1.0, decimal=4)
def test_ScaledOperator(self):
print("test_ScaledOperator")
ig = ImageGeometry(10, 20, 30)
img = ig.allocate()
scalar = 0.5
sid = scalar * IdentityOperator(ig)
numpy.testing.assert_array_equal(scalar * img.as_array(),
sid.direct(img).as_array())
def test_CompositionOperator_adjoint7(self):
ig = self.ig
data = self.data
G = GradientOperator(domain_geometry=ig)
Id1 = 2 * IdentityOperator(ig)
Id2 = IdentityOperator(ig)
d = CompositionOperator(G, Id1, Id2)
out1 = G.direct(data)
out2 = G.adjoint(out1)
d_out = d.adjoint(out1)
numpy.testing.assert_array_almost_equal(d_out.as_array(),
2 * out2.as_array())
numpy.testing.assert_array_almost_equal(d_out.as_array(),
2 * out2.as_array())
def test_CompositionOperator_direct1(self):
ig = self.ig
data = self.data
G = GradientOperator(domain_geometry=ig)
Id1 = 2 * IdentityOperator(ig)
Id2 = IdentityOperator(ig)
d = CompositionOperator(G, Id2)
out1 = G.direct(data)
out2 = d.direct(data)
numpy.testing.assert_array_almost_equal(
out2.get_item(0).as_array(),
out1.get_item(0).as_array())
numpy.testing.assert_array_almost_equal(
out2.get_item(1).as_array(),
out1.get_item(1).as_array())
def test_compare_with_PDHG(self):
# Load an image from the CIL gallery.
data = dataexample.SHAPES.get()
ig = data.geometry
# Add gaussian noise
noisy_data = applynoise.gaussian(data, seed=10, var=0.005)
# TV regularisation parameter
alpha = 1
# fidelity = 0.5 * L2NormSquared(b=noisy_data)
# fidelity = L1Norm(b=noisy_data)
fidelity = KullbackLeibler(b=noisy_data, use_numba=False)
# Setup and run the PDHG algorithm
F = BlockFunction(alpha * MixedL21Norm(), fidelity)
G = ZeroFunction()
K = BlockOperator(GradientOperator(ig), IdentityOperator(ig))
# Compute operator Norm
normK = K.norm()
# Primal & dual stepsizes
sigma = 1. / normK
tau = 1. / normK
pdhg = PDHG(f=F,
g=G,
operator=K,
tau=tau,
sigma=sigma,
max_iteration=100,
update_objective_interval=10)
pdhg.run(verbose=0)
sigma = 1
tau = sigma / normK**2
admm = LADMM(f=G,
g=F,
operator=K,
tau=tau,
sigma=sigma,
max_iteration=100,
update_objective_interval=10)
admm.run(verbose=0)
from cil.utilities.quality_measures import psnr
if debug_print:
print("PSNR", psnr(admm.solution, pdhg.solution))
np.testing.assert_almost_equal(psnr(admm.solution, pdhg.solution),
84.46678222768597,
decimal=4)
def test_Norm2sq_as_OperatorCompositionFunction(self):
print('Test for OperatorCompositionFunction')
M, N = 50, 50
ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N)
#numpy.random.seed(1)
b = ig.allocate('random', seed=1)
print('Check call with IdentityOperator operator... OK\n')
operator = 3 * IdentityOperator(ig)
u = ig.allocate('random', seed=50)
f = 0.5 * L2NormSquared(b=b)
func1 = OperatorCompositionFunction(f, operator)
func2 = LeastSquares(operator, b, 0.5)
print("f.L {}".format(f.L))
print("0.5*f.L {}".format((0.5 * f).L))
print("type func1 {}".format(type(func1)))
print("func1.L {}".format(func1.L))
print("func2.L {}".format(func2.L))
print("operator.norm() {}".format(operator.norm()))
numpy.testing.assert_almost_equal(func1(u), func2(u))
print('Check gradient with IdentityOperator operator... OK\n')
tmp1 = ig.allocate()
tmp2 = ig.allocate()
res_gradient1 = func1.gradient(u)
res_gradient2 = func2.gradient(u)
func1.gradient(u, out=tmp1)
func2.gradient(u, out=tmp2)
self.assertNumpyArrayAlmostEqual(res_gradient1.as_array(),
res_gradient2.as_array())
self.assertNumpyArrayAlmostEqual(tmp1.as_array(), tmp2.as_array())
print('Check call with MatrixOperator... OK\n')
mat = np.random.randn(M, N)
operator = MatrixOperator(mat)
vg = VectorGeometry(N)
b = vg.allocate('random')
u = vg.allocate('random')
func1 = OperatorCompositionFunction(0.5 * L2NormSquared(b=b), operator)
func2 = LeastSquares(operator, b, 0.5)
self.assertNumpyArrayAlmostEqual(func1(u), func2(u))
numpy.testing.assert_almost_equal(func1.L, func2.L)
def test_exception_initial_CGLS(self):
if debug_print:
print ("Test CGLS")
ig = ImageGeometry(10,2)
numpy.random.seed(2)
initial = ig.allocate(0.)
b = ig.allocate('random')
identity = IdentityOperator(ig)
try:
alg = CGLS(initial=initial, operator=identity, data=b, x_init=initial)
assert False
except ValueError as ve:
assert True
def test_PDHG_strongly_convex_both_fconj_and_g(self):
ig = ImageGeometry(3,3)
data = ig.allocate('random')
f = L2NormSquared(b=data)
g = L2NormSquared()
operator = IdentityOperator(ig)
try:
pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10,
gamma_g = 0.5, gamma_fconj=0.5)
pdhg.run(verbose=0)
except ValueError as err:
print(err)
def test_Lipschitz(self):
print('Test for OperatorCompositionFunction')
M, N = 50, 50
ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N)
b = ig.allocate('random', seed=1)
print('Check call with IdentityOperator operator... OK\n')
operator = 3 * IdentityOperator(ig)
u = ig.allocate('random_int', seed=50)
func2 = LeastSquares(operator, b, 0.5)
assert func2.L != 2
print(func2.L)
func2.L = 2
assert func2.L == 2
def test_BlockOperatorLinearValidity(self):
print("test_BlockOperatorLinearValidity")
M, N = 3, 4
ig = ImageGeometry(M, N)
arr = ig.allocate('random', seed=1)
G = GradientOperator(ig)
Id = IdentityOperator(ig)
B = BlockOperator(G, Id)
# Nx1 case
u = ig.allocate('random', seed=2)
w = B.range_geometry().allocate(ImageGeometry.RANDOM, seed=3)
w1 = B.direct(u)
u1 = B.adjoint(w)
self.assertAlmostEqual((w * w1).sum(), (u1 * u).sum(), places=5)
def test_Lipschitz3(self):
print('Test for test_Lipschitz3')
M, N = 50, 50
ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N)
b = ig.allocate('random', seed=1)
print('Check call with IdentityOperator operator... OK\n')
operator = 3 * IdentityOperator(ig)
u = ig.allocate('random_int', seed=50)
# func2 = LeastSquares(operator, b, 0.5)
func1 = ConstantFunction(0.3)
f3 = TranslateFunction(func1, 3)
assert f3.L != 2
print(f3.L)
f3.L = 2
assert f3.L == 2
def test_SIRT(self):
if debug_print:
print("Test CGLS")
#ig = ImageGeometry(124,153,154)
ig = ImageGeometry(10, 2)
numpy.random.seed(2)
initial = ig.allocate(0.)
b = ig.allocate('random')
# b = initial.copy()
# fill with random numbers
# b.fill(numpy.random.random(initial.shape))
# b = ig.allocate()
# bdata = numpy.reshape(numpy.asarray([i for i in range(20)]), (2,10))
# b.fill(bdata)
identity = IdentityOperator(ig)
alg = SIRT(initial=initial, operator=identity, data=b)
alg.max_iteration = 200
alg.run(20, verbose=0)
np.testing.assert_array_almost_equal(alg.x.as_array(), b.as_array())
alg2 = SIRT(initial=initial, operator=identity, data=b, upper=0.3)
alg2.max_iteration = 200
alg2.run(20, verbose=0)
# equal
try:
numpy.testing.assert_equal(alg2.get_output().max(), 0.3)
if debug_print:
print("Equal OK, returning")
return
except AssertionError as ae:
if debug_print:
print("Not equal, trying almost equal")
# almost equal to 7 digits or less
try:
numpy.testing.assert_almost_equal(alg2.get_output().max(), 0.3)
if debug_print:
print("Almost Equal OK, returning")
return
except AssertionError as ae:
if debug_print:
print("Not almost equal, trying less")
numpy.testing.assert_array_less(alg2.get_output().max(), 0.3)
def test_exception_initial_GD(self):
print("Test FISTA")
ig = ImageGeometry(127, 139, 149)
initial = ig.allocate()
b = initial.copy()
# fill with random numbers
b.fill(numpy.random.random(initial.shape))
initial = ig.allocate(ImageGeometry.RANDOM)
identity = IdentityOperator(ig)
norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity)
opt = {'tol': 1e-4, 'memopt': False}
print("initial objective", norm2sq(initial))
try:
alg = GD(initial=initial,
objective_function=norm2sq,
x_init=initial)
assert False
except ValueError as ve:
assert True
def test_Lipschitz4(self):
print('Test for test_Lipschitz4')
M, N = 50, 50
ig = ImageGeometry(voxel_num_x=M, voxel_num_y=N)
b = ig.allocate('random', seed=1)
print('Check call with IdentityOperator operator... OK\n')
operator = 3 * IdentityOperator(ig)
u = ig.allocate('random_int', seed=50)
# func2 = LeastSquares(operator, b, 0.5)
func1 = ConstantFunction(0.3)
f3 = func1 + 3
assert f3.L == 0
print("OK")
print(f3.L)
f3.L = 2
assert f3.L == 2
print("OK")
assert func1.L == 0
print("OK")
try:
func1.L = 2
assert False
except AttributeError as ve:
assert True
print("OK")
f2 = LeastSquares(operator, b, 0.5)
f4 = 2 * f2
assert f4.L == 2 * f2.L
print("OK")
f4.L = 10
assert f4.L != 2 * f2.L
print("OK")
f4 = -2 * f2
assert f4.L == 2 * f2.L
