def parallel_penalty_one_iteration_solve(self,N,m,my_list,x0=None, Lbfgs_options=None, algorithm='my_lbfgs',scale=False): dt=float(self.T)/N if x0==None: x0 = np.zeros(N+m) x = None if algorithm=='my_lbfgs': x0 = self.Vec(x0) Result = [] rank = self.comm.Get_rank() for i in range(len(my_list)): def J(u): return self.parallel_penalty_functional(u,N,my_list[i]) def grad_J(u): return self.penalty_grad(u,N,m,my_list[i]) if algorithm=='my_lbfgs': self.update_Lbfgs_options(Lbfgs_options) if scale: scaler={'m':m,'factor':self.Lbfgs_options['scale_factor']} solver = Lbfgs(J,grad_J,x0,options=self.Lbfgs_options, scale=scaler) else: solver = Lbfgs(J,grad_J,x0,options=self.Lbfgs_options) res = solver.one_iteration(self.comm) Result.append(res) #print res.array(),rank #x0 = res['control'] #print J(x0.array()) if rank ==0: Result.append(res) else: Result.append(0) return Result if len(Result)==1: return res else: return Result
def solver(self, opt, ic, start, end, Tn, algorithm='scipy_lbfgs', options=None): h = self.mesh.hmax() def J(x): loc_opt, loc_ic = self.get_opt(x, opt, ic, 1) U = self.PDE_solver(loc_ic, loc_opt, start, end, Tn) return self.J(loc_opt, loc_ic, U, start, end) def grad_J(x): loc_opt, loc_ic = self.get_opt(x, opt, ic, 1) P = self.adjoint_solver(loc_ic, loc_opt, start, end, Tn) return self.grad_J(P, loc_opt, loc_ic, h) control0 = self.get_control(opt, ic, 1) if algorithm == 'my_lbfgs': control0 = SimpleVector(control0) self.update_lbfgs_options(options) solver = Lbfgs(J, grad_J, control0, options=self.Lbfgs_options) res = solver.solve() elif algorithm == 'scipy_lbfgs': res = Mini(J, control0.copy(), method='L-BFGS-B', jac=grad_J, options={ 'gtol': 1e-5, 'disp': True }) elif algorithm == 'my_steepest_decent': self.update_SD_options(options) SDopt = self.SD_options Solver = SteepestDecent(J, grad_J, control0.copy(), options=SDopt) res = Solver.solve() return res
def PPCLBFGSsolve2(self, N, m, my_list, x0=None, options=None, scale=False): dt = float(self.T) / N if x0 == None: x0 = SimpleVector(x0=self.initial_control(N, m=m)) result = [] PPC = self.PC_creator(N, m, step=1) if scale: scaler = {'m': m, 'factor': 1} else: scaler = None for i in range(len(my_list)): J, grad_J = self.generate_reduced_penalty(dt, N, m, my_list[i]) self.update_Lbfgs_options(options) Lbfgsopt = self.Lbfgs_options Solver = Lbfgs(J, grad_J, x0, Hinit=None, options=Lbfgsopt, pc=PPC, scale=scaler) res = Solver.solve() x0 = res['control'] result.append(res) if len(result) == 1: return res else: return result
def thread_parallel_penalty_solve(self, N, m, mu_list, x0=None, Lbfgs_options=None, algorithm='my_lbfgs', scale=False): dt = float(self.T) / N if x0 == None: x0 = np.zeros(N + m) x = None if algorithm == 'my_lbfgs': x0 = self.Vec(x0) Result = [] for i in range(len(mu_list)): def J(u): return self.thread_parallel_penalty_functional( u, N, m, mu_list[i]) def grad_J(u): return self.thread_parallel_penalty_grad(u, N, m, mu_list[i]) #J,grad_J = self.generate_reduced_penalty(dt,N,m,mu_list[i]) if algorithm == 'my_lbfgs': self.update_Lbfgs_options(Lbfgs_options) if scale: scaler = { 'm': m, 'factor': self.Lbfgs_options['scale_factor'] } solver = Lbfgs(J, grad_J, x0, options=self.Lbfgs_options, scale=scaler) else: solver = Lbfgs(J, grad_J, x0, options=self.Lbfgs_options) res = solver.solve() Result.append(res) x0 = res['control'] print J(x0.array()) elif algorithm == 'my_steepest_decent': self.update_SD_options(Lbfgs_options) SDopt = self.SD_options if scale: scale = {'m': m, 'factor': SDopt['scale_factor']} Solver = SteepestDecent(J, grad_J, x0.copy(), options=SDopt, scale=scale) res = Solver.solve() res.rescale() else: Solver = PPCSteepestDecent(J, grad_J, x0.copy(), lambda x: x, options=SDopt) res = Solver.split_solve(m) x0 = res.x.copy() Result.append(res) elif algorithm == 'slow_steepest_decent': self.update_SD_options(Lbfgs_options) SDopt = self.SD_options Solver = SteepestDecent(J, grad_J, x0.copy(), options=SDopt) res = Solver.solve() x0 = res.x.copy() Result.append(res) elif algorithm == 'split_lbfgs': self.update_Lbfgs_options(Lbfgs_options) Solver = SplitLbfgs(J, grad_J, x0, m, options=self.Lbfgs_options) res = Solver.solve() x0 = res.x.copy() Result.append(res) if len(Result) == 1: return res else: return Result
def penalty_solver(self, opt, ic, start, end, Tn, m, mu_list, algorithm='scipy_lbfgs', options=None): h = self.h X = Function(self.V) xN = self.xN control0 = self.get_control(opt, ic, m) if algorithm == 'my_lbfgs': control0 = SimpleVector(control0) res = [] for k in range(len(mu_list)): J, grad_J = self.create_reduced_penalty_j(opt, ic, start, end, Tn, m, mu_list[k]) if algorithm == 'my_steepest_decent': self.update_SD_options(options) SDopt = self.SD_options Solver = SteepestDecent(J, grad_J, control0.copy(), options=SDopt) res1 = Solver.solve() control0 = res1.x.copy() else: self.update_lbfgs_options(options) if algorithm == 'my_lbfgs': solver = Lbfgs(J, grad_J, control0, options=self.Lbfgs_options) res1 = solver.solve() control0 = res1['control'].copy() elif algorithm == 'scipy_lbfgs': res1 = Mini(J, control0.copy(), method='L-BFGS-B', jac=grad_J, options={ 'gtol': 1e-6, 'disp': True, 'maxcor': 10 }) control0 = res1.x.copy() res.append(res1) if len(res) == 1: return res[0] return res