def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, store_hst=False, hot_start=False, disp_opts=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call. Documentation last updated: February. 2, 2011 - Ruben E. Perez ''' # if ((self.poa) and (sens_mode.lower() == 'pgc')): raise NotImplementedError( "pyPSQP - Current implementation only allows single level parallelization, either 'POA' or 'pgc'" ) # end if self.poa or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print 'pyPSQP: Parallel objective Function Analysis requires mpi4py' # end comm = MPI.COMM_WORLD nproc = comm.Get_size() if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast elif (mpi4py.__version__[0] == '1'): Bcast = comm.bcast # end self.pll = True self.myrank = comm.Get_rank() else: self.pll = False self.myrank = 0 # end myrank = self.myrank # def_fname = self.options['IFILE'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory( opt_problem.name, store_hst, hot_start, def_fname) # gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) # ====================================================================== # PSQP - Objective/Constraint Values Storage # ====================================================================== def eval(x): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] # end # end xn = xg else: xn = x # end # Flush Output Files self.flushFiles() # Evaluate User Function (Real Valued) fail = 0 f = [] g = [] if (myrank == 0): if self.h_start: [vals, hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.h_start = False hos_file.close() else: [f, g, fail] = [ vals['obj'][0][0], vals['con'][0], int(vals['fail'][0][0]) ] # end # end # end if self.pll: self.h_start = Bcast(self.h_start, root=0) # end if self.h_start and self.pll: [f, g, fail] = Bcast([f, g, fail], root=0) elif not self.h_start: [f, g, fail] = opt_problem.obj_fun(xn, *args, **kwargs) # end # Store History if (myrank == 0): if self.sto_hst: log_file.write(x, 'x') log_file.write(f, 'obj') log_file.write(g, 'con') log_file.write(fail, 'fail') # end # end # Objective Assigment if isinstance(f, float): f = [f] # end for i in xrange(len(opt_problem._objectives.keys())): if isinstance(f[i], complex): ff[i] = f[i].astype(float) else: ff[i] = f[i] # end # end # Constraints Assigment i = 0 for j in xrange(len(opt_problem._constraints.keys())): if isinstance(g[j], complex): gg[i] = g[j].astype(float) else: gg[i] = g[j] # end i += 1 # end # Gradients if self.h_start: dff = [] dgg = [] if (myrank == 0): [vals, hist_end] = hos_file.read(ident=['grad_obj', 'grad_con']) if hist_end: self.h_start = False hos_file.close() else: dff = vals['grad_obj'][0].reshape( (len(opt_problem._objectives.keys()), len(opt_problem._variables.keys()))) dgg = vals['grad_con'][0].reshape( (len(opt_problem._constraints.keys()), len(opt_problem._variables.keys()))) # end # end if self.pll: self.h_start = Bcast(self.h_start, root=0) # end if self.h_start and self.pll: [dff, dgg] = Bcast([dff, dgg], root=0) # end # end if not self.h_start: # dff, dgg = gradient.getGrad(x, group_ids, f, g, *args, **kwargs) # end # Store History if self.sto_hst and (myrank == 0): log_file.write(dff, 'grad_obj') log_file.write(dgg, 'grad_con') # end # Store self.stored_data['x'] = copy.copy(x) self.stored_data['f'] = copy.copy(ff) self.stored_data['g'] = copy.copy(gg) self.stored_data['df'] = copy.copy(dff) self.stored_data['dg'] = copy.copy(dgg) return # ====================================================================== # PSQP - Objective Values Function # ====================================================================== def pobj(n, x, f): if ((self.stored_data['x'] != x).any()): eval(x) # end ff = self.stored_data['f'] return ff[0] # ====================================================================== # PSQP - Constraint Values Function # ====================================================================== def pcon(n, k, x, g): if ((self.stored_data['x'] != x).any()): eval(x) # end gg = self.stored_data['g'] return gg[k - 1] # ====================================================================== # PSQP - Objective Gradients Function # ====================================================================== def pdobj(n, x, df): if ((self.stored_data['x'] != x).any()): eval(x) # end df = self.stored_data['df'] return df[0] # ====================================================================== # PSQP - Constraint Gradients Function # ====================================================================== def pdcon(n, k, x, dg): if ((self.stored_data['x'] != x).any()): eval(x) # end dg = self.stored_data['dg'] return dg[k - 1] # Variables Handling nvar = len(opt_problem._variables.keys()) xl = [] xu = [] xi = [] xx = [] for key in opt_problem._variables.keys(): xl.append(opt_problem._variables[key].lower) xu.append(opt_problem._variables[key].upper) xi.append(3) xx.append(opt_problem._variables[key].value) # end xl = numpy.array(xl) xu = numpy.array(xu) xi = numpy.array(xi) xx = numpy.array(xx) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key]['name']] = [ k, k + group_len ] k += group_len # end # end # Constraints Handling ncon = len(opt_problem._constraints.keys()) if ncon > 0: gi = [] gg = [] for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': gi.append(5) elif opt_problem._constraints[key].type == 'i': gi.append(2) # end gg.append(opt_problem._constraints[key].value) # end gg.append(0.0) gl = numpy.zeros([ncon], numpy.float) gu = numpy.zeros([ncon], numpy.float) gi = numpy.array(gi, numpy.float) gg = numpy.array(gg, numpy.float) else: gl = numpy.array([0], numpy.float) gu = numpy.array([0], numpy.float) gi = numpy.array([0], numpy.float) gg = numpy.array([0], numpy.float) # end # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) # end ff = numpy.array(ff, numpy.float) # Setup argument list values nf = numpy.array([nvar], numpy.int) nc = numpy.array([ncon], numpy.int) mit = numpy.array([self.options['MIT'][1]], numpy.int) mfv = numpy.array([self.options['MFV'][1]], numpy.int) met = numpy.array([self.options['MET'][1]], numpy.int) mec = numpy.array([self.options['MEC'][1]], numpy.int) xmax = numpy.array([self.options['XMAX'][1]], numpy.float) tolx = numpy.array([self.options['TOLX'][1]], numpy.float) tolc = numpy.array([self.options['TOLC'][1]], numpy.float) tolg = numpy.array([self.options['TOLG'][1]], numpy.float) rpf = numpy.array([self.options['RPF'][1]], numpy.float) gmax = numpy.array([0], numpy.float) cmax = numpy.array([0], numpy.float) if (myrank == 0): if (self.options['IPRINT'][1] <= 2): iprint = numpy.array([self.options['IPRINT'][1]], numpy.int) else: raise IOError('Incorrect Output Level Setting') # end else: iprint = numpy.array([0], numpy.int) # end iout = numpy.array([self.options['IOUT'][1]], numpy.int) ifile = self.options['IFILE'][1] if (myrank == 0): if (iprint != 0): if os.path.isfile(ifile): os.remove(ifile) # end # end # end iterm = numpy.array([0], numpy.int) # Storage Arrays self.stored_data = {} self.stored_data['x'] = {} # numpy.zeros([nvar],float) self.stored_data['f'] = {} # numpy.zeros([nobj],float) self.stored_data['g'] = {} # numpy.zeros([ncon],float) self.stored_data['df'] = {} # numpy.zeros([nvar],float) self.stored_data['dg'] = {} # numpy.zeros([ncon,nvar],float) # Run PSQP t0 = time.time() psqp.psqp_wrap(nf, nc, xx, xi, xl, xu, gg, gi, gl, gu, mit, mfv, met, mec, xmax, tolx, tolc, tolg, rpf, ff, gmax, cmax, iprint, iout, ifile, iterm, pobj, pdobj, pcon, pdcon) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name + '.cue') os.remove(name + '.bin') os.rename(name + '_tmp.cue', name + '.cue') os.rename(name + '_tmp.bin', name + '.bin') # end # end # end # Store Results sol_inform = {} sol_inform['value'] = iterm[0] sol_inform['text'] = self.getInform(iterm[0]) if store_sol: sol_name = 'PSQP Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if sol_options.has_key('defaults'): del sol_options['defaults'] # end sol_evals = psqp.stat.nfv + psqp.stat.nfg * nvar sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xx[i] i += 1 # end sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = ff[i] i += 1 # end if ncon > 0: sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = gg[i] i += 1 # end else: sol_cons = {} # end sol_lambda = {} opt_problem.addSol(self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) # end return ff, xx, sol_inform
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, store_hst=False, hot_start=False, disp_opts=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call. Documentation last updated: February. 2, 2011 - Ruben E. Perez ''' # if ((self.poa) and (sens_mode.lower() == 'pgc')): raise NotImplementedError("pyKSOPT - Current implementation only allows single level parallelization, either 'POA' or 'pgc'") #end if self.poa or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print 'pyKSOPT: Parallel objective Function Analysis requires mpi4py' #end comm = MPI.COMM_WORLD nproc = comm.Get_size() if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast elif (mpi4py.__version__[0] == '1'): Bcast = comm.bcast #end self.pll = True self.myrank = comm.Get_rank() else: self.pll = False self.myrank = 0 #end myrank = self.myrank # def_fname = self.options['IFILE'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory(opt_problem.name, store_hst, hot_start, def_fname) # gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) #====================================================================== # KSOPT - Objective/Constraint Values Function #====================================================================== def ksobj(nv,no,nc,x,f,g): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1]-group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] #end #end xn = xg else: xn = x #end # Flush Output Files self.flushFiles() # Evaluate User Function fail = 0 ff = [] gg = [] if (myrank == 0): if self.h_start: [vals,hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.h_start = False hos_file.close() else: [ff,gg,fail] = [vals['obj'][0][0],vals['con'][0],int(vals['fail'][0][0])] #end #end #end if self.pll: self.h_start = Bcast(self.h_start,root=0) #end if self.h_start and self.pll: [ff,gg,fail] = Bcast([ff,gg,fail],root=0) elif not self.h_start: [ff,gg,fail] = opt_problem.obj_fun(xn, *args, **kwargs) #end # Store History if (myrank == 0): if self.sto_hst: log_file.write(x,'x') log_file.write(ff,'obj') log_file.write(gg,'con') log_file.write(fail,'fail') #end #end # Objective Assigment if isinstance(ff,float): ff = [ff] #end for i in xrange(len(opt_problem._objectives.keys())): if isinstance(ff[i],complex): f[i] = ff[i].astype(float) else: f[i] = ff[i] #end #end # Constraints Assigment for i in xrange(len(opt_problem._constraints.keys())): if isinstance(gg[i],complex): g[i] = gg[i].astype(float) else: g[i] = gg[i] #end #end return f,g #====================================================================== # KSOPT - Objective/Constraint Gradients Function #====================================================================== def ksgrd(nv,no,nc,x,f,g,df,dg): if self.h_start: dff = [] dgg = [] if (myrank == 0): [vals,hist_end] = hos_file.read(ident=['grad_obj','grad_con']) if hist_end: self.h_start = False hos_file.close() else: dff = vals['grad_obj'][0].reshape((len(opt_problem._objectives.keys()),len(opt_problem._variables.keys()))) dgg = vals['grad_con'][0].reshape((len(opt_problem._constraints.keys()),len(opt_problem._variables.keys()))) #end #end if self.pll: self.h_start = Bcast(self.h_start,root=0) #end if self.h_start and self.pll: [dff,dgg] = Bcast([dff,dgg],root=0) #end #end if not self.h_start: # dff,dgg = gradient.getGrad(x, group_ids, f, g, *args, **kwargs) #end # Store History if self.sto_hst and (myrank == 0): log_file.write(dff,'grad_obj') log_file.write(dgg,'grad_con') #end # Gradient Assignment for i in xrange(len(opt_problem._variables.keys())): for j in xrange(len(opt_problem._objectives.keys())): df[j,i] = dff[j,i] #end for j in xrange(len(opt_problem._constraints.keys())): dg[j,i] = dgg[j,i] #end #end return df,dg # Variables Handling nvar = len(opt_problem._variables.keys()) xl = [] xu = [] xx = [] for key in opt_problem._variables.keys(): if (opt_problem._variables[key].type == 'c'): xl.append(opt_problem._variables[key].lower) xu.append(opt_problem._variables[key].upper) xx.append(opt_problem._variables[key].value) elif (opt_problem._variables[key].type == 'i'): raise IOError('KSOPT cannot handle integer design variables') elif (opt_problem._variables[key].type == 'd'): raise IOError('KSOPT cannot handle discrete design variables') #end #end xl = numpy.array(xl) xu = numpy.array(xu) xx = numpy.array(xx) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key]['name']] = [k,k+group_len] k += group_len #end #end # Constraints Handling ncon = len(opt_problem._constraints.keys()) gg = [] if ncon > 0: for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': raise IOError('KSOPT cannot handle equality constraints') #end gg.append(opt_problem._constraints[key].value) #end #end gg = numpy.array(gg) # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) #end ff = numpy.array(ff) # Setup argument list values ndv = numpy.array([nvar], numpy.int) nob = numpy.array([nobj], numpy.int) ncn = numpy.array([ncon], numpy.int) nwork0 = 63 nwork1 = 3*nobj + ncon + 12*nvar + nvar*(nvar+1) nwork2 = nobj*nvar + ncon*nvar nwork3 = 2*max(2*nvar,nobj+ncon) nworkS = nwork0 + nwork1 + nwork2 + nwork3 nwork = numpy.array([nworkS], numpy.int) work = numpy.zeros([nwork], numpy.float) itmax = numpy.array([self.options['ITMAX'][1]], numpy.int) rdfun = numpy.array([self.options['RDFUN'][1]], numpy.float) rhomin = numpy.array([self.options['RHOMIN'][1]], numpy.float) rhomax = numpy.array([self.options['RHOMAX'][1]], numpy.float) iout = numpy.array([self.options['IOUT'][1]], numpy.int) if (myrank == 0): if (self.options['IPRINT'][1]>=0 and self.options['IPRINT'][1]<=3): iprint = numpy.array([self.options['IPRINT'][1]], numpy.int) else: raise IOError('Incorrect Output Level Setting') #end else: iprint = numpy.array([0], numpy.int) #end ifile = self.options['IFILE'][1] if (iprint > 0): if os.path.isfile(ifile): os.remove(ifile) #end #end nfun = numpy.array([0], numpy.int) ngrd = numpy.array([0], numpy.int) # Run KSOPT t0 = time.time() ksopt.ksmain(ndv,nob,ncn,xx,xl,xu,ff,gg,work,nwork, itmax,rdfun,rhomin,rhomax,iout,iprint,ifile, nfun,ngrd,ksobj,ksgrd) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name+'.cue') os.remove(name+'.bin') os.rename(name+'_tmp.cue',name+'.cue') os.rename(name+'_tmp.bin',name+'.bin') #end #end #end if (iprint > 0): ksopt.closeunit(self.options['IOUT'][1]) #end # Store Results sol_inform = {} sol_inform['value'] = [] sol_inform['text'] = {} if store_sol: sol_name = 'KSOPT Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if sol_options.has_key('defaults'): del sol_options['defaults'] #end sol_evals = nfun[0] + ngrd[0]*nvar sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xx[i] i += 1 #end sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = ff[i] i += 1 #end if ncon > 0: sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = gg[i] i += 1 #end else: sol_cons = {} #end sol_lambda = {} opt_problem.addSol(self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) #end return ff, xx, sol_inform
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, disp_opts=False, store_hst=False, hot_start=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call. Documentation last updated: February. 2, 2011 - Peter W. Jansen ''' # if ((self.poa) and (sens_mode.lower() == 'pgc')): raise NotImplementedError( "pyMMA - Current implementation only allows single level parallelization, either 'POA' or 'pgc'" ) #end if self.poa or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print 'pyMMA: Parallel objective Function Analysis requires mpi4py' #end comm = MPI.COMM_WORLD nproc = comm.Get_size() if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast elif (mpi4py.__version__[0] == '1'): Bcast = comm.bcast #end self.pll = True self.myrank = comm.Get_rank() else: self.pll = False self.myrank = 0 #end myrank = self.myrank # def_fname = self.options['IFILE'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory( opt_problem.name, store_hst, hot_start, def_fname) # gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) #====================================================================== # MMA - Objective/Constraint Values and Gradients Function #====================================================================== def func(m, n, xval, f0val, df0dx, fval, dfdx): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = xval[group_ids[group][0]] else: xg[group] = xval[ group_ids[group][0]:group_ids[group][1]] #end #end xn = xg else: xn = xval #end # Flush Output Files self.flushFiles() # Evaluate User Function (Real Valued) fail = 0 f = [] g = [] if (myrank == 0): if self.h_start: [vals, hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.h_start = False hos_file.close() else: [f, g, fail] = [ vals['obj'][0][0], vals['con'][0], int(vals['fail'][0][0]) ] #end #end #end if self.pll: self.h_start = Bcast(self.h_start, root=0) #end if self.h_start and self.pll: [f, g, fail] = Bcast([f, g, fail], root=0) elif not self.h_start: [f, g, fail] = opt_problem.obj_fun(xn, *args, **kwargs) #end # Store History if (myrank == 0): if self.sto_hst: log_file.write(xval, 'x') log_file.write(f, 'obj') log_file.write(g, 'con') log_file.write(fail, 'fail') #end #end # Gradients if self.h_start: df = [] dg = [] if (myrank == 0): [vals, hist_end] = hos_file.read(ident=['grad_obj', 'grad_con']) if hist_end: self.h_start = False hos_file.close() else: df = vals['grad_obj'][0].reshape( (len(opt_problem._objectives.keys()), len(opt_problem._variables.keys()))) dg = vals['grad_con'][0].reshape( (len(opt_problem._constraints.keys()), len(opt_problem._variables.keys()))) #end #end if self.pll: self.h_start = Bcast(self.h_start, root=0) #end if self.h_start and self.pll: [df, dg] = Bcast([df, dg], root=0) #end #end if not self.h_start: # df, dg = gradient.getGrad(xval, group_ids, [f], g, *args, **kwargs) #end # Store History if self.sto_hst and (myrank == 0): log_file.write(df, 'grad_obj') log_file.write(dg, 'grad_con') #end # Objective Assigment if isinstance(f, complex): f0val = f.astype(float) else: f0val = f #end # Constraints Assigment for i in xrange(len(opt_problem._constraints.keys())): if isinstance(g[i], complex): fval[i] = g[i].astype(float) else: fval[i] = g[i] #end #end # Gradients Assigment k = 0 for i in xrange(len(opt_problem._variables.keys())): if isinstance(df[0, i], complex): df0dx[i] = df[0, i].astype(float) else: df0dx[i] = df[0, i] #end for jj in xrange(len(opt_problem._constraints.keys())): if isinstance(dg[jj, i], complex): dfdx[k] = dg[jj, i].astype(float) else: dfdx[k] = dg[jj, i] #end k += 1 #end #end return f0val, df0dx, fval, dfdx # Variables Handling n = len(opt_problem._variables.keys()) xmin = [] xmax = [] xval = [] for key in opt_problem._variables.keys(): if (opt_problem._variables[key].type == 'c'): xmin.append(opt_problem._variables[key].lower) xmax.append(opt_problem._variables[key].upper) xval.append(opt_problem._variables[key].value) elif (opt_problem._variables[key].type == 'i'): raise IOError('MMA cannot handle integer design variables') elif (opt_problem._variables[key].type == 'd'): raise IOError('MMA cannot handle discrete design variables') #end #end xmin = numpy.array(xmin) xmax = numpy.array(xmax) xval = numpy.array(xval) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key]['name']] = [ k, k + group_len ] k += group_len #end #end # Constraints Handling m = len(opt_problem._constraints.keys()) neqc = 0 #fval = [] fmax = [] if m > 0: for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': raise IOError('MMA cannot handle equality constraints') #neqc += 1 #end #fval.append(opt_problem._constraints[key].value) fmax.append(opt_problem._constraints[key].upper) #end #end #fval = numpy.array(fval) fmax = numpy.array(fmax) # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) f0val = [] for key in opt_problem._objectives.keys(): f0val.append(opt_problem._objectives[key].value) #end f0val = numpy.array(f0val) # Setup argument list values xmma = numpy.zeros([n], numpy.float) # Space used internally by the program # for the asymptotes (xlow and xupp) and # computed bounds on x (alpha and beta) xlow = numpy.zeros([n], numpy.float) xupp = numpy.zeros([n], numpy.float) alfa = numpy.zeros([n], numpy.float) beta = numpy.zeros([n], numpy.float) # The objective and constraint function # values and space for the gradients fval = numpy.zeros([m], numpy.float) df0dx = numpy.zeros([n], numpy.float) dfdx = numpy.zeros([m * n], numpy.float) # Space for the coefficients and artificial # variables to be computed (set to default values) p = numpy.zeros([m * n], numpy.float) q = numpy.zeros([m * n], numpy.float) p0 = numpy.zeros([n], numpy.float) q0 = numpy.zeros([n], numpy.float) b = numpy.zeros([m], numpy.float) y = numpy.zeros([m], numpy.float) z = numpy.array([0.], numpy.float) a = numpy.zeros([m], numpy.float) c = 10000 * numpy.ones([m], numpy.float) # Space for the Lagrange multipliers (ulam) # the gradient of the dual objective function, # search direction, and Hessian of the dual objective ulam = numpy.ones([m], numpy.float) gradf = numpy.zeros([m], numpy.float) dsrch = numpy.zeros([m], numpy.float) hessf = numpy.zeros([m * (m + 1) / 2], numpy.float) # Specify that all variables are free to move iyfree = numpy.ones([m], numpy.int) # iter = numpy.array([0], numpy.int) maxit = numpy.array([self.options['MAXIT'][1]], numpy.int) geps = numpy.array([self.options['GEPS'][1]], numpy.float) dabobj = numpy.array([self.options['DABOBJ'][1]], numpy.float) delobj = numpy.array([self.options['DELOBJ'][1]], numpy.float) itrm = numpy.array([self.options['ITRM'][1]], numpy.int) inform = numpy.array([0], numpy.int) if (myrank == 0): iprint = numpy.array([self.options['IPRINT'][1]], numpy.int) else: iprint = numpy.array([0], numpy.int) iout = numpy.array([self.options['IOUT'][1]], numpy.int) ifile = self.options['IFILE'][1] if (myrank == 0): if (iprint >= 0): if os.path.isfile(ifile): os.remove(ifile) #end #end #end # nfunc = numpy.array([0], numpy.int) # Run MMA t0 = time.time() mma.mma(n, m, iter, maxit, geps, dabobj, delobj, itrm, inform, xval, xmma, xmin, xmax, xlow, xupp, alfa, beta, f0val, fval, fmax, df0dx, dfdx, p, q, p0, q0, b, y, z, a, c, ulam, gradf, dsrch, hessf, iyfree, iprint, iout, ifile, nfunc, func) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name + '.cue') os.remove(name + '.bin') os.rename(name + '_tmp.cue', name + '.cue') os.rename(name + '_tmp.bin', name + '.bin') #end #end #end if (iprint > 0): mma.closeunit(self.options['IOUT'][1]) #end # Store Results sol_inform = {} sol_inform['value'] = inform[0] sol_inform['text'] = self.getInform(inform[0]) if store_sol: sol_name = 'MMA Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if sol_options.has_key('defaults'): del sol_options['defaults'] #end sol_evals = nfunc[0] sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xmma[i] i += 1 #end sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = f0val[i] i += 1 #end if m > 0: sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = fval[i] i += 1 #end else: sol_cons = {} #end sol_lambda = {} opt_problem.addSol(self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) #end return f0val, xmma, sol_inform
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, store_hst=False, hot_start=False, disp_opts=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call. Documentation last updated: February. 2, 2011 - Ruben E. Perez ''' # nec = 0 nic = 0 for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': nec += 1 if opt_problem._constraints[key].type == 'i': nic += 1 #end #end # if ((self.poa) and (sens_mode.lower() == 'pgc')): raise NotImplementedError( "pyFSQP - Current implementation only allows single level parallelization, either 'POA' or 'pgc'" ) #end if self.poa or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print( 'pyFSQP: Parallel objective Function Analysis requires mpi4py' ) #end comm = MPI.COMM_WORLD nproc = comm.Get_size() if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast elif (mpi4py.__version__[0] == '1'): Bcast = comm.bcast #end self.pll = True self.myrank = comm.Get_rank() else: self.pll = False self.myrank = 0 #end myrank = self.myrank # def_fname = self.options['ifile'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory( opt_problem.name, store_hst, hot_start, def_fname) # gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) #====================================================================== # FSQP - Objective/Constraint Values Storage #====================================================================== def eval(x): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] #end #end xn = xg else: xn = x #end # Flush Output Files self.flushFiles() # Evaluate User Function (Real Valued) fail = 0 f = [] g = [] if (myrank == 0): if self.hot_start: [vals, hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.hot_start = False hos_file.close() else: [f, g, fail] = [ vals['obj'][0][0], vals['con'][0], int(vals['fail'][0][0]) ] #end #end #end if self.pll: self.hot_start = Bcast(self.hot_start, root=0) #end if self.hot_start and self.pll: [f, g, fail] = Bcast([f, g, fail], root=0) elif not self.hot_start: [f, g, fail] = opt_problem.obj_fun(xn, *args, **kwargs) #end # Store History if (myrank == 0): if self.sto_hst: log_file.write(x, 'x') log_file.write(f, 'obj') log_file.write(g, 'con') log_file.write(fail, 'fail') #end #end # Objective Assigment if isinstance(f, float): f = [f] #end for i in range(len(opt_problem._objectives.keys())): if isinstance(f[i], complex): ff[i] = f[i].astype(float) else: ff[i] = f[i] #end #end # Constraints Assigment i = 0 for j in range(len(opt_problem._constraints.keys())): if isinstance(g[j], complex): gg[i] = g[j].astype(float) else: gg[i] = g[j] #end i += 1 #end # Gradients if self.hot_start: dff = [] dgg = [] if (myrank == 0): [vals, hist_end] = hos_file.read(ident=['grad_obj', 'grad_con']) if hist_end: self.hot_start = False hos_file.close() else: dff = vals['grad_obj'][0].reshape( (len(opt_problem._objectives.keys()), len(opt_problem._variables.keys()))) dgg = vals['grad_con'][0].reshape( (len(opt_problem._constraints.keys()), len(opt_problem._variables.keys()))) #end #end if self.pll: self.hot_start = Bcast(self.hot_start, root=0) #end if self.hot_start and self.pll: [dff, dgg] = Bcast([dff, dgg], root=0) #end #end if not self.hot_start: # dff, dgg = gradient.getGrad(x, group_ids, f, g, *args, **kwargs) #end # Store History if self.sto_hst and (myrank == 0): log_file.write(dff, 'grad_obj') log_file.write(dgg, 'grad_con') #end # Store self.stored_data['x'] = copy.copy(x) self.stored_data['f'] = copy.copy(ff) self.stored_data['g'] = copy.copy(gg) self.stored_data['df'] = copy.copy(dff) self.stored_data['dg'] = copy.copy(dgg) return #====================================================================== # FSQP - Objective Values Function #====================================================================== def obj(nparam, j, x, fj): if ((self.stored_data['x'] != x).any()): eval(x) #end ff = self.stored_data['f'] if (nobj == 1): fj = ff else: if isinstance(ff, list): ff = numpy.array(ff) #end fj = ff[j - 1] #end return fj #====================================================================== # FSQP - Constraint Values Function #====================================================================== def cntr(nparam, j, x, gj): # for given j, assign to gj the value of the jth constraint evaluated at x if ((self.stored_data['x'] != x).any()): eval(x) #end gg = self.stored_data['g'] if (j <= nic): jg = nec + (j - 1) else: jg = (j - 1) - nic #end gj = gg[jg] return gj #====================================================================== # FSQP - Objective Gradients Function #====================================================================== def gradobj(nparam, j, x, gradfj, obj): # assign to gradfj the gradient of the jth objective function evaluated at x if ((self.stored_data['x'] != x).any()): eval(x) #end df = self.stored_data['df'] for i in range(len(opt_problem._variables.keys())): gradfj[i] = df[j - 1, i] #end return gradfj #====================================================================== # FSQP - Constraint Gradients Function #====================================================================== def gradcntr(nparam, j, x, gradgj, obj): # assign to gradgj the gradient of the jth constraint evaluated at x if ((self.stored_data['x'] != x).any()): eval(x) #end dg = self.stored_data['dg'] if (j <= nic): jg = nec + (j - 1) else: jg = (j - 1) - nic #end gradgj = dg[jg] return gradgj # Variables Handling nvar = len(opt_problem._variables.keys()) xl = [] xu = [] xx = [] for key in opt_problem._variables.keys(): xl.append(opt_problem._variables[key].lower) xu.append(opt_problem._variables[key].upper) xx.append(opt_problem._variables[key].value) #end xl = numpy.array(xl) xu = numpy.array(xu) xx = numpy.array(xx) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key]['name']] = [ k, k + group_len ] k += group_len #end #end # Constraints Handling ncon = len(opt_problem._constraints.keys()) neqc = 0 gg = [] if ncon > 0: for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': neqc += 1 #end gg.append(opt_problem._constraints[key].value) #end gg = numpy.array(gg, numpy.float) else: gg = numpy.array([0], numpy.float) #end # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) #end ff = numpy.array(ff, numpy.float) # Setup argument list values nparam = numpy.array([nvar], numpy.int) nf = numpy.array([nobj], numpy.int) nineqn = numpy.array([ncon - neqc], numpy.int) nineq = nineqn neqn = numpy.array([neqc], numpy.int) neq = neqn mode = numpy.array([self.options['mode'][1]], numpy.int) if (myrank == 0): if (self.options['iprint'][1] >= 0): iprint = numpy.array([self.options['iprint'][1]], numpy.int) else: raise IOError('Incorrect Output Level Setting') #end else: iprint = numpy.array([0], numpy.int) #end iout = numpy.array([self.options['iout'][1]], numpy.int) ifile = self.options['ifile'][1] if (iprint > 0): if os.path.isfile(ifile): os.remove(ifile) #end #end miter = numpy.array([self.options['miter'][1]], numpy.int) inform = numpy.array([0], numpy.int) bigbnd = numpy.array([self.options['bigbnd'][1]], numpy.float) epstol = numpy.array([self.options['epstol'][1]], numpy.float) epsneq = numpy.array([self.options['epseqn'][1]], numpy.float) udelta = numpy.array([0], numpy.float) iwsizeM = 6 * nvar + 8 * max([1, ncon]) + 7 * max([1, nobj]) + 30 iwsize = numpy.array([iwsizeM], numpy.int) iw = numpy.zeros([iwsize], numpy.float) nwsizeM = 4 * nvar**2 + 5 * max([1, ncon]) * nvar + 3 * max([ 1, nobj ]) * nvar + 26 * (nvar + max([1, nobj])) + 45 * max([1, ncon]) + 100 nwsize = numpy.array([nwsizeM], numpy.int) w = numpy.zeros([nwsize], numpy.float) # Storage Arrays self.stored_data = {} self.stored_data['x'] = {} #numpy.zeros([nvar],float) self.stored_data['f'] = {} #numpy.zeros([nobj],float) self.stored_data['g'] = {} #numpy.zeros([ncon],float) self.stored_data['df'] = {} #numpy.zeros([nvar],float) self.stored_data['dg'] = {} #numpy.zeros([ncon,nvar],float) # Run FSQP t0 = time.time() ffsqp.ffsqp(nparam, nf, nineqn, nineq, neqn, neq, mode, iprint, miter, inform, bigbnd, epstol, epsneq, udelta, xl, xu, xx, ff, gg, iw, iwsize, w, nwsize, obj, cntr, gradobj, gradcntr, iout, ifile) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name + '.cue') os.remove(name + '.bin') os.rename(name + '_tmp.cue', name + '.cue') os.rename(name + '_tmp.bin', name + '.bin') #end #end #end if (iprint > 0): ffsqp.closeunit(self.options['iout'][1]) #end # Store Results sol_inform = {} sol_inform['value'] = inform[0] sol_inform['text'] = self.getInform(inform[0]) if store_sol: sol_name = 'FSQP Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if 'defaults' in sol_options: del sol_options['defaults'] #end sol_evals = 0 sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xx[i] i += 1 #end sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = ff[i] i += 1 #end if ncon > 0: sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = gg[i] i += 1 #end else: sol_cons = {} #end if ncon > 0: sol_lambda = numpy.zeros(ncon, float) for i in range(ncon): sol_lambda[i] = w[nvar + i] #end else: sol_lambda = {} #end opt_problem.addSol(self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) #end return ff, xx, sol_inform
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, disp_opts=False, store_hst=False, hot_start=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call. Documentation last updated: February. 2, 2011 - Peter W. Jansen ''' # if ((self.poa) and (sens_mode.lower() == 'pgc')): raise NotImplementedError( "pyNLPQL - Current implementation only allows single level parallelization, either 'POA' or 'pgc'" ) # end if self.poa or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print 'pyNLPQL: Parallel objective Function Analysis requires mpi4py' # end comm = MPI.COMM_WORLD nproc = comm.Get_size() if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast elif (mpi4py.__version__[0] == '1'): Bcast = comm.bcast # end self.pll = True self.myrank = comm.Get_rank() else: self.pll = False self.myrank = 0 # end myrank = self.myrank # def_fname = self.options['iFile'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory( opt_problem.name, store_hst, hot_start, def_fname) # gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) # ====================================================================== # NLPQL - Objective/Constraint Values Function (Real Valued) # ====================================================================== def nlfunc(m, me, mmax, n, f, g, x, active): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] # end # end xn = xg else: xn = x # end # Flush Output Files self.flushFiles() # Evaluate User Function fail = 0 ff = [] gg = [] if (myrank == 0): if self.h_start: [vals, hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.h_start = False hos_file.close() else: [ff, gg, fail] = [ vals['obj'][0][0], vals['con'][0], int(vals['fail'][0][0]) ] # end # end # end if self.pll: self.h_start = Bcast(self.h_start, root=0) # end if self.h_start and self.pll: [ff, gg, fail] = Bcast([ff, gg, fail], root=0) elif not self.h_start: [ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs) # end # Store History if (myrank == 0): if self.sto_hst: log_file.write(x, 'x') log_file.write(ff, 'obj') log_file.write(gg, 'con') log_file.write(fail, 'fail') # end # end # Objective Assigment if isinstance(ff, complex): f = ff.astype(float) else: f = ff # end # Constraints Assigment (negative gg as nlpql uses g(x) >= 0) for i in xrange(len(opt_problem._constraints.keys())): if isinstance(gg[i], complex): g[i] = -gg[i].astype(float) else: g[i] = -gg[i] # end # end return f, g # ====================================================================== # NLPQL - Objective/Constraint Gradients Function # ====================================================================== def nlgrad(m, me, mmax, n, f, g, df, dg, x, active, wa): if self.h_start: dff = [] dgg = [] if (myrank == 0): [vals, hist_end] = hos_file.read(ident=['grad_obj', 'grad_con']) if hist_end: self.h_start = False hos_file.close() else: dff = vals['grad_obj'][0].reshape( (len(opt_problem._objectives.keys()), len(opt_problem._variables.keys()))) dgg = vals['grad_con'][0].reshape( (len(opt_problem._constraints.keys()), len(opt_problem._variables.keys()))) # end # end if self.pll: self.h_start = Bcast(self.h_start, root=0) # end if self.h_start and self.pll: [dff, dgg] = Bcast([dff, dgg], root=0) # end # end if not self.h_start: # dff, dgg = gradient.getGrad( x, group_ids, [f], -g[0:len(opt_problem._constraints.keys())], *args, **kwargs) # end # Store History if self.sto_hst and (myrank == 0): log_file.write(dff, 'grad_obj') log_file.write(dgg, 'grad_con') # end # Gradient Assignment for i in xrange(len(opt_problem._variables.keys())): df[i] = dff[0, i] for j in xrange(len(opt_problem._constraints.keys())): dg[j, i] = -dgg[j, i] # end # end return df, dg # Variables Handling nvar = len(opt_problem._variables.keys()) xl = [] xu = [] xx = [] for key in opt_problem._variables.keys(): if (opt_problem._variables[key].type == 'c'): xl.append(opt_problem._variables[key].lower) xu.append(opt_problem._variables[key].upper) xx.append(opt_problem._variables[key].value) elif (opt_problem._variables[key].type == 'i'): raise IOError('NLPQL cannot handle integer design variables') elif (opt_problem._variables[key].type == 'd'): raise IOError('NLPQL cannot handle discrete design variables') # end # end xl = numpy.array(xl) xu = numpy.array(xu) xx = numpy.array(xx) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key]['name']] = [ k, k + group_len ] k += group_len # end # end # Constraints Handling ncon = len(opt_problem._constraints.keys()) neqc = 0 # gg = [] if ncon > 0: for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': neqc += 1 # end # gg.append(opt_problem._constraints[key].value) # end # end # gg = numpy.array(gg, numpy.float) # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) # end ff = numpy.array(ff, numpy.float) # Setup argument list values mm = numpy.array([ncon], numpy.int) me = numpy.array([neqc], numpy.int) mmx = 200 if (ncon >= mmx): mmx = ncon + 1 # end mmax = numpy.array([mmx], numpy.int) nn = numpy.array([nvar], numpy.int) nmx = 200 if (nvar >= nmx): nmx = nvar + 1 # end nmax = numpy.array([nmx], numpy.int) mnn2 = numpy.array([mm[0] + nn[0] + nn[0] + 2], numpy.int) # xx = _ConcatenateVector(self.variables, 'value') # ff = self.objective.value gg = numpy.zeros([mmax], numpy.float) df = numpy.zeros([nmax], numpy.float) dg = numpy.zeros([mmax, nmax], numpy.float) uu = numpy.zeros([mnn2], numpy.float) # xl = _ConcatenateVector(self.variables, 'lower') # xu = _ConcatenateVector(self.variables, 'upper') cc = numpy.zeros([nmax, nmax], numpy.float) dd = numpy.zeros([nmax], numpy.float) acc = numpy.array([self.options['Accurancy'][1]], numpy.float) scbou = numpy.array([self.options['ScaleBound'][1]], numpy.float) maxfun = numpy.array([self.options['maxFun'][1]], numpy.int) maxit = numpy.array([self.options['maxIt'][1]], numpy.int) if (myrank == 0): if (self.options['iPrint'][1] >= 0 and self.options['iPrint'][1] <= 4): iprint = numpy.array([self.options['iPrint'][1]], numpy.int) else: raise IOError('Incorrect Output Level Setting') # end else: iprint = numpy.array([0], numpy.int) # end if (self.options['mode'][1] >= 0 and self.options['mode'][1] <= 18): mode = self.options['mode'][1] else: raise IOError('Incorrect Mode Setting') # end iout = self.options['iout'][1] ifile = self.options['iFile'][1] if (iprint > 0): if os.path.isfile(ifile): os.remove(ifile) # end # end ifail = numpy.array([0], numpy.int) lwa0 = 100000 lwa1 = 4 * mmax + 4 * ncon + 19 * nvar + 55 lwa2 = mmax * nvar + 4 * mmax + 4 * ncon + 18 * nvar + 55 lwa3 = 3 / 2 * (nvar + 1) * (nvar + 1) + 10 * nvar + 2 * ncon + 10 lwaM = max([lwa0, lwa1, lwa2, lwa3]) + lwa3 lwa = numpy.array([lwaM], numpy.int) wa = numpy.zeros([lwa], numpy.float) lkwa = numpy.array([mmx + 2 * nmx + 20], numpy.int) kwa = numpy.zeros([lkwa], numpy.intc) lactiv = numpy.array([2 * mmx + 15], numpy.int) active = numpy.zeros([lactiv], numpy.bool) lmerit = numpy.array([self.options['lmerit'][1]], numpy.bool) lql = numpy.array([self.options['lql'][1]], numpy.bool) fmp = numpy.array([eps], numpy.float) # Run NLPQL t0 = time.time() nlpql.nlpql1(mm, me, mmax, nn, nmax, mnn2, xx, ff, gg, df, dg, uu, xl, xu, cc, dd, acc, scbou, maxfun, maxit, iprint, mode, iout, ifile, ifail, wa, lwa, kwa, lkwa, active, lactiv, lmerit, lql, fmp, nlfunc, nlgrad) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name + '.cue') os.remove(name + '.bin') os.rename(name + '_tmp.cue', name + '.cue') os.rename(name + '_tmp.bin', name + '.bin') # end # end # end if (iprint > 0): nlpql.closeunit(self.options['iout'][1]) # end # Store Results sol_inform = {} sol_inform['value'] = ifail[0] sol_inform['text'] = self.getInform(ifail[0]) if store_sol: sol_name = 'NLPQL Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if sol_options.has_key('defaults'): del sol_options['defaults'] # end sol_evals = kwa[0] + kwa[1] * nvar sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xx[i] i += 1 # end sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = ff[i] i += 1 # end if ncon > 0: sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = -gg[i] i += 1 # end else: sol_cons = {} # end if ncon > 0: sol_lambda = numpy.zeros(ncon, float) for i in xrange(ncon): sol_lambda[i] = uu[i] # end else: sol_lambda = {} # end opt_problem.addSol(self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) # end return ff, xx, sol_inform
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, store_hst=False, hot_start=False, disp_opts=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call. Documentation last updated: February. 2, 2013 - Ruben E. Perez ''' # if ((self.poa) and (sens_mode.lower() == 'pgc')): raise NotImplementedError( "pyFILTERSD - Current implementation only allows single level parallelization, either 'POA' or 'pgc'" ) #end if self.poa or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print( 'pyFILTERSD: Parallel objective Function Analysis requires mpi4py' ) #end comm = MPI.COMM_WORLD nproc = comm.Get_size() if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast elif (mpi4py.__version__[0] == '1'): Bcast = comm.bcast #end self.pll = True self.myrank = comm.Get_rank() else: self.pll = False self.myrank = 0 #end myrank = self.myrank # def_fname = self.options['ifile'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory( opt_problem.name, store_hst, hot_start, def_fname) # gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) #====================================================================== # filterSD - Objective/Constraint Values Function (Real Valued) #====================================================================== def functions(n, m, x, f, g, user, iuser): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] #end #end xn = xg else: xn = x #end # Flush Output Files self.flushFiles() # Evaluate User Function fail = 0 ff = [] gg = [] if (myrank == 0): if self.hot_start: [vals, hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.hot_start = False hos_file.close() else: [ff, gg, fail] = [ vals['obj'][0][0], vals['con'][0], int(vals['fail'][0][0]) ] #end #end #end if self.pll: self.hot_start = Bcast(self.hot_start, root=0) #end if self.hot_start and self.pll: [ff, gg, fail] = Bcast([ff, gg, fail], root=0) elif not self.hot_start: [ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs) #end # Store History if (myrank == 0): if self.sto_hst: log_file.write(x, 'x') log_file.write(ff, 'obj') log_file.write(gg, 'con') log_file.write(fail, 'fail') #end #end # Store self.stored_data['x'] = copy.copy(x) self.stored_data['f'] = copy.copy(ff) self.stored_data['g'] = copy.copy(gg) # Objective Assigment if isinstance(ff, complex): f = ff.astype(float) else: f = ff #end # Constraints Assigment for i in range(len(opt_problem._constraints.keys())): if isinstance(gg[i], complex): g[i] = gg[i].astype(float) else: g[i] = gg[i] #end #end return f, g #====================================================================== # filterSD - Objective/Constraint Gradients Function #====================================================================== def gradients(n, m, x, a, user, iuser): if ((self.stored_data['x'] != x).any()): f, g = functions(n, m, x, [], [], [], []) else: f = self.stored_data['f'] g = self.stored_data['g'] #end if self.hot_start: dff = [] dgg = [] if (myrank == 0): [vals, hist_end] = hos_file.read(ident=['grad_obj', 'grad_con']) if hist_end: self.hot_start = False hos_file.close() else: dff = vals['grad_obj'][0].reshape( (len(opt_problem._objectives.keys()), len(opt_problem._variables.keys()))) dgg = vals['grad_con'][0].reshape( (len(opt_problem._constraints.keys()), len(opt_problem._variables.keys()))) #end #end if self.pll: self.hot_start = Bcast(self.hot_start, root=0) #end if self.hot_start and self.pll: [dff, dgg] = Bcast([dff, dgg], root=0) #end #end if not self.hot_start: # dff, dgg = gradient.getGrad( x, group_ids, [f], g[0:len(opt_problem._constraints.keys())], *args, **kwargs) #end # Store History if self.sto_hst and (myrank == 0): log_file.write(dff, 'grad_obj') log_file.write(dgg, 'grad_con') #end # Gradient Assignment for i in range(len(opt_problem._variables.keys())): a[i, 0] = dff[0, i] #end for i in range(len(opt_problem._variables.keys())): for j in range(len(opt_problem._constraints.keys())): a[i, j + 1] = dgg[j, i] #end #end return a # Variables Handling nvar = len(opt_problem._variables.keys()) xl = [] xu = [] xx = [] for key in opt_problem._variables.keys(): xl.append(opt_problem._variables[key].lower) xu.append(opt_problem._variables[key].upper) xx.append(opt_problem._variables[key].value) #end xl = numpy.array(xl) xu = numpy.array(xu) xx = numpy.array(xx) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key]['name']] = [ k, k + group_len ] k += group_len #end #end # Constraints Handling ncon = len(opt_problem._constraints.keys()) gg = [] if ncon > 0: for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': raise IOError( 'FILTERSD cannot handle equality constraints') #end gg.append(opt_problem._constraints[key].value) #end gg = numpy.array(gg, numpy.float) else: ncon = 1 gg = numpy.array([0], numpy.float) #end # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) #end ff = numpy.array(ff, numpy.float) # Setup argument list values nn = numpy.array([nvar], numpy.int) mm = numpy.array([ncon], numpy.int) al = numpy.zeros(mm, numpy.float) ubd = numpy.array([self.options['ubd'][1]], numpy.float) rho = numpy.array([self.options['rho'][1]], numpy.float) htol = numpy.array([self.options['htol'][1]], numpy.float) rgtol = numpy.array([self.options['rgtol'][1]], numpy.float) maxit = numpy.array([self.options['maxit'][1]], numpy.int) maxgr = numpy.array([self.options['maxgr'][1]], numpy.int) dchk = numpy.array([self.options['dchk'][1]], numpy.int) dtol = numpy.array([self.options['dtol'][1]], numpy.float) if (myrank == 0): if (self.options['iprint'][1] >= 0): iprint = numpy.array([self.options['iprint'][1]], numpy.int) else: raise IOError('Incorrect Output Level Setting') #end else: iprint = numpy.array([0], numpy.int) #end iout = numpy.array([self.options['iout'][1]], numpy.int) ifile = self.options['ifile'][1] if (iprint > 0): if os.path.isfile(ifile): os.remove(ifile) #end #end ifail = numpy.array([0], numpy.int) nfevs = numpy.array([0], numpy.int) ngevs = numpy.array([0], numpy.int) # Storage Arrays self.stored_data = {} self.stored_data['x'] = {} self.stored_data['f'] = {} self.stored_data['g'] = {} # Run filterSD t0 = time.time() filtersd.filtersd_wrap(nn, mm, xx, xl, xu, al, ff, gg, inf, ubd, rho, htol, rgtol, maxit, maxgr, dchk, dtol, iprint, iout, ifile, ifail, nfevs, ngevs, functions, gradients) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name + '.cue') os.remove(name + '.bin') os.rename(name + '_tmp.cue', name + '.cue') os.rename(name + '_tmp.bin', name + '.bin') #end #end #end if (iprint > 0): filtersd.closeunit(self.options['iout'][1]) #end # Store Results sol_inform = {} sol_inform['value'] = ifail[0] sol_inform['text'] = self.getInform(ifail[0]) if store_sol: sol_name = 'FILTERSD Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if 'defaults' in sol_options: del sol_options['defaults'] #end sol_evals = nfevs[0] + ngevs[0] * nvar sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xx[i] i += 1 #end sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = ff[i] i += 1 #end if ncon > 0: sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = gg[i] i += 1 #end else: sol_cons = {} #end if ncon > 0: sol_lambda = numpy.zeros(ncon, float) for i in range(ncon): sol_lambda[i] = al[i] #end else: sol_lambda = {} #end opt_problem.addSol(self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) time.sleep(0) #end return ff, xx, sol_inform
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, disp_opts=False, store_hst=False, hot_start=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call. Documentation last updated: Feb. 2, 2011 - Peter W. Jansen ''' # if ((self.poa) and (sens_mode.lower() == 'pgc')): raise NotImplementedError( "pySNOPT - Current implementation only allows single level parallelization, either 'POA' or 'pgc'" ) if self.poa or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print( 'pySNOPT: Parallel objective Function Analysis requires mpi4py' ) comm = MPI.COMM_WORLD nproc = comm.Get_size() if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast elif (mpi4py.__version__[0] == '1'): Bcast = comm.bcast elif (mpi4py.__version__[0] == '2'): Bcast = comm.bcast self.pll = True self.myrank = comm.Get_rank() else: self.pll = False self.myrank = 0 myrank = self.myrank # def_fname = self.options['Print file'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory( opt_problem.name, store_hst, hot_start, def_fname) # gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) #====================================================================== # SNOPT-C - Objective/Constraint Values Function #====================================================================== def snfuncgrag(mode, njac, x, f_obj, g_obj, f_con, g_con): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] xn = xg else: xn = x # Flush Output Files self.flushFiles() # Evaluate function values and derivatives together if required if sens_type == 'user': fail = 0 if mode == 0: # assign function values only # Check history first if self.hot_start: [vals, hist_end ] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.hot_start = False hos_file.close() else: [f_obj, f_con, fail] = [ vals['obj'][0][0], vals['con'][0], int(vals['fail'][0][0]) ] # Otherwise evaluate function if not self.hot_start: [f_obj, f_con, fail] = opt_problem.obj_fun(xn, ret='val', *args, **kwargs) # Store History if self.sto_hst: log_file.write(x, 'x') log_file.write(f_obj, 'obj') log_file.write(f_con, 'con') log_file.write(fail, 'fail') if (fail == 1): mode = -1 return mode print(f_obj, f_con) return mode, f_obj, g_obj, f_con, g_con elif mode == 1: # assign gradients only raise NotImplementedError( 'Assignment of gradients only is not implemented') elif mode == 2: # assign values and gradients # Check history first if self.hot_start: # Check for function values first [vals, hist_end ] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.hot_start = False hos_file.close() else: [f_obj, f_con, fail] = [ vals['obj'][0][0], vals['con'][0], int(vals['fail'][0][0]) ] if self.hot_start: # Function values found, check for gradient values [vals, hist_end ] = hos_file.read(ident=['grad_obj', 'grad_con']) if hist_end: self.hot_start = False hos_file.close() else: g_obj = vals['grad_obj'][0] g_con = vals['grad_con'][0].reshape( (len(opt_problem._constraints.keys()), len(opt_problem._variables.keys()))) # If either values or gradients not found, evaluate function if not self.hot_start: [f_obj, f_con, g_obj, g_con, fail] = opt_problem.obj_fun(xn, ret='all', *args, **kwargs) # Store History if self.sto_hst: log_file.write(x, 'x') log_file.write(f_obj, 'obj') log_file.write(f_con, 'con') log_file.write(g_obj, 'grad_obj') log_file.write(g_con, 'grad_con') log_file.write(fail, 'fail') if (fail == 1): mode = -1 return mode print(f_obj, f_con) return mode, f_obj, g_obj, f_con, g_con else: raise ValueError( 'Requested mode should be 0, 1, or 2, not %i' % mode) # Evaluate User Function fail = 0 if (myrank == 0): if self.hot_start: [vals, hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.hot_start = False hos_file.close() else: [f_obj, f_con, fail] = [ vals['obj'][0][0], vals['con'][0], int(vals['fail'][0][0]) ] if self.pll: self.hot_start = Bcast(self.hot_start, root=0) if self.hot_start and self.pll: [f_obj, f_con, fail] = Bcast([f_obj, f_con, fail], root=0) elif not self.hot_start: [f_obj, f_con, fail] = opt_problem.obj_fun(xn, *args, **kwargs) # Store History if (myrank == 0): if self.sto_hst: log_file.write(x, 'x') log_file.write(f_obj, 'obj') log_file.write(f_con, 'con') log_file.write(fail, 'fail') # if (fail == 1): mode = -1 return mode # Gradients if mode != 0 and self.hot_start: if (myrank == 0): [vals, hist_end] = hos_file.read(ident=['grad_obj', 'grad_con']) if hist_end: self.hot_start = False hos_file.close() else: g_obj = vals['grad_obj'][0] g_con = vals['grad_con'][0].reshape( (len(opt_problem._constraints.keys()), len(opt_problem._variables.keys()))) if self.pll: self.hot_start = Bcast(self.hot_start, root=0) if self.hot_start and self.pll: [g_obj, g_con] = Bcast([g_obj, g_con], root=0) if mode != 0 and not self.hot_start: # dff, dgg = gradient.getGrad(x, group_ids, [f_obj], f_con, *args, **kwargs) # for i in range(len(opt_problem._variables.keys())): g_obj[i] = dff[0, i] for j in range(len(opt_problem._constraints.keys())): g_con[j, i] = dgg[j, i] if (myrank == 0): if mode != 0 and self.sto_hst: log_file.write(g_obj, 'grad_obj') log_file.write(g_con, 'grad_con') # Objective Assigment if isinstance(f_obj, complex): f_obj = f_obj.astype(float) # Constraints Assigment for i in range(len(opt_problem._constraints.keys())): if isinstance(f_con[i], complex): f_con[i] = f_con[i].astype(float) #print f_con # if not all(f_con): # print("not all f_con") # print f_con # f_con = [0] return mode, f_obj, g_obj, f_con, g_con # Variables Handling nvar = len(opt_problem._variables.keys()) blx = [] bux = [] xs = [] for key in opt_problem._variables.keys(): if (opt_problem._variables[key].type == 'c'): blx.append(opt_problem._variables[key].lower) bux.append(opt_problem._variables[key].upper) xs.append(opt_problem._variables[key].value) elif (opt_problem._variables[key].type == 'i'): raise IOError('SNOPT cannot handle integer design variables') elif (opt_problem._variables[key].type == 'd'): raise IOError('SNOPT cannot handle discrete design variables') blx = numpy.array(blx) bux = numpy.array(bux) xs = numpy.array(xs) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key]['name']] = [ k, k + group_len ] k += group_len # Constraints Handling ncon = len(opt_problem._constraints.keys()) blc = [] buc = [] if ncon > 0: for key in opt_problem._constraints.keys(): if (opt_problem._constraints[key].type == 'e'): blc.append(opt_problem._constraints[key].equal) buc.append(opt_problem._constraints[key].equal) elif (opt_problem._constraints[key].type == 'i'): blc.append(opt_problem._constraints[key].lower) buc.append(opt_problem._constraints[key].upper) else: #if ((store_sol) and (myrank == 0)): # print("Optimization Problem Does Not Have Constraints") # print("Unconstrained Optimization Initiated") ncon = 1 blc.append(-inf) buc.append(inf) blc = numpy.array(blc) buc = numpy.array(buc) # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) ff = numpy.array(ff, numpy.float) # Initialize SNOPT iPrint = self.options['iPrint'][1] if (myrank != 0): iPrint = 0 PrintFile = self.options['Print file'][1] if (iPrint != 0): if os.path.isfile(PrintFile): os.remove(PrintFile) ierror = snopt.openunit(iPrint, numpy.array(PrintFile), numpy.array('new'), numpy.array('sequential')) if (ierror != 0): raise IOError('Failed to properly open %s, ierror = %3d' % (PrintFile, ierror)) iSumm = self.options['iSumm'][1] if (myrank != 0): iSumm = 0 SummFile = self.options['Summary file'][1] if (iSumm != 0): if os.path.isfile(SummFile): os.remove(SummFile) ierror = snopt.openunit(iSumm, numpy.array(SummFile), numpy.array('new'), numpy.array('sequential')) if (ierror != 0): raise IOError('Failed to properly open %s, ierror = %3d' % (SummFile, ierror)) lencw = 500 leniw = 500 + 100 * (ncon + nvar) lenrw = 500 + 200 * (ncon + nvar) self.options['Total integer workspace'][1] = leniw self.options['Total real workspace'][1] = lenrw string = [] for i in range(lencw): string.append(' ') cw = numpy.array(string, 'c') iw = numpy.zeros(leniw, 'i') rw = numpy.zeros(lenrw, numpy.float) snopt.sninit(iPrint, iSumm, cw, iw, rw) # Memory allocation if (opt_problem._linearConstraints): (aLr, aLc) = opt_problem._linearConstraints.matrix.shape ne = (ncon + aLr) * nvar else: ne = ncon * nvar nnCon = numpy.array(ncon, numpy.int) nnObj = numpy.array(nvar, numpy.int) nnJac = numpy.array(nvar, numpy.int) neGcon = nnCon * nnJac iExit = 0 mincw, miniw, minrw, cw = snopt.snmemb(iExit, ncon, nvar, ne, neGcon, nnCon, nnJac, nnObj, cw, iw, rw) if ((minrw > lenrw) or (miniw > leniw) or (mincw > lencw)): if (mincw > lencw): lencw = mincw string = "" for i in range(lencw): string = string + " " # end for cw = numpy.transpose( numpy.reshape(numpy.array(string), (lencw, 8))) if (miniw > leniw): leniw = miniw iw = numpy.zeros(leniw, 'i') if (minrw > lenrw): lenrw = minrw rw = numpy.zeros(lenrw, numpy.float) snopt.sninit(iPrint, iSumm, cw, iw, rw) # Set Options inform = numpy.array([-1], numpy.int) for i in range(len(self.set_options)): name = self.set_options[i][0] value = self.set_options[i][1] if isinstance(value, str): if (name == 'Start'): if (value == 'Cold'): snopt.snset('Cold start', iPrint, iSumm, inform, cw, iw, rw) elif (value == 'Warm'): snopt.snset('Warm start', iPrint, iSumm, inform, cw, iw, rw) elif (name == 'Problem Type'): if (value == 'Minimize'): snopt.snset('Minimize', iPrint, iSumm, inform, cw, iw, rw) elif (value == 'Maximize'): snopt.snset('Maximize', iPrint, iSumm, inform, cw, iw, rw) elif (value == 'Feasible point'): snopt.snset('Feasible point', iPrint, iSumm, inform, cw, iw, rw) elif (name == 'Print file'): snopt.snset(name + ' ' + '%d' % (iPrint), iPrint, iSumm, inform, cw, iw, rw) elif (name == 'Summary file'): snopt.snset(name + ' ' + '%d' % (iSumm), iPrint, iSumm, inform, cw, iw, rw) else: snopt.snset(name + ' ' + value, iPrint, iSumm, inform, cw, iw, rw) elif isinstance(value, float): snopt.snsetr(name, value, iPrint, iSumm, inform, cw, iw, rw) elif isinstance(value, int): if (name == 'iPrint') and iPrint == 0: pass elif (name == 'iSumm') and iSumm == 0: pass else: snopt.snseti(name, value, iPrint, iSumm, inform, cw, iw, rw) elif isinstance(value, type(None)): snopt.snset(name, iPrint, iSumm, inform, cw, iw, rw) # Setup argument list values start = numpy.array(self.options['Start'][1]) nName = numpy.array([1], numpy.int) nnCon = numpy.array(ncon, numpy.int) nnObj = numpy.array(nvar, numpy.int) nnJac = numpy.array(nvar, numpy.int) iObj = numpy.array([0], numpy.int) ObjAdd = numpy.array([0.], numpy.float) ProbNm = numpy.array(self.name) # Setup constraints if (opt_problem._linearConstraints): # have linear constraints (aLr, aLc) = opt_problem._linearConstraints.matrix.shape neL = (ncon + aLr) * nvar a = numpy.zeros(neL, numpy.float) ina = ncon for j in range(nvar): inal = 0 for i in range(ncon, ncon + aLr): a[ina] = opt_problem._linearConstraints.matrix[inal, j] ina = ina + 1 inal = inal + 1 ina = ina + ncon ha = numpy.zeros(neL, 'i') ine = 0 for j in range(nvar): for i in range(ncon + aLr): ha[ine] = i + 1 ine = ine + 1 ka = numpy.zeros(nvar + 1, 'i') ka[0] = 1 for i in range(1, nvar + 1): ka[i] = ka[i - 1] + (ncon + aLr) bl = numpy.concatenate( (blx, blc, opt_problem._linearConstraints.lower)) bu = numpy.concatenate( (bux, buc, opt_problem._linearConstraints.upper)) xs = numpy.concatenate((xs, numpy.zeros(ncon + aLr, numpy.float))) hs = numpy.zeros(nvar + ncon + aLr, 'i') pi = numpy.zeros(ncon + aLr, numpy.float) rc = numpy.zeros(nvar + ncon + aLr, numpy.float) else: a = numpy.zeros(ne, numpy.float) ha = numpy.zeros(ne, 'i') ine = 0 for j in range(nvar): for i in range(ncon): ha[ine] = i + 1 ine = ine + 1 ka = numpy.zeros(nvar + 1, 'i') ka[0] = 1 for i in range(1, nvar + 1): ka[i] = ka[i - 1] + ncon bl = numpy.concatenate((blx, blc)) bu = numpy.concatenate((bux, buc)) xs = numpy.concatenate((xs, numpy.zeros(ncon, numpy.float))) hs = numpy.zeros(nvar + ncon, 'i') pi = numpy.zeros(ncon, numpy.float) rc = numpy.zeros(nvar + ncon, numpy.float) lencu = numpy.array([1], numpy.int) leniu = numpy.array([1], numpy.int) lenru = numpy.array([1], numpy.int) cu = numpy.array([" "], 'c') iu = numpy.zeros([leniu[0]], numpy.int) ru = numpy.zeros([lenru[0]], numpy.float) Names = numpy.array([" "], 'c') #inform = numpy.array([-1], numpy.int) mincw = numpy.array([0], numpy.int) miniw = numpy.array([0], numpy.int) minrw = numpy.array([0], numpy.int) nS = numpy.array([0], numpy.int) ninf = numpy.array([0], numpy.int) sinf = numpy.array([0.], numpy.float) # Run SNOPT t0 = time.time() snopt.snoptc(start, nnCon, nnObj, nnJac, iObj, ObjAdd, ProbNm, snfuncgrag, a, ha, ka, bl, bu, Names, hs, xs, pi, rc, inform, mincw, miniw, minrw, nS, ninf, sinf, ff, cu, iu, ru, cw, iw, rw) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name + '.cue') os.remove(name + '.bin') os.rename(name + '_tmp.cue', name + '.cue') os.rename(name + '_tmp.bin', name + '.bin') if (iPrint != 0): snopt.closeunit(self.options['iPrint'][1]) if (iSumm != 0): snopt.closeunit(self.options['iSumm'][1]) if (self.options['New basis file'] != 0): snopt.closeunit(self.options['New basis file'][1]) if (self.options['Dump file'] != 0): snopt.closeunit(self.options['Dump file'][1]) # Store Results sol_inform = {} sol_inform['value'] = inform sol_inform['text'] = self.getInform(inform) if store_sol: sol_name = 'SNOPT Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if 'defaults' in sol_options: del sol_options['defaults'] sol_evals = 0 sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xs[i] i += 1 sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = ff[i] i += 1 sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = xs[nvar + i] i += 1 if ncon > 0: sol_lambda = numpy.zeros(ncon, float) for i in range(ncon): sol_lambda[i] = pi[i] else: sol_lambda = {} opt_problem.addSol(self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) return ff, xs[0:nvar], sol_inform
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, store_hst=False, hot_start=False, disp_opts=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call. Documentation last updated: February. 2, 2011 - Peter W. Jansen ''' # if ((self.poa) and (sens_mode.lower() == 'pgc')): raise NotImplementedError( "pySOLVOPT - Current implementation only allows single level parallelization, either 'POA' or 'pgc'") # end if self.poa or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print 'pySOLVOPT: Parallel objective Function Analysis requires mpi4py' # end comm = MPI.COMM_WORLD nproc = comm.Get_size() if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast elif (mpi4py.__version__[0] == '1'): Bcast = comm.bcast # end self.pll = True self.myrank = comm.Get_rank() else: self.pll = False self.myrank = 0 # end myrank = self.myrank # def_fname = self.options['ifile'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory(opt_problem.name, store_hst, hot_start, def_fname) # gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) # ====================================================================== # SOLVOPT - Objective/Constraint Values Storage # ====================================================================== def soeval(x): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] # end # end xn = xg else: xn = x # end # Flush Output Files self.flushFiles() # Evaluate User Function fail = 0 f = [] g = [] if (myrank == 0): if self.h_start: [vals, hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.h_start = False hos_file.close() else: [f, g, fail] = [vals['obj'][0][0], vals['con'][0], int(vals['fail'][0][0])] # end # end # end if self.pll: self.h_start = Bcast(self.h_start, root=0) # end if self.h_start and self.pll: [f, g, fail] = Bcast([f, g, fail], root=0) elif not self.h_start: [f, g, fail] = opt_problem.obj_fun(xn, *args, **kwargs) # end # Store History if (myrank == 0): if self.sto_hst: log_file.write(x, 'x') log_file.write(f, 'obj') log_file.write(g, 'con') log_file.write(fail, 'fail') # end # end # Gradients if self.h_start: df = [] dg = [] if (myrank == 0): [vals, hist_end] = hos_file.read(ident=['grad_obj', 'grad_con']) if hist_end: self.h_start = False hos_file.close() else: df = vals['grad_obj'][0].reshape( (len(opt_problem._objectives.keys()), len(opt_problem._variables.keys()))) dg = vals['grad_con'][0].reshape( (len(opt_problem._constraints.keys()), len(opt_problem._variables.keys()))) # end # end if self.pll: self.h_start = Bcast(self.h_start, root=0) # end if self.h_start and self.pll: [df, dg] = Bcast([df, dg], root=0) # end # end if not self.h_start: # df, dg = gradient.getGrad(x, group_ids, [f], g, *args, **kwargs) # end # Store History if (myrank == 0): if self.sto_hst: log_file.write(df, 'grad_obj') log_file.write(dg, 'grad_con') # end # end # Objective Assigment if isinstance(f, complex): ff = f.astype(float) else: ff = f # end # Constraints Assigment i = 0 j = 0 for j in xrange(len(opt_problem._constraints.keys())): if isinstance(g[j], complex): gg[i] = g[j].astype(float) else: gg[i] = g[j] # end i += 1 # end for key in opt_problem._variables.keys(): if (opt_problem._variables[key].lower != -inf): gg[i] = xl[j] - x[j] i += 1 # end if (opt_problem._variables[key].upper != inf): gg[i] = x[j] - xu[j] i += 1 # end # end # Gradient Assignment df = df[0] dgg = numpy.zeros([len(opt_problem._variables.keys()) * 2, len(opt_problem._variables.keys())], 'd') i = len(opt_problem._constraints.keys()) j = 0 for key in opt_problem._variables.keys(): if (opt_problem._variables[key].lower != -inf): if (gg[i] > 0): dgg[j, j] = -1 # end i += 1 # end if (opt_problem._variables[key].upper != inf): if (gg[i] > 0): dgg[j, j] = 1 # end i += 1 # end j += 1 # end dg = numpy.concatenate((dg, dgg), axis=0) # Store self.stored_data['x'] = copy.copy(x) self.stored_data['f'] = copy.copy(ff) self.stored_data['g'] = copy.copy(gg) self.stored_data['df'] = copy.copy(df) self.stored_data['dg'] = copy.copy(dg) return # ====================================================================== # SOLVOPT - Objective Value Function # ====================================================================== def soobjf(n, x, f): if ((self.stored_data['x'] != x).any()): soeval(x) # end f = self.stored_data['f'] return f # ====================================================================== # SOLVOPT - Constraint Values Function # ====================================================================== def soobjg(n, x, g): if ((self.stored_data['x'] != x).any()): soeval(x) # end # Constraints Maximal Residual maxg = numpy.zeros([len(self.stored_data['g'])], float) i = 0 for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': maxg[i] = abs(self.stored_data['g'][i]) i += 1 elif opt_problem._constraints[key].type == 'i': maxg[i] = max(0, self.stored_data['g'][i]) i += 1 # end # end for j in xrange(len(opt_problem._constraints), len(self.stored_data['g'])): maxg[i] = max(0, self.stored_data['g'][i]) i += 1 # end g = max(maxg) return g # ====================================================================== # SOLVOPT - Objective Gradients Function # ====================================================================== def sogrdf(n, x, df): if ((self.stored_data['x'] != x).any()): soeval(x) # end df = self.stored_data['df'] return df # ====================================================================== # SOLVOPT - Constraint Gradients Function # ====================================================================== def sogrdg(n, x, dg): if ((self.stored_data['x'] != x).any()): soeval(x) # end # Constraints Maximal Residual maxg = numpy.zeros([len(self.stored_data['g'])], float) i = 0 for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': maxg[i] = abs(self.stored_data['g'][i]) i += 1 elif opt_problem._constraints[key].type == 'i': maxg[i] = max(0, self.stored_data['g'][i]) i += 1 # end # end for j in xrange(len(opt_problem._constraints), len(self.stored_data['g'])): maxg[i] = max(0, self.stored_data['g'][i]) i += 1 # end id = min(numpy.nonzero(maxg == max(maxg))[0]) dg = self.stored_data['dg'][id] return dg # Variables Handling nvar = len(opt_problem._variables.keys()) xl = [] xu = [] xx = [] for key in opt_problem._variables.keys(): if (opt_problem._variables[key].type == 'c'): xl.append(opt_problem._variables[key].lower) xu.append(opt_problem._variables[key].upper) xx.append(opt_problem._variables[key].value) elif (opt_problem._variables[key].type == 'i'): raise IOError('SOLVOPT cannot handle integer design variables') elif (opt_problem._variables[key].type == 'd'): raise IOError('SOLVOPT cannot handle discrete design variables') # end # end xl = numpy.array(xl) xu = numpy.array(xu) xx = numpy.array(xx) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key]['name']] = [k, k + group_len] k += group_len # end # end # Constraints Handling ncon = len(opt_problem._constraints.keys()) neqc = 0 gg = [] if ncon > 0: for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': neqc += 1 # end # gg.append(opt_problem._constraints[key].value) gg.append(opt_problem._constraints[key].upper) # end # end nadd = 0 for key in opt_problem._variables.keys(): if (opt_problem._variables[key].lower != -inf): gg.append(0) nadd += 1 # end if (opt_problem._variables[key].upper != inf): gg.append(0) nadd += 1 # end # end gg = numpy.array(gg, numpy.float) # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) # end ff = numpy.array(ff, numpy.float) # Setup argument list values n = numpy.array([nvar], numpy.int) flg = numpy.array([True], numpy.bool) iprint = self.options['iprint'][1] if (myrank != 0): iprint = -1 else: iprint = self.options['iprint'][1] # end options = numpy.zeros([13], numpy.float) options[0] = -1 # Minimize options[1] = self.options['xtol'][1] # Variables Tolerance options[2] = self.options['ftol'][1] # Objective Tolerance options[3] = self.options['maxit'][1] # Maximum Number of Iterations options[4] = iprint # Output Level options[5] = self.options['gtol'][1] # Constraints Tolerance options[6] = self.options['spcdil'][1] # Space Dilation options[7] = 1e-11 # LB FD Stepsize (NA as we provide our own sensitivities) flfc = numpy.array([True], numpy.bool) flgc = numpy.array([True], numpy.bool) iout = numpy.array([self.options['iout'][1]], numpy.int) ifile = self.options['ifile'][1] if (iprint >= 0): if os.path.isfile(ifile): os.remove(ifile) # end # end wb = numpy.zeros([nvar, nvar], numpy.float) wg = numpy.zeros([nvar], numpy.float) wg0 = numpy.zeros([nvar], numpy.float) wg1 = numpy.zeros([nvar], numpy.float) wgt = numpy.zeros([nvar], numpy.float) wgc = numpy.zeros([nvar], numpy.float) wz = numpy.zeros([nvar], numpy.float) wx1 = numpy.zeros([nvar], numpy.float) wxopt = numpy.zeros([nvar], numpy.float) wxrec = numpy.zeros([nvar], numpy.float) wgrec = numpy.zeros([nvar], numpy.float) wxx = numpy.zeros([nvar], numpy.float) wdeltax = numpy.zeros([nvar], numpy.float) widx = numpy.zeros([nvar], numpy.int) # Storage Arrays self.stored_data = {} self.stored_data['x'] = {} # numpy.zeros([nvar],float) self.stored_data['f'] = {} # numpy.zeros([nobj],float) self.stored_data['g'] = {} # numpy.zeros([ncon+nadd],float) self.stored_data['df'] = {} # numpy.zeros([nvar],float) self.stored_data['dg'] = {} # numpy.zeros([ncon+nadd,nvar],float) # Run SOLVOPT t0 = time.time() solvopt.solvopt(n, xx, ff, soobjf, flg, sogrdf, options, flfc, soobjg, flgc, sogrdg, wb, wg, wg0, wg1, wgt, wgc, wz, wx1, wxopt, wxrec, wgrec, wxx, wdeltax, widx, iout, ifile) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name + '.cue') os.remove(name + '.bin') os.rename(name + '_tmp.cue', name + '.cue') os.rename(name + '_tmp.bin', name + '.bin') # end # end # end if (iprint > 0): solvopt.closeunit(self.options['iout'][1]) # end # Store Results sol_inform = {} sol_inform['value'] = options[8] sol_inform['text'] = self.getInform(options[8]) if store_sol: sol_name = 'SOLVOPT Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if sol_options.has_key('defaults'): del sol_options['defaults'] # end sol_evals = options[9] + options[10] # assumes cnst fevals and gevals are included in feval & geval sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xx[i] i += 1 # end sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = ff[i] i += 1 # end if ncon > 0: sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = gg[i] i += 1 if (i >= ncon): break # end # end else: sol_cons = {} # end sol_lambda = {} opt_problem.addSol(self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) # end return ff, xx, sol_inform
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, disp_opts=False, store_hst=False, hot_start=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call. Documentation last updated: February. 2, 2011 - Peter W. Jansen ''' if ((self.poa) and (sens_mode.lower() == 'pgc')): raise NotImplementedError( "pySLSQP - Current implementation only allows single level parallelization, either 'POA' or 'pgc'" ) if self.poa or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print( 'pySLSQP: Parallel objective Function Analysis requires mpi4py' ) comm = MPI.COMM_WORLD nproc = comm.Get_size() if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast elif (mpi4py.__version__[0] >= '1'): Bcast = comm.bcast self.pll = True self.myrank = comm.Get_rank() else: self.pll = False self.myrank = 0 myrank = self.myrank def_fname = self.options['IFILE'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory( opt_problem.name, store_hst, hot_start, def_fname) gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) #====================================================================== # SLSQP - Objective/Constraint Values Function #====================================================================== def slfunc(m, me, la, n, f, g, x): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] xn = xg else: xn = x # Flush Output Files self.flushFiles() # Evaluate User Function fail = 0 ff = [] gg = [] if (myrank == 0): if self.hot_start: [vals, hist_end] = hos_file.read( ident=['obj', 'con', 'fail']) if hist_end: self.hot_start = False hos_file.close() else: [ff, gg, fail] = [ vals['obj'][0][0], vals['con'][0], int(vals['fail'] [0][0]) ] if self.pll: self.hot_start = Bcast(self.hot_start, root=0) if self.hot_start and self.pll: [ff, gg, fail] = Bcast([ff, gg, fail], root=0) elif not self.hot_start: [ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs) # Store History if (myrank == 0): if self.sto_hst: log_file.write(x, 'x') log_file.write(ff, 'obj') log_file.write(gg, 'con') log_file.write(fail, 'fail') # Objective Assigment if isinstance(ff, complex): f = ff.astype(float) else: f = ff # Constraints Assignment (negative gg as slsqp uses g(x) >= 0) for i in range(len(opt_problem._constraints.keys())): if isinstance(gg[i], complex): g[i] = -gg[i].astype(float) else: g[i] = -gg[i] return f, g #====================================================================== # SLSQP - Objective/Constraint Gradients Function #====================================================================== def slgrad(m, me, la, n, f, g, df, dg, x): if self.hot_start: dff = [] dgg = [] if (myrank == 0): [vals, hist_end] = hos_file.read( ident=['grad_obj', 'grad_con']) if hist_end: self.hot_start = False hos_file.close() else: dff = vals['grad_obj'][0].reshape( (len(opt_problem._objectives.keys()), len(opt_problem._variables.keys()))) dgg = vals['grad_con'][0].reshape( (len(opt_problem._constraints.keys()), len(opt_problem._variables.keys()))) if self.pll: self.hot_start = Bcast(self.hot_start, root=0) if self.hot_start and self.pll: [dff, dgg] = Bcast([dff, dgg], root=0) if not self.hot_start: dff, dgg = gradient.getGrad(x, group_ids, [f], -g, *args, ** kwargs) # Store History if self.sto_hst and (myrank == 0): log_file.write(dff, 'grad_obj') log_file.write(dgg, 'grad_con') # Gradient Assigment for i in range(len(opt_problem._variables.keys())): df[i] = dff[0, i] for jj in range(len(opt_problem._constraints.keys())): dg[jj, i] = -dgg[jj, i] return df, dg # Variables Handling n = len(opt_problem._variables.keys()) xl = [] xu = [] xx = [] for key in opt_problem._variables.keys(): if (opt_problem._variables[key].type == 'c'): xl.append(opt_problem._variables[key].lower) xu.append(opt_problem._variables[key].upper) xx.append(opt_problem._variables[key].value) elif (opt_problem._variables[key].type == 'i'): raise IOError('SLSQP cannot handle integer design variables') elif (opt_problem._variables[key].type == 'd'): raise IOError('SLSQP cannot handle discrete design variables') xl = numpy.array(xl) xu = numpy.array(xu) xx = numpy.array(xx) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key][ 'name']] = [k, k + group_len] k += group_len # Constraints Handling m = len(opt_problem._constraints.keys()) meq = 0 #gg = [] if m > 0: for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': meq += 1 #gg.append(opt_problem._constraints[key].value) #gg = numpy.array(gg,numpy.float) # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) ff = numpy.array(ff, numpy.float) # Setup argument list values la = max(m, 1) gg = numpy.zeros([la], numpy.float) n1 = numpy.array([n + 1], numpy.int) df = numpy.zeros([n + 1], numpy.float) dg = numpy.zeros([la, n + 1], numpy.float) acc = numpy.array([self.options['ACC'][1]], numpy.float) maxit = numpy.array([self.options['MAXIT'][1]], numpy.int) iprint = numpy.array([self.options['IPRINT'][1]], numpy.int) if (myrank != 0): iprint = -1 else: iprint = self.options['IPRINT'][1] iout = numpy.array([self.options['IOUT'][1]], numpy.int) ifile = self.options['IFILE'][1] if (iprint >= 0): if os.path.isfile(ifile): os.remove(ifile) mode = numpy.array([0], numpy.int) mineq = m - meq + 2 * (n + 1) lsq = (n + 1) * ((n + 1) + 1) + meq * ((n + 1) + 1) + mineq * ( (n + 1) + 1) lsi = ((n + 1) - meq + 1) * (mineq + 2) + 2 * mineq lsei = ((n + 1) + mineq) * ((n + 1) - meq) + 2 * meq + (n + 1) slsqpb = (n + 1) * (n / 2) + 2 * m + 3 * n + 3 * (n + 1) + 1 lwM = lsq + lsi + lsei + slsqpb + n + m lw = numpy.array([lwM], numpy.int) w = numpy.zeros(lw, numpy.float) ljwM = max(mineq, (n + 1) - meq) ljw = numpy.array([ljwM], numpy.int) jw = numpy.zeros(ljw, numpy.intc) nfunc = numpy.array([0], numpy.int) ngrad = numpy.array([0], numpy.int) # Run SLSQP t0 = time.time() slsqp.slsqp(m, meq, la, n, xx, xl, xu, ff, gg, df, dg, acc, maxit, iprint, iout, ifile, mode, w, lw, jw, ljw, nfunc, ngrad, slfunc, slgrad) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name + '.cue') os.remove(name + '.bin') os.rename(name + '_tmp.cue', name + '.cue') os.rename(name + '_tmp.bin', name + '.bin') if (iprint > 0): slsqp.closeunit(self.options['IOUT'][1]) # Store Results sol_inform = {} sol_inform['value'] = mode[0] sol_inform['text'] = self.getInform(mode[0]) if store_sol: sol_name = 'SLSQP Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if 'defaults' in sol_options: del sol_options['defaults'] sol_evals = 0 sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xx[i] i += 1 sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = ff[i] i += 1 if m > 0: sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = -gg[i] i += 1 else: sol_cons = {} sol_lambda = {} opt_problem.addSol( self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) return ff, xx, sol_inform
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, store_hst=False, hot_start=False, disp_opts=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call. Documentation last updated: February. 2, 2013 - Peter W. Jansen ''' # if ((self.pll_type != None) and (sens_mode.lower() == 'pgc')): raise NotImplementedError( "pyNLPQLP - Current implementation only allows single level parallelization, either 'POA', 'SMP', 'DPM' or 'pgc'" ) #end if (self.pll_type != None) or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print( 'pyNLPQLP: Parallel objective Function Analysis or gradient calculation requires mpi4py' ) #end comm = MPI.COMM_WORLD if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast Barrier = comm.Barrier Send = comm.Send Recv = comm.Recv elif (mpi4py.__version__[0] == '1'): Bcast = comm.bcast Barrier = comm.barrier Send = comm.send Recv = comm.recv #end self.pll = True if (self.pll_type == 'SPM'): nproc = comm.Get_size() else: nproc = 1 #end self.myrank = comm.Get_rank() else: self.pll = False nproc = 1 self.myrank = 0 #end myrank = self.myrank # def_fname = self.options['IFILE'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory( opt_problem.name, store_hst, hot_start, def_fname) # gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) #====================================================================== # NLPQLP - Objective/Constraint Values Function #====================================================================== def nlfunc(l, nmax, mmax, x, lactive, active, f, g): # if (self.pll_type == 'SPM'): mxi = myrank else: mxi = 0 #end # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = x[group_ids[group][0], mxi] else: xg[group] = x[group_ids[group][0]:group_ids[group][1], mxi] #end #end xn = xg else: xn = x[:-1, mxi] #end # Flush Output Files self.flushFiles() # Evaluate User Function fail = 0 ff = [] gg = [] if (myrank == 0): if self.hot_start: for proc in range(l): [vals, hist_end ] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.hot_start = False hos_file.close() else: [ff, gg, fail] = [ vals['obj'][0][0], vals['con'][0], int(vals['fail'][0][0]) ] f[proc] = ff g[:, proc] = gg #end #end #end #end if self.pll: self.hot_start = Bcast(self.hot_start, root=0) #end if self.hot_start and self.pll: [f, g] = Bcast([f, g], root=0) elif not self.hot_start: [ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs) # Objective Assigment if isinstance(ff, complex): f[mxi] = ff.astype(float) else: f[mxi] = ff #end # Constraints Assigment (negative gg as nlpqlp uses g(x) >= 0) for i in range(len(opt_problem._constraints.keys())): if isinstance(gg[i], complex): g[i, mxi] = -gg[i].astype(float) else: g[i, mxi] = -gg[i] #end #end if (self.pll_type == 'SPM'): send_buf = {} send_buf[myrank] = {'fi': f[mxi], 'gi': g[:, mxi]} if myrank != 0: Send(send_buf, dest=0) else: p_results = [] for proc in range(1, nproc): p_results.append(Recv(source=proc)) #end #end if myrank == 0: for proc in range(nproc - 1): for i in p_results[proc].keys(): f[i] = p_results[proc][i]['fi'] g[:, i] = p_results[proc][i]['gi'] #end #end #end [f, g] = Bcast([f, g], root=0) #end #end # Store History if (myrank == 0): if self.sto_hst: for proc in range(l): log_file.write(x[:-1, proc], 'x') log_file.write(f[proc], 'obj') log_file.write(g[:, proc], 'con') log_file.write(fail, 'fail') #end #end #end return f, g #====================================================================== # NLPQLP - Objective/Constraint Gradients Function #====================================================================== def nlgrad(l, nmax, mmax, x, lactive, active, f, g, df, dg): if self.hot_start: dff = [] dgg = [] if (myrank == 0): [vals, hist_end] = hos_file.read(ident=['grad_obj', 'grad_con']) if hist_end: self.hot_start = False hos_file.close() else: dff = vals['grad_obj'][0].reshape( (len(opt_problem._objectives.keys()), len(opt_problem._variables.keys()))) dgg = vals['grad_con'][0].reshape( (len(opt_problem._constraints.keys()), len(opt_problem._variables.keys()))) #end #end if self.pll: self.hot_start = Bcast(self.hot_start, root=0) #end if self.hot_start and self.pll: [dff, dgg] = Bcast([dff, dgg], root=0) #end #end if not self.hot_start: # dff, dgg = gradient.getGrad( x[:-1, 0], group_ids, [f[0]], -g[0:len(opt_problem._constraints.keys()), 0], *args, **kwargs) #end # Store History if self.sto_hst and (myrank == 0): log_file.write(dff, 'grad_obj') log_file.write(dgg, 'grad_con') #end # Gradient Assignment for i in range(len(opt_problem._variables.keys())): df[i] = dff[0, i] for j in range(len(opt_problem._constraints.keys())): dg[j, i] = -dgg[j, i] #end #end return df, dg # Variables Handling nvar = len(opt_problem._variables.keys()) xl = numpy.zeros([max(2, nvar + 1)], numpy.float) xu = numpy.zeros([max(2, nvar + 1)], numpy.float) xx = numpy.zeros([max(2, nvar + 1), nproc], numpy.float) i = 0 for key in opt_problem._variables.keys(): if (opt_problem._variables[key].type == 'c'): xl[i] = opt_problem._variables[key].lower xu[i] = opt_problem._variables[key].upper for proc in range(nproc): xx[i, proc] = opt_problem._variables[key].value #end elif (opt_problem._variables[key].type == 'i'): raise IOError('NLPQLP cannot handle integer design variables') elif (opt_problem._variables[key].type == 'd'): raise IOError('NLPQLP cannot handle discrete design variables') #end i += 1 #end # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key]['name']] = [ k, k + group_len ] k += group_len #end #end # Constraints Handling ncon = len(opt_problem._constraints.keys()) neqc = 0 gg = numpy.zeros([ncon, nproc], numpy.float) if ncon > 0: i = 0 for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': neqc += 1 #end if (self.pll == False): gg[i, 0] = opt_problem._constraints[key].value else: for proc in range(nproc): gg[i, proc] = opt_problem._constraints[key].value #end #end i += 1 #end #end # Objective Handling objfunc = opt_problem.obj_fun if (len(opt_problem._objectives.keys()) > 1): raise IOError('NLPQLP cannot handle multi-objective problems') #end ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) #end ff = numpy.array(ff * nproc, numpy.float) # Setup argument list values ll = numpy.array([nproc], numpy.int) mm = numpy.array([ncon], numpy.int) me = numpy.array([neqc], numpy.int) mmax = numpy.array([max(1, mm)], numpy.int) nn = numpy.array([nvar], numpy.int) nmax = numpy.array([max(2, nn + 1)], numpy.int) mnn2 = numpy.array([mmax + nmax + nmax + 2], numpy.int) gg = numpy.zeros([mmax, ll], numpy.float) df = numpy.zeros([nmax], numpy.float) dg = numpy.zeros([mmax, nmax], numpy.float) uu = numpy.zeros([mnn2], numpy.float) cc = numpy.zeros([nmax, nmax], numpy.float) dd = numpy.zeros([nmax], numpy.float) acc = numpy.array([self.options['ACC'][1]], numpy.float) accqp = numpy.array([self.options['ACCQP'][1]], numpy.float) stpmin = numpy.array([self.options['STPMIN'][1]], numpy.float) maxfun = numpy.array([self.options['MAXFUN'][1]], numpy.int) maxit = numpy.array([self.options['MAXIT'][1]], numpy.int) if (nproc != 1): maxnm = numpy.array([max(1, min(50, nproc))], numpy.int) else: maxnm = numpy.array([0], numpy.int) #end rhob = self.options['RHOB'][1] if (self.options['MODE'][1] >= 0 and self.options['MODE'][1] <= 18): mode = self.options['MODE'][1] else: raise IOError('Incorrect Mode Setting') #end ifail = numpy.array([0], numpy.int) if (myrank == 0): if (self.options['IPRINT'][1] >= 0 and self.options['IPRINT'][1] <= 4): iprint = numpy.array([self.options['IPRINT'][1]], numpy.int) else: raise IOError('Incorrect Output Level Setting') #end else: iprint = numpy.array([0], numpy.int) #end iout = self.options['IOUT'][1] ifile = self.options['IFILE'][1] if (iprint > 0): if os.path.isfile(ifile): os.remove(ifile) #end #end lwa = numpy.array([ 23 * nmax + 4 * mmax + 3 * mmax + 150 + 3 * nmax * nmax / 2 + 10 * nmax + nmax + mmax + 1 ], numpy.int) wa = numpy.zeros([lwa], numpy.float) lkwa = numpy.array([25 + nmax], numpy.int) kwa = numpy.zeros([lkwa], numpy.intc) lactiv = numpy.array([2 * mmax + 10], numpy.int) active = numpy.zeros([lactiv], numpy.bool) lql = numpy.array([self.options['LQL'][1]], numpy.bool) nfun = numpy.array([0], numpy.int) ngrd = numpy.array([0], numpy.int) # Run NLPQLP t0 = time.time() xx, ff, gg, uu, nfun, ngrd = nlpqlp.nlpqlp_wrap( ll, mm, me, mmax, nn, nmax, mnn2, xx, ff, gg, df, dg, uu, xl, xu, cc, dd, acc, accqp, stpmin, maxfun, maxit, maxnm, rhob, mode, ifail, iprint, iout, ifile, wa, lwa, kwa, lkwa, active, lactiv, lql, nfun, ngrd, nlfunc, nlgrad) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name + '.cue') os.remove(name + '.bin') os.rename(name + '_tmp.cue', name + '.cue') os.rename(name + '_tmp.bin', name + '.bin') #end #end #end if (iprint > 0): nlpqlp.closeunit(self.options['IOUT'][1]) #end # Store Results sol_inform = {} sol_inform['value'] = ifail[0] sol_inform['text'] = self.getInform(ifail[0]) if store_sol: sol_name = 'NLPQLP Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if 'defaults' in sol_options: del sol_options['defaults'] #end sol_evals = nfun + ngrd * nvar sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xx[i, 0] i += 1 #end sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = ff[0] i += 1 #end if ncon > 0: sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = -gg[i, 0] i += 1 #end else: sol_cons = {} #end if ncon > 0: sol_lambda = numpy.zeros(ncon, float) for i in range(ncon): sol_lambda[i] = uu[i] #end else: sol_lambda = {} #end opt_problem.addSol(self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) #end return ff, xx, sol_inform
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, disp_opts=False, store_hst=False, hot_start=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call. Documentation last updated: February. 2, 2011 - Peter W. Jansen ''' # if ((self.poa) and (sens_mode.lower() == 'pgc')): raise NotImplementedError( "pyALGENCAN - Current implementation only allows single level parallelization, either 'POA' or 'pgc'" ) #end if self.poa or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print 'pyALGENCAN: Parallel objective Function Analysis requires mpi4py' #end comm = MPI.COMM_WORLD nproc = comm.Get_size() if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast elif (mpi4py.__version__[0] == '1'): Bcast = comm.bcast #end self.pll = True self.myrank = comm.Get_rank() else: self.pll = False self.myrank = 0 #end myrank = self.myrank # def_fname = self.options['ifile'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory( opt_problem.name, store_hst, hot_start, def_fname) # gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) # def evalf(n, x, f, flag): flag = -1 return f, flag def evalg(n, x, g, flag): flag = -1 return g, flag def evalh(n, x, hlin, hcol, hval, hnnz, flag): flag = -1 return hlin, hcol, hval, hnnz, flag def evalc(n, x, ind, c, flag): flag = -1 return c, flag def evaljac(n, x, ind, jcvar, jcval, jcnnz, flag): flag = -1 return jcvar, jcval, jcnnz, flag def evalgjacp(n, x, g, m, p, q, work, gotj, flag): flag = -1 return g, p, q, gotj, flag def evalhc(n, x, ind, hclin, hccol, hcval, hcnnz, flag): flag = -1 return hclin, hccol, hcval, hcnnz, flag def evalhl(n, x, m, lmbda, scalef, scalec, hllin, hlcol, hlval, hlnnz, flag): flag = -1 return hllin, hlcol, hlval, hlnnz, flag def evalhlp(n, x, m, lmbda, sf, sc, p, hp, goth, flag): flag = -1 return hp, goth, flag #====================================================================== # ALGENCAN - Objective/Constraint Values Function #====================================================================== def evalfc(n, x, f, m, g, flag): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] #end #end xn = xg else: xn = x #end # Flush Output Files self.flushFiles() # Evaluate User Function flag = 0 if (myrank == 0): if self.h_start: [vals, hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.h_start = False hos_file.close() else: [ff, gg, flag] = [ vals['obj'][0][0], vals['con'][0], int(vals['fail'][0][0]) ] #end #end #end if self.pll: self.h_start = Bcast(self.h_start, root=0) #end if self.h_start and self.pll: [ff, gg, fail] = Bcast([ff, gg, fail], root=0) elif not self.h_start: [ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs) #end # Store History if (myrank == 0): if self.sto_hst: log_file.write(x, 'x') log_file.write(ff, 'obj') log_file.write(gg, 'con') log_file.write(fail, 'fail') #end #end # Objective Assigment if isinstance(ff, complex): f = ff.astype(float) else: f = ff #end # Constraints Assigment for i in xrange(len(opt_problem._constraints.keys())): if isinstance(gg[i], complex): g[i] = gg[i].astype(float) else: g[i] = gg[i] #end #end return f, g, fail #====================================================================== # ALGENCAN - Objective/Constraint Gradients Function #====================================================================== def evalgjac(n, x, jfval, m, jcfun, jcvar, jcval, jcnnz, flag): if self.h_start: if (myrank == 0): [vals, hist_end] = hos_file.read(ident=['grad_obj', 'grad_con']) if hist_end: self.h_start = False hos_file.close() else: dff = vals['grad_obj'][0].reshape( (len(opt_problem._objectives.keys()), len(opt_problem._variables.keys()))) dgg = vals['grad_con'][0].reshape( (len(opt_problem._constraints.keys()), len(opt_problem._variables.keys()))) #end #end if self.pll: self.h_start = Bcast(self.h_start, root=0) #end if self.h_start and self.pll: [dff, dgg] = Bcast([dff, dgg], root=0) #end #end if not self.h_start: [ff, gg, fail] = opt_problem.obj_fun(x, *args, **kwargs) dff, dgg = gradient.getGrad(x, group_ids, [ff], gg, *args, **kwargs) #end # Store History if self.sto_hst and (myrank == 0): log_file.write(dff, 'grad_obj') log_file.write(dgg, 'grad_con') #end # Objective Gradient Assigment for i in xrange(len(opt_problem._variables.keys())): jfval[i] = dff[0, i] #end # Constraint Gradient Assigment jcnnz = 0 for jj in xrange(len(opt_problem._constraints.keys())): for ii in xrange(len(opt_problem._variables.keys())): jcfun[jcnnz] = jj + 1 jcvar[jcnnz] = ii + 1 jcval[jcnnz] = dgg[jj, ii] jcnnz += 1 #end #end return jfval, jcfun, jcvar, jcval, jcnnz, fail # Variables Handling n = len(opt_problem._variables.keys()) xl = [] xu = [] xx = [] for key in opt_problem._variables.keys(): if (opt_problem._variables[key].type == 'c'): xl.append(opt_problem._variables[key].lower) xu.append(opt_problem._variables[key].upper) xx.append(opt_problem._variables[key].value) elif (opt_problem._variables[key].type == 'i'): raise IOError('NLPQL cannot handle integer design variables') elif (opt_problem._variables[key].type == 'd'): raise IOError('NLPQL cannot handle discrete design variables') #end #end xl = numpy.array(xl) xu = numpy.array(xu) xx = numpy.array(xx) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key]['name']] = [ k, k + group_len ] k += group_len #end #end # Constraints Handling m = len(opt_problem._constraints.keys()) equatn = [] linear = [] if m > 0: for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': equatn.append(True) elif opt_problem._constraints[key].type == 'i': equatn.append(False) #end linear.append(False) #end else: raise IOError( 'ALGENCAN support for unconstrained problems not implemented yet' ) #end equatn = numpy.array(equatn) linear = numpy.array(linear) # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) #end ff = numpy.array(ff) # Setup argument list values nn = numpy.array([n], numpy.int) mm = numpy.array([m], numpy.int) lm = numpy.zeros([m], numpy.float) coded = numpy.array([ False, False, False, False, False, False, True, True, False, False ], numpy.bool) epsfeas = numpy.array([self.options['epsfeas'][1]], numpy.float) epsopt = numpy.array([self.options['epsopt'][1]], numpy.float) efacc = numpy.array([self.options['efacc'][1]], numpy.float) eoacc = numpy.array([self.options['eoacc'][1]], numpy.float) checkder = numpy.array([self.options['checkder'][1]], numpy.bool) iprint = numpy.array([self.options['iprint'][1]], numpy.int) if (myrank != 0): iprint = 0 else: iprint = self.options['iprint'][1] #end ncomp = numpy.array([self.options['ncomp'][1]], numpy.int) ifile = self.options['ifile'][1] if (iprint >= 0): if os.path.isfile(ifile): os.remove(ifile) #end #end cnormu = numpy.array([0], numpy.float) snorm = numpy.array([0], numpy.float) nlpsupn = numpy.array([0], numpy.float) inform = numpy.array([0], numpy.int) # Run ALGENCAN t0 = time.time() algencan.algencan(epsfeas, epsopt, efacc, eoacc, iprint, ncomp, nn, xx, xl, xu, mm, lm, equatn, linear, coded, checkder, ff, cnormu, snorm, nlpsupn, inform, ifile, evalf, evalg, evalh, evalc, evaljac, evalhc, evalfc, evalgjac, evalgjacp, evalhl, evalhlp) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name + '.cue') os.remove(name + '.bin') os.rename(name + '_tmp.cue', name + '.cue') os.rename(name + '_tmp.bin', name + '.bin') #end #end #end if (iprint > 0): algencan.closeunit(10) #end # [fs, gg, fail] = opt_problem.obj_fun(xx, *args, **kwargs) # Store Results sol_inform = {} sol_inform['value'] = inform[0] sol_inform['text'] = self.getInform(inform[0]) if store_sol: sol_name = 'ALGENCAN Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if sol_options.has_key('defaults'): del sol_options['defaults'] #end sol_evals = 0 sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xx[i] i += 1 #end sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = ff[i] i += 1 #end if m > 0: sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = gg[i] i += 1 #end else: sol_cons = {} #end sol_lambda = lm opt_problem.addSol(self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) #end return ff, xx, sol_inform
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, disp_opts=False, store_hst=False, hot_start=False, sens_mode='', sens_step={}, *args, **kwargs): """ Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Documentation last updated: Feb. 2, 2011 - Peter W. Jansen """ self.pll = False self.myrank = 0 myrank = self.myrank tmp_file = False def_fname = self.options['output_file'][1].split('.')[0] if isinstance(store_hst, str): if isinstance(hot_start, str): if (myrank == 0): if (store_hst == hot_start): hos_file = History(hot_start, 'r', self) log_file = History(store_hst + '_tmp', 'w', self, opt_problem.name) tmp_file = True else: hos_file = History(hot_start, 'r', self) log_file = History(store_hst, 'w', self, opt_problem.name) self.sto_hst = True self.hot_start = True elif hot_start: if (myrank == 0): hos_file = History(store_hst, 'r', self) log_file = History(store_hst + '_tmp', 'w', self, opt_problem.name) tmp_file = True self.sto_hst = True self.hot_start = True else: if (myrank == 0): log_file = History(store_hst, 'w', self, opt_problem.name) self.sto_hst = True self.hot_start = False elif store_hst: if isinstance(hot_start, str): if (hot_start == def_fname): if (myrank == 0): hos_file = History(hot_start, 'r', self) log_file = History(def_fname + '_tmp', 'w', self, opt_problem.name) tmp_file = True else: if (myrank == 0): hos_file = History(hot_start, 'r', self) log_file = History(def_fname, 'w', self, opt_problem.name) self.sto_hst = True self.hot_start = True elif hot_start: if (myrank == 0): hos_file = History(def_fname, 'r', self) log_file = History(def_fname + '_tmp', 'w', self, opt_problem.name) tmp_file = True self.sto_hst = True self.hot_start = True else: if (myrank == 0): log_file = History(def_fname, 'w', self, opt_problem.name) self.sto_hst = True self.hot_start = False else: self.sto_hst = False self.hot_start = False gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) def eval_f(x, user_data=None): """IPOPT - Objective Value Function.""" # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] xn = xg else: xn = x # Flush Output Files self.flushFiles() # Evaluate User Function fail = 0 # if (myrank == 0): # if self.hot_start: # [vals,hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) # if hist_end: # self.hot_start = False # hos_file.close() # else: # [ff,gg,fail] = [vals['obj'][0][0],vals['con'][0],int(vals['fail'][0][0])] # # # if self.pll: # self.hot_start = Bcast(self.hot_start,root=0) # if self.hot_start and self.pll: # [ff,gg,fail] = Bcast([ff,gg,fail],root=0) # else: [ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs) # Store History if (myrank == 0): if self.sto_hst: log_file.write(x, 'x') log_file.write(ff, 'obj') log_file.write(gg, 'con') log_file.write(fail, 'fail') # Objective Assigment if isinstance(ff, complex): f = ff.astype(float) else: f = ff # Constraints Assigment g = numpy.zeros(len(opt_problem._constraints.keys())) for i in range(len(opt_problem._constraints.keys())): if isinstance(gg[i], complex): g[i] = gg[i].astype(float) else: g[i] = gg[i] return f def eval_g(x, user_data=None): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] xn = xg else: xn = x # Flush Output Files self.flushFiles() # Evaluate User Function fail = 0 # if (myrank == 0): # if self.hot_start: # [vals,hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) # if hist_end: # self.hot_start = False # hos_file.close() # else: # [ff,gg,fail] = [vals['obj'][0][0],vals['con'][0],int(vals['fail'][0][0])] # if self.pll: # self.hot_start = Bcast(self.hot_start,root=0) # if self.hot_start and self.pll: # [ff,gg,fail] = Bcast([ff,gg,fail],root=0) # else: [ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs) # Store History if (myrank == 0): if self.sto_hst: log_file.write(x, 'x') log_file.write(ff, 'obj') log_file.write(gg, 'con') log_file.write(fail, 'fail') # Objective Assigment if isinstance(ff, complex): f = ff.astype(float) else: f = ff # Constraints Assigment g = numpy.zeros(len(opt_problem._constraints.keys())) for i in range(len(opt_problem._constraints.keys())): if isinstance(gg[i], complex): g[i] = gg[i].astype(float) else: g[i] = gg[i] return g def eval_grad_f(x, user_data=None): """IPOPT - Objective/Constraint Gradients Function.""" # if self.hot_start: # if (myrank == 0): # [vals,hist_end] = hos_file.read(ident=['grad_obj','grad_con']) # if hist_end: # self.hot_start = False # hos_file.close() # else: # dff = vals['grad_obj'][0].reshape((len(opt_problem._objectives.keys()),len(opt_problem._variables.keys()))) # dgg = vals['grad_con'][0].reshape((len(opt_problem._constraints.keys()),len(opt_problem._variables.keys()))) # # # if self.pll: # self.hot_start = Bcast(self.hot_start,root=0) # # if self.hot_start and self.pll: # [dff,dgg] = Bcast([dff,dgg],root=0) # # if not self.hot_start: [f, g, fail] = opt_problem.obj_fun(x, *args, **kwargs) dff, dgg = gradient.getGrad(x, group_ids, [f], g, *args, **kwargs) # Store History if self.sto_hst and (myrank == 0): log_file.write(dff, 'grad_obj') log_file.write(dgg, 'grad_con') # Gradient Assignment df = numpy.zeros(len(opt_problem._variables.keys())) for i in range(len(opt_problem._variables.keys())): df[i] = dff[0, i] return df def eval_grad_g(x, flag, user_data=None): # if self.hot_start: # if (myrank == 0): # [vals,hist_end] = hos_file.read(ident=['grad_obj','grad_con']) # if hist_end: # self.hot_start = False # hos_file.close() # else: # dff = vals['grad_obj'][0].reshape((len(opt_problem._objectives.keys()),len(opt_problem._variables.keys()))) # dgg = vals['grad_con'][0].reshape((len(opt_problem._constraints.keys()),len(opt_problem._variables.keys()))) # # # if self.pll: # self.hot_start = Bcast(self.hot_start,root=0) # # if self.hot_start and self.pll: # [dff,dgg] = Bcast([dff,dgg],root=0) # # if not self.hot_start: if flag: a = numpy.zeros( len(opt_problem._variables.keys()) * len(opt_problem._constraints.keys()), int) b = numpy.zeros( len(opt_problem._variables.keys()) * len(opt_problem._constraints.keys()), int) for i in range(len(opt_problem._constraints.keys())): for j in range(len(opt_problem._variables.keys())): a[i * len(opt_problem._variables.keys()) + j] = i b[i * len(opt_problem._variables.keys()) + j] = j return (a, b) else: [f, g, fail] = opt_problem.obj_fun(x, *args, **kwargs) dff, dgg = gradient.getGrad(x, group_ids, [f], g, *args, **kwargs) # Store History if self.sto_hst and (myrank == 0): log_file.write(dff, 'grad_obj') log_file.write(dgg, 'grad_con') # Gradient Assignment a = numpy.zeros([ len(opt_problem._variables.keys()) * len(opt_problem._constraints.keys()) ]) for i in range(len(opt_problem._constraints.keys())): for j in range(len(opt_problem._variables.keys())): a[i * len(opt_problem._variables.keys()) + j] = dgg[i, j] return a # Variables Handling nvar = len(opt_problem._variables.keys()) xl = [] xu = [] xx = [] for key in opt_problem._variables.keys(): if opt_problem._variables[key].type == 'c': xl.append(opt_problem._variables[key].lower) xu.append(opt_problem._variables[key].upper) xx.append(opt_problem._variables[key].value) elif opt_problem._variables[key].type == 'i': raise IOError('IPOPT cannot handle integer design variables') elif opt_problem._variables[key].type == 'd': raise IOError('IPOPT cannot handle discrete design variables') xl = numpy.array(xl) xu = numpy.array(xu) xx = numpy.array(xx) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key][ 'name']] = [k, k + group_len] k += group_len # Constraints Handling ncon = len(opt_problem._constraints.keys()) blc = [] buc = [] if ncon > 0: for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': blc.append(opt_problem._constraints[key].equal) buc.append(opt_problem._constraints[key].equal) elif opt_problem._constraints[key].type == 'i': blc.append(opt_problem._constraints[key].lower) buc.append(opt_problem._constraints[key].upper) else: if ((store_sol) and (myrank == 0)): print("Optimization Problem Does Not Have Constraints\n") print("Unconstrained Optimization Initiated\n") ncon = 1 blc.append(-inf) buc.append(inf) blc = numpy.array(blc) buc = numpy.array(buc) # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) ff = numpy.array(ff) # Create an IPOPT instance problem nnzj = nvar * ncon nnzh = nvar * nvar ipopt = pyipopt.create(nvar, xl, xu, ncon, blc, buc, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_grad_g) # Setup Options optionss = self.options.copy() del optionss['defaults'] for i in optionss: if not self.options['defaults'][i][1] == optionss[i][1]: if self.options[i][0].__name__ == 'int': ipopt.int_option(i, self.options[i][1]) if self.options[i][0].__name__ == 'float': ipopt.num_option(i, self.options[i][1]) if self.options[i][0].__name__ == 'str': ipopt.str_option(i, self.options[i][1]) # Run IPOPT t0 = time.time() r = ipopt.solve(xx) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name + '.cue') os.remove(name + '.bin') os.rename(name + '_tmp.cue', name + '.cue') os.rename(name + '_tmp.bin', name + '.bin') ipopt.close() # Store Results sol_inform = {} print(r) sol_inform['value'] = r[-1] # ifail[0] sol_inform['text'] = self.getInform(r[-1]) # self.getInform(ifail[0]) if store_sol: sol_name = 'IPOPT Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if 'default' in sol_options: del sol_options['defaults'] sol_evals = 0 sol_vars = copy.deepcopy(opt_problem._variables) i = 0 x = r[0] for key in sol_vars.keys(): sol_vars[key].value = x[i] i += 1 sol_objs = copy.deepcopy(opt_problem._objectives) sol_objs[0].value = r[4] sol_cons = {} if ncon > 0: sol_lambda = r[3] else: sol_lambda = {} opt_problem.addSol( self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) return ff, xx, sol_inform # ifail[0]
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, store_hst=False, hot_start=False, disp_opts=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call Documentation last updated: February. 2, 2011 - Ruben E. Perez ''' # if ((self.poa) and (sens_mode.lower() == 'pgc')): raise NotImplementedError("pyCONMIN- Current implementation only allows single level parallelization, either 'POA' or 'pgc'") if self.poa or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print('pyCONMIN: Parallel objective Function Analysis requires mpi4py') comm = MPI.COMM_WORLD nproc = comm.Get_size() if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast elif (mpi4py.__version__[0] == '1'): Bcast = comm.bcast self.pll = True self.myrank = comm.Get_rank() else: self.pll = False self.myrank = 0 myrank = self.myrank # def_fname = self.options['IFILE'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory(opt_problem.name, store_hst, hot_start, def_fname) # gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) #====================================================================== # CONMIN - Objective/Constraint Values Function #====================================================================== def cnmnfun(n1,n2,x,f,g): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1]-group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] xn = xg else: xn = x # Flush Output Files self.flushFiles() # Evaluate User Function fail = 0 ff = [] gg = [] if (myrank == 0): if self.hot_start: [vals,hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.hot_start = False hos_file.close() else: [ff,gg,fail] = [vals['obj'][0][0],vals['con'][0],int(vals['fail'][0][0])] if self.pll: self.hot_start = Bcast(self.hot_start,root=0) if self.hot_start and self.pll: [ff,gg,fail] = Bcast([ff,gg,fail],root=0) elif not self.hot_start: [ff,gg,fail] = opt_problem.obj_fun(xn, *args, **kwargs) # Store History if (myrank == 0): if self.sto_hst: log_file.write(x,'x') log_file.write(ff,'obj') log_file.write(gg,'con') log_file.write(fail,'fail') # Objective Assigment if isinstance(ff,complex): f = ff.astype(float) else: f = ff # Constraints Assigment for i in range(len(opt_problem._constraints.keys())): if isinstance(gg[i],complex): g[i] = gg[i].astype(float) else: g[i] = gg[i] return f,g #====================================================================== # CONMIN - Objective/Constraint Gradients Function #====================================================================== def cnmngrd(n1,n2,x,f,g,ct,df,a,ic,nac): # nac = 0 for j in range(len(opt_problem._constraints.keys())): if (g[j] >= ct): ic[nac] = j + 1 nac += 1 # if self.hot_start: dff = [] dgg = [] if (myrank == 0): [vals,hist_end] = hos_file.read(ident=['grad_obj','grad_con']) if hist_end: self.hot_start = False hos_file.close() else: dff = vals['grad_obj'][0].reshape((len(opt_problem._objectives.keys()),len(opt_problem._variables.keys()))) dgg = vals['grad_con'][0].reshape((len(opt_problem._constraints.keys()),len(opt_problem._variables.keys()))) if self.pll: self.hot_start = Bcast(self.hot_start,root=0) if self.hot_start and self.pll: [dff,dgg] = Bcast([dff,dgg],root=0) if not self.hot_start: # dff,dgg = gradient.getGrad(x, group_ids, [f], g[0:len(opt_problem._constraints.keys())], *args, **kwargs) # Store History if self.sto_hst and (myrank == 0): log_file.write(dff,'grad_obj') log_file.write(dgg,'grad_con') # Gradient Assignment for i in range(len(opt_problem._variables.keys())): df[i] = dff[0,i] for j in range(len(opt_problem._constraints.keys())): for k in range(nac): if (ic[k] == j+1): a[i,k] = dgg[j,i] return df,a,ic,nac # Variables Handling nvar = len(opt_problem._variables.keys()) xl = [] xu = [] xx = [] for key in opt_problem._variables.keys(): if (opt_problem._variables[key].type == 'c'): xl.append(opt_problem._variables[key].lower) xu.append(opt_problem._variables[key].upper) xx.append(opt_problem._variables[key].value) elif (opt_problem._variables[key].type == 'i'): raise IOError('CONMIN cannot handle integer design variables') elif (opt_problem._variables[key].type == 'd'): raise IOError('CONMIN cannot handle discrete design variables') xl = numpy.array(xl) xu = numpy.array(xu) xx = numpy.array(xx) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key]['name']] = [k,k+group_len] k += group_len # Constraints Handling ncon = len(opt_problem._constraints.keys()) #neqc = 0 #gg = [] if ncon > 0: for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'e': raise IOError('CONMIN cannot handle equality constraints') #neqc += 1 #gg.append(opt_problem._constraints[key].value) #gg = numpy.array(gg) # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) ff = numpy.array(ff,numpy.float) # Setup argument list values ndv = numpy.array([nvar], numpy.int) ncn = numpy.array([ncon], numpy.int) nn1 = numpy.array([ndv[0]+2], numpy.int) nn2 = numpy.array([ncn[0]+2*ndv[0]], numpy.int) #nn3 = numpy.array([numpy.min(100,ndv[0]+1)], numpy.int) nn3 = numpy.array([numpy.max([nn2[0],ndv[0]])], numpy.int) #nn4 = numpy.array([numpy.max(nn3[0],ndv[0])], numpy.int) nn4 = numpy.array([numpy.max([nn2[0],ndv[0]])], numpy.int) nn5 = numpy.array([2*nn4[0]], numpy.int) if ncon > 0: gg = numpy.zeros(ncn, numpy.float) else: gg = numpy.array([0], numpy.float) if (myrank == 0): if (self.options['IPRINT'][1]>=0 and self.options['IPRINT'][1]<=4): iprint = numpy.array([self.options['IPRINT'][1]], numpy.int) else: raise IOError('Incorrect Output Level Setting') else: iprint = numpy.array([0], numpy.int) iout = numpy.array([self.options['IOUT'][1]], numpy.int) ifile = self.options['IFILE'][1] if (iprint > 0): if os.path.isfile(ifile): os.remove(ifile) itmax = numpy.array([self.options['ITMAX'][1]], numpy.int) delfun = numpy.array([self.options['DELFUN'][1]], numpy.float) finit,ginit = cnmnfun([],[],xx,ff,gg) dabfun = numpy.array([self.options['DABFUN'][1]*finit], numpy.float) itrm = numpy.array([self.options['ITRM'][1]], numpy.int) nfeasct = numpy.array([self.options['NFEASCT'][1]], numpy.int) nfdg = numpy.array(1, numpy.int) nfun = numpy.array([0], numpy.int) ngrd = numpy.array([0], numpy.int) # Run CONMIN t0 = time.time() conmin.conmin(ndv,ncn,xx,xl,xu,ff,gg,nn1,nn2,nn3,nn4,nn5, iprint,iout,ifile,itmax,delfun,dabfun,itrm,nfeasct, nfdg,nfun,ngrd,cnmnfun,cnmngrd) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name+'.cue') os.remove(name+'.bin') os.rename(name+'_tmp.cue',name+'.cue') os.rename(name+'_tmp.bin',name+'.bin') if (iprint > 0): conmin.closeunit(self.options['IOUT'][1]) # Store Results sol_inform = {} sol_inform['value'] = [] #ifail[0] sol_inform['text'] = {} #self.getInform(ifail[0]) if store_sol: sol_name = 'CONMIN Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if 'defaults' in sol_options: del sol_options['defaults'] sol_evals = nfun[0] + ngrd[0]*nvar sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xx[i] i += 1 sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = ff[i] i += 1 if ncon > 0: sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = gg[i] i += 1 else: sol_cons = {} sol_lambda = {} opt_problem.addSol(self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) return ff, xx, sol_inform #ifail[0]
def __solve__(self, opt_problem={}, sens_type='FD', store_sol=True, store_hst=False, hot_start=False, disp_opts=False, sens_mode='', sens_step={}, *args, **kwargs): ''' Run Optimizer (Optimize Routine) **Keyword arguments:** - opt_problem -> INST: Optimization instance - sens_type -> STR/FUNC: Gradient type, *Default* = 'FD' - store_sol -> BOOL: Store solution in Optimization class flag, *Default* = True - disp_opts -> BOOL: Flag to display options in solution text, *Default* = False - store_hst -> BOOL/STR: Flag/filename to store optimization history, *Default* = False - hot_start -> BOOL/STR: Flag/filename to read optimization history, *Default* = False - sens_mode -> STR: Flag for parallel gradient calculation, *Default* = '' - sens_step -> FLOAT: Sensitivity setp size, *Default* = {} [corresponds to 1e-6 (FD), 1e-20(CS)] Additional arguments and keyword arguments are passed to the objective function call. Documentation last updated: February. 2, 2011 - Ruben E. Perez ''' # if ((self.poa) and (sens_mode.lower() == 'pgc')): raise NotImplementedError( "pyMMFD - Current implementation only allows single level parallelization, either 'POA' or 'pgc'" ) #end if self.poa or (sens_mode.lower() == 'pgc'): try: import mpi4py from mpi4py import MPI except ImportError: print( 'pyMMFD: Parallel objective Function Analysis requires mpi4py' ) #end comm = MPI.COMM_WORLD nproc = comm.Get_size() if (mpi4py.__version__[0] == '0'): Bcast = comm.Bcast elif (mpi4py.__version__[0] == '1'): Bcast = comm.bcast #end self.pll = True self.myrank = comm.Get_rank() else: self.pll = False self.myrank = 0 #end myrank = self.myrank # def_fname = self.options['IFILE'][1].split('.')[0] hos_file, log_file, tmp_file = self._setHistory( opt_problem.name, store_hst, hot_start, def_fname) # gradient = Gradient(opt_problem, sens_type, sens_mode, sens_step, *args, **kwargs) #====================================================================== # MMFD - Objective/Constraint Values Function #====================================================================== def mmfdfun(nv, nc, x, f, g): # Variables Groups Handling if opt_problem.use_groups: xg = {} for group in group_ids.keys(): if (group_ids[group][1] - group_ids[group][0] == 1): xg[group] = x[group_ids[group][0]] else: xg[group] = x[group_ids[group][0]:group_ids[group][1]] #end #end xn = xg else: xn = x #end # Flush Output Files self.flushFiles() # Evaluate User Function fail = 0 ff = [] gg = [] if (myrank == 0): if self.hot_start: [vals, hist_end] = hos_file.read(ident=['obj', 'con', 'fail']) if hist_end: self.hot_start = False hos_file.close() else: [ff, gg, fail] = [ vals['obj'][0][0], vals['con'][0], int(vals['fail'][0][0]) ] #end #end #end if self.pll: self.hot_start = Bcast(self.hot_start, root=0) #end if self.hot_start and self.pll: [ff, gg, fail] = Bcast([ff, gg, fail], root=0) elif not self.hot_start: [ff, gg, fail] = opt_problem.obj_fun(xn, *args, **kwargs) #end # Store History if (myrank == 0): if self.sto_hst: log_file.write(x, 'x') log_file.write(ff, 'obj') log_file.write(gg, 'con') log_file.write(fail, 'fail') #end #end # Objective Assigment if isinstance(ff, complex): f = ff.astype(float) else: f = ff #end # Constraints Assigment for i in range(len(opt_problem._constraints.keys())): if isinstance(gg[i], complex): g[i] = gg[i].astype(float) else: g[i] = gg[i] #end #end return f, g #====================================================================== # MMFD - Objective/Constraint Gradients Function #====================================================================== def mmfdgrd(nv, nc, x, f, g, df, dg): if self.hot_start: dff = [] dgg = [] if (myrank == 0): [vals, hist_end] = hos_file.read(ident=['grad_obj', 'grad_con']) if hist_end: self.hot_start = False hos_file.close() else: dff = vals['grad_obj'][0].reshape( (len(opt_problem._objectives.keys()), len(opt_problem._variables.keys()))) dgg = vals['grad_con'][0].reshape( (len(opt_problem._constraints.keys()), len(opt_problem._variables.keys()))) #end #end if self.pll: self.hot_start = Bcast(self.hot_start, root=0) #end if self.hot_start and self.pll: [dff, dgg] = Bcast([dff, dgg], root=0) #end #end if not self.hot_start: # dff, dgg = gradient.getGrad(x, group_ids, [f], g, *args, **kwargs) #end # Store History if self.sto_hst and (myrank == 0): log_file.write(dff, 'grad_obj') log_file.write(dgg, 'grad_con') #end # Gradient Assignment for i in range(len(opt_problem._variables.keys())): df[i] = dff[0, i] for j in range(len(opt_problem._constraints.keys())): dg[i, j] = dgg[j, i] #end #end return df, dg # Variables Handling nvar = len(opt_problem._variables.keys()) xl = [] xu = [] xx = [] for key in opt_problem._variables.keys(): if (opt_problem._variables[key].type == 'c'): xl.append(opt_problem._variables[key].lower) xu.append(opt_problem._variables[key].upper) xx.append(opt_problem._variables[key].value) elif (opt_problem._variables[key].type == 'i'): raise IOError('MMFD cannot handle integer design variables') elif (opt_problem._variables[key].type == 'd'): raise IOError('MMFD cannot handle discrete design variables') #end #end xl = numpy.array(xl) xu = numpy.array(xu) xx = numpy.array(xx) # Variables Groups Handling group_ids = {} if opt_problem.use_groups: k = 0 for key in opt_problem._vargroups.keys(): group_len = len(opt_problem._vargroups[key]['ids']) group_ids[opt_problem._vargroups[key]['name']] = [ k, k + group_len ] k += group_len #end #end # Constraints Handling ncon = len(opt_problem._constraints.keys()) neqc = 0 gg = [] idg = [] if ncon > 0: for key in opt_problem._constraints.keys(): if opt_problem._constraints[key].type == 'i': idg.append(1) elif opt_problem._constraints[key].type == 'e': idg.append(-1) #end gg.append(opt_problem._constraints[key].value) #end else: raise IOError( 'MMFD support for unconstrained problems not implemented yet') #end gg = numpy.array(gg) idg = numpy.array(idg, numpy.int) # Objective Handling objfunc = opt_problem.obj_fun nobj = len(opt_problem._objectives.keys()) ff = [] for key in opt_problem._objectives.keys(): ff.append(opt_problem._objectives[key].value) #end ff = numpy.array(ff) # Setup argument list values ndv = numpy.array([nvar], numpy.int) ncn = numpy.array([ncon], numpy.int) if (self.options['IOPT'][1] >= 0 and self.options['IOPT'][1] <= 1): iopt = numpy.array([self.options['IOPT'][1]], numpy.int) else: raise IOError('Incorrect Feasible Directions Approach') #end if (self.options['IONED'][1] >= 0 and self.options['IONED'][1] <= 3): ioned = numpy.array([self.options['IONED'][1]], numpy.int) else: raise IOError('Incorrect One-Dimensional Search Method') #end if (myrank == 0): if (self.options['IPRINT'][1] >= 0 and self.options['IPRINT'][1] <= 2): iprint = numpy.array([self.options['IPRINT'][1]], numpy.int) else: raise IOError('Incorrect Output Level Setting') #end else: iprint = numpy.array([0], numpy.int) #end #iout = numpy.array([self.options['IOUT'][1]], numpy.int) ifile = self.options['IFILE'][1] if (iprint > 0): if os.path.isfile(ifile): os.remove(ifile) #end #end ct = numpy.array([self.options['CT'][1]], numpy.float) ctmin = numpy.array([self.options['CTMIN'][1]], numpy.float) finit, ginit = mmfdfun([], [], xx, ff, gg) dabobj = numpy.array([self.options['DABOBJ'][1] * finit], numpy.float) delobj = numpy.array([self.options['DELOBJ'][1]], numpy.float) thetaz = numpy.array([self.options['THETAZ'][1]], numpy.float) pmlt = numpy.array([self.options['PMLT'][1]], numpy.float) itmax = numpy.array([self.options['ITMAX'][1]], numpy.int) itrmop = numpy.array([self.options['ITRMOP'][1]], numpy.int) nrwk0 = 500 nrwk1 = 10 * (2 * nvar + ncon) nrwk2 = (ncon + 2 * nvar + 3) nrwk3 = (ncon + 2 * nvar) * ((ncon + 2 * nvar) / 2 + 1) nrwkS = nrwk0 + nrwk1 + nrwk2 + nrwk3 nrwk = numpy.array([nrwkS], numpy.int) wk = numpy.zeros([nrwk], numpy.float) nriwk = numpy.array([nrwkS], numpy.int) iwk = numpy.zeros([nriwk], numpy.int) nfun = numpy.array([0], numpy.int) ngrd = numpy.array([0], numpy.int) # Run MMFD t0 = time.time() mmfd.mmfd(iopt, ioned, iprint, ndv, ncn, xx, xl, xu, ff, gg, idg, wk, nrwk, iwk, nriwk, ifile, ct, ctmin, dabobj, delobj, thetaz, pmlt, itmax, itrmop, nfun, ngrd, mmfdfun, mmfdgrd) sol_time = time.time() - t0 if (myrank == 0): if self.sto_hst: log_file.close() if tmp_file: hos_file.close() name = hos_file.filename os.remove(name + '.cue') os.remove(name + '.bin') os.rename(name + '_tmp.cue', name + '.cue') os.rename(name + '_tmp.bin', name + '.bin') #end #end #end if (iprint > 0): # mmfd.closeunit(self.options['IOUT'][1]) mmfd.closeunit(6) #end # Store Results sol_inform = {} sol_inform['value'] = [] sol_inform['text'] = {} if store_sol: sol_name = 'MMFD Solution to ' + opt_problem.name sol_options = copy.copy(self.options) if 'defaults' in sol_options: del sol_options['defaults'] #end sol_evals = nfun[0] + ngrd[0] * nvar sol_vars = copy.deepcopy(opt_problem._variables) i = 0 for key in sol_vars.keys(): sol_vars[key].value = xx[i] i += 1 #end sol_objs = copy.deepcopy(opt_problem._objectives) i = 0 for key in sol_objs.keys(): sol_objs[key].value = ff[i] i += 1 #end if ncon > 0: sol_cons = copy.deepcopy(opt_problem._constraints) i = 0 for key in sol_cons.keys(): sol_cons[key].value = gg[i] i += 1 #end else: sol_cons = {} #end sol_lambda = {} opt_problem.addSol(self.__class__.__name__, sol_name, objfunc, sol_time, sol_evals, sol_inform, sol_vars, sol_objs, sol_cons, sol_options, display_opts=disp_opts, Lambda=sol_lambda, Sensitivities=sens_type, myrank=myrank, arguments=args, **kwargs) #end return ff, xx, sol_inform