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)")