def solve (p): global P P = p t0 = time.time() # Create the problem for Ipopt to solve nlp = pyipopt.create(P.nvar, P.x_L, P.x_U, P.ncon, P.g_L, P.g_U, P.nnjz, P.nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g) # Set Ipopt solve options nlp.int_option("print_level",5) nlp.num_option("acceptable_tol",1000.0) nlp.num_option("tol",1000.0) nlp.num_option("dual_inf_tol",10000.0) nlp.num_option("compl_inf_tol",10000.0) nlp.int_option("max_iter", 1000) #nlp.str_option("derivative_test","first-order") stitching_constraint(0.0, 0) print "Calling solve" x, zl, zu, constrain_mu, obj, status = nlp.solve(P.x) # Solve the NLP problem with Ipopt nlp.close() if status == 0: solve_time = time.time() - t0 print "Solution found in: ",solve_time," (sec)" P.x = x P.solved = True else: print "Failed to find solution!" P.x = x P.solved = False
def solve_init(self, eval_J, eval_dJ): nvar = int(2*self.num_cables) ncon = int(self.num_cables + self.num_cables*(self.num_cables-1)/2) low_var = -numpy.inf*numpy.ones(nvar,dtype=float) up_var = numpy.inf*numpy.ones(nvar, dtype=float) up_var[0], low_var[0] = 0, 0 inf_con = numpy.inf*numpy.ones(ncon, dtype=float) zero_con = numpy.zeros(ncon, dtype=float) self.nlp = pyipopt.create(nvar, # Number of controls low_var, # Lower bounds for Control up_var, # Upper bounds for Control ncon, # Number of constraints -inf_con, # Lower bounds for contraints zero_con, # Upper bounds for contraints nvar*ncon, # Number of nonzeros in cons. Jac 0, # Number of nonzeros in cons. Hes lambda pos: eval_J(pos), # Objective eval lambda pos: eval_dJ(pos), # Obj. grad eval self.eval_g, # Constraint evaluation self.eval_jac_g # Constraint Jacobian evaluation ) # So it does not violate the boundary constraint self.nlp.num_option('bound_relax_factor', 0) self.nlp.int_option('max_iter', 16) self.nlp.int_option("print_level",6)
def run(x0, eval_jac_g, eval_h): if x0.shape != (N*D,): raise "x is wrong dims!" x_L, x_U = set_x_bounds(lowbnd, upbnd) start = time.time() print eval_h.nnz nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, eval_jac_g.nnz, eval_h.nnz, eval_f_adolc, eval_grad_f, eval_g_adolc, eval_jac_g, eval_h) #nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, eval_jac_g.nnz, 365, eval_f_adolc, eval_grad_f, eval_g_adolc, eval_jac_g) nlp.int_option('max_iter', maxits) nlp.num_option('constr_viol_tol', epsg) nlp.num_option('tol', epsf) nlp.num_option('acceptable_tol', 1e-3) nlp.str_option('linear_solver', linear_solver) nlp.str_option('mu_strategy', 'adaptive') nlp.num_option('bound_relax_factor', 0) nlp.str_option('adaptive_mu_globalization','never-monotone-mode') results = nlp.solve(x0) print "optimized: ", time.time()-start, "s" print "Exit flag = ", results[5] print "Action = ", results[4] return results[4], results[0]
def runOptimization(self): pyipopt.set_loglevel(0) self.nlp = pyipopt.create( self.optDict['nPrimal'], self.constraintDict['lowerBound'], self.constraintDict['upperBound'], self.optDict['nConstraint'], self.constraintDict['lowerConstraint'], self.constraintDict['upperConstraint'], self.optDict['nJacobianNonZero'], self.optDict['nHessianNonZero'], self.evalObjectiveFunction, self.evalObjectiveFunctionGradient, self.evalConstraints, self.evalConstraintsJacbobian) self.nlp.int_option("max_iter", 150) # self.nlp.str_option('derivative_test', 'first-order') # self.nlp.num_option('derivative_test_tol', 1e-2) # self.nlp.num_option('derivative_test_perturbation', 1e-3) self.nlp.num_option('point_perturbation_radius', 1e-3) # self.nlp.int_option('max_iter', 100) # self.nlp.str_option('derivative_test_print_all', 'yes') # self.nlp.int_option('derivative_test_first_index', 330) # self.nlp.num_option('acceptable_constr_viol_tol', 1) x, zl, zu, constraint_multipliers, obj, status = self.nlp.solve(self.initialGuess) return x[self.sliceDict['varMu']], x[self.sliceDict['varTheta']], self.optX, self.optY
def optimizePC(channel, noiseIfPower, rate, linkBandwidth, pMax, p0, m, verbosity=0): ''' Uses channel values, PHY parameters and power consumption characteristics to find minimal resource allocation. Returns resource allocation, objective value and IPOPT status. Input: channel - 3d array. 0d users, 1d n_tx, 2d n_rx noiseIfPower - total noise power over the linkbandwidth rate - target rate in bps pMax - maximum allowed transmission power p0 - power consumption at zero transmission (not sleep) m - power consumption load factor verbosity - IPOPT verbosity level Output: obj - solution objective value solution - resource share per user status - IPOPT status ''' # the channel dimensions tell some more parameters users = channel.shape[0] n_tx = channel.shape[1] n_rx = channel.shape[2] # preparing IPOPT parameters nvar = users # for readability x_L = zeros((nvar), dtype=float_) * 0.0 x_U = ones((nvar), dtype=float_) * 1.0 ncon = nvar + 1 # transmit power constraints and the unit sum g_L = zeros(1+nvar) # unit sum and all power constraints g_L[0] = 1. g_U = pMax * ones(1+nvar) # unit sum and all power constraints g_U[0] = 1. nnzj = nvar * (1+nvar) nnzh = 0 #used? x0 = repeat([1./(nvar+1)],nvar) # Starting point # IPOPT requires single parameter functions if n_tx is 2 and n_rx is 2: eval_f = lambda mus: optimMinPow2x2.eval_f(mus, noiseIfPower, channel, rate, linkBandwidth, p0, m) eval_grad_f = lambda mus: optimMinPow2x2.eval_grad_f(mus, noiseIfPower, channel, rate, linkBandwidth, p0, m) eval_g = lambda mus: optimMinPow2x2.eval_g(mus, noiseIfPower, channel, rate, linkBandwidth) eval_jac_g = lambda mus, flag: optimMinPow2x2.eval_jac_g(mus, noiseIfPower, channel, rate, linkBandwidth, flag) else: raise NotImplementedError # other combinations may be needed later # Call solve() pyipopt.set_loglevel(min([2,verbosity])) # verbose nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g) #nlp.int_option("max_iter", 3000) #nlp.num_option("tol", 1e-8) #nlp.num_option("acceptable_tol", 1e-2) #nlp.int_option("acceptable_iter", 0) nlp.str_option("derivative_test", "first-order") nlp.str_option("derivative_test_print_all", "no") #nlp.str_option("print_options_documentation", "yes") nlp.int_option("print_level", min([verbosity,12])) # maximum is 12 nlp.str_option("print_user_options", "yes") solution, zl, zu, obj, status = nlp.solve(x0) nlp.close() return obj, solution, status
def ipopt_naive(self, start=None, iters=3000, acc=1E-5, callback=True, verbose=False): """ x - # of variables xl - lower bounds of variables xu - upper bounds of variables m - # of constraints gl - lower bounds of constraints gu - upper bounds of constraints nnzj - number of nonzero values in jacobian nnzh - number of nonzero values in hessian (set to 0 if eval_h is not used) eval_f - objective function eval_grad_f - calculates gradient of objective function eval_g - calculates constraint values eval_jac_g - calculates jacobian eval_h - calculates hessian (optional, if not used set nnzh to 0) """ try: if not (hasattr(IPOPT, "create")): print "WARNING: IPOPT not correctly installed (not start)" return start except NameError: print "WARNING: IPOPT is not installed!" return start if start is None: start = self.defaultState.extract(excludeKeys=self.excludeKeys) if callback == True: callback = self.robot.cleanupCallback #start = N.array(start, subok=True) numConst, lCBounds, uCBounds = self.getConstData() numVar = start.size lVBounds = [] uVBounds = [] for i in range(start.size / self.robot.nvars): lVBounds += self.robot.xLBounds uVBounds += self.robot.xUBounds lVBounds = N.array(lVBounds, dtype=float) uVBounds = N.array(uVBounds, dtype=float) struct = self.eval_jac_g(start, False) numNonZero = struct.size ipprob = IPOPT.create(numVar, lVBounds, uVBounds, numConst, lCBounds, uCBounds, numNonZero, 0, self.eval_f, self.eval_grad_f, self.eval_g, self.eval_jac_g) ipprob.num_option('tol', acc) ipprob.int_option('max_iter', iters) # call solve with initial state (start) x, zl, zu, constraint_multipliers, obj, status = ipprob.solve(start) ipprob.close() return x
def solve(self): x0 = self._robot.configuration() nbVar = len(x0) xL = [-math.pi] * nbVar xU = [math.pi] * nbVar cL = [] cU = [] nCon = 0 nnzH = 0 ssR = [] ssC = [] for c in self._constraint: cL.append(c.lBounds()) cU.append(c.uBounds()) ss = c.sparseStruct() ssR += (np.array(ss[0]) + nCon).tolist() ssC += ss[1] nCon += c.constraintCount() ss = (np.array(ssR), np.array(ssC)) nnzJ = len(ssC) def evalF(x, user=None): self._robot.configure(x) return 0.0 def evalFJ(x, user=None): self._robot.configure(x) return np.zeros(nbVar) def evalC(x, user=None): self._robot.configure(x) l = [] for c in self._constraint: l += c.eval(x) return np.array(l) def evalCJ(x, flag, user=None): if flag: return ss else: l = [] for c in self._constraint: l += c.evalJ(x) return np.array(l) opt = pyipopt.create(nbVar, np.array(xL), np.array(xU), nCon, np.array(cL), np.array(cU), nnzJ, nnzH, evalF, evalFJ, evalC, evalCJ) x, zl, zu, obj, status = opt.solve(np.array(x0)) opt.close()
def start_iteration(self): """Perform initial setup before iteration loop begins.""" self._config_ipopt() # get the initial values of the parameters for i, val in enumerate(self.get_parameters().values()): self.design_vals[i] = val.evaluate(self.parent) self.update_constraints() x_L = array( [ x.low for x in self.get_parameters().values() ] ) x_U = array( [ x.high for x in self.get_parameters().values() ] ) # Ipopt treats equality and inequality constraints together. # For equality constraints, just set the g_l and g_u to be # equal. For this driver, the inequality constraints come # first. g_l is set to 0.0 and g_l is set to the largest float. # For the equality constraints, both g_l and g_u are set to zero. g_L = zeros( self.num_constraints, 'd') g_U = zeros( self.num_constraints, 'd') for i in range( self.num_ineq_constraints ): g_U[i] = sys.float_info.max # number of non zeros in Jacobian nnzj = self.num_params * self.num_constraints # of constraints. Assumed to be dense # number of non zeros in hessian nnzh = self.num_params * ( self.num_params + 1 ) / 2 try: self.nlp = pyipopt.create( self.num_params, x_L, x_U, self.num_constraints, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, intermediate_callback # f2py lets you pass extra args to # callback functions # http://cens.ioc.ee/projects/f2py2e/usersguide/ # index.html#call-back-arguments # We pass the driver itself to the callbacks ### not using them for now # eval_f_extra_args = (self,), # eval_grad_f_extra_args = (self,), # eval_g_extra_args = (self,), # eval_jac_g_extra_args = (self,), # intermediate_cb_extra_args = (self,), ) self.nlp.set_intermediate_callback( intermediate_callback ) except Exception, err: self._logger.error(str(err)) raise
def solve_constr(theta0, use_hess = False): pyipopt.set_loglevel(1) n = theta0.size x_L = np.array([pyipopt.NLP_LOWER_BOUND_INF]*n, dtype=float) x_U = np.array([pyipopt.NLP_UPPER_BOUND_INF]*n, dtype=float) ncon = pstationtrue.size g_L = g_U = pstationtrue nnzj = maskj.sum() nnzh = maskh.sum() idxrj, idxcj = np.mgrid[:ncon, :n] idxrh, idxch = np.mgrid[:n, :n] eval_c = lambda t: constr(t) eval_j = lambda t, f: (idxrj[maskj], idxcj[maskj]) if f else np.squeeze(jab(t))[maskj] if use_hess: eval_h = lambda t, l, o, f: (idxrh[maskh], idxch[maskh]) if f else np.squeeze(hess_constr(t,l,o))[maskh] nlp = pyipopt.create(theta0.size, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad, eval_c, eval_j, eval_h) else: nlp = pyipopt.create(theta0.size, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad, eval_c, eval_j) results = nlp.solve(theta0) nlp.close() return results
def main(): # verbose pyipopt.set_loglevel(2) # define the parameters and their box constraints nvar = 2 x_L = numpy.array([-3, -3], dtype=float) x_U = numpy.array([3, 3], dtype=float) # define the inequality constraints ncon = 0 g_L = numpy.array([], dtype=float) g_U = numpy.array([], dtype=float) # define the number of nonzeros in the jacobian and in the hessian # there are no nonzeros in the constraint jacobian nnzj = 0 # there are maximum nonzeros (nvar*(nvar+1))/2 in the lagrangian hessian nnzh = 3 # create the nonlinear programming model nlp = pyipopt.create( nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, eval_h, apply_new, ) # define the initial guess x0 = numpy.array([-1.2, 1], dtype=float) # compute the results using ipopt results = nlp.solve(x0) # free the model nlp.close() # report the results print results
def main(): # verbose pyipopt.set_loglevel(2) # define the parameters and their box constraints nvar = 2 x_L = numpy.array([-3, -3], dtype=float) x_U = numpy.array([3, 3], dtype=float) # define the inequality constraints ncon = 0 g_L = numpy.array([], dtype=float) g_U = numpy.array([], dtype=float) # define the number of nonzeros in the jacobian and in the hessian # there are no nonzeros in the constraint jacobian nnzj = 0 # there are maximum nonzeros (nvar*(nvar+1))/2 in the lagrangian hessian nnzh = 3 # create the nonlinear programming model nlp = pyipopt.create( nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, eval_h, apply_new, ) # define the initial guess x0 = numpy.array([-1.2, 1], dtype=float) # compute the results using ipopt results = nlp.solve(x0) # free the model nlp.close() # report the results print(results)
def __init__(self,ListStreams,ListUnits,CFlag=5,PrintOpt=0,Xtol=1e-6,iter=100): self.XFlag=[] self.X=[] self.Sigma=[] self.CFlag=CFlag self.ListStreams=ListStreams self.ListUints=ListUnits self.ConstructXFlag() #self.ConstructX() self.Xmeas=self.X self.JacobianSize() if (self.CFlag==5 or self.CFlag==6 or self.CFlag==7): self.JacoNorm() self.NonZeroJacoRowCol() self.NonZeroHessRowCol() self.nnzh=len(self.NonZeroHessRow) self.nnzj=len(self.NonZeroJacoRow) self.ConstraintBounds() self.nlp = pyipopt.create(self.Xlen, self.XLB, self.XUB, self.Glen, self.GLB, self.GUB, self.nnzj, self.nnzh, self.Objective, self.obj_grad, self.Constraints, self.ConstructJaco, self.Hessian) self.nlp.int_option('print_level',PrintOpt) self.nlp.int_option('max_iter',iter) self.nlp.num_option('tol',Xtol) # self.nlp.num_option('dual_inf_tol',500000) # self.nlp.str_option('accept_every_trial_step','yes') # '''==============Derivative Check============================''' # self.nlp.str_option('derivative_test','only-second-order') # self.nlp.num_option('derivative_test_perturbation',1e-6) # self.nlp.num_option('derivative_test_tol',1e-5) # '''=================================================================''' #self.nlp.str_option('hessian_approximation','limited-memory') #self.nlp.str_option('nlp_scaling_method','none') #self.nlp.num_option('nlp_scaling_min_value',0.01) #self.nlp.str_option('alpha_for_y','full') #self.nlp.num_option('constr_viol_tol',1e-4) #nlp.str_option('expect_infeasible_problem','yes') #nlp.str_option('start_with_resto','yes') self.X0 = asarray(self.Xmeas,dtype=float_) self.Validation() self.ExitFlag={} self.Xopt, self.zl, self.zu, self.constraint_multipliers, self.obj, self.status = self.nlp.solve(self.X0) self.ExitFlag[-1]=self.status for i in range(0): if (self.status !=0): self.Xopt, self.zl, self.zu, self.constraint_multipliers, self.obj, self.status = self.nlp.solve(self.Xopt) self.ExitFlag[i]=self.status if (self.status==0): self.OptimIndex=i print 'sucess ',i break self.nlp.close()
def solve (p, warm_start): global P P = p t0 = time.time() # Create the problem for Ipopt to solve P.nlp = pyipopt.create(P.nvar, P.x_L, P.x_U, P.ncon, P.g_L, P.g_U, P.nnjz, P.nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g) # Set Ipopt solve options """ P.nlp.int_option("print_level",1) P.nlp.num_option("acceptable_tol",10.0) P.nlp.num_option("tol",10.0) P.nlp.num_option("dual_inf_tol",1000.0) P.nlp.num_option("compl_inf_tol",1000.0) P.nlp.int_option("max_iter", 10000) P.nlp.str_option("linear_solver", "mumps") """ P.nlp.str_option("linear_solver", "mumps") P.nlp.str_option("jacobian_approximation", "exact") P.nlp.str_option("hessian_approximation", "limited-memory") P.nlp.num_option("max_cpu_time", 40.0) P.nlp.num_option("tol", 10.0) P.nlp.str_option("print_timing_statistics", "no") P.nlp.str_option("print_user_options", "no") P.nlp.int_option("print_level",4) if warm_start: P.nlp.str_option('mu_strategy', 'adaptive') P.nlp.str_option("warm_start_init_point", "yes") #P.nlp.str_option("derivative_test","first-order") print "Calling solve" x, zl, zu, constrain_mu, obj, status = P.nlp.solve(P.x) # Solve the NLP problem with Ipopt #nlp.close() if status == 0: solve_time = time.time() - t0 print "Solution found in: ",solve_time," (sec)" P.x = x P.solved = True else: print "Failed to find solution!" P.x = x P.solved = False
def __build_pyipopt_problem(self): """Build the pyipopt problem from the OptimizationProblem instance.""" import pyipopt from functools import partial self.rfn = ReducedFunctionalNumPy(self.problem.reduced_functional) ncontrols = len(self.rfn.get_controls()) (lb, ub) = self.__get_bounds() (nconstraints, fun_g, jac_g, clb, cub) = self.__get_constraints() constraints_nnz = nconstraints * ncontrols # A callback that evaluates the functional and derivative. J = self.rfn.__call__ dJ = partial(self.rfn.derivative, forget=False) nlp = pyipopt.create( len(ub), # length of control vector lb, # lower bounds on control vector ub, # upper bounds on control vector nconstraints, # number of constraints clb, # lower bounds on constraints, cub, # upper bounds on constraints, constraints_nnz, # number of nonzeros in the constraint Jacobian 0, # number of nonzeros in the Hessian J, # to evaluate the functional dJ, # to evaluate the gradient fun_g, # to evaluate the constraints jac_g) # to evaluate the constraint Jacobian pyipopt.set_loglevel(1) # turn off annoying pyipopt logging if rank(self.problem.reduced_functional.mpi_comm()) > 0: nlp.int_option('print_level', 0) # disable redundant IPOPT output in parallel else: nlp.int_option('print_level', 6) # very useful IPOPT output if isinstance(self.problem, MaximizationProblem): # multiply objective function by -1 internally in # ipopt to maximise instead of minimise nlp.num_option('obj_scaling_factor', -1.0) self.pyipopt_problem = nlp
def __build_pyipopt_problem(self): """Build the pyipopt problem from the OptimizationProblem instance.""" import pyipopt from functools import partial self.rfn = ReducedFunctionalNumPy(self.problem.reduced_functional) ncontrols = len(self.rfn.get_controls()) (lb, ub) = self.__get_bounds() (nconstraints, fun_g, jac_g, clb, cub) = self.__get_constraints() constraints_nnz = nconstraints * ncontrols # A callback that evaluates the functional and derivative. J = self.rfn.__call__ dJ = partial(self.rfn.derivative, forget=False) nlp = pyipopt.create( len(ub), # length of control vector lb, # lower bounds on control vector ub, # upper bounds on control vector nconstraints, # number of constraints clb, # lower bounds on constraints, cub, # upper bounds on constraints, constraints_nnz, # number of nonzeros in the constraint Jacobian 0, # number of nonzeros in the Hessian J, # to evaluate the functional dJ, # to evaluate the gradient fun_g, # to evaluate the constraints jac_g, ) # to evaluate the constraint Jacobian pyipopt.set_loglevel(1) # turn off annoying pyipopt logging if rank(self.problem.reduced_functional.mpi_comm()) > 0: nlp.int_option("print_level", 0) # disable redundant IPOPT output in parallel else: nlp.int_option("print_level", 6) # very useful IPOPT output if isinstance(self.problem, MaximizationProblem): # multiply objective function by -1 internally in # ipopt to maximise instead of minimise nlp.num_option("obj_scaling_factor", -1.0) self.pyipopt_problem = nlp
def solve_init(self, eval_J, eval_dJ): nvar = self.num_angles low_var = -numpy.infty * numpy.ones(nvar, dtype=float) up_var = numpy.infty * numpy.ones(nvar, dtype=float) self.nlp = pyipopt.create( nvar, # Number of controls low_var, # Lower bounds for Control up_var, # Upper bounds for Control 0, # Number of constraints numpy.array([], dtype=float), numpy.array([], dtype=float), 0, # Number of nonzeros in cons. Jac 0, # Number of nonzeros in cons. Hes lambda angle: eval_J(angle), # Objective eval lambda angle: eval_dJ(angle), # Obj. grad eval self.func_g, self.jac_g)
def estimate_alpha_beta(counts, X, ini=None, verbose=0, use_empty_entries=True): """ Estimate the parameters of g Parameters ---------- counts: ndarray use_empty_entries: boolean, optional, default: True whether to use zeroes entries as information or not """ m, n = X.shape nvar = 1 ncon = 0 nnzj = 0 nnzh = 0 x_L = np.array([- 10000.]) x_U = np.array([10000000.]) nlp = pyipopt.create(nvar, x_L, x_U, ncon, x_L, x_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g) nlp.int_option('max_iter', 100) if ini is None: if verbose: print "Initial values not provided" ini = np.random.randint(1, 100, size=(1, )) + \ np.random.random(size=(1, )) results = nlp.solve(ini, (m, n, counts, X, use_empty_entries)) try: x, _, _, _, _ = results except ValueError: x, _, _, _, _, _ = results # Evaluate counts with new estimated model. d = euclidean_distances(X) mask = (np.tri(m, dtype=np.bool) == False) & (counts != 0) & (d != 0) beta = counts[mask].sum() / (d[mask] ** x[0]).sum() return x[0], beta
def optimizegraph(opt, max_iter=300, max_cpu_time=100): x_L, x_U = opt.bound_variables() g_L, g_U = opt.bound_constraints() nlp = pyipopt.create(opt.n_var, x_L, x_U, opt.n_cons, g_L, g_U, opt.nnzj, opt.nnzh, \ opt.eval_objective, opt.eval_grad_objective, opt.eval_constraints, opt.eval_jac_constraint) nlp.num_option('max_cpu_time', max_cpu_time) nlp.int_option('print_level', 0) nlp.num_option('tol', 1e-12) nlp.num_option('acceptable_tol', 1e-12) x, zl, zu, constraint_multipliers, obj, status = nlp.solve( initialize_flow(opt)) nlp.close() # reinforce flow balance x = reinforce_flowbalance(opt, x) # scale x x = np.maximum(x, 0) s = np.sum(opt.weights) / np.dot(opt.efflen, x) opt.results = x * s return opt, status
def _solve(self, x0, A, l, u, xmin, xmax): """ Solves using the Interior Point OPTimizer. """ # Indexes of constrained lines. il = [i for i,ln in enumerate(self._ln) if 0.0 < ln.rate_a < 1e10] nl2 = len(il) neqnln = 2 * self._nb # no. of non-linear equality constraints niqnln = 2 * len(il) # no. of lines with constraints user_data = {"A": A, "neqnln": neqnln, "niqnln": niqnln} self._f(x0) Jdata = self._dg(x0, False, user_data) # Hdata = self._h(x0, ones(neqnln + niqnln), None, False, user_data) lmbda = {"eqnonlin": ones(neqnln), "ineqnonlin": ones(niqnln)} H = tril(self._hessfcn(x0, lmbda), format="coo") self._Hrow, self._Hcol = H.row, H.col n = len(x0) # the number of variables xl = xmin xu = xmax gl = r_[zeros(2 * self._nb), -Inf * ones(2 * nl2), l] gu = r_[zeros(2 * self._nb), zeros(2 * nl2), u] m = len(gl) # the number of constraints nnzj = len(Jdata) # the number of nonzeros in Jacobian matrix nnzh = 0#len(H.data) # the number of non-zeros in Hessian matrix f_fcn, df_fcn, g_fcn, dg_fcn, h_fcn = \ self._f, self._df, self._g, self._dg, self._h nlp = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, nnzh, f_fcn, df_fcn, g_fcn, dg_fcn)#, h_fcn) # print dir(nlp) # nlp.str_option("print_options_documentation", "yes") # nlp.int_option("max_iter", 10) # x, zl, zu, obj = nlp.solve(x0) success = nlp.solve(x0, user_data) nlp.close()
def _solve(self, x0, A, l, u, xmin, xmax): """ Solves using the Interior Point OPTimizer. """ # Indexes of constrained lines. il = [i for i, ln in enumerate(self._ln) if 0.0 < ln.rate_a < 1e10] nl2 = len(il) neqnln = 2 * self._nb # no. of non-linear equality constraints niqnln = 2 * len(il) # no. of lines with constraints user_data = {"A": A, "neqnln": neqnln, "niqnln": niqnln} self._f(x0) Jdata = self._dg(x0, False, user_data) # Hdata = self._h(x0, ones(neqnln + niqnln), None, False, user_data) lmbda = {"eqnonlin": ones(neqnln), "ineqnonlin": ones(niqnln)} H = tril(self._hessfcn(x0, lmbda), format="coo") self._Hrow, self._Hcol = H.row, H.col n = len(x0) # the number of variables xl = xmin xu = xmax gl = r_[zeros(2 * self._nb), -Inf * ones(2 * nl2), l] gu = r_[zeros(2 * self._nb), zeros(2 * nl2), u] m = len(gl) # the number of constraints nnzj = len(Jdata) # the number of nonzeros in Jacobian matrix nnzh = 0 #len(H.data) # the number of non-zeros in Hessian matrix f_fcn, df_fcn, g_fcn, dg_fcn, h_fcn = \ self._f, self._df, self._g, self._dg, self._h nlp = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, nnzh, f_fcn, df_fcn, g_fcn, dg_fcn) #, h_fcn) # print dir(nlp) # nlp.str_option("print_options_documentation", "yes") # nlp.int_option("max_iter", 10) # x, zl, zu, obj = nlp.solve(x0) success = nlp.solve(x0, user_data) nlp.close()
def improve_ipopt(x0, prob, *args, **kwargs): try: import pyipopt except ImportError: raise Exception("PyIpopt package is not installed.") lb = pyipopt.NLP_LOWER_BOUND_INF ub = pyipopt.NLP_UPPER_BOUND_INF g_L = np.zeros(prob.m) for i in range(prob.m): if prob.fs[i].relop == '<=': g_L[i] = lb g_U = np.zeros(prob.m) def eval_grad_f(x, user_data = None): return 2*prob.f0.P.dot(x) + prob.f0.qarray def eval_g(x, user_data = None): return np.array([f.eval(x) for f in prob.fs]) jac_grid = np.indices((prob.m, prob.n)) jac_r = jac_grid[0].ravel() jac_c = jac_grid[1].ravel() def eval_jac_g(x, flag, user_data = None): if flag: return (jac_r, jac_c) else: return np.vstack([2*f.P.dot(x)+f.qarray for f in prob.fs]) nlp = pyipopt.create( prob.n, lb*np.ones(prob.n), ub*np.ones(prob.n), prob.m, g_L, g_U, prob.m*prob.n, 0, prob.f0.eval, eval_grad_f, eval_g, eval_jac_g ) try: x, zl, zu, constraint_multipliers, obj, status = nlp.solve(x0) except: pass return x
def OptSolver(bounds, OptObj, max_iter=10): """ Function that returns a pyipopt object with OptObj atributes """ # Number of Design Variables nvar = OptObj.nvars # Upper and lower bounds x_L = numpy.ones(nvar) * bounds[0] x_U = numpy.ones(nvar) * bounds[1] # Number of non-zeros gradients constraints_nnz = nvar*OptObj.cst_num acst_L = numpy.array(OptObj.cst_L) acst_U = numpy.array(OptObj.cst_U) PyIpOptObj = pyipopt.create(nvar, # number of the design variables x_L, # lower bounds of the design variables x_U, # upper bounds of the design variables OptObj.cst_num, # number of constraints acst_L, # lower bounds on constraints, acst_U, # upper bounds on constraints, constraints_nnz, # number of nonzeros in the constraint Jacobian 0, # number of nonzeros in the Hessian OptObj.obj_fun, # objective function OptObj.obj_dfun, # gradient of the objective function OptObj.cst_fval, # constraint function OptObj.jacobian ) # gradient of the constraint function #Parameters PyIpOptObj.num_option('acceptable_tol', 1.0e-10) PyIpOptObj.num_option('eta_phi', 1e-12) # eta_phi: Relaxation factor in the Armijo condition. PyIpOptObj.num_option('theta_max_fact', 30000) # Determines upper bound for constraint violation in the filter. PyIpOptObj.int_option('max_soc', 20) PyIpOptObj.int_option('max_iter', max_iter) PyIpOptObj.int_option('watchdog_shortened_iter_trigger', 20) PyIpOptObj.int_option('accept_after_max_steps', 5) pyipopt.set_loglevel(1) # turn off annoying pyipopt logging PyIpOptObj.int_option('print_level', 6) # very useful IPOPT output return PyIpOptObj
def main(): cable_positions_numpy = numpy.array(cable_positions) print(cable_positions) def eval_robust_J(cable_positions): if max(eval_g(cable_positions)) > 0: print("Warning: Inequality constraint is not satisfied") return numpy.inf # print eval_g(cable_positions).T try: j = eval_J(cable_positions) # c1 = numpy.array([cable_positions[0],cable_positions[1]]) # c2 = numpy.array([cable_positions[2],cable_positions[3]]) # c3 = numpy.array([cable_positions[4],cable_positions[5]]) # print("Angles between the three cables: %.2f, %.2f, %.2f" # % (numpy.arccos(numpy.dot(c1-c2,c1-c3)/ # (numpy.sqrt(numpy.dot(c1-c2,c1-c2) # *numpy.dot(c1-c3,c1-c3))))/(2*numpy.pi)*360, # numpy.arccos(numpy.dot(c1-c2,c3-c2)/ # (numpy.sqrt(numpy.dot(c1-c2,c1-c2) # *numpy.dot(c3-c2,c3-c2))))/(2*numpy.pi)*360, # numpy.arccos(numpy.dot(c3-c1,c3-c2)/ # (numpy.sqrt(numpy.dot(c3-c1,c3-c1) # *numpy.dot(c3-c2,c3-c2))))/(2*numpy.pi)*360)) except: print("ERROR: Forward model failed, returning infinity") j = numpy.inf exit(1) #print( "J = ", j) return j def eval_robust_dJ(cable_positions): if max(eval_g(cable_positions)) > 0: print("Warning: Inequality constraint is not satisfied") return numpy.inf dj = eval_dJ(cable_positions) print("|dj| = ", numpy.dot(dj, dj)**0.5) return dj def test_J(cable_positions): """ Test of optimization without state eq""" j = 0.5 * numpy.dot(cable_positions, cable_positions) if max(eval_g(cable_positions)) > 0: print("Warning: Inequality constraint is not satisfied: ") print(eval_g(cable_positions)) print(cable_positions) print("*" * 25) print("J = ", j) return j def test_dJ(cable_positions): """ Test of optimization without state eq""" dj = numpy.array(cable_positions) print("|dj| = ", numpy.dot(dj, dj)**0.5) return dj # Check that input data match input variables nvar = int(2 * num_cables) # Number of controls ncon = int(num_cables + num_cables * (num_cables - 1) / 2) # Number of inequality constraints # Create the NLP model #pyipopt.set_loglevel(2) # Set verbosity nlp = pyipopt.create( nvar, # Number of controls -numpy.inf * numpy.ones(nvar, dtype=float), # Lower bounds of controls numpy.inf * numpy.ones(nvar, dtype=float), # Upper bounds of controls ncon, # Number of inequality constraints -numpy.inf * numpy.ones( ncon, dtype=float), # Lower bounds of inequality constraints numpy.zeros(ncon, dtype=float), # Upper bounds of inequality constraints nvar * ncon, # Number of nonzeros in the constraint Jacobian 0, # Number of nonzeros in the Hessian lambda pos: eval_robust_J(pos), # Objective evaluation lambda pos: eval_robust_dJ(pos), # Objective gradient evaluation # lambda pos: test_J(pos), # Objective evaluation # lambda pos: test_dJ(pos), # Objective gradient evaluation eval_g, # Constraint evaluation eval_jac_g, # Constraint Jacobian evaluation ) nlp.num_option('obj_scaling_factor', 1e-1) # 1e-2 for isoceles example as gradient is bigger # 1e-1 for 3 cables as gradient is smaller nlp.int_option('max_iter', 100) nlp.num_option('acceptable_tol', 1e-2) nlp.num_option('tol', 1e-2) nlp.num_option('bound_relax_factor', 0) # So it does not violate the boundary constraint # nlp.str_option('mu_strategy',"adaptive") #nlp.str_option('nlp_scaling_method',"gradient-based") # nlp.num_option("mu_max", 0.1) # nlp.num_option('mu_init', 0.1)#1e25) #nlp.num_option('bound_relax_factor', 0) # So it does not violate the boundary constraint # nlp.num_option('acceptable_tol', 1e-5) # Solve the optimisation problem opt_cable_pos = nlp.solve(cable_positions_numpy)[0] nlp.close() # Report the results d = opt_cable_pos.reshape(-1, 2) for i in range(num_cables): max_radius = outer_cable_mesh_radius - inner_cable_mesh_radius - distance_from_outer_cable_mesh print("Cable %d distance from center: %.3e" % (i, numpy.sqrt(d[i, 0]**2 + d[i, 1]**2))) for j in range(i + 1, num_cables): print("Distance between Cable %d and %d: %.3e" % (i, j, numpy.sqrt( (d[i, 0] - d[j, 0])**2) + (d[i, 1] - d[j, 1])**2)) print("Cable_positions:") for i in range(num_cables): print("%10.3e, %10.3e" % (d[i, 0], d[i, 1])) update_mesh(opt_cable_pos) # dolfin.plot(update_mesh(opt_cable_pos)) TempFiles = [ dolfin.File("output/T_ipopt_part%d.pvd" % i) for i in range(num_cables + 1) ] eval_J(cable_positions) for i in range(num_cables + 1): TempFiles[i] << T.part(i) eval_J(opt_cable_pos) for i in range(num_cables + 1): TempFiles[i] << T.part(i) c1 = d[0, :] c2 = d[1, :] c3 = d[2, :] print( numpy.arccos( numpy.dot(c1 - c2, c1 - c3) / (numpy.sqrt( numpy.dot(c1 - c2, c1 - c2) * numpy.dot(c1 - c3, c1 - c3)))) / (2 * numpy.pi) * 360) print( numpy.arccos( numpy.dot(c1 - c2, c3 - c2) / (numpy.sqrt( numpy.dot(c1 - c2, c1 - c2) * numpy.dot(c3 - c2, c3 - c2)))) / (2 * numpy.pi) * 360) print( numpy.arccos( numpy.dot(c3 - c1, c3 - c2) / (numpy.sqrt( numpy.dot(c3 - c1, c3 - c1) * numpy.dot(c3 - c2, c3 - c2)))) / (2 * numpy.pi) * 360)
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) # end # end self.sto_hst = True self.h_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 # end self.sto_hst = True self.h_start = True else: if myrank == 0: log_file = History(store_hst, "w", self, opt_problem.name) # end self.sto_hst = True self.h_start = False # end 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 # end else: if myrank == 0: hos_file = History(hot_start, "r", self) log_file = History(def_fname, "w", self, opt_problem.name) # end # end self.sto_hst = True self.h_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 # end self.sto_hst = True self.h_start = True else: if myrank == 0: log_file = History(def_fname, "w", self, opt_problem.name) # end self.sto_hst = True self.h_start = False # end else: self.sto_hst = False self.h_start = False # end 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]] # end # end xn = xg else: xn = x # end # Flush Output Files self.flushFiles() # Evaluate User Function fail = 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,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) # else: [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 g = numpy.zeros(len(opt_problem._constraints.keys())) 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 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]] # end # end xn = xg else: xn = x # end # Flush Output Files self.flushFiles() # Evaluate User Function fail = 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,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) # else: [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 g = numpy.zeros(len(opt_problem._constraints.keys())) 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 g def eval_grad_f(x, user_data=None): """IPOPT - Objective/Constraint Gradients Function.""" # 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: [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") # end # Gradient Assignment df = numpy.zeros(len(opt_problem._variables.keys())) for i in xrange(len(opt_problem._variables.keys())): df[i] = dff[0, i] # end return df def eval_grad_g(x, flag, user_data=None): # 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: 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 xrange(len(opt_problem._constraints.keys())): for j in xrange(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") # end # Gradient Assignment a = numpy.zeros([len(opt_problem._variables.keys()) * len(opt_problem._constraints.keys())]) for i in xrange(len(opt_problem._constraints.keys())): for j in xrange(len(opt_problem._variables.keys())): a[i * len(opt_problem._variables.keys()) + j] = dgg[i, j] # end # end 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") # 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()) 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) # end # end else: if (store_sol) and (myrank == 0): print "Optimization Problem Does Not Have Constraints\n" print "Unconstrained Optimization Initiated\n" # end ncon = 1 blc.append(-inf) buc.append(inf) # end 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) # end 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") # end # end # end 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"] # end 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 # end 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 = {} # 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 # ifail[0]
def ipoptopf_solver(om, ppopt): """Solves AC optimal power flow using IPOPT. Inputs are an OPF model object and a PYPOWER options vector. Outputs are a C{results} dict, C{success} flag and C{raw} output dict. C{results} is a PYPOWER case dict (ppc) with the usual C{baseMVA}, C{bus} C{branch}, C{gen}, C{gencost} fields, along with the following additional fields: - C{order} see 'help ext2int' for details of this field - C{x} final value of optimization variables (internal order) - C{f} final objective function value - C{mu} shadow prices on ... - C{var} - C{l} lower bounds on variables - C{u} upper bounds on variables - C{nln} - C{l} lower bounds on nonlinear constraints - C{u} upper bounds on nonlinear constraints - C{lin} - C{l} lower bounds on linear constraints - C{u} upper bounds on linear constraints C{success} is C{True} if solver converged successfully, C{False} otherwise C{raw} is a raw output dict in form returned by MINOS - C{xr} final value of optimization variables - C{pimul} constraint multipliers - C{info} solver specific termination code - C{output} solver specific output information @see: L{opf}, L{pips} @author: Ray Zimmerman (PSERC Cornell) @author: Carlos E. Murillo-Sanchez (PSERC Cornell & Universidad Autonoma de Manizales) @author: Richard Lincoln """ import pyipopt ## unpack data ppc = om.get_ppc() baseMVA, bus, gen, branch, gencost = \ ppc['baseMVA'], ppc['bus'], ppc['gen'], ppc['branch'], ppc['gencost'] vv, _, nn, _ = om.get_idx() ## problem dimensions nb = shape(bus)[0] ## number of buses ng = shape(gen)[0] ## number of gens nl = shape(branch)[0] ## number of branches ny = om.getN('var', 'y') ## number of piece-wise linear costs ## linear constraints A, l, u = om.linear_constraints() ## bounds on optimization vars _, xmin, xmax = om.getv() ## build admittance matrices Ybus, Yf, Yt = makeYbus(baseMVA, bus, branch) ## try to select an interior initial point ll = xmin.copy() uu = xmax.copy() ll[xmin == -Inf] = -2e19 ## replace Inf with numerical proxies uu[xmax == Inf] = 2e19 x0 = (ll + uu) / 2 Varefs = bus[bus[:, BUS_TYPE] == REF, VA] * (pi / 180) x0[vv['i1']['Va']:vv['iN']['Va']] = Varefs[ 0] ## angles set to first reference angle if ny > 0: ipwl = find(gencost[:, MODEL] == PW_LINEAR) # PQ = r_[gen[:, PMAX], gen[:, QMAX]] # c = totcost(gencost[ipwl, :], PQ[ipwl]) ## largest y-value in CCV data c = gencost.flatten('F')[sub2ind(shape(gencost), ipwl, NCOST + 2 * gencost[ipwl, NCOST])] x0[vv['i1']['y']:vv['iN']['y']] = max(c) + 0.1 * abs(max(c)) # x0[vv['i1']['y']:vv['iN']['y']) = c + 0.1 * abs(c) ## find branches with flow limits il = find((branch[:, RATE_A] != 0) & (branch[:, RATE_A] < 1e10)) nl2 = len(il) ## number of constrained lines ##----- run opf ----- ## build Jacobian and Hessian structure if A is not None and issparse(A): nA = A.shape[0] ## number of original linear constraints else: nA = 0 nx = len(x0) f = branch[:, F_BUS] ## list of "from" buses t = branch[:, T_BUS] ## list of "to" buses Cf = sparse((ones(nl), (arange(nl), f)), (nl, nb)) ## connection matrix for line & from buses Ct = sparse((ones(nl), (arange(nl), t)), (nl, nb)) ## connection matrix for line & to buses Cl = Cf + Ct Cb = Cl.T * Cl + speye(nb, nb) Cl2 = Cl[il, :] Cg = sparse((ones(ng), (gen[:, GEN_BUS], arange(ng))), (nb, ng)) nz = nx - 2 * (nb + ng) nxtra = nx - 2 * nb if nz > 0: Js = vstack([ hstack([Cb, Cb, Cg, sparse( (nb, ng)), sparse((nb, nz))]), hstack([Cb, Cb, sparse( (nb, ng)), Cg, sparse((nb, nz))]), hstack([Cl2, Cl2, sparse((nl2, 2 * ng)), sparse((nl2, nz))]), hstack([Cl2, Cl2, sparse((nl2, 2 * ng)), sparse((nl2, nz))]) ], 'coo') else: Js = vstack([ hstack([Cb, Cb, Cg, sparse((nb, ng))]), hstack([ Cb, Cb, sparse((nb, ng)), Cg, ]), hstack([ Cl2, Cl2, sparse((nl2, 2 * ng)), ]), hstack([ Cl2, Cl2, sparse((nl2, 2 * ng)), ]) ], 'coo') if A is not None and issparse(A): Js = vstack([Js, A], 'coo') f, _, d2f = opf_costfcn(x0, om, True) Hs = tril(d2f + vstack([ hstack([Cb, Cb, sparse((nb, nxtra))]), hstack([Cb, Cb, sparse((nb, nxtra))]), sparse((nxtra, nx)) ]), format='coo') ## set options struct for IPOPT # options = {} # options['ipopt'] = ipopt_options([], ppopt) ## extra data to pass to functions userdata = { 'om': om, 'Ybus': Ybus, 'Yf': Yf[il, :], 'Yt': Yt[il, :], 'ppopt': ppopt, 'il': il, 'A': A, 'nA': nA, 'neqnln': 2 * nb, 'niqnln': 2 * nl2, 'Js': Js, 'Hs': Hs } ## check Jacobian and Hessian structure #xr = rand(x0.shape) #lmbda = rand( 2 * nb + 2 * nl2) #Js1 = eval_jac_g(x, flag, userdata) #(xr, options.auxdata) #Hs1 = eval_h(xr, 1, lmbda, userdata) #i1, j1, s = find(Js) #i2, j2, s = find(Js1) #if (len(i1) != len(i2)) | (norm(i1 - i2) != 0) | (norm(j1 - j2) != 0): # raise ValueError, 'something''s wrong with the Jacobian structure' # #i1, j1, s = find(Hs) #i2, j2, s = find(Hs1) #if (len(i1) != len(i2)) | (norm(i1 - i2) != 0) | (norm(j1 - j2) != 0): # raise ValueError, 'something''s wrong with the Hessian structure' ## define variable and constraint bounds # n is the number of variables n = x0.shape[0] # xl is the lower bound of x as bounded constraints xl = xmin # xu is the upper bound of x as bounded constraints xu = xmax neqnln = 2 * nb niqnln = 2 * nl2 # number of constraints m = neqnln + niqnln + nA # lower bound of constraint gl = r_[zeros(neqnln), -Inf * ones(niqnln), l] # upper bound of constraints gu = r_[zeros(neqnln), zeros(niqnln), u] # number of nonzeros in Jacobi matrix nnzj = Js.nnz # number of non-zeros in Hessian matrix, you can set it to 0 nnzh = Hs.nnz eval_hessian = True if eval_hessian: hessian = lambda x, lagrange, obj_factor, flag, user_data=None: \ eval_h(x, lagrange, obj_factor, flag, userdata) nlp = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, hessian) else: nnzh = 0 nlp = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g) nlp.int_option('print_level', 5) nlp.num_option('tol', 1.0000e-12) nlp.int_option('max_iter', 250) nlp.num_option('dual_inf_tol', 0.10000) nlp.num_option('constr_viol_tol', 1.0000e-06) nlp.num_option('compl_inf_tol', 1.0000e-05) nlp.num_option('acceptable_tol', 1.0000e-08) nlp.num_option('acceptable_constr_viol_tol', 1.0000e-04) nlp.num_option('acceptable_compl_inf_tol', 0.0010000) nlp.str_option('mu_strategy', 'adaptive') iter = 0 def intermediate_callback(algmod, iter_count, obj_value, inf_pr, inf_du, mu, d_norm, regularization_size, alpha_du, alpha_pr, ls_trials, user_data=None): iter = iter_count return True nlp.set_intermediate_callback(intermediate_callback) ## run the optimization # returns final solution x, upper and lower bound for multiplier, final # objective function obj and the return status of ipopt x, zl, zu, obj, status, zg = nlp.solve(x0, m, userdata) info = { 'x': x, 'zl': zl, 'zu': zu, 'obj': obj, 'status': status, 'lmbda': zg } nlp.close() success = (status == 0) | (status == 1) output = {'iterations': iter} f, _ = opf_costfcn(x, om) ## update solution data Va = x[vv['i1']['Va']:vv['iN']['Va']] Vm = x[vv['i1']['Vm']:vv['iN']['Vm']] Pg = x[vv['i1']['Pg']:vv['iN']['Pg']] Qg = x[vv['i1']['Qg']:vv['iN']['Qg']] V = Vm * exp(1j * Va) ##----- calculate return values ----- ## update voltages & generator outputs bus[:, VA] = Va * 180 / pi bus[:, VM] = Vm gen[:, PG] = Pg * baseMVA gen[:, QG] = Qg * baseMVA gen[:, VG] = Vm[gen[:, GEN_BUS].astype(int)] ## compute branch flows f_br = branch[:, F_BUS].astype(int) t_br = branch[:, T_BUS].astype(int) Sf = V[f_br] * conj(Yf * V) ## cplx pwr at "from" bus, p.u. St = V[t_br] * conj(Yt * V) ## cplx pwr at "to" bus, p.u. branch[:, PF] = Sf.real * baseMVA branch[:, QF] = Sf.imag * baseMVA branch[:, PT] = St.real * baseMVA branch[:, QT] = St.imag * baseMVA ## line constraint is actually on square of limit ## so we must fix multipliers muSf = zeros(nl) muSt = zeros(nl) if len(il) > 0: muSf[il] = 2 * info['lmbda'][2 * nb + arange(nl2)] * branch[il, RATE_A] / baseMVA muSt[il] = 2 * info['lmbda'][2 * nb + nl2 + arange(nl2)] * branch[il, RATE_A] / baseMVA ## update Lagrange multipliers bus[:, MU_VMAX] = info['zu'][vv['i1']['Vm']:vv['iN']['Vm']] bus[:, MU_VMIN] = info['zl'][vv['i1']['Vm']:vv['iN']['Vm']] gen[:, MU_PMAX] = info['zu'][vv['i1']['Pg']:vv['iN']['Pg']] / baseMVA gen[:, MU_PMIN] = info['zl'][vv['i1']['Pg']:vv['iN']['Pg']] / baseMVA gen[:, MU_QMAX] = info['zu'][vv['i1']['Qg']:vv['iN']['Qg']] / baseMVA gen[:, MU_QMIN] = info['zl'][vv['i1']['Qg']:vv['iN']['Qg']] / baseMVA bus[:, LAM_P] = info['lmbda'][nn['i1']['Pmis']:nn['iN']['Pmis']] / baseMVA bus[:, LAM_Q] = info['lmbda'][nn['i1']['Qmis']:nn['iN']['Qmis']] / baseMVA branch[:, MU_SF] = muSf / baseMVA branch[:, MU_ST] = muSt / baseMVA ## package up results nlnN = om.getN('nln') ## extract multipliers for nonlinear constraints kl = find(info['lmbda'][:2 * nb] < 0) ku = find(info['lmbda'][:2 * nb] > 0) nl_mu_l = zeros(nlnN) nl_mu_u = r_[zeros(2 * nb), muSf, muSt] nl_mu_l[kl] = -info['lmbda'][kl] nl_mu_u[ku] = info['lmbda'][ku] ## extract multipliers for linear constraints lam_lin = info['lmbda'][2 * nb + 2 * nl2 + arange(nA)] ## lmbda for linear constraints kl = find(lam_lin < 0) ## lower bound binding ku = find(lam_lin > 0) ## upper bound binding mu_l = zeros(nA) mu_l[kl] = -lam_lin[kl] mu_u = zeros(nA) mu_u[ku] = lam_lin[ku] mu = { 'var': {'l': info['zl'], 'u': info['zu']}, 'nln': {'l': nl_mu_l, 'u': nl_mu_u}, \ 'lin': {'l': mu_l, 'u': mu_u} } results = ppc results['bus'], results['branch'], results['gen'], \ results['om'], results['x'], results['mu'], results['f'] = \ bus, branch, gen, om, x, mu, f pimul = r_[results['mu']['nln']['l'] - results['mu']['nln']['u'], results['mu']['lin']['l'] - results['mu']['lin']['u'], -ones(ny > 0), results['mu']['var']['l'] - results['mu']['var']['u']] raw = {'xr': x, 'pimul': pimul, 'info': info['status'], 'output': output} return results, success, raw
def __solver__(self, p): if not pyipoptInstalled: p.err('you should have pyipopt installed') # try: # os.close(1); os.close(2) # may not work for non-Unix OS # except: # pass nvar = p.n x_L = p.lb x_U = p.ub ncon = p.nc + p.nh + p.b.size + p.beq.size g_L, g_U = zeros(ncon), zeros(ncon) g_L[:p.nc] = -inf g_L[p.nc+p.nh:p.nc+p.nh+p.b.size] = -inf # IPOPT non-linear constraints, both eq and ineq if p.isFDmodel: r = [] if p.nc != 0: r.append(p._getPattern(p.user.c)) if p.nh != 0: r.append(p._getPattern(p.user.h)) if p.nb != 0: r.append(p.A) if p.nbeq != 0: r.append(p.Aeq) if len(r)>0: if all([isinstance(elem, ndarray) for elem in r]): r = vstack(r) else: r = Vstack(r) if isspmatrix(r): from scipy import __version__ if __version__.startswith('0.7.3') or __version__.startswith('0.7.2') or __version__.startswith('0.7.1') or __version__.startswith('0.7.0'): p.pWarn('updating scipy to version >= 0.7.4 is very recommended for the problem with the solver IPOPT') else: r = array([]) if isspmatrix(r): I, J, _ = Find(r) # DON'T remove it! I, J = array(I, int64), array(J, int64) elif isinstance(r, ndarray): if r.size == 0: I, J= array([], dtype=int64),array([], dtype=int64) else: I, J = where(r) else: p.disp('unimplemented type:%s' % str(type(r))) # dense matrix? nnzj = len(I) else: I, J = where(ones((ncon, p.n))) #I, J = None, None nnzj = ncon * p.n #TODO: reduce it def eval_g(x): r = array(()) if p.userProvided.c: r = p.c(x) if p.userProvided.h: r = hstack((r, p.h(x))) r = hstack((r, p._get_AX_Less_B_residuals(x), p._get_AeqX_eq_Beq_residuals(x))) return r def eval_jac_g(x, flag, userdata = (I, J)): (I, J) = userdata if flag and p.isFDmodel: return (I, J) r = [] if p.userProvided.c: r.append(p.dc(x)) if p.userProvided.h: r.append(p.dh(x)) if p.nb != 0: r.append(p.A) if p.nbeq != 0: r.append(p.Aeq) # TODO: fix it! if any([isspmatrix(elem) for elem in r]): r = Vstack([(atleast_2d(elem) if elem.ndim < 2 else elem) for elem in r]) elif len(r)!=0: r = vstack(r) if p.isFDmodel: # TODO: make it more properly R = (r.tocsr() if isspmatrix(r) else r)[I, J] if isspmatrix(R): return R.A elif isinstance(R, ndarray): return R else: p.err('bug in OpenOpt-ipopt connection, inform OpenOpt developers, type(R) = %s' % type(R)) if flag: return (I, J) else: if isspmatrix(r): r = r.A return r.flatten() """ This function might be buggy, """ # // comment by Eric nnzh = 0 def eval_h(lagrange, obj_factor, flag): return None # def apply_new(x): # return True nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, p.f, p.df, eval_g, eval_jac_g) if self.optFile == 'auto': lines = ['# generated automatically by OpenOpt\n','print_level 0\n'] lines.append('tol ' + str(p.ftol)+ '\n') lines.append('constr_viol_tol ' + str(p.contol)+ '\n') lines.append('max_iter ' + str(min(15000, p.maxIter))+ '\n') if self.options != '' : for s in re.split(',|;', self.options): lines.append(s.strip().replace('=', ' ', 1) + '\n') if p.nc == 0: lines.append('jac_d_constant yes\n') if p.nh == 0: lines.append('jac_c_constant yes\n') if p.castFrom.lower() in ('lp', 'qp', 'llsp'): lines.append('hessian_constant yes\n') ipopt_opt_file = open('ipopt.opt', 'w') ipopt_opt_file.writelines(lines) ipopt_opt_file.close() try: x, zl, zu, obj = nlp.solve(p.x0)[:4] if p.point(p.xk).betterThan(p.point(x)): obj = p.fk p.xk = p.xk.copy() # for more safety else: p.xk, p.fk = x.copy(), obj if p.istop == 0: p.istop = 1000 finally: nlp.close()
def test_example1(self): nvar = 4 x_L = np.ones((nvar), dtype=np.float_) * 1.0 x_U = np.ones((nvar), dtype=np.float_) * 5.0 ncon = 2 g_L = np.array([25.0, 40.0]) g_U = np.array([2.0*pow(10.0, 19), 40.0]) def eval_f(x, user_data = None): assert len(x) == 4 return x[0] * x[3] * (x[0] + x[1] + x[2]) + x[2] def eval_grad_f(x, user_data = None): assert len(x) == 4 grad_f = np.array([ x[0] * x[3] + x[3] * (x[0] + x[1] + x[2]) , x[0] * x[3], x[0] * x[3] + 1.0, x[0] * (x[0] + x[1] + x[2]) ], np.float_) return grad_f; def eval_g(x, user_data= None): assert len(x) == 4 return np.array([ x[0] * x[1] * x[2] * x[3], x[0]*x[0] + x[1]*x[1] + x[2]*x[2] + x[3]*x[3] ], np.float_) nnzj = 8 def eval_jac_g(x, flag, user_data = None): if flag: return (np.array([0, 0, 0, 0, 1, 1, 1, 1]), np.array([0, 1, 2, 3, 0, 1, 2, 3])) else: assert len(x) == 4 return np.array([ x[1]*x[2]*x[3], x[0]*x[2]*x[3], x[0]*x[1]*x[3], x[0]*x[1]*x[2], 2.0*x[0], 2.0*x[1], 2.0*x[2], 2.0*x[3] ]) nnzh = 10 def eval_h(x, lagrange, obj_factor, flag, user_data = None): if flag: hrow = [0, 1, 1, 2, 2, 2, 3, 3, 3, 3] hcol = [0, 0, 1, 0, 1, 2, 0, 1, 2, 3] return (np.array(hcol), np.array(hrow)) else: values = zeros((10), np.float_) values[0] = obj_factor * (2*x[3]) values[1] = obj_factor * (x[3]) values[2] = 0 values[3] = obj_factor * (x[3]) values[4] = 0 values[5] = 0 values[6] = obj_factor * (2*x[0] + x[1] + x[2]) values[7] = obj_factor * (x[0]) values[8] = obj_factor * (x[0]) values[9] = 0 values[1] += lagrange[0] * (x[2] * x[3]) values[3] += lagrange[0] * (x[1] * x[3]) values[4] += lagrange[0] * (x[0] * x[3]) values[6] += lagrange[0] * (x[1] * x[2]) values[7] += lagrange[0] * (x[0] * x[2]) values[8] += lagrange[0] * (x[0] * x[1]) values[0] += lagrange[1] * 2 values[2] += lagrange[1] * 2 values[5] += lagrange[1] * 2 values[9] += lagrange[1] * 2 return values def apply_new(x): return True nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g) x0 = np.array([1.0, 5.0, 5.0, 1.0]) pi0 = np.array([1.0, 1.0]) """ print x0 print nvar, ncon, nnzj print x_L, x_U print g_L, g_U print eval_f(x0) print eval_grad_f(x0) print eval_g(x0) a = eval_jac_g(x0, True) print "a = ", a[1], a[0] print eval_jac_g(x0, False) print eval_h(x0, pi0, 1.0, False) print eval_h(x0, pi0, 1.0, True) """ r = nlp.solve(x0) nlp.close() # print "Solution of the primal variables, x" # print r["x"] # print "Solution of the bound multipliers, z_L and z_U" # print r["mult_xL"], r["mult_xU"] # print "Solution of the constraint multiplier, lambda" # print r["mult_g"] # print "Objective value" # print "f(x*) =", r["f"] # print "Constraint value" # print "g(x*) =", r["g"] nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, eval_h) r = nlp.solve(x0)
values[6] += lagrange[0] * (x[1] * x[2]) values[7] += lagrange[0] * (x[0] * x[2]) values[8] += lagrange[0] * (x[0] * x[1]) values[0] += lagrange[1] * 2 values[2] += lagrange[1] * 2 values[5] += lagrange[1] * 2 values[9] += lagrange[1] * 2 return values def apply_new(x): return True nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, eval_h) x0 = array([1.0, 5.0, 5.0, 1.0]) pi0 = array([1.0, 1.0]) """ print x0 print nvar, ncon, nnzj print x_L, x_U print g_L, g_U print eval_f(x0) print eval_grad_f(x0) print eval_g(x0) a = eval_jac_g(x0, True) print "a = ", a[1], a[0] print eval_jac_g(x0, False)
def pyipopt_qp(H, c, A, gl, gu, x0=None, xl=None, xu=None, hessian=False, **kw_args): """IPOPT based quadratic program solver. Solves the quadratic programming problem: min 0.5*x'Hx + c'x x subject to: gl <= Ax <= gu xl <= x <= xu @param H: quadratic cost coefficient matrix @param c: linear cost coefficients @param A: linear constraint matrix @param gl: lower bound of constraints @param gu: upper bound of constraints @param x0: initial starting point @param xl: lower bound of x as bounded constraints @param xu: upper bound of x as bounded constraints @param finite_differences: evaluate Hessian by finite differences @param kw_args: IPOPT options """ userdata = {'H': H, 'c': c, 'A': A} if x0 is None: x0 = zeros(A.shape[1]) # n is the number of variables n = x0.shape[0] # number of linear constraints (zero nln) m = A.shape[0] # number of nonzeros in Jacobi matrix nnzj = A.nnz if gl is None: gl = -Inf * ones(m) if gu is None: gu = Inf * ones(m) if (xl is None) or (len(xl) == 0): xl = -Inf * ones(n) if (xu is None) or (len(xu) == 0): xu = Inf * ones(n) if not hessian: nnzh = 0 nlp = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, nnzh, qp_f, qp_grad_f, qp_g, qp_jac_g) else: Hl = tril(H, format='coo') # number of non-zeros in Hessian matrix nnzh = Hl.nnz eval_h = lambda x, lagrange, obj_factor, flag, \ userdata=None: qp_h(x, lagrange, obj_factor, flag, Hl) nlp = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, nnzh, qp_f, qp_grad_f, qp_g, qp_jac_g, eval_h) for k, v in kw_args.iteritems(): if isinstance(v, int): nlp.int_option(k, v) elif isinstance(v, basestring): nlp.str_option(k, v) else: nlp.num_option(k, v) # returns x, upper and lower bound for multiplier, final # objective function obj and the return status of IPOPT result = nlp.solve(x0, m, userdata) ## final values for the primal variables x = result[0] ## final values for the lower bound multipliers zl = result[1] ## final values for the upper bound multipliers zu = result[2] ## final value of the objective obj = result[3] ## status of the algorithm status = result[4] ## final values for the constraint multipliers zg = result[5] nlp.close() return x, zl, zu, obj, status, zg
values[6] += lagrange[0] * (x[1] * x[2]) values[7] += lagrange[0] * (x[0] * x[2]) values[8] += lagrange[0] * (x[0] * x[1]) values[0] += lagrange[1] * 2 values[2] += lagrange[1] * 2 values[5] += lagrange[1] * 2 values[9] += lagrange[1] * 2 return values def apply_new(x): return True nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g) x0 = array([1.0, 5.0, 5.0, 1.0]) pi0 = array([1.0, 1.0]) """ print x0 print nvar, ncon, nnzj print x_L, x_U print g_L, g_U print eval_f(x0) print eval_grad_f(x0) print eval_g(x0) a = eval_jac_g(x0, True) print "a = ", a[1], a[0] print eval_jac_g(x0, False) print eval_h(x0, pi0, 1.0, False)
def main(): prob = {} prob["n"] = 20 prob["qdim"] = 2 prob["udim"] = 2 prob["dt"] = 1.0 / (prob["n"] - 1) qdim = prob['qdim'] start = np.array([0] * qdim + [0] * qdim) end = np.array([10] * qdim + [0] * qdim) n = prob["n"] q_v_arr_lst = [ np.linspace(start[i], end[i], n) for i in range(2 * prob['qdim']) ] u_arr = np.ones((prob["udim"], n)) * 2 X_2d = np.vstack([q_v_arr_lst, u_arr]) X_init = X_2d.T.flatten() x_L = np.ones(X_init.size) * -100 x_U = np.ones(X_init.size) * 100 X_sample = np.random.uniform(x_L, x_U) #set the cost and the gradient of the cost ctrl_cost = cost.Control_Cost(prob) eval_f_adolc = aa.Func_Adolc(ctrl_cost, X_sample, scaler=True) eval_grad_f_adolc = aa.Eval_Grad_F_Adolc(eval_f_adolc.id) # eval_grad_f_adolc = aa.Func_Adolc(ctrl_cost.eval_grad_f, X_sample) #set the constriant function for points at specific time points = [(0, start), (n - 1, end)] # p_index, p_g_func = [constraint.get_point_constriant(prob, t, g) # for (t, g) in points] p_index_g_piar = [ constraint.get_point_constriant(prob, t, g) for (t, g) in points ] p_index_iter, p_g_func_iter = zip(*p_index_g_piar) p_index_lst = list(p_index_iter) p_g_lst = list(p_g_func_iter) # p_g_adolc_lst = [aa.Func_Adolc(g, X_sample[i]) # for (i, g) in p_index_g_piar] #set the dynamic constriants block = dy.Block(prob["qdim"], prob["udim"]) dynamics = block.dynamics d_index, d_g_func = constraint.get_dynamic_constriants( prob, dynamics, range(0, n - 1)) # d_g_adolc = aa.Func_Adolc(d_g_func, X_sample[d_index[0]]) #all dynamcis shares the same approximation function # d_g_adolc_lst = [d_g_adolc for i in d_index] d_g_lst = [d_g_func for i in d_index] index_lst = p_index_lst + d_index # eval_g_adolc_lst = p_g_adolc_lst + d_g_adolc_lst eval_g_lst = p_g_lst + d_g_lst # X_sample_lst = [X_sample[i] for i in index_lst] # # g_adolc_x_pair = zip(eval_g_adolc_lst, X_sample_lst) # # eval_jac_adolc_lst = [aa.Eval_Jac_G_Adolc(g.id, x) # for (g, x) in g_adolc_x_pair] eval_g = constraint.Stacked_Constriants(eval_g_lst, index_lst) eval_g_adolc = aa.Func_Adolc(eval_g, X_sample) eval_jac_g_adolc = aa.Eval_Jac_G_Adolc(eval_g_adolc.id, X_sample) # eval_g_adolc = aa.Func_Adolc(eval_g, X_sample) # eval_jac_g = constraint.Stacked_Constriants_Jacobian(eval_g_lst , # eval_jac_lst, # index_lst) nvar = X_init.size ncon = eval_g(X_init).size eval_lagrangian = constraint.Eval_Lagrangian(ctrl_cost, eval_g) #x, lagrangian, obj_factor x_lag_lst = [X_sample, np.ones(ncon), 1] x_lag_arr = np.hstack(x_lag_lst) eval_lagrangian_adolc = aa.Func_Adolc(eval_lagrangian, x_lag_lst) eval_h_adolc = aa.Eval_h_adolc(eval_lagrangian_adolc.id, x_lag_arr) maks = eval_h_adolc(X_init, np.ones(ncon), 1, True) H = eval_h_adolc(X_init, np.ones(ncon), 1, False) g_L = np.zeros(ncon) g_U = np.zeros(ncon) nnzj = eval_jac_g_adolc.nnzj nnzh = eval_h_adolc.nnzh import ipdb ipdb.set_trace() # XXX BREAKPOINT # nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, 0, eval_f_adolc , # eval_grad_f_adolc, eval_g_adolc, eval_jac_g_adolc) nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f_adolc, eval_grad_f_adolc, eval_g_adolc, eval_jac_g_adolc, eval_h_adolc) output, zl, zu, constraint_multipliers, obj, status = nlp.solve(X_init) output_2d = output.reshape(n, -1) return output_2d, prob
print print "Calling solver with set of vars" print "nvar = ", nvar print "x_L = ", x_L print "x_U = ", x_U print "g_L = ", g_L print "g_U = ", g_U print "ncon = ", ncon print "nnzj, nnzh = ", nnzj, ", ", nnzh print "x0 = ", x0 # Call solve() #pyipopt.set_loglevel(2) # verbose nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, anon_eval_f, anon_eval_grad_f, anon_eval_g, anon_eval_jac_g) #nlp.int_option("max_iter", 3000) #nlp.num_option("tol", 1e-8) #nlp.num_option("acceptable_tol", 1e-2) #nlp.int_option("acceptable_iter", 0) nlp.str_option("derivative_test", "first-order") nlp.str_option("derivative_test_print_all", "no") #nlp.str_option("print_options_documentation", "yes") nlp.str_option("print_user_options", "yes") #nlp.int_option("print_level", 12) x, zl, zu, obj, status = nlp.solve(x0) nlp.close() # Print results print print "Solution of the primal variables, x"
ineq_constr_jac(x), axis=0) i_s = [] j_s = [] if flag: for i in range(len(x0)): for j in range(len(ret)): i_s.append(i) j_s.append(j) return (np.array(i_s), np.array(j_s)) else: return ret.flatten() nnzj = len(eval_jac_g(x0, False)) g_L = np.zeros((len(eval_g(x0)))) g_U = np.zeros_like(g_L) g_U[neq:] = 1e10 nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, avg_cost, avg_cost_grad, eval_g, eval_jac_g) nlp.num_option('bound_relax_factor', 0.1) nlp.str_option("mu_strategy", "adaptive") nlp.str_option("derivative_test", "first-order") nlp.str_option('warm_start_init_point', 'yes') nlp.str_option('linear_solver', 'mumps') print(datetime.datetime.now(), ": Going to call solve") x, zl, zu, constraint_multipliers, obj, status = nlp.solve(x0) nlp.close() print(x)
def get_ipopt_miu(self): """Optimized miu Calculate optimal miu. Called when opt=True is passed to loop(). ... Args: None Returns nd.array: Array of optimal miu, n = params.tmax """ try: import pyipopt except ImportError: pyipopt = None print('OPTIMIZATION ERROR: It appears that you do not have ' 'pyipopt installed. Please install it before running ' 'optimization.') x0 = np.concatenate( (np.linspace(0, 1, 40) ** (1 - np.linspace(0, 1, 40)), np.ones(20)) ) M = 0 nnzj = 0 nnzh = 0 xl = np.zeros(self.params.tmax) xu = np.ones(self.params.tmax) xl[0] = .005 xu[0] = .005 xl[-20:] = 1 gl = np.zeros(M) gu = np.ones(M) * 4.0 def eval_f(_x0): if (_x0 == self.opt_x).all() and self.opt_obj is not None: return self.opt_obj else: self.opt_x = _x0.copy() return self.obj_loop(_x0) def eval_grad_f(_x0): if (_x0 == self.opt_x).all() and self.opt_grad_f is not None: return self.opt_grad_f else: self.opt_x = _x0.copy() return self.grad_loop(_x0) def eval_g(x): return np.zeros(M) def eval_jac_g(x, flag): if flag: return [], [] else: return np.empty(M) pyipopt.set_loglevel(1) nlp = pyipopt.create( self.opt_vars, xl, xu, M, gl, gu, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, ) nlp.num_option('constr_viol_tol', 8e-7) nlp.int_option('max_iter', 30) nlp.num_option('max_cpu_time', 60) nlp.num_option('tol', self.opt_tol) # nlp.num_option('acceptable_tol', 1e-4) # nlp.int_option('acceptable_iter', 4) nlp.num_option('obj_scaling_factor', -1e+0) nlp.int_option('print_level', 0) nlp.str_option('linear_solver', 'ma57') # nlp.str_option('derivative_test', 'first-order') x = nlp.solve(x0)[0] nlp.close() return x
def test_ipopt_optimization(): """ This test checks 1. the sparse functionality of pyadolc 2. the execution speed compared to the direct sparse computation 3. run the optimization with the derivatives provided by pyadolc IPOPT is an interior point algorithm to solve min f(x) x in R^n s.t. g_L <= g(x) <= g_U x_L <= x <= x_U this test fails probably because of a bug in pyipopt """ try: import pyipopt except: #print '"pyipopt is not installed, skipping test' #return raise NotImplementedError("pyipopt is not installed, skipping test") try: import scipy.sparse as sparse except: #print '"pyipopt is not installed, skipping test' #return raise NotImplementedError("scipy is not installed, skipping test") import time nvar = 4 x_L = numpy.ones((nvar), dtype=numpy.float_) * 1.0 x_U = numpy.ones((nvar), dtype=numpy.float_) * 5.0 ncon = 2 g_L = numpy.array([25.0, 40.0]) g_U = numpy.array([2.0 * pow(10.0, 19), 40.0]) def eval_f(x, user_data=None): assert len(x) == 4 return x[0] * x[3] * (x[0] + x[1] + x[2]) + x[2] def eval_grad_f(x, user_data=None): assert len(x) == 4 grad_f = numpy.array([ x[0] * x[3] + x[3] * (x[0] + x[1] + x[2]), x[0] * x[3], x[0] * x[3] + 1.0, x[0] * (x[0] + x[1] + x[2]) ]) return grad_f def eval_g(x, user_data=None): assert len(x) == 4 return numpy.array([ x[0] * x[1] * x[2] * x[3], x[0] * x[0] + x[1] * x[1] + x[2] * x[2] + x[3] * x[3] ]) nnzj = 8 def eval_jac_g(x, flag, user_data=None): if flag: return (numpy.array([0, 0, 0, 0, 1, 1, 1, 1]), numpy.array([0, 1, 2, 3, 0, 1, 2, 3])) else: assert len(x) == 4 return numpy.array([ x[1] * x[2] * x[3], x[0] * x[2] * x[3], x[0] * x[1] * x[3], x[0] * x[1] * x[2], 2.0 * x[0], 2.0 * x[1], 2.0 * x[2], 2.0 * x[3] ]) nnzh = 10 def eval_h(x, lagrange, obj_factor, flag, user_data=None): if flag: hrow = [0, 1, 1, 2, 2, 2, 3, 3, 3, 3] hcol = [0, 0, 1, 0, 1, 2, 0, 1, 2, 3] return (numpy.array(hcol, dtype=int), numpy.array(hrow, dtype=int)) else: values = numpy.zeros((10), numpy.float_) values[0] = obj_factor * (2 * x[3]) values[1] = obj_factor * (x[3]) values[2] = 0 values[3] = obj_factor * (x[3]) values[4] = 0 values[5] = 0 values[6] = obj_factor * (2 * x[0] + x[1] + x[2]) values[7] = obj_factor * (x[0]) values[8] = obj_factor * (x[0]) values[9] = 0 values[1] += lagrange[0] * (x[2] * x[3]) values[3] += lagrange[0] * (x[1] * x[3]) values[4] += lagrange[0] * (x[0] * x[3]) values[6] += lagrange[0] * (x[1] * x[2]) values[7] += lagrange[0] * (x[0] * x[2]) values[8] += lagrange[0] * (x[0] * x[1]) values[0] += lagrange[1] * 2 values[2] += lagrange[1] * 2 values[5] += lagrange[1] * 2 values[9] += lagrange[1] * 2 return values def apply_new(x): return True x0 = numpy.array([1.0, 5.0, 5.0, 1.0]) pi0 = numpy.array([1.0, 1.0]) # check that adolc gives the same answers as derivatives calculated by hand trace_on(1) ax = adouble(x0) independent(ax) ay = eval_f(ax) dependent(ay) trace_off() trace_on(2) ax = adouble(x0) independent(ax) ay = eval_g(ax) dependent(ay) trace_off() trace_on(3) ax = adouble(x0) independent(ax) ay = eval_g(ax) dependent(ay[0]) trace_off() trace_on(4) ax = adouble(x0) independent(ax) ay = eval_g(ax) dependent(ay[1]) trace_off() def eval_f_adolc(x, user_data=None): return function(1, x)[0] def eval_grad_f_adolc(x, user_data=None): return gradient(1, x) def eval_g_adolc(x, user_data=None): return function(2, x) def eval_jac_g_adolc(x, flag, user_data=None): options = numpy.array([1, 1, 0, 0], dtype=int) result = colpack.sparse_jac_no_repeat(2, x, options) if flag: return (numpy.asarray(result[1], dtype=int), numpy.asarray(result[2], dtype=int)) else: return result[3] def eval_h_adolc(x, lagrange, obj_factor, flag, user_data=None): if flag: # return sparsity pattern of the hessian if eval_h_adolc.firstrun == True: # this can be done more elegantly based directly on # the sparsity pattern returned by adolc.sparse.hess_pat options = numpy.array([0, 0], dtype=int) result_f = colpack.sparse_hess_no_repeat(1, x, options) result_g0 = colpack.sparse_hess_no_repeat(3, x, options) result_g1 = colpack.sparse_hess_no_repeat(4, x, options) Hf = sparse.coo_matrix( (result_f[3], (result_f[1], result_f[2])), shape=(4, 4)) Hg0 = sparse.coo_matrix( (result_g0[3], (result_g0[1], result_g0[2])), shape=(4, 4)) Hg1 = sparse.coo_matrix( (result_g1[3], (result_g1[1], result_g1[2])), shape=(4, 4)) H = Hf + Hg0 + Hg1 H = H.tocoo() hrow = H.row hcol = H.col hpat = (numpy.array(hcol, dtype=int), numpy.array(hrow, dtype=int)) eval_h_adolc.hpat = hpat eval_h_adolc.firstrun = False return eval_h_adolc.hpat else: # compute sparse hessian assert numpy.ndim(x) == 1 assert numpy.size(x) == 4 options = numpy.array([0, 0], dtype=int) result_f = colpack.sparse_hess_no_repeat(1, x, options) result_g0 = colpack.sparse_hess_no_repeat(3, x, options) result_g1 = colpack.sparse_hess_no_repeat(4, x, options) Hf = sparse.coo_matrix((result_f[3], (result_f[1], result_f[2])), shape=(4, 4)) Hg0 = sparse.coo_matrix( (result_g0[3], (result_g0[1], result_g0[2])), shape=(4, 4)) Hg1 = sparse.coo_matrix( (result_g1[3], (result_g1[1], result_g1[2])), shape=(4, 4)) H = Hf + Hg0 + Hg1 H = H.tocoo() values = numpy.zeros((10), float) values[:] = H.data return values eval_h_adolc.firstrun = True # function of f assert_almost_equal(eval_f(x0), eval_f_adolc(x0)) # gradient of f assert_array_almost_equal(eval_grad_f(x0), eval_grad_f_adolc(x0)) # function of g assert_array_almost_equal(eval_g(x0), function(2, x0)) # sparse jacobian of g assert_array_equal(eval_jac_g_adolc(x0, True)[0], eval_jac_g(x0, True)[0]) assert_array_equal(eval_jac_g_adolc(x0, True)[1], eval_jac_g(x0, True)[1]) assert_array_equal(eval_jac_g_adolc(x0, False), eval_jac_g(x0, False)) # sparse hessian of the lagrangian lagrange = numpy.ones(2, dtype=float) obj_factor = 1. x0 = numpy.random.rand(4) result = (eval_h(x0, lagrange, obj_factor, False), eval_h(x0, lagrange, obj_factor, True)) result_adolc = (eval_h_adolc(x0, lagrange, obj_factor, False), eval_h_adolc(x0, lagrange, obj_factor, True)) H = sparse.coo_matrix(result, shape=(4, 4)) H_adolc = sparse.coo_matrix(result_adolc, shape=(4, 4)) H = H.todense() H_adolc = H_adolc.todense() assert_array_almost_equal(H, H_adolc.T) # test optimization with PYIPOPT nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, eval_h) start_time = time.time() result = nlp.solve(x0) end_time = time.time() nlp.close() pure_python_optimization_time = end_time - start_time nlp_adolc = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f_adolc, eval_grad_f_adolc, eval_g_adolc, eval_jac_g_adolc, eval_h_adolc) start_time = time.time() result_adolc = nlp_adolc.solve(x0) end_time = time.time() nlp_adolc.close() adolc_optimization_time = end_time - start_time print('optimization time with derivatives computed by adolc = ', adolc_optimization_time) print('optimization time with derivatives computed by hand = ', pure_python_optimization_time) assert adolc_optimization_time / pure_python_optimization_time < 10 # this works with the pyipopt version from code.google.com assert_array_almost_equal(result[0], result_adolc[0]) assert_array_almost_equal(result[1], result_adolc[1]) assert_array_almost_equal(result[2], result_adolc[2]) assert_array_almost_equal(result[3], result_adolc[3])
def iterate(k_init, n_agents, gp_old): # IPOPT PARAMETERS below " N = 3 * n_agents # number of vars M = 3 * n_agents + 1 # number of constraints NELE_JAC = N * M NELE_HESS = (N**2 - N) / 2 + N # number of non-zero entries of Hess matrix # Vector of variables -> solution of non-linear equation system X = np.empty(N) LAM = np.empty(M) # multipliers G = np.empty(M) # (in-)equality constraints # Vector of lower and upper bounds G_L = np.empty(M) G_U = np.empty(M) X_L = np.empty(N) X_U = np.empty(N) Z_L = np.empty(N) Z_U = np.empty(N) # get coords of an individual points grid_pt_box = k_init X_L[:n_agents] = c_bar X_U[:n_agents] = c_up X_L[n_agents:2 * n_agents] = l_bar X_U[n_agents:2 * n_agents] = l_up X_L[2 * n_agents:3 * n_agents] = inv_bar X_U[2 * n_agents:3 * n_agents] = inv_up # Set bounds for the constraints G_L[:n_agents] = c_bar G_U[:n_agents] = c_up G_L[n_agents:2 * n_agents] = l_bar G_U[n_agents:2 * n_agents] = l_up G_L[2 * n_agents:3 * n_agents] = inv_bar G_U[2 * n_agents:3 * n_agents] = inv_up G_L[3 * n_agents] = 0.0 # both values set to 0 for equality contraints G_U[3 * n_agents] = 0.0 # initial guesses for first iteration cons_init = 0.5 * (X_U[:n_agents] - X_L[:n_agents]) + X_L[:n_agents] lab_init = 0.5 * (X_U[n_agents:2 * n_agents] - X_L[n_agents:2 * n_agents]) + X_L[n_agents:2 * n_agents] inv_init = 0.5 * (X_U[2 * n_agents:3 * n_agents] - X_L[2 * n_agents:3 * n_agents]) + X_L[2 * n_agents:3 * n_agents] X[:n_agents] = cons_init X[n_agents:2 * n_agents] = lab_init X[2 * n_agents:3 * n_agents] = inv_init # Create ev_f, eval_f, eval_grad_f, eval_g, eval_jac_g for given k_init and n_agent def eval_f(X): return EV_F_ITER(X, k_init, n_agents, gp_old) def eval_grad_f(X): return EV_GRAD_F_ITER(X, k_init, n_agents, gp_old) def eval_g(X): return EV_G_ITER(X, k_init, n_agents) def eval_jac_g(X, flag): return EV_JAC_G_ITER(X, flag, k_init, n_agents) # First create a handle for the Ipopt problem nlp = pyipopt.create(N, X_L, X_U, M, G_L, G_U, NELE_JAC, NELE_HESS, eval_f, eval_grad_f, eval_g, eval_jac_g) nlp.num_option("obj_scaling_factor", -1.00) nlp.num_option("tol", 1e-6) nlp.num_option("acceptable_tol", 1e-5) nlp.str_option("derivative_test", "first-order") nlp.str_option("hessian_approximation", "limited-memory") nlp.int_option("print_level", 0) x, z_l, z_u, constraint_multipliers, obj, status = nlp.solve(X) nlp.close() # x: Solution of the primal variables # z_l, z_u: Solution of the bound multipliers # constraint_multipliers: Solution of the constraint multipliers # obj: Objective value # status: Exit Status # Unpack Consumption, Labor, and Investment c = x[:n_agents] l = x[n_agents:2 * n_agents] inv = x[2 * n_agents:3 * n_agents] to_print = np.hstack((obj, x)) # === debug #f=open("results.txt", 'a') #np.savetxt(f, np.transpose(to_print) #, fmt=len(x)*'%10.10f ') #for num in to_print: # f.write(str(num)+"\t") #f.write("\n") #f.close() return obj, c, l, inv
def ipoptopf_solver(om, ppopt): """Solves AC optimal power flow using IPOPT. Inputs are an OPF model object and a PYPOWER options vector. Outputs are a C{results} dict, C{success} flag and C{raw} output dict. C{results} is a PYPOWER case dict (ppc) with the usual C{baseMVA}, C{bus} C{branch}, C{gen}, C{gencost} fields, along with the following additional fields: - C{order} see 'help ext2int' for details of this field - C{x} final value of optimization variables (internal order) - C{f} final objective function value - C{mu} shadow prices on ... - C{var} - C{l} lower bounds on variables - C{u} upper bounds on variables - C{nln} - C{l} lower bounds on nonlinear constraints - C{u} upper bounds on nonlinear constraints - C{lin} - C{l} lower bounds on linear constraints - C{u} upper bounds on linear constraints C{success} is C{True} if solver converged successfully, C{False} otherwise C{raw} is a raw output dict in form returned by MINOS - C{xr} final value of optimization variables - C{pimul} constraint multipliers - C{info} solver specific termination code - C{output} solver specific output information @see: L{opf}, L{pips} @author: Ray Zimmerman (PSERC Cornell) @author: Carlos E. Murillo-Sanchez (PSERC Cornell & Universidad Autonoma de Manizales) @author: Richard Lincoln """ import pyipopt ## unpack data ppc = om.get_ppc() baseMVA, bus, gen, branch, gencost = \ ppc['baseMVA'], ppc['bus'], ppc['gen'], ppc['branch'], ppc['gencost'] vv, _, nn, _ = om.get_idx() ## problem dimensions nb = shape(bus)[0] ## number of buses ng = shape(gen)[0] ## number of gens nl = shape(branch)[0] ## number of branches ny = om.getN('var', 'y') ## number of piece-wise linear costs ## linear constraints A, l, u = om.linear_constraints() ## bounds on optimization vars _, xmin, xmax = om.getv() ## build admittance matrices Ybus, Yf, Yt = makeYbus(baseMVA, bus, branch) ## try to select an interior initial point ll = xmin.copy(); uu = xmax.copy() ll[xmin == -Inf] = -2e19 ## replace Inf with numerical proxies uu[xmax == Inf] = 2e19 x0 = (ll + uu) / 2 Varefs = bus[bus[:, BUS_TYPE] == REF, VA] * (pi / 180) x0[vv['i1']['Va']:vv['iN']['Va']] = Varefs[0] ## angles set to first reference angle if ny > 0: ipwl = find(gencost[:, MODEL] == PW_LINEAR) # PQ = r_[gen[:, PMAX], gen[:, QMAX]] # c = totcost(gencost[ipwl, :], PQ[ipwl]) ## largest y-value in CCV data c = gencost.flatten('F')[sub2ind(shape(gencost), ipwl, NCOST + 2 * gencost[ipwl, NCOST])] x0[vv['i1']['y']:vv['iN']['y']] = max(c) + 0.1 * abs(max(c)) # x0[vv['i1']['y']:vv['iN']['y']) = c + 0.1 * abs(c) ## find branches with flow limits il = find((branch[:, RATE_A] != 0) & (branch[:, RATE_A] < 1e10)) nl2 = len(il) ## number of constrained lines ##----- run opf ----- ## build Jacobian and Hessian structure if A is not None and issparse(A): nA = A.shape[0] ## number of original linear constraints else: nA = 0 nx = len(x0) f = branch[:, F_BUS] ## list of "from" buses t = branch[:, T_BUS] ## list of "to" buses Cf = sparse((ones(nl), (arange(nl), f)), (nl, nb)) ## connection matrix for line & from buses Ct = sparse((ones(nl), (arange(nl), t)), (nl, nb)) ## connection matrix for line & to buses Cl = Cf + Ct Cb = Cl.T * Cl + speye(nb, nb) Cl2 = Cl[il, :] Cg = sparse((ones(ng), (gen[:, GEN_BUS], arange(ng))), (nb, ng)) nz = nx - 2 * (nb + ng) nxtra = nx - 2 * nb if nz > 0: Js = vstack([ hstack([Cb, Cb, Cg, sparse((nb, ng)), sparse((nb, nz))]), hstack([Cb, Cb, sparse((nb, ng)), Cg, sparse((nb, nz))]), hstack([Cl2, Cl2, sparse((nl2, 2 * ng)), sparse((nl2, nz))]), hstack([Cl2, Cl2, sparse((nl2, 2 * ng)), sparse((nl2, nz))]) ], 'coo') else: Js = vstack([ hstack([Cb, Cb, Cg, sparse((nb, ng))]), hstack([Cb, Cb, sparse((nb, ng)), Cg, ]), hstack([Cl2, Cl2, sparse((nl2, 2 * ng)), ]), hstack([Cl2, Cl2, sparse((nl2, 2 * ng)), ]) ], 'coo') if A is not None and issparse(A): Js = vstack([Js, A], 'coo') f, _, d2f = opf_costfcn(x0, om, True) Hs = tril(d2f + vstack([ hstack([Cb, Cb, sparse((nb, nxtra))]), hstack([Cb, Cb, sparse((nb, nxtra))]), sparse((nxtra, nx)) ]), format='coo') ## set options struct for IPOPT # options = {} # options['ipopt'] = ipopt_options([], ppopt) ## extra data to pass to functions userdata = { 'om': om, 'Ybus': Ybus, 'Yf': Yf[il, :], 'Yt': Yt[il, :], 'ppopt': ppopt, 'il': il, 'A': A, 'nA': nA, 'neqnln': 2 * nb, 'niqnln': 2 * nl2, 'Js': Js, 'Hs': Hs } ## check Jacobian and Hessian structure #xr = rand(x0.shape) #lmbda = rand( 2 * nb + 2 * nl2) #Js1 = eval_jac_g(x, flag, userdata) #(xr, options.auxdata) #Hs1 = eval_h(xr, 1, lmbda, userdata) #i1, j1, s = find(Js) #i2, j2, s = find(Js1) #if (len(i1) != len(i2)) | (norm(i1 - i2) != 0) | (norm(j1 - j2) != 0): # raise ValueError, 'something''s wrong with the Jacobian structure' # #i1, j1, s = find(Hs) #i2, j2, s = find(Hs1) #if (len(i1) != len(i2)) | (norm(i1 - i2) != 0) | (norm(j1 - j2) != 0): # raise ValueError, 'something''s wrong with the Hessian structure' ## define variable and constraint bounds # n is the number of variables n = x0.shape[0] # xl is the lower bound of x as bounded constraints xl = xmin # xu is the upper bound of x as bounded constraints xu = xmax neqnln = 2 * nb niqnln = 2 * nl2 # number of constraints m = neqnln + niqnln + nA # lower bound of constraint gl = r_[zeros(neqnln), -Inf * ones(niqnln), l] # upper bound of constraints gu = r_[zeros(neqnln), zeros(niqnln), u] # number of nonzeros in Jacobi matrix nnzj = Js.nnz # number of non-zeros in Hessian matrix, you can set it to 0 nnzh = Hs.nnz eval_hessian = True if eval_hessian: hessian = lambda x, lagrange, obj_factor, flag, user_data=None: \ eval_h(x, lagrange, obj_factor, flag, userdata) nlp = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, hessian) else: nnzh = 0 nlp = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g) nlp.int_option('print_level', 5) nlp.num_option('tol', 1.0000e-12) nlp.int_option('max_iter', 250) nlp.num_option('dual_inf_tol', 0.10000) nlp.num_option('constr_viol_tol', 1.0000e-06) nlp.num_option('compl_inf_tol', 1.0000e-05) nlp.num_option('acceptable_tol', 1.0000e-08) nlp.num_option('acceptable_constr_viol_tol', 1.0000e-04) nlp.num_option('acceptable_compl_inf_tol', 0.0010000) nlp.str_option('mu_strategy', 'adaptive') iter = 0 def intermediate_callback(algmod, iter_count, obj_value, inf_pr, inf_du, mu, d_norm, regularization_size, alpha_du, alpha_pr, ls_trials, user_data=None): iter = iter_count return True nlp.set_intermediate_callback(intermediate_callback) ## run the optimization # returns final solution x, upper and lower bound for multiplier, final # objective function obj and the return status of ipopt x, zl, zu, obj, status, zg = nlp.solve(x0, m, userdata) info = {'x': x, 'zl': zl, 'zu': zu, 'obj': obj, 'status': status, 'lmbda': zg} nlp.close() success = (status == 0) | (status == 1) output = {'iterations': iter} f, _ = opf_costfcn(x, om) ## update solution data Va = x[vv['i1']['Va']:vv['iN']['Va']] Vm = x[vv['i1']['Vm']:vv['iN']['Vm']] Pg = x[vv['i1']['Pg']:vv['iN']['Pg']] Qg = x[vv['i1']['Qg']:vv['iN']['Qg']] V = Vm * exp(1j * Va) ##----- calculate return values ----- ## update voltages & generator outputs bus[:, VA] = Va * 180 / pi bus[:, VM] = Vm gen[:, PG] = Pg * baseMVA gen[:, QG] = Qg * baseMVA gen[:, VG] = Vm[gen[:, GEN_BUS].astype(int)] ## compute branch flows f_br = branch[:, F_BUS].astype(int) t_br = branch[:, T_BUS].astype(int) Sf = V[f_br] * conj(Yf * V) ## cplx pwr at "from" bus, p.u. St = V[t_br] * conj(Yt * V) ## cplx pwr at "to" bus, p.u. branch[:, PF] = Sf.real * baseMVA branch[:, QF] = Sf.imag * baseMVA branch[:, PT] = St.real * baseMVA branch[:, QT] = St.imag * baseMVA ## line constraint is actually on square of limit ## so we must fix multipliers muSf = zeros(nl) muSt = zeros(nl) if len(il) > 0: muSf[il] = 2 * info['lmbda'][2 * nb + arange(nl2)] * branch[il, RATE_A] / baseMVA muSt[il] = 2 * info['lmbda'][2 * nb + nl2 + arange(nl2)] * branch[il, RATE_A] / baseMVA ## update Lagrange multipliers bus[:, MU_VMAX] = info['zu'][vv['i1']['Vm']:vv['iN']['Vm']] bus[:, MU_VMIN] = info['zl'][vv['i1']['Vm']:vv['iN']['Vm']] gen[:, MU_PMAX] = info['zu'][vv['i1']['Pg']:vv['iN']['Pg']] / baseMVA gen[:, MU_PMIN] = info['zl'][vv['i1']['Pg']:vv['iN']['Pg']] / baseMVA gen[:, MU_QMAX] = info['zu'][vv['i1']['Qg']:vv['iN']['Qg']] / baseMVA gen[:, MU_QMIN] = info['zl'][vv['i1']['Qg']:vv['iN']['Qg']] / baseMVA bus[:, LAM_P] = info['lmbda'][nn['i1']['Pmis']:nn['iN']['Pmis']] / baseMVA bus[:, LAM_Q] = info['lmbda'][nn['i1']['Qmis']:nn['iN']['Qmis']] / baseMVA branch[:, MU_SF] = muSf / baseMVA branch[:, MU_ST] = muSt / baseMVA ## package up results nlnN = om.getN('nln') ## extract multipliers for nonlinear constraints kl = find(info['lmbda'][:2 * nb] < 0) ku = find(info['lmbda'][:2 * nb] > 0) nl_mu_l = zeros(nlnN) nl_mu_u = r_[zeros(2 * nb), muSf, muSt] nl_mu_l[kl] = -info['lmbda'][kl] nl_mu_u[ku] = info['lmbda'][ku] ## extract multipliers for linear constraints lam_lin = info['lmbda'][2 * nb + 2 * nl2 + arange(nA)] ## lmbda for linear constraints kl = find(lam_lin < 0) ## lower bound binding ku = find(lam_lin > 0) ## upper bound binding mu_l = zeros(nA) mu_l[kl] = -lam_lin[kl] mu_u = zeros(nA) mu_u[ku] = lam_lin[ku] mu = { 'var': {'l': info['zl'], 'u': info['zu']}, 'nln': {'l': nl_mu_l, 'u': nl_mu_u}, \ 'lin': {'l': mu_l, 'u': mu_u} } results = ppc results['bus'], results['branch'], results['gen'], \ results['om'], results['x'], results['mu'], results['f'] = \ bus, branch, gen, om, x, mu, f pimul = r_[ results['mu']['nln']['l'] - results['mu']['nln']['u'], results['mu']['lin']['l'] - results['mu']['lin']['u'], -ones(ny > 0), results['mu']['var']['l'] - results['mu']['var']['u'] ] raw = {'xr': x, 'pimul': pimul, 'info': info['status'], 'output': output} return results, success, raw
def main(traj_filename): prob = {} prob["n"] = 10 prob["qdim"] = 2 prob["udim"] = 1 # prob["dt"] = 0.1/( prob["n"]-1) prob["dt"] = 0.1 p_L = [-2, -1*np.pi, -2, -np.pi, -3] p_U = [2, 1*np.pi, 2, np.pi, 3] x_L = np.tile(p_L, prob["n"]) x_U = np.tile(p_U, prob["n"]) qdim = prob['qdim'] start = np.array([0]*qdim+[0]*qdim) start[1] = -np.pi start[1] = 0 end = np.array([0]*qdim+[0]*qdim) n = prob["n"] q_v_arr_lst = [np.linspace(start[i], end[i], n) for i in range(2*prob['qdim'])] u_arr = np.ones((prob["udim"], n))*0.001 X_2d = np.vstack([q_v_arr_lst, u_arr]) X_init = X_2d.T.flatten() # set the control cost X_sample = np.random.uniform(x_L, x_U) #set the cost and the gradient of the cost ctrl_cost = cost.Control_Cost(prob) eval_f_adolc = aa.Func_Adolc(ctrl_cost, X_sample, scaler=True) eval_grad_f_adolc = aa.Eval_Grad_F_Adolc(eval_f_adolc.id) # eval_grad_f_adolc = aa.Func_Adolc(ctrl_cost.eval_grad_f, X_sample) #set the constriant function for points at specific time g1 = np.array([-np.pi, 0]) g2 = np.array([0, 0]) points = [(0, g1), (n-1, g2)] # points = [(n-1, end)] # points = [(0, start)] # p_index, p_g_func = [constraint.get_point_constriant(prob, t, g) # for (t, g) in points] # q and v of the pole dims = np.array([1,1+prob["qdim"]]) p_index_g_piar = [constraint.get_point_constriant(prob, t, g, dims) for (t, g) in points] p_index_iter, p_g_func_iter = zip(*p_index_g_piar) p_index_lst = list(p_index_iter) p_g_lst = list(p_g_func_iter) # p_g_adolc_lst = [aa.Func_Adolc(g, X_sample[i]) # for (i, g) in p_index_g_piar] D_factory= constraint.Dynamics_constriant model_path = "/home/tao/src/gym/gym/envs/mujoco/assets/inverted_pendulum.xml" model = dy.make_model(model_path) sim = mujoco_py.MjSim(model) qdim = model.nq udim = model.nu cart = dy.Mujoco_Dynamics(model, sim, qdim, udim) dynamics = cart.dynamics d_index, d_g_func = constraint.get_dynamic_constriants(prob, dynamics, range(0, n-1)) # d_g_adolc = aa.Func_Adolc(d_g_func, X_sample[d_index[0]]) #all dynamcis shares the same approximation function # d_g_adolc_lst = [d_g_adolc for i in d_index] d_g_lst = [d_g_func for i in d_index] index_lst = p_index_lst + d_index eval_g_lst = p_g_lst + d_g_lst # X_sample_lst = [X_sample[i] for i in index_lst] # # g_adolc_x_pair = zip(eval_g_adolc_lst, X_sample_lst) # # eval_jac_adolc_lst = [aa.Eval_Jac_G_Adolc(g.id, x) # for (g, x) in g_adolc_x_pair] eval_g = constraint.Stacked_Constriants(eval_g_lst, index_lst) eval_g_adolc = aa.Func_Adolc(eval_g, X_sample) eval_jac_g_adolc = aa.Eval_Jac_G_Adolc(eval_g_adolc.id, X_sample) # eval_g_adolc = aa.Func_Adolc(eval_g, X_sample) # eval_jac_g = constraint.Stacked_Constriants_Jacobian(eval_g_lst , # eval_jac_lst, # index_lst) nvar = X_init.size ncon = eval_g(X_init).size eval_lagrangian = constraint.Eval_Lagrangian(ctrl_cost, eval_g) #x, lagrangian, obj_factor x_lag_lst = [X_sample, np.ones(ncon), 1] x_lag_arr = np.hstack(x_lag_lst) eval_lagrangian_adolc = aa.Func_Adolc(eval_lagrangian, x_lag_lst) eval_h_adolc = aa.Eval_h_adolc(eval_lagrangian_adolc.id, x_lag_arr) maks = eval_h_adolc(X_init, np.ones(ncon), 1, True) H = eval_h_adolc(X_init, np.ones(ncon), 1, False) g_L = np.zeros(ncon) g_U = np.zeros(ncon) nnzj = eval_jac_g_adolc.nnzj nnzh = eval_h_adolc.nnzh nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, 0, eval_f_adolc , eval_grad_f_adolc, eval_g_adolc, eval_jac_g_adolc) # nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f_adolc , # eval_grad_f_adolc, eval_g_adolc, eval_jac_g_adolc, eval_h_adolc) output, zl, zu, constraint_multipliers, obj, status = nlp.solve(X_init) output_2d = output.reshape(n, -1) output.dump(traj_filename) return output_2d, prob
def cons_opt(obj, cons, Vars, x0): """nlinprog Parameters ---------- obj : cons : Returns ------- Notes ------ """ nvars = len(Vars) x_L = np.array((pyipopt.NLP_LOWER_BOUND_INF,)*nvars) x_U = np.array((pyipopt.NLP_UPPER_BOUND_INF,)*nvars) #x_L = -20.*np.ones(nvars) #x_U = 20.*np.ones(nvars) g_L, g_U, g = [], [], [] for gc in group_cons_by_ub_lb(cons): g_L.append(gc.lb) g_U.append(gc.ub) g.append(gc.expr) ncon = len(g) g_L, g_U = np.array(g_L), np.array(g_U) eval_g = ft.partial(list2array_wrap, sym.lambdify(Vars, g)) js = jac(Vars, g) jrow, jcol, jdata = np.asarray(js.row, dtype=int), np.asarray(js.col, dtype=int), js.data eval_jac_g = ft.partial(eval_jac_cons, (jrow, jcol, sym.lambdify(Vars, jdata.tolist()))) eval_f = ft.partial(eval_expr, sym.lambdify(Vars, obj)) eval_grad_f = ft.partial(eval_grad_obj, sym.lambdify(Vars, grad(Vars, obj))) #eval_hessian_f = ft.partial(eval_expr, sym.lambdify(Vars, sym.hessian(obj, Vars))) nnzj = js.nnz nnzh = 0 if debug: for gi, lb, ub in zip(g, g_L, g_U): print('{} \in [{}, {}]'.format(gi, lb, ub)) nlp = pyipopt.create(nvars, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g) # Verbosity level \in [0, 12] nlp.int_option('print_level', print_level) nlp.num_option('constr_viol_tol', constr_viol_tol) res_x, zl, zu, constraint_multipliers, res_obj, status = nlp.solve(x0) nlp.close() if debug: def print_variable(variable_name, value): for i in xrange(len(value)): print(variable_name + "["+str(i)+"] =", value[i]) print() print("Solution of the primal variables, x") print_variable("x", res_x) print() print("Solution of the bound multipliers, z_L and z_U") print_variable("z_L", zl) print_variable("z_U", zu) print() print("Solution of the constraint multipliers, lambda") print_variable("lambda", constraint_multipliers) print() print("Objective value") print("f(x*) =", res_obj) # Return codes in IpReturnCodes_inc.h print('status:', status) return spec.OPTRES(res_obj, res_x, 'OK', status in (0, 1))
## IPOPT SOLUTION start = time.time() nvar = data.numX xl = np.zeros(data.numX) xu = 2e19*np.ones(data.numX) m = 0 gl = np.zeros(1) gu = 2e19*np.ones(1) g_L = np.array([], dtype=float) g_U = np.array([], dtype=float) nnzj = 0 nnzh = int(data.numX * (data.numX + 1) / 2) nlp = pyipopt.create(nvar, xl, xu, m, g_L, g_U, nnzj, nnzh, evaluateFunction, evaluateGradient, eval_g, eval_jac_g, evaluateHessian) nlp.num_option('tol', 1e-5) nlp.int_option("print_level", 5) nlp.str_option('hessian_approximation', 'limited-memory') nlp.str_option('mu_strategy', 'adaptive') nlp.str_option('mu_oracle', 'probing') nlp.str_option('linear_solver', 'ma97') nlp.num_option('acceptable_tol', 1e-2) nlp.int_option("acceptable_iter", 5) nlp.num_option('acceptable_obj_change_tol', 5e-1) mylines = [float(myline) for myline in [line.rstrip('\n') for line in open('/home/wilmer/Dropbox/IpOptSolver/currentIntensities.txt')]] data.currentIntensities = np.array(mylines) x, zl, zu, constraint_multipliers, obj, status = nlp.solve(data.currentIntensities) print('solved in ' + str(time.time()-start) + ' seconds') # PYTHON scipy.optimize solution
def min_ipopt(self, XP0, xtrace=None): """ Minimize f starting from XP0 using IPOPT. Returns the minimizing state, the minimum function value, and the termination information. """ if self.taped == False: self.tape_A(xtrace) #Is this time consuming - creates a new instance of the class at each call #Need to move outside this function #Or figure out how to do this WITH a function instead of a class eval_h_adolc = self.Eval_h_adolc(XP0) nnzh = eval_h_adolc.nnz #Includes NPest nvar = len(XP0) #Use bounds - Includes parameters. Does this work for time dependent parameters? x_L = np.asarray(self.bounds)[:, 0] x_U = np.asarray(self.bounds)[:, 1] ncon = 0 g_L = np.array([]) g_U = np.array([]) nnzj = 0 nlp_adolc = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, A_taped, gradA_taped, eval_g, eval_jac_g, eval_h_adolc) #Setting default settings to match minAone with adjustments nlp_adolc.num_option('tol', 1e-6) nlp_adolc.str_option('mu_strategy', 'adaptive') nlp_adolc.str_option('adaptive_mu_globalization', 'never-monotone-mode') nlp_adolc.int_option('max_iter', 1000) nlp_adolc.str_option('linear_solver', 'ma97') nlp_adolc.num_option('bound_relax_factor', 0) #IPOPT distinguishes between num, int, and str options #Only supports 3 options atm, could for loop through values with if statements... if self.opt_args is not None: if 'max_iter' in boundz: nlp_adolc.int_option('max_iter', boundz.get('max_iter')) if 'tol' in boundz: nlp_adolc.num_option('tol', boundz.get('tol')) if 'linear_solver' in boundz: nlp_adolc.str_option('linear_solver', boundz.get('linear_solver')) # start the optimization print("Beginning optimization...") tstart = time.time() XPmin, _, _, _, Amin, status = nlp_adolc.solve(XP0) #deleting objects nlp_adolc.close() del eval_h_adolc print("Optimization complete!") print("Time = {0} s".format(time.time() - tstart)) #print("Exit flag = {0}".format(status)) #print("Exit message: {0}".format(res.message)) #print("Iterations = {0}".format(res.nit)) print("Obj. function value = {0}\n".format(Amin)) return XPmin, Amin, status
def get_ipopt_options(rd, lb, ub, tol, max_iter, **kwargs): """Get options for IPOPT module (interior point algorithm) See `<https://projects.coin-or.org/Ipopt>` rd : :py:class`dolfin_adjoint.ReducedFunctional` The reduced functional lb : list Lower bound on the control ub : list Upper bound on the control tol : float Tolerance max_iter : int Maximum number of iterations *Returns* nlp : ipopt instance A nonlinear ipopt problem """ ncontrols = len(ub) nconstraints = 0 empty = np.array([], dtype=float) clb = empty cub = empty constraints_nnz = nconstraints * ncontrols # The constraint function, should do nothing def fun_g(x, user_data=None): return empty # The constraint Jacobian def jac_g(x, flag, user_data=None): if flag: rows = np.array([], dtype=int) cols = np.array([], dtype=int) return (rows, cols) else: return empty J = rd.__call__ dJ = rd.derivative nlp = pyipopt.create( ncontrols, # length of control vector lb, # lower bounds on control vector ub, # upper bounds on control vector 0, # number of constraints clb, # lower bounds on constraints, cub, # upper bounds on constraints, 0, # number of nonzeros in the constraint Jacobian 0, # number of nonzeros in the Hessian J, # to evaluate the functional dJ, # to evaluate the gradient fun_g, # to evaluate the constraints jac_g, ) # to evaluate the constraint Jacobian pyipopt.set_loglevel(1) return nlp
return j.tolist() dummyh, hrow, hcol = _amplpy.eval_H( nlp.x0, nlp.pi0, 1, 1.0 ) print hrow, hcol dummyh, hrow, hcol = nlp.hess( nlp.x0, nlp.pi0, 1.0 ) def eval_h(x, lagrange, obj_factor, flag): if flag: return (hrow.tolist(), hcol.tolist()) else: temph, dummyr, dummyc = nlp.hess(array(x), array(lagrange), obj_factor) assert len(temph) == nnzh return temph.tolist() print n, m print xl, xu print nnzj print gl, gu print x0 print eval_f(x0) print eval_grad_f(x0) print eval_g(x0) print eval_jac_g(x0, False) print eval_jac_g(x0, True) nlp = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, 0, eval_f, eval_grad_f, eval_g, eval_jac_g, ) print nlp #nlp.solve(x0)
def MCdo(b, i): user = os.path.expanduser("~") tempOut = robj.r("rm(list=ls())") tempOut = robj.r("i <- %i"%(i+1)) tempOut = robj.r("b <- %i"%(i*(1000)+(b+1) )) tempOut = robj.r("source('CMLE_unstable_support.r')") regrMat = np.array((robj.r("do.call(cbind, regr)"))) regr = OrderedDict([('SA',np.ones((regrMat.shape[0],0))),('VA',regrMat[:,0:1]),('CB',np.ones((regrMat.shape[0],0))),('barWA',regrMat[:,1:2]),('barWB',regrMat[:,2:4]),('bara',regrMat[:,4:5]),('VB',regrMat[:,5:6])]) Y = np.array((robj.r("Y"))) x0 = np.array((robj.r("unname(x0)"))) xL = np.array((robj.r("unname(xL)"))) tPL = np.array((robj.r("unname(out.2step$time )"))) def fll(x): return LL_jo(x, Y, regr) def heq(x): return const_cmle(x, Y, regr) np.random.seed(b) while np.isinf(fll(adouble(x0)).val): x0 = np.random.uniform(size=len(x0)) ccd = os.getcwd() if not os.path.exists(user + '/Documents/adolc%i_%i'%(i, b)): os.makedirs(user + '/Documents/adolc%i_%i'%(i, b)) os.chdir(user + '/Documents/adolc%i_%i'%(i, b)) adolc.trace_on(1) ax = adolc.adouble(np.zeros(len(x0))) adolc.independent(ax) ay = fll(ax) adolc.dependent(ay) adolc.trace_off() # trace constraint function adolc.trace_on(2) ax = adolc.adouble(x0) adolc.independent(ax) ay = heq(ax) adolc.dependent(ay) adolc.trace_off() npar = len(x0) def adFun(x): return adolc.function(1, x) def grFun(x): return adolc.gradient(1, x) def const_adolc(x): return adolc.function(2,x) def jac_adolc(x): return adolc.jacobian(2,x) def lagrangian(x, lagrange, obj_factor): return obj_factor*fll(x) + np.dot(lagrange, heq(x)) #Jacobian #### initalize it class jac_c_adolc: def __init__(self, x): options = None result = adolc.colpack.sparse_jac_no_repeat(2,x,options) self.nnz = result[0] self.rind = np.asarray(result[1],dtype=int) self.cind = np.asarray(result[2],dtype=int) self.values = np.asarray(result[3],dtype=float) def __call__(self, x, flag, user_data=None): if flag: return (self.rind, self.cind) else: result = adolc.colpack.sparse_jac_repeat(2, x, self.nnz, self.rind, self.cind, self.values) return result[3] ##### create the function Jac_c_adolc = jac_c_adolc(x0) ###Hessian # trace lagrangian function adolc.trace_on(3) ax = adolc.adouble(x0) adolc.independent(ax) ay = lagrangian(ax, xL, np.array([1.0])) adolc.dependent(ay) adolc.trace_off() M = Y.shape[1] nreal = npar-M given = {'rind': np.concatenate((np.kron(np.arange(nreal), np.ones(npar,dtype='int')), np.arange(nreal, npar))), 'cind': np.concatenate((np.tile(np.arange(npar), nreal), np.arange(nreal, npar)))} mask = np.where(given['rind'] <= given['cind']) given['rind'] = given['rind'][mask] given['cind'] = given['cind'][mask] def hessLag_adolc(x, lagrange, obj_factor, flag, user_data=None): if flag: result = (given['rind'], given['cind']) else: result = np.ravel(adolc.hessian(3, x)[given['rind'],given['cind']], order="C") return result H2 = hessLag_adolc(x0, xL, 1.0, False) H2a = hessLag_adolc(x0, xL, 1.0, True) nnzh = len(given['rind']) ##Optimization #PRELIMS: other things to pass to IPOPT nvar = len(x0) #number of variables in the problem x_L = np.array([-np.inf]*nvar, dtype=float) #box contraints on variables (none) x_U = np.array([np.inf]*nvar, dtype=float) #PRELIMS:define the (in)equality constraints ncon = heq(ax).shape[0] #number of constraints g_L = np.array([0]*ncon, dtype=float) #constraints are to equal 0 g_U = np.array([0]*ncon, dtype=float) #constraints are to equal 0 #PRELIMS: define the number of nonzeros in the jacobian val = Jac_c_adolc(x0, False) nnzj = len(val) # create the nonlinear programming model nlp2 = pyipopt.create( nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, adFun, grFun, const_adolc, Jac_c_adolc, hessLag_adolc ) nlp2.num_option('expect_infeasible_problem_ctol', 1e-15) nlp2.int_option('max_iter', 100) nlp2.num_option('dual_inf_tol', 1e-3) nlp2.num_option('constr_viol_tol', 1e-3) nlp2.num_option('tol', 1e-6) nlp2.int_option('print_level', 0) t1 = time() out = nlp2.solve(x0) t1 = time()-t1 t1 = t1 + tPL # free the model nlp2.close() os.chdir(ccd) shutil.rmtree(user + '/Documents/adolc%i_%i'%(i, b)) output = np.concatenate((out[0][:6], t1, np.array([out[5]]))) return output
def _minimize(self, initial_val, loss_grad_func, equality_funcs, equality_grad_funcs, inequality_funcs, inequality_grad_funcs, packed_bounds, step_callback, optimizer_kwargs): # initial value should be float64 initial_val = np.array(initial_val, dtype=np.float_) # objective function def eval_f(x, user_data=None): loss, _ = loss_grad_func(x) return np.array(loss, dtype=np.float_) # gradient of objective function def eval_grad_f(x, user_data=None): _, grad_f = loss_grad_func(x) return np.array(grad_f, dtype=np.float_) # gradient function (first inequalities then equalities) def eval_g(x, user_data=None): inequalities = [inequality_funcs[i](x) for i in range(nineqcon)] equalities = [equality_funcs[i](x) for i in range(neqcon)] return np.array(inequalities + equalities, dtype=np.float_).reshape(ncon, ) # hessian of the lagrangian (first inequalities then equalities) def eval_h(x, lagrange, obj_factor, flag, user_data=None): rows, cols = np.tril_indices(nvar) if flag: return (np.array(rows, dtype=np.int_), np.array(cols, dtype=np.int_)) else: loss = [loss_hessian_func(x)] inequalities = [inequality_hessian_funcs[i](x) for i in range(nineqcon)] equalities = [equality_hessian_funcs[i](x) for i in range(neqcon)] values = np.zeros([nvar, nvar]) values += obj_factor * loss[0][0] for idc in range(nineqcon): values += lagrange[idc] * inequalities[idc][0] for idc in range(neqcon): values += lagrange[idc + nineqcon] * equalities[idc][0] return np.array(values.reshape(nvar, nvar)[rows, cols], dtype=np.float_) # jacobian for gradient (first inequalities the equalities) def eval_jac_g(x, flag, user_data=None): rows, cols = np.indices((ncon, nvar)) if flag: return (np.array(rows.reshape(-1, 1), dtype=np.int_), np.array(cols.reshape(-1, 1), dtype=np.int_)) else: inequalities = [inequality_grad_funcs[i](x) for i in range(nineqcon)] equalities = [equality_grad_funcs[i](x) for i in range(neqcon)] values = np.empty([ncon, nvar]) for idc in range(nineqcon): values[idc, :] = inequalities[idc][0] for idc in range(neqcon): values[idc + nineqcon, :] = equalities[idc][0] return np.array(values.reshape(ncon * nvar, ), dtype=np.float_) # box constraints on the variables nvar = int(np.sum([np.prod(self._vars[i].get_shape().as_list()) for i in range(len(self._vars))])) if self._packed_bounds is None: x_L = -np.ones((nvar), dtype=np.float_) * np.inf x_U = np.ones((nvar), dtype=np.float_) * np.inf else: x_L, x_U = zip(*self._packed_bounds) x_L = np.array(x_L, dtype=np.float_) x_U = np.array(x_U, dtype=np.float_) # inequality constraints as g(x)>=0 and equality constraints as h(x)=0 nineqcon = len(self._inequalities) neqcon = len(self._equalities) ncon = nineqcon + neqcon g_L_ineq = np.zeros((nineqcon), dtype=np.float_) g_U_ineq = np.ones((nineqcon), dtype=np.float_) * 2.0 * pow(10.0, 19) g_L_eq = np.zeros((neqcon), dtype=np.float_) g_U_eq = np.zeros((neqcon), dtype=np.float_) g_L = np.concatenate((g_L_ineq, g_L_eq), axis=0) g_U = np.concatenate((g_U_ineq, g_U_eq), axis=0) nnzj = nvar * ncon nnzh = int(nvar * (nvar + 1) / 2) minimize_args = [nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g] # create nlp in ipopt import pyipopt # log_level decides if logs from pyipopt are desired -- these are logs on # top of what is returned from ipopt set by "print_level"; see below if "log_level" in optimizer_kwargs["options"]: pyipopt.set_loglevel(optimizer_kwargs["options"]["log_level"]) nlp = pyipopt.create(*minimize_args) # check https://www.coin-or.org/Ipopt/documentation/node40.html # for more options and default settings # default print_level=5 # default max_iter=3000 # default tol=1e-8 for optvar in optimizer_kwargs["options"]: if optvar is "log_level": print elif type(optimizer_kwargs["options"][optvar]) is np.str: nlp.str_option(optvar, optimizer_kwargs["options"][optvar]) elif type(optimizer_kwargs["options"][optvar]) is np.int: nlp.int_option(optvar, optimizer_kwargs["options"][optvar]) else: nlp.num_option(optvar, optimizer_kwargs["options"][optvar]) result_x, zl, zu, constraint_multipliers, result_f, status = nlp.solve(initial_val) nlp.close() message_lines = [ 'Optimization terminated with:', ' Message: %s', ' Objective function value: %f', ] message_args = [status, result_f] logging.info('\n'.join(message_lines), *message_args) print("Optimization terminated with message: {}".format(status)) return result_x
def test_ipopt_optimization(): """ This test checks 1. the sparse functionality of pyadolc 2. the execution speed compared to the direct sparse computation 3. run the optimization with the derivatives provided by pyadolc IPOPT is an interior point algorithm to solve min f(x) x in R^n s.t. g_L <= g(x) <= g_U x_L <= x <= x_U """ try: import pyipopt except: #print '"pyipopt is not installed, skipping test' #return raise NotImplementedError("pyipopt is not installed, skipping test") import time nvar = 4 x_L = numpy.ones((nvar), dtype=numpy.float_) * 1.0 x_U = numpy.ones((nvar), dtype=numpy.float_) * 5.0 ncon = 2 g_L = numpy.array([25.0, 40.0]) g_U = numpy.array([2.0*pow(10.0, 19), 40.0]) def eval_f(x, user_data = None): assert len(x) == 4 return x[0] * x[3] * (x[0] + x[1] + x[2]) + x[2] def eval_grad_f(x, user_data = None): assert len(x) == 4 grad_f = numpy.array([ x[0] * x[3] + x[3] * (x[0] + x[1] + x[2]) , x[0] * x[3], x[0] * x[3] + 1.0, x[0] * (x[0] + x[1] + x[2]) ]) return grad_f; def eval_g(x, user_data= None): assert len(x) == 4 return numpy.array([ x[0] * x[1] * x[2] * x[3], x[0]*x[0] + x[1]*x[1] + x[2]*x[2] + x[3]*x[3] ]) nnzj = 8 def eval_jac_g(x, flag, user_data = None): if flag: return (numpy.array([0, 0, 0, 0, 1, 1, 1, 1]), numpy.array([0, 1, 2, 3, 0, 1, 2, 3])) else: assert len(x) == 4 return numpy.array([ x[1]*x[2]*x[3], x[0]*x[2]*x[3], x[0]*x[1]*x[3], x[0]*x[1]*x[2], 2.0*x[0], 2.0*x[1], 2.0*x[2], 2.0*x[3] ]) nnzh = 10 def eval_h(x, lagrange, obj_factor, flag, user_data = None): if flag: hrow = [0, 1, 1, 2, 2, 2, 3, 3, 3, 3] hcol = [0, 0, 1, 0, 1, 2, 0, 1, 2, 3] return (numpy.array(hcol,dtype=int), numpy.array(hrow,dtype=int)) else: values = numpy.zeros((10), numpy.float_) values[0] = obj_factor * (2*x[3]) values[1] = obj_factor * (x[3]) values[2] = 0 values[3] = obj_factor * (x[3]) values[4] = 0 values[5] = 0 values[6] = obj_factor * (2*x[0] + x[1] + x[2]) values[7] = obj_factor * (x[0]) values[8] = obj_factor * (x[0]) values[9] = 0 values[1] += lagrange[0] * (x[2] * x[3]) values[3] += lagrange[0] * (x[1] * x[3]) values[4] += lagrange[0] * (x[0] * x[3]) values[6] += lagrange[0] * (x[1] * x[2]) values[7] += lagrange[0] * (x[0] * x[2]) values[8] += lagrange[0] * (x[0] * x[1]) values[0] += lagrange[1] * 2 values[2] += lagrange[1] * 2 values[5] += lagrange[1] * 2 values[9] += lagrange[1] * 2 return values def apply_new(x): return True x0 = numpy.array([1.0, 5.0, 5.0, 1.0]) pi0 = numpy.array([1.0, 1.0]) # check that adolc gives the same answers as derivatives calculated by hand trace_on(1) ax = adouble(x0) independent(ax) ay = eval_f(ax) dependent(ay) trace_off() trace_on(2) ax = adouble(x0) independent(ax) ay = eval_g(ax) dependent(ay) trace_off() trace_on(3) ax = adouble(x0) independent(ax) ay = eval_g(ax) dependent(ay[0]) trace_off() trace_on(4) ax = adouble(x0) independent(ax) ay = eval_g(ax) dependent(ay[1]) trace_off() def eval_f_adolc(x, user_data = None): return function(1,x)[0] def eval_grad_f_adolc(x, user_data = None): return gradient(1,x) def eval_g_adolc(x, user_data= None): return function(2,x) def eval_jac_g_adolc(x, flag, user_data = None): options = numpy.array([1,1,0,0],dtype=int) result = sparse.sparse_jac_no_repeat(2,x,options) if flag: return (numpy.asarray(result[1],dtype=int), numpy.asarray(result[2],dtype=int)) else: return result[3] def eval_h_adolc(x, lagrange, obj_factor, flag, user_data = None): options = numpy.array([0,0],dtype=int) assert numpy.ndim(x) == 1 assert numpy.size(x) == 4 result_f = sparse.sparse_hess_no_repeat(1, x, options) result_g0 = sparse.sparse_hess_no_repeat(3, x,options) result_g1 = sparse.sparse_hess_no_repeat(4, x,options) Hf = scipy.sparse.coo_matrix( (result_f[3], (result_f[1], result_f[2])), shape=(4, 4)) Hg0 = scipy.sparse.coo_matrix( (result_g0[3], (result_g0[1], result_g0[2])), shape=(4, 4)) Hg1 = scipy.sparse.coo_matrix( (result_g1[3], (result_g1[1], result_g1[2])), shape=(4, 4)) H = Hf + Hg0 + Hg1 H = H.tocoo() if flag: hrow = H.row hcol = H.col return (numpy.array(hcol,dtype=int), numpy.array(hrow,dtype=int)) else: values = numpy.zeros((10), float) values[:] = H.data return values # function of f assert_almost_equal(eval_f(x0), eval_f_adolc(x0)) # gradient of f assert_array_almost_equal(eval_grad_f(x0), eval_grad_f_adolc(x0)) # function of g assert_array_almost_equal(eval_g(x0), function(2,x0)) # sparse jacobian of g assert_array_equal(eval_jac_g_adolc(x0,True)[0], eval_jac_g(x0,True)[0]) assert_array_equal(eval_jac_g_adolc(x0,True)[1], eval_jac_g(x0,True)[1]) assert_array_equal(eval_jac_g_adolc(x0,False), eval_jac_g(x0,False)) # sparse hessian of the lagrangian lagrange = numpy.ones(2,dtype=float) obj_factor = 1. x0 = numpy.random.rand(4) result = (eval_h(x0, lagrange, obj_factor, False), eval_h(x0, lagrange, obj_factor, True)) result_adolc = (eval_h_adolc(x0, lagrange, obj_factor, False), eval_h_adolc(x0, lagrange, obj_factor, True)) H = scipy.sparse.coo_matrix( result, shape=(4, 4)) H_adolc = scipy.sparse.coo_matrix( result_adolc, shape=(4, 4)) H = H.todense() H_adolc = H_adolc.todense() assert_array_almost_equal( H, H_adolc.T) # test optimization with PYIPOPT nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, eval_h) start_time = time.time() result = nlp.solve(x0) end_time = time.time() nlp.close() pure_python_optimization_time = end_time - start_time nlp_adolc = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f_adolc, eval_grad_f_adolc, eval_g_adolc, eval_jac_g_adolc, eval_h_adolc) start_time = time.time() result_adolc = nlp_adolc.solve(x0) end_time = time.time() nlp_adolc.close() adolc_optimization_time = end_time - start_time print 'optimization time with derivatives computed by adolc = ', adolc_optimization_time print 'optimization time with derivatives computed by hand = ',pure_python_optimization_time assert adolc_optimization_time / pure_python_optimization_time < 10 # this works with the pyipopt version from code.google.com assert_array_almost_equal(result[0], result_adolc[0]) assert_array_almost_equal(result[1], result_adolc[1]) assert_array_almost_equal(result[2], result_adolc[2]) assert_array_almost_equal(result[3], result_adolc[3])
print eval_f(x0) assert len(eval_grad_f(x0)) == n print eval_grad_f(x0) assert len(eval_g(x0)) == m a = eval_jac_g(x0, True) print "row, col ", a[0], a[1] print eval_jac_g(x0, False) print eval_h(True, True, True, True) print eval_h(nlp.x0, nlp.pi0, 1.0, True) def gf2(x, data = None): return array([0.0 for i in xrange(m)]) def f2(x, data = None): return 0 """ print "Solving problem with approximate hession calculation now" problem = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, 0, eval_f, eval_grad_f, eval_g, eval_jac_g) problem.solve(x0) problem.close() print "Solving problem with exact hession calculation now" mynlp = pyipopt.create(n, xl, xu, m, gl, gu, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, eval_h, applynew) mynlp.solve(x0) mynlp.close()
def Ipopt_Solve(problem): """Solves a Nexus optimization problem using ipopt Assumptions: You can actually install ipopt on your machine Source: N/A Inputs: problem [nexus()] Outputs: result [array] Properties Used: None """ # Pull out the basic problem inp = problem.optimization_problem.inputs obj = problem.optimization_problem.objective con = problem.optimization_problem.constraints # Number of input variables and constrains nvar = len(inp) ncon = len(con) # Set inputs ini = inp[:,1] # Initials bnd = inp[:,2] # Bounds scl = inp[:,3] # Scale # Scaled initials x0 = ini/scl x0 = x0.astype(float) # Nonzero jacobians and hessians, fix this nnzj = ncon*nvar nnzh = nvar*nvar # Bounds for inputs and constraints flbd = np.zeros_like(ini) fubd = np.zeros_like(ini) for ii in xrange(0,nvar): flbd[ii] = (bnd[ii][0]/scl[ii]) fubd[ii] = (bnd[ii][1]/scl[ii]) g_L = np.zeros_like(con) g_U = np.zeros_like(con) # Setup constraints for ii in xrange(0,len(con)): name = con[ii][0] edge = con[ii][2] if con[ii][1]=='<': g_L[ii] = -np.inf g_U[ii] = edge elif con[ii][1]=='>': g_L[ii] = edge g_U[ii] = np.inf elif con[ii][1]=='=': g_L[ii] = edge g_U[ii] = edge # Instantiate the problem and set objective import pyipopt #import down here to allow SUAVE to run without the user having Ipopt flbd = flbd.astype(float) fubd = fubd.astype(float) g_L = g_L.astype(float) g_U = g_U.astype(float) # Create the problem nlp = pyipopt.create(nvar, flbd, fubd, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g) nlp.str_option('derivative_test_print_all','yes') nlp.str_option('derivative_test','first-order') # Solve the problem result = nlp.solve(x0,problem) nlp.close() return result
## IPOPT SOLUTION start = time.time() nvar = data.numX xl = np.zeros(data.numX) xu = 2e19 * np.ones(data.numX) m = 0 gl = np.zeros(1) gu = 2e19 * np.ones(1) g_L = np.array([], dtype=float) g_U = np.array([], dtype=float) nnzj = 0 nnzh = int(data.numX * (data.numX + 1) / 2) nlp = pyipopt.create(nvar, xl, xu, m, g_L, g_U, nnzj, nnzh, evaluateFunction, evaluateGradient, eval_g, eval_jac_g, evaluateHessian) nlp.num_option('tol', 1e-5) nlp.int_option("print_level", 5) nlp.str_option('hessian_approximation', 'limited-memory') nlp.str_option('mu_strategy', 'adaptive') nlp.str_option('mu_oracle', 'probing') nlp.str_option('linear_solver', 'ma97') nlp.num_option('acceptable_tol', 1e-2) nlp.int_option("acceptable_iter", 5) nlp.num_option('acceptable_obj_change_tol', 5e-1) mylines = [ float(myline) for myline in [ line.rstrip('\n') for line in open( '/home/wilmer/Dropbox/IpOptSolver/currentIntensities.txt') ] ]
# sparse jacobian of g assert_array_equal(eval_jac_g_adolc(x0, True)[0], eval_jac_g(x0, True)[0]) assert_array_equal(eval_jac_g_adolc(x0, True)[1], eval_jac_g(x0, True)[1]) assert_array_equal(eval_jac_g_adolc(x0, False), eval_jac_g(x0, False)) # test optimization with PYIPOPT nvar = 4 x_L = numpy.ones((nvar), dtype=numpy.float_) * 1.0 x_U = numpy.ones((nvar), dtype=numpy.float_) * 5.0 ncon = 2 g_L = numpy.array([25.0, 40.0]) g_U = numpy.array([2.0 * pow(10.0, 19), 40.0]) nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, eval_h) start_time = time.time() result = nlp.solve(x0) end_time = time.time() nlp.close() pure_python_optimization_time = end_time - start_time nlp_adolc = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f_adolc, eval_grad_f_adolc, eval_g_adolc, eval_jac_g_adolc, eval_h_adolc) start_time = time.time() result_adolc = nlp_adolc.solve(x0) end_time = time.time() nlp_adolc.close()
def Ipopt_Solve(problem): """Solves a Nexus optimization problem using ipopt Assumptions: You can actually install ipopt on your machine Source: N/A Inputs: problem [nexus()] Outputs: result [array] Properties Used: None """ # Pull out the basic problem inp = problem.optimization_problem.inputs obj = problem.optimization_problem.objective con = problem.optimization_problem.constraints # Number of input variables and constrains nvar = len(inp) ncon = len(con) # Set inputs ini = inp[:, 1] # Initials bndl = inp[:, 2] # Bounds bndu = inp[:, 3] # Bounds scl = inp[:, 4] # Scale # Scaled initials x0 = ini / scl x0 = x0.astype(float) # Nonzero jacobians and hessians, fix this nnzj = ncon * nvar nnzh = nvar * nvar # Bounds for inputs and constraints flbd = np.zeros_like(ini) fubd = np.zeros_like(ini) for ii in range(0, nvar): flbd[ii] = (bndl[ii] / scl[ii]) fubd[ii] = (bndu[ii] / scl[ii]) g_L = np.zeros_like(con) g_U = np.zeros_like(con) # Setup constraints for ii in range(0, len(con)): name = con[ii][0] edge = con[ii][2] if con[ii][1] == '<': g_L[ii] = -np.inf g_U[ii] = edge elif con[ii][1] == '>': g_L[ii] = edge g_U[ii] = np.inf elif con[ii][1] == '=': g_L[ii] = edge g_U[ii] = edge # Instantiate the problem and set objective import pyipopt #import down here to allow SUAVE to run without the user having Ipopt flbd = flbd.astype(float) fubd = fubd.astype(float) g_L = g_L.astype(float) g_U = g_U.astype(float) # Create the problem nlp = pyipopt.create(nvar, flbd, fubd, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g) nlp.str_option('derivative_test_print_all', 'yes') nlp.str_option('derivative_test', 'first-order') # Solve the problem result = nlp.solve(x0, problem) nlp.close() return result
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, x0=None, options={}): """Solve the nonlinear problem from a specified starting point. Arguments: x0 -- array of length self.nvars with initial guesses for values of self.variables (in that order), or a scalar to be used as the initial guess for all variables; if not supplied, all variables will be set initially to 1.0. options -- dictionary {'option': value} of options to pass to IPOPT. Options will be taken from (in increasing order of priority) IPOPT's default values, the module-wide default_ipopt_options, those specified in self.fixed_variable_treatment or self.ipopt_options, this argument, or the ipopt.opt file (if any) in the working directory. Errors will result if invalid names or values for options are given here. Returns: x -- array of variable values returned by IPOPT (ordered as in self.variables) Also sets self.x, self.zl, self.zu, self.constraint_multipliers, self.obj_value, and self.status to x, the lower and upper bound multipliers, the Lagrange multipliers associated with the constraint functions, the final objective function value, and the optimzation status, respectively, and sets self.soln to a dictionary mapping each variable key to its value in self.x. This method does not recompile the objective, constraint and derivative functions if self.compile() has already been called. If anything except bounds on variables, bounds on constraints, and/or parameter values has been changed since the last time self.compile() has been called, self.compile must be called again before solving, or this method will attempt to solve an out-of-date version of the problem. Each call to solve does create a new pyipopt problem instance as self.nlp, closing the old one beforehand if self.active_nlp is true, and resetting self.active_nlp to true afterwards. """ if not self._compiled: self.compile() if x0 is None: x0 = np.ones(self.nvar) elif np.isscalar(x0): x0 = x0 * np.ones(self.nvar) else: # Assume this is a vector. Check its length, as trying to # proceed with an inappropriately sized starting point may # lead to crashes. if len(x0) != self.nvar: message = ( 'Starting point has wrong dimension (needed %d, given %d)' % (self.nvar, len(x0))) raise ValueError(message) self.close_nlp() x_L, x_U = self.make_variable_bound_vectors() g_L, g_U = self.make_constraint_bound_vectors() # The following avoids a segmentation fault that results # when bound methods are supplied as evaluation functions # to pyipopt, which I don't really understand: eval_f = lambda x, user_data=None: self.eval_f(x) eval_grad_f = lambda x, user_data=None: self.eval_grad_f(x) eval_g = lambda x, user_data=None: self.eval_g(x) eval_jac_g = lambda x, flag, user_data=None: self.eval_jac_g(x, flag) eval_h= lambda x, lagrange, obj_factor, flag, user_data=None: \ self.eval_h(x,lagrange,obj_factor,flag) self.nlp = pyipopt.create(self.nvar, x_L, x_U, self.ncon, g_L, g_U, self._nnzj, self._nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, eval_h) self.active_nlp = True # Handle generic IPOPT options all_options = {} all_options.update(default_ipopt_options) all_options['fixed_variable_treatment'] = self.fixed_variable_treatment all_options.update(self.ipopt_options) all_options.update(options) for option, value in all_options.iteritems(): if isinstance(value, str): self.nlp.str_option(option, value) elif isinstance(value, int): self.nlp.int_option(option, value) else: self.nlp.num_option(option, value) (self.x, self.zl, self.zu, self.constraint_multipliers, self.obj_value, self.status) = self.nlp.solve(x0) self.soln = dict(zip(self.variables, self.x)) if self.status not in (0, 1): raise OptimizationFailure('IPOPT exited with status %d' % self.status) return self.x.copy()
# sparse jacobian of g assert_array_equal(eval_jac_g_adolc(x0, True)[0], eval_jac_g(x0, True)[0]) assert_array_equal(eval_jac_g_adolc(x0, True)[1], eval_jac_g(x0, True)[1]) assert_array_equal(eval_jac_g_adolc(x0, False), eval_jac_g(x0, False)) # test optimization with PYIPOPT nvar = 4 x_L = numpy.ones((nvar), dtype=numpy.float_) * 1.0 x_U = numpy.ones((nvar), dtype=numpy.float_) * 5.0 ncon = 2 g_L = numpy.array([25.0, 40.0]) g_U = numpy.array([2.0 * pow(10.0, 19), 40.0]) nlp = pyipopt.create(nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, eval_f, eval_grad_f, eval_g, eval_jac_g, eval_h) start_time = time.time() result = nlp.solve(x0) end_time = time.time() nlp.close() pure_python_optimization_time = end_time - start_time nlp_adolc = pyipopt.create( nvar, x_L, x_U, ncon, g_L, g_U, nnzj,
#PRELIMS: define the number of nonzeros in the jacobian val = Jac_c_adolc(x0, False) nnzj = len(val) # create the nonlinear programming model nlp2 = pyipopt.create( nvar, x_L, x_U, ncon, g_L, g_U, nnzj, nnzh, adFun, grFun, const_adolc, Jac_c_adolc, hessLag_adolc ) nlp2.num_option('expect_infeasible_problem_ctol', 1e-15) nlp2.int_option('max_iter', 5000) nlp2.num_option('dual_inf_tol', 1e-5) nlp2.num_option('constr_viol_tol', 1e-5) nlp2.num_option('tol', 1e-6)
def solve(self): """ Solves AC optimal power flow. """ case = self.om.case base_mva = case.base_mva # TODO: Explain this value. self.opt["cost_mult"] = 1e-4 # Unpack the OPF model. bs, ln, gn, _ = self._unpack_model(self.om) # Compute problem dimensions. ipol, _, nb, nl, _, ny, nxyz = self._dimension_data(bs, ln, gn) # Compute problem dimensions. ng = len(gn) # gpol = [g for g in gn if g.pcost_model == POLYNOMIAL] # Indexes of constrained lines. il = array([i for i,l in enumerate(ln) if 0.0 < l.rate_a < 1e10]) nl2 = len(il) # Linear constraints (l <= A*x <= u). A, l, u = self.om.linear_constraints() # AA, bb = self._linear_constraints(self.om) _, xmin, xmax = self._var_bounds() # Select an interior initial point for interior point solver. x0 = self._initial_interior_point(bs, gn, xmin, xmax, ny) # Build admittance matrices. Ybus, Yf, Yt = case.Y # Optimisation variables. Va = self.om.get_var("Va") Vm = self.om.get_var("Vm") Pg = self.om.get_var("Pg") Qg = self.om.get_var("Qg") # Adds a constraint on the reference bus angles. # xmin, xmax = self._ref_bus_angle_constraint(bs, Va, xmin, xmax) def f_fcn(x, user_data=None): """ Evaluates the objective function. """ p_gen = x[Pg.i1:Pg.iN + 1] # Active generation in p.u. q_gen = x[Qg.i1:Qg.iN + 1] # Reactive generation in p.u. # Polynomial cost of P and Q. xx = r_[p_gen, q_gen] * base_mva if len(ipol) > 0: f = sum([g.total_cost(xx[i]) for i,g in enumerate(gn)]) else: f = 0 # Piecewise linear cost of P and Q. if ny: y = self.om.get_var("y") ccost = csr_matrix((ones(ny), (range(y.i1, y.iN + 1), zeros(ny))), shape=(nxyz, 1)).T f = f + ccost * x else: ccost = zeros((1, nxyz)) # TODO: Generalised cost term. return f def df_fcn(x, usr_data=None): """ Calculates gradient of the objective function. """ p_gen = x[Pg.i1:Pg.iN + 1] # Active generation in p.u. q_gen = x[Qg.i1:Qg.iN + 1] # Reactive generation in p.u. xx = r_[p_gen, q_gen] * base_mva if ny > 0: y = self.om.get_var("y") iy = range(y.i1, y.iN + 1) ccost = \ csr_matrix((ones(ny), (iy, zeros(ny))), shape=(nxyz, 1)).T else: ccost = zeros((1, nxyz)) # TODO: Generalised cost term. iPg = range(Pg.i1, Pg.iN + 1) iQg = range(Qg.i1, Qg.iN + 1) # Polynomial cost of P and Q. df_dPgQg = zeros((2 * ng, 1)) # w.r.t p.u. Pg and Qg # df_dPgQg[ipol] = matrix([g.poly_cost(xx[i], 1) for g in gpol]) # for i, g in enumerate(gn): # der = polyder(list(g.p_cost)) # df_dPgQg[i] = polyval(der, xx[i]) * base_mva for i in ipol: df_dPgQg[i] = \ base_mva * polyval(polyder(list(gn[i].p_cost)), xx[i]) df = zeros((nxyz, 1)) df[iPg] = df_dPgQg[:ng] df[iQg] = df_dPgQg[ng:ng + ng] # Piecewise linear cost of P and Q. df = df + ccost.T # TODO: Generalised cost term. return asarray(df).flatten() def g_fcn(x, usr_data=None): """ Evaluates the non-linear constraint values. """ Pgen = x[Pg.i1:Pg.iN + 1] # Active generation in p.u. Qgen = x[Qg.i1:Qg.iN + 1] # Reactive generation in p.u. for i, g in enumerate(gn): g.p = Pgen[i] * base_mva # active generation in MW g.q = Qgen[i] * base_mva # reactive generation in MVAr # Rebuild the net complex bus power injection vector in p.u. Sbus = case.getSbus(bs) Vang = x[Va.i1:Va.iN + 1] Vmag = x[Vm.i1:Vm.iN + 1] V = Vmag * exp(1j * Vang) # Evaluate the power flow equations. mis = V * conj(Ybus * V) - Sbus # Equality constraints (power flow). g = r_[mis.real, # active power mismatch for all buses mis.imag] # reactive power mismatch for all buses # Inequality constraints (branch flow limits). # (line constraint is actually on square of limit) flow_max = array([(l.rate_a / base_mva)**2 for l in ln]) # FIXME: There must be a more elegant method for this. for i, v in enumerate(flow_max): if v == 0.0: flow_max[i] = Inf if self.flow_lim == IFLOW: If = Yf * V It = Yt * V # Branch current limits. h = r_[(If * conj(If)) - flow_max, (If * conj(It)) - flow_max] else: i_fbus = [e.from_bus._i for e in ln] i_tbus = [e.to_bus._i for e in ln] # Complex power injected at "from" bus (p.u.). Sf = V[i_fbus] * conj(Yf * V) # Complex power injected at "to" bus (p.u.). St = V[i_tbus] * conj(Yt * V) if self.flow_lim == PFLOW: # active power limit, P (Pan Wei) # Branch real power limits. h = r_[Sf.real()**2 - flow_max, St.real()**2 - flow_max] elif self.flow_lim == SFLOW: # apparent power limit, |S| # Branch apparent power limits. h = r_[(Sf * conj(Sf)) - flow_max, (St * conj(St)) - flow_max].real else: raise ValueError return r_[g, h] def dg_fcn(x, flag, usr_data=None): """ Calculates the Jacobian matrix. It takes two arguments, the first is the variable x and the second is a Boolean flag. If the flag is true, the function returns a tuple of arrays (row, col) to indicate the sparse structure of the Jacobian matrix. If the flag is false the function returns the values of the Jacobian matrix with length nnzj. """ iVa = range(Va.i1, Va.iN + 1) iVm = range(Vm.i1, Vm.iN + 1) iPg = range(Pg.i1, Pg.iN + 1) iQg = range(Qg.i1, Qg.iN + 1) iVaVmPgQg = r_[iVa, iVm, iPg, iQg].T Vang = x[Va.i1:Va.iN + 1] Vmag = x[Vm.i1:Vm.iN + 1] V = Vmag * exp(1j * Vang) # Compute partials of injected bus powers. dSbus_dVm, dSbus_dVa = case.dSbus_dV(Ybus, V) i_gbus = [gen.bus._i for gen in gn] neg_Cg = csr_matrix((-ones(ng), (i_gbus, range(ng))), (nb, ng)) # Transposed Jacobian of the power balance equality constraints. dg = lil_matrix((nxyz, 2 * nb)) blank = csr_matrix((nb, ng)) dg[iVaVmPgQg, :] = vstack([ hstack([dSbus_dVa.real, dSbus_dVm.real, neg_Cg, blank]), hstack([dSbus_dVa.imag, dSbus_dVm.imag, blank, neg_Cg]) ], "csr").T # Compute partials of flows w.r.t V. if self.flow_lim == IFLOW: dFf_dVa, dFf_dVm, dFt_dVa, dFt_dVm, Ff, Ft = \ case.dIbr_dV(Yf, Yt, V) else: dFf_dVa, dFf_dVm, dFt_dVa, dFt_dVm, Ff, Ft = \ case.dSbr_dV(Yf, Yt, V, bs, ln) if self.flow_lim == PFLOW: dFf_dVa = dFf_dVa.real dFf_dVm = dFf_dVm.real dFt_dVa = dFt_dVa.real dFt_dVm = dFt_dVm.real Ff = Ff.real Ft = Ft.real # Squared magnitude of flow (complex power, current or real power). df_dVa, df_dVm, dt_dVa, dt_dVm = \ case.dAbr_dV(dFf_dVa, dFf_dVm, dFt_dVa, dFt_dVm, Ff, Ft) # Construct Jacobian of inequality constraints (branch limits) and # transpose it. dh = lil_matrix((nxyz, 2 * nl)) dh[r_[iVa, iVm].T, :] = vstack([hstack([df_dVa, df_dVm]), hstack([dt_dVa, dt_dVm])], "csr").T J = vstack([dg, dh, A]).tocoo() if flag: return (J.row, J.col) else: return J.data def h_fcn(x, lagrange, obj_factor, flag, usr_data=None): """ Evaluates the Hessian of the Lagrangian. """ neqnln = 2 * nb niqnln = 2 * len(il) # no. of lines with constraints Pgen = x[Pg.i1:Pg.iN + 1] # Active generation in p.u. Qgen = x[Qg.i1:Qg.iN + 1] # Reactive generation in p.u. for i, g in enumerate(gn): g.p = Pgen[i] * base_mva # active generation in MW g.q = Qgen[i] * base_mva # reactive generation in MVAr Vang = x[Va.i1:Va.iN + 1] Vmag = x[Vm.i1:Vm.iN + 1] V = Vmag * exp(1j * Vang) nxtra = nxyz - 2 * nb #------------------------------------------------------------------ # Evaluate d2f. #------------------------------------------------------------------ d2f_dPg2 = lil_matrix((ng, 1)) # w.r.t p.u. Pg d2f_dQg2 = lil_matrix((ng, 1)) # w.r.t p.u. Qg] for i in ipol: d2f_dPg2[i, 0] = polyval(polyder(list(gn[i].p_cost), 2), Pg.v0[i] * base_mva) * base_mva**2 # for i in ipol: # d2f_dQg2[i] = polyval(polyder(list(gn[i].p_cost), 2), # Qg.v0[i] * base_mva) * base_mva**2 i = r_[range(Pg.i1, Pg.iN + 1), range(Qg.i1, Qg.iN + 1)] d2f = csr_matrix((vstack([d2f_dPg2, d2f_dQg2]).toarray().flatten(), (i, i)), shape=(nxyz, nxyz)) # TODO: Generalised cost model. d2f = d2f * self.opt["cost_mult"] #------------------------------------------------------------------ # Evaluate Hessian of power balance constraints. #------------------------------------------------------------------ eqnonlin = lagrange[:neqnln] # nlam = len(lagrange["eqnonlin"]) / 2 nlam = len(eqnonlin) / 2 lamP = eqnonlin[:nlam] lamQ = eqnonlin[nlam:nlam + nlam] Gpaa, Gpav, Gpva, Gpvv = case.d2Sbus_dV2(Ybus, V, lamP) Gqaa, Gqav, Gqva, Gqvv = case.d2Sbus_dV2(Ybus, V, lamQ) d2G = vstack([ hstack([ vstack([hstack([Gpaa, Gpav]), hstack([Gpva, Gpvv])]).real + vstack([hstack([Gqaa, Gqav]), hstack([Gqva, Gqvv])]).imag, csr_matrix((2 * nb, nxtra))]), hstack([ csr_matrix((nxtra, 2 * nb)), csr_matrix((nxtra, nxtra)) ]) ], "csr") #------------------------------------------------------------------ # Evaluate Hessian of flow constraints. #------------------------------------------------------------------ ineqnonlin = lagrange[neqnln:neqnln + niqnln] nmu = len(ineqnonlin) / 2 muF = ineqnonlin[:nmu] muT = ineqnonlin[nmu:nmu + nmu] if self.flow_lim == "I": dIf_dVa, dIf_dVm, dIt_dVa, dIt_dVm, If, It = \ case.dIbr_dV(Yf, Yt, V) Hfaa, Hfav, Hfva, Hfvv = \ case.d2AIbr_dV2(dIf_dVa, dIf_dVm, If, Yf, V, muF) Htaa, Htav, Htva, Htvv = \ case.d2AIbr_dV2(dIt_dVa, dIt_dVm, It, Yt, V, muT) else: f = [e.from_bus._i for e in ln] t = [e.to_bus._i for e in ln] # Line-bus connection matrices. Cf = csr_matrix((ones(nl), (range(nl), f)), (nl, nb)) Ct = csr_matrix((ones(nl), (range(nl), t)), (nl, nb)) dSf_dVa, dSf_dVm, dSt_dVa, dSt_dVm, Sf, St = \ case.dSbr_dV(Yf, Yt, V) if self.flow_lim == PFLOW: Hfaa, Hfav, Hfva, Hfvv = \ case.d2ASbr_dV2(dSf_dVa.real(), dSf_dVm.real(), Sf.real(), Cf, Yf, V, muF) Htaa, Htav, Htva, Htvv = \ case.d2ASbr_dV2(dSt_dVa.real(), dSt_dVm.real(), St.real(), Ct, Yt, V, muT) elif self.flow_lim == SFLOW: Hfaa, Hfav, Hfva, Hfvv = \ case.d2ASbr_dV2(dSf_dVa, dSf_dVm, Sf, Cf, Yf, V, muF) Htaa, Htav, Htva, Htvv = \ case.d2ASbr_dV2(dSt_dVa, dSt_dVm, St, Ct, Yt, V, muT) else: raise ValueError d2H = vstack([ hstack([ vstack([hstack([Hfaa, Hfav]), hstack([Hfva, Hfvv])]) + vstack([hstack([Htaa, Htav]), hstack([Htva, Htvv])]), csr_matrix((2 * nb, nxtra)) ]), hstack([ csr_matrix((nxtra, 2 * nb)), csr_matrix((nxtra, nxtra)) ]) ], "csr") H = d2f + d2G + d2H if flag: return (H.row, H.col) else: return H.data n = len(x0) # the number of variables gl = r_[zeros(2 * nb), -Inf * ones(2 * nl2), l] gu = r_[zeros(2 * nb), zeros(2 * nl2), u] m = len(gl) # the number of constraints nnzj = 0 # the number of nonzeros in Jacobian matrix nnzh = 0 # the number of non-zeros in Hessian matrix nlp = pyipopt.create(n, xmin, xmax, m, gl, gu, nnzj, nnzh, f_fcn, df_fcn, g_fcn, dg_fcn, h_fcn) # x, zl, zu, obj = nlp.solve(x0) success = nlp.solve(x0) nlp.close() print "Success:", success print "Solution of the primal variables, x" # print x print "Solution of the bound multipliers, z_L and z_U" # print zl, zu print "Objective value"