def descent(self, tolerance=1e-4, max_iter=150):
self.operator.get_spec_rad()
cost0 = 0.0
for i in range(max_iter):
grad = self.operator.grad_step(self.algorithm.data_rec, self.data)
self.algorithm.check_threshold(i, grad)
self.algorithm.update(grad, self.operator.inv_spec_rad)
l2norm0 = norm(self.data - pca_convolve(self.algorithm.data_rec_prev, self.operator.psf_pcs, self.operator.psf_coef), 2)
l2norm1 = norm(self.data - pca_convolve(self.algorithm.data_rec, self.operator.psf_pcs, self.operator.psf_coef), 2)
if l2norm1 > l2norm0:
self.algorithm.speed_switch(False)
nuc_norm = nuclear_norm(map2matrix(self.algorithm.data_rec,
self.layout))
l2norm = norm(self.data - pca_convolve(self.algorithm.data_rec,
self.operator.psf_pcs, self.operator.psf_coef), 2)
cost = (0.5 * l2norm ** 2 + self.algorithm.thresh * nuc_norm)
print ' - i:', i, cost, l2norm, nuc_norm
if np.abs(cost - cost0) < tolerance:
print ' - Gradient Descent converged after %d iterations!' % \
(i + 1)
print ' - Final cost, l2norm, nuc_norm:', cost, l2norm, nuc_norm
break
elif i == max_iter - 1:
print ' - Gradient Descent did not converge after %d iterations!' \
% max_iter
print ' - Final cost, l2norm, nuc_norm:', cost, l2norm, nuc_norm
cost0 = cost
return self.algorithm.data_rec
def condat(image, psf_pcs, psf_coef, image_rec=None, layout=None,
inv_spec_rad=None, filters=None, wavelet_levels=None,
wavelet_opt=None, weights=None, thresh_factor=3, n_reweights=0,
tolerance=1e-4, max_iter=150):
print ' - Wavelet Levels:', wavelet_levels
print ' - Threshold Factor:', thresh_factor
print ' - Reweights:', n_reweights
if isinstance(filters, type(None)):
filters = get_mr_filters(image.shape, wavelet_levels, wavelet_opt)
filters_rot = rotate_filters(filters)
x_old = np.ones(image.shape)
y_old = np.ones([filters.shape[0]] + list(image.shape))
transpose_test(convolve_mr_filters, deconvolve_mr_filters, x_old.shape,
(filters,), y_old.shape, (filters_rot,))
if isinstance(weights, type(None)):
error_weights = get_noise_est(psf_pcs, psf_coef, filters)
if isinstance(inv_spec_rad, type(None)):
beta = power_method(psf_pcs, psf_coef)
else:
beta = 1.0 / inv_spec_rad
l1norm_filters = sum([norm(filter, 1) for filter in filters])
tau = 1.0 / (beta + l1norm_filters)
# tau = (l1norm_filters**2 + inv_spec_rad**2/2)**(-1)
sigma = tau
# sigma=1
rho_n = 0.5
print ''
print ' SPEC_RAD:', beta
print ' SIGMA:', sigma
print ' TAU:', tau
print ' TAU/SIGMA TEST:', (1 / tau - sigma * l1norm_filters ** 2 >= beta / 2)
print ' RHO_n:', rho_n
print ''
print ' i COST L2_NORM L1_NORM'
# Set initial weights
weights = thresh_factor * np.copy(error_weights)
for j in range(n_reweights + 1):
for i in range(max_iter):
grad = grad_step(x_old, image, psf_coef, psf_pcs)
# weights = sigma * get_sigma_map(grad)
x_prox = x_old - tau * grad - tau * deconvolve_mr_filters(y_old, filters_rot)
x_temp = keep_positive(x_prox)
y_prox = y_old + sigma * convolve_mr_filters(2 * x_temp - x_old, filters)
y_temp = y_prox - sigma * weighted_threshold(y_prox / sigma, 1 / sigma, weights)
x_new, y_new = rho_n * np.array([x_temp, y_temp]) + (1 - rho_n) * np.array([x_old, y_old])
np.copyto(x_old, x_new)
np.copyto(y_old, y_new)
l2norm = norm(image - pca_convolve(x_new, psf_pcs, psf_coef), 2)
l1norm = sum([norm(a, 1) for a in np.multiply(weights, convolve_mr_filters(x_new, filters))])
cost = 0.5 * l2norm ** 2 + sigma * l1norm
print '', i, cost, l2norm, l1norm
# Reweight
x_wave = convolve_mr_filters(x_new, filters)
weights *= (1.0 / (1.0 + np.abs(x_wave) / (thresh_factor * error_weights)))
print ''
return x_new
def gradient_descent(image, psf_pcs, psf_coef, image_rec=None, layout=None,
inv_spec_rad=None, thresh_factor=3, tolerance=1e-4,
max_iter=150):
operator = PixelVariantPSF(psf_pcs, psf_coef)
operator.get_spec_rad()
algorithm = LowRankMatrix(image.shape, layout)
if isinstance(image_rec, type(None)):
# Set inital guess for gradient descent.
image_rec = np.ones(image.shape)
# Get the inverse spectral radius
if isinstance(inv_spec_rad, type(None)):
inv_spec_rad = operator.inv_spec_rad
rec_flag = False
else:
# Get SVD of the initial image reconstruction.
image_matrix = map2matrix(image_rec, layout)
u, s, v = np.linalg.svd(image_matrix)
s = np.diag(s)
s.resize(image_matrix.shape)
a = np.dot(s, v)
a0 = np.copy(a)
# Get the inverse spectral radius
if isinstance(inv_spec_rad, type(None)):
inv_spec_rad = 1. / power_method_UA([u, a], psf_pcs, psf_coef,
[image.shape, layout])
rec_flag = True
# Set inital values for testing convergence.
image_rec_xn = np.copy(image_rec)
image_rec_zn = np.copy(image_rec_xn)
cost0 = 0.0
t0 = 1.0
nuc_norm = 0.0
use_speed_up = True
print ' * 1/rho =', inv_spec_rad
# Perfom gradient descent to reconstruct image.
for i in range(max_iter):
if rec_flag:
image_matrix = map2matrix(-1. * operator.grad_step(image_rec_zn,
image), layout)
a1 = a + inv_spec_rad * np.dot(u.T, image_matrix)
a1 = np.dot(u.T, keep_positive(np.dot(u, a1)))
a, t0 = speed_up(a1, a0, t0)
image_rec_zn = matrix2map(np.dot(u, a), image.shape)
a0 = np.copy(a1)
else:
# Calculate the gradient for this step.
grad = operator.grad_step(image_rec_zn, image)
algorithm.check_threshold(i, grad)
algorithm.update(grad, inv_spec_rad)
l2norm0 = norm(image - pca_convolve(algorithm.data_rec_prev, psf_pcs, psf_coef), 2)
l2norm1 = norm(image - pca_convolve(algorithm.data_rec, psf_pcs, psf_coef), 2)
if l2norm1 > l2norm0:
use_speed_up = False
if use_speed_up:
image_rec_zn, t0 = speed_up(algorithm.data_rec, algorithm.data_rec_prev, t0)
else:
image_rec_zn = np.copy(algorithm.data_rec)
u3, s3, v3 = np.linalg.svd(map2matrix(image_rec_zn, layout))
nuc_norm = np.sum(s3)
l2norm = norm(image - pca_convolve(image_rec_zn, psf_pcs, psf_coef), 2)
cost = (0.5 * l2norm ** 2 + algorithm.thresh * nuc_norm)
# print ' - i:', i, cost, thresh, l2norm
if np.abs(cost - cost0) < tolerance:
print ' - Gradient Descent converged after %d iterations!' % \
(i + 1)
print ' - Final cost, thresh, l2norm:', cost, algorithm.thresh, l2norm
break
elif i == max_iter - 1:
print ' - Gradient Descent did not converge after %d iterations!' \
% max_iter
print ' - Final cost, thresh, l2norm:', cost, algorithm.thresh, l2norm
cost0 = cost
image_rec = image_rec_zn
return image_rec
def gradient_descent(image, psf_pcs, psf_coef, image_rec=None, layout=None,
inv_spec_rad=None, thresh_factor=3, tolerance=1e-4,
max_iter=150):
operator = PixelVariantPSF(psf_pcs, psf_coef)
if isinstance(image_rec, type(None)):
# Set inital guess for gradient descent.
image_rec = np.ones(image.shape)
# Get the inverse spectral radius
if isinstance(inv_spec_rad, type(None)):
inv_spec_rad = 1. / power_method(psf_pcs, psf_coef)
rec_flag = False
else:
# Get SVD of the initial image reconstruction.
image_matrix = map2matrix(image_rec, layout)
u, s, v = np.linalg.svd(image_matrix)
s = np.diag(s)
s.resize(image_matrix.shape)
a = np.dot(s, v)
a0 = np.copy(a)
# Get the inverse spectral radius
if isinstance(inv_spec_rad, type(None)):
inv_spec_rad = 1. / power_method_UA([u, a], psf_pcs, psf_coef,
[image.shape, layout])
rec_flag = True
# Set inital values for testing convergence.
image_rec_xn = np.copy(image_rec)
image_rec_zn = np.copy(image_rec_xn)
cost0 = 0.0
t0 = 1.0
nuc_norm = 0.0
thresh = 0.0
thresh0 = 100.0
update_thresh = True
use_speed_up = True
print ' * 1/rho =', inv_spec_rad
# Perfom gradient descent to reconstruct image.
for i in range(max_iter):
if rec_flag:
image_matrix = map2matrix(-1. * grad_step(image_rec_zn, image,
psf_coef, psf_pcs), layout)
a1 = a + inv_spec_rad * np.dot(u.T, image_matrix)
a1 = np.dot(u.T, keep_positive(np.dot(u, a1)))
a, t0 = speed_up(a1, a0, t0)
image_rec_zn = matrix2map(np.dot(u, a), image.shape)
a0 = np.copy(a1)
else:
# Calculate the gradient for this step.
# grad = grad_step(image_rec_zn, image, psf_coef, psf_pcs)
grad = operator.grad_step(image_rec_zn, image)
uu, ss, vv = np.linalg.svd(map2matrix(grad, layout))
if update_thresh:
thresh = thresh_factor * np.median(ss)
if np.abs(thresh - thresh0) < tolerance:
update_thresh = False
print ' - Threshold converged!'
else:
thresh0 = thresh
if update_thresh and i == 50:
update_thresh = False
print ' - Threshold stabalised after 50 iterations.'
image_rec_yn = image_rec_zn - inv_spec_rad * grad
image_matrix = map2matrix(image_rec_yn, layout)
image_matrix, nuc_normxx = threshold(image_matrix, thresh,
threshold_type='soft',
return_nuc_norm=True)
image_rec_xn_1 = matrix2map(image_matrix, image.shape)
l2norm0 = norm(image - pca_convolve(image_rec_xn, psf_pcs, psf_coef), 2)
l2norm1 = norm(image - pca_convolve(image_rec_xn_1, psf_pcs, psf_coef), 2)
if l2norm1 > l2norm0:
use_speed_up = False
if use_speed_up:
image_rec_zn, t0 = speed_up(image_rec_xn_1, image_rec_xn, t0)
else:
image_rec_zn = np.copy(image_rec_xn_1)
image_rec_xn = np.copy(image_rec_xn_1)
u3, s3, v3 = np.linalg.svd(map2matrix(image_rec_zn, layout))
nuc_norm = np.sum(s3)
l2norm = norm(image - pca_convolve(image_rec_zn, psf_pcs, psf_coef), 2)
cost = (0.5 * l2norm ** 2 + thresh * nuc_norm)
# print ' - i:', i, cost, thresh, l2norm
if np.abs(cost - cost0) < tolerance:
print ' - Gradient Descent converged after %d iterations!' % \
(i + 1)
print ' - Final cost, thresh, l2norm:', cost, thresh, l2norm
break
elif i == max_iter - 1:
print ' - Gradient Descent did not converge after %d iterations!' \
% max_iter
print ' - Final cost, thresh, l2norm:', cost, thresh, l2norm
cost0 = cost
image_rec = image_rec_zn
return image_rec