def test_eval(self):
dim = 100
obj = Objective(func=ackley,
dim=Dimension(dim, [[-1, 1]] * dim, [True] * dim))
sol = Solution(x=[0.2] * dim)
res = obj.eval(sol)
assert abs(res) <= 1e-7
def search(_dataset):
'''
Search the best hyper-paramers for the given dataset Using ZOOpt
:param _dataset: the given dataset
:return: (best hyper-parameters，performance of the best hyper-parameters)
'''
global dataset
dataset = _dataset
dim = Dimension(
19, [[16, 32], [1, 8], [1, 1], [1, 1], [16, 32], [1, 8],
[1, 1], [1, 1], [0, 1], [1, 8], [1, 10], [0, 1], [1, 8], [1, 10],
[40, 50], [30, 40], [20, 30], [10, 20], [0.0001, 0.001]],
[
False, False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False, False, True
])
obj = Objective(eval, dim)
# perform optimization
global round
round = 0
solution = Opt.min(obj, Parameter(budget=BUDGET))
# print result
solution.print_solution()
plt.plot(obj.get_history_bestsofar())
plt.savefig('figure.png')
return (solution.get_x(), solution.get_value())
def test_history_best_so_far(self):
input_data = [0.5, 0.6, 0.4, 0.7, 0.3, 0.2]
output_data = [0.5, 0.5, 0.4, 0.4, 0.3, 0.2]
obj = Objective()
obj.set_history(input_data)
best_history = obj.get_history_bestsofar()
assert best_history == output_data
def minimize_sphere_sre():
"""
Example of minimizing high-dimensional sphere function with sequential random embedding.
:return: no return value
"""
dim_size = 10000 # dimensions
dim_regs = [[-1, 1]] * dim_size # dimension range
dim_tys = [True] * dim_size # dimension type : real
dim = Dimension(dim_size, dim_regs,
dim_tys) # form up the dimension object
objective = Objective(sphere_sre, dim) # form up the objective function
# setup algorithm parameters
budget = 2000 # number of calls to the objective function
parameter = Parameter(budget=budget,
high_dim_handling=True,
reducedim=True,
num_sre=5,
low_dimension=Dimension(10, [[-1, 1]] * 10,
[True] * 10))
solution_list = ExpOpt.min(objective,
parameter,
repeat=1,
plot=True,
plot_file="img/minimize_sphere_sre.png")
def minimize_ackley_continuous_noisy():
"""
SSRacos example of minimizing ackley function under Gaussian noise
:return: no return value
"""
ackley_noise_func = ackley_noise_creator(0, 0.1)
dim_size = 100 # dimensions
dim_regs = [[-1, 1]] * dim_size # dimension range
dim_tys = [True] * dim_size # dimension type : real
dim = Dimension(dim_size, dim_regs,
dim_tys) # form up the dimension object
objective = Objective(ackley_noise_func,
dim) # form up the objective function
budget = 200000 # 20*dim_size # number of calls to the objective function
# suppression=True means optimize with value suppression, which is a noise handling method
# resampling=True means optimize with re-sampling, which is another common used noise handling method
# non_update_allowed=500 and resample_times=100 means if the best solution doesn't change for 500 budgets,
# the best solution will be evaluated repeatedly for 100 times
# balance_rate is a parameter for exponential weight average of several evaluations of one sample.
parameter = Parameter(budget=budget,
noise_handling=True,
suppression=True,
non_update_allowed=500,
resample_times=100,
balance_rate=0.5)
# parameter = Parameter(budget=budget, noise_handling=True, resampling=True, resample_times=10)
parameter.set_positive_size(5)
ExpOpt.min(objective,
parameter,
repeat=2,
plot=True,
plot_file="img/ackley_continuous_noisy_figure.png")
def run_test(task_name, layers, in_budget, max_step, repeat):
gym_task = GymTask(task_name) # choose a task by name
gym_task.new_nnmodel(layers) # construct a neural network
gym_task.set_max_step(max_step) # set max step in gym
budget = in_budget # number of calls to the objective function
rand_probability = 0.95 # the probability of sample in model
# set dimension
dim_size = gym_task.get_w_size()
dim_regs = [[-10, 10]] * dim_size
dim_tys = [True] * dim_size
dim = Dimension(dim_size, dim_regs, dim_tys)
objective = Objective(gym_task.sum_reward,
dim) # form up the objective function
parameter = Parameter(
budget=budget,
autoset=True) # by default, the algorithm is sequential RACOS
parameter.set_probability(rand_probability)
result = []
sum = 0
print('solved solution is:')
for i in range(repeat):
ins = Opt.min(objective, parameter)
result.append(ins.get_value())
sum += ins.get_value()
ins.print_solution()
print(result) # results in repeat times
print(sum / len(result)) # average result
def minimize_sphere_mixed():
"""
Mixed optimization example of minimizing sphere function, which has mixed search search space.
:return: no return value
"""
# setup optimization problem
dim_size = 100
dim_regs = []
dim_tys = []
# In this example, the search space is discrete if this dimension index is odd, Otherwise, the search space
# is continuous.
for i in range(dim_size):
if i % 2 == 0:
dim_regs.append([0, 1])
dim_tys.append(True)
else:
dim_regs.append([0, 100])
dim_tys.append(False)
dim = Dimension(dim_size, dim_regs, dim_tys)
objective = Objective(sphere_mixed, dim) # form up the objective function
budget = 100 * dim_size # number of calls to the objective function
parameter = Parameter(budget=budget)
solution_list = ExpOpt.min(objective,
parameter,
repeat=1,
plot=True,
plot_file="img/sphere_mixed_figure.png")
def test_performance(self):
ackley_noise_func = ackley_noise_creator(0, 0.1)
dim_size = 100 # dimensions
one_dim = (ValueType.CONTINUOUS, [-1, 1], 1e-6)
dim_list = [(one_dim)] * dim_size
dim = Dimension2(dim_list) # form up the dimension object
objective = Objective(ackley_noise_func,
dim) # form up the objective function
budget = 20000 # 20*dim_size # number of calls to the objective function
# suppression=True means optimize with value suppression, which is a noise handling method
# resampling=True means optimize with re-sampling, which is another common used noise handling method
# non_update_allowed=500 and resample_times=100 means if the best solution doesn't change for 500 budgets,
# the best solution will be evaluated repeatedly for 100 times
# balance_rate is a parameter for exponential weight average of several evaluations of one sample.
parameter = Parameter(budget=budget,
noise_handling=True,
suppression=True,
non_update_allowed=200,
resample_times=50,
balance_rate=0.5)
# parameter = Parameter(budget=budget, noise_handling=True, resampling=True, resample_times=10)
parameter.set_positive_size(5)
sol = Opt.min(objective, parameter)
assert sol.get_value() < 4
def run_test(task_name, layers, in_budget, max_step, repeat):
gym_task = GymTask(task_name) # choose a task by name
gym_task.new_nnmodel(layers) # construct a neural network
gym_task.set_max_step(max_step) # set max step in gym
budget = in_budget # number of calls to the objective function
rand_probability = 0.95 # the probability of sample in model
# set dimension
dim_size = gym_task.get_w_size()
dim_regs = [[-10, 10]] * dim_size
dim_tys = [True] * dim_size
dim = Dimension(dim_size, dim_regs, dim_tys)
result = []
sum = 0
print('solved solution is:')
for i in range(repeat):
objective = Objective(gym_task.sum_reward, dim) # form up the objective function
parameter = Parameter(budget=budget, autoset=True) # by default, the algorithm is sequential RACOS
parameter.set_probability(rand_probability)
ins = Opt.min(objective, parameter)
result.append(ins.get_value())
best_stable_ins = objective.get_best_stable_ins()
if best_stable_ins != None:
best_stable_ins_val = best_stable_ins.get_value()
else:
best_stable_ins_val = float("inf")
for i in range(1):
ins_rewards = []
for i in range(100):
ins_rewards.append(gym_task.sum_reward(ins))
# print(np.mean(ins_rewards),best_stable_ins_val)
if np.mean(ins_rewards) < best_stable_ins_val:
print("last mean", np.mean(ins_rewards))
print("last std", np.std(ins_rewards))
else:
print("stable mean", best_stable_ins.get_value())
print("stable std", best_stable_ins.get_std())
sum += ins.get_value()
#ins.print_solution()
print(result) # results in repeat times
print(sum/len(result)) # average result
def test_sracos_performance(self):
dim = 100 # dimension
objective = Objective(ackley,
Dimension(dim, [[-1, 1]] * dim,
[True] * dim)) # setup objective
parameter = Parameter(budget=100 * dim)
solution = Opt.min(objective, parameter)
assert solution.get_value() < 0.2
def test_asracos_performance(self):
# continuous
dim = 100 # dimension
objective = Objective(ackley,
Dimension(dim, [[-1, 1]] * dim,
[True] * dim)) # setup objective
parameter = Parameter(budget=100 * dim,
parallel=True,
server_num=2,
seed=2)
# parameter = Parameter(budget=100 * dim, init_samples=[Solution([0] * 100)]) # init with init_samples
solution_list = ExpOpt.min(objective, parameter, repeat=1)
for solution in solution_list:
value = solution.get_value()
assert value < 0.2
# discrete
# setcover
problem = SetCover()
dim = problem.dim # the dim is prepared by the class
objective = Objective(problem.fx,
dim) # form up the objective function
budget = 100 * dim.get_size(
) # number of calls to the objective function
parameter = Parameter(budget=budget,
parallel=True,
server_num=2,
seed=777)
sol = ExpOpt.min(objective, parameter, repeat=1)[0]
assert sol.get_value() < 2
# sphere
dim_size = 100 # dimensions
dim_regs = [[-10, 10]] * dim_size # dimension range
dim_tys = [False] * dim_size # dimension type : integer
dim_order = [True] * dim_size
dim = Dimension(dim_size, dim_regs, dim_tys,
order=dim_order) # form up the dimension object
objective = Objective(sphere_discrete_order,
dim) # form up the objective function
parameter = Parameter(budget=10000,
parallel=True,
server_num=2,
uncertain_bits=1,
seed=1)
sol = ExpOpt.min(objective, parameter)[0]
assert sol.get_value() < 10
def opt_var_ids(exs, maps): dim = Dimension(len(flatten(exs)), [[0, 1]] * len(flatten(exs)), [False] * len(flatten(exs))) obj = Objective(lambda v: -consistent_score(exs, v.get_x(), maps).score, dim) param = Parameter(budget=100, autoset=True) solution = Opt.min(obj, param) return solution
def test_racos_performance2(self):
# continuous
dim = 100 # dimension
one_dim = (ValueType.CONTINUOUS, [-1, 1], 1e-6)
dim_list = [(one_dim)] * dim
objective = Objective(ackley, Dimension2(dim_list)) # setup objective
parameter = Parameter(budget=100 * dim, sequential=False, seed=1)
solution = ExpOpt.min(objective, parameter)[0]
assert solution.get_value() < 0.2
dim = 500
dim_list = [(one_dim)] * dim
objective = Objective(ackley, Dimension2(dim_list)) # setup objective
parameter = Parameter(budget=10000, sequential=False, seed=1)
sol = Opt.min(objective, parameter)
sol.print_solution()
assert solution.get_value() < 2
# discrete
# setcover
problem = SetCover()
dim_size = 20
one_dim = (ValueType.DISCRETE, [0, 1], False)
dim_list = [(one_dim)] * dim_size
dim = Dimension2(dim_list) # the dim is prepared by the class
objective = Objective(problem.fx,
dim) # form up the objective function
budget = 100 * dim.get_size(
) # number of calls to the objective function
parameter = Parameter(budget=budget, sequential=False, seed=777)
sol = Opt.min(objective, parameter)
sol.print_solution()
assert sol.get_value() < 2
# sphere
dim_size = 100 # dimensions
one_dim = (ValueType.DISCRETE, [-10, 10], True)
dim_list = [(one_dim)] * dim_size
dim = Dimension2(dim_list) # form up the dimension object
objective = Objective(sphere_discrete_order,
dim) # form up the objective function
parameter = Parameter(budget=10000, sequential=False, seed=77)
sol = Opt.min(objective, parameter)
sol.print_solution()
assert sol.get_value() < 200
def test_racos_performance(self):
# continuous
dim = 100 # dimension
objective = Objective(ackley,
Dimension(dim, [[-1, 1]] * dim,
[True] * dim)) # setup objective
parameter = Parameter(budget=100 * dim, sequential=False, seed=1)
solution = ExpOpt.min(objective, parameter)[0]
assert solution.get_value() < 0.2
dim = 500
objective = Objective(ackley,
Dimension(dim, [[-1, 1]] * dim,
[True] * dim)) # setup objective
parameter = Parameter(budget=10000, sequential=False, seed=1)
sol = Opt.min(objective, parameter)
sol.print_solution()
assert solution.get_value() < 2
# discrete
# setcover
problem = SetCover()
dim = problem.dim # the dim is prepared by the class
objective = Objective(problem.fx,
dim) # form up the objective function
budget = 100 * dim.get_size(
) # number of calls to the objective function
parameter = Parameter(budget=budget, sequential=False, seed=777)
sol = Opt.min(objective, parameter)
sol.print_solution()
assert sol.get_value() < 2
# sphere
dim_size = 100 # dimensions
dim_regs = [[-10, 10]] * dim_size # dimension range
dim_tys = [False] * dim_size # dimension type : integer
dim_order = [True] * dim_size
dim = Dimension(dim_size, dim_regs, dim_tys,
order=dim_order) # form up the dimension object
objective = Objective(sphere_discrete_order,
dim) # form up the objective function
parameter = Parameter(budget=10000, sequential=False, seed=77)
sol = Opt.min(objective, parameter)
sol.print_solution()
assert sol.get_value() < 200
def opt_var_ids_sets_chess_constraint(exs, mapping, constraint):
num_chess = num_of_chess(exs)
dim = Dimension(num_chess, [[0, 1]] * num_chess, [False] * num_chess)
obj = Objective(lambda v: -consistent_score_sets_chess(
exs, [int(i) for i in v.get_x()], mapping)[0],
dim=dim,
constraint=constraint)
param = Parameter(budget=100, autoset=True)
solution = Opt.min(obj, param)
return solution
def opt_var_ids_sets_constraint(exs, mapping, constraint): dim = Dimension(size=len(flatten(exs)), regs=[[0, 1]] * len(flatten(exs)), tys=[False] * len(flatten(exs))) obj = Objective(lambda v: -consistent_score_sets( exs, [int(i) for i in v.get_x()], mapping)[0], dim=dim, constraint=constraint) param = Parameter(budget=100, autoset=True) solution = Opt.min(obj, param) return solution
def test_resample(self):
dim = 100
obj = Objective(func=ackley,
dim=Dimension(dim, [[-1, 1]] * dim, [True] * dim))
sol = Solution(x=[0.2] * dim)
res = obj.eval(sol)
obj.resample(sol, 3)
assert abs(sol.get_value()) <= 1e-7
sol.set_value(0)
obj.resample_func(sol, 3)
assert abs(sol.get_value()) <= 1e-7
def test_performance(self):
dim_size = 10000 # dimensions
dim_regs = [[-1, 1]] * dim_size # dimension range
dim_tys = [True] * dim_size # dimension type : real
dim = Dimension(dim_size, dim_regs, dim_tys) # form up the dimension object
objective = Objective(sphere_sre, dim) # form up the objective function
# setup algorithm parameters
budget = 2000 # number of calls to the objective function
parameter = Parameter(budget=budget, high_dim_handling=True, reducedim=True, num_sre=5,
low_dimension=Dimension(10, [[-1, 1]] * 10, [True] * 10))
solution = Opt.min(objective, parameter)
assert solution.get_value() < 0.3
def run_ss_test(task_name, layers, in_budget, max_step, repeat,
terminal_value):
gym_task = GymTask(task_name) # choose a task by name
gym_task.new_nnmodel(layers) # construct a neural network
gym_task.set_max_step(max_step) # set max step in gym
budget = in_budget # number of calls to the objective function
rand_probability = 0.95 # the probability of sample in model
# set dimension
dim_size = gym_task.get_w_size()
dim_regs = [[-10, 10]] * dim_size
dim_tys = [True] * dim_size
dim = Dimension(dim_size, dim_regs, dim_tys)
def resample_function(solution, iteration_num):
eval_list = []
for i in range(iteration_num):
eval_list.append(gym_task.sum_reward(solution))
return sum(eval_list) * 1.0 / len(eval_list)
# form up the objective function
objective = Objective(gym_task.sum_reward,
dim,
re_sample_func=resample_function)
# by default, the algorithm is sequential RACOS
parameter = Parameter(budget=budget,
autoset=True,
suppression=True,
terminal_value=terminal_value)
parameter.set_resample_times(70)
parameter.set_probability(rand_probability)
result = []
total_sum = 0
total_step = []
print('solved solution is:')
for i in range(repeat):
ins = Opt.min(objective, parameter)
result.append(ins.get_value())
total_sum += ins.get_value()
ins.print_solution()
print("total step %s" % gym_task.total_step)
total_step.append(gym_task.total_step)
gym_task.total_step = 0
print(result) # results in repeat times
print(total_sum / len(result)) # average result
print(total_step)
print("------------------------avg total step %s" %
(sum(total_step) / len(total_step)))
def generate_negative_data(self, dim_range):
self.__negative_dataset = []
dim_size = self.__dim_size # dimensions
dim_regs = [dim_range] * dim_size # dimension range
dim_tys = [True] * dim_size # dimension type : real
dim = Dimension(dim_size, dim_regs,
dim_tys) # form up the dimension object
budget = self.__Budget # number of calls to the objective function
# by setting autoset=false, the algorithm parameters will not be set by default
parameter = Parameter(algorithm="sracos", budget=budget, autoset=True)
# so you are allowed to setup algorithm parameters of racos
# parameter.set_train_size(6)
# parameter.set_probability(0.95)
# parameter.set_uncertain_bits(2)
# parameter.set_positive_size(1)
# parameter.set_negative_size(5)
print "generate negative sample of class:", self.__class_num
for i in range(self.__generate_size):
# init the SRACOS randomly
sample_list = random.sample(range(self.__original_data.shape[0]),
self.__init_num)
init_data = self.__original_data[sample_list]
parameter.set_init_samples(init_data)
objective = Objective(self.train_Dminus, dim)
print 'I have objective'
solution = Opt.min(objective, parameter)
print 'Trying for solution'
x_minus = solution.get_x()
self.__negative_dataset.append(x_minus)
print x_minus
print "[ASG] class", self.__class_num, ": Generating negative data, data size:", len(
self.__negative_dataset)
print "**************************************************"
isExists = os.path.exists(self.__gendir)
# store the generated data
if not isExists:
os.mkdir(self.__gendir)
with open(self.__negative_filename, "w") as f:
f.write("")
with open(self.__negative_filename, "a") as f:
for k in range(len(self.__negative_dataset)):
for t in range(len(self.__negative_dataset[k])):
f.write(str(self.__negative_dataset[k][t]) + ' ')
f.write("\n")
return
def minimize_sphere_continuous():
"""
Example of minimizing the sphere function
:return: no return value
"""
dim_size = 100
# form up the objective function
objective = Objective(sphere, Dimension(dim_size, [[-1, 1]] * dim_size, [True] * dim_size))
budget = 100 * dim_size
# if intermediate_result is True, ZOOpt will output intermediate best solution every intermediate_freq budget
parameter = Parameter(budget=budget, intermediate_result=True,
intermediate_freq=1000)
ExpOpt.min(objective, parameter, repeat=1, plot=True, plot_file="img/sphere_continuous_figure.png")
def __init__(self, ss, sz, focusing_list, solver, _n_iter, best_approx):
self.dof = len(ss)
self.rew = 2000
self.x_prev = ss
self.sz = sz
self.focusing_list = focusing_list
self.l = len(self.focusing_list)
self.solver = solver
self._n_iter = _n_iter
self.t0 = time.time()
self.timer = [0]
self.values = [1000]
# Spawn MAD-X process
self.reset()
self.best_approx = best_approx
if self.solver == 'ZOOpt':
dim = self.dof
#dim_bounds = self.Bounds_maker()
dimobj = Dimension(dim, [[0, 628.3185]] * dim, [True] * dim)
self.parameter = Parameter(budget=self._n_iter,
init_samples=[ss],
exploration_rate=0.25)
self.step = Objective(self.step, dimobj)
elif self.solver == 'BOBYQA': # currently broken
self.upper = np.multiply(np.ones((self.dof), ), 628.3185)
self.lower = np.multiply(self.upper, 0)
elif self.solver == 'Bayesian': # currently unfinished
dim = self.dof
x = [
'x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7', 'x8', 'x9', 'x10',
'x11', 'x12', 'x13', 'x14', 'x15', 'x16', 'x17', 'x18', 'x19',
'x20', 'x21', 'x22', 'x23', 'x24', 'x25', 'x26', 'x27', 'x28',
'x29', 'x30', 'x31', 'x32', 'x33', 'x34', 'x35', 'x36', 'x37',
'x38', 'x39', 'x40'
] #,
#'x41' ,'x42' ,'x43' ,'x44' ,'x45' ,'x46' ,'x47' ,'x48' ,'x49' , 'x50']
bounds = {}
for n in range(self.dof):
bounds[x[n]] = (0, 628.3185)
self.pbounds = bounds
self.optimizer = BayesianOptimization(
f=self.step2,
pbounds=self.pbounds,
random_state=2,
)
else:
self.bounds = [[0, 628.3185]] * self.dof
def test_noisy(self):
ackley_noise_func = ackley_noise_creator(0, 0.1)
dim_size = 100 # dimensions
dim_regs = [[-1, 1]] * dim_size # dimension range
dim_tys = [True] * dim_size # dimension type : real
dim = Dimension(dim_size, dim_regs, dim_tys) # form up the dimension object
objective = Objective(ackley_noise_func, dim) # form up the objective function
budget = 20000 # 20*dim_size # number of calls to the objective function
parameter = Parameter(budget=budget, noise_handling=True, suppression=True, non_update_allowed=200,
resample_times=50, balance_rate=0.5, seed=1)
# parameter = Parameter(budget=budget, noise_handling=True, resampling=True, resample_times=10)
parameter.set_positive_size(5)
sol1 = Opt.min(objective, parameter)
sol2 = Opt.min(objective, parameter)
assert sol1.get_value() == sol2.get_value()
def test_performance(self):
mse = SparseMSE('example/sparse_regression/sonar.arff')
mse.set_sparsity(8)
# setup objective
# print(mse.get_dim().get_size())
objective = Objective(func=mse.loss,
dim=mse.get_dim(),
constraint=mse.constraint)
parameter = Parameter(algorithm='poss',
budget=2 * exp(1) * (mse.get_sparsity()**2) *
mse.get_dim().get_size())
# perform sparse regression with constraint |w|_0 <= k
solution = Opt.min(objective, parameter)
assert solution.get_value()[0] < 0.6
def minimize_ackley_continuous():
"""
Continuous optimization example of minimizing the ackley function.
:return: no return value
"""
dim_size = 100 # dimensions
dim_regs = [[-1, 1]] * dim_size # dimension range
dim_tys = [True] * dim_size # dimension type : real
dim = Dimension(dim_size, dim_regs, dim_tys) # form up the dimension object
objective = Objective(ackley, dim) # form up the objective function
budget = 100 * dim_size # number of calls to the objective function
parameter = Parameter(budget=budget)
solution_list = ExpOpt.min(objective, parameter, repeat=1, plot=True, plot_file="img/ackley_continuous_figure.png")
def minimize_sphere_discrete_order():
"""
Discrete optimization example of minimizing the sphere function, which has ordered search space.
:return: no return value
"""
dim_size = 100 # dimensions
dim_regs = [[-10, 10]] * dim_size # dimension range
dim_tys = [False] * dim_size # dimension type : integer
dim_order = [True] * dim_size
dim = Dimension(dim_size, dim_regs, dim_tys, order=dim_order) # form up the dimension object
objective = Objective(sphere_discrete_order, dim) # form up the objective function
# setup algorithm parameters
budget = 10000 # number of calls to the objective function
parameter = Parameter(budget=budget, uncertain_bits=1)
ExpOpt.min(objective, parameter, repeat=1, plot=True, plot_file="img/sphere_discrete_order_figure.png")
def fit(self,
real_data,
budget=10000,
server_num=3,
repeat=1,
seed=1,
plot=False,
plot_file="optimize.png",
intermediate_freq=100,
init_samples=None,
loss_ord=0):
problem = problem_maker(self, real_data, self.training_date_end,
loss_ord)
dim, dim_range, dim_type = self.get_dim() # dimension
dim_range = [[a[0], a[1]] for a in dim_range]
print(dim_range)
objective = Objective(problem, Dimension(dim, dim_range,
dim_type)) # set up objective
parameter = Parameter(algorithm='racos',
budget=budget,
intermediate_result=True,
intermediate_freq=intermediate_freq,
seed=seed,
parallel=True,
server_num=server_num,
init_samples=init_samples)
parameter.set_probability(0.6)
solution_list = ExpOpt.min(objective,
parameter,
repeat=repeat,
plot=plot,
plot_file=plot_file)
f_min = np.inf
x_min = None
for s in solution_list:
if s.get_value() < f_min:
f_min = s.get_value()
x_min = s.get_x()
self.set_param(x_min)
return x_min, f_min
def __init__(self, dimension, parameter):
"""
Initialization.
:param dimension: instance of Dimension2 class
:param parameter: instance of Parameter class
"""
RacosCommon.__init__(self)
self.clear()
objective = Objective(None, dimension)
self.set_objective(objective)
self.set_parameters(parameter)
self.init_num = 0
self.complete_num = 0
self.semaphore = 1 # control init
self.ub = self._parameter.get_uncertain_bits()
if self.ub is None:
self.ub = self.choose_ub(self.get_objective())
return
def minimize_setcover_discrete():
"""
Discrete optimization example of minimizing setcover problem.
:return: no return value
"""
problem = SetCover()
dim = problem.dim # the dim is prepared by the class
objective = Objective(problem.fx, dim) # form up the objective function
budget = 100 * dim.get_size() # number of calls to the objective function
# if autoset is False, you should define train_size, positive_size, negative_size on your own
parameter = Parameter(budget=budget, autoset=False)
parameter.set_train_size(6)
parameter.set_positive_size(1)
parameter.set_negative_size(5)
ExpOpt.min(objective,
parameter,
repeat=10,
best_n=5,
plot=True,
plot_file="img/setcover_discrete_figure.png")
def test_performance(self):
# load data file
mse = SparseMSE('example/sparse_regression/sonar.arff')
mse.set_sparsity(8)
# setup objective
objective = Objective(func=mse.loss,
dim=mse.get_dim(),
constraint=mse.constraint)
# ponss_theta and ponss_b are parameters used in PONSS algorithm and should be provided by users. ponss_theta stands
# for the threshold. ponss_b limits the number of solutions in the population set.
parameter = Parameter(algorithm='poss',
noise_handling=True,
ponss=True,
ponss_theta=0.5,
ponss_b=mse.get_k(),
budget=2 * exp(1) * (mse.get_sparsity()**2) *
mse.get_dim().get_size())
# perform sparse regression with constraint |w|_0 <= k
solution = Opt.min(objective, parameter)
assert solution.get_value()[0] < 0.7
