def values(self):
sample_values = []
for task in self.tasks:
pt = self.mean().point(task)
s = Sample(pt, self.prob)
v = s.evaluate(task)
sample_values += [v]
return sample_values
def solve(self):
dim = self.prob.dim
num_samples = 5000
fp = open('sample_data_weier_v2.csv', 'w+')
for i in range(num_samples):
pt = (np.random.rand(dim) - 0.5) * 2.0
s = Sample(pt, self.prob)
values = [s.evaluate(t) for t in self.tasks]
print('sample %d at %s' % (i, pt))
row = ", ".join([str(x) for x in [i] + list(pt) + list(values)])
fp.write(row + "\n")
fp.close()
def evaluate(self, _x):
self.eval_counter += 1
# Scale up the second part, to cover all the possible range
if self.mean_type == 'linear':
x = np.zeros(self.prob.dim * 2)
for i in range(self.prob.dim):
x[i] = _x[i]
for i in range(self.prob.dim, 2 * self.prob.dim):
x[i] = _x[i] - _x[i - self.prob.dim]
else:
x = np.array(_x)
self.mean().set_params(x)
sample_values = []
for task in self.tasks:
pt = self.mean().point(task)
s = Sample(pt, self.prob)
v = s.evaluate(task)
sample_values += [v]
avg_error = np.mean(sample_values)
if np.isnan(avg_error):
avg_error = 9999.9
print x, ' value: {', avg_error, '}'
self.iter_values += [sample_values] # Values for the entire iterations
self.iter_params += [x]
# If one iteration is ended
if self.eval_counter % 16 == 0:
self.iter_counter += 1
# print 'CMA Iteration', self.iter_counter, self.prob.eval_counter
# for v in self.iter_values:
# print sum(v), v
# print 'best:', self.values()
sum_values = [sum(vs) for vs in self.iter_values]
print('sum_values = %s' % sum_values)
best_index = np.nanargmin(sum_values)
print('best_index = %d' % best_index)
best_params = self.iter_params[best_index]
print('best params = %s' % best_params)
self.mean().set_params(best_params)
[o.notify_step(self, self.model) for o in self.observers]
self.iter_values = []
self.iter_params = []
return avg_error
def solve(self):
[o.notify_init(self, self.model) for o in self.observers]
sample_values = []
for task in self.tasks:
pt = self.mean().point(task)
s = Sample(pt, self.prob)
v = s.evaluate(task)
sample_values += [v]
self.iter_values += [sample_values]
self.iter_params += [self.mean().params()]
[o.notify_step(self, self.model) for o in self.observers]
res = {'result': 'NG'}
# opt = {'verb_time': 0, 'popsize': 16, 'tolfun': 1.0}
cma.CMAOptions('tol')
opts = cma.CMAOptions()
opts.set('verb_disp', 1)
# opts.set('tolfun', 0.001)
# opts.set('tolx', 0.0000001)
# opts.set('tolx', 1.0)
opts.set('ftarget', 0.001)
num_offsprings = 16
opts.set('popsize', num_offsprings)
max_iter = int(20000 / self.n / num_offsprings)
print('maxiter: %d' % max_iter)
opts.set('maxiter', max_iter)
for key, value in opts.iteritems():
print '[', key, ']\n', value
x0 = np.random.rand(self.mean().paramdim) - 0.5
# print cma.CMAOptions()
# exit(0)
print()
print('------- CMA-ES --------')
res = cma.fmin(self.evaluate, x0, 1.0, opts)
print('-----------------------')
print()
# np.set_printoptions(precision=6, suppress=True)
print('the answer: %s' % res[0])
[o.notify_solve(self, self.model) for o in self.observers]
return res
def evaluate(self, x):
self.eval_counter += 1
s = Sample(x, self.prob)
v = s.evaluate(self.current_task)
print('%.6f <--- %s' % (v, x))
return v
# Case 1. If we use individual approach..
mean = model.mean.Interpolation(NUM_TASKS)
# # Case 2. If we use our algorithm..
# import json
# with open('result_parameterized_04.json') as fp:
# data = json.load(fp)
# my_params = eval('np.' + data['mean_params'])
# tasks = np.linspace(0.0, 1.0, 6)
# my_model = model.Model(prob.dim, tasks, 'linear')
# my_model.mean.set_params(my_params)
# mean = my_model.mean
# resume all the cases..
print('mean = %s' % mean)
test_tasks = np.linspace(0.0, 1.0, NUM_TEST_TASKS)
values = []
for w in test_tasks:
pt = mean.point(w)
s = Sample(pt, prob)
v = s.evaluate(w)
if v > 10.0:
v = v / 10 + 1.0
print('%.4f, pt = %s , value = %.6f' % (w, repr(pt), v))
values += [v]
print('average: %.8f' % np.mean(values))
print('max: %.8f' % np.max(values))
print('values: %s' % values)
