def test_seed_gives_repeatability(self): result = differential_evolution(self.quadratic, [(-100, 100)], polish=False, seed=1, tol=0.5) result2 = differential_evolution(self.quadratic, [(-100, 100)], polish=False, seed=1, tol=0.5) assert_equal(result.x, result2.x)
def params(self,name,bounds): if name in self.models.keys(): if name == u'Modified_Zener_Hollomon': ans = opt.differential_evolution(self.models[name][1],bounds,args=(self.temp,self.rate,self.xdata,self.ydata,), strategy='best1bin',disp=True) error = np.sqrt(sum(np.square(self.models[name][0](ans.x,self.temp,self.rate,self.xdata)-self.ydata))/len(self.xdata)) else: ans = opt.differential_evolution(self.models[name][1],bounds,args=(self.xdata,self.ydata,),disp=True) error = np.sqrt(sum(np.square(self.models[name][0](ans.x,self.xdata)-self.ydata))/len(self.xdata)) print 'Model:',name print 'Params:',ans.x print 'Error:',error return [ans.x,error] else: return None
def test_gh_4511_regression(self): # This modification of the differential evolution docstring example # uses a custom popsize that had triggered an off-by-one error. # Because we do not care about solving the optimization problem in # this test, we use maxiter=1 to reduce the testing time. bounds = [(-5, 5), (-5, 5)] # result = differential_evolution(rosen, bounds, popsize=1815, # maxiter=1) # the original issue arose because of rounding error in arange, with # linspace being a much better solution. 1815 is quite a large popsize # to use and results in a long test time (~13s). I used the original # issue to figure out the lowest number of samples that would cause # this rounding error to occur, 49. differential_evolution(rosen, bounds, popsize=49, maxiter=1)
def improve_emulator_for_lnlik(self,swmm,improvement_steps,design): import scipy.optimize as opt # from multiprocessing import Pool j=0 # threads=8 while j<improvement_steps: ret=opt.differential_evolution(self.lnprob, bounds=list(zip(self.lower_bounds, self.upper_bounds)) ,args=[False] ,disp=True, popsize=20,maxiter=20, polish=False) pars=ret.x[0:8] if cf.closest_distance(self.result_producing_thing.dp,pars)<0.5: pars=design.pars_all[self.ini_dd+self.added_counter] swmm.result=design.data_all[self.ini_dd+self.added_counter] self.added_counter+=1 else: swmm.run(pars) with open("candidates.dat", 'ab') as file: np.savetxt(file,pars,fmt='%10.5f', newline=' ') with open("candidates.dat", 'a') as file: file.writelines("\n") self.result_producing_thing.dd=np.vstack((self.result_producing_thing.dd,swmm.result)) self.result_producing_thing.dp=np.vstack((self.result_producing_thing.dp, pars)) self.result_producing_thing.condition() j+=1
def minimize_waveform_only(r, phi, z, scale, t0, smooth, wf,): # result = op.minimize(neg_lnlike_wf, [r, phi, z, scale,t0, smooth, esmooth], args=(wf) ,method="Powell") bounds = [ (0, detector.detector_radius), (0, np.pi/4), (0, detector.detector_length), (scale/1.2, scale*1.2), (wf.t0Guess - 15, wf.t0Guess +10), (0, 20) ] result = op.differential_evolution(neg_lnlike_wf, bounds, args=([wf]), polish=False, maxiter=100) return result
def run(self,func=None): """Allows the user to set the data from a File This data is to be compared with the simulated data in the process of parameter estimation Args: func: An Optional Variable with default value (None) which by default run differential evolution which is from scipy function. Users can provide reference to their defined function as argument. Returns: The Value of the parameter(s) which are estimated by the function provided. .. sectionauthor:: Shaik Asifullah <*****@*****.**> """ self._parameter_names = self.bounds.keys() self._parameter_bounds = self.bounds.values() self._model_roadrunner = te.loada(self.model.model) x_data = self.data[:,0] y_data = self.data[:,1:] arguments = (x_data,y_data) if(func is not None): result = differential_evolution(self._SSE, self._parameter_bounds, args=arguments) return(result.x) else: result = func(self._SSE,self._parameter_bounds,args=arguments) return(result.x)
def optimize(): import numpy as np bounds = [(0, 1), (0, 5), (20,21)] result = differential_evolution(eq, bounds) print(result)
def __tune__(self): if self.minimizer == Minimizer.DifferentialEvolution: bounds = [ self.spectralRadiusBound, self.inputScalingBound, self.reservoirScalingBound, self.leakingRateBound, ] result = optimize.differential_evolution(self.__reservoirTrain__, bounds=bounds) print("The Optimization results are :" + str(result)) return result.x[0], result.x[1], result.x[2], result.x[3] else: bounds = [ self.spectralRadiusBound, self.inputScalingBound, self.reservoirScalingBound, self.leakingRateBound, ] minimizer_kwargs = {"method": "TNC", "bounds": bounds, "options": {"eps": 0.005}} mytakestep = ParameterStep() result = optimize.basinhopping( self.__reservoirTrain__, x0=self.initialGuess, minimizer_kwargs=minimizer_kwargs, take_step=mytakestep, stepsize=0.005, ) print("The Optimization results are :" + str(result)) return result.x[0], result.x[1], result.x[2], result.x[3]
def estimate_de( peaks, sizes ): f = ZFunc( peaks, sizes, [], estimate=True ) bounds = [ (0.01, 0.5), (-275, 75) ] niter = 0 results = [] while niter < 3: #prev_rss = rss res = differential_evolution(f, bounds, tol=1e-5, mutation=(0.3, 1.7), popsize=45, recombination=0.5, strategy='rand1bin') pairs, final_rss = f.get_pairs(res.x) pairs.sort() rtimes, bpsizes = zip( *pairs) zres = estimate_z(rtimes, bpsizes, 1) niter += 1 cerr('I: DE iter: %2d - pairs: %2d - Cur RSS: %6.2f' % (niter, len(pairs), zres.rss)) results.append( (zres, pairs ) ) if zres.rss < len(bpsizes) * 1.0: break results.sort( key = lambda x: x[0].rss ) zres, pairs = results[0] plot(f.rtimes, f.sizes, zres.z, pairs) return pairs, zres.z
def hausdorff_distance_2D(a, b, rotation=False, rotation_pivot=False, rotation_limits=[-math.pi/4., math.pi/4.]): """Comparing a vector data 'a' to a vector data 'b'.""" def find_d_rotated(beta): """Find Hausdorff distance considering a rigid body rotation.""" for i in range(len(data['x'])): x = b['x'][i] - x_pivot y = b['y'][i] - y_pivot c_beta = math.cos(beta) s_beta = math.sin(beta) x_rotated = c_beta*x - s_beta*y + x_pivot y_rotated = s_beta*x + c_beta*y + y_pivot b_rotated = {'x': x_rotated, 'y': y_rotated} return find_d(a, b_rotated) if rotation is False and rotation_pivot is False: return find_d(a, b) else: # determine what is the leading edge and the rotation angle beta x_pivot = rotation_pivot[0] y_pivot = rotation_pivot[1] beta_bounds = [0, -math.pi/4] result = differential_evolution(find_d_rotated, beta_bounds) return result.fun
def test_L6(self): # Lampinen ([5]) test problem 6 def f(x): x = np.hstack(([0], x)) # 1-indexed to match reference fun = (x[1]-10)**3 + (x[2] - 20)**3 return fun def c1(x): x = np.hstack(([0], x)) # 1-indexed to match reference return [(x[1]-5)**2 + (x[2] - 5)**2 - 100, -(x[1]-6)**2 - (x[2] - 5)**2 + 82.81] N = NonlinearConstraint(c1, 0, np.inf) bounds = [(13, 100), (0, 100)] constraints = (N) res = differential_evolution(f, bounds, strategy='rand1bin', seed=1234, constraints=constraints, tol=1e-7) x_opt = (14.095, 0.84296) f_opt = -6961.814744 assert_allclose(f(x_opt), f_opt, atol=1e-6) assert_allclose(res.fun, f_opt, atol=0.001) assert_allclose(res.x, x_opt, atol=1e-4) assert res.success assert_(np.all(np.array(c1(res.x)) >= 0)) assert_(np.all(res.x >= np.array(bounds)[:, 0])) assert_(np.all(res.x <= np.array(bounds)[:, 1]))
def test_L5(self): # Lampinen ([5]) test problem 5 def f(x): x = np.hstack(([0], x)) # 1-indexed to match reference fun = (np.sin(2*np.pi*x[1])**3*np.sin(2*np.pi*x[2]) / (x[1]**3*(x[1]+x[2]))) return -fun # maximize def c1(x): x = np.hstack(([0], x)) # 1-indexed to match reference return [x[1]**2 - x[2] + 1, 1 - x[1] + (x[2]-4)**2] N = NonlinearConstraint(c1, -np.inf, 0) bounds = [(0, 10)]*2 constraints = (N) res = differential_evolution(f, bounds, strategy='rand1bin', seed=1234, constraints=constraints) x_opt = (1.22797135, 4.24537337) f_opt = -0.095825 print(res) assert_allclose(f(x_opt), f_opt, atol=2e-5) assert_allclose(res.fun, f_opt, atol=1e-4) assert res.success assert_(np.all(np.array(c1(res.x)) <= 0)) assert_(np.all(res.x >= np.array(bounds)[:, 0])) assert_(np.all(res.x <= np.array(bounds)[:, 1]))
def test_L9(self): # Lampinen ([5]) test problem 9 def f(x): x = np.hstack(([0], x)) # 1-indexed to match reference return x[1]**2 + (x[2]-1)**2 def c1(x): x = np.hstack(([0], x)) # 1-indexed to match reference return [x[2] - x[1]**2] N = NonlinearConstraint(c1, [-.001], [0.001]) bounds = [(-1, 1)]*2 constraints = (N) res = differential_evolution(f, bounds, strategy='rand1bin', seed=1234, constraints=constraints) x_opt = [np.sqrt(2)/2, 0.5] f_opt = 0.75 assert_allclose(f(x_opt), f_opt) assert_allclose(np.abs(res.x), x_opt, atol=1e-3) assert_allclose(res.fun, f_opt, atol=1e-3) assert res.success assert_(np.all(np.array(c1(res.x)) >= -0.001)) assert_(np.all(np.array(c1(res.x)) <= 0.001)) assert_(np.all(res.x >= np.array(bounds)[:, 0])) assert_(np.all(res.x <= np.array(bounds)[:, 1]))
def fit(self): # Remove baseline i_x = linspace(self.l, self.u, 100) peak_counts = self.peak_counts - self._eval_baseline(self.peak_ind) i_y = interp1d( self.peak_ind, peak_counts, kind="cubic", bounds_error=False, fill_value=0.0 )(i_x) def fobj(C): return ((self._gaussian(i_x, *C) - i_y) ** 2).sum() cal = sop.differential_evolution( fobj, ( (0.5 * peak_counts.max(), 1.5 * peak_counts.max()), (self.l, self.u), (1, self.u - self.l) ), tol=.0001, popsize=30, ) if not cal.success: print("Fit failed") else: self.fit_params = cal.x
def get_optimal_splines(events, optimise_bin_edges, k=1): cut_events = {} cut_energies, ga_cuts, xi_cuts = [], [], [] for elow, ehigh, emid in zip(optimise_bin_edges[:-1], optimise_bin_edges[1:], np.sqrt(optimise_bin_edges[:-1] * optimise_bin_edges[1:])): for key in events: cut_events[key] = events[key][ (events[key]["MC_Energy"] > elow) & (events[key]["MC_Energy"] < ehigh)] res = optimize.differential_evolution( cut_and_sensitivity, bounds=[(.5, 1), (0, 0.5)], maxiter=1000, popsize=10, args=(cut_events, np.array([elow / energy_unit, ehigh / energy_unit]) * energy_unit, alpha) ) if res.success: cut_energies.append(emid.value) ga_cuts.append(res.x[0]) xi_cuts.append(res.x[1]) spline_ga = interpolate.splrep(cut_energies, ga_cuts, k=k) spline_xi = interpolate.splrep(cut_energies, xi_cuts, k=k) return (spline_ga, ga_cuts), (spline_xi, xi_cuts)
def test_gh_4511_regression(self): # This modification of the differential evolution docstring example # uses a custom popsize that had triggered an off-by-one error. # Because we do not care about solving the optimization problem in # this test, we use maxiter=1 to reduce the testing time. bounds = [(-5, 5), (-5, 5)] result = differential_evolution(rosen, bounds, popsize=1815, maxiter=1)
def _optimization_diffevo(self, x0, minimizer_kwargs, niter): # pragma: no cover """ Parameters ---------- x0 : np.ndarray An optimization vector. minimizer_kwargs : dict A dictionary of keyword arguments to pass to the optimizer. niter : int If applicable, the number of iterations to make. Returns ------- result : OptimizeResult, None The result of the optimization. Returns None if the optimization failed. """ if 'constraints' in minimizer_kwargs: msg = "Differential Evolution can only be used in unconstrained optimization." raise OptimizationException(msg) if niter is None: niter = self._default_hops result = differential_evolution(func=self.objective, bounds=minimizer_kwargs['bounds'], maxiter=minimizer_kwargs['options']['maxiter'], popsize=niter, tol=minimizer_kwargs['options']['ftol'], ) if result.success: return result
def run_test(test, args=(), g_args=()): if test is not test10_1: res = tgo(test.f, test.bounds, args=args, g_cons=test.g, g_args=g_args) # Exceptional cases if test == test5_1: # Remove the extra minimizer found in this test # (note all minima is at the global 0.0 value) res.xl = [res.xl[0], res.xl[1], res.xl[3], res.xl[2]] res.funl = res.funl[:4] if test == test10_1: res = tgo(test.f, test.bounds, args=args, g_cons=test.g, g_args=g_args, n=1000) print("=" * 100) print("=" * 100) print("Topographical Global Optimization: ") print("-" * 34) print(res) from scipy.optimize import differential_evolution, basinhopping res2 = differential_evolution(test.f, test.bounds, args=args) print("=" * 100) print("Differential Evolution: ") print("-" * 23) print(res2) print("=" * 100) print("Basinhopping : (x_0 = numpy.mean(bounds,axis=1)) ") x_0 = numpy.mean(test.bounds, axis=1) minimizer_kwargs = {'args': args} res3 = basinhopping(test.f, x_0, minimizer_kwargs=minimizer_kwargs) print("-" * 49) print(res3) # Global minima if test.expected_x is not None: numpy.testing.assert_allclose(res.x, test.expected_x, rtol=test_atol, atol=test_atol) # (Optional tests) if test.expected_fun is not None: numpy.testing.assert_allclose(res.fun, test.expected_fun, atol=test_atol) if test.expected_xl is not None: numpy.testing.assert_allclose(res.xl, test.expected_xl, atol=test_atol) if test.expected_funl is not None: numpy.testing.assert_allclose(res.funl, test.expected_funl, atol=test_atol)
def fit_model(self, dataX, datarp, datacp, differential_evolution=True, TNC=True, SLSQP=True, verbose=True): '''Fit the function using one or multiple optimization methods in serial''' def diffsq(params): self.setparams(params) (rp,cp) = self(dataX) diffrp = (datarp - rp)/datarp diffcp = (datacp - cp)/datacp #Ldatacp = datacp/(datarp**2 + datacp**2) #Lfitcp = cp/(rp**2 + cp**2) #diffLcp = (Ldatacp - Lfitcp)/Ldatacp return dot(diffcp, diffcp) + dot(diffrp, diffrp) #+ dot(diffLcp,diffLcp) def costfun(params): """Wrapper function neede for the optimization method Args: params: a list of parameters for the model Returns: The cost (real scalar) """ Error = diffsq(params) fsumpenalty = datarp[0] - self.fsum() return Error + fsumpenalty**2 start_t = time.time() params = self.getparams() bounds = self.getbounds() if (differential_evolution == True): resultobject = optimize.differential_evolution(costfun,bounds,maxiter=2000) if (verbose == True): print("diff. evolv. number of iterations = ", resultobject.nit) if (TNC == True): resultobject = optimize.minimize(costfun, x0=params, bounds=bounds, method='TNC') if (verbose == True): print("TNC number of iterations = ", resultobject.nit) if (SLSQP == True): resultobject = optimize.minimize(costfun, x0=params, bounds=bounds, method='SLSQP') if (verbose == True): print("SLSQP number of iterations = ", resultobject.nit) #mybounds = MyBounds(bounds=array(bounds)) #ret = basinhopping(diffsq, params, niter=10,accept_test=mybounds) params = self.getparams() #get updated params end_t = time.time() m, s = divmod(end_t - start_t, 60) h, m = divmod(m, 60) print("Fit completed in %02d hr %02d min %02d sec" % (h, m, s)) self.RMS_error = sqrt(diffsq(params)/(2*len(dataX))) #Store RMS error
def optimize(): import scipy.optimize as opt bounds = [slice(0.1, 20, 1), slice(0, 20, 1)] # rs = opt.brute(lambda v: solve(v)[0], bounds, full_output=True) bounds = [(0.1, 20), (0, 20)] rs = opt.differential_evolution(lambda v: solve(v)[0], bounds) print(rs)
def _min_max_band(args): """ Min and max values at `idx`. Global optimization to find the extrema per component. Parameters ---------- args: list It is a list of an idx and other arguments as a tuple: idx : int Index value of the components to compute The tuple contains: band : list of float PDF values `[min_pdf, max_pdf]` to be within. pca : statsmodels Principal Component Analysis instance The PCA object to use. bounds : sequence ``(min, max)`` pair for each components ks_gaussian : KDEMultivariate instance Returns ------- band : tuple of float ``(max, min)`` curve values at `idx` """ idx, (band, pca, bounds, ks_gaussian, use_brute, seed) = args if have_de_optim and not use_brute: max_ = differential_evolution(_curve_constrained, bounds=bounds, args=(idx, -1, band, pca, ks_gaussian), maxiter=7, seed=seed).x min_ = differential_evolution(_curve_constrained, bounds=bounds, args=(idx, 1, band, pca, ks_gaussian), maxiter=7, seed=seed).x else: max_ = brute(_curve_constrained, ranges=bounds, finish=fmin, args=(idx, -1, band, pca, ks_gaussian)) min_ = brute(_curve_constrained, ranges=bounds, finish=fmin, args=(idx, 1, band, pca, ks_gaussian)) band = (_inverse_transform(pca, max_)[0][idx], _inverse_transform(pca, min_)[0][idx]) return band
def opte(f): """Optimize the eigenvalues""" from scipy.optimize import differential_evolution from scipy.optimize import minimize bounds = [(0.,1.) for i in range(h.dimensionality)] x0 = np.random.random(h.dimensionality) # inital vector res = differential_evolution(f,bounds=bounds) # res = minimize(f,res.x,method="Powell") return f(res.x)
def bench_run(self, **minimizer_kwargs): """ do an optimization test starting at x0 for all the optimizers """ kwargs = self.minimizer_kwargs if hasattr(self.fun, "temperature"): kwargs["T"] = self.function.temperature if hasattr(self.fun, "stepsize"): kwargs["stepsize"] = self.function.stepsize minimizer_kwargs = {"method": "L-BFGS-B"} x0 = self.get_random_configuration() # basinhopping - with gradient if hasattr(self.function, 'der'): minimizer_kwargs['jac'] = True t0 = time.time() res = basinhopping( self.energy_gradient, x0, accept_test=self.accept_test, callback=self.stop_criterion, niter=1000, minimizer_kwargs=minimizer_kwargs, **kwargs) t1 = time.time() res.success = True if not self.found_target(res): res.success = False self.add_result(res, t1 - t0, 'basinhopping') # basinhopping - no gradient x0 = self.get_random_configuration() minimizer_kwargs['jac'] = False t0 = time.time() res = basinhopping( self.fun, x0, accept_test=self.accept_test, callback=self.stop_criterion, niter=1000, minimizer_kwargs=minimizer_kwargs, **kwargs) t1 = time.time() res.success = True if not self.found_target(res): res.success = False self.add_result(res, t1 - t0, 'basinhopping - no gradient') # differential_evolution t0 = time.time() res = differential_evolution(self.fun, self.bounds, popsize=20, polish=True) t1 = time.time() if not self.found_target(res): res.success = False self.add_result(res, t1 - t0, 'differential_evolution')
def minimize_waveform_only_nosmooth(r, phi, z, scale, t0, wf,): #result = op.minimize(neg_lnlike_wf_nosmooth, [r, phi, z, scale,t0], args=(wf) ,method="Nelder-Mead") #result = op.basinhopping(neg_lnlike_wf_nosmooth, [r, phi, z, scale,t0], niter=10, minimizer_kwargs={"args":wf, "method": "Nelder-Mead"}) bounds = [ (0, detector.detector_radius), (0, np.pi/4), (0, detector.detector_length), (scale/1.2, scale*1.2), (0, 15) ] result = op.differential_evolution(neg_lnlike_wf_nosmooth, bounds, args=([wf]), polish=False, maxiter=100) return result
def conditional_firing_probability(train1, train2, min_points=0, method=None): """ Calculate the conditional firing probability between two lists of spike times train1: numpy array of spike times in msec train2: numpy array of spike times in msec threshold: minimum amplitude of fit delay: minimum peak time of fit in msec For LeFeber the fit was performed with the following limits 0 <= max < 1 0 <= delay <= 500 1 <= width <= 100 0 <= offset <= 0.5 The followng was required to declare a connection max/offset >= 2 5<= delay <= 250 width > 5 """ class Empty_Fit(): def __init__(self): self.x = np.zeros(4) self.x[-1] = 1 psth = np.zeros(500) max2 = train2.shape[0] indices = np.searchsorted(train2, train1, side='right') for i, index in enumerate(indices): j = index while (j < max2) and (train2[j] - train1[i] < 500): psth[int(train2[j] - train1[i])] += 1 j += 1 if np.sum(psth) < min_points: return Empty_Fit(), psth psth /= train1.shape[0] xdata = np.arange(500) offset = np.average(psth) maxi = np.max(psth) - offset delay = np.argmax(psth) width = delay/2 if delay/2 > 5 else 5 p0 = (maxi, delay, width, offset) bounds = ((0, 1), (0, 500), (1, 100), (0, 0.5)) if method == 'DE': fit = opt.differential_evolution(_cfp_cost, bounds=bounds, seed=1, args=(psth, xdata), maxiter=100, polish=False) p0 = fit.x fit = opt.minimize(_cfp_cost, p0, bounds=bounds, args=(psth, xdata), method='L-BFGS-B') return fit, psth
def maxEffGlobal(Ts, Tc, Ps, fs, X, n): myRange = [(0, 12)] * n myEg = optimize.differential_evolution( maxEff, myRange, args=(Ts, Tc, Ps, fs, X), maxiter=100000, popsize=15, tol=0.0001 ) if myEg["success"]: return myEg else: # this should return NaN probably return myEg
def RandomSearch(P_Search_Alg, H_a, H_b, P_con, P_relay, per_s, per_c): CCF_beta_func=lambda x: CCF_sumrate_compute(vector(RR, [1,]+list(x[0:L-1])), H_a, H_b, P_con, P_relay, per_s, per_c) Pranges=((0.1,betaScale_max),)*(L-1) if P_Search_Alg=='differential_evolution': ResSearch=optimize.differential_evolution(CCF_beta_func,Pranges) beta_opt=ResSearch.x sum_rate_opt=-ResSearch.fun else: raise Exception("error: Not Such Search Algorithm!") return beta_opt, sum_rate_opt
def opt_differential_evolution(parametersList): # Maximul of iterations of the algorithm max_iter=10 # Set the bounds of each parameter bounds=list() for i in range(0,len(parametersList)): bounds.append((parametersList[i][1],parametersList[i][2])) # TODO : change the criterium of convergence scipy_res=differential_evolution(deepov_func,bounds,args=parametersList,maxiter=max_iter,disp=True,polish=False) return scipy_res
def estimate_hyperpars(self): import scipy.optimize as opt lower=np.array([0,0,0]) upper=np.array([0.001,10,10]) ret=opt.differential_evolution(self.objective_hyperpars, bounds=list(zip(lower, upper)) ,disp=True, popsize=100,maxiter=200, polish=False) return ret
def test_infinite_objective_function(self): # Test that there are no problems if the objective function # returns inf on some runs def sometimes_inf(x): if x[0] < .5: return np.inf return x[1] bounds = [(0, 1), (0, 1)] x_fit = differential_evolution(sometimes_inf, bounds=[(0, 1), (0, 1)], disp=False)
def optimizer(func, x0, args, disp): res = optimize.differential_evolution(func, bounds, args, tol=1e-1) return res.x
x0 = [4.14826750e-04, 4.99870249e+01, 2.00000000e-01, 6.52069017e-02,8.55311554e-01] temp = 333.0 with open(str(temp)+"_dat_fn1.txt","w+") as p: with open(str(temp)+"_results_fn1.txt","w+") as f: f.write("x0 = tau_c,dj,lamb,ks,kt\n") temp_dat = np.loadtxt('t_333.txt',delimiter=',') lifetime_exp_zero = 5.752641121675911 lifetime_exp_res = 1.4174868758031038 lifetime_exp_high = 6.347652948471806 J = 28.95 res = differential_evolution(lambda x1,x2,x3,x4,x5,x6,x7: calc_yield_parallel(*x1,x2,x3,x4,x5,x6,x7),bounds=bnds,args=(temp,temp_dat,lifetime_exp_zero,lifetime_exp_res,lifetime_exp_high,J), maxiter= 10) #res = minimize(lambda x1,x2,x3,x4,x5,x6,x7: calc_yield_parallel(*x1,x2,x3,x4,x5,x6,x7),x0,args=(temp,temp_dat,lifetime_exp_zero,lifetime_exp_res,lifetime_exp_high,J),method='SLSQP',bounds=bnds) print(res) f.write("\n") f.write("x0 for T=333k\n") f.write(str(res)+"\n") for i in range(0,len(res.x)): p.write(str(res.x[i])+",") p.write(str(temp)+"\n")
def scale(x, scale=5): return cv2.resize(x, None, fx=scale, fy=scale, interpolation=cv2.INTER_AREA) while True: bounds = [(0, shape[0] - 1), (0, shape[1]), (0, 255), (0, 255), (0, 255)] * d result = differential_evolution(optimize, bounds, maxiter=iters, popsize=popsize, tol=1e-5, callback=callback) adv_img = perturb(result.x) inp = Variable(torch.from_numpy(preprocess(adv_img)).float().unsqueeze(0)) out = model(inp) prob = softmax(out.data.numpy()[0]) print('Prob [%s]: %f --> Prob[%s]: %f' % (cifar10_class_names[pred_orig], prob_orig[pred_orig], cifar10_class_names[pred_adv], prob_adv)) cv2.imshow('adversarial image', scale(adv_img[..., ::-1])) key = 0 while True:
def stsc(X, w, C, eigen_gap=0, verbose=0): ''' Self-tuning spectral clustering affinity_matrix: locally scaled affinity matrix C: largest possible group number eigen_gap: whether to use gap of eigenvalues to select candinates for STSC labels: cluster labels assigned to points Reference: "Zelnik-Manor, L. and Perona, P. Self-tuning spectral clustering. In NIPS, pp. 1601-1608. 2005." ''' if eigen_gap: # Get candidates for c_best, based on eigenvalues of L c_range = set([ idx + 1 for idx in find_gap(w[:C + 1], multiple=True, verbose=verbose)[0] ]) # if 1 in c_range: # c_range = c_range - set({1}) # c_range.add(2) else: c_range = range(1, C + 1) min_align = np.inf for c in c_range: # For each possible group number c recover the rotation which best aligns X's columns # with the canonical coordinate system if verbose == 2: print 'c =', c if c == 1: # In the ideal case, the end points of eigenvectors should form a vertical line in the 1st dim, # i.e., var(X[:, 0]) = 0 J_opt = np.var(X[:, 0]) theta_opt = 0 else: # Optimize alignment cost over theta K = c * (c - 1) / 2 # Visualize cost function and its gradient # if K == 1: # thetas = np.arange(-np.pi/2, np.pi/2, np.pi/100) # costs = np.zeros_like(thetas) # grads = np.zeros_like(thetas) # for i in range(len(thetas)): # costs[i] = align_cost(np.array([thetas[i]]), X[:,:2]) # grads[i] = align_grad(np.array([thetas[i]]), X[:,:2]) # plt.figure() # plt.subplot(211) # plt.plot(thetas, costs) # plt.title('cost') # plt.subplot(212) # plt.plot(thetas, grads) # plt.title('gradient') # plt.show() res = differential_evolution(align_cost, bounds=((-np.pi / 4, np.pi / 4), ) * K, args=(X[:, :c], ), popsize=100, tol=1e-8) J_opt = np.clip(res.fun, np.finfo(float).eps, np.inf) theta_opt = res.x if verbose == 2: print 'J_opt =', J_opt print 'theta_opt =', theta_opt if J_opt <= min_align: min_align = J_opt c_best = c theta_best = theta_opt return c_best, theta_best, min_align
] ref_trajectory = Trajectory(variables_ref) ref_trajectory.solver() tra_ref = ref_trajectory.getdisp() np.savetxt('tra_ref.csv', tra_ref, fmt='%f', delimiter=',') #Optimization = CostFunction([45.,45.,180.]) #print('TotalError: ',Optimization) #------------------------------------------------------------------------------------------------------------------- # Optimization #------------------------------------------------------------------------------------------------------------------- Opt_SimplifiedModel = differential_evolution(CostFunction, bounds, strategy=Strategy, maxiter=MaxGenerations, popsize=Np, tol=0.01, mutation=F, recombination=CR, polish=SwitchtoGradients, init='latinhypercube', callback=StopOptimization) np.savetxt('ErrorTotal.csv', MinErrorList, fmt='%f', delimiter=',') #------------------------------------------------------------------------------------------------------------------- #------------------------------------------------------------------------------------------------------------------- #Create a Summary file for the Optimization Process end = time.time() Duration = (end - start) / 60. / 60.
fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.view_init(45, -45) ax.plot_surface(xgrid, ygrid, eggholder(xy), cmap='terrain') ax.set_xlabel('x') ax.set_ylabel('y') ax.set_zlabel('eggholder(x, y)') plt.show() results = dict() results['shgo'] = optimize.shgo(eggholder, bounds) results['shgo'] results['DA'] = optimize.dual_annealing(eggholder, bounds) results['DA'] results['DE'] = optimize.differential_evolution(eggholder, bounds) results['BH'] = optimize.basinhopping(eggholder, bounds) results['shgo_sobol'] = optimize.shgo(eggholder, bounds, n=200, iters=5, sampling_method='sobol') fig = plt.figure() ax = fig.add_subplot(111) im = ax.imshow(eggholder(xy), interpolation='bilinear', origin='lower', cmap='gray') ax.set_xlabel('x') ax.set_ylabel('y') def plot_point(res, marker='o', color=None): ax.plot(512+res.x[0], 512+res.x[1], marker=marker, color=color, ms=10) plot_point(results['BH'], color='y') # basinhopping - yellow
def deconvolve(a, deltaF): #a: signal to deconvolve natural linewidht from #deltaF: frequency range over which a resides peakSig = a.max() #to properly scale the final result x = np.arange(a.shape[0]) xDense = np.linspace(x[0], x[-1], num=251) a = a / a.max() # plt.scatter(x,a) dataAnalyzer = DataAnalyzer() b = dataAnalyzer.multi_Voigt( (xDense - (xDense.min() + xDense.max()) / 2) * deltaF / xDense.max(), 0, 1, 0, 1e-10) b = b / b.max() # b=b[75:-75] aFunc = spi.Rbf(x, a, smooth=0.0) #interp1d(x,a) a = aFunc(xDense) # plt.plot(xDense,a) window = 2 * int((a.shape[0] / 20) // 2) + 1 for i in range(25): a = sps.savgol_filter(a, window, 2) a = a / a.max() # plt.plot(xDense,a) # plt.plot(b) # plt.show() M = generate_MConv(a, b) M = M / M.max() # test=np.asarray([1,1,1,1,2,0,1,1,0,1]) # plt.plot(generate_Curve(test,a.shape[0])) # plt.show() @numba.njit(numba.float64(numba.float64[:])) def cost_Inner(c): cost = 0 cost += 10 * np.abs(np.sum(c[c < 0])) #sum up the negative values # c=c-c.min() c = c / c.max() aNew = M @ c aNew = aNew / aNew.max() cost += np.sum((aNew - a)**2) cost0 = 1.0 #find any peaks in the data, besides the one single peak j = 0 for i in range(0, c.shape[0] - 3): # xclude the end probe = c[i:i + 3] if np.argmax( probe ) == 1: #center should not be peak, except at the actual peak if j != 0: #There should be at least one peak, so ingore the fir time cost += cost0 #add a small penalty j = 1 return cost def cost(args): #args: the deviation from the original array c = generate_Curve(args, a.shape[0]) # cFunc=spi.interp1d(np.linspace(0,a.shape[0],args.shape[0]),args) # c=cFunc(np.arange(0,a.shape[0])) return cost_Inner(c) bounds = [] # for i in range(a.shape[0]): # deltaLower=a[i] #the signal can be totally compensated, but not go below zero # deltayMaxFact=.25 #Factor for setting upper bound. Much more efficient than adding same amount everywhere # deltaUpper=deltayMaxFact*a[i]+.1 # bounds.append((-deltaLower,deltaUpper)) for i in range(25): bounds.append((-1.0, 1.0)) bestSol = None for i in range(5): sol = spo.differential_evolution(cost, bounds, maxiter=5000, disp=False, mutation=(.5, 1.5), recombination=.25, popsize=1, tol=0, workers=1, polish=True) if sol.fun < 1.0: bestSol = sol break else: if bestSol is None: bestSol = sol elif sol.fun < bestSol.fun: bestSol = sol # cFunc = spi.interp1d(np.linspace(0, a.shape[0], bestSol.x.shape[0]), bestSol.x) # c = cFunc(np.arange(0, a.shape[0])) c = generate_Curve(bestSol.x, a.shape[0]) c = c * peakSig / c.max() # plt.plot(c/c.max()) # window = 2 * int((a.shape[0] / 10) // 2) + 1 # c=sps.savgol_filter(c,window,2) # j = 0 # for i in range(0, c.shape[0] - 3): # xclude the end # probe = c[i:i + 3] # if np.argmax(probe) == 1: # center should not be peak, except at the actual peak # if j != 0: # There should be at least one peak, so ingore the fir time # print('fail') # j = 1 # plt.plot(c) # c=sps.savgol_filter(c,window,2) # c=sps.savgol_filter(c,window,2) # plt.plot(c/c.max()) # aNew=M@c # aNew=aNew/aNew.max() # plt.plot(a) # plt.plot(aNew) # aNew=aNew/aNew.max() # print(np.sum((a-aNew)**2)) # plt.show() cFunc = spi.Rbf(xDense, c) cDownSample = cFunc(x) return cDownSample
def execute(self, **de_options): ans = differential_evolution(self.list2kwargs(self.objective), self.bounds, **de_options) return self._pack_output(ans)
f1_range = [-20, -14] f2_range = [-14, 0.5] x1 = np.linspace(min(f1_range), max(f1_range), 1000) x2 = np.linspace(min(f2_range), max(f2_range), 1000) y = np.linspace(0, 0, 1000) problem = MOProblem(variables=varsl, objectives=[f1, f2], ideal=np.array([-20, -12]), nadir=np.array([-14, 0.5])) from desdeo_mcdm.interactive.NIMBUS import NIMBUS from scipy.optimize import minimize, differential_evolution scalar_method = ScalarMethod( lambda x, _, **y: differential_evolution(x, **y), use_scipy=True, method_args={ "polish": True, "disp": True }) method = NIMBUS(problem, scalar_method) classification_request, plot_request = method.start() # print(classification_request.content.keys()) # print(classification_request.content["message"]) print(classification_request.content["objective_values"])
with open('dataset/podaci_INTERVENTION.pkl', 'rb') as f2: list_inter = pickle.load(f2) country_atribute = pd.read_csv("dataset/country_atribute.csv", index_col=0) country_atribute = [] bnd = ((-1, 0), ) * list_inter[0].iloc[:, 2:].shape[1] + ((0, 2), ) * 3 if fit == 1: if opt == 'meta': res = optimize.differential_evolution(Obj_function, bounds=bnd, maxiter=iter_max, popsize=pop_size, args=( country_atribute, list_SIRM, list_inter, ), disp=True, tol=0.00001) np.save( "modeli/vektor_{}_{}_{}_{}".format(iter_max, pop_size, opt, name), res.x) elif opt == 'neld': x0 = np.zeros(len(bnd)) res = optimize.minimize(Obj_function, x0, args=( country_atribute, list_SIRM,
return np.round(res, decimals=0) #return np.array(x, dtype = 'int32') # Поскольку градиента для негладкой функции не существует # метод BFGS в данном случае непригоден для поиска экстремума x_0 = 22.0 optimize_result = minimize(f, x0=x_0, method='BFGS') if optimize_result['success']: draw_optimization_result(x_0, x, f(x), "BFGS optimization method", optimize_result) print("optimize_result = {0}".format(optimize_result)) # записываем в файл значение функции для первого приближения with open('C:\\Lessons\\Course1Week3\\FuncMinimizing\\NonSmooth_Results.txt', 'w') as file_obj: file_obj.writelines(str(np.round(optimize_result['fun'][0], 2)) + ' ') bounds = [(1, 30)] optimize_result = differential_evolution(f, bounds) if optimize_result['success']: draw_optimization_result(bounds, x, f(x), "Differential evolution", optimize_result) print("optimize_result = {0}".format(optimize_result)) # записываем в файл значение функции для второго приближения with open('C:\\Lessons\\Course1Week3\\FuncMinimizing\\NonSmooth_Results.txt', 'a') as file_obj: file_obj.writelines(str(np.round(optimize_result['fun'], 2)) + ' ')
lc_event_fun=hm.ll_lc_event) elif use_model == 'ExpIDM': pguess = [40, 1, 1, 3, 10, 15] mybounds = [(20, 120), (.1, 5), (.1, 35), (.1, 20), (.1, 20), (.1, 75)] cal = hc.make_calibration(curplatoon, meas, platooninfo, .1, hm.RelaxExpIDM) start = time.time() cal.simulate(pguess) print('time to compute loss is ' + str(time.time() - start)) start = time.time() if use_method == 'BFGS': bfgs = sc.fmin_l_bfgs_b(cal.simulate, pguess, bounds=mybounds, approx_grad=1) # BFGS print('time to calibrate is ' + str(time.time() - start) + ' to find mse ' + str(bfgs[1])) elif use_method == 'GA': bfgs = sc.differential_evolution(cal.simulate, bounds=mybounds, workers=2) # GA print('time to calibrate is ' + str(time.time() - start) + ' to find mse ' + str(bfgs['fun'])) plt.plot(cal.all_vehicles[0].speedmem) plt.ylabel('speed') plt.xlabel('time index')
def __tune__(self): bounds = [self.probabilityBound] result = optimize.differential_evolution(self.__ESNTrain__, bounds=bounds) print("\nThe optimal parameters for Erdos ESN:" + str(result.x)) return result.x[0]
] y0_seirpdq_known = S0, P0, R0, D0 # bounds_seirdaq = [(0, 1e-2), (0, 1), (0, 1), (0, 0.2), (0, 0.2), (0, 0.2)] result_seirpdq = optimize.differential_evolution( # seirpdq_least_squares_error_ode, seirpdq_least_squares_error_ode_y0, bounds=bounds_seirpdq, # args=(data_time, [infected_individuals, dead_individuals], seirpdq_ode_solver, y0_seirpdq), args=( data_time, [infected_individuals, dead_individuals], seirpdq_ode_solver, y0_seirpdq_known, target_population, ), popsize=30, strategy="best1bin", tol=1e-5, recombination=0.95, mutation=0.6, maxiter=10000, polish=True, disp=True, seed=seed, callback=callback_de, workers=-1, ) print(result_seirpdq) # %%
def Op_ABC(C_all_points): #len(C_all_points) = 10 (2 * Num_of_Points) # for i in range(len(C_all_points)/2): # i = i * 2 # print C_all_points[i],',',C_all_points[i+1] # print ' ' #Point in Polygon? for i in range(len(C_all_points) / 2): i = i * 2 if g.point_in_polygon(vg.Point(C_all_points[i], C_all_points[i + 1])) == -1: pass else: return float('inf') #change[a,b,c,d] to [[a,b],[c,d]] CABC_all_points = [] for i in range(len(C_all_points) / 2): i = i * 2 Temp_CABC = [C_all_points[i], C_all_points[i + 1]] CABC_all_points.append(Temp_CABC) ap = [Point(p) for p in CABC_all_points] co = [LRF_(p.x, p.y, Radius) for p in ap] #A: The intersect part of path coverage (Enclude polygons) Sa = getIntersection(co).area #B: The rest of the map's area except path coverage Sb = getUnscanned(co).area #C: The shortest distance def Dis_PosC(x): Dist_ = 0 Store_Comb = [] list_Num = 5 Permutation_list = [] list_ = [0, 1, 2, 3, 4] x_list = [] for i in range(len(C_all_points) / 2): x[i] = math.floor(x[i]) x_list.append(int(round(x[i]))) for i in range(list_Num): Permutation_list.append(list_[x_list[i]]) del list_[x_list[i]] # for i in range(len(C_all_points)/2): # print Permutation_list[i] # print ' ' for i in range(len(C_all_points) / 2): Store_Comb.append(CABC_all_points[Permutation_list[i]]) for i in range(len(C_all_points) / 2 - 1): Dis_0 = vg.Point(Store_Comb[i][0], Store_Comb[i][1]) Dis_1 = vg.Point(Store_Comb[i + 1][0], Store_Comb[i + 1][1]) Dist = g.shortest_path(Dis_0, Dis_1) _Dist_ = LineString(sp2list(Dist)).length Dist_ = Dist_ + _Dist_ return Dist_ New_Nearest_Dis = [] bounds_C = [(0.1, 4.9), (0.1, 3.9), (0.1, 2.9), (0.1, 1.9), (0.1, 0.9)] Nearest_Dis = differential_evolution(Dis_PosC, bounds_C, maxiter=5, polish=False) for i in range(5): New_Nearest_Dis.append(Nearest_Dis.x[i]) #Find the best sequence x_list = [] BS_x = [] Store_Comb = [] list_Num = 5 Permutation_list = [] list_ = [0, 1, 2, 3, 4] for i in range(len(C_all_points) / 2): BS_x.append(math.floor(New_Nearest_Dis[i])) x_list.append(int(round(BS_x[i]))) for i in range(list_Num): Permutation_list.append(list_[x_list[i]]) del list_[x_list[i]] for i in range(len(C_all_points) / 2): Store_Comb.append(CABC_all_points[Permutation_list[i]]) for i in range(len(C_all_points) / 2): Adjust_x.append(Store_Comb[i]) #A + B + C Cal_Op_ABC = Sa + Sb + Nearest_Dis.fun return Cal_Op_ABC
def fitting_shape_coefficients(filename, bounds='Default', n=5, return_data=False, return_error=False, optimize_deltaz=False): """Fit shape parameters to given data points Inputs: - filename: name of the file where the original data is - bounds: bounds for the shape parameters. If not defined, Default values are used. - n: order of the Bernstein polynomial. If bounds is default this input will define the order of the polynomial. Otherwise the length of bounds (minus one) is taken into consideration""" from hausdorff_distance import hausdorff_distance_2D def shape_difference(inputs, optimize_deltaz=False): if optimize_deltaz == True or optimize_deltaz == [True]: y_u = CST(upper['x'], 1, deltasz=inputs[-1] / 2., Au=list(inputs[:n + 1])) y_l = CST(lower['x'], 1, deltasz=inputs[-1] / 2., Al=list(inputs[n + 1:-1])) else: y_u = CST(upper['x'], 1, deltasz=deltaz / 2., Au=list(inputs[:n + 1])) y_l = CST(lower['x'], 1, deltasz=deltaz / 2., Al=list(inputs[n + 1:])) # Vector to be compared with a_u = {'x': upper['x'], 'y': y_u} a_l = {'x': lower['x'], 'y': y_l} b_u = upper b_l = lower return hausdorff_distance_2D(a_u, b_u) + hausdorff_distance_2D( a_l, b_l) # def shape_difference_upper(inputs, optimize_deltaz = False): # if optimize_deltaz == True: # y = CST(x, 1, deltasz = inputs[-1]/2., Au = list(inputs[:-1])) # else: # y = CST(x, 1, deltasz = inputs[-1]/2., Au = list(inputs)) # # Vector to be compared with # b = {'x': x, 'y': y} # return hausdorff_distance_2D(a, b) # def shape_difference_lower(inputs, optimize_deltaz = False): # if optimize_deltaz == True: # y = CST(x, 1, deltasz = inputs[-1]/2., Al = list(inputs[:-1])) # else: # y = CST(x, 1, deltasz = deltaz/2., Al = list(inputs)) # # Vector to be compared with # b = {'x': x, 'y': y} # return hausdorff_distance_2D(a, b) def separate_upper_lower(data): for i in range(len(data['x'])): if data['y'][i] < 0: break upper = {'x': data['x'][0:i], 'y': data['y'][0:i]} lower = {'x': data['x'][i:], 'y': data['y'][i:]} return upper, lower # Order of Bernstein polynomial if bounds != 'Default': n = len(bounds) - 1 # Obtaining data data = output_reader(filename, separator=', ', header=['x', 'y']) # Rotating airfoil x_TE = (data['x'][0] + data['x'][-1]) / 2. y_TE = (data['y'][0] + data['y'][-1]) / 2. theta_TE = math.atan(-y_TE / x_TE) # position trailing edge at the x-axis processed_data = {'x': [], 'y': []} for i in range(len(data['x'])): x = data['x'][i] y = data['y'][i] c_theta = math.cos(theta_TE) s_theta = math.sin(theta_TE) x_rotated = c_theta * x - s_theta * y y_rotated = s_theta * x + c_theta * y processed_data['x'].append(x_rotated) processed_data['y'].append(y_rotated) data = processed_data # determine what is the leading edge and the rotation angle beta processed_data = {'x': [], 'y': []} min_x_list = [] min_y_list = [] min_x = min(data['x']) min_index = data['x'].index(min_x) min_y = data['y'][min_index] chord = max(data['x']) - min(data['x']) beta = math.atan((y_TE - min_y) / (x_TE - min_x)) for i in range(len(data['x'])): processed_data['x'].append((data['x'][i] - min_x) / chord) processed_data['y'].append(data['y'][i] / chord) data = processed_data #============================================================================== # Optimizing shape #============================================================================== # Determining default bounds if bounds == 'Default': upper_bounds = [[0, 1.]] * (n + 1) lower_bounds = [[0, 1]] + [[-1., 1.]] * n if optimize_deltaz: bounds = upper_bounds + lower_bounds + [[0, 0.1]] else: bounds = upper_bounds + lower_bounds deltaz = (data['y'][0] - data['y'][-1]) print(bounds) upper, lower = separate_upper_lower(data) # a = data # x = data['x'] result = differential_evolution(shape_difference, bounds, disp=True, popsize=10, args=[optimize_deltaz]) print('order %i upper done' % n) # x = lower['x'] # a = lower # result_lower = differential_evolution(shape_difference_lower, lower_bounds, # disp=True, popsize = 10, # args = (optimize_deltaz)) # print 'order %i lower done' % n if optimize_deltaz: Au = list(result.x[:n + 1]) Al = list(result.x[n + 1:-1]) deltaz = result.x[-1] else: Au = list(result.x[:n + 1]) Al = list(result.x[n + 1:]) # Return Al, Au, and others if return_data: return data, deltaz, Al, Au elif return_error: return result.fun, deltaz, Al, Au else: return deltaz, Al, Au
def main(*args): # EXCEL if len(args) == 0: wb = xw.Book.caller() # ECLIPSE elif len(args) == 1: filename = args[0][0] wb = xw.Book(Root.resources() + filename) df = erw.data_reader(wb) ############# n = 1096 days = [i for i in range(len(df))] price = numpy.array(df.Price) holiday = numpy.array(df.Holiday) lnPrice = numpy.log(price[:n]) dim = len(df) ################# def func(t, alpha, beta, gamma, tau): return alpha + beta * holiday[int(t)] + gamma * numpy.cos( (tau + t) * (2 * math.pi) / 365) def funcSqSum(params): alpha, beta, gamma, tau = params return sum([(lnPrice[t] - func(t, alpha, beta, gamma, tau))**2 for t in range(0, n)]) x0 = [1.0, 1.0, 2.0, 3.0] eh = Eh() eh.lnPricetransp = lnPrice.reshape((len(lnPrice), 1)) eh.simulated = randopt.randopt(funcSqSum)[0] eh.value = randopt.randopt(funcSqSum)[1] ###############GLOBAL OPTIM f1 = open('basopt.txt', 'r+') if list(f1) == []: basopt = basinhopping(funcSqSum, x0) basopteha = basopt.x alpha = basopteha[0] beta = basopteha[1] gamma = basopteha[2] tau = basopteha[3] x = [alpha, beta, gamma, tau] json.dump(x, f1) else: f1 = open('basopt.txt', 'r') basopteha = json.load(f1) alpha = basopteha[0] beta = basopteha[1] gamma = basopteha[2] tau = basopteha[3] f2 = open('deopt.txt', 'r+') if list(f2) == []: bounds = [(-1000, 1000), (-1000, 1000), (-1000, 1000), (0, 365)] deopt = differential_evolution(funcSqSum, bounds) deopteha = deopt.x alpha2 = deopteha[0] beta2 = deopteha[1] gamma2 = deopteha[2] tau2 = deopteha[3] y = [alpha2, beta2, gamma2, tau2] json.dump(y, f2) else: f2 = open('deopt.txt', 'r') deopteha = json.load(f2) alpha2 = deopteha[0] beta2 = deopteha[1] gamma2 = deopteha[2] tau2 = deopteha[3] #######################Season, S_t season = numpy.zeros(dim) for t in days: season[t] = func(t, alpha, beta, gamma, tau) S = lnPrice[:n] - season[:n] ####################### eh.deopteha = deopteha eh.basopteha = basopteha eh.deoptfv = funcSqSum(deopteha) eh.basoptfv = funcSqSum(basopteha) eh.seasonexcel = season.reshape(len(season), 1) eh.Swrite = S.reshape(len(S), 1) kalk = calc.parameters(S, n) Delta = kalk[6] Kappa = kalk[8] Sigma = kalk[9] tol = 50 #####################################KALIBRATION kal1 = kal.kalibr(S, Kappa, Sigma, Delta, tol, n, season) S_kal1 = kal1[0] Pt_kal1 = kal1[1] pt1 = pth.plothelper(n, tol, price, Pt_kal1) pthelpkal1 = pt1 eh.S_kalresult = S_kal1.reshape(len(S_kal1), 1) eh.Pt_kalresult = Pt_kal1.reshape(len(Pt_kal1), 1) erw.result_writer(wb, eh) kal2 = kal.kalibr(S, Kappa, Sigma, Delta, tol, n, season) S_kal2 = kal2[0] Pt_kal2 = kal2[1] pt2 = pth.plothelper(n, tol, price, Pt_kal2) pthelpkal2 = pt2 kal3 = kal.kalibr(S, Kappa, Sigma, Delta, tol, n, season) S_kal3 = kal3[0] Pt_kal3 = kal3[1] pt3 = pth.plothelper(n, tol, price, Pt_kal3) pthelpkal3 = pt3 kal4 = kal.kalibr(S, Kappa, Sigma, Delta, tol, n, season) S_kal4 = kal4[0] Pt_kal4 = kal4[1] pt4 = pth.plothelper(n, tol, price, Pt_kal4) pthelpkal4 = pt4 kal5 = kal.kalibr(S, Kappa, Sigma, Delta, tol, n, season) S_kal5 = kal5[0] Pt_kal5 = kal5[1] pt5 = pth.plothelper(n, tol, price, Pt_kal5) pthelpkal5 = pt5 ############## MEAN REVERTING TEST print ts.adfuller(S) #ADFULLER TEST #####Hurts, mean reverting <=> H<0.5 def hurst(ts): """Returns the Hurst Exponent of the time series vector ts""" lags = range(2, 100) tau = [sqrt(std(subtract(ts[lag:], ts[:-lag]))) for lag in lags] poly = polyfit(log(lags), log(tau), 1) return poly[0] * 2.0 print "Hurst(S): %s" % hurst(S) #############################Prediction, 7 day tol = n pu = scipy.stats.norm.ppf(0.975) #up/felso p = 0.0 # standard norm=0 pd = scipy.stats.norm.ppf(0.025) #down/also Delta = 1.0 S_pred = pred.pred(p, S, Kappa, Delta, Sigma, tol, season)[0] Pt_pred = pred.pred(p, S, Kappa, Delta, Sigma, tol, season)[1] S_pu = pred.pred(pu, S, Kappa, Delta, Sigma, tol, season)[0] Pt_pu = pred.pred(pu, S, Kappa, Delta, Sigma, tol, season)[1] S_pd = pred.pred(pd, S, Kappa, Delta, Sigma, tol, season)[0] Pt_pd = pred.pred(pd, S, Kappa, Delta, Sigma, tol, season)[1] plothelper2 = predplot.prdplt(n, tol, price, Pt_pu) plothelper3 = predplot.prdplt(n, tol, price, Pt_pd) plotgood = predplot.prdplt(n, tol, price, Pt_pred) ############PLOTS plt.figure(1) plt.plot(price, label='1') plt.plot(pthelpkal1, label='2') plt.title("Ar") plt.xlabel('Ido, napokban') plt.ylabel('Eur/MWh') # szotchasztikus folyamat plt.figure(2) plt.plot(S, label='1') plt.plot(S_kal1, label='2') plt.title("S folyamat") plt.xlabel('Id , napokban') #szezon fv plot plt.figure(3) plt.plot(season) plt.title("Szezon fuggveny") plt.xlabel('Ido, napokban') #predikcio plt.figure(4) plt.plot(plothelper2[n - 15:], label='pt_upper') plt.plot(plothelper3[n - 15:], label='pt_lower') plt.plot(plotgood[n - 15:], label='pt_pontos') plt.plot(price[n - 15:n], label='eredeti') plt.title("Ar predikcio") plt.xlabel('Ido, napokban') plt.ylabel('Eur/MWh') #tobb kalibracio plt.figure(5) plt.plot(pthelpkal1[0:100], label='Kalibracio 1') plt.plot(pthelpkal2[0:100], label='Kalibracio 2') plt.plot(pthelpkal3[0:100], label='Kalibracio 3') plt.plot(price[0:50], label='Eredeti ar', linewidth=3.0) plt.title("Szcenariok") plt.xlabel('Ido, napokban') plt.ylabel('Eur/MWh') #megtobb plt.figure(6) plt.plot(pthelpkal1[0:100], label='Kalibracio 1') plt.plot(pthelpkal2[0:100], label='Kalibracio 2') plt.plot(pthelpkal3[0:100], label='Kalibracio 3') plt.plot(pthelpkal4[0:100], label='Kalibracio 4') plt.plot(pthelpkal5[0:100], label='Kalibracio 5') plt.plot(price[0:50], label='Eredeti ar', linewidth=3.0) plt.title("Szcenariok") plt.xlabel('Ido, napokban') plt.ylabel('Eur/MWh') plt.show() print 'END'
def run(self): """ Optimize the problem using selected Scipy optimizer. Returns ------- boolean Failure flag; True if failed to converge, False is successful. """ problem = self._problem opt = self.options['optimizer'] model = problem.model self.iter_count = 0 self._total_jac = None # Initial Run with RecordingDebugging(self._get_name(), self.iter_count, self) as rec: model.run_solve_nonlinear() self.iter_count += 1 self._con_cache = self.get_constraint_values() desvar_vals = self.get_design_var_values() self._dvlist = list(self._designvars) # maxiter and disp get passsed into scipy with all the other options. self.opt_settings['maxiter'] = self.options['maxiter'] self.opt_settings['disp'] = self.options['disp'] # Size Problem nparam = 0 for param in itervalues(self._designvars): nparam += param['size'] x_init = np.empty(nparam) # Initial Design Vars i = 0 use_bounds = (opt in _bounds_optimizers) if use_bounds: bounds = [] else: bounds = None for name, meta in iteritems(self._designvars): size = meta['size'] x_init[i:i + size] = desvar_vals[name] i += size # Bounds if our optimizer supports them if use_bounds: meta_low = meta['lower'] meta_high = meta['upper'] for j in range(size): if isinstance(meta_low, np.ndarray): p_low = meta_low[j] else: p_low = meta_low if isinstance(meta_high, np.ndarray): p_high = meta_high[j] else: p_high = meta_high bounds.append((p_low, p_high)) if use_bounds and (opt in _supports_new_style) and _use_new_style: # For 'trust-constr' it is better to use the new type bounds, because it seems to work # better (for the current examples in the tests) with the "keep_feasible" option try: from scipy.optimize import Bounds from scipy.optimize._constraints import old_bound_to_new except ImportError: msg = ('The "trust-constr" optimizer is supported for SciPy 1.1.0 and above. ' 'The installed version is {}') raise ImportError(msg.format(scipy_version)) # Convert "old-style" bounds to "new_style" bounds lower, upper = old_bound_to_new(bounds) # tuple, tuple keep_feasible = self.opt_settings.get('keep_feasible_bounds', True) bounds = Bounds(lb=lower, ub=upper, keep_feasible=keep_feasible) # Constraints constraints = [] i = 1 # start at 1 since row 0 is the objective. Constraints start at row 1. lin_i = 0 # counter for linear constraint jacobian lincons = [] # list of linear constraints self._obj_and_nlcons = list(self._objs) if opt in _constraint_optimizers: for name, meta in iteritems(self._cons): size = meta['size'] upper = meta['upper'] lower = meta['lower'] equals = meta['equals'] if 'linear' in meta and meta['linear']: lincons.append(name) self._con_idx[name] = lin_i lin_i += size else: self._obj_and_nlcons.append(name) self._con_idx[name] = i i += size # In scipy constraint optimizers take constraints in two separate formats # Type of constraints is list of NonlinearConstraint if opt in _supports_new_style and _use_new_style: try: from scipy.optimize import NonlinearConstraint except ImportError: msg = ('The "trust-constr" optimizer is supported for SciPy 1.1.0 and' 'above. The installed version is {}') raise ImportError(msg.format(scipy_version)) if equals is not None: lb = ub = equals else: lb = lower ub = upper # Loop over every index separately, # because scipy calls each constraint by index. for j in range(size): # Double-sided constraints are accepted by the algorithm args = [name, False, j] # TODO linear constraint if meta['linear'] # TODO add option for Hessian con = NonlinearConstraint(fun=signature_extender(self._con_val_func, args), lb=lb, ub=ub, jac=signature_extender(self._congradfunc, args)) constraints.append(con) else: # Type of constraints is list of dict # Loop over every index separately, # because scipy calls each constraint by index. for j in range(size): con_dict = {} if meta['equals'] is not None: con_dict['type'] = 'eq' else: con_dict['type'] = 'ineq' con_dict['fun'] = self._confunc if opt in _constraint_grad_optimizers: con_dict['jac'] = self._congradfunc con_dict['args'] = [name, False, j] constraints.append(con_dict) if isinstance(upper, np.ndarray): upper = upper[j] if isinstance(lower, np.ndarray): lower = lower[j] dblcon = (upper < openmdao.INF_BOUND) and (lower > -openmdao.INF_BOUND) # Add extra constraint if double-sided if dblcon: dcon_dict = {} dcon_dict['type'] = 'ineq' dcon_dict['fun'] = self._confunc if opt in _constraint_grad_optimizers: dcon_dict['jac'] = self._congradfunc dcon_dict['args'] = [name, True, j] constraints.append(dcon_dict) # precalculate gradients of linear constraints if lincons: self._lincongrad_cache = self._compute_totals(of=lincons, wrt=self._dvlist, return_format='array') else: self._lincongrad_cache = None # Provide gradients for optimizers that support it if opt in _gradient_optimizers: jac = self._gradfunc else: jac = None # Hessian calculation method for optimizers, which require it if opt in _hessian_optimizers: if 'hess' in self.opt_settings: hess = self.opt_settings.pop('hess') else: # Defaults to BFGS, if not in opt_settings from scipy.optimize import BFGS hess = BFGS() else: hess = None # compute dynamic simul deriv coloring if option is set if coloring_mod._use_sparsity and self.options['dynamic_simul_derivs']: coloring_mod.dynamic_simul_coloring(self, run_model=False, do_sparsity=False) # optimize try: if opt in _optimizers: result = minimize(self._objfunc, x_init, # args=(), method=opt, jac=jac, hess=hess, # hessp=None, bounds=bounds, constraints=constraints, tol=self.options['tol'], # callback=None, options=self.opt_settings) elif opt == 'basinhopping': from scipy.optimize import basinhopping def fun(x): return self._objfunc(x), jac(x) if 'minimizer_kwargs' not in self.opt_settings: self.opt_settings['minimizer_kwargs'] = {"method": "L-BFGS-B", "jac": True} self.opt_settings.pop('maxiter') # It does not have this argument def accept_test(f_new, x_new, f_old, x_old): # Used to implement bounds besides the original functionality if bounds is not None: bound_check = all([b[0] <= xi <= b[1] for xi, b in zip(x_new, bounds)]) user_test = self.opt_settings.pop('accept_test', None) # callable # has to satisfy both the bounds and the acceptance test defined by the # user if user_test is not None: test_res = user_test(f_new, x_new, f_old, x_old) if test_res == 'force accept': return test_res else: # result is boolean return bound_check and test_res else: # no user acceptance test, check only the bounds return bound_check else: return True result = basinhopping(fun, x_init, accept_test=accept_test, **self.opt_settings) elif opt == 'dual_annealing': from scipy.optimize import dual_annealing self.opt_settings.pop('disp') # It does not have this argument # There is no "options" param, so "opt_settings" can be used to set the (many) # keyword arguments result = dual_annealing(self._objfunc, bounds=bounds, **self.opt_settings) elif opt == 'differential_evolution': from scipy.optimize import differential_evolution # There is no "options" param, so "opt_settings" can be used to set the (many) # keyword arguments result = differential_evolution(self._objfunc, bounds=bounds, **self.opt_settings) elif opt == 'shgo': from scipy.optimize import shgo kwargs = dict() for param in ('minimizer_kwargs', 'sampling_method ', 'n', 'iters'): if param in self.opt_settings: kwargs[param] = self.opt_settings[param] # Set the Jacobian and the Hessian to the value calculated in OpenMDAO if 'minimizer_kwargs' not in kwargs or kwargs['minimizer_kwargs'] is None: kwargs['minimizer_kwargs'] = {} kwargs['minimizer_kwargs'].setdefault('jac', jac) kwargs['minimizer_kwargs'].setdefault('hess', hess) # Objective function tolerance self.opt_settings['f_tol'] = self.options['tol'] result = shgo(self._objfunc, bounds=bounds, constraints=constraints, options=self.opt_settings, **kwargs) else: msg = 'Optimizer "{}" is not implemented yet. Choose from: {}' raise NotImplementedError(msg.format(opt, _all_optimizers)) # If an exception was swallowed in one of our callbacks, we want to raise it # rather than the cryptic message from scipy. except Exception as msg: if self._exc_info is not None: self._reraise() else: raise if self._exc_info is not None: self._reraise() self.result = result if hasattr(result, 'success'): self.fail = False if result.success else True if self.fail: print('Optimization FAILED.') print(result.message) print('-' * 35) elif self.options['disp']: print('Optimization Complete') print('-' * 35) else: self.fail = True # It is not known, so the worst option is assumed print('Optimization Complete (success not known)') print(result.message) print('-' * 35) return self.fail
{"name": "id_start_x", "type": ["int"]}, {"name": "model", "type": ["bytes"]}, {"name": "model_size", "type": ["int"]}, {"name": "rmse", "type": ["null", "float"]}, {"name": "mae", "type": ["null", "float"]}, {"name": "rsquared", "type": ["null", "float"]}, {"name": "CPU_ms", "type": ["int"]}, {"name": "RAM", "type": ["int"]} ] """ new_model = new_pc.decode_avro_msg(msg) model = pickle.loads(new_model['model']) result = differential_evolution(evaluate_diff_evo, bounds, maxiter=N_MAX_ITER, popsize=N_POP_SIZE) surrogate_x = result.x[0] surrogate_y = result.fun print(f"The {new_model['model_name']} optimization suggests " f"x={round(surrogate_x, 3)}, y={round(surrogate_y, 3)}") """ "name": "Model_Application", "fields": [ {"name": "phase", "type": ["enum"], "symbols": ["init", "observation"]}, {"name": "model_name", "type": ["string"]}, {"name": "id_x", "type": ["int"]}, {"name": "n_data_points", "type": ["int"]}, {"name": "id_start_x", "type": ["int"]},
def main(): main_dir = Path( r'P:\Synchronize\IWS\Testings\fourtrans_practice\multisite_phs_spec_corr\5min\v7_long_range') os.chdir(main_dir) # in_data_file = Path(r'temperature_avg.csv') # in_crds_file = Path(r'temperature_avg_coords.csv') # has X, Y, Z cols # out_fig_pref = f'temperature_{mw_ftn}' suff = '__RR1D_RTsum' in_data_file = Path(r'../neckar_1min_ppt_data_20km_buff_Y2009__RRD_RTsum.pkl') in_crds_file = Path(r'../metadata_ppt_gkz3_crds.csv') # has X, Y cols out_fig_pref = f'ppt_{mw_ftn}' sep = ';' time_fmt = '%Y-%m-%d %H:%M:%S' beg_time = '2009-01-01 00:00:00' end_time = '2009-03-31 23:59:00' fig_size = (15, 7) cut_off_dist = 70e3 rng_bds = [1, 1e6] sill_bds = [0.0, 1.0] out_dir = main_dir phss_out_dir = out_dir / 'phss' phss_out_dir.mkdir(exist_ok=True, parents=True) cos_out_dir = out_dir / 'cos' cos_out_dir.mkdir(exist_ok=True, parents=True) sin_out_dir = out_dir / 'sin' sin_out_dir.mkdir(exist_ok=True, parents=True) mags_out_dir = out_dir / 'mags' mags_out_dir.mkdir(exist_ok=True, parents=True) if in_data_file.suffix == '.csv': data_df = pd.read_csv(in_data_file, sep=sep, index_col=0) data_df.index = pd.to_datetime(data_df.index, format=time_fmt) elif in_data_file.suffix == '.pkl': data_df = pd.read_pickle(in_data_file) else: raise NotImplementedError( f'Unknown extension of in_data_file: {in_data_file.suffix}!') crds_df = pd.read_csv(in_crds_file, sep=sep, index_col=0) data_df = data_df.loc[beg_time:end_time] data_df.dropna(axis=1, how='any', inplace=True) crds_df = crds_df.loc[data_df.columns] assert np.all(np.isfinite(data_df.values)) assert np.all(np.isfinite(crds_df[['X', 'Y']].values)) print(data_df.shape) print(crds_df.shape) assert all(data_df.shape) all_stns = data_df.columns if data_df.shape[0] % 2: data_df = data_df.iloc[:-1,:] print('Dropped last record in data_df!') n_stns = data_df.shape[1] probs_df = data_df.rank(axis=0) / (data_df.shape[0] + 1) norms_df = pd.DataFrame( data=norm.ppf(probs_df.values), columns=data_df.columns) ft_df = pd.DataFrame( data=np.fft.rfft(norms_df.values, axis=0), columns=data_df.columns) phs_spec_df = pd.DataFrame(data=np.angle(ft_df), columns=data_df.columns) cos_spec_df = pd.DataFrame( data=np.cos(phs_spec_df.values), columns=data_df.columns) sin_spec_df = pd.DataFrame( data=np.sin(phs_spec_df.values), columns=data_df.columns) # phs_le_idxs = phs_spec_df < 0 # # phs_spec_df[phs_le_idxs] = (2 * np.pi) + phs_spec_df[phs_le_idxs] mag_spec_df = pd.DataFrame( data=np.abs(ft_df), columns=data_df.columns) n_freqs = phs_spec_df.shape[0] # Test to verify that forward and backward transforms are # working as expected. # fft_vals = np.empty_like(mag_spec_df.values, dtype=complex) # # fft_vals[:].real = mag_spec_df.values * np.cos(phs_spec_df.values) # fft_vals[:].imag = mag_spec_df.values * np.sin(phs_spec_df.values) # # ift_vals = np.fft.irfft(fft_vals, axis=0) phs_spec_df.to_csv(str(phss_out_dir / f'phss{suff}.csv'), sep=sep) cos_spec_df.to_csv(str(cos_out_dir / f'cos{suff}.csv'), sep=sep) sin_spec_df.to_csv(str(sin_out_dir / f'sin{suff}.csv'), sep=sep) mag_spec_df.to_csv(str(mags_out_dir / f'mags{suff}.csv'), sep=sep) dist_and_corrs_mat = np.full( (int(n_stns * (n_stns - 1) * 0.5), 3), np.nan) print(dist_and_corrs_mat.shape) print('Filling matrix...') idx = 0 for i in range(n_stns): x_crd_i, y_crd_i = crds_df.loc[all_stns[i], ['X', 'Y']] for j in range(n_stns): if j <= i: continue x_crd_j, y_crd_j = crds_df.loc[ all_stns[j], ['X', 'Y']] dist = ( ((x_crd_i - x_crd_j) ** 2) + ((y_crd_i - y_crd_j) ** 2)) dist **= 0.5 phs_corr = np.cos( phs_spec_df.loc[:, all_stns[i]].values - phs_spec_df.loc[:, all_stns[j]].values).sum() / n_freqs mag_num = mag_spec_df.loc[:, [all_stns[i], all_stns[j]]].product(axis=1).values.sum() mag_denom = mag_spec_df.loc[:, [all_stns[i], all_stns[j]]].values ** 2 mag_denom = mag_denom.sum(axis=0) mag_denom = np.product(mag_denom) mag_denom **= 0.5 mag_corr = mag_num / mag_denom dist_and_corrs_mat[idx, 0] = dist dist_and_corrs_mat[idx, 1] = phs_corr dist_and_corrs_mat[idx, 2] = mag_corr idx += 1 assert np.all(np.isfinite(dist_and_corrs_mat)) print('Done filling!') # max_corr = dist_and_corrs_mat[:, [1, 2]].max() # min_corr = dist_and_corrs_mat[:, [1, 2]].min() print('Optimizing...') dist_sort_idxs = np.argsort(dist_and_corrs_mat[:, 0]) (exp_vg_vals_x_mw, exp_vg_vals_mag_mw, exp_vg_vals_phs_mw) = get_mv_vals_crds( dist_and_corrs_mat[dist_sort_idxs, 0], dist_and_corrs_mat[dist_sort_idxs, 2], dist_and_corrs_mat[dist_sort_idxs, 1], 50) opt_dist_idxs = exp_vg_vals_x_mw < cut_off_dist bds = [ rng_bds, sill_bds] opt_res = differential_evolution( obj_ftn, bds, popsize=50, args=(exp_vg_vals_x_mw[opt_dist_idxs], exp_vg_vals_mag_mw[opt_dist_idxs]), polish=False) opt_prms = opt_res.x sq_diff = opt_res.fun print(np.round(opt_prms, 3)) print(sq_diff) print('Done optimizing.') mag_cftn_str = ( f'{opt_prms[1]:0.5f} Exp({opt_prms[0]:0.1f})') with open(str(mags_out_dir / f'{out_fig_pref}_cftns{suff}.csv'), 'w') as txt_hdl: txt_hdl.write(f'ft_type;cftn\n') txt_hdl.write(f'mag;{mag_cftn_str}\n') with open(str(mags_out_dir / f'vg_strs{suff}.csv'), 'w') as txt_hdl: txt_hdl.write(f'freq;vg\n') for i in range(n_freqs): txt_hdl.write(f'{i};{mag_cftn_str}\n') exp_vg_vals = get_nug_sph_cftn(opt_prms, dist_and_corrs_mat[:, 0]) # Magnitude scatter plt.figure(figsize=fig_size) plt.scatter( dist_and_corrs_mat[:, 0], dist_and_corrs_mat[:, 2], alpha=0.6, color='red', label='obs') plt.scatter( dist_and_corrs_mat[:, 0], exp_vg_vals, alpha=0.6, color='blue', label='fit') plt.plot( exp_vg_vals_x_mw, exp_vg_vals_mag_mw, alpha=0.6, color='green', label='mw') plt.title(mag_cftn_str) plt.grid() plt.legend() plt.xlabel('Distance (m)') plt.ylabel('Mag. Spec. Corr. (-)') plt.gca().set_axisbelow(True) plt.xlim(0, plt.xlim()[1]) # plt.ylim(min_corr, max_corr) plt.savefig( str(mags_out_dir / f'{out_fig_pref}_mag_corr_cftn{suff}.png'), bbox_inches='tight') # plt.show() plt.close() # Phase spectrum. opt_res = differential_evolution( obj_ftn, bds, popsize=50, args=(exp_vg_vals_x_mw[opt_dist_idxs], exp_vg_vals_phs_mw[opt_dist_idxs]), polish=False) opt_prms = opt_res.x sq_diff = opt_res.fun print(np.round(opt_prms, 3)) print(sq_diff) print('Done optimizing.') phs_cftn_str = ( f'{opt_prms[1]:0.5f} Exp({opt_prms[0]:0.1f})') with open(str(phss_out_dir / f'{out_fig_pref}_cftns{suff}.csv'), 'w') as txt_hdl: txt_hdl.write(f'ft_type;cftn\n') txt_hdl.write(f'phs;{phs_cftn_str}\n') with open(str(phss_out_dir / f'vg_strs{suff}.csv'), 'w') as txt_hdl: txt_hdl.write(f'freq;vg\n') for i in range(n_freqs): txt_hdl.write(f'{i};{phs_cftn_str}\n') with open(str(cos_out_dir / f'vg_strs{suff}.csv'), 'w') as txt_hdl: txt_hdl.write(f'freq;vg\n') for i in range(n_freqs): txt_hdl.write(f'{i};{phs_cftn_str}\n') with open(str(sin_out_dir / f'vg_strs{suff}.csv'), 'w') as txt_hdl: txt_hdl.write(f'freq;vg\n') for i in range(n_freqs): txt_hdl.write(f'{i};{phs_cftn_str}\n') exp_vg_vals = get_nug_sph_cftn(opt_prms, dist_and_corrs_mat[:, 0]) # Phase scatter plt.figure(figsize=fig_size) plt.scatter( dist_and_corrs_mat[:, 0], dist_and_corrs_mat[:, 1], alpha=0.6, color='red', label='obs') plt.scatter( dist_and_corrs_mat[:, 0], exp_vg_vals, alpha=0.6, color='blue', label='fit') plt.plot( exp_vg_vals_x_mw, exp_vg_vals_phs_mw, alpha=0.6, color='green', label='mw') plt.title(phs_cftn_str) plt.grid() plt.legend() plt.xlabel('Distance (m)') plt.ylabel('Phs. Spec. Corr. (-)') plt.gca().set_axisbelow(True) plt.xlim(0, plt.xlim()[1]) # plt.ylim(min_corr, max_corr) plt.savefig( str(phss_out_dir / f'{out_fig_pref}_phs_corr_cftn{suff}.png'), bbox_inches='tight') # plt.show() plt.close() return
xyz_data = (xy_data_coord, histo, matern_v) if opt_method == 'nelder-mead': initial_param = np.array( [10, 10, 10]) # sigma, length and noise - find a good one to reduce iterations # No bounds needed for Nelder-Mead solution = scopt.minimize(fun=log_model_evidence, args=xyz_data, x0=initial_param, method='Nelder-Mead') elif opt_method == 'latin-hypercube': boundary = [(0, 30), (0, 3), (0, 3)] solution = scopt.differential_evolution(func=log_model_evidence, bounds=boundary, args=xyz_data, init='latinhypercube') sigma_optimal = solution.x[0] length_optimal = solution.x[1] noise_optimal = solution.x[2] print(solution) """Defining the entire range of potential sampling points""" intervals = 50 cut_off_x = (np.max(xv_transform_row) - np.min(xv_transform_row)) / 2 cut_off_y = (np.max(yv_transform_row) - np.min(yv_transform_row)) / 2 sampling_points_x = np.linspace( np.min(xv_transform_row) - cut_off_x, np.max(xv_transform_row) + cut_off_x, intervals) sampling_points_y = np.linspace( np.min(yv_transform_row) - cut_off_y,
def __tune__(self): bounds = [self.attachmentBound] result = optimize.differential_evolution(self.__ESNTrain__, bounds=bounds) #print("\nThe optimal parameters for Scale Free Networks ESN:"+str(result.x)) return int(np.floor(result.x[0]))
(k**13) * p13 + (k**14) * p14) ] api = api_i[s - 3] aps[i, s - 1] = api corr = np.corrcoef(aps[off_idx:, Q_obs_col], aps[off_idx:, s - 1])[0, 1] crs[s] = corr return (1 - corr) # optimize x0_bounds = (0, 1) bounds = [x0_bounds] result = differential_evolution(objective, bounds) x = result[0].x # show final objective print('Optimised_corr_' + str(s) + ': ' + str(1 - objective(x))) # print (solution) print('k = ' + str(x[0])) print('\n') crs = list(crs) columns = ('prec', 'Q_obs', 'api_3', 'api_4', 'api_5', 'api_6', 'api_7', 'api_8', 'api_9', 'api_10', 'api_11', 'api_12', 'api_13', 'api_14') idx = pd.date_range(dates_start, dates_end) aps_df = pd.DataFrame(aps, columns=columns, index=idx) pd.to_pickle(aps_df, 'aps' + station_p) aps_df.to_excel('aps.xlsx', sheet_name='Sheet1')
def differential_evolution( parameters_guess, bounds, fit_bead, fit_parameter_names, exp_dict, global_opts={}, constraints=None, ): r""" Fit defined parameters for equation of state object using scipy.optimize.differential_evolution with given experimental data. Parameters ---------- parameters_guess : numpy.ndarray An array of initial guesses for parameters. bounds : list[tuple] List of length equal to fit_parameter_names with lists of pairs for minimum and maximum bounds of parameter being fit. Defaults from Eos object are broad, so we recommend specification. fit_bead : str Name of bead whose parameters are being fit. fit_parameter_names : list[str] This list contains the name of the parameter being fit (e.g. epsilon). See EOS documentation for supported parameter names. Cross interaction parameter names should be composed of parameter name and the other bead type, separated by an underscore (e.g. epsilon_CO2). exp_dict : dict Dictionary of experimental data objects. global_opts : dict, Optional - init (str) - Optional, default="random", type of initiation for population - write_intermediate_file (str) - Optional, default=False, If True, an intermediate file will be written from the method callback - filename (str) - Optional, default=None, filename for callback output, if provided, ``write_intermediate_file`` will be set to True - obj_cut (float) - Optional, default=None, Cut-off objective value to write the parameters, if provided, ``write_intermediate_file`` will be set to True - etc. Other keywords for scipy.optimize.differential_evolution use the function defaults constraints : dict, Optional, default=None This dictionary of constraint types and their arguments will be converted into a tuple of constraint classes that is compatible Returns ------- Objective : obj scipy OptimizedResult object """ obj_kwargs = ["obj_cut", "filename", "write_intermediate_file"] if "obj_cut" in global_opts: obj_cut = global_opts["obj_cut"] del global_opts["obj_cut"] global_opts["write_intermediate_file"] = True else: obj_cut = None if "filename" in global_opts: filename = global_opts["filename"] del global_opts["filename"] global_opts["write_intermediate_file"] = True else: filename = None if ("write_intermediate_file" in global_opts and global_opts["write_intermediate_file"]): del global_opts["write_intermediate_file"] global_opts["callback"] = _WriteParameterResults(fit_parameter_names, obj_cut=obj_cut, filename=filename) # Options for differential evolution, set defaults in new_global_opts new_global_opts = {"init": "random"} if global_opts: for key, value in global_opts.items(): if key == "MultiprocessingObject": flag_workers = "workers" in global_opts and global_opts[ "workers"] > 1 if value.ncores > 1 and flag_workers: logger.info( "Differential Evolution algorithm is using {} workers." .format(value.ncores)) new_global_opts["workers"] = value._pool.map exp_dict = _del_Data_MultiprocessingObject(exp_dict) elif key not in obj_kwargs: new_global_opts[key] = value global_opts = new_global_opts if constraints is not None: global_opts["constraints"] = ff.initialize_constraints( constraints, "class") logger.info("Differential Evolution Options: {}".format(global_opts)) result = spo.differential_evolution(ff.compute_obj, bounds, args=(fit_bead, fit_parameter_names, exp_dict, bounds), **global_opts) return result
df = pd.DataFrame(index=['Weights', 'fitness'], data=np.concatenate([optimizer.W[None, ...], optimizer.fitness[None, ...]], axis=0)) #display(df) #print(df) ''' clear_output() print(i, optimizer.best) fitness_values.append(optimizer.fitness) best_fitness.append(optimizer.best[0]) for fv in np.array(fitness_values).T: plt.plot(fv, color='b') plt.plot(best_fitness, color='g') bestGrid = auxGrid(*denormalize(optimizer.best[1])) plt.imshow(pimg + (1 - bestGrid)) result = optimize.differential_evolution(lambda x: -fitness(x), bounds=aquarium) aaa = auxGrid(*denormalize(result.x)) plt.imshow(pimg + (1 - aaa)) plt.imshow( utils.grid(img_fit.shape, [a1, a2], [freq1, freq2], [phase1, phase2], width)) plt.imshow(auxGrid(*denormalize(optimizer.best[1]))) swarm_size = 20 population = np.random.randn(swarm_size, 4) * .5 pso = PSO(population, 1, 1, 0.8) for i in range(50): pso.minimize(lambda x: -fitness(x))
import numpy as np from scipy import optimize from matplotlib import pylab as plt x = np.arange(1, 30, 0.1) y1 = np.sin(x / 5.) * np.exp(x / 10.) + 5 * np.exp(-x / 2.) y_gr = [int(y1_val) for y1_val in y1] y_func = lambda x: int(np.sin(x / 5.) * np.exp(x / 10.) + 5 * np.exp(-x / 2.)) plt.plot(x, y_gr) mmm = optimize.minimize(y_func, [30], method='BFGS') print(mmm) print("# Task 1 MIN: " + str(mmm.fun) + " in point " + str(mmm.x)) print("----------------------------------------------") mmm = optimize.differential_evolution(y_func, [(1, 30)]) print(mmm) print("# Task 2 MIN: " + str(mmm.fun) + " in point " + str(mmm.x))
def fitting_shape_coefficients(filename, bounds='Default', n=5, return_data=False, return_error=False, optimize_deltaz=False, solver='gradient', deltaz=None, objective='hausdorf', surface='both', x0=None): """Fit shape parameters to given data points Inputs: - filename: name of the file where the original data is - bounds: bounds for the shape parameters. If not defined, Default values are used. - n: order of the Bernstein polynomial. If bounds is default this input will define the order of the polynomial. Otherwise the length of bounds (minus one) is taken into consideration""" from optimization_tools.hausdorff_distance import hausdorff_distance_2D def shape_difference(inputs, optimize_deltaz=False, surface=surface): # Define deltaz if optimize_deltaz is True or optimize_deltaz == [True]: deltasz = inputs[-1] / 2. else: deltasz = deltaz / 2. # Calculate upper and lower surface if surface == 'both': y_u = CST(upper['x'], 1, deltasz=deltasz, Au=list(inputs[:n + 1])) y_l = CST(lower['x'], 1, deltasz=deltasz, Al=list(inputs[n + 1:-1])) elif surface == 'upper': y_u = CST(upper['x'], 1, deltasz=deltasz, Au=list(inputs[:n + 1])) elif surface == 'lower': y_l = CST(lower['x'], 1, deltasz=deltasz, Al=list(inputs[:n + 1])) # Vector to be compared with error = 0 if surface == 'upper' or surface == 'both': a_u = {'x': upper['x'], 'y': y_u} if objective == 'hausdorf': error += hausdorff_distance_2D(a_u, upper) elif objective == 'squared_mean': error += np.mean( (np.array(a_u['x']) - np.array(upper['x']))**2 + (np.array(a_u['y']) - np.array(upper['y']))**2) if surface == 'lower' or surface == 'both': a_l = {'x': lower['x'], 'y': y_l} if objective == 'hausdorf': error += hausdorff_distance_2D(a_l, lower) elif objective == 'squared_mean': error += np.mean( (np.array(a_l['x']) - np.array(lower['x']))**2 + (np.array(a_l['y']) - np.array(lower['y']))**2) # plt.figure() # plt.scatter(a_u['x'], a_u['y'], c='k') # plt.scatter(a_l['x'], a_l['y'], c='b') # plt.scatter(upper['x'], upper['y'], c='r') # plt.scatter(lower['x'], lower['y'], c='g') # plt.show() return error def separate_upper_lower(data): for key in data: data[key] = np.array(data[key]) index = np.where(data['y'] > 0) upper = {'x': data['x'][index], 'y': data['y'][index]} index = np.where(data['y'] <= 0) lower = {'x': data['x'][index], 'y': data['y'][index]} # x = data['x'] # y = data['y'] # for i in range(len(x)): # if data['y'][i] < 0: # break # upper = {'x': x[0:i], # 'y': y[0:i]} # lower = {'x': x[i:], # 'y': y[i:]} return upper, lower def _determine_bounds_x0(n, optimize_deltaz, bounds): if bounds == 'Default': upper_bounds = [[0, 1]] + [[-1., 1.]] * n lower_bounds = [[0, 1]] + [[-1., 1.]] * n if optimize_deltaz: if surface == 'both': bounds = upper_bounds + lower_bounds + [[0, 0.1]] x0 = (n + 1) * [ 0., ] + (n + 1) * [ 0., ] + [0.] elif surface == 'upper': bounds = upper_bounds + [[0, 0.1]] x0 = (n + 1) * [ 0., ] + [0.] elif surface == 'lower': bounds = lower_bounds + [[0, 0.1]] x0 = (n + 1) * [ 0., ] + [0.] else: bounds = upper_bounds + lower_bounds x0 = (n + 1) * [ 0., ] + (n + 1) * [ 0., ] return x0, bounds # Order of Bernstein polynomial if bounds != 'Default': n = len(bounds) - 1 # Obtaining data if filename[-2:] == '.p': import pickle data = pickle.load(open(filename, "rb"), encoding='latin1') data = data['wing'][list(data['wing'].keys())[3]] x, y, z = data.T else: data = output_reader(filename, separator='\t', header=['x', 'z']) x = data['x'] z = data['z'] # Rotating airfoil x_TE = (x[0] + x[-1]) / 2. y_TE = (z[0] + z[-1]) / 2. theta_TE = math.atan(-y_TE / x_TE) # position trailing edge at the x-axis processed_data = {'x': [], 'y': []} for i in range(len(x)): x_i = x[i] z_i = z[i] c_theta = math.cos(theta_TE) s_theta = math.sin(theta_TE) x_rotated = c_theta * x_i - s_theta * z_i z_rotated = s_theta * x_i + c_theta * z_i processed_data['x'].append(x_rotated) processed_data['y'].append(z_rotated) data = processed_data # determine what is the leading edge and the rotation angle beta processed_data = {'x': [], 'y': []} min_x = min(x) # min_index = data['x'].index(min_x) # min_y = data['y'][min_index] chord = max(x) - min(x) # beta = math.atan((y_TE - min_y)/(x_TE - min_x)) for i in range(len(x)): processed_data['x'].append((x[i] - min_x) / chord) processed_data['y'].append(z[i] / chord) data = processed_data # Determining default bounds x0_default, bounds = _determine_bounds_x0(n, optimize_deltaz, bounds) if x0 is None: x0 = x0_default if not optimize_deltaz and deltaz is None: deltaz = (data['y'][0] - data['y'][-1]) if surface == 'both': upper, lower = separate_upper_lower(data) elif surface == 'upper': upper = data elif surface == 'lower': lower = data # Calculate original error error0 = shape_difference(x0, optimize_deltaz=optimize_deltaz, surface=surface) def f(x): return shape_difference( x, optimize_deltaz=optimize_deltaz, surface=surface) / error0 # Optimize if solver == 'differential_evolution': result = differential_evolution(f, bounds, disp=True, popsize=10) x = result.x f = result.fun elif solver == 'gradient': solution = minimize(f, x0, bounds=bounds, options={ 'maxfun': 30000, 'eps': 1e-02 }) x = solution['x'] f = solution['fun'] print('order %i done' % n) # Unpackage data if surface == 'both' or surface == 'upper': Au = list(x[:n + 1]) if surface == 'both': if optimize_deltaz: Al = list(x[n + 1:-1]) deltaz = x[-1] else: Al = list(x[n + 1:]) elif surface == 'lower': Al = list(x[:n + 1]) # Return Al, Au, and others to_return = [] if return_data: to_return.append(data) if return_error: to_return.append(f) to_return.append(deltaz) if surface == 'lower' or surface == 'both': to_return.append(Al) elif surface == 'upper' or surface == 'both': to_return.append(Au) print(to_return) return to_return
x_list.append(int(round(BS_x[i]))) for i in range(list_Num): Permutation_list.append(list_[x_list[i]]) del list_[x_list[i]] for i in range(len(C_all_points) / 2): Store_Comb.append(CABC_all_points[Permutation_list[i]]) for i in range(len(C_all_points) / 2): Adjust_x.append(Store_Comb[i]) #A + B + C Cal_Op_ABC = Sa + Sb + Nearest_Dis.fun return Cal_Op_ABC COp_ABC = differential_evolution(Op_ABC, bounds, maxiter=5, polish=False) #COp_ABC.x = C_all_points (The best one) print COp_ABC.x print COp_ABC.fun Adjust_x_ = [] for i in range(len(Adjust_x) - 5, len(Adjust_x), 1): Adjust_x_.append(Adjust_x[i]) #Plot Plot_Store_Dist = [] for i in range(len(Adjust_x_) - 1): Dis_0 = vg.Point(Adjust_x_[i][0], Adjust_x_[i][1]) Dis_1 = vg.Point(Adjust_x_[i + 1][0], Adjust_x_[i + 1][1]) Dist = g.shortest_path(Dis_0, Dis_1) del Dist[len(Dist) - 1]
from cmath import sin, exp import numpy as np from matplotlib import pylab as plt from scipy import linalg from scipy import optimize def f(x): return (sin(x / 5.0) * exp(x / 10.0) + 5 * exp(-x / 2.0)).real def c(arr): return sum([f(i) for i in arr]) #x = [i for i in np.arange(-10, 10, 1)] #y = [f(i) for i in np.arange(-10, 10, 1)] # plt.plot(x, y) # plt.show() print(optimize.differential_evolution(f, [(1,30)])) # result = optimize.minimize(f, 2) # print(result)
def __tune__(self): bounds = [self.reservoirConnectivityBound] result = optimize.differential_evolution(self.__ESNTrain__, bounds=bounds) print("\nThe optimal parameters for classic ESN:" + str(result.x)) return result.x[0]