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_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 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 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_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 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_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 generate_positive_data(self, dim_range): self.__positive_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="racos", 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) with open(self.__positive_filename) as f: for line in f: self.__positive_dataset.append( [float(x) for x in line.split()]) # print("generate positive sample of class:", self.__class_num) # for i in range(self.__generate_size): # # initial for the generate program # 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_Dplus, dim) # solution = Opt.min(objective, parameter) # x_plus = solution.get_x() # self.__positive_dataset.append(x_plus) # print("[ASG] class",self.__class_num, ": generating positive data, data size:",len(self.__positive_dataset)) # print("**************************************************") # # isDataExists = os.path.exists(self.__datadir) # if not isDataExists: # os.mkdir(self.__datadir) # with open(self.__pos_filename, "a") as f: # for k in range(len(self.__positive_dataset)): # for t in range(len(self.__positive_dataset[k])): # f.write(str(self.__positive_dataset[k][t]) + ' ') # f.write("\n") # # # store the generated data # isExists = os.path.exists(self.__gendir) # if not isExists: # os.mkdir(self.__gendir) # with open(self.__positive_filename,"w") as f: # f.write("") # with open(self.__positive_filename,"a") as f: # for k in range(len(self.__positive_dataset)): # for t in range(len(self.__positive_dataset[k])): # f.write(str(self.__positive_dataset[k][t])+ ' ') # f.write("\n") return
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 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 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 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 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 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_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_test(task_name, layers, in_budget, max_step, repeat, terminal_value=None): """ example of running direct policy search for gym task. :param task_name: gym task name :param layers: layer information of the neural network e.g., [2, 5, 1] means input layer has 2 neurons, hidden layer(only one) has 5 and output layer has 1 :param in_budget: number of calls to the objective function :param max_step: max step in gym :param repeat: repeat number in a test :param terminal_value: early stop, algorithm should stop when such value is reached :return: no return 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) # form up the objective function objective = Objective(gym_task.sum_reward, dim) parameter = Parameter(budget=budget, terminal_value=terminal_value) parameter.set_probability(rand_probability) solution_list = ExpOpt.min(objective, parameter, repeat=repeat)
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_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 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 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 __init__(self, algo="asracos", budget=None, dim_dict=None, max_concurrent=10, metric="episode_reward_mean", mode="min", **kwargs): assert budget is not None, "`budget` should not be None!" assert dim_dict is not None, "`dim_list` should not be None!" assert type(max_concurrent) is int and max_concurrent > 0 assert mode in ["min", "max"], "`mode` must be 'min' or 'max'!" _algo = algo.lower() assert _algo in ["asracos", "sracos" ], "`algo` must be in ['asracos', 'sracos'] currently" self._max_concurrent = max_concurrent self._metric = metric if mode == "max": self._metric_op = -1. elif mode == "min": self._metric_op = 1. self._live_trial_mapping = {} self._dim_keys = [] _dim_list = [] for k in dim_dict: self._dim_keys.append(k) _dim_list.append(dim_dict[k]) dim = Dimension2(_dim_list) par = Parameter(budget=budget) if _algo == "sracos" or _algo == "asracos": self.optimizer = SRacosTune(dimension=dim, parameter=par) self.solution_dict = {} self.best_solution_list = [] super(ZOOptSearch, self).__init__( metric=self._metric, mode=mode, **kwargs)
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
def Policy_Search(self): def ackley(solution): value = [] if self.pre: w1 = self.Pre_Reg(self.policy_reserve) w_1_dim = (self.config.feature_size, self.config.hidden_size) w_2_dim = (self.config.hidden_size, self.config.action_size) w_flat = solution.get_x() if not self.pre: value.append( np.reshape(w_flat[0:w_1_dim[0] * w_1_dim[1]], w_1_dim)) value.append( np.reshape(w_flat[w_1_dim[0] * w_1_dim[1]:], w_2_dim)) else: value.append(w1) value.append(np.reshape(w_flat, w_2_dim)) self.model._assign(value) self.model.train_model(None, None, None, None, None) mean_reward, max_reward, min_reward = self.Get_Data( self.policy_reserve) print "eval max_reward: {}, min_reward: {}, mean_reward: {}".format( max_reward, min_reward, mean_reward) return -mean_reward if not self.pre: dim = self.config.feature_size * self.config.hidden_size + self.config.hidden_size * self.config.action_size else: dim = self.config.hidden_size * self.config.action_size obj = Objective(ackley, Dimension(dim, [[-0.01, 0.01]] * dim, [True] * dim)) solution = Opt.min( obj, Parameter(budget=100 * dim, uncertain_bits=100, intermediate_result=False, intermediate_freq=1)) solution.print_solution()