def skip_test_FISTA_denoise_cvx(self):
if not cvx_not_installable:
opt = {'memopt': True}
N = 64
ig = ImageGeometry(voxel_num_x=N, voxel_num_y=N)
Phantom = ImageData(geometry=ig)
x = Phantom.as_array()
x[int(round(N / 4)):int(round(3 * N / 4)),
int(round(N / 4)):int(round(3 * N / 4))] = 0.5
x[int(round(N / 8)):int(round(7 * N / 8)),
int(round(3 * N / 8)):int(round(5 * N / 8))] = 1
# Identity operator for denoising
I = TomoIdentity(ig)
# Data and add noise
y = I.direct(Phantom)
y.array = y.array + 0.1 * np.random.randn(N, N)
# Data fidelity term
f_denoise = Norm2sq(I, y, c=0.5, memopt=True)
x_init = ImageData(geometry=ig)
f_denoise.L = PowerMethodNonsquare(I, 25, x_init)[0]
# 1-norm regulariser
lam1_denoise = 1.0
g1_denoise = Norm1(lam1_denoise)
# Initial guess
x_init_denoise = ImageData(np.zeros((N, N)))
# Combine with least squares and solve using generic FISTA implementation
x_fista1_denoise, it1_denoise, timing1_denoise, \
criter1_denoise = \
FISTA(x_init_denoise, f_denoise, g1_denoise, opt=opt)
print(x_fista1_denoise)
print(criter1_denoise[-1])
# Now denoise LS + 1-norm with FBPD
x_fbpd1_denoise, itfbpd1_denoise, timingfbpd1_denoise,\
criterfbpd1_denoise = \
FBPD(x_init_denoise, I, None, f_denoise, g1_denoise)
print(x_fbpd1_denoise)
print(criterfbpd1_denoise[-1])
# Compare to CVXPY
# Construct the problem.
x1_denoise = Variable(N**2)
objective1_denoise = Minimize(
0.5 * sum_squares(x1_denoise - y.array.flatten()) +
lam1_denoise * norm(x1_denoise, 1))
prob1_denoise = Problem(objective1_denoise)
# The optimal objective is returned by prob.solve().
result1_denoise = prob1_denoise.solve(verbose=False,
solver=SCS,
eps=1e-12)
# The optimal solution for x is stored in x.value and optimal objective value
# is in result as well as in objective.value
print(
"CVXPY least squares plus 1-norm solution and objective value:"
)
print(x1_denoise.value)
print(objective1_denoise.value)
self.assertNumpyArrayAlmostEqual(x_fista1_denoise.array.flatten(),
x1_denoise.value, 5)
self.assertNumpyArrayAlmostEqual(x_fbpd1_denoise.array.flatten(),
x1_denoise.value, 5)
x1_cvx = x1_denoise.value
x1_cvx.shape = (N, N)
# Now TV with FBPD
lam_tv = 0.1
gtv = TV2D(lam_tv)
gtv(gtv.op.direct(x_init_denoise))
opt_tv = {'tol': 1e-4, 'iter': 10000}
x_fbpdtv_denoise, itfbpdtv_denoise, timingfbpdtv_denoise,\
criterfbpdtv_denoise = \
FBPD(x_init_denoise, gtv.op, None, f_denoise, gtv, opt=opt_tv)
print(x_fbpdtv_denoise)
print(criterfbpdtv_denoise[-1])
# Compare to CVXPY
# Construct the problem.
xtv_denoise = Variable((N, N))
objectivetv_denoise = Minimize(0.5 *
sum_squares(xtv_denoise - y.array) +
lam_tv * tv(xtv_denoise))
probtv_denoise = Problem(objectivetv_denoise)
# The optimal objective is returned by prob.solve().
resulttv_denoise = probtv_denoise.solve(verbose=False,
solver=SCS,
eps=1e-12)
# The optimal solution for x is stored in x.value and optimal objective value
# is in result as well as in objective.value
print(
"CVXPY least squares plus 1-norm solution and objective value:"
)
print(xtv_denoise.value)
print(objectivetv_denoise.value)
self.assertNumpyArrayAlmostEqual(x_fbpdtv_denoise.as_array(),
xtv_denoise.value, 1)
else:
self.assertTrue(cvx_not_installable)
def skip_test_FBPD_Norm1_cvx(self):
print("test_FBPD_Norm1_cvx")
if not cvx_not_installable:
opt = {'memopt': True}
# Problem data.
m = 30
n = 20
np.random.seed(1)
Amat = np.random.randn(m, n)
A = LinearOperatorMatrix(Amat)
bmat = np.random.randn(m)
bmat.shape = (bmat.shape[0], 1)
# A = Identity()
# Change n to equal to m.
b = DataContainer(bmat)
# Regularization parameter
lam = 10
opt = {'memopt': True}
# Initial guess
x_init = DataContainer(np.random.randn(n, 1))
# Create object instances with the test data A and b.
f = Norm2sq(A, b, c=0.5, memopt=True)
f.L = PowerMethodNonsquare(A, 25, x_init)[0]
print("Lipschitz", f.L)
g0 = ZeroFun()
# Create 1-norm object instance
g1 = Norm1(lam)
# Compare to CVXPY
# Construct the problem.
x1 = Variable(n)
objective1 = Minimize(0.5 * sum_squares(Amat * x1 - bmat.T[0]) +
lam * norm(x1, 1))
prob1 = Problem(objective1)
# The optimal objective is returned by prob.solve().
result1 = prob1.solve(verbose=False, solver=SCS, eps=1e-9)
# The optimal solution for x is stored in x.value and optimal objective value
# is in result as well as in objective.value
print(
"CVXPY least squares plus 1-norm solution and objective value:"
)
print(x1.value)
print(objective1.value)
# Now try another algorithm FBPD for same problem:
x_fbpd1, itfbpd1, timingfbpd1, criterfbpd1 = FBPD(
x_init, Identity(), None, f, g1)
print(x_fbpd1)
print(criterfbpd1[-1])
self.assertNumpyArrayAlmostEqual(numpy.squeeze(x_fbpd1.array),
x1.value, 6)
else:
self.assertTrue(cvx_not_installable)
def get_max_sing_val(self):
self.s1, sall, svec = PowerMethodNonsquare(self,10)
return self.s1
def get_max_sing_val(self):
a = PowerMethodNonsquare(self,10)
self.s1 = a[0]
return self.s1
def get_max_sing_val(self):
if self.s1 is None:
self.s1, sall, svec = PowerMethodNonsquare(self,10)
return self.s1
else:
return self.s1