def solve(self): """ Wrapper function for scipy.optimize.differential_evolution """ progress = [] def cb(xk, convergence): progress.append(self.fun(xk)) # initialize number of points = popsize space = Space([(0.,1.)]*len(self.bounds)) lhs = Lhs() pop = np.asarray(lhs.generate(space.dimensions, self.popsize)) min_b, max_b = np.asarray(self.bounds).T diff = max_b - min_b pop = min_b + pop * diff progress.append(np.min(np.apply_along_axis(self.fun, 1, pop))) result = scipy_de(self.fun, self.bounds, popsize=1, maxiter = self.maxiter, tol=0.0001, disp=self.disp, callback=cb, init=pop) self.x = result.x self.fx = result.fun f_calls = (np.arange(1,len(progress)+1)) * self.popsize self.converge_data = np.vstack((f_calls, np.asarray(progress))) self.solved = True
def lhs_sample(n_samples): """ Takes random n_samples with the lhs method. Returns array x and y. """ x = np.array([]) y = np.array([]) # Makes the space of points which van be chosen from space = Space([(-2., 1.), (-1.5, 1.5)]) # Chooses which kind oh lhs will be used lhs = Lhs(lhs_type="classic", criterion=None) coordinates = 0 # Generates n_samples withhi the chosen space coordinates = lhs.generate(space.dimensions, n_samples) # appends all x and y values to array for coordinate in coordinates: a = coordinate[0] x = np.append(x, a) b = coordinate[1] y = np.append(y, b) return x, y
def main(): args = getArgumentParser().parse_args() space = [ skopt.space.Real(args.mzp_min, args.mzp_max, name='mzp', prior='uniform'), skopt.space.Real(args.mdh_min, args.mdh_max, name='mdh', prior='uniform'), skopt.space.Real(args.mdm_min, args.mdm_max, name='mdm', prior='uniform'), skopt.space.Real(args.gx_min, args.gx_max, name='g', prior='log-uniform') ] # sample data lhs = Lhs(lhs_type="centered", criterion=None) x = np.array(lhs.generate(space, args.n_samples, random_state=42)) # set up dataframe for writing to file df = pd.DataFrame(data=x, columns=["mzp", "mdh", "mdm", "g"]) df.index.rename('dsid', inplace=True) df.index = np.arange(args.dsid_start, args.dsid_start + len(df)) # write data to file df.to_csv('./grid_hypercube.csv', header=False)
def create_sampler(self): """ Create the sampler Returns ------- """ if self.method == "lhs": self.lhs = Lhs(lhs_type=self.lhs_type, criterion=self.criterion, iterations=self.iterations) else: raise Exception("The specified sampling method ", self.method, "is not supported.")
def __init__(self, bounds, method='latin'): self.dimensions = len(bounds) self.position = np.empty(self.dimensions) self.velocity = np.zeros(self.dimensions) self.pbest_position = np.empty(self.dimensions) self.pbest_value = None self.lowerbounds, self.upperbounds = np.asarray(bounds).T # initialize positions if method == 'random': position = np.random.rand(self.dimensions) elif method == 'latin': space = Space([(0.,1.)]*self.dimensions) lhs = Lhs() position = np.asarray(lhs.generate(space.dimensions,1))[0] min_b, max_b = np.asarray(bounds).T diff = max_b - min_b self.position = min_b + position * diff
def draw_latin_hypercube_samples(self, num_samples: int) -> list: """ Draws an LHS-distributed sample from the search space """ if self.searchspace_size < num_samples: raise ValueError("Can't sample more than the size of the search space") if self.sampling_crit is None: lhs = Lhs(lhs_type="centered", criterion=None) else: lhs = Lhs(lhs_type="classic", criterion=self.sampling_crit, iterations=self.sampling_iter) param_configs = lhs.generate(self.dimensions(), num_samples) indices = list() normalized_param_configs = list() for i in range(len(param_configs) - 1): try: param_config = self.normalize_param_config(param_configs[i]) index = self.find_param_config_index(param_config) indices.append(index) normalized_param_configs.append(param_config) except ValueError: """ Due to search space restrictions, the search space may not be an exact cartesian product of the tunable parameter values. It is thus possible for LHS to generate a parameter combination that is not in the actual searchspace, which must be skipped. """ continue return list(zip(normalized_param_configs, indices))
def test_lhs_random_state(criterion): n_dim = 2 n_samples = 20 lhs = Lhs() h = lhs._lhs_normalized(n_dim, n_samples, 0) h2 = lhs._lhs_normalized(n_dim, n_samples, 0) assert_array_equal(h, h2) lhs = Lhs(criterion=criterion, iterations=100) h = lhs.generate([ (0., 1.), ] * n_dim, n_samples, random_state=0) h2 = lhs.generate([ (0., 1.), ] * n_dim, n_samples, random_state=0) assert_array_equal(h, h2)
def cook_initial_point_generator(generator, **kwargs): """Cook a default initial point generator. For the special generator called "random" the return value is None. Parameters ---------- generator : "lhs", "sobol", "halton", "hammersly", "grid", "random" \ or InitialPointGenerator instance" Should inherit from `skopt.sampler.InitialPointGenerator`. kwargs : dict Extra parameters provided to the generator at init time. """ if generator is None: generator = "random" elif isinstance(generator, str): generator = generator.lower() if generator not in [ "sobol", "halton", "hammersly", "lhs", "random", "grid", "maxpro", "maxpro-gd" ]: raise ValueError("Valid strings for the generator parameter " " are: 'sobol', 'lhs', 'halton', 'hammersly'," "'random', 'maxpro','maxpro-gd', or 'grid' not " "%s." % generator) elif not isinstance(generator, InitialPointGenerator): raise ValueError("generator has to be an InitialPointGenerator." "Got %s" % (str(type(generator)))) if isinstance(generator, str): if generator == "sobol": generator = Sobol() elif generator == "halton": generator = Halton() elif generator == "hammersly": generator = Hammersly() elif generator == "lhs": generator = Lhs() elif generator == "grid": generator = Grid() elif generator == "random": return None elif generator == "maxpro": generator = MaxPro(use_gradient=False) elif generator == "maxpro-gd": generator = MaxPro(use_gradient=True) generator.set_params(**kwargs) return generator
def test_lhs_pdist(): n_dim = 2 n_samples = 20 lhs = Lhs() h = lhs._lhs_normalized(n_dim, n_samples, 0) d_classic = spatial.distance.pdist(np.array(h), 'euclidean') lhs = Lhs(criterion="maximin", iterations=100) h = lhs.generate([ (0., 1.), ] * n_dim, n_samples, random_state=0) d = spatial.distance.pdist(np.array(h), 'euclidean') assert np.min(d) > np.min(d_classic)
def test_lhs_criterion(lhs_type, criterion): lhs = Lhs(lhs_type=lhs_type, criterion=criterion, iterations=100) samples = lhs.generate([ (0., 1.), ] * 2, 200) assert len(samples) == 200 assert len(samples[0]) == 2 samples = lhs.generate([("a", "b", "c")], 3) assert samples[0][0] in ["a", "b", "c"] samples = lhs.generate([("a", "b", "c"), (0, 1)], 1) assert samples[0][0] in ["a", "b", "c"] assert samples[0][1] in [0, 1] samples = lhs.generate([("a", "b", "c"), (0, 1)], 3) assert samples[0][0] in ["a", "b", "c"] assert samples[0][1] in [0, 1]
from skopt.sampler import Lhs space = Space([ (0.0395, 0.0790, 0.1185, 0.0000), (0, 1e-2, 1e-4, 1e-8), (0.08750, 0.13125, 0.17500, 0.21875, 0.26250, 0.00000) ]) n_samples = 100 rand = space.rvs(NSAMP) len(rand) lhs = Lhs(lhs_type="centered", criterion=None) lhs.generate(space.dimensions, n_samples) # if monet.isNotebook(): # (USR, LND) = ('dsk', 'PAN') # else: # (USR, LND) = (sys.argv[1], sys.argv[2]) # EXPS = aux.getExps(LND) # (PT_ROT, _, _, _, _, _) = aux.selectPath(USR, EXPS[0], LND) # expsToPlot = aux.EXPS_TO_PLOT ############################################################################### # Generate keycards ############################################################################### # kCats = [i[0] for i in aux.DATA_HEAD] # scalers = [aux.DATA_SCA[i] for i in kCats] # splitExps = [i.split('_')[1:] for i in expsToPlot]
############################################################################# # Sobol' # ------ sobol = Sobol() x = sobol.generate(space.dimensions, n_samples) plot_searchspace(x, "Sobol'") pdist_data.append(pdist(x).flatten()) x_label.append("sobol'") ############################################################################# # Classic Latin hypercube sampling # -------------------------------- lhs = Lhs(lhs_type="classic", criterion=None) x = lhs.generate(space.dimensions, n_samples) plot_searchspace(x, 'classic LHS') pdist_data.append(pdist(x).flatten()) x_label.append("lhs") ############################################################################# # Centered Latin hypercube sampling # --------------------------------- lhs = Lhs(lhs_type="centered", criterion=None) x = lhs.generate(space.dimensions, n_samples) plot_searchspace(x, 'centered LHS') pdist_data.append(pdist(x).flatten()) x_label.append("center")
new_file.close() print('Wrote file to ',fname) omega_m_limits = [0.2,0.4] h_limits = [0.6,0.8] sigma_8_limits = [0.7,0.8] f_esc_limits = [0.01,1.] C_ion_limits = [0.,1.] D_ion_limits = [0.,2.] limits = np.array([omega_m_limits,h_limits,sigma_8_limits,f_esc_limits,C_ion_limits,D_ion_limits]) lhs = Lhs(lhs_type="classic", criterion=None) np.random.seed(123456789) omega_m, h, sigma_8, f_esc, C_ion, D_ion = np.array(lhs.generate(limits, n_samples= 1000)).T file = open("simfast21.ini") ini_file = file.readlines() file.close() for i in range(len(omega_m)): dirname = 'runs/run'+str(i) os.system('mkdir '+dirname) fname = dirname+'/simfast21.ini'
class Sampler_SkoptSampler(Sampler): """ Sampler using skopt.sampler class Attributes ---------- """ def __init__(self, samplerDict): """Sampler_SkoptSampler class constructor Parameters ---------- """ Sampler.__init__(self, samplerDict) # type self.type = "SkoptSampler" # method: LHS, Sobol, Halton, and Hammersly self.method = None # dictionary for the options of the particular method self.options = {} # load sampler configuration from dictionary self.load_from_sampler_dict() # create the sampler self.lhs = None self.create_sampler() def load_from_sampler_dict(self): """ Load configuration of the sampler from the dictionary Returns ------- """ #get the method: e.g., lhs self.method = self.samplerDict['method'] #load options self.lhs_type = "classic" if "lhs_type" in self.samplerDict: self.lhs_type = self.samplerDict["lhs_type"] self.criterion = "maximin" if "criterion" in self.samplerDict: self.criterion = self.samplerDict["criterion"] self.iterations = 1000 if "iterations" in self.samplerDict: self.iterations = self.samplerDict["iterations"] def create_sampler(self): """ Create the sampler Returns ------- """ if self.method == "lhs": self.lhs = Lhs(lhs_type=self.lhs_type, criterion=self.criterion, iterations=self.iterations) else: raise Exception("The specified sampling method ", self.method, "is not supported.") def generate(self, space, n_samples): """ Generate and return samples Parameters ---------- space: Space object n_samples: int number of samples to draw Returns ------- array[n_samples, n_parameters] """ return self.lhs.generate(space.dimensions, n_samples)
import sys import numpy as np import matplotlib.pyplot as plt from skopt.space import Space from skopt.sampler import Lhs import cantera as ct gas = ct.Solution('../mech/JP10skeletal.cti') lhs = Lhs(lhs_type="classic", criterion=None) space = Space([(1100., 1500.), (1., 10.), ('0', '1')]) nsamples = 30 x = lhs.generate(space.dimensions, nsamples) comp = ['C10H16:0.01,n2:0.99', 'C10H16:0.02,n2:0.99'] for i in range(nsamples): gas.TPX = x[i][0], x[i][1] * ct.one_atm, comp[np.int16(x[i][2])] r = ct.IdealGasConstPressureReactor(gas) sim = ct.ReactorNet([r]) time = 0.0 states = ct.SolutionArray(gas, extra=['t']) print('%10s %10s %10s %14s' % ('t [s]', 'T [K]', 'P [Pa]', 'u [J/kg]')) for n in range(50): states.append(r.thermo.state, t=time) time += 1.e-4
def test_opt(env): """Wrapper for calling the optimizer.""" # First day of historical data first_day = env.init_date run_params = env.bucky_params.opt_params if run_params.rolling: first_day -= datetime.timedelta(days=6) # Environment admin2 and admin1 values env_adm2 = xp.to_cpu(env.g_data.adm2_id) env_adm1 = xp.to_cpu(env.g_data.adm1_id) # Get historical case and death data hist = case_death_df(first_day, env_adm2) # Make sure environment end date is same as amount of available historical data days_of_hist_data = ( hist.index.get_level_values(-1).max() - datetime.datetime( env.init_date.year, env.init_date.month, env.init_date.day)).days if days_of_hist_data != env.base_mc_instance.t_max: env.base_mc_instance.set_tmax(days_of_hist_data) # Get environment admin2 mask good_fips = hist.index.get_level_values("adm2").unique() fips_mask = xp.array(np.isin(env_adm2, good_fips)) # Extract case and death data from data frame hist_daily_cases = xp.array( hist.cumulative_reported_cases.unstack().to_numpy()) hist_daily_deaths = xp.array(hist.cumulative_deaths.unstack().to_numpy()) # Sum case and death data to state hist_daily_cases = env.g_data.sum_adm1(hist_daily_cases, mask=fips_mask) hist_daily_deaths = env.g_data.sum_adm1(hist_daily_deaths, mask=fips_mask) # Hosp data hist = hosp_df(first_day, env_adm1) # Move hosp data to xp array where 0-index is admin1 id hist_daily_h_df = hist.previous_day_admission_adult_covid_confirmed.unstack( ) hist_daily_h = xp.zeros( (hist_daily_h_df.index.max() + 1, len(hist_daily_h_df.columns))) hist_daily_h[hist_daily_h_df.index.to_numpy()] = hist_daily_h_df.to_numpy() # Collect case, death, hosp data hist_vals = [hist_daily_cases, hist_daily_deaths, hist_daily_h] # Get rid of negatives hist_vals = [xp.clip(vals, a_min=0.0, a_max=None) for vals in hist_vals] # Rolling mean if run_params.rolling: from ..util.rolling_mean import rolling_mean hist_vals = [rolling_mean(vals, axis=1) for vals in hist_vals] # Spline if run_params.spline: from ..util.spline_smooth import fit hist_vals = [fit(vals, df=run_params.dof) for vals in hist_vals] # Get rid of negatives hist_vals = [xp.clip(vals, a_min=0.0, a_max=None) for vals in hist_vals] from functools import partial from scipy.optimize import minimize from skopt import gp_minimize from skopt.sampler import Lhs from skopt.space import Real # Opt function params opt_params, keys = extract_values(env.bucky_params.base_params, env.bucky_params.opt_params.to_opt) # Opt function args args = (env, hist_vals, fips_mask, keys) # Global search initialization lhs = Lhs(criterion="maximin", iterations=10000) # Best objective value best_opt = np.inf best_params = opt_params # 2 Global searches for (lower, upper) in run_params.global_multipliers: dims = [Real(lower * p, upper * p) for p in best_params] res = gp_minimize( partial(opt_func, args=args), dimensions=dims, x0=best_params.tolist(), initial_point_generator=lhs, # callback=[checkpoint_saver], n_calls=run_params.global_calls, verbose=True, ) if res.fun < best_opt: best_opt = res.fun best_params = np.array(res.x) # Local search result = minimize( opt_func, best_params, (args, ), options={ "disp": True, "adaptive": True, "maxfev": run_params.local_calls }, # local_calls method="Nelder-Mead", ) if result.fun < best_opt: best_opt = result.fun best_params = np.array(result.x) print("Best Opt:", best_opt) print("Best Params:", best_params) with open(BEST_OPT_FILE, "w") as f: best_params = [p.item() for p in best_params] new_params = rebuild_params(best_params, keys) yaml.safe_dump(new_params, f) with open(VALUES_FILE, "a") as f: f.write("{},{}\n".format(run_params.ID, best_opt))
def _generate(self): lhs = Lhs(criterion=self.criterion, iterations=self.iterations) X = lhs.generate(self.search_dims, self.size, random_state=self.rng) return X
def solve(self): """ Solves the optimization problem through simulated annealing algorithm """ # provide an initial state and temperature time = 0 current_temp = self.initial_temp space = Space([(0.,1.)]*len(self.bounds)) lhs = Lhs() current_state = np.asarray(lhs.generate(space.dimensions, self.popsize)) min_b, max_b = np.asarray(self.bounds).T diff = max_b - min_b current_state = min_b + current_state * diff # evaluate current state energy = np.apply_along_axis(self.fun, 1, current_state) best_energy = np.min(energy) best_state = current_state[np.argmin(energy)] evals = self.popsize # variables for storing progress data progress = [] for i in range(self.maxiter): for j in range(len(current_state)): # generate a new state, randomly chosen neighbour of state if self.get_neighbor == 'cauchy': neighbor = SimulatedAnnealing.get_neighbor_cauchy(current_state[j], diff, min_b, max_b, current_temp, self.qv) else: neighbor = SimulatedAnnealing.get_neighbor_normal(current_state[j], diff, self.initial_temp, current_temp) # evaluate new neighbor energy_neighbor = self.fun(neighbor) delta = energy_neighbor - energy[j] evals += 1 if delta < 0: current_state[j] = neighbor energy[j] = energy_neighbor if energy[j] < best_energy: best_energy = energy[j] best_state = current_state[j] else: if np.random.rand() < np.exp(-delta/current_temp): current_state[j] = neighbor energy[j] = energy_neighbor progress.append(best_energy) time += 1 current_temp = self.temp_func(self.initial_temp, current_temp, time, self.qv) if self.disp: print(f"simulated annealing step {i}: f(x)= {best_energy}") if evals > self.max_eval: break f_calls = np.arange(1, i+2) * self.popsize self.converge_data = np.vstack((f_calls, np.asarray(progress))) self.solved = True self.x = best_state self.fx = best_energy
inv_G_ls = [0.35938137 * T] #[2.58*10**(-3)*T] repeat = 1 for G, inv_G in enumerate(inv_G_ls): y = lambda site_w: OpenQT(s, d, np.array(site_w[:(s - 2) * d]), np.array(site_w[(s - 2) * d:]), Gamma=1 / inv_G, n_p=3).T_r(epabs=0.001)[0] # object function note = "inv_Gamma = {0}T".format(inv_G / T) print(note) filename = '{0}s_{1}d_job_{2}_{3}invG_kappa_0.01.csv'.format( s, d, job, inv_G / T) for itr in range(repeat): lhs = Lhs(lhs_type="classic", criterion=None) X_init = lhs.generate(bound, num_init) print(X_init) Y_init = np.array([y(X_i) for X_i in X_init]) print(Y_init) # Run BO r = gp_minimize( y, # negative for maximize; positive for minimize bound, base_estimator=gpr, acq_func='LCB', # expected improvement kappa=0.01, # xi=0.01, # exploitation-exploration trade-off # acq_optimizer="sampling", # for the periodic kernel n_calls=num_itr, # number of iterations (s-2)*d*100
def test_lhs_centered(): lhs = Lhs(lhs_type="centered") samples = lhs.generate([ (0., 1.), ] * 3, 3) assert_almost_equal(np.sum(samples), 4.5)