def sparse_rec_fista(gradient_op,
linear_op,
prox_op,
cost_op,
mu=1e-6,
nb_scales=4,
lambda_init=1.0,
max_nb_of_iter=300,
atol=1e-4,
metric_call_period=5,
metrics=None,
verbose=0):
""" The FISTA sparse reconstruction without reweightings.
.. note:: At the moment, tested only with 2D data.
Parameters
----------
gradient_op: instance of class GradBase
the gradient operator.
linear_op: instance of LinearBase
the linear operator: seek the sparsity, ie. a wavelet transform.
prox_op: instance of ProximityParent
the proximal operator.
cost_op: instance of costObj
the cost function used to check for convergence during the
optimization.
mu: float, (default 1e-6)
coefficient of regularization.
nb_scales: int, default 4
the number of scales in the wavelet decomposition.
lambda_init: float, (default 1.0)
initial value for the FISTA step.
max_nb_of_iter: int (optional, default 300)
the maximum number of iterations in the Condat-Vu proximal-dual
splitting algorithm.
atol: float (optional, default 1e-4)
tolerance threshold for convergence.
metric_call_period: int (default 5)
the period on which the metrics are compute.
metrics: dict (optional, default None)
the list of desired convergence metrics: {'metric_name':
[@metric, metric_parameter]}. See modopt for the metrics API.
verbose: int (optional, default 0)
the verbosity level.
Returns
-------
x_final: ndarray
the estimated FISTA solution.
transform: a WaveletTransformBase derived instance
the wavelet transformation instance.
costs: list of float
the cost function values.
metrics: dict
the requested metrics values during the optimization.
"""
# Check inputs
start = time.clock()
if not linear_op.transform.__is_decimated__:
warnings.warn("Undecimated wavelets shouldn't be used with FISTA: "
"non optimal solution.")
# Define the initial primal and dual solutions
x_init = np.zeros(gradient_op.fourier_op.shape, dtype=np.complex)
alpha = linear_op.op(x_init)
alpha[...] = 0.0
# Welcome message
if verbose > 0:
print(fista_logo())
print(" - mu: ", mu)
print(" - lipschitz constant: ", gradient_op.spec_rad)
print(" - data: ", gradient_op.fourier_op.shape)
if hasattr(linear_op, "nb_scale"):
print(" - wavelet: ", linear_op, "-", linear_op.nb_scale)
print(" - max iterations: ", max_nb_of_iter)
print(" - image variable shape: ", x_init.shape)
print(" - alpha variable shape: ", alpha.shape)
print("-" * 40)
# Define the proximity dual operator
weights = copy.deepcopy(alpha)
weights[...] = mu
prox_op.weights = weights
# Define the optimizer
opt = ForwardBackward(x=alpha,
grad=gradient_op,
prox=prox_op,
cost=cost_op,
auto_iterate=False,
metric_call_period=metric_call_period,
metrics=metrics or {},
linear=linear_op,
beta_param=gradient_op.inv_spec_rad)
cost_op = opt._cost_func
# Perform the reconstruction
if verbose > 0:
print("Starting optimization...")
opt.iterate(max_iter=max_nb_of_iter)
end = time.clock()
if verbose > 0:
# cost_op.plot_cost()
if hasattr(cost_op, "cost"):
print(" - final iteration number: ", cost_op._iteration)
print(" - final log10 cost value: ", np.log10(cost_op.cost))
print(" - converged: ", opt.converge)
print("Done.")
print("Execution time: ", end - start, " seconds")
print("-" * 40)
x_final = linear_op.adj_op(opt.x_final)
if hasattr(cost_op, "cost"):
costs = cost_op._cost_list
else:
costs = None
return x_final, linear_op.transform, costs, opt.metrics
def sparse_rec_fista(data, wavelet_name, samples, mu, nb_scales=4,
lambda_init=1.0, max_nb_of_iter=300, atol=1e-4,
non_cartesian=False, uniform_data_shape=None, verbose=0):
""" The FISTA sparse reconstruction without reweightings.
.. note:: At the moment, supports only 2D data.
Parameters
----------
data: ndarray
the data to reconstruct (observation are expected in the Fourier
space).
wavelet_name: str
the wavelet name to be used during the decomposition.
samples: np.ndarray
the mask samples in the Fourier domain.
mu: float
coefficient of regularization.
nb_scales: int, default 4
the number of scales in the wavelet decomposition.
lambda_init: float, (default 1.0)
initial value for the FISTA step.
max_nb_of_iter: int (optional, default 300)
the maximum number of iterations in the Condat-Vu proximal-dual
splitting algorithm.
atol: float (optional, default 1e-4)
tolerance threshold for convergence.
non_cartesian: bool (optional, default False)
if set, use the nfftw rather than the fftw. Expect an 1D input dataset.
uniform_data_shape: uplet (optional, default None)
the shape of the matrix containing the uniform data. Only required
for non-cartesian reconstructions.
verbose: int (optional, default 0)
the verbosity level.
Returns
-------
x_final: ndarray
the estimated FISTA solution.
transform: a WaveletTransformBase derived instance
the wavelet transformation instance.
"""
# Check inputs
start = time.clock()
if non_cartesian and data.ndim != 1:
raise ValueError("Expect 1D data with the non-cartesian option.")
elif non_cartesian and uniform_data_shape is None:
raise ValueError("Need to set the 'uniform_data_shape' parameter with "
"the non-cartesian option.")
elif not non_cartesian and data.ndim != 2:
raise ValueError("At the moment, this functuion only supports 2D "
"data.")
# Define the gradient/linear/fourier operators
linear_op = Wavelet2(
nb_scale=nb_scales,
wavelet_name=wavelet_name)
if non_cartesian:
fourier_op = NFFT2(
samples=samples,
shape=uniform_data_shape)
else:
fourier_op = FFT2(
samples=samples,
shape=data.shape)
gradient_op = GradSynthesis2(
data=data,
linear_op=linear_op,
fourier_op=fourier_op)
# Define the initial primal and dual solutions
x_init = np.zeros(fourier_op.shape, dtype=np.complex)
alpha = linear_op.op(x_init)
alpha[...] = 0.0
# Welcome message
if verbose > 0:
print(fista_logo())
print(" - mu: ", mu)
print(" - lipschitz constant: ", gradient_op.spec_rad)
print(" - data: ", data.shape)
print(" - wavelet: ", wavelet_name, "-", nb_scales)
print(" - max iterations: ", max_nb_of_iter)
print(" - image variable shape: ", x_init.shape)
print(" - alpha variable shape: ", alpha.shape)
print("-" * 40)
# Define the proximity dual operator
weights = copy.deepcopy(alpha)
weights[...] = mu
prox_op = SparseThreshold(linear_op, weights, thresh_type="soft")
# Define the optimizer
cost_op = None
opt = ForwardBackward(
x=alpha,
grad=gradient_op,
prox=prox_op,
cost=cost_op,
auto_iterate=False)
# Perform the reconstruction
end = time.clock()
if verbose > 0:
print("Starting optimization...")
opt.iterate(max_iter=max_nb_of_iter)
if verbose > 0:
# cost_op.plot_cost()
# print(" - final iteration number: ", cost_op._iteration)
# print(" - final log10 cost value: ", np.log10(cost_op.cost))
print(" - converged: ", opt.converge)
print("Done.")
print("Execution time: ", end - start, " seconds")
print("-" * 40)
x_final = linear_op.adj_op(opt.x_final)
return x_final, linear_op.transform
def sparse_rec_fista(gradient_op,
linear_op,
mu,
lambda_init=1.0,
max_nb_of_iter=300,
atol=1e-4,
verbose=0,
get_cost=False):
""" The FISTA sparse reconstruction without reweightings.
.. note:: At the moment, supports only 2D data.
Parameters
----------
gradient_op: Instance of class GradBase
The gradient operator of the differentiable part
linear_op: Instance of LinearBase
The linear operator is the tranform in wich we seek the sparsity.
samples: np.ndarray
the mask samples in the Fourier domain.
mu: float
coefficient of regularization.
nb_scales: int, default 4
the number of scales in the wavelet decomposition.
lambda_init: float, (default 1.0)
initial value for the FISTA step.
max_nb_of_iter: int (optional, default 300)
the maximum number of iterations in the Condat-Vu proximal-dual
splitting algorithm.
atol: float (optional, default 1e-4)
tolerance threshold for convergence.
verbose: int (optional, default 0)
the verbosity level.
get_cost: bool (default False)
computes the cost of the objective function
Returns
-------
x_final: ndarray
the estimated FISTA solution.
transform: a WaveletTransformBase derived instance
the wavelet transformation instance.
"""
# Check inputs
start = time.clock()
# Define the initial primal and dual solutions
x_init = np.zeros(gradient_op.fourier_op.shape, dtype=np.complex)
alpha = linear_op.op(x_init)
alpha[...] = 0.0
# Welcome message
if verbose > 0:
print(fista_logo())
print(" - mu: ", mu)
print(" - lipschitz constant: ", gradient_op.spec_rad)
print(" - data: ", gradient_op.obs_data.shape)
print(" - max iterations: ", max_nb_of_iter)
print(" - image variable shape: ", x_init.shape)
print(" - alpha variable shape: ", alpha.shape)
print("-" * 40)
# Define the proximity dual operator
weights = copy.deepcopy(alpha)
weights[...] = mu
prox_op = Threshold(weights)
# Define the optimizer
cost_op = None
opt = ForwardBackward(x=alpha,
grad=gradient_op,
prox=prox_op,
cost=cost_op,
auto_iterate=False)
# Perform the reconstruction
if verbose > 0:
print("Starting optimization...")
if get_cost:
cost = np.zeros(max_nb_of_iter)
for i in range(max_nb_of_iter):
opt._update()
if get_cost:
cost[i] = gradient_op.get_cost(opt._x_new) + \
prox_op.get_cost(opt._x_new)
if opt.converge:
print(' - Converged!')
if get_cost:
cost = cost[0:i]
break
opt.x_final = opt._x_new
end = time.clock()
if verbose > 0:
# cost_op.plot_cost()
# print(" - final iteration number: ", cost_op._iteration)
# print(" - final log10 cost value: ", np.log10(cost_op.cost))
print(" - converged: ", opt.converge)
print("Done.")
print("Execution time: ", end - start, " seconds")
print("-" * 40)
x_final = linear_op.adj_op(opt.x_final)
if get_cost:
return x_final, linear_op.transform, cost
else:
return x_final, linear_op.transform
def sparse_rec_fista(gradient_op,
linear_op,
prox_op,
cost_op,
lambda_init=1.0,
max_nb_of_iter=300,
metric_call_period=5,
metrics={},
verbose=0,
**lambda_update_params):
""" The FISTA sparse reconstruction without reweightings.
.. note:: At the moment, tested only with 2D data.
Parameters
----------
gradient_op: instance of class GradBase
the gradient operator.
linear_op: instance of LinearBase
the linear operator: seek the sparsity, ie. a wavelet transform.
prox_op: instance of ProximityParent
the proximal operator.
cost_op: instance of costObj
the cost function used to check for convergence during the
optimization.
lambda_init: float, (default 1.0)
initial value for the FISTA step.
max_nb_of_iter: int (optional, default 300)
the maximum number of iterations in the Condat-Vu proximal-dual
splitting algorithm.
metric_call_period: int (default 5)
the period on which the metrics are compute.
metrics: dict (optional, default None)
the list of desired convergence metrics: {'metric_name':
[@metric, metric_parameter]}. See modopt for the metrics API.
verbose: int (optional, default 0)
the verbosity level.
lambda_update_params: dict,
Parameters for the lambda update in FISTA mode
Returns
-------
x_final: ndarray
the estimated FISTA solution.
transform: a WaveletTransformBase derived instance
the wavelet transformation instance.
costs: list of float
the cost function values.
metrics: dict
the requested metrics values during the optimization.
"""
start = time.clock()
# Define the initial primal and dual solutions
x_init = np.zeros(gradient_op.fourier_op.shape, dtype=np.complex)
alpha = linear_op.op(x_init)
alpha[...] = 0.0
# Welcome message
if verbose > 0:
print(fista_logo())
print(" - mu: ", prox_op.weights)
print(" - lipschitz constant: ", gradient_op.spec_rad)
print(" - data: ", gradient_op.fourier_op.shape)
if hasattr(linear_op, "nb_scale"):
print(" - wavelet: ", linear_op, "-", linear_op.nb_scale)
print(" - max iterations: ", max_nb_of_iter)
print(" - image variable shape: ", x_init.shape)
print(" - alpha variable shape: ", alpha.shape)
print("-" * 40)
beta_param = gradient_op.inv_spec_rad
if lambda_update_params.get("restart_strategy") == "greedy":
lambda_update_params["min_beta"] = gradient_op.inv_spec_rad
# this value is the recommended one by J. Liang in his article
# when introducing greedy FISTA.
# ref: https://arxiv.org/pdf/1807.04005.pdf
beta_param *= 1.3
# Define the optimizer
opt = ForwardBackward(x=alpha,
grad=gradient_op,
prox=prox_op,
cost=cost_op,
auto_iterate=False,
metric_call_period=metric_call_period,
metrics=metrics,
linear=linear_op,
lambda_param=lambda_init,
beta_param=beta_param,
**lambda_update_params)
cost_op = opt._cost_func
# Perform the reconstruction
if verbose > 0:
print("Starting optimization...")
opt.iterate(max_iter=max_nb_of_iter)
end = time.clock()
if verbose > 0:
# cost_op.plot_cost()
if hasattr(cost_op, "cost"):
print(" - final iteration number: ", cost_op._iteration)
print(" - final log10 cost value: ", np.log10(cost_op.cost))
print(" - converged: ", opt.converge)
print("Done.")
print("Execution time: ", end - start, " seconds")
print("-" * 40)
x_final = linear_op.adj_op(opt.x_final)
if hasattr(cost_op, "cost"):
costs = cost_op._cost_list
else:
costs = None
return x_final, linear_op.transform, costs, opt.metrics