def wls_fit(function, initial_guess, X, Y, weights=None, lb=None, ub=None): """[Inputs] function is of form: def function(coeffs, xdata) """ if weights is None: weights = [1] * len(X) def penalty(c): fit = function(c, X) error = (weights * (Y - fit) ** 2).sum() return error problem = NLP(penalty, initial_guess) if lb is not None: problem.lb = lb if ub is not None: problem.ub = ub solver = 'ipopt' result = problem.solve(solver) coeffs = result.xf return coeffs
def _min(self, func, x0, *args, **kwargs): if _USE_OPENOPT: if 'solver' in kwargs: solver = kwargs['solver'] del kwargs['solver'] else: solver = 'ralg' if 'df' in kwargs: df = kwargs['df'] del kwargs['df'] else: df = self._diff p = NLP( func, x0, args=( self.mx, self.my, self.size), df=df, **kwargs) z = p.solve(solver) return z.xf, z.ff, z.istop > 0, z.msg else: a = minimize( func, x0, args=( self.mx, self.my, self.size), *args, **kwargs) return a.x, a.fun, a.success, a.message
def openopt(self, *args, **kwargs): from openopt import NLP if 'plotting' in kwargs: plotting = True kwargs.pop('plotting') else: plotting = False try: solver = args[0] except: solver = 'ralg' self.args += args[1:] self.kwargs.update(kwargs) f = lambda p: sum(((self.func(p, self.x, self.const,self.mima) - self.y) / self.weights)**2) self.prob = NLP(f, x0 = self.p0, *self.args, **self.kwargs) self.res = self.prob.solve(solver) self.p = self.res.xf if plotting: self.plot(self.xdata, self.ydata, 'o', label = 'original data') self.plot(self.x, self.y, '+') self.plot(self.xdata, self.func(self.p, self.xdata,self.const,self.mima), label = 'fit with openopt:\n solver: '+ solver)
def garchfit(self,initvalue): """ estimate GARCH(1,1) paramters by maximum likelihood method. Optimization should be under the following constraints: ARCH + GARCH < 1 (Stationarity) All parameters >= 0 (Non-negative) ------------------------------------------------------------------------- InitValue = [ARCH; GARCH; Constant] """ try: from openopt import NLP lb = [0.0001, 0.0001, 0.] #lower bound A = [1, 1, 0] b = 1.0 p = NLP(self.f,initvalue,lb=lb,A=A,b=b) r = p.solve('ralg') return r.xf except ImportError: print "Openopt is not installed, will use scipy.fmin_cobyla instead" print "the result may not accurate though" params = fmin_cobyla(self.f,initvalue,cons=[lambda x:1-(x[0]+x[1]), lambda x:x[0], lambda x:x[2], lambda x:x[1]]) return params
def test_openopt(): p = NLP(residual, x0, lb=lb, ub=ub, iprint=1, plot=True) # uncomment the following (and set scale = 1 above) to use openopt's # scaling mechanism. This only seems to work with a few solvers, though. #p.scale = np.array([1, 1e6, 1e6, 1e6, 1e6, 1]) r = p.solve('ralg') # OpenOpt solver, seems to work well,
def startOptimization(self, root, varsRoot, AddVar, currValues, \ ValsColumnName, ObjEntry, ExperimentNumber, Next, NN, goal, objtol, C): AddVar.destroy() ValsColumnName.set('Experiment parameters') n = len(self.NameEntriesList) Names, Lb, Ub, Tol, x0 = [], [], [], [], [] for i in range(n): N, L, U, T, valEntry = \ self.NameEntriesList[i], self.LB_EntriesList[i], self.UB_EntriesList[i], self.TolEntriesList[i], self.ValueEntriesList[i] N.config(state=DISABLED) L.config(state=DISABLED) U.config(state=DISABLED) T.config(state=DISABLED) #valEntry.config(state=DISABLED) name, lb, ub, tol, val = N.get(), L.get(), U.get(), T.get(), valEntry.get() Names.append(name) x0.append(float(val)) Lb.append(float(lb) if lb != '' else -inf) Ub.append(float(ub) if ub != '' else inf) # TODO: fix zero Tol.append(float(tol) if tol != '' else 0) x0, Tol, Lb, Ub = asfarray(x0), asfarray(Tol), asfarray(Lb), asfarray(Ub) x0 *= xtolScaleFactor / Tol #self.x0 = copy(x0) from openopt import NLP, oosolver p = NLP(objective, x0, lb = Lb * xtolScaleFactor / Tol, ub=Ub * xtolScaleFactor / Tol) self.prob = p #calculated_points = [(copy(x0), copy(float(ObjEntry.get()))) p.args = (Tol, self, ObjEntry, p, root, ExperimentNumber, Next, NN, objtol, C) #p.graphics.rate = -inf #p.f_iter = 2 solver = oosolver('bobyqa', useStopByException = False) p.solve(solver, iprint = 1, goal = goal)#, plot=1, xlabel='nf') self.solved = True if p.stopcase >= 0: self.ValsColumnName.set('Best parameters') NN.set('Best obtained objective value:') #Next.config(state=DISABLED) Next.destroy() #reverse = True if goal == 'min' else False calculated_items = self.calculated_points.items() if isinstance(self.calculated_points, dict) else self.calculated_points vals = [calculated_items[i][1] for i in range(len(calculated_items))] ind = argsort(vals) j = ind[0] if goal == 'min' else ind[-1] key, val = calculated_items[j] text_coords = key.split(' ') for i in range(len(self.ValueEntriesList)): self.ValueEntriesList[i].delete(0, END) self.ValueEntriesList[i].insert(0, text_coords[i]) ObjEntry.delete(0, END) obj_tol = self.ObjTolEntry.get() val = float(val) * 1e4 * objtol ObjEntry.insert(0, str(val)) ObjEntry.config(state=DISABLED)
def find2(self, POIMobj, motif_len, motif_start, base, path2pwm=None,solver="NLP"): self.motif_start = motif_start self.motif_len = motif_len x0 = tools.ini_pwm(motif_len, 1, len(base))[0] x0 = x0.flatten() lb = np.ones(x0.shape) * 0.001 ub = np.ones(x0.shape) * 0.999 iprint = 0 maxIter = 1000 ftol = 1e-04 gradtol = 1e-03 diffInt = 1e-05 contol = 1e-02 maxFunEvals = 1e04 maxTime = 100 lenA = int(len(x0)) lenk = int(len(x0)) / len(base) Aeq = np.zeros((lenk, lenA)) beq = np.ones(lenk) for i in range(lenk): for pk in range(i, lenA, lenk): Aeq[i, pk] = 1 # ,Aeq=Aeq,beq=beq, cons = {'type': 'eq', 'fun': lambda x: np.dot(Aeq, x) - beq} bnds = [] for i in range(len(x0)): bnds.append((lb[i], ub[i])) # bnds = np.vstack((lb,ub)) if solver == "ralg": from openopt import NLP p = NLP(self.f_L2, x0,lb=lb, ub=ub, Aeq=Aeq,beq=beq, args=(POIMobj.gPOIM,POIMobj.L,motif_start,POIMobj.small_k,motif_len), diffInt=diffInt, ftol=ftol, plot=0, iprint=iprint,maxIter = maxIter, maxFunEvals = maxFunEvals, show=False, contol=contol) result = p._solve(solver) x = result.xf f = result.ff elif solver == "LBFGSB": x, f, d = fmin_l_bfgs_b(self.f_L2, x0, args=(POIMobj.gPOIM, POIMobj.L, motif_start, POIMobj.small_k, motif_len), approx_grad=True)#constraints=cons)# elif solver == "SLSQP": result = minimize(self.f_L2, x0,args=(POIMobj.gPOIM, POIMobj.L, motif_start, POIMobj.small_k, motif_len),method='SLSQP',bounds=bnds,constraints=cons) x = result.x f = result.fun self.motif_pwm = np.reshape(x, (4, motif_len)) fopt = f self.normalize() if not(path2pwm is None): np.savetxt(path2pwm, self.poim_norm) return self.motif_pwm
def balance(sam, debug=False): try: table = sam.array() except AttributeError: table = np.array(sam) assert table.shape[0] == table.shape[1] size = table.shape[0] x0 = np.array([v for v in table.flatten() if v != 0]) def transform(ox): ret = np.zeros_like(table) i = 0 for r in range(size): for c in range(size): if table[r, c] != 0: ret[r, c] = ox[i] i += 1 return ret def objective(ox): ox = np.square((ox - x0) / x0) return np.sum(ox) def constraints(ox): ox = transform(ox) ret = np.sum(ox, 0) - np.sum(ox, 1) return ret print constraints(x0) if debug: print("--- balance ---") p = NLP(objective, x0, h=constraints, iprint=50 * int(debug), maxIter=100000, maxFunEvals=1e7, name='NLP_1') r = p.solve('ralg', plot=0) if debug: print 'constraints' print constraints(r.xf) assert r.isFeasible try: return sam.replace(transform(r.xf)) except UnboundLocalError: return transform(r.xf)
def lower_bound_predictor(model, lower, upper): n_sample, n_feature = model.X.shape theta = model.theta_ ph = 2 beta = model.beta gamma = model.gamma X = model.X x_lb = atleast_2d(lower) x_ub = atleast_2d(upper) x_lb = x_lb.T if size(x_lb, 1) != n_feature else x_lb x_ub = x_ub.T if size(x_ub, 1) != n_feature else x_ub x_lb = (x_lb - model.X_mean) / model.X_std x_ub = (x_ub - model.X_mean) / model.X_std # a = zeros(1, m) b = zeros(1, m) # midpoint = (z_min + z_max)' / 2 # for i = 1:m # if gamma(i) >= 0 # # tangent line relaxation # b(i) = -gamma(i) * exp(-midpoint(i)) # a(i) = gamma(i) * exp(-midpoint(i)) - b(i) * midpoint(i) # else # # chord relaxation # b(i) = (gamma(i) * exp(-z_max(i)) - gamma(i) * exp(-z_min(i))) / (z_max(i)-z_min(i)) # a(i) = gamma(i) * exp(-z_min(i)) - b(i) * z_min(i) # x0 = ((x_ub - x_lb) * rand(1, n_feature) + x_lb)[0].tolist() # Make a starting guess at the solution obj = model.predict # x_opt = fmin_slsqp(obj, x0, bounds=zip(x_lb[0], x_ub[0]), iter=1e4, iprint=-1) p = NLP(obj, x0, lb=x_lb[0], ub=x_ub[0], iprint=1e6) r = p.solve('ralg') x_opt = r.xf # if any(x_opt < x_lb) or any(x_opt > x_ub): # pdb.set_trace() res = obj(x_opt) return res
def run(self, plot=True): """ Solves the optimization problem. """ # Initial try p0 = self.get_p0() #Lower bounds and Upper bounds (HARDCODED FOR QUADTANK) lbound = N.array([0.0001] * len(p0)) if self.gridsize == 1: ubound = [10.0] * (self.gridsize * self.nbr_us) else: ubound = [10.0] * (self.gridsize * self.nbr_us ) + [0.20, 0.20, 0.20, 0.20, N.inf] * ( (self.gridsize - 1)) #UPPER BOUND FOR VDP #ubound = [0.75]*(self.gridsize*self.nbr_us)+[N.inf]*((self.gridsize-1)*self.nbr_ys) if self.verbosity >= Multiple_Shooting.NORMAL: print 'Initial parameter vector: ' print p0 print 'Lower bound:', len(lbound) print 'Upper bound:', len(ubound) # Get OpenOPT handler p_solve = NLP(self.f, p0, lb=lbound, ub=ubound, maxFunEvals=self.maxFeval, maxIter=self.maxIter, ftol=self.ftol, maxTime=self.maxTime) #If multiple shooting is preformed or single shooting if self.gridsize > 1: p_solve.h = self.h if plot: p_solve.plot = 1 self.opt = p_solve.solve(self.optMethod) return self.opt
def getDirectionOptimPoint(p, func, x, direction, forwardMultiplier = 2.0, maxiter = 150, xtol = None, maxConstrLimit = None, \ alpha_lb = 0, alpha_ub = inf, \ rightLocalization = 0, leftLocalization = 0, \ rightBorderForLocalization = 0, leftBorderForLocalization = None): if all(direction==0): p.err('nonzero direction is required') if maxConstrLimit is None: lsFunc = funcDirectionValue args = (func, x, direction) else: lsFunc = funcDirectionValueWithMaxConstraintLimit args = (func, x, direction, maxConstrLimit, p) prev_alpha, new_alpha = alpha_lb, min(alpha_lb+0.5, alpha_ub) prev_val = lsFunc(prev_alpha, *args) for i in range(p.maxLineSearch): if lsFunc(new_alpha, *args)>prev_val or new_alpha==alpha_ub: break else: if i != 0: prev_alpha = min(alpha_lb, new_alpha) new_alpha *= forwardMultiplier if i == p.maxLineSearch-1: p.debugmsg('getDirectionOptimPoint: maxLineSearch is exeeded') lb, ub = prev_alpha, new_alpha if xtol is None: xtol = p.xtol / 2.0 # NB! goldenSection solver ignores x0 p_LS = NLP(lsFunc, x0=0, lb = lb, ub = ub, iprint = -1, \ args=args, xtol = xtol, maxIter = maxiter, contol = p.contol)# contol is used in funcDirectionValueWithMaxConstraintLimit r = p_LS.solve('goldenSection', useOOiterfcn=False, rightLocalization=rightLocalization, leftLocalization=leftLocalization, rightBorderForLocalization=rightBorderForLocalization, leftBorderForLocalization=leftBorderForLocalization) if r.istop == IS_MAX_ITER_REACHED: p.warn('getDirectionOptimPoint: max iter has been exceeded') alpha_opt = r.special.rightXOptBorder R = DirectionOptimPoint() R.leftAlphaOptBorder = r.special.leftXOptBorder R.leftXOptBorder = x + R.leftAlphaOptBorder * direction R.rightAlphaOptBorder = r.special.rightXOptBorder R.rightXOptBorder = x + R.rightAlphaOptBorder * direction R.x = x + alpha_opt * direction R.alpha = alpha_opt R.evalsF = r.evals['f']+i return R
def balance(sam, debug=False): try: table = sam.array() except AttributeError: table = np.array(sam) assert table.shape[0] == table.shape[1] size = table.shape[0] x0 = np.array([v for v in table.flatten() if v !=0]) def transform(ox): ret = np.zeros_like(table) i = 0 for r in range(size): for c in range(size): if table[r, c] != 0: ret[r, c] = ox[i] i += 1 return ret def objective(ox): ox = np.square((ox - x0) / x0) return np.sum(ox) def constraints(ox): ox = transform(ox) ret = np.sum(ox, 0) - np.sum(ox, 1) return ret print constraints(x0) if debug: print("--- balance ---") p = NLP(objective, x0, h=constraints, iprint = 50 * int(debug), maxIter = 100000, maxFunEvals = 1e7, name = 'NLP_1') r = p.solve('ralg', plot=0) if debug: print 'constraints' print constraints(r.xf) assert r.isFeasible try: return sam.replace(transform(r.xf)) except UnboundLocalError: return transform(r.xf)
def max_loglik_z(self, method='scipy_slsqp'): message(self, 'Optimizing strain frequencies using %s' % (method)) # Initialize frequencies z = [] # Bound frequencies in (0,1) lb = np.zeros(self.n) ub = np.ones(self.n) # Constrain frequencies to sum to 1 def h(a): return sum(a) - 1 quiet() # For every subject for i in range(self.m): # Objective function def f(a): # Get frequencies (N) and error rate zi = a ei = self.e # Get nucleotide frequencies at every position (L,4) a1 = np.einsum('i...,i...', zi, self.p)[self.mask[i]] # Remove masked sites from alignment (L,4) xi = self.x[i][self.mask[i]] # Error correct and weight by counts a2 = np.einsum('ij,ij', xi, np.log(((1 - ei) * a1 + ei / 4.).clip(1e-10))) # Return negative log-likelihood return -1. * a2 # Run optimization g = self.z[i, :] soln = NLP(f, g, lb=lb, ub=ub, h=h, gtol=1e-5, contol=1e-5, name='NLP1').solve(method, plot=0) if soln.ff <= f(g) and soln.isFeasible == True: zi = soln.xf z.append(zi.clip(0, 1)) else: z.append(g) loud() # Update frequencies and error rate self.z = np.array(z) return self
def phScenSolve(scen,rho,verbose=0): Wfilename = 'work/W%d.npy' %(scen); W=load(Wfilename); orho,nscen,nwells,nx,LB,UB = readref() # print 'rho=%g,nx=%d' %(rho,nx) # refcard = load('work/refcard.npy') # orho,nscen,nwells,nx,LB,UB = readcard(refcard) qfn = 'work/qhat%d.npy' %(nx); qhat = load(qfn) H = GenHydroScen(nx,nscen,nwells,scen) e = lambda q,H,W,rho,qhat: gwrfull(q,H,W,rho,qhat) q0 = qhat; # we should read qsol! # q0 = array([0.0025,-0.0038,0.0018,-0.0092]) which_opt = 2 #0 slsqp,1 cobyla, 2 NLP if which_opt>0: if which_opt==1: up = lambda q,H,W,rho,qhat,scen: min(q-LB) dn = lambda q,H,W,rho,qhat,scen: max(UB-q) qopt = fmin_cobyla(e,q0,cons=[up,dn],iprint=0, args=[H,W,rho,qhat],rhoend=0.0001) # qopt = fmin_brute(q0,H,W,rho,qhat,scen) else: eNLP = lambda q: gwrfull(q,H,W,rho,qhat) popt = NLP(eNLP,q0,lb=LB*ones((nwells,1)), ub=UB*ones((nwells,1)),iprint=-1) ropt = popt.solve('ralg') qopt = ropt.xf qopt = qopt.reshape(1,-1) else: bounds = [(LB,UB) for i in range(size(qhat))] # print bounds qopt = fmin_slsqp(e,q0,bounds=bounds,iprint=0, args=[H,W,rho,qhat,scen],acc=0.001) filename = 'work/qsol%d' %(scen); save(filename,squeeze(qopt)) print 'qsol[%d] =' %(scen),qopt # qpert = zeros((1,nwells)); # for i in range(nwells): ## qpert[:,i]= qopt[:,i]+0.01*random.randn() # print 'qpert[%d]=' %(scen),qpert # z1=gwrfullCH(qopt,H,W,rho,qhat,scen) # z2=gwrfullCH(qpert,H,W,rho,qhat,scen) # print 'TicToc=%g' %(z1-z2) if verbose: scenvecprint(scen,qopt) return
def _fit_openopt(self): from openopt import NLP solver = self.kwargs.get('solver','ralg') #~ self.args += args[1:] #~ self.kwargs.update(kwargs) self.err = [1e10,1e9,1e8,1e7] self.i = 0 params = [] for p in self.model.x0: params.append(p()['value']) def f(params): for i in xrange(len(params)): if self.model.x0[i]()['froozen']: params[i] = self.model.x0[i]()['value'] else: if abs(params[i]) == nan or abs(params[i]) == inf: params[i] = self.model.x0[i]()['value'] self.i = (self.i+1)%4 return sum([self.err[self.i]]*len(self.data.x)) if params[i] < self.model.x0[i]()['min']: params[i] = self.model.x0[i]()['min'] self.i = (self.i+1)%4 return sum([self.err[self.i]]*len(self.data.x)) if params[i] > self.model.x0[i]()['max']: params[i] = self.model.x0[i]()['max'] self.i = (self.i+1)%4 return sum([self.err[self.i]]*len(self.data.x)) if self.data.we is not None: return sum((self.data.y-self.model.fcn(params,self.data.x,self.model.const))**2 * self.data.we) else: return sum(self.data.y-self.model.fcn(params,self.data.x,self.model.const)**2) #~ f = lambda p: sum(((self.func(p, self.x) - self.y) / self.weights)**2) self.prob = NLP(f, x0 = params) self.res = self.prob.solve(solver) self.storeResult(self.res) return self.result
def gridmax(al,gam,w,D,th,tl,steps): grid = linspace(0.000,1.0,steps) pisep = 0 for n in grid: gridh = linspace(n,1,steps-n*steps) for nh in gridh: pinowsep = profitsseparating(n,nh,al,gam,w,D,th,tl) if pinowsep >pisep: pisep = pinowsep solutioneffortsep = [n,nh] x0 = [solutioneffortsep[0],solutioneffortsep[1]] lb = [0,0] ub = [1,1] A= [1,-1] b=[0] f=lambda x: -profitsseparating(x[0],x[1],al,gam,w,D,th,tl)#note that the functions below search for a minimum, hence the "-" p=NLP(f,x0,lb=lb,ub=ub,A=A,b=b,contol = 1e-8,gtol = 1e-10,ftol = 1e-12) solver='ralg' r=p.solve(solver) #the "2 program" simply assumes ef=0 and maximizes over efh only; the result is then compared to the other program above. This is done because there is a local maximum at ef=0 (see paper) f2=lambda x: -profitsseparating(0,x[0],al,gam,w,D,th,tl) lb2=[0] ulb2=[1] p2=NLP(f2,solutioneffortsep[1],lb=lb2,ub=ulb2,contol = 1e-8,gtol = 1e-10,ftol = 1e-12) r2=p2.solve(solver) if r.ff<r2.ff: print 'solver result with gamma=',gam,', alpha=',al,', w=',w,' and D=',D,', th=',th,', tl=',tl,' the effort levels are: ', r.xf ref=r.xf[0] refh=r.xf[1] piff=r.ff else: print 'solver result with gamma=',gam,', alpha=',al,', w=',w,' and D=',D,', th=',th,', tl=',tl,' the effort levels are : 0',r2.xf ref=0 refh=r2.xf[0] piff=r2.ff print ref,refh print 'ub1 is ', ub1(ref,refh, al,gam,util(w),util(w-D),th,tl), '; ul1 is ',ul1(ref,refh, al,gam,util(w),util(w-D),th,tl) print 'ub2 is ', ub2(ref,refh, al,gam,util(w),util(w-D),th,tl), '; ul2 is ',ul2(ref,refh, al,gam,util(w),util(w-D),th,tl) euff=al*(betah(ref,al,th,tl)*ul1(ref,refh, al,gam,util(w),util(w-D),th,tl)+(1-betah(ref,al,th,tl))*ub1(ref,refh, al,gam,util(w),util(w-D),th,tl))+(1-al)*(betal(ref,al,th,tl)*ul2(ref,refh, al,gam,util(w),util(w-D),th,tl)+(1-betal(ref,al,th,tl))*ub2(ref,refh, al,gam,util(w),util(w-D),th,tl))-cost(ref,gam) print 'expected utility under this contract is ', euff print 'expected solver profits are ',-piff return [-piff,euff]#this return is used for creating the graph
def fit(fitfunc, model, data_single, y, starting_values, param_upper_bounds, param_lower_bounds): print_level = -1 if model.main_constrained: fitting = NLP( partial (fitfunc, data = data_single, ind = y, return_residuals=False, return_SSR=True ), starting_values, ub=param_upper_bounds, lb=param_lower_bounds, ftol=model.tolerence ) #results = fitting.solve('nlp:ralg', iprint=print_level) #return fitting.solve('nssolve', iprint = print_level) return fitting.solve('ralg', iprint = print_level, maxIter = model.max_runs) else: fitting = NLP( partial (fitfunc, data=data_single, ind = y, return_residuals=False, return_SSR=True ), starting_values, ftol=model.tolerence, maxIter = model.max_runs, ) return fitting.solve('scipy_leastsq', iprint=print_level)
def run(self, plot=True): """ Solves the optimization problem. """ # Initial try p0 = self.get_p0() #Lower bounds and Upper bounds (HARDCODED FOR QUADTANK) lbound = N.array([0.0001]*len(p0)) if self.gridsize == 1: ubound = [10.0]*(self.gridsize*self.nbr_us) else: ubound = [10.0]*(self.gridsize*self.nbr_us) + [0.20,0.20,0.20,0.20,N.inf]*((self.gridsize-1)) #UPPER BOUND FOR VDP #ubound = [0.75]*(self.gridsize*self.nbr_us)+[N.inf]*((self.gridsize-1)*self.nbr_ys) if self.verbosity >= Multiple_Shooting.NORMAL: print 'Initial parameter vector: ' print p0 print 'Lower bound:', len(lbound) print 'Upper bound:', len(ubound) # Get OpenOPT handler p_solve = NLP(self.f,p0,lb = lbound, ub=ubound,maxFunEvals = self.maxFeval, maxIter = self.maxIter, ftol=self.ftol, maxTime=self.maxTime) #If multiple shooting is preformed or single shooting if self.gridsize > 1: p_solve.h = self.h if plot: p_solve.plot = 1 self.opt = p_solve.solve(self.optMethod) return self.opt
def optimise_openopt(target_speed): from openopt import NLP def fitfun(gene): ontimes = np.require(gene[:12].copy(), requirements=['C', 'A', 'O', 'W']) offtimes = np.require(ontimes + gene[12:].copy(), requirements=['C', 'A', 'O', 'W']) currents = [243.]*12 flyer.prop.overwriteCoils(ontimes.ctypes.data_as(c_double_p), offtimes.ctypes.data_as(c_double_p)) flyer.preparePropagation(currents) flyer.propagate(0) pos = flyer.finalPositions[0] vel = flyer.finalVelocities[0] ind = np.where((pos[:, 2] > 268.) & (vel[:, 2] < 1.1*target_speed) & (vel[:, 2] > 0.9*target_speed))[0] # all particles that reach the end print 'good particles:', ind.shape[0] return -1.*ind.shape[0] initval = np.append(flyer.ontimes, flyer.offtimes - flyer.ontimes) lb = np.array(24*[0]) ub = np.array(12*[600] + 12*[85]) p = NLP(fitfun, initval, lb=lb, ub=ub) r = p.solve('bobyqa', plot=0) return r
def upper_bound_mse(model, lower, upper): n_sample, n_feature = model.X.shape x_lb = atleast_2d(lower) x_ub = atleast_2d(upper) x_lb = x_lb.T if size(x_lb, 1) != n_feature else x_lb x_ub = x_ub.T if size(x_ub, 1) != n_feature else x_ub x0 = ((x_ub - x_lb) * rand(1, n_feature) + x_lb)[0] obj = objective_mse_wrapper(model) # x_opt = fmin_slsqp(obj, x0, bounds=zip(x_lb[0], x_ub[0]), iter=1e4, iprint=-1) # # openopt optimizers p = NLP(obj, x0, lb=x_lb[0], ub=x_ub[0], iprint=1e6) r = p.solve('ralg') x_opt = r.xf # if any(x_opt < x_lb) or any(x_opt > x_ub): # pdb.set_trace() res = -obj(x_opt) return res
def milpTransfer(originProb): newProb = NLP(originProb.f, originProb.x0) originProb.inspire(newProb) newProb.discreteVars = originProb.discreteVars def err(s): # to prevent text output raise OpenOptException(s) newProb.err = err for fn in ['df', 'd2f', 'c', 'dc', 'h', 'dh']: if hasattr(originProb, fn) and getattr(originProb.userProvided, fn) or originProb.isFDmodel: setattr(newProb, fn, getattr(originProb, fn)) newProb.plot = 0 newProb.iprint = -1 newProb.nlpSolver = originProb.nlpSolver return newProb
def milpTransfer(originProb): newProb = NLP(originProb.f, originProb.x0) originProb.fill(newProb) newProb.discreteVars = originProb.discreteVars def err(s): # to prevent text output raise OpenOptException(s) newProb.err = err for fn in ['df', 'd2f', 'c', 'dc', 'h', 'dh']: if hasattr(originProb, fn) and getattr(originProb.userProvided, fn) or originProb.isFDmodel: setattr(newProb, fn, getattr(originProb, fn)) newProb.plot = 0 newProb.iprint = -1 newProb.nlpSolver = originProb.nlpSolver return newProb
def optimize( self, solver="ralg", plot=0, maxIter=1e5, maxCPUTime=3600, maxFunEvals=1e12 ): if self.mtype == "LP" or self.mtype == "MILP": p = MILP( self.objective, self.init, constraints=self.constraints, maxIter=maxIter, maxCPUTime=maxCPUTime, maxFunEvals=maxFunEvals, ) elif self.mtype == "NLP": p = NLP( self.objective, self.init, constraints=self.constraints, maxIter=maxIter, maxCPUTime=maxCPUTime, maxFunEvals=maxFunEvals, ) else: print("Model Type Error") raise TypeError if self.sense == GRB.MAXIMIZE: self.Results = p.maximize(solver, plot=plot) else: self.Results = p.minimize(solver, plot=plot) # print(self.Results) self.ObjVal = self.Results.ff if self.Results.isFeasible: self.Status = GRB.OPTIMAL else: self.Status = GRB.INFEASIBLE for v in self.variables: v.VarName = v.name v.X = self.Results.xf[v] return self.Status
def fit_kernel_model(kernel, loss, X, y, gamma, weights=None): n_samples = X.shape[0] gamma = float(gamma) if weights is not None: weights = weights / np.sum(weights) * weights.size # --- optimize bias term --- bias = fd.oovar('bias', size=1) if weights is None: obj_fun = fd.sum(loss(y, bias)) else: obj_fun = fd.sum(fd.dot(weights, loss(y, bias))) optimizer = NLP(obj_fun, {bias: 0.}, ftol=1e-6, iprint=-1) result = optimizer.solve('ralg') bias = result(bias) # --- optimize betas --- beta = fd.oovar('beta', size=n_samples) # gram matrix K = kernel(X, X) assert K.shape == (n_samples, n_samples) K_dot_beta = fd.dot(K, beta) penalization_term = gamma * fd.dot(beta, K_dot_beta) if weights is None: loss_term = fd.sum(loss(y - bias, K_dot_beta)) else: loss_term = fd.sum(fd.dot(weights, loss(y - bias, K_dot_beta))) obj_fun = penalization_term + loss_term beta0 = np.zeros((n_samples, )) optimizer = NLP(obj_fun, {beta: beta0}, ftol=1e-4, iprint=-1) result = optimizer.solve('ralg') beta = result(beta) return KernelModel(X, kernel, beta, bias)
def max_log_marginal_likelihood(self, hyp_initial_guess, maxiter=1, optimization_algorithm="scipy_cg", ftol=1.0e-3, fixedHypers=None, use_gradient=False, logscale=False): """ Set up the optimization problem in order to maximize the log_marginal_likelihood. Parameters ---------- parametric_model : Classifier the actual parameteric model to be optimized. hyp_initial_guess : numpy.ndarray set of hyperparameters' initial values where to start optimization. optimization_algorithm : string actual name of the optimization algorithm. See http://scipy.org/scipy/scikits/wiki/NLP for a comprehensive/updated list of available NLP solvers. (Defaults to 'ralg') ftol : float threshold for the stopping criterion of the solver, which is mapped in OpenOpt NLP.ftol (Defaults to 1.0e-3) fixedHypers : numpy.ndarray (boolean array) boolean vector of the same size of hyp_initial_guess; 'False' means that the corresponding hyperparameter must be kept fixed (so not optimized). (Defaults to None, which during means all True) Notes ----- The maximization of log_marginal_likelihood is a non-linear optimization problem (NLP). This fact is confirmed by Dmitrey, author of OpenOpt. """ self.problem = None self.use_gradient = use_gradient self.logscale = logscale # use log-scale on hyperparameters to enhance numerical stability self.optimization_algorithm = optimization_algorithm self.hyp_initial_guess = np.array(hyp_initial_guess) self.hyp_initial_guess_log = np.log(self.hyp_initial_guess) if fixedHypers is None: fixedHypers = np.zeros(self.hyp_initial_guess.shape[0],dtype=bool) pass self.freeHypers = -fixedHypers if self.logscale: self.hyp_running_guess = self.hyp_initial_guess_log.copy() else: self.hyp_running_guess = self.hyp_initial_guess.copy() pass self.f_last_x = None def f(x): """ Wrapper to the log_marginal_likelihood to be maximized. """ # XXX EO: since some OpenOpt NLP solvers does not # implement lower bounds the hyperparameters bounds are # implemented inside PyMVPA: (see dmitrey's post on # [SciPy-user] 20080628). # # XXX EO: OpenOpt does not implement optimization of a # subset of the hyperparameters so it is implemented here. # # XXX EO: OpenOpt does not implement logrithmic scale of # the hyperparameters (to enhance numerical stability), so # it is implemented here. self.f_last_x = x.copy() self.hyp_running_guess[self.freeHypers] = x # REMOVE print "guess:",self.hyp_running_guess,x try: if self.logscale: self.parametric_model.set_hyperparameters(np.exp(self.hyp_running_guess)) else: self.parametric_model.set_hyperparameters(self.hyp_running_guess) pass except InvalidHyperparameterError: if __debug__: debug("MOD_SEL","WARNING: invalid hyperparameters!") return -np.inf try: self.parametric_model.train(self.dataset) except (np.linalg.linalg.LinAlgError, SL.basic.LinAlgError, ValueError): # Note that ValueError could be raised when Cholesky gets Inf or Nan. if __debug__: debug("MOD_SEL", "WARNING: Cholesky failed! Invalid hyperparameters!") return -np.inf log_marginal_likelihood = self.parametric_model.compute_log_marginal_likelihood() # REMOVE print log_marginal_likelihood return log_marginal_likelihood def df(x): """ Proxy to the log_marginal_likelihood first derivative. Necessary for OpenOpt when using derivatives. """ self.hyp_running_guess[self.freeHypers] = x # REMOVE print "df guess:",self.hyp_running_guess,x # XXX EO: Most of the following lines can be skipped if # df() is computed just after f() with the same # hyperparameters. The partial results obtained during f() # are what is needed for df(). For now, in order to avoid # bugs difficult to trace, we keep this redunundancy. A # deep check with how OpenOpt works or using memoization # should solve this issue. try: if self.logscale: self.parametric_model.set_hyperparameters(np.exp(self.hyp_running_guess)) else: self.parametric_model.set_hyperparameters(self.hyp_running_guess) pass except InvalidHyperparameterError: if __debug__: debug("MOD_SEL", "WARNING: invalid hyperparameters!") return -np.inf # Check if it is possible to avoid useless computations # already done in f(). According to tests and information # collected from OpenOpt people, it is sufficiently # unexpected that the following test succeed: if np.any(x!=self.f_last_x): if __debug__: debug("MOD_SEL","UNEXPECTED: recomputing train+log_marginal_likelihood.") try: self.parametric_model.train(self.dataset) except (np.linalg.linalg.LinAlgError, SL.basic.LinAlgError, ValueError): if __debug__: debug("MOD_SEL", "WARNING: Cholesky failed! Invalid hyperparameters!") # XXX EO: which value for the gradient to return to # OpenOpt when hyperparameters are wrong? return np.zeros(x.size) log_marginal_likelihood = self.parametric_model.compute_log_marginal_likelihood() # recompute what's needed (to be safe) REMOVE IN FUTURE! pass if self.logscale: gradient_log_marginal_likelihood = self.parametric_model.compute_gradient_log_marginal_likelihood_logscale() else: gradient_log_marginal_likelihood = self.parametric_model.compute_gradient_log_marginal_likelihood() pass # REMOVE print "grad:",gradient_log_marginal_likelihood return gradient_log_marginal_likelihood[self.freeHypers] if self.logscale: # vector of hyperparameters' values where to start the search x0 = self.hyp_initial_guess_log[self.freeHypers] else: x0 = self.hyp_initial_guess[self.freeHypers] pass self.contol = 1.0e-20 # Constraint tolerance level # XXX EO: is it necessary to use contol when self.logscale is # True and there is no lb? Ask dmitrey. if self.use_gradient: # actual instance of the OpenOpt non-linear problem self.problem = NLP(f, x0, df=df, contol=self.contol, goal='maximum') else: self.problem = NLP(f, x0, contol=self.contol, goal='maximum') pass self.problem.name = "Max LogMargLikelihood" if not self.logscale: # set lower bound for hyperparameters: avoid negative # hyperparameters. Note: problem.n is the size of # hyperparameters' vector self.problem.lb = np.zeros(self.problem.n)+self.contol pass # max number of iterations for the optimizer. self.problem.maxiter = maxiter # check whether the derivative of log_marginal_likelihood converged to # zero before ending optimization self.problem.checkdf = True # set increment of log_marginal_likelihood under which the optimizer stops self.problem.ftol = ftol self.problem.iprint = _openopt_debug() return self.problem
# so it should be something like 1e-3...1e-5 gtol = 1e-7 # (default gtol = 1e-6) # Assign problem: # 1st arg - objective function # 2nd arg - start point p = NLP(f, x0, df=df, c=c, dc=dc, h=h, dh=dh, A=A, b=b, Aeq=Aeq, beq=beq, lb=lb, ub=ub, gtol=gtol, contol=contol, iprint=50, maxIter=10000, maxFunEvals=1e7, name='NLP_1') #optional: graphic output, requires pylab (matplotlib) p.plot = True #optional: user-supplied 1st derivatives check p.checkdf()
I can't inform how successfully OO-connected solvers will handle a prob instance with restricted dom because it seems to be too prob-specific Still I can inform that ralg handles the problems rather well provided in every point x from R^nVars at least one ineq constraint is active (i.e. value constr[i](x) belongs to R+) Note also that some solvers require x0 inside dom objFunc. For ralg it doesn't matter. """ from numpy import * from openopt import NLP n = 100 an = arange(n) # array [0, 1, 2, ..., n-1] x0 = n+15*(1+cos(an)) f = lambda x: (x**2).sum() + sqrt(x**3).sum() df = lambda x: 2*x + 1.5*x**0.5 lb = zeros(n) solvers = ['ralg'] #solvers = ['ipopt'] for solver in solvers: p = NLP(f, x0, df=df, lb=lb, xtol = 1e-6, iprint = 50, maxIter = 10000, maxFunEvals = 1e8) #p.checkdf() r = p.solve(solver) # expected r.xf = small values near zero
colors = colors[:len(solvers)] lines, results = [], {} for j in range(len(solvers)): solver = solvers[j] color = colors[j] p = NLP(f, x0, name='bench2', df=df, c=c, dc=dc, h=h, dh=dh, lb=lb, ub=ub, gtol=gtol, ftol=ftol, maxFunEvals=1e7, maxIter=maxIter, maxTime=maxTime, plot=1, color=color, iprint=10, legend=[solvers[j]], show=False, contol=contol) # p = NLP(f, x0, name = 'bench2', df = df, c=c, dc = dc, lb = lb, ub = ub, gtol=gtol, ftol = ftol, maxFunEvals = 1e7, maxIter = 1e4, maxTime = maxTime, plot = 1, color = color, iprint = 0, legend = [solvers[j]], show=False, contol = contol) if solver[:4] == ['ralg']: pass # p.gtol = 1e-8 # p.ftol = 1e-7
from openopt import NLP from numpy import cos, arange, ones, asarray, abs, zeros N = 30 M = 5 ff = lambda x: ((x-M)**2).sum() p = NLP(ff, cos(arange(N))) p.df = lambda x: 2*(x-M) p.c = lambda x: [2* x[0] **4-32, x[1]**2+x[2]**2 - 8] def dc(x): r = zeros((2, p.n)) r[0,0] = 2 * 4 * x[0]**3 r[1,1] = 2 * x[1] r[1,2] = 2 * x[2] return r p.dc = dc h1 = lambda x: 1e1*(x[-1]-1)**4 h2 = lambda x: (x[-2]-1.5)**4 p.h = lambda x: (h1(x), h2(x)) def dh(x): r = zeros((2, p.n)) r[0,-1] = 1e1*4*(x[-1]-1)**3 r[1,-2] = 4*(x[-2]-1.5)**3 return r p.dh = dh p.lb = -6*ones(N) p.ub = 6*ones(N) p.lb[3] = 5.5
T = Triangle((1,2,a),(2,b,4),(c,6.5,7)) # let's create an initial estimation to the problems below startValues = {a:1, b:0.5, c:0.1} # you could mere set any, but sometimes a good estimation matters # let's find an a,b,c values wrt r = 1.5 with required tolerance 10^-5, R = 4.2 and tol 10^-4, a+c == 2.5 wrt tol 10^-7 # if no tol is provided, p.contol is used (default 10^-6) equations = [(T.r == 1.5)(tol=1e-5) , (T.R == 4.2)(tol=1e-4), (a+c == 2.5)(tol=1e-7)] prob = SNLE(equations, startValues) result = prob.solve('nssolve', iprint = 0) # nssolve is name of the solver involved print('\nsolution has%s been found' % ('' if result.stopcase > 0 else ' not')) print('values:' + str(result(a, b, c))) # [1.5773327492140974, -1.2582702179532217, 0.92266725078590239] print('triangle sides: '+str(T.sides(result))) # [8.387574299361475, 7.0470774415247455, 4.1815836020856336] print('orthocenter of the triangle: ' + str(T.H(result))) # [ 0.90789867 2.15008869 1.15609611] # let's find minimum inscribed radius subjected to the constraints a<1.5, a>-1, b<0, a+2*c<4, log(1-b)<2] : objective = T.r prob = NLP(objective, startValues, constraints = [a<1.5, a>-1, b<0, a+2*c<4, log(1-b)<2]) result1 = prob.minimize('ralg', iprint = 0) # ralg is name of the solver involved, see http://openopt.org/ralg for details print('\nminimal inscribed radius: %0.3f' % T.r(result1)) # 1.321 print('optimal values:' + str(result1(a, b, c))) # [1.4999968332804028, 2.7938728907900973e-07, 0.62272481283890913] #let's find minimum outscribed radius subjected to the constraints a<1.5, a>-1, b<0, a+2*c<4, log(1-b)<2] : prob = NLP(T.R, startValues, constraints = (a<1.5, a>-1, b<0, (a+2*c<4)(tol=1e-7), log(1-b)<2)) result2 = prob.minimize('ralg', iprint = 0) print('\nminimal outscribed radius: %0.3f' % T.R(result2)) # 3.681 print('optimal values:' + str(result2(a, b, c))) # [1.499999901863762, -1.7546960034401648e-06, 1.2499958739399943]
from openopt import NLP from numpy import cos, arange, ones, asarray, abs, zeros N = 30 M = 5 ff = lambda x: ((x - M)**2).sum() p = NLP(ff, cos(arange(N))) p.df = lambda x: 2 * (x - M) p.c = lambda x: [2 * x[0]**4 - 32, x[1]**2 + x[2]**2 - 8] def dc(x): r = zeros((2, p.n)) r[0, 0] = 2 * 4 * x[0]**3 r[1, 1] = 2 * x[1] r[1, 2] = 2 * x[2] return r p.dc = dc h1 = lambda x: 1e1 * (x[-1] - 1)**4 h2 = lambda x: (x[-2] - 1.5)**4 p.h = lambda x: (h1(x), h2(x)) def dh(x): r = zeros((2, p.n)) r[0, -1] = 1e1 * 4 * (x[-1] - 1)**3 r[1, -2] = 4 * (x[-2] - 1.5)**3 return r
def test(complexity=0, **kwargs): n = 15 * (complexity+1) x0 = 15*cos(arange(n)) + 8 f = lambda x: ((x-15)**2).sum() df = lambda x: 2*(x-15) c = lambda x: [2* x[0] **4-32, x[1]**2+x[2]**2 - 8] # dc(x)/dx: non-lin ineq constraints gradients (optional): def dc(x): r = zeros((len(c(x0)), n)) r[0,0] = 2 * 4 * x[0]**3 r[1,1] = 2 * x[1] r[1,2] = 2 * x[2] return r hp = 2 h1 = lambda x: (x[-1]-13)**hp h2 = lambda x: (x[-2]-17)**hp h = lambda x:[h1(x), h2(x)] # dh(x)/dx: non-lin eq constraints gradients (optional): def dh(x): r = zeros((2, n)) r[0, -1] = hp*(x[-1]-13)**(hp-1) r[1, -2] = hp*(x[-2]-17)**(hp-1) return r lb = -8*ones(n) ub = 15*ones(n)+8*cos(arange(n)) ind = 3 A = zeros((2, n)) A[0, ind:ind+2] = 1 A[1, ind+2:ind+4] = 1 b = [15, 8] Aeq = zeros(n) Aeq[ind+4:ind+8] = 1 beq = 45 ######################################################## colors = ['b', 'k', 'y', 'g', 'r'] #solvers = ['ipopt', 'ralg','scipy_cobyla'] solvers = ['ralg','scipy_slsqp', 'ipopt'] solvers = [ 'ralg', 'scipy_slsqp'] solvers = [ 'ralg'] solvers = [ 'r2'] solvers = [ 'ralg', 'scipy_slsqp'] ######################################################## for i, solver in enumerate(solvers): p = NLP(f, x0, df=df, c=c, h=h, dc=dc, dh=dh, lb=lb, ub=ub, A=A, b=b, Aeq=Aeq, beq=beq, maxIter = 1e4, \ show = solver==solvers[-1], color=colors[i], **kwargs ) if not kwargs.has_key('iprint'): p.iprint = -1 # p.checkdf() # p.checkdc() # p.checkdh() r = p.solve(solver) if r.istop>0: return True, r, p else: return False, r, p
# print 'pos',pos_sum(p0) # print 'neg',neg_sum(p0) if 0: p0=N.ones(M*2+3) p0[0:3]=[.1,.1,.1] if 1: p0=N.ones(M*2)/(M) if 1: print len(p0) lowerm=1e-4*N.ones(len(p0)) #lowerm[0:3]=[-1,-1,-1] upperm=N.ones(len(p0)) if 1: p = NLP(Entropy, p0, maxIter = 1e3, maxFunEvals = 1e5) if 0: p = NLP(chisq, p0, maxIter = 1e3, maxFunEvals = 1e5) if 0: p = NLP(max_wrap, p0, maxIter = 1e3, maxFunEvals = 1e5) if 0: p.lb=lowerm p.ub=upperm p.args.f=(h,k,l,fq,fqerr,x,z,cosmat_list,coslist,flist) p.plot = 0 p.iprint = 1 p.contol = 1e-5#3 # required constraints tolerance, default for NLP is 1e-6
res = scipy.optimize.differential_evolution(objLegrand.cost,bounds=boxBounds) solvers = [ 'ralg', 'lincher', 'gsubg', 'scipy_slsqp', 'scipy_cobyla', 'interalg', 'auglag', 'ptn', 'mma' ] pro = NLP(f=objLegrand.cost,x0=theta,df=objLegrand.sensitivity,lb=lb,ub=ub,A=A,b=b) pro.plot = True rRalg = pro.solve('ralg') pro = NLP(f=objLegrand.cost,x0=theta3,df=objLegrand.sensitivity,lb=lb,ub=ub,A=A,b=b) pro.plot = True rRalg = pro.solve('ralg') pro = NLP(f=objLegrand.cost,x0=theta,df=objLegrand.sensitivity,lb=lb,ub=ub,A=A,b=b) pro.plot = True rSLSQP = pro.solve('scipy_slsqp') # we try to refine the solution
def max_loglik_p(self, method='scipy_slsqp'): message(self, 'Optimizing strain genotypes using %s' % (method)) # Initialize frequencies p = [] # Bound genotypes in (0,1) lb = np.zeros(4 * self.n) ub = np.ones(4 * self.n) # Constrain genotypes to sum to 1 def h(a): return np.reshape(a, (self.n, 4)).sum(axis=1) - 1.0 quiet() # Optimize genotypes at every position for j in range(self.l): # Copy mask mj = self.mask[:, j].copy() # Objective function def f(a): # Reshape strain genotypes pi = np.reshape(a, (self.n, 4)) # Nucleotide frequencies at position j a1 = (1 - self.e) * (np.dot(self.z, pi)) + (self.e / 4.) # Site likelihoods l1 = (self.x[:, j, :] * np.log(a1.clip(1e-10))).sum(axis=1) # Robust estimation if self.robust == True: # Alternative likelihoods l2 = (np.log(.25) * self.x[:, j, :]).sum(axis=1) # Pay likelihood penalty to mask sites i = l1 >= self.penalty * l2 # Update mask mj[i] = True mj[np.logical_not(i)] = False # Penalized likelihood lf = l1[i].sum( ) + self.penalty * l2[np.logical_not(i)].sum() else: # Normal likelihood lf = l1.sum() # L2 penalty #return -1.*lf - pi.max(axis=1).sum() return -1. * lf - (pi**2).sum() # Calculate original likelihood x0 = self.p[:, j, :].flatten() l0 = f(x0) # Optimize genotypes g = [.25] * 4 * self.n soln = NLP(f, g, h=h, lb=lb, ub=ub, gtol=1e-5, contol=1e-5, name='NLP1').solve(method, plot=0) # Update genotypes if soln.ff <= l0 and soln.isFeasible == True: # Discretize results xf = discretize_genotypes( np.reshape(soln.xf.clip(0, 1), (self.n, 4))) lf = f(xf.flatten()) # Validate likelihood if lf < l0: # Update genotypes and mask p.append(xf) if self.robust == True: self.mask[:, j] = mj continue # If likelihood not improved, use original genotypes p.append(self.p[:, j, :]) loud() # Fix shape self.p = np.swapaxes(np.array(p), 0, 1) return self
n = I.shape[1] x0fn = 'x0_' + infn[:-4] + '.txt' x0 = None if os.path.isfile(x0fn): x0 = np.loadtxt(x0fn) if x0 is None or x0.shape[0] != 2 * m + n: x0 = np.ones(2 * m + n) # x0[m + 1: 2 * m + 1] = I0 / 10 logger.debug(x0.shape) lb = np.zeros(2 * m + n) ub = np.ones(2 * m + n) ub[m:] = np.inf p = NLP(error_function2, x0, maxIter=1e5, maxFunEvals=1e7, lb=lb, ub=ub) p.args.f = (I, m) p.df = grad p.checkdf() r = p.solve('ralg', plot=1) x = r.xf logger.info(x) xfn = 'x_' + infn[:-4] + '.txt' np.savetxt(xfn, x) # p = NLP(error_function2, x, maxIter=1e4, maxFunEvals=1e6, lb=lb, ub=ub) # p.args.f = (I, m) # r = p.solve('ralg', plot=1) # x = r.xf
def fit_node(self,index): qnode=self.qlist[index] print qnode.q th=qnode.th_condensed['a3'] counts=qnode.th_condensed['counts'] counts_err=qnode.th_condensed['counts_err'] print qnode.th_condensed['counts'].std() print qnode.th_condensed['counts'].mean() maxval=qnode.th_condensed['counts'].max() minval=qnode.th_condensed['counts'].min() diff=qnode.th_condensed['counts'].max()-qnode.th_condensed['counts'].min()\ -qnode.th_condensed['counts'].mean() sig=qnode.th_condensed['counts'].std() if diff-2*sig>0: #the difference between the high and low point and #the mean is greater than 3 sigma so we have a signal p0=findpeak(th,counts,1) print 'p0',p0 #Area center width Bak center=p0[0] width=p0[1] sigma=width/2/N.sqrt(2*N.log(2)) Imax=maxval-minval area=Imax*(N.sqrt(2*pi)*sigma) print 'Imax',Imax pin=[area,center,width,0] if 1: p = NLP(chisq, pin, maxIter = 1e3, maxFunEvals = 1e5) #p.lb=lowerm #p.ub=upperm p.args.f=(th,counts,counts_err) p.plot = 0 p.iprint = 1 p.contol = 1e-5#3 # required constraints tolerance, default for NLP is 1e-6 # for ALGENCAN solver gradtol is the only one stop criterium connected to openopt # (except maxfun, maxiter) # Note that in ALGENCAN gradtol means norm of projected gradient of the Augmented Lagrangian # so it should be something like 1e-3...1e-5 p.gradtol = 1e-5#5 # gradient stop criterium (default for NLP is 1e-6) #print 'maxiter', p.maxiter #print 'maxfun', p.maxfun p.maxIter=50 # p.maxfun=100 #p.df_iter = 50 p.maxTime = 4000 #r=p.solve('scipy_cobyla') #r=p.solve('scipy_lbfgsb') #r = p.solve('algencan') print 'ralg' r = p.solve('ralg') print 'done' pfit=r.xf print 'pfit openopt',pfit print 'r dict', r.__dict__ if 0: print 'curvefit' print sys.executable pfit,popt=curve_fit(gauss2, th, counts, p0=pfit, sigma=counts_err) print 'p,popt', pfit,popt perror=N.sqrt(N.diag(popt)) print 'perror',perror chisqr=chisq(pfit,th,counts,counts_err) dof=len(th)-len(pfit) print 'chisq',chisqr if 0: oparam=scipy.odr.Model(gauss) mydatao=scipy.odr.RealData(th,counts,sx=None,sy=counts_err) myodr = scipy.odr.ODR(mydatao, oparam, beta0=pfit) myoutput=myodr.run() myoutput.pprint() pfit=myoutput.beta if 1: print 'mpfit' p0=pfit parbase={'value':0., 'fixed':0, 'limited':[0,0], 'limits':[0.,0.]} parinfo=[] for i in range(len(p0)): parinfo.append(copy.deepcopy(parbase)) for i in range(len(p0)): parinfo[i]['value']=p0[i] fa = {'x':th, 'y':counts, 'err':counts_err} #parinfo[1]['fixed']=1 #parinfo[2]['fixed']=1 m = mpfit(myfunct_res, p0, parinfo=parinfo,functkw=fa) if (m.status <= 0): print 'error message = ', m.errmsg params=m.params pfit=params perror=m.perror #chisqr=(myfunct_res(m.params, x=th, y=counts, err=counts_err)[1]**2).sum() chisqr=chisq(pfit,th,counts,counts_err) dof=m.dof #Icalc=gauss(pfit,th) #print 'mpfit chisqr', chisqr if 0: width_x=N.linspace(p0[0]-p0[1],p0[0]+p0[1],100) width_y=N.ones(width_x.shape)*(maxval-minval)/2 pos_y=N.linspace(minval,maxval,100) pos_x=N.ones(pos_y.shape)*p0[0] if 1: pylab.errorbar(th,counts,counts_err,marker='s',linestyle='None',mfc='black',mec='black',ecolor='black') pylab.plot(width_x,width_y) pylab.plot(pos_x,pos_y) pylab.plot(th,Icalc) pylab.show() else: #fix center #fix width print 'no peak' #Area center width Bak area=0 center=th[len(th)/2] width=(th.max()-th.min())/5.0 #rather arbitrary, but we don't know if it's the first.... Bak=qnode.th_condensed['counts'].mean() p0=N.array([area,center,width,Bak],dtype='float64') #initial conditions parbase={'value':0., 'fixed':0, 'limited':[0,0], 'limits':[0.,0.]} parinfo=[] for i in range(len(p0)): parinfo.append(copy.deepcopy(parbase)) for i in range(len(p0)): parinfo[i]['value']=p0[i] fa = {'x':th, 'y':counts, 'err':counts_err} parinfo[1]['fixed']=1 parinfo[2]['fixed']=1 m = mpfit(myfunct_res, p0, parinfo=parinfo,functkw=fa) if (m.status <= 0): print 'error message = ', m.errmsg params=m.params pfit=params perror=m.perror #chisqr=(myfunct_res(m.params, x=th, y=counts, err=counts_err)[1]**2).sum() chisqr=chisq(pfit,th,counts,counts_err) dof=m.dof Icalc=gauss(pfit,th) #print 'perror',perror if 0: pylab.errorbar(th,counts,counts_err,marker='s',linestyle='None',mfc='black',mec='black',ecolor='black') pylab.plot(th,Icalc) pylab.show() print 'final answer' print 'perror', 'perror' #If the fit is unweighted (i.e. no errors were given, or the weights # were uniformly set to unity), then .perror will probably not represent #the true parameter uncertainties. # *If* you can assume that the true reduced chi-squared value is unity -- # meaning that the fit is implicitly assumed to be of good quality -- # then the estimated parameter uncertainties can be computed by scaling # .perror by the measured chi-squared value. # dof = len(x) - len(mpfit.params) # deg of freedom # # scaled uncertainties # pcerror = mpfit.perror * sqrt(mpfit.fnorm / dof) print 'params', pfit print 'chisqr', chisqr #note that chisqr already is scaled by dof pcerror=perror*N.sqrt(m.fnorm / m.dof)#chisqr print 'pcerror', pcerror self.qlist[index].th_integrated_intensity=N.abs(pfit[0]) self.qlist[index].th_integrated_intensity_err=N.abs(pcerror[0]) Icalc=gauss(pfit,th) print 'perror',perror if 0: pylab.figure() pylab.errorbar(th,counts,counts_err,marker='s',linestyle='None',mfc='black',mec='black',ecolor='black') pylab.plot(th,Icalc) qstr=str(qnode.q['h_center'])+','+str(qnode.q['k_center'])+','+str(qnode.q['l_center']) pylab.title(qstr) #pylab.show() return
# so it should be something like 1e-3...1e-5 gtol = 1e-6 # (default gtol = 1e-6) # Assign problem: # 1st arg - objective function # 2nd arg - start point #p = NLP(f, x0, c=c, gtol=gtol, contol=contol, iprint = 50, maxIter = 10000, maxFunEvals = 1e7, name = 'NLP_1') x0 = rd.uniform(-0.8, 0.8, num_dof*(2*N+1)) # x0[2*N] = 0 # x0[2*(2*N)] = 0 # x0[3*(2*N)] = 0 #x0 = rd.uniform(-0.1, 0.1, 2*N+1).tolist() + rd.uniform(-0.01, 0.01, 2*N+1).tolist() + rd.uniform(-.001, 0.001, 2*N+1).tolist() #x0 = range(0, num_dof*(2*N+1)) #p = NLP(f, x0, c=c, h=h, gtol=gtol, contol=contol, iprint = 1, maxIter = 1000, maxFunEvals = 1e7, name = 'NLP_1') p = NLP(f, x0, c=c, h=h, gtol=gtol, contol=contol, iprint = 1, maxIter = 700, maxFunEvals = 1e7, name = 'NLP_1') #p = NLP(f, x0, gtol=gtol, contol=contol, iprint = 50, maxIter = 10000, maxFunEvals = 1e7, name = 'NLP_1') #optional: graphic output, requires pylab (matplotlib) p.plot = True solver = 'ralg' #solver = 'scipy_cobyla' #solver = 'algencan' #solver = 'ipopt' #solver = 'scipy_slsqp' # solve the problem r = p.solve(solver, plot=0) # string argument is solver name
# solvers = ['ralg', 'algencan'] solvers = ["ralg"] ############################################################### lines, results = [], {} for j, solver in enumerate(solvers): p = NLP( ff, startPoint, xlabel=Xlabel, gtol=gtol, diffInt=diffInt, ftol=ftol, maxIter=1390, plot=PLOT, color=colors[j], iprint=10, df_iter=4, legend=solver, show=False, contol=contol, maxTime=maxTime, maxFunEvals=maxFunEvals, name="NLP_bench_1", ) p.constraints = [c1 < 0, c2 < 0, h1.eq(0), h2.eq(0), x > lb, x < ub] # p.constraints = h1.eq(0) # p._Prepare() # print p.dc(p.x0) # print h1.D(startPoint)
#print 'len p',len(p) x,z=precompute_r() X,Z=N.meshgrid(x,z) coslist,cosmat_list=precompute_cos(h,k,l,x,z) #print 'coslist',coslist[0] flist=N.ones(len(p0)) flist[M::]=-flist[M::] #vout=chisq_hessian(p,fqerr,p,coslist,flist) #print 'vout', vout # print 'pos',pos_sum(p0) # print 'neg',neg_sum(p0) p = NLP(Entropy, p0, maxIter = 1e3, maxFunEvals = 1e5) #p = NLP(chisq, p0, maxIter = 1e3, maxFunEvals = 1e5) # f(x) gradient (optional): # p.df = S_grad # p.d2f=S_hessian # p.userProvided.d2f=True # lb<= x <= ub: # x4 <= -2.5 # 3.5 <= x5 <= 4.5 # all other: lb = -5, ub = +15 #p.lb =1e-7*N.ones(p.n) #p.ub = N.ones(p.n) p.lb =1e-7*N.ones(p0.shape) p.ub = N.ones(p0.shape)
def AMPGO(objfun, x0, args=(), local='L-BFGS-B', local_opts=None, bounds=None, maxfunevals=None, totaliter=20, maxiter=5, glbtol=1e-5, eps1=0.02, eps2=0.1, tabulistsize=5, tabustrategy='farthest', fmin=-numpy.inf, disp=None): """ Finds the global minimum of a function using the AMPGO (Adaptive Memory Programming for Global Optimization) algorithm. :param `objfun`: Function to be optimized, in the form ``f(x, *args)``. :type `objfun`: callable :param `args`: Additional arguments passed to `objfun`. :type `args`: tuple :param `local`: The local minimization method (e.g. ``"L-BFGS-B"``). It can be one of the available `scipy` local solvers or `OpenOpt` solvers. :type `local`: string :param `bounds`: A list of tuples specifying the lower and upper bound for each independent variable [(`xl0`, `xu0`), (`xl1`, `xu1`), ...] :type `bounds`: list :param `maxfunevals`: The maximum number of function evaluations allowed. :type `maxfunevals`: integer :param `totaliter`: The maximum number of global iterations allowed. :type `totaliter`: integer :param `maxiter`: The maximum number of `Tabu Tunnelling` iterations allowed during each global iteration. :type `maxiter`: integer :param `glbtol`: The optimization will stop if the absolute difference between the current minimum objective function value and the provided global optimum (`fmin`) is less than `glbtol`. :type `glbtol`: float :param `eps1`: A constant used to define an aspiration value for the objective function during the Tunnelling phase. :type `eps1`: float :param `eps2`: Perturbation factor used to move away from the latest local minimum at the start of a Tunnelling phase. :type `eps2`: float :param `tabulistsize`: The size of the tabu search list (a circular list). :type `tabulistsize`: integer :param `tabustrategy`: The strategy to use when the size of the tabu list exceeds `tabulistsize`. It can be 'oldest' to drop the oldest point from the tabu list or 'farthest' to drop the element farthest from the last local minimum found. :type `tabustrategy`: string :param `fmin`: If known, the objective function global optimum value. :type `fmin`: float :param `disp`: If zero or defaulted, then no output is printed on screen. If a positive number, then status messages are printed. :type `disp`: integer :returns: A tuple of 5 elements, in the following order: 1. **best_x** (`array_like`): the estimated position of the global minimum. 2. **best_f** (`float`): the value of `objfun` at the minimum. 3. **evaluations** (`integer`): the number of function evaluations. 4. **msg** (`string`): a message describes the cause of the termination. 5. **tunnel_info** (`tuple`): a tuple containing the total number of Tunnelling phases performed and the successful ones. :rtype: `tuple` The detailed implementation of AMPGO is described in the paper "Adaptive Memory Programming for Constrained Global Optimization" located here: http://leeds-faculty.colorado.edu/glover/fred%20pubs/416%20-%20AMP%20(TS)%20for%20Constrained%20Global%20Opt%20w%20Lasdon%20et%20al%20.pdf Copyright 2014 Andrea Gavana """ if local not in SCIPY_LOCAL_SOLVERS + OPENOPT_LOCAL_SOLVERS: raise Exception('Invalid local solver selected: %s' % local) if local in SCIPY_LOCAL_SOLVERS and not SCIPY: raise Exception( 'The selected solver %s is not available as there is no scipy installation' % local) if local in OPENOPT_LOCAL_SOLVERS and not OPENOPT: raise Exception( 'The selected solver %s is not available as there is no OpenOpt installation' % local) x0 = numpy.atleast_1d(x0) n = len(x0) if bounds is None: bounds = [(None, None)] * n if len(bounds) != n: raise ValueError('length of x0 != length of bounds') low = [0] * n up = [0] * n for i in range(n): if bounds[i] is None: l, u = -numpy.inf, numpy.inf else: l, u = bounds[i] if l is None: low[i] = -numpy.inf else: low[i] = l if u is None: up[i] = numpy.inf else: up[i] = u if maxfunevals is None: maxfunevals = max(100, 10 * len(x0)) if tabulistsize < 1: raise Exception( 'Invalid tabulistsize specified: %s. It should be an integer greater than zero.' % tabulistsize) if tabustrategy not in ['oldest', 'farthest']: raise Exception( 'Invalid tabustrategy specified: %s. It must be one of "oldest" or "farthest"' % tabustrategy) iprint = 50 if disp is None or disp <= 0: disp = 0 iprint = -1 low = numpy.asarray(low) up = numpy.asarray(up) tabulist = [] best_f = numpy.inf best_x = x0 global_iter = 0 all_tunnel = success_tunnel = 0 evaluations = 0 if glbtol < 1e-8: local_tol = glbtol else: local_tol = 1e-8 while 1: if disp > 0: print('\n') print('=' * 72) print('Starting MINIMIZATION Phase %-3d' % (global_iter + 1)) print('=' * 72) if local in OPENOPT_LOCAL_SOLVERS: problem = NLP(objfun, x0, lb=low, ub=up, maxFunEvals=max(1, maxfunevals), ftol=local_tol, iprint=iprint) problem.args = args results = problem.solve(local) xf, yf, num_fun = results.xf, results.ff, results.evals['f'] else: options = {'maxiter': max(1, maxfunevals), 'disp': disp} if local_opts is not None: options.update(local_opts) res = minimize(objfun, x0, args=args, method=local, bounds=bounds, tol=local_tol, options=options) xf, yf, num_fun = res['x'], res['fun'], res['nfev'] maxfunevals -= num_fun evaluations += num_fun if yf < best_f: best_f = yf best_x = xf if disp > 0: print('\n\n ==> Reached local minimum: %s\n' % yf) if best_f < fmin + glbtol: if disp > 0: print('=' * 72) return best_x, best_f, evaluations, 'Optimization terminated successfully', ( all_tunnel, success_tunnel) if maxfunevals <= 0: if disp > 0: print('=' * 72) return best_x, best_f, evaluations, 'Maximum number of function evaluations exceeded', ( all_tunnel, success_tunnel) tabulist = drop_tabu_points(xf, tabulist, tabulistsize, tabustrategy) tabulist.append(xf) i = improve = 0 while i < maxiter and improve == 0: if disp > 0: print('-' * 72) print('Starting TUNNELLING Phase (%3d-%3d)' % (global_iter + 1, i + 1)) print('-' * 72) all_tunnel += 1 r = numpy.random.uniform(-1.0, 1.0, size=(n, )) beta = eps2 * numpy.linalg.norm(xf) / numpy.linalg.norm(r) if numpy.abs(beta) < 1e-8: beta = eps2 x0 = xf + beta * r x0 = numpy.where(x0 < low, low, x0) x0 = numpy.where(x0 > up, up, x0) aspiration = best_f - eps1 * (1.0 + numpy.abs(best_f)) tunnel_args = tuple([objfun, aspiration, tabulist] + list(args)) if local in OPENOPT_LOCAL_SOLVERS: problem = NLP(tunnel, x0, lb=low, ub=up, maxFunEvals=max(1, maxfunevals), ftol=local_tol, iprint=iprint) problem.args = tunnel_args results = problem.solve(local) xf, yf, num_fun = results.xf, results.ff, results.evals['f'] else: options = {'maxiter': max(1, maxfunevals), 'disp': disp} if local_opts is not None: options.update(local_opts) res = minimize(tunnel, x0, args=tunnel_args, method=local, bounds=bounds, tol=local_tol, options=options) xf, yf, num_fun = res['x'], res['fun'], res['nfev'] maxfunevals -= num_fun evaluations += num_fun yf = inverse_tunnel(xf, yf, aspiration, tabulist) if yf <= best_f + glbtol: oldf = best_f best_f = yf best_x = xf improve = 1 success_tunnel += 1 if disp > 0: print( '\n\n ==> Successful tunnelling phase. Reached local minimum: %s < %s\n' % (yf, oldf)) if best_f < fmin + glbtol: return best_x, best_f, evaluations, 'Optimization terminated successfully', ( all_tunnel, success_tunnel) i += 1 if maxfunevals <= 0: return best_x, best_f, evaluations, 'Maximum number of function evaluations exceeded', ( all_tunnel, success_tunnel) tabulist = drop_tabu_points(xf, tabulist, tabulistsize, tabustrategy) tabulist.append(xf) if disp > 0: print('=' * 72) global_iter += 1 x0 = xf.copy() if global_iter >= totaliter: return best_x, best_f, evaluations, 'Maximum number of global iterations exceeded', ( all_tunnel, success_tunnel) if best_f < fmin + glbtol: return best_x, best_f, evaluations, 'Optimization terminated successfully', ( all_tunnel, success_tunnel)
from openopt import NLP from numpy import cos, arange, ones, asarray, abs, zeros N = 30 M = 5 ff = lambda x: ((x-M)**2).sum() p = NLP(ff, cos(arange(N))) def df(x): r = 2*(x-M) r[0] += 15 #incorrect derivative r[8] += 80 #incorrect derivative return r p.df = df p.c = lambda x: [2* x[0] **4-32, x[1]**2+x[2]**2 - 8] def dc(x): r = zeros((2, p.n)) r[0,0] = 2 * 4 * x[0]**3 r[1,1] = 2 * x[1] r[1,2] = 2 * x[2] + 15 #incorrect derivative return r p.dc = dc p.h = lambda x: (1e1*(x[-1]-1)**4, (x[-2]-1.5)**4) def dh(x): r = zeros((2, p.n)) r[0,-1] = 1e1*4*(x[-1]-1)**3 r[1,-2] = 4*(x[-2]-1.5)**3 + 15 #incorrect derivative return r
subjected to y > 5 4x-5z < -1 (x-10)^2 + (y+1)^2 < 50 ''' from openopt import NLP from numpy import * x0 = [0,0,0] # start point estimation # define objective function as a Python language function # of course, you can use "def f(x):" for multi-line functions instead of "f = lambda x:" f = lambda x: (x[0]-1)**2 + (x[1]-2)**2 + (x[2]-3)**4 # form box-bound constraints lb <= x <= ub lb = [-inf, 5, -inf] # lower bound # form general linear constraints Ax <= b A = [4, 0, -5] b = -1 # form general nonlinear constraints c(x) <= 0 c = lambda x: (x[0] - 10)**2 + (x[1]+1) ** 2 - 50 # optionally you can provide derivatives (user-supplied or from automatic differentiation) # for objective function and/or nonlinear constraints, see further doc below p = NLP(f, x0, lb=lb, A=A, b=b, c=c) r = p.solve('ralg') print r.xf # [ 6.25834211 4.99999931 5.20667372]
############################################################### lines, results = [], {} for j, solver in enumerate(solvers): p = NLP( ff, x0, xlabel=Xlabel, c=c, h=h, lb=lb, ub=ub, gtol=gtol, diffInt=diffInt, ftol=ftol, maxIter=1390, plot=PLOT, color=colors[j], iprint=10, df_iter=4, legend=solver, show=False, contol=contol, maxTime=maxTime, maxFunEvals=maxFunEvals, name="NLP_5", ) if solver == "algencan": p.gtol = 1e-2 elif solver == "ralg":
#print 'len pd',len(pd) #print 'len p',len(p) x, z = precompute_r() X, Z = N.meshgrid(x, z) coslist, cosmat_list = precompute_cos(h, k, l, x, z) #print 'coslist',coslist[0] flist = N.ones(len(p0)) flist[M::] = -flist[M::] #vout=chisq_hessian(p,fqerr,p,coslist,flist) #print 'vout', vout # print 'pos',pos_sum(p0) # print 'neg',neg_sum(p0) p = NLP(Entropy, p0, maxIter=1e3, maxFunEvals=1e5) #p = NLP(chisq, p0, maxIter = 1e3, maxFunEvals = 1e5) # f(x) gradient (optional): # p.df = S_grad # p.d2f=S_hessian # p.userProvided.d2f=True # lb<= x <= ub: # x4 <= -2.5 # 3.5 <= x5 <= 4.5 # all other: lb = -5, ub = +15 #p.lb =1e-7*N.ones(p.n) #p.ub = N.ones(p.n) p.lb = 1e-7 * N.ones(p0.shape) p.ub = N.ones(p0.shape) #p.ub[4] = -2.5
from openopt import NLP from numpy import cos, arange, ones, asarray, zeros, mat, array N = 50 # objfunc: # (x0-1)^4 + (x2-1)^4 + ... +(x49-1)^4 -> min (N=nVars=50) f = lambda x : ((x-1)**4).sum() x0 = cos(arange(N)) p = NLP(f, x0, maxIter = 1e3, maxFunEvals = 1e5) # f(x) gradient (optional): p.df = lambda x: 4*(x-1)**3 # lb<= x <= ub: # x4 <= -2.5 # 3.5 <= x5 <= 4.5 # all other: lb = -5, ub = +15 p.lb = -5*ones(N) p.ub = 15*ones(N) p.ub[4] = -2.5 p.lb[5], p.ub[5] = 3.5, 4.5 # Ax <= b # x0+...+xN>= 1.1*N # x9 + x19 <= 1.5 # x10+x11 >= 1.6 p.A = zeros((3, N)) p.A[0, 9] = 1
def __init__(self, calibration, parameter, debug=False): def eqX(industry, Industry): i, I = industry, Industry def equation(x): X, px, pf = x[sX:sF], x[spx:spz], x[spf:epf] pf = np.array([float(x[spf:epf]), 1]) return X[i] - self.calibration.alpha[I] * sum([ pf[h] * self.calibration.FF[H] for h, H in enumerate(parameter.factors) ] / px[i]) return equation def eqpx(i): def equation(x): X, Z = x[sX:sF], x[sZ:spx] return X[i] - Z[i] return equation def eqZ(i): def equation(x): px, pz = x[spx:spz], x[spz:spf] return px[i] - pz[i] return equation def eqpz(j, J): def equation(x): F, Z = Table.unflatten(index=parameter.factors, columns=parameter.industries, sam=x[sF:sZ]), x[sZ:spx] return Z[j] - self.calibration.b[J] * np.prod([ F[J][H]**self.calibration.beta[J][H] for H in parameter.factors ]) return equation def eqpf(H): def equation(x): F = Table.unflatten(index=parameter.factors, columns=parameter.industries, sam=x[sF:sZ]) return sum( F[J][H] for J in parameter.industries) - self.calibration.FF[H] return equation def eqF(h, H, j, J): def equation(x): F, Z, pz, pf = Table.unflatten( index=parameter.factors, columns=parameter.industries, sam=x[sF:sZ]), x[sZ:spx], x[spz:spf], x[spf:epf] pf = np.array([float(x[spf:epf]), 1]) return F[J][ H] - self.calibration.beta[J][H] * pz[j] * Z[j] / pf[h] return equation self.calibration = copy(calibration) self.calibration.X0 = self.calibration.X0['HH'] j = i = len(parameter.industries) h = len(parameter.factors) sX = 0 sF = sX + i sZ = sF + i * h spx = sZ + j spz = spx + i spf = spz + j epf = spf + h - 1 epf_numerair = epf + 1 lb = np.array([(np.float64(0.001))] * epf) self.x = x = np.empty(epf, dtype='f64') x[sX:sF] = self.calibration.X0.data x[sF:sZ] = self.calibration.F0.as_matrix().flatten() x[sZ:spx] = self.calibration.Z0.data x[spx:spz] = [1] * i x[spz:spf] = [1] * j x[spf:epf] = [1] * (epf - spf) self.t = x[:] if debug: self.x = x = np.array([21.1] * epf) print x xnames = [] * (epf_numerair) xnames[sX:sF] = self.calibration.X0.names xnames[sF:sZ] = [ i + h + ' ' for i in parameter.industries for h in parameter.factors ] xnames[sZ:spx] = self.calibration.Z0.names xnames[spx:spz] = parameter.industries xnames[spz:spf] = parameter.industries xnames[spf:epf] = parameter.factors xnames[epf] = parameter.factors[-1] xtypes = [] * epf_numerair xtypes[sX:sF] = ['X0'] * len(self.calibration.X0) xtypes[sF:sZ] = ['F'] * (len(parameter.industries) + len(parameter.factors)) xtypes[sZ:spx] = ['F0'] * len(self.calibration.F0) xtypes[spx:spz] = ['pb'] * len(parameter.industries) xtypes[spz:spf] = ['pz'] * len(parameter.industries) xtypes[spf:epf] = ['pf'] * len(parameter.factors) xtypes[epf] = ['pf'] self.xnametypes = [ '%s %s' % (xnames[i], xtypes[i]) for i in range(epf - 1) ] constraints = [] for i, I in enumerate(parameter.industries): industry, Industry = unlink2(i, I) constraints.append(eqX(industry, Industry)) constraints.append(eqpx(industry)) constraints.append(eqZ(industry)) constraints.append(eqpz(industry, Industry)) for F in parameter.factors: Factor = unlink(F) constraints.append(eqpf(Factor)) for f, F in enumerate(parameter.factors): for i, I in enumerate(parameter.industries): industry, Industry = unlink2(i, I) factor, Factor = unlink2(f, F) constraints.append(eqF(factor, Factor, industry, Industry)) self.UU = UU = lambda x: -np.prod([ x[i]**self.calibration.alpha[i] for i in range(len(parameter.industries)) ]) p = NLP(UU, x, h=constraints, lb=lb, iprint=50, maxIter=10000, maxFunEvals=1e7, name='NLP_1') p.plot = debug self.r = p.solve('ralg', plot=0) if debug: for i, constraint in enumerate(constraints): print(i, '%02f' % constraint(self.r.xf))
from openopt import NLP x0 = [4, 5, 6] #h = lambda x: log(1+abs(4+x[1])) #f = lambda x: log(1+abs(x[0])) f = lambda x: x[0]**4 + x[1]**4 + x[2]**4 df = lambda x: [4*x[0]**3, 4*x[1]**3, 4*x[2]**3] h = lambda x: [(x[0]-1)**2, (x[1]-1)**4] dh = lambda x: [[2*(x[0]-1), 0, 0], [0, 4*(x[1]-1)**3, 0]] colors = ['r', 'b', 'g', 'k', 'y'] solvers = ['ralg','scipy_cobyla', 'algencan', 'ipopt', 'scipy_slsqp'] solvers = ['ralg','algencan'] contol = 1e-8 gtol = 1e-8 for i, solver in enumerate(solvers): p = NLP(f, x0, df=df, h=h, dh=dh, gtol = gtol, diffInt = 1e-1, contol = contol, iprint = 1000, maxIter = 1e5, maxTime = 50, maxFunEvals = 1e8, color=colors[i], plot=0, show = i == len(solvers)) p.checkdh() r = p.solve(solver) # #x0 = 4 ##h = lambda x: log(1+abs(4+x[1])) ##f = lambda x: log(1+abs(x[0])) #f = lambda x: x**4 #h = lambda x: (x-1)**2 #colors = ['r', 'b', 'g', 'k', 'y'] #solvers = ['ralg','scipy_cobyla', 'algencan', 'ipopt', 'scipy_slsqp'] ##solvers = ['algencan'] #contol = 1e-8 #gtol = 1e-8 #for i, solver in enumerate(solvers):
x1 = 1 z1 = 5 z2 = 2 x0 = [x1, z1, z2] # calculate the constraints first [y1, y2, _] = GaussSeidelCoordinator( x1, z1, z2, 0) # find values of y1, y2 that is consistent with x1, z1, z2 coupling.y1 = y1 coupling.y2 = y2 # print initial values print('Initial Objective: ' + str(ObjectiveMain(x0))) print('[x1 z1 z2] = ' + str(x0)) print('[y1 y2] = [' + str(coupling.y1) + ', ' + str(coupling.y2) + ']') # Non linear Programming for optimizing the Sellar problem # documentation at: https://github.com/troyshu/openopt/blob/master/openopt/oo.py p = NLP(f=ObjectiveMain, x0=x0, lb=(0, -10, 0), ub=(10, 10, 10), c=[Constraint1, Constraint2], iprint=50) res = p.solve('scipy_cobyla') # print the results print('\n' + '-' * 50) print('Final Objective: ' + str(res.ff)) print('[x1 z1 z2] = ' + str(res.xf)) print('[y1 y2] = [' + str(coupling.y1) + ', ' + str(coupling.y2) + ']')
# -*- coding: utf-8 -*- ''' Created on 2014/3/26 min (x-1)^2 + (y-2)^2 + (z-3)^4 s.t. y > 5 4x-5z < -1 (x-10)^2 + (y+1)^2 < 50 ''' from FuncDesigner import * from openopt import NLP from time import time t = time() x,y,z = oovars('x', 'y', 'z') f = (x-1)**2 + (y-2)**2 + (z-3)**4 startPoint = {x:0, y:0, z:0} constraints = [y>5, 4*x-5*z<-1, (x-10)**2 + (y+1)**2 < 50] p = NLP(f, startPoint, constraints = constraints) r = p.solve('ipopt') x_opt, y_opt, z_opt = r(x,y,z) print(x_opt, y_opt, z_opt) # x=6.25834212, y=4.99999936, z=5.2066737 print "elapsed %.3f secs"%(time() - t)
""" This is test for future work on ralg It may fail for now """ from FuncDesigner import * from openopt import NLP from numpy import nan a, b = oovars('a', 'b') f = a**2 + b**2 K = 1e5 minTreshold = 0.1 c1 = ifThenElse(a > minTreshold, K * a**2 + 1.0 / K * b**2, nan) < K * minTreshold**2 c2 = a > minTreshold startPoint = {a: -K, b: -K} p = NLP(f, startPoint, constraints=[c1, c2], iprint=10, maxIter=1e4) solver = 'ipopt' solver = 'ralg' #solver = 'scipy_slsqp' r = p.solve(solver)
class data_fitting(): def __init__(self, xdata, ydata, p0, const, mimas, func, *args, **kwargs): self.xdata = xdata self.ydata = ydata self.p0 = p0 self.const = const self.mima = mimas self.func = func self.args = args if "weights" in kwargs: self.weights0 = kwargs['weights'] kwargs.pop('weights') else: self.weights0 = 1. if 'plot' in kwargs: self.plot = kwargs['plot'] kwargs.pop('plot') else: self.plot = plot if 'fit_range' in kwargs: if isscalar(kwargs['fit_range']): start, end, right_border, left_border = set_fitrange(self.xdata, self.ydata, _plot = self.plot) self.x = xdata[start[0]:end[0] + 1] self.y = ydata[start[0]:end[0] + 1] self.start = start[0] self.end = end[0] elif isinstance(kwargs['fit_range'], list): start, end = kwargs['fit_range'] self.x = xdata[start:end + 1] self.y = ydata[start:end + 1] self.start = start self.end = end kwargs.pop('fit_range') try: self.weights = self.weights0[self.start:self.end + 1] except: self.weights = 1. else: self.x = xdata self.y = ydata self.weights = self.weights0 self.kwargs = kwargs def leastsq(self, *args, **kwargs): from scipy.optimize import leastsq if 'plotting' in kwargs: plotting = True kwargs.pop('plotting') else: plotting = False f = lambda p, x, y, weights: (self.func(p, x,self.const,self.mima) - y) / weights self.p, self.cov = leastsq(f, self.p0, reargs = (self.x, self.y, self.weights), **kwargs) if plotting: self.plot(self.xdata, self.ydata, 'o', label = 'original data') self.plot(self.x, self.y, '+') self.plot(self.xdata, self.func(self.p, self.xdata,self.const,self.mima), label = 'fit with scipy.optimize.leastsq') def curve_fit(self, **kwargs): from scipy.optimize import curve_fit if 'plotting' in kwargs: plotting = True kwargs.pop('plotting') else: plotting = False def f(x, *p): return self.func(p[0], x, self.const, self.mima) self.p, self.cov = curve_fit(f, self.x, self.y, p0 = self.p0, sigma = self.weights, **kwargs) if plotting: self.plot(self.xdata, self.ydata, 'o', label = 'original data') self.plot(self.x, self.y, '+') self.plot(self.xdata, self.func(self.p, self.xdata,self.const,self.mima), label = 'fit with scipy.optimize.curve_fit') def odr(self, *args, **kwargs): from scipy import odr if 'plotting' in kwargs: plotting = True kwargs.pop('plotting') else: plotting = False f = lambda p, x: self.func(p, x,self.const,self.mima) self.mod = odr.Model(f) self.dat = odr.Data(self.x, self.y, we = 1. / self.weights) self.my_odr = odr.ODR(self.dat, self.mod, self.p0, *args, **kwargs) self.out = self.my_odr.run() self.p = self.out.beta self.cov = self.out.cov_beta #self.sd = out.sd_beta if plotting: self.plot(self.xdata, self.ydata, 'o', label = 'original data') self.plot(self.x, self.y, '+') self.plot(self.xdata, self.func(self.p, self.xdata,self.const,self.mima), label = 'fit with scipy.odr') def openopt(self, *args, **kwargs): from openopt import NLP if 'plotting' in kwargs: plotting = True kwargs.pop('plotting') else: plotting = False try: solver = args[0] except: solver = 'ralg' self.args += args[1:] self.kwargs.update(kwargs) f = lambda p: sum(((self.func(p, self.x, self.const,self.mima) - self.y) / self.weights)**2) self.prob = NLP(f, x0 = self.p0, *self.args, **self.kwargs) self.res = self.prob.solve(solver) self.p = self.res.xf if plotting: self.plot(self.xdata, self.ydata, 'o', label = 'original data') self.plot(self.x, self.y, '+') self.plot(self.xdata, self.func(self.p, self.xdata,self.const,self.mima), label = 'fit with openopt:\n solver: '+ solver)
from FuncDesigner import * from openopt import NLP from numpy import arange, ones n = 50 kappa = 1.05 Tol = 1e16 c = arange(1, n + 1) / 10.0 x = oovar("x") startPoint = {x: ones(n)} xs = sum(x) cons = (x <= kappa / n * xs)(tol=-1e-6) f = sum(c * x) + 1e-300 * sum(sqrt(-x + kappa / n * xs + Tol)) p = NLP(f, startPoint, constraints=cons) r = p.minimize( "gsubg", dilation=False, iprint=10, ftol=1e-10, fTol=1e-4, xtol=1e-6, maxIter=1e5, maxFunEvals=1e7, T="float128" ) print "objective func evaluations: ", r.evals["f"]
############################################################### solvers = ['ralg', 'scipy_cobyla', 'lincher', 'scipy_slsqp', 'ipopt','algencan'] #solvers = ['ralg', 'ipopt'] solvers = ['ralg', 'scipy_cobyla', 'lincher', 'scipy_slsqp', 'ipopt'] solvers = ['ralg', 'scipy_slsqp', 'scipy_cobyla', 'algencan'] #solvers = ['ipopt','ralg', 'algencan'] solvers = ['ralg', 'scipy_cobyla'] #solvers = ['ralg', 'scipy_slsqp'] #solvers = ['ralg', 'algencan'] solvers = ['ralg'] ############################################################### lines, results = [], {} for j, solver in enumerate(solvers): p = NLP(ff, startPoint, xlabel = Xlabel, gtol=gtol, diffInt = diffInt, ftol = ftol, maxIter = 1390, plot = PLOT, color = colors[j], iprint = 10, df_iter = 4, legend = solver, show=False, contol = contol, maxTime = maxTime, maxFunEvals = maxFunEvals, name='NLP_bench_1') p.constraints = [c1<0, c2<0, h1.eq(0), h2.eq(0), x > lb, x< ub] #p.constraints = h1.eq(0) #p._Prepare() #print p.dc(p.x0) #print h1.D(startPoint) #print h2.D(startPoint) #continue if solver =='algencan': p.gtol = 1e-2 elif solver == 'ralg': pass #p.debug = 1