def uncertainty_quantification(
x_sol,
data,
sigma,
weights,
wav,
levels,
gamma,
options={
'alpha': 0.99,
"top": 1e3,
"bottom": 0,
"region_size": 16,
"iters": 10,
"tol": 1e-3
}):
psi = linear_operators.dictionary(wav, levels, x_sol.shape)
W = weights
obj = lambda data_sol, data_mask, wav_sol, wav_mask: gamma * np.sum(
np.abs(wav_sol + wav_mask)) + np.sum(
np.abs(W * (data_sol + data_mask) - W * data)**2) / (2 * sigma**2)
bound = obj(x_sol, 0, psi.dir_op(x_sol), 0) + float(len(
np.ravel(x_sol))) + np.sqrt(
float(len(np.ravel(x_sol))) * 16. * np.log(3. / options['alpha']))
print(obj(x_sol, 0, psi.dir_op(x_sol), 0))
print(
np.sqrt(
float(len(np.ravel(x_sol))) * 16. * np.log(3. / options['alpha'])))
phi = linear_operators.identity()
return map_uncertainty.create_local_credible_interval_fast(
x_sol, phi, psi, options['region_size'], obj, bound, options['iters'],
options['tol'], options['bottom'], options['top'])
def __init__(self, data, background, Phi=None):
self.data = data
self.background = background
self.beta = 1.
if (Phi is None):
self.Phi = linear_operators.identity()
else:
self.Phi = Phi
def test_id_op():
id_op = linear_operators.identity()
inp = np.random.normal(0, 10., (10, 10))
out = inp
forward_operator(id_op, inp, out)
adjoint_operator(id_op, inp, out)
inp = np.random.normal(0, 10., (10))
out = inp
forward_operator(id_op, inp, out)
adjoint_operator(id_op, inp, out)
def __init__(self, epsilon, data, Phi=None):
if np.any(epsilon <= 0):
raise Exception("'epsilon' must be positive")
self.epsilon = epsilon
self.data = data
self.beta = 1.
if (Phi is None):
self.Phi = linear_operators.identity()
else:
self.Phi = Phi
def __init__(self, tau, l2axis=0, Phi=None):
if np.any(tau <= 0):
raise Exception("'tau' must be positive")
self.tau = tau
self.l2axis = l2axis
self.beta = 1.
if (Phi is None):
self.Phi = linear_operators.identity()
else:
self.Phi = Phi
def __init__(self, sigma, Psi=None):
if np.any(sigma <= 0):
raise Exception("'gamma' must be positive")
self.sigma = sigma
self.beta = 1.
if (Psi is None):
self.Psi = linear_operators.identity()
else:
self.Psi = Psi
def __init__(self, epsilon, data, background, iters=20, Phi=None):
if np.any(epsilon <= 0):
raise Exception("'epsilon' must be positive")
self.epsilon = epsilon
self.data = data
self.background = background
self.beta = 1.
if (Phi is None):
self.Phi = linear_operators.identity()
else:
self.Phi = Phi
self.loglike = lambda x, mask: np.sum(x[mask] - self.data[
mask] - self.data[mask] * np.log(x[mask]) + self.data[mask] * np.
log(self.data[mask]))
# below are functions needed for newtons method to find the root for the prox
self.f = lambda x, delta, mask: self.loglike(
np.abs(x - delta + np.sqrt((x - delta)**2 + 4 * delta * self.data))
/ 2., mask) - epsilon / 2.
self.df = lambda x, delta, mask: np.sum(
((delta - x[mask] + 2 * self.data[mask]) / np.sqrt(
(x[mask] - delta)**2 + 4 * delta * self.data[mask]) - 1) *
(1 - 2 * self.data[mask] / (x[mask] - delta + np.sqrt(
(x[mask] - delta)**2 + 4 * delta * self.data[mask])))) / 2.
self.iters = iters