def optimizationSC(): from scipy.optimize import fmin_cobyla objectiveSC = lambda x: objectNL(x, grad=0) f1Dev = lambda x: x[0] f2Dev = lambda x: x[1] lc1Cstrt = lambda x: x[2] - 1 lc2Cstrt = lambda x: x[3] - 1 fmin_cobyla(objectiveSC, [0.18, 0.09, 1.1, 1.1], [f1Dev, f2Dev, lc1Cstrt, lc2Cstrt], rhobeg=0.2, rhoend=1e-4)
def main(): parse_args() mpm.mp.prec = PREC runtime = str(datetime.datetime.now()) time_start = timeit.default_timer() # filename = "cobyla_wavesolve_run" + str(NSIZE) + runtime fmin_cobyla(objective, [A1, A2, B1, B2, G1, G2], get_constraints, maxfun=MAXFUN, rhobeg=RHOBEG, rhoend=RHOEND)
def mindist(cobramodel,x0,FBAobjval, optreq = 0, tol = 0.001): cobmodel = CobylaModel(cobramodel, tol = tol) if x0 is None: x0 = [0 for element in cobmodel.C] if optreq == 0: minsol = optimize.fmin_cobyla(compdistcomplete,x0,cobmodel.allconstr,args = (cobramodel,),consargs = ()) else: objcon = lambda x, objective = cobmodel.C , value = FBAobjval, optreq = optreq : np.dot(C,x) - FBAobjval*optreq #+ 0.0001 allconstr2 = cobmodel.allconstr + [objcon] minsol = optimize.fmin_cobyla(compdistcomplete,x0,allconstr2,args = (cobramodel,),consargs = ()) return minsol
def fitting(Eqm, Eel, ljd, uniform_weight, output=True): if uniform_weight == True: x = fmin_cobyla(f_opt_LB_cobyla, opt_p_LB, cons, args=(Eqm, Eel, np.array(weight0(Eqm)), np.transpose(ljd)), maxfun=100000, iprint=0) opt_LJ = ljeval_LB(np.transpose(ljdists), x) if output: output_parameters(x) output_goodness(opt_LJ) if out != '': output_energies(opt_LJ) return x else: # 1st iteration x = fmin_cobyla(f_opt_LB_cobyla, opt_p_LB, cons, args=(Eqm, Eel, np.array(weight1(Eqm - Eel)), np.transpose(ljd)), maxfun=100000, iprint=0) opt_LJ = ljeval_LB(np.transpose(ljdists), x) if ver: print "Iteration #1:" output_parameters(x) output_goodness(opt_LJ) # 2nd iteration x = fmin_cobyla(f_opt_LB_cobyla, opt_p_LB, cons, args=(Eqm, Eel, np.array(weight2(Eqm, Eel, opt_LJ)), np.transpose(ljd)), maxfun=100000, iprint=0) opt_LJ2 = ljeval_LB(np.transpose(ljdists), x) if ver: print "Iteration #2:" if output: output_parameters(x) output_goodness(opt_LJ2) if out != '': output_energies(opt_LJ2) return x
def fit(self, lX, ly, sample_weight=None): n_cols = lX.shape[1] x0 = np.ones((n_cols, 1)) constr_lb = [ lambda x, z=i: x[z] - self.lowerbound for i in range(n_cols) ] constr_ub = [ lambda x, z=i: self.upperbound - x[z] for i in range(n_cols) ] constr = constr_lb + constr_ub # constr=constr_lb self.coef_ = fmin_cobyla(self.fopt, x0, constr, args=(lX, ly), consargs=(), rhoend=1e-10, maxfun=10000, disp=0) # coef_ = minimize(fopt, x0,method='COBYLA',constraints=self.constr) # normalize coefficient if self.normalize: self.coef_ = self.coef_ / np.sum(self.coef_) # print "Normalizing coefficients:",self.coef_ if np.isnan(np.sum(self.coef_)): print("We have NaN here...")
def local_refine(f, gts, eqs, x0, rhobeg=1, rhoend=1e-7, maxfun=1e4): """ Use SciPy's COBYLA solver in an attempt to find a minimizer of ``f`` subject to inequality constraints in ``gts`` and equality constraints in ``eqs``. Parameters ---------- f : a callable function The minimization objective. gts : a list of callable functions Each ``g in gts`` specifies an inequality constraint ``g(x) >= 0``. eqs : a list of callable functions Each ``g in eqs`` specifies an equality constraint ``g(x) == 0``. x0 : ndarray An initial point for COBYLA. rhobeg : float Controls the size of COBYLA's initial search space. rhoend : float Termination criteria, controlling the size of COBYLA's smallest search space. maxfun : int Termination criteria, bounding the number of COBYLA's iterations. Returns ------- x : ndarray The solution returned by COBYLA. """ maxfun = int(maxfun) x = fmin_cobyla(f, x0, gts + eqs + [-g for g in eqs], rhobeg=rhobeg, rhoend=rhoend, maxfun=maxfun) return x
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 q4(): r = 0.05 # annual interest rate (with 6 month compounding) recrate = [0.1, 0.25, 0.5, 0.1, 0.2] coupon = [0.05, 0.02, 0.05, 0.05, 0.1] nperiod = [2 * x for x in range(1, 6)] fs = [fdb(r / 2, c, rec, nper) for c, rec, nper in zip(coupon, recrate, nperiod)] h0 = np.linspace(0.1, 0.9, nperiod[-1]) h0 = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 0.99]) h0 = 0.05 * np.ones((nperiod[-1] + 1,)) bondprices = np.array([100.92, 91.56, 105.60, 98.90, 137.48]) / 100 def nonneg(h): h = copy.deepcopy(h) h[h > 0] = 0 return np.sum(h) def monotonic(h): x = h[1:] - h[:-1] x[x > 0] = 0 return np.sum(x) hopt = fmin_cobyla(lambda hr: np.sum(([f(hr) for f in fs] - bondprices) ** 2), h0, [nonneg, monotonic], disp=0) return hopt
def test_simple(self): x = fmin_cobyla(self.fun, self.x0, [self.con1, self.con2], rhobeg=1, rhoend=1e-5, maxfun=100) assert_allclose(x, self.solution, atol=1e-4)
def fullA_Xing(X,S,D): #X: the data matrix #S: the similarity Matrix #D: the dissimilarty Matrix #Creating the objective function and the constraints function here def objective(A): values = [] for i in range(S.shape[0]): for j in range(S.shape[1]): if S[i,j] == 0: continue M = np.matrix(X[i] - X[j]) values.append(np.sum((M*A)*M.T)) return np.sum(np.array(values)) def constraint(A): values = [] for i in range(D.shape[0]): for j in range(D.shape[1]): if D[i,j] == 0: continue M = np.matrix(X[i]-X[j]) values.append(np.sqrt(np.sum((M*A)*M.T))) return np.sum(np.array(values)) A0 = np.random.rand(X.shape[1], X.shape[1]) return fmin_cobyla(objective, A0, [constraint], rhoend=1e-7)
def fit_adsorption_kinetics_fmin_cobyla(self): from scipy.optimize import fmin_cobyla def constr0(params): return params[0] def constr1(params): return params[1] def constr2(params): return params[2] error = self.compute_error(self.initial_parameters, self.concentrations, self.mean_surf_conc, self.times) self.initial_sse = error self.fitted_parameters = fmin_cobyla(self.compute_error, self.initial_parameters, [], args=self.model_parameters, consargs=(), rhobeg=min( self.initial_parameters), rhoend=1e-9, iprint=2) error = self.compute_error(self.fitted_parameters, self.concentrations, self.mean_surf_conc, self.times) self.final_sse = error
def get_weights(): # Read validation labels _, labels, _, _, _ = utils.load_data() skf = StratifiedKFold(labels, n_folds=5, random_state=23) test_index = None for _, test_idx in skf: test_index = np.append( test_index, test_idx) if test_index is not None else test_idx val_labels = labels[test_index] # Read predictions on validation set val_predictions = [] prediction_files = utils.get_prediction_files() for preds_file in prediction_files: vp = np.genfromtxt(os.path.join(consts.BLEND_PATH, preds_file), delimiter=',') val_predictions.append(vp) # Minimize blending function p0 = [1.] * len(prediction_files) p = fmin_cobyla(error, p0, args=(val_predictions, val_labels), cons=[constraint], rhoend=1e-5) return p
def calc_variable_arrays(self, trend_mod, data, periods): """ Function to calculate arrays that depend on changing starting variables, i.e. trend modifier Parameters ---------- trend_modifier : float Trend modifier value for exponential dampened smoothing function. data : array Data array that needs to be forecasted periods : integer Number of periods to forecast. """ self.xs = data self.fcast_periods = periods self.data_N = self.xs.size self.warmUp = self.data_N / 2 # Going with a warm-up of half the data, instead of 6 self.zero_len = self.data_N + self.fcast_periods # Length of arrays with one missing value self.lvlArr = np.zeros(self.zero_len + 1) self.errors = np.zeros(self.data_N) self.trendArr = np.zeros(self.zero_len + 1) self.fcasts = np.zeros(self.zero_len) avg_first_four_diffs = np.average(np.diff(self.xs[:4 + 1])) self.trendArr[0] = avg_first_four_diffs self.lvlArr[0] = self.xs[0] - avg_first_four_diffs self.trend_modifier = trend_mod self.trend_exp = np.ones(self.zero_len + 1) self.trend_exp[self.data_N:] = np.power( self.trend_modifier, (np.arange(self.data_N + 1, self.zero_len + 2) - self.data_N) ) self.trend_multiplier = np.zeros(self.zero_len + 1) self.trend_multiplier[self.data_N:] = np.cumsum(self.trend_exp[self.data_N:]) return optimize.fmin_cobyla(self.exp_smooth_forecast, self.x0, self.constrs, iprint=0)
def main(self, fit_params=None, par=None, Rd=None, Ci=None, N_p=None, Tleaf=None, Q10=None, Eaj=None, Eav=None, deltaSj=None, deltaSv=None, r25=None, Hdv=200000.0, Hdj=200000.0, Tref=None): """ figure out the optimal allocation of nitrogen """ result = opt.fmin_cobyla(self.objective, x0=fit_params, disp=0, cons=[ self.constraint_Np, self.constraint_Nc, self.constraint_Ne, self.constraint_Nr ], args=(par, Rd, Ci, N_p, Tleaf, Q10, Eaj, Eav, deltaSj, deltaSv, r25, Hdv, Hdj, Tref), consargs=(N_p, )) return result
def find_min_dist_residual(f, points, dis_threshold): def objective(X, P): # print "objective:",X,P # P is point and X is a point on curve x, y = np.ndarray.tolist(np.asarray(X).reshape((2))) return np.sqrt((x - P[0])**2 + (y - P[1])**2) def c1(X, P): X = np.asarray(X).reshape((2)) P = np.asarray(P).reshape((2)) return f(X, P) summation = 0 indices = [] for i in range(points.shape[0]): P = points[i, :] # print "point of cloud:", P X = fmin_cobyla(objective, x0=[P], cons=[c1], args=([P]), consargs=([P])) # print objective(X, P) dist = objective(X, P) if dist <= dis_threshold: summation += objective(X, P) indices.append(i) return summation / points.shape[0], indices
def _fit_sphere(points, disp='auto'): """Aux function to fit a sphere to an arbitrary set of points""" from scipy.optimize import fmin_cobyla if isinstance(disp, string_types) and disp == 'auto': disp = True if logger.level <= 20 else False # initial guess for center and radius radii = (np.max(points, axis=1) - np.min(points, axis=1)) / 2. radius_init = radii.mean() center_init = np.median(points, axis=0) # optimization x0 = np.concatenate([center_init, [radius_init]]) def cost_fun(center_rad): d = points - center_rad[:3] d = (np.sqrt(np.sum(d * d, axis=1)) - center_rad[3]) return np.sum(d * d) def constraint(center_rad): return center_rad[3] # radius must be >= 0 x_opt = fmin_cobyla(cost_fun, x0, constraint, rhobeg=radius_init, rhoend=radius_init * 1e-6, disp=disp) origin = x_opt[:3] radius = x_opt[3] return radius, origin
def getCostPerformanceCurve(): X_opt = [] f_opt = [] TP_opt = [] cost_opt = [] for i in range(len(weights)): OP.W = weights[i] X_opt.append([]) TP_opt.append([]) cost_opt.append([]) f_opt.append([]) for j in initial_guesses: x = fmin_cobyla(func=OP.ObjectiveFunction, x0=j, cons=OP.constraints, rhobeg=1, rhoend=1e-3) X_opt[i].append(x) TP_opt[i].append(OP.NormalizedThroughput(OP.Clip(x))) cost_opt[i].append(OP.NormalizedCost(OP.Clip(x))) f_opt[i].append(OP.ObjectiveFunction(x)) #write the arrays out to a file with open("RESULT_X_opt.py", "w") as f: print >> f, "X_opt=", X_opt with open("RESULT_TP_opt.py", "w") as f: print >> f, "TP_opt=", TP_opt with open("RESULT_cost_opt.py", "w") as f: print >> f, "cost_opt=", cost_opt with open("RESULT_f_opt.py", "w") as f: print >> f, "f_opt=", f_opt
def aim_point(self, model, params, dataX, dataY, delta=0.001, return_dist=False, **kwargs): dist2 = list() aim_points = list() for index, row in np.ndenumerate(dataX): p = (dataX[index], dataY[index]) funct = lambda x: model.eval(params, x) obj = lambda X: self.evaldist2(model, params, p[0], X[0], p[1], X[ 1]) greater_coeff = 1 if dataY[index] - funct(dataX[index]) > 0 else -1 def c1(X): x, y = X return greater_coeff * (y - funct(x)) p0 = (dataX[index], funct(dataX[index])) X = fmin_cobyla(obj, x0=p0, cons=[c1]) aim_points.append(X[0]) if return_dist: dist2.append(obj(X)) self.logger.debug(f"Aim: {aim_points}") if return_dist: return dist2, aim_points return aim_points
def blend_predictions(train_preds, test_preds, labels, ids_sub, skf, save_results=False): test_index = None for _, test_idx in skf: test_index = np.append(test_index, test_idx) if test_index is not None else test_idx val_labels = labels[test_index] val_predictions, val_submission = [], [] for i in range(np.shape(train_preds)[1]): val_predictions.append(train_preds[:,i]) for i in range(np.shape(test_preds)[1]): val_submission.append(test_preds[:, i]) p0 = [1.] * len(val_predictions) p = fmin_cobyla(error, p0, args=(val_predictions, val_labels), cons=[constraint], rhoend=1e-5) err = error(p, val_predictions, val_labels) print 'error:', err y_submission = blended(p, val_submission) if save_results: csv_output = 'submission_{}.csv'.format(time.strftime("%Y%m%d-%H%M%S")) pd.DataFrame({"ID": ids_sub, "PredictedProb": y_submission}).to_csv(csv_output, index=False) print 'saving:', csv_output return err
def COBYLAEstimator(S, binnedTrain, abg_init): from scipy.optimize import fmin_cobyla print 'COBYLA method: ' constraints = [lambda p: p[0]- .01, lambda p: 8. - p[0], lambda p: p[1] - .01, lambda p: 5. - p[1], lambda p: p[2] - .01, lambda p: 8. - p[2]] # lbounds = ((.01, 5.), # (.01, 5.), # (.0 , 5.) ); # def func(abg): 'Solve it:' Fs = S.solve(abg, visualize=False) Ss = S.transformSurvivorData(binnedTrain) Ls = Fs[:,:,-1] - Ss 'Return ' G = .5*sum(Ls*Ls)*S._dt return G abg_est = fmin_cobyla(func, abg_init, constraints, disp=0); return abg_est
def __solver__(self, p): #p.kernelIterFuncs.pop(SMALL_DELTA_X) #p.kernelIterFuncs.pop(SMALL_DELTA_F) xBounds2Matrix(p) p.cobyla = EmptyClass() if p.userProvided.c: p.cobyla.nc = p.c(p.x0).size else: p.cobyla.nc = 0 if p.userProvided.h: p.cobyla.nh = p.h(p.x0).size else: p.cobyla.nh = 0 det_arr = cumsum(array((p.cobyla.nc, p.cobyla.nh, p.b.size, p.beq.size, p.cobyla.nh, p.beq.size))) cons = [] for i in range(det_arr[-1]): if i < det_arr[0]: c = lambda x, i=i: - p.c(x)[i] # cobyla requires positive constraints! elif det_arr[0] <= i < det_arr[1]: j = i - det_arr[0] c = lambda x, j=j: p.h(x)[j] elif det_arr[1] <= i < det_arr[2]: j = i - det_arr[1] #assert 0<= j <p.cobyla.nb c = lambda x, j=j: p.b[j] - p.dotmult(p.A[j], x).sum() # cobyla requires positive constraints! elif det_arr[2] <= i < det_arr[3]: j = i - det_arr[2] #assert 0<= j <p.cobyla.nbeq c = lambda x, j=j: p.dotmult(p.Aeq[j], x).sum() - p.beq[j] elif det_arr[3] <= i < det_arr[4]: j = i - det_arr[3] c = lambda x, j=j: - p.h(x)[j] elif det_arr[4] <= i < det_arr[5]: j = i - det_arr[4] #assert 0<= j <p.cobyla.nbeq c = lambda x, j=j: p.dotmult(p.Aeq[j], x).sum() - p.beq[j] else: p.err('error in connection cobyla to openopt') cons.append(c) ## def oo_cobyla_cons(x): ## c0 = -p.c(x) ## c1 = p.h(x) ## c2 = -(p.matmult(p.A, x) - p.b) ## c3 = p.matmult(p.Aeq, x) - p.beq ## return hstack((c0, c1, -c1, c2, c3, -c3)) # p.xk = p.x0.copy() # p.fk = p.f(p.x0) # # p.iterfcn() # if p.istop: # p.xf = p.xk # p.ff = p.fk # return xf = fmin_cobyla(p.f, p.x0, cons = tuple(cons), iprint = 0, maxfun = p.maxFunEvals, rhoend = p.xtol ) p.xk = xf p.fk = p.f(xf) p.istop = 1000
def fitting(Eqm,Eel,ljd,uniform_weight,output=True): if uniform_weight == True: x = fmin_cobyla(f_opt_LB_cobyla, opt_p_LB, cons, args=(Eqm, Eel, np.array(weight0(Eqm)), np.transpose(ljd)), maxfun=100000, iprint=0) opt_LJ = ljeval_LB(np.transpose(ljdists),x) if output: output_parameters(x) output_goodness(opt_LJ) if out != '': output_energies(opt_LJ) return x else: # 1st iteration x = fmin_cobyla(f_opt_LB_cobyla, opt_p_LB, cons, args=(Eqm, Eel, np.array(weight1(Eqm-Eel)), np.transpose(ljd)), maxfun=100000, iprint=0) opt_LJ = ljeval_LB(np.transpose(ljdists),x) if ver: print "Iteration #1:" output_parameters(x) output_goodness(opt_LJ) # 2nd iteration x = fmin_cobyla(f_opt_LB_cobyla, opt_p_LB, cons, args=(Eqm, Eel, np.array(weight2(Eqm,Eel,opt_LJ)), np.transpose(ljd)), maxfun=100000, iprint=0) opt_LJ2 = ljeval_LB(np.transpose(ljdists),x) if ver: print "Iteration #2:" if output: output_parameters(x) output_goodness(opt_LJ2) if out != '': output_energies(opt_LJ2) return x
def _from_samples(histogram, alpha, ordered=False): """ Reference: T. Denoeux (2006), "Constructing belief functions from sample data using multinomial confidence regions", International Journal of Approximate Reasoning 42, 228-252. """ p_lower, p_upper = MassFunction._confidence_intervals(histogram, alpha) def p_lower_set(hs): l = u = 0 for h in H: if h in hs: l += p_lower[h] else: u += p_upper[h] return max(l, 1 - u) if ordered: H = sorted(histogram.keys()) m = MassFunction() for i1, h1 in enumerate(H): m[(h1, )] = p_lower[h1] for i2, h2 in enumerate(H[i1 + 1:]): i2 += i1 + 1 if i2 == i1 + 1: v = p_lower_set( H[i1:i2 + 1]) - p_lower[h1] - p_lower[h2] else: v = p_lower_set(H[i1:i2 + 1]) - p_lower_set( H[i1 + 1:i2 + 1]) - p_lower_set( H[i1:i2]) + p_lower_set(H[i1 + 1:i2]) if v > 0: m[H[i1:i2 + 1]] = v return m else: H = list(histogram.keys()) L = 2**len(H) initial = numpy.zeros(L) cons = [] singletons = lambda index: [ i for i in range(len(H)) if 2**i & index ] # constraint (24) bel = lambda index, m: fsum(m[sum([2**i for i in h_ind])] for h_ind in powerset(singletons(index))) c24 = lambda m, i: p_lower_set(MassFunction._from_array_index( i, H)) - bel(i, m) for i in range(L): cons.append(partial(c24, i=i)) # constraint (25) cons.append(lambda m: m.sum() - 1.0) cons.append(lambda m: 1.0 - m.sum()) # constraint (26) for i in range(L): cons.append(partial(lambda m, i_s: m[i_s], i_s=i)) f = lambda m: -1 * 2**len(H) * fsum( [m[i] * 2**(-len(singletons(i))) for i in range(L)]) m_optimal = fmin_cobyla(f, initial, cons, disp=0) return MassFunction.from_array(m_optimal, H)
def _fit_chpi_pos(est_pos_dev, hpi_head_rrs, x0): """Fit rotation and translation parameters for cHPI coils""" from scipy.optimize import fmin_cobyla denom = np.sum((hpi_head_rrs - np.mean(hpi_head_rrs, axis=0)) ** 2) objective = partial(_chpi_objective, est_pos_dev=est_pos_dev, hpi_head_rrs=hpi_head_rrs) x = fmin_cobyla(objective, x0, (), rhobeg=1e-2, rhoend=1e-6, disp=False) return x, 1. - objective(x) / denom
def fitPspCobyla(x, y, guess, bounds, risePower=1.0): def cons(v, *args): ret = 1 if all(v > bounds[:,0]) and all(v < bounds[:,1]) else 0 #print "Constraint:", v, ret return ret fit = opt.fmin_cobyla(errFn, guess, [cons], args=(x,y,risePower), disp=0) return fit
def get_offset_cost(self): # Get closest point from the curve X = fmin_cobyla(offset_obj, x0=[self.state[0], self.state[1]], cons=[c1]) x_r, y_r = X state_diff = np.array([state[0]-x_r, state[1]-y_r]) Qk = np.array([[1,0,0],[0,1,0],[0,0,self.args.w_vel]]) return np.matmul(np.matmul(state_diff.T*Q),state_diff)
def fitPspCobyla(x, y, guess, bounds, risePower=1.0): def cons(v, *args): ret = 1 if all(v > bounds[:, 0]) and all(v < bounds[:, 1]) else 0 #print "Constraint:", v, ret return ret fit = opt.fmin_cobyla(errFn, guess, [cons], args=(x, y, risePower), disp=0) return fit
def _fit_dipole(min_dist_to_inner_skull, B_orig, t, rrs, guess_fwd_svd, fwd_data, whitener, proj_op, fmin_cobyla): """Fit a single bit of data""" B = np.dot(whitener, B_orig) surf = None # make constraint function to keep the solver within the inner skull if isinstance(fwd_data["inner_skull"], dict): # bem surf = fwd_data["inner_skull"] def constraint(rd): dist = _compute_nearest(surf["rr"], rd[np.newaxis, :], return_dists=True)[1][0] if _points_outside_surface(rd[np.newaxis, :], surf, 1)[0]: dist *= -1.0 # Once we know the dipole is below the inner skull, # let's check if its distance to the inner skull is at least # min_dist_to_inner_skull. This can be enforced by adding a # constrain proportional to its distance. dist -= min_dist_to_inner_skull return dist else: # sphere R, r0 = fwd_data["inner_skull"] R_adj = R - 1e-3 # to be sure we don't hit the innermost surf def constraint(rd): return R_adj - np.sqrt(np.sum((rd - r0) ** 2)) # Find a good starting point (find_best_guess in C) B2 = np.dot(B, B) if B2 == 0: logger.warning("Zero field found for time %s" % t) return np.zeros(3), 0, np.zeros(3), 0 x0 = rrs[np.argmin([_fit_eval(rrs[fi][np.newaxis, :], B, B2, fwd_svd) for fi, fwd_svd in enumerate(guess_fwd_svd)])] fun = partial(_fit_eval, B=B, B2=B2, fwd_data=fwd_data, whitener=whitener, constraint=constraint) # Tested minimizers: # Simplex, BFGS, CG, COBYLA, L-BFGS-B, Powell, SLSQP, TNC # Several were similar, but COBYLA won for having a handy constraint # function we can use to ensure we stay inside the inner skull / # smallest sphere rd_final = fmin_cobyla(fun, x0, (constraint,), consargs=(), rhobeg=5e-2, rhoend=1e-4, disp=False) # Compute the dipole moment at the final point Q, gof, residual = _fit_Q(fwd_data, whitener, proj_op, B, B2, B_orig, rd_final) amp = np.sqrt(np.dot(Q, Q)) norm = 1.0 if amp == 0.0 else amp ori = Q / norm msg = "---- Fitted : %7.1f ms" % (1000.0 * t) if surf is not None: dist_to_inner_skull = _compute_nearest(surf["rr"], rd_final[np.newaxis, :], return_dists=True)[1][0] msg += ", distance to inner skull : %2.4f mm" % (dist_to_inner_skull * 1000.0) logger.info(msg) return rd_final, amp, ori, gof, residual
def _from_samples_consonant(histogram, alpha, approximate=False): """ Reference: A. Aregui, T. Denoeux (2008), "Constructing consonant belief functions from sample data using confidence sets of pignistic probabilities", International Journal of Approximate Reasoning 49, 575-594. """ p_lower, p_upper = MassFunction._confidence_intervals(histogram, alpha) H = list(histogram.keys()) if approximate: # approximate possibility distribution poss = { h1: min(1, fsum([min(p_upper[h1], p_upper[h2]) for h2 in H])) for h1 in H } else: # optimal possibility distribution (based on linear programming) poss = {h: 0 for h in H} for k, h_k in enumerate(H): S_k = { l for l in range(len(H)) if p_lower[H[l]] >= p_upper[h_k] } S_k.add(k) I_k = { l for l in range(len(H)) if p_upper[H[l]] < p_lower[h_k] } P_k = set(range(len(H))).difference(S_k.union(I_k)) for A in powerset(P_k): G = S_k.union(A) G_c = set(range(len(H))).difference(G) cons = [] # constraint (26) for i, h in enumerate(H): cons.append( partial(lambda p, i_s, p_s: p[i_s] - p_s, i_s=i, p_s=p_lower[h])) # lower bound cons.append( partial(lambda p, i_s, p_s: p_s - p[i_s], i_s=i, p_s=p_upper[h])) # upper bound # constraint (27) cons.append(lambda p: 1 - sum(p)) cons.append(lambda p: sum(p) - 1) # constraint (30) for i in G: cons.append( partial(lambda p, i_s: p[i_s] - p[k], i_s=i)) # constraint (31) for i in G_c: cons.append( partial(lambda p, i_s: p[k] - p[i_s], i_s=i)) initial = [1.0 / len(H)] * len(H) f = lambda p: -(fsum([p[i] for i in G_c]) + len(G) * p[k]) poss_optimal = fmin_cobyla(f, initial, cons, disp=0) poss[h_k] = max(poss[h_k], -f(poss_optimal)) return MassFunction.from_possibility(poss)
def _fit_dipole(min_dist_to_inner_skull, B_orig, t, guess_rrs, guess_data, fwd_data, whitener, proj_op, fmin_cobyla, ori): """Fit a single bit of data.""" B = np.dot(whitener, B_orig) # make constraint function to keep the solver within the inner skull if isinstance(fwd_data['inner_skull'], dict): # bem surf = fwd_data['inner_skull'] constraint = partial(_surface_constraint, surf=surf, min_dist_to_inner_skull=min_dist_to_inner_skull) else: # sphere surf = None R, r0 = fwd_data['inner_skull'] constraint = partial(_sphere_constraint, r0=r0, R_adj=R - min_dist_to_inner_skull) del R, r0 # Find a good starting point (find_best_guess in C) B2 = np.dot(B, B) if B2 == 0: warn('Zero field found for time %s' % t) return np.zeros(3), 0, np.zeros(3), 0, B idx = np.argmin([_fit_eval(guess_rrs[[fi], :], B, B2, fwd_svd) for fi, fwd_svd in enumerate(guess_data['fwd_svd'])]) x0 = guess_rrs[idx] fun = partial(_fit_eval, B=B, B2=B2, fwd_data=fwd_data, whitener=whitener) # Tested minimizers: # Simplex, BFGS, CG, COBYLA, L-BFGS-B, Powell, SLSQP, TNC # Several were similar, but COBYLA won for having a handy constraint # function we can use to ensure we stay inside the inner skull / # smallest sphere rd_final = fmin_cobyla(fun, x0, (constraint,), consargs=(), rhobeg=5e-2, rhoend=5e-5, disp=False) # simplex = _make_tetra_simplex() + x0 # _simplex_minimize(simplex, 1e-4, 2e-4, fun) # rd_final = simplex[0] # Compute the dipole moment at the final point Q, gof, residual = _fit_Q(fwd_data, whitener, proj_op, B, B2, B_orig, rd_final, ori=ori) amp = np.sqrt(np.dot(Q, Q)) norm = 1. if amp == 0. else amp ori = Q / norm msg = '---- Fitted : %7.1f ms' % (1000. * t) if surf is not None: dist_to_inner_skull = _compute_nearest( surf['rr'], rd_final[np.newaxis, :], return_dists=True)[1][0] msg += (", distance to inner skull : %2.4f mm" % (dist_to_inner_skull * 1000.)) logger.info(msg) return rd_final, amp, ori, gof, residual
def _fit_chpi_pos(coil_dev_rrs, coil_head_rrs, x0): """Fit rotation and translation parameters for cHPI coils""" from scipy.optimize import fmin_cobyla denom = np.sum((coil_head_rrs - np.mean(coil_head_rrs, axis=0)) ** 2) objective = partial(_chpi_objective, coil_dev_rrs=coil_dev_rrs, coil_head_rrs=coil_head_rrs) x = fmin_cobyla(objective, x0, _unit_quat_constraint, rhobeg=1e-2, rhoend=1e-6, disp=False) return x, 1. - objective(x) / denom
def _fit_magnetic_dipole(B_orig, w, coils, x0): """Fit a single bit of data (x0 = pos)""" from scipy.optimize import fmin_cobyla B = np.dot(w, B_orig) B2 = np.dot(B, B) objective = partial(_magnetic_dipole_objective, B=B, B2=B2, w=w, coils=coils) x = fmin_cobyla(objective, x0, (), rhobeg=1e-2, rhoend=1e-4, disp=False) return x, 1. - objective(x) / B2
def train(self, inp, out, t): from scipy.optimize import fmin_cobyla self.t = t self.b = out.mean() constr = [lambda p, inp, out: self.t - sum(p)] for i in range(self.params.shape[0]): constr.append(Pick(i)) self.updateparams(fmin_cobyla(self.objective,self.params.copy(),\ constr,(inp,out),maxfun=100000))
def test_simple(self): # use disp=True as smoke test for gh-8118 x = fmin_cobyla(self.fun, self.x0, [self.con1, self.con2], rhobeg=1, rhoend=1e-5, maxfun=100, disp=True) assert_allclose(x, self.solution, atol=1e-4)
def _fit_magnetic_dipole(B_orig, x0, coils, scale, method): """Fit a single bit of data (x0 = pos).""" from scipy.optimize import fmin_cobyla B = np.dot(scale, B_orig) B2 = np.dot(B, B) objective = partial(_magnetic_dipole_objective, B=B, B2=B2, coils=coils, scale=scale, method=method) x = fmin_cobyla(objective, x0, (), rhobeg=1e-4, rhoend=1e-5, disp=False) return x, 1. - objective(x) / B2
def _optimize(self, left: FitData, right: FitData, kwa, params): if self.symmetry is Symmetry.both: cost = lambda x: self._sym(left, right, x[0], x[1]) elif self.symmetry is Symmetry.left: cost = lambda x: self._asym(left, right, x[0], x[1]) else: cost = lambda x: self._asym(left, right, 1. / x[0], -x[0] * x[1]) tmp = fmin_cobyla(cost, params, **kwa) return (cost(tmp), tmp[0], tmp[1])
def _minimize(x_0: np.array) -> np.array: return fmin_cobyla(objective, x_0, constraints, rhobeg=self._rhobeg, rhoend=self._rhoend, maxfun=self._maxfun, disp=self._disp, catol=self._catol)
def train(self,inp,out,t): from scipy.optimize import fmin_cobyla self.t = t self.b = out.mean() constr = [lambda p, inp, out: self.t - sum(p)] for i in range(self.params.shape[0]): constr.append(Pick(i)) self.updateparams(fmin_cobyla(self.objective,self.params.copy(),\ constr,(inp,out),maxfun=100000))
def _minimize(x_0: np.ndarray) -> Tuple[np.ndarray, Any]: x = fmin_cobyla(objective, x_0, constraints, rhobeg=self._rhobeg, rhoend=self._rhoend, maxfun=self._maxfun, disp=self._disp, catol=self._catol) return x, None
def similarity_correction(sim, reads, N, negative_correction=True): """ Calculate corrected abundances given a similarity matrix and observations using optimization. Copied from GASiC, for metaproteomic experiments replace the term 'reads' with 'spectra'. Input: sim: [numpy.array (M,M)] with pairwise similarities between species reads: [numpy.array (M,)] with number of observed reads for each species N: [int] total number of reads negative_correction: [boolean] whether numerical errors (negative values) should be corrected or not Output: abundances: [numpy.array (M,)] estimated abundance of each species in the sample """ # transform reads to abundances and rename similarity matrix A = np.transpose(sim) r = reads.astype(np.float) / N rng = range(len(reads)) # Now solve the optimization problem: min_c |Ac-r|^2 s.t. c_i >= 0 and 1-sum(c_i) >= 0 # construct objective function def objective(c): # numpy implementation of objective function |A*c-r|^2 return np.sum(np.square(np.dot(A, c) - r)) # construct constraints def build_con(k): # constraint: k'th component of x should be >0 return lambda c: c[k] cons = [build_con(k) for k in rng] # constraint: the sum of all components of x should not exceed 1 cons.append(lambda c: 1 - np.sum(c)) # initial guess c_0 = np.array([0.5 for i in range(len(reads))]) # finally: optimization procedure abundances = opt.fmin_cobyla(objective, c_0, cons, disp=0, rhoend=1e-10, maxfun=10000) if negative_correction: for i in range(len(abundances)): if abundances[i] < 0: print "warning: correcting negative similarity ", abundances[ i], " -> 0" abundances[i] = 0 return abundances
def _fit_magnetic_dipole(B_orig, x0, coils, scale, method, too_close): """Fit a single bit of data (x0 = pos).""" from scipy.optimize import fmin_cobyla B = dgemv(alpha=1, a=scale, x=B_orig) # np.dot(scale, B_orig) B2 = ddot(B, B) # np.dot(B, B) lwork = _svd_lwork((3, B_orig.shape[0])) objective = partial(_magnetic_dipole_objective, B=B, B2=B2, coils=coils, scale=scale, method=method, too_close=too_close, lwork=lwork) x = fmin_cobyla(objective, x0, (), rhobeg=1e-4, rhoend=1e-5, disp=False) return x, 1. - objective(x) / B2
def setGravity(self): window_size = 15 d = self.aConfigs[len(self.aConfigs)-window_size:] def func(x): return (np.sum(np.dot(d-x,x))/np.linalg.norm(x))**2 def constr(x): return np.linalg.norm(x) - CONST_GRAVITY self.gravity = fmin_cobyla(func, [0., 0., 0.], constr, rhoend=1e-7)
def test_vector_constraints(): # test that fmin_cobyla and minimize can take a combination # of constraints, some returning a number and others an array def fun(x): return (x[0] - 1)**2 + (x[1] - 2.5)**2 def fmin(x): return fun(x) - 1 def cons1(x): a = np.array([[1, -2, 2], [-1, -2, 6], [-1, 2, 2]]) return np.array([a[i, 0] * x[0] + a[i, 1] * x[1] + a[i, 2] for i in range(len(a))]) def cons2(x): return x # identity, acts as bounds x > 0 x0 = np.array([2, 0]) cons_list = [fun, cons1, cons2] xsol = [1.4, 1.7] fsol = 0.8 # testing fmin_cobyla sol = fmin_cobyla(fun, x0, cons_list, rhoend=1e-5, iprint=0) assert_allclose(sol, xsol, atol=1e-4) sol = fmin_cobyla(fun, x0, fmin, rhoend=1e-5, iprint=0) assert_allclose(fun(sol), 1, atol=1e-4) # testing minimize constraints = [{'type': 'ineq', 'fun': cons} for cons in cons_list] sol = minimize(fun, x0, constraints=constraints, tol=1e-5) assert_allclose(sol.x, xsol, atol=1e-4) assert_(sol.success, sol.message) assert_allclose(sol.fun, fsol, atol=1e-4) constraints = {'type': 'ineq', 'fun': fmin} sol = minimize(fun, x0, constraints=constraints, tol=1e-5) assert_allclose(sol.fun, 1, atol=1e-4)
def __call__(self): self.first_guess() self.current_solution = opt.fmin_cobyla(self.criterion, self.current_solution, self.cons, args=self.args, **self.kwargs) # output depends on kwargs ... if isinstance(self.optimizer_output, tuple): self.current_solution = self.optimizer_output[0] else: self.current_solution = self.optimizer_output return self.current_solution
def _fit_chpi_pos(coil_dev_rrs, coil_head_rrs, x0): """Fit rotation and translation parameters for cHPI coils.""" from scipy.optimize import fmin_cobyla denom = np.sum((coil_head_rrs - np.mean(coil_head_rrs, axis=0)) ** 2) objective = partial(_chpi_objective, coil_dev_rrs=coil_dev_rrs, coil_head_rrs=coil_head_rrs) x0 = x0.copy() x0[3:] *= 10. # decimeters to get quats and head units close x = fmin_cobyla(objective, x0, _unit_quat_constraint, rhobeg=1e-3, rhoend=1e-5, disp=False) result = objective(x) x[3:] /= 10. return x, 1. - result / denom
def main(self, fit_params=None, par=None, Rd=None, Ci=None, N_p=None, Tleaf=None, Q10=None, Eaj=None, Eav=None, deltaSj=None, deltaSv=None, r25=None, Hdv=200000.0, Hdj=200000.0, Tref=None): """ figure out the optimal allocation of nitrogen """ result = opt.fmin_cobyla(self.objective, x0=fit_params, disp=0, cons=[self.constraint_Np, self.constraint_Nc, self.constraint_Ne, self.constraint_Nr], args=(par, Rd, Ci, N_p, Tleaf, Q10, Eaj, Eav, deltaSj, deltaSv, r25, Hdv, Hdj, Tref), consargs=(N_p,)) return result
def sell_captial(self): """ 1. take a random price (can be learned) 2. calculate for this price how much of the good should be sold to maximize profit. 3. offers to sell the according amount. """ price = np.random.uniform(0, 10, 1) objective = lambda x: - (self.sales_price_consumption_good * (self.possession('K') - x[0]) + x[0] * price ) constraint = lambda x: self.possession('K') - x[0] x = fmin_cobyla(func=objective, x0=(0, 0), cons=[constraint], disp=0) quantity = x[0] self.sell('downfirm', random.randint(0, self.num_downfirms), 'K', float(quantity), price)
def _fit_dipole(B_orig, t, rrs, guess_fwd_svd, fwd_data, whitener, proj_op, fmin_cobyla): """Fit a single bit of data""" logger.info('---- Fitting : %7.1f ms' % (1000 * t,)) B = np.dot(whitener, B_orig) # make constraint function to keep the solver within the inner skull if isinstance(fwd_data['inner_skull'], dict): # bem surf = fwd_data['inner_skull'] def constraint(rd): if _points_outside_surface(rd[np.newaxis, :], surf, 1)[0]: dist = _compute_nearest(surf['rr'], rd[np.newaxis, :], return_dists=True)[1][0] return -dist else: return 1. else: # sphere R, r0 = fwd_data['inner_skull'] R_adj = R - 1e-5 # to be sure we don't hit the innermost surf def constraint(rd): return R_adj - np.sqrt(np.sum((rd - r0) ** 2)) # Find a good starting point (find_best_guess in C) B2 = np.dot(B, B) if B2 == 0: logger.warning('Zero field found for time %s' % t) return np.zeros(3), 0, np.zeros(3), 0 x0 = rrs[np.argmin([_fit_eval(rrs[fi][np.newaxis, :], B, B2, fwd_svd) for fi, fwd_svd in enumerate(guess_fwd_svd)])] fun = partial(_fit_eval, B=B, B2=B2, fwd_data=fwd_data, whitener=whitener, constraint=constraint) # Tested minimizers: # Simplex, BFGS, CG, COBYLA, L-BFGS-B, Powell, SLSQP, TNC # Several were similar, but COBYLA won for having a handy constraint # function we can use to ensure we stay inside the inner skull / # smallest sphere rd_final = fmin_cobyla(fun, x0, (constraint,), consargs=(), rhobeg=5e-2, rhoend=1e-4, disp=False) # Compute the dipole moment at the final point Q, gof, residual = _fit_Q(fwd_data, whitener, proj_op, B, B2, B_orig, rd_final) amp = np.sqrt(np.sum(Q * Q)) norm = 1 if amp == 0 else amp ori = Q / norm return rd_final, amp, ori, gof, residual
def _from_samples(histogram, alpha, ordered=False): """ Reference: T. Denoeux (2006), "Constructing belief functions from sample data using multinomial confidence regions", International Journal of Approximate Reasoning 42, 228-252. """ p_lower, p_upper = MassFunction._confidence_intervals(histogram, alpha) def p_lower_set(hs): l = u = 0 for h in H: if h in hs: l += p_lower[h] else: u += p_upper[h] return max(l, 1 - u) if ordered: H = sorted(histogram.keys()) m = MassFunction() for i1, h1 in enumerate(H): m[(h1,)] = p_lower[h1] for i2, h2 in enumerate(H[i1 + 1:]): i2 += i1 + 1 if i2 == i1 + 1: v = p_lower_set(H[i1:i2 + 1]) - p_lower[h1] - p_lower[h2] else: v = p_lower_set(H[i1:i2 + 1]) - p_lower_set(H[i1 + 1:i2 + 1]) - p_lower_set(H[i1:i2]) + p_lower_set(H[i1 + 1:i2]) if v > 0: m[H[i1:i2 + 1]] = v return m else: H = list(histogram.keys()) L = 2**len(H) initial = numpy.zeros(L) cons = [] singletons = lambda index: [i for i in range(len(H)) if 2**i & index] # constraint (24) bel = lambda index, m: fsum(m[sum([2**i for i in h_ind])] for h_ind in powerset(singletons(index))) c24 = lambda m, i: p_lower_set(MassFunction._from_array_index(i, H)) - bel(i, m) for i in range(L): cons.append(partial(c24, i=i)) # constraint (25) cons.append(lambda m: m.sum() - 1.0) cons.append(lambda m: 1.0 - m.sum()) # constraint (26) for i in range(L): cons.append(partial(lambda m, i_s: m[i_s], i_s=i)) f = lambda m: -1 * 2**len(H) * fsum([m[i] * 2**(-len(singletons(i))) for i in range(L)]) m_optimal = fmin_cobyla(f, initial, cons, disp=0) return MassFunction.from_array(m_optimal, H)
def utility(init_w, delta, blacklit_r, blacklit_sigma): def objective(w): return -np.dot(w,r)+0.5*delta*np.dot(np.dot(w,sigma),w) constraints = [] for i in range(np.array(init_w).size): constraints.append(lambda w: 1 - w[i] ) constraints.append(lambda w: 3-sum(abs(w))) constraints.append(lambda w: sum(w)-1) constraints.append(lambda w: -sum(w)+1) return optimize.fmin_cobyla(objective,init_w,constraints,rhoend=1e-7,maxfun=1000)
def __init__(self, samples): n = len(samples) - 1 tot = sum(samples) pmf = super(BetaBinomMLEst, self).pmf # function to minimize def f(x): pred = (tot * pmf(n, k, x[0], x[1]) for k in range(len(samples))) diff = ((p - samples[k]) ** 2 for k, p in enumerate(pred)) return sum(diff) # L2 error # initial guess with method of moments mom = BetaBinomMoMEst(samples) x0 = np.array([mom.alpha, mom.beta]) xn = fmin_cobyla(f, x0, [lambda x: x[0], lambda x: x[1]], rhobeg=1e-1, rhoend=1e-10, disp=0) self._ah = xn[0] self._bh = xn[1]
def opt_wlf_coeffs(self, df, ref_temp, wlf_coeffs, opt): """Generate the optimized master curve""" temps = np.unique(df['Temp']) if len(temps) == 1: # only one data set return np.zeros(2) if wlf_coeffs is None: wlf_coeffs = self.get_wlf_coeffs(df, ref_temp) if opt is None: opt = self.optwlf if not opt: return wlf_coeffs def func(xopt, *args): """Objective function returning the area between the fitted curve and shifted data """ if np.any(np.abs(xopt[1] + temps - ref_temp) < EPS): self.fiterr = 1000. return self.fiterr df1 = self.shift_data(df.copy(), ref_temp, xopt) fit = self.fit_shifted_data(df1) # determine error between fitted curve and master curve yvals = [] for logx in df1['Log[X/aT]']: yvals.append(self.cf.eval(fit, logx)) yvals = np.asarray(yvals) error = np.sqrt(np.mean((yvals - df1['Y']) ** 2)) self.fiterr = error # / area(data[:,0],data[:,1]) return self.fiterr if self.optimizer == COBYLA: cons = [lambda x: 1 if abs(x[1]+temp-ref_temp) > EPS else -1 for temp in temps] wlf_coeffs = sciopt.fmin_cobyla(func, wlf_coeffs, cons, disp=0) elif self.optimizer == POWELL: wlf_coeffs = sciopt.fmin_powell(func, wlf_coeffs, disp=0) else: wlf_coeffs = sciopt.fmin(func, wlf_coeffs, disp=0) return wlf_coeffs
def optimize_spacing(x0, dx): x0 = np.asarray(x0) sorted_index = np.argsort(x0) x1 = x0[sorted_index] dx = np.asarray(dx)[sorted_index] objective, constraints = get_objective_constraints(x1, dx) x1_optimized = fmin_cobyla(objective, x1, constraints, rhoend=1e-7, iprint=0) x0_optimized = np.empty_like(x1_optimized) x0_optimized[sorted_index] = x1_optimized return x0_optimized
def fit(self, lX, ly, sample_weight=None): n_cols = lX.shape[1] x0 = np.ones((n_cols, 1)) constr_lb = [lambda x, z=i: x[z] - self.lowerbound for i in range(n_cols)] constr_ub = [lambda x, z=i: self.upperbound - x[z] for i in range(n_cols)] constr = constr_lb + constr_ub # constr=constr_lb self.coef_ = fmin_cobyla(self.fopt, x0, constr, args=(lX, ly), consargs=(), rhoend=1e-10, maxfun=10000, disp=0) # coef_ = minimize(fopt, x0,method='COBYLA',constraints=self.constr) # normalize coefficient if self.normalize: self.coef_ = self.coef_ / np.sum(self.coef_) # print "Normalizing coefficients:",self.coef_ if np.isnan(np.sum(self.coef_)): print "We have NaN here..."