def svd_power_method(arr, geo, angles, **kwargs):
"""
method to determine the largest singular value for the rectangular A
projection matrix.
:param arr: (np.ndarray, dtype=np.float32)
random vector
:param geo: (tigre.geometry())
geometry of the set up
:param angles: (np.ndarray, dtype=np.float32)
angles of projection
:param kwargs:
optional arguments
:keyword maxiter: (int)
number of iterations to run unless margin of error epsilon has
been reached. Default: 100
:keyword epsilon: (float)
margin of error for the algorithm. Default: 0.001
:keyword verbose: (bool)
print stuff. Default: False
:return: (float)
the largest singular value of the A matrix.
"""
maxiter = 100
if "maxiter" in kwargs:
maxiter = kwargs["maxiter"]
# very optimistic value for epsilon (it turns out)
epsilon = 0.001
if "epsilon" in kwargs:
epsilon = kwargs["epsilon"]
verbose = False
if "verbose" in kwargs:
verbose = kwargs["verbose"]
error = np.inf
arr_old = arr.copy()
i = 0
while error >= epsilon:
if verbose:
if i == 0:
print("using SVD power method to calculate " "Lipschitz const")
if np.mod(i, 10) == 0:
print("error for val is:" + str(error))
# very verbose and inefficient for now
omega = tigre.Ax(arr_old, geo, angles)
alpha = np.linalg.norm(omega)
u = (1.0 / alpha) * omega
z = tigre.Atb(u, geo, angles)
beta = np.linalg.norm(z)
arr = (1.0 / beta) * z
error = np.linalg.norm(tigre.Ax(arr, geo, angles) - beta * u)
sigma = beta
arr_old = arr
i += 1
if i >= maxiter:
return sigma
return sigma
def update_image(self, geo, angle, iteration):
"""
VERBOSE:
for j in range(angleblocks):
angle = np.array([alpha[j]], dtype=np.float32)
proj_err = proj[angle_index[j]] - Ax(res, geo, angle, 'Siddon')
backprj = Atb(proj_err, geo, angle, 'FDK')
res += backprj
res[res<0]=0
:return: None
"""
self.res += (
self.__bm__
* 2
* tigre.Atb(
(
self.proj[self.angle_index[iteration]]
- tigre.Ax(self.res, geo, angle, "interpolated", gpuids=self.gpuids)
),
geo,
angle,
"matched",
gpuids=self.gpuids,
)
)
def run_main_iter(self):
self.l2l = np.zeros([self.niter], dtype=np.float32)
avgtime = []
for i in range(self.niter):
if i == 0:
print("CGLS Algorithm in progress.")
toc = time.clock()
if i == 1:
tic = time.clock()
print('Esitmated time until completetion (s): ' +
str((self.niter - 1) * (tic - toc)))
avgtic = time.clock()
q = tigre.Ax(self.__p__, self.geo, self.angles, 'ray-voxel')
q_norm = np.linalg.norm(q)
alpha = self.__gamma__ / (q_norm * q_norm)
self.res += alpha * self.__p__
avgtoc = time.clock()
avgtime.append(abs(avgtic - avgtoc))
for item in self.__dict__:
if isinstance(getattr(self, item), np.ndarray):
if np.isnan(getattr(self, item)).any():
raise ValueError('nan found for ' + item +
' at iteraton ' + str(i))
aux = self.proj - \
tigre.Ax(self.res, self.geo, self.angles, 'ray-voxel')
self.l2l[i] = np.linalg.norm(aux)
if i > 0 and self.l2l[i] > self.l2l[i - 1]:
print('re-initilization of CGLS called at iteration:' + str(i))
if self.re_init_at_iteration + 1 == i:
print(
'Algorithm exited with two consecutive reinitializations.'
)
return self.res
self.res -= alpha * self.__p__
self.reinitialise_cgls()
self.re_init_at_iteration = i
self.__r__ -= alpha * q
s = tigre.Atb(self.__r__, self.geo, self.angles)
s_norm = np.linalg.norm(s)
gamma1 = s_norm * s_norm
beta = gamma1 / self.__gamma__
if self.log_parameters:
self.parameter_history['alpha'][i] = alpha
self.parameter_history['beta'][i] = beta
self.parameter_history['gamma'][i] = self.__gamma__
self.parameter_history['q_norm'][i] = q_norm
self.parameter_history['s_norm'][i] = s_norm
self.__gamma__ = gamma1
self.__p__ = s + beta * self.__p__
print('Average time taken for each iteration for CGLS:' +
str(sum(avgtime) / len(avgtime)) + '(s)')
def svd_power_method(arr, geo, angles, **kwargs):
maxiter = 100
if 'maxiter' in kwargs:
maxiter = kwargs['maxiter']
#very optimistic value for epsilon (it turns out)
epsilon = 0.001
if 'epsilon' in kwargs:
epsilon = kwargs['epsilon']
verbose = False
if 'verbose' in kwargs:
verbose = kwargs['verbose']
error = np.inf
arr_old = arr.copy()
i = 0
while error >= epsilon:
if verbose:
if i == 0:
print('using SVD power method to calculate ' 'Lipschitz const')
if np.mod(i, 10) == 0:
print('error for val is:' + str(error))
# very verbose and inefficient for now
omega = tigre.Ax(arr_old, geo, angles)
alpha = np.linalg.norm(omega)
u = (1. / alpha) * omega
z = tigre.Atb(u, geo, angles)
beta = np.linalg.norm(z)
arr = (1. / beta) * z
error = np.linalg.norm(tigre.Ax(arr, geo, angles) - beta * u)
sigma = beta
arr_old = arr
i += 1
if i >= maxiter:
return sigma
return sigma
# http://www.anstuocmath.ro/mathematics/anale2015vol2/Bentbib_A.H.__Kanber_A..pdf
def run_main_iter(self):
self.l2l = np.zeros([self.niter], dtype=np.float32)
avgtime = []
for i in range(self.niter):
if i == 0:
if self.verbose:
print("CGLS Algorithm in progress.")
toc = default_timer()
if i == 1:
tic = default_timer()
if self.verbose:
print("Esitmated time until completetion (s): " +
str((self.niter - 1) * (tic - toc)))
avgtic = default_timer()
q = tigre.Ax(self.__p__,
self.geo,
self.angles,
"Siddon",
gpuids=self.gpuids)
q_norm = np.linalg.norm(q)
alpha = self.__gamma__ / (q_norm * q_norm)
self.res += alpha * self.__p__
avgtoc = default_timer()
avgtime.append(abs(avgtic - avgtoc))
for item in self.__dict__:
if isinstance(getattr(self, item), np.ndarray):
if np.isnan(getattr(self, item)).any():
raise ValueError("nan found for " + item +
" at iteraton " + str(i))
aux = self.proj - tigre.Ax(
self.res, self.geo, self.angles, "Siddon", gpuids=self.gpuids)
self.l2l[i] = np.linalg.norm(aux)
if i > 0 and self.l2l[i] > self.l2l[i - 1]:
if self.verbose:
print("re-initilization of CGLS called at iteration:" +
str(i))
if self.re_init_at_iteration + 1 == i:
if self.verbose:
print(
"Algorithm exited with two consecutive reinitializations."
)
return self.res
self.res -= alpha * self.__p__
self.reinitialise_cgls()
self.re_init_at_iteration = i
self.__r__ -= alpha * q
s = tigre.Atb(self.__r__,
self.geo,
self.angles,
gpuids=self.gpuids)
s_norm = np.linalg.norm(s)
gamma1 = s_norm * s_norm
beta = gamma1 / self.__gamma__
if self.log_parameters:
self.parameter_history["alpha"][i] = alpha
self.parameter_history["beta"][i] = beta
self.parameter_history["gamma"][i] = self.__gamma__
self.parameter_history["q_norm"][i] = q_norm
self.parameter_history["s_norm"][i] = s_norm
self.__gamma__ = gamma1
self.__p__ = s + beta * self.__p__
if self.verbose:
print("Average time taken for each iteration for CGLS:" +
str(sum(avgtime) / len(avgtime)) + "(s)")
def run_main_iter(self):
self.l2l = np.zeros((1, self.niter), dtype=np.float32)
avgtime = []
for i in range(self.niter):
if self.verbose:
self._estimate_time_until_completion(i)
if self.Quameasopts is not None:
res_prev = copy.deepcopy(self.res)
avgtic = default_timer()
q = tigre.Ax(self.__p__,
self.geo,
self.angles,
"Siddon",
gpuids=self.gpuids)
q_norm = np.linalg.norm(q)
alpha = self.__gamma__ / (q_norm * q_norm)
self.res += alpha * self.__p__
avgtoc = default_timer()
avgtime.append(abs(avgtic - avgtoc))
for item in self.__dict__:
if (isinstance(getattr(self, item), np.ndarray)
and np.isnan(getattr(self, item)).any()):
raise ValueError("nan found for " + item +
" at iteraton " + str(i))
aux = self.proj - tigre.Ax(
self.res, self.geo, self.angles, "Siddon", gpuids=self.gpuids)
self.l2l[0, i] = np.linalg.norm(aux)
if i > 0 and self.l2l[0, i] > self.l2l[0, i - 1]:
if self.verbose:
print("re-initilization of CGLS called at iteration:" +
str(i))
if self.re_init_at_iteration + 1 == i:
if self.verbose:
print(
"Algorithm exited with two consecutive reinitializations."
)
return self.res
self.res -= alpha * self.__p__
self.reinitialise_cgls()
self.re_init_at_iteration = i
self.__r__ -= alpha * q
s = tigre.Atb(self.__r__,
self.geo,
self.angles,
backprojection_type="matched",
gpuids=self.gpuids)
s_norm = np.linalg.norm(s)
gamma1 = s_norm * s_norm
beta = gamma1 / self.__gamma__
if self.log_parameters:
self.parameter_history["alpha"][i] = alpha
self.parameter_history["beta"][i] = beta
self.parameter_history["gamma"][i] = self.__gamma__
self.parameter_history["q_norm"][i] = q_norm
self.parameter_history["s_norm"][i] = s_norm
self.__gamma__ = gamma1
self.__p__ = s + beta * self.__p__
if self.Quameasopts is not None:
self.error_measurement(res_prev, i)
if self.verbose:
print("Average time taken for each iteration for CGLS:" +
str(sum(avgtime) / len(avgtime)) + "(s)")