# Compute operator Norm
normK1 = operator1.norm()
normK2 = operator2.norm()
# Primal & dual stepsizes
sigma1 = 1
tau1 = 1 / (sigma1 * normK1**2)
sigma2 = 1
tau2 = 1 / (sigma2 * normK2**2)
# Setup and run the PDHG algorithm
pdhg1 = PDHG(f=f, g=g, operator=operator1, tau=tau1, sigma=sigma1)
pdhg1.max_iteration = 2000
pdhg1.update_objective_interval = 200
pdhg1.run(1000)
# Setup and run the PDHG algorithm
pdhg2 = PDHG(f=f, g=g, operator=operator2, tau=tau2, sigma=sigma2)
pdhg2.max_iteration = 2000
pdhg2.update_objective_interval = 200
pdhg2.run(1000)
#%%
tindex = [8, 16, 24]
fig2, axes2 = plt.subplots(nrows=3, ncols=3, figsize=(10, 10))
# Ground Truth
axes2[0, 0].imshow(phantom_2Dt[tindex[0], :, :])
axes2[0, 0].set_title('Time {}'.format(tindex[0]))
# Create functions
f1 = 0.5 * alpha**2 * L2NormSquared()
f2 = 0.5 * L2NormSquared(b=noisy_data)
f = BlockFunction(f1, f2)
g = ZeroFunction()
## Compute operator Norm
normK = op_PDHG.norm()
## Primal & dual stepsizes
sigma = 10
tau = 1 / (sigma * normK**2)
pdhg = PDHG(f=f, g=g, operator=op_PDHG, tau=tau, sigma=sigma)
pdhg.max_iteration = 1000
pdhg.update_objective_interval = 200
pdhg.run(1000, verbose=False)
# Show results
plt.figure(figsize=(10, 10))
plt.subplot(2, 1, 1)
plt.imshow(cgls.get_output().as_array())
plt.title('CGLS reconstruction')
plt.subplot(2, 1, 2)
plt.imshow(pdhg.get_output().as_array())
plt.title('PDHG reconstruction')
plt.show()
def test_PDHG_Denoising(self):
print ("PDHG Denoising with 3 noises")
# adapted from demo PDHG_TV_Color_Denoising.py in CIL-Demos repository
# loader = TestData(data_dir=os.path.join(os.environ['SIRF_INSTALL_PATH'], 'share','ccpi'))
# loader = TestData(data_dir=os.path.join(sys.prefix, 'share','ccpi'))
loader = TestData()
data = loader.load(TestData.PEPPERS, size=(256,256))
ig = data.geometry
ag = ig
which_noise = 0
# Create noisy data.
noises = ['gaussian', 'poisson', 's&p']
noise = noises[which_noise]
def setup(data, noise):
if noise == 's&p':
n1 = TestData.random_noise(data.as_array(), mode = noise, salt_vs_pepper = 0.9, amount=0.2, seed=10)
elif noise == 'poisson':
scale = 5
n1 = TestData.random_noise( data.as_array()/scale, mode = noise, seed = 10)*scale
elif noise == 'gaussian':
n1 = TestData.random_noise(data.as_array(), mode = noise, seed = 10)
else:
raise ValueError('Unsupported Noise ', noise)
noisy_data = ig.allocate()
noisy_data.fill(n1)
# Regularisation Parameter depending on the noise distribution
if noise == 's&p':
alpha = 0.8
elif noise == 'poisson':
alpha = 1
elif noise == 'gaussian':
alpha = .3
# fidelity
if noise == 's&p':
g = L1Norm(b=noisy_data)
elif noise == 'poisson':
g = KullbackLeibler(b=noisy_data)
elif noise == 'gaussian':
g = 0.5 * L2NormSquared(b=noisy_data)
return noisy_data, alpha, g
noisy_data, alpha, g = setup(data, noise)
operator = Gradient(ig, correlation=Gradient.CORRELATION_SPACE)
f1 = alpha * MixedL21Norm()
# Compute operator Norm
normK = operator.norm()
# Primal & dual stepsizes
sigma = 1
tau = 1/(sigma*normK**2)
# Setup and run the PDHG algorithm
pdhg1 = PDHG(f=f1,g=g,operator=operator, tau=tau, sigma=sigma)
pdhg1.max_iteration = 2000
pdhg1.update_objective_interval = 200
pdhg1.run(1000, very_verbose=True)
rmse = (pdhg1.get_output() - data).norm() / data.as_array().size
print ("RMSE", rmse)
self.assertLess(rmse, 2e-4)
which_noise = 1
noise = noises[which_noise]
noisy_data, alpha, g = setup(data, noise)
operator = Gradient(ig, correlation=Gradient.CORRELATION_SPACE)
f1 = alpha * MixedL21Norm()
# Compute operator Norm
normK = operator.norm()
# Primal & dual stepsizes
sigma = 1
tau = 1/(sigma*normK**2)
# Setup and run the PDHG algorithm
pdhg1 = PDHG(f=f1,g=g,operator=operator, tau=tau, sigma=sigma,
max_iteration=2000, update_objective_interval=200)
pdhg1.run(1000)
rmse = (pdhg1.get_output() - data).norm() / data.as_array().size
print ("RMSE", rmse)
self.assertLess(rmse, 2e-4)
which_noise = 2
noise = noises[which_noise]
noisy_data, alpha, g = setup(data, noise)
operator = Gradient(ig, correlation=Gradient.CORRELATION_SPACE)
f1 = alpha * MixedL21Norm()
# Compute operator Norm
normK = operator.norm()
# Primal & dual stepsizes
sigma = 1
tau = 1/(sigma*normK**2)
# Setup and run the PDHG algorithm
pdhg1 = PDHG(f=f1,g=g,operator=operator, tau=tau, sigma=sigma)
pdhg1.max_iteration = 2000
pdhg1.update_objective_interval = 200
pdhg1.run(1000)
rmse = (pdhg1.get_output() - data).norm() / data.as_array().size
print ("RMSE", rmse)
self.assertLess(rmse, 2e-4)