def __call__(self, vars, tag=None):
wd, state = self.create_workdir(
pj(env.runs_dir, "cma_es" if tag is None else tag))
if state is None:
state = State(self.seed)
state.dump(wd)
#start_vals = get_vars(
# const = read_json(GlobalConfig.ConstFilename)
# , var_specs = read_json(GlobalConfig.VarSpecsFile)
# , vars = vars
# , min = self.min_bound
# , max = self.max_bound
#)
rng = np.random.RandomState(state.seed)
start_vals = self.min_bound + self.max_bound * rng.random_sample(
len(vars))
es = cma.CMAEvolutionStrategy(
start_vals, self.sigma, {
'bounds': [self.min_bound, self.max_bound],
'popsize': self.popsize,
'seed': state.seed
})
for X, tells in state.vals:
X = es.ask()
es.tell(X, tells)
id = sum([len(v[1]) for v in state.vals])
while not es.stop():
X = es.ask()
asks, tells, pool = [], [], []
tells, pool = [], []
for Xi in X:
p = runner(Xi,
vars,
wd,
wait=False,
id=id,
min=self.min_bound,
max=self.max_bound)
pool.append((id, p))
id += 1
if len(pool) >= GlobalConfig.Jobs:
Algo.wait_pool(pool, tells)
state, asks, tells, pool = Algo.dump_state(
wd, state, asks, tells, pool)
while len(pool) > 0:
self.wait_pool(pool, tells)
state, asks, tells, pool = Algo.dump_state(wd, state, asks, tells,
pool)
tells = [out for _, out in sorted(tells, key=lambda x: x[0])]
es.tell(X, tells)
es.disp()
def __call__(self, vars, tag=None):
wd, state = self.create_workdir(
pj(env.runs_dir, "mc" if tag is None else tag))
if state is None:
state = State(self.seed)
state.dump(wd)
rng = np.random.RandomState(state.seed)
asks, tells, pool = [], [], []
run_ids = range(sum([len(v[1]) for v in state.vals]), self.number)
dim_size = len(vars)
X = np.zeros((len(run_ids), dim_size))
for dim_idx in xrange(dim_size):
X[:, dim_idx] = self.min_bound + self.max_bound * lhs_sample(
len(run_ids), rng)
for x_id, run_id in enumerate(run_ids):
x = X[x_id, :]
pool.append((run_id,
runner(x,
vars,
wd,
wait=False,
id=run_id,
min=self.min_bound,
max=self.max_bound)))
asks.append((run_id, x))
if len(pool) >= GlobalConfig.Jobs:
Algo.wait_pool(pool, tells)
state, asks, tells, pool = Algo.dump_state(
wd, state, asks, tells, pool)
while len(pool) > 0:
Algo.wait_pool(pool, tells)
state, asks, tells, pool = Algo.dump_state(wd, state, asks, tells,
pool)
def __call__(self, vars, tag=None):
wd, state = self.create_workdir(
pj(env.runs_dir, "grid_search" if tag is None else tag))
if state is None:
state = State(0) # doesn't matter
state.dump(wd)
if self.freeze_point:
self.freeze_point = [
float(p) for p in self.freeze_point.split(" ") if p.strip()
]
if self.non_freeze_vars is None:
raise Exception(
"Got freeze point but freeze variables are not defined")
if self.non_freeze_vars:
self.non_freeze_vars = [
v.strip() for v in self.non_freeze_vars.split(" ")
if v.strip()
]
else:
self.non_freeze_vars = vars
dim_of_problem = len(self.non_freeze_vars)
number_of_dim_slice = (self.max_bound - self.min_bound) / self.step
axis_slices = [
np.linspace(self.min_bound,
self.max_bound,
num=number_of_dim_slice)
for _ in xrange(dim_of_problem)
]
if len(axis_slices) == 1:
points = axis_slices[0].reshape(1, -1).T
else:
points = np.vstack(np.meshgrid(*axis_slices)).reshape(
dim_of_problem, -1).T
number_of_steps = len(points)
if number_of_steps > GlobalConfig.NumberOfCalcutationsUpperBound:
raise Exception(
"There are a lot of calculations ({}). Reconsider your setup".
format(number_of_steps))
nsteps_done = sum([len(v[1]) for v in state.vals])
points = points[nsteps_done:]
asks, tells, pool = [], [], []
for id, point in enumerate(points):
if self.freeze_point:
x = list(self.freeze_point)
for vi, v in enumerate(self.non_freeze_vars):
try:
var_idx = vars.index(v)
except ValueError:
raise Exception(
"Can't find non freeze var {} in specification".
format(v))
x[var_idx] = point[vi]
else:
x = point
pool.append((id,
runner(x,
vars,
wd,
wait=False,
id=id,
min=self.min_bound,
max=self.max_bound)))
asks.append((id, x))
if len(pool) >= GlobalConfig.Jobs:
Algo.wait_pool(pool, tells)
state, asks, tells, pool = Algo.dump_state(
wd, state, asks, tells, pool)
while len(pool) > 0:
Algo.wait_pool(pool, tells)
state, asks, tells, pool = Algo.dump_state(wd, state, asks, tells,
pool)
