def get_functions_borders(num_vars = 3, grid_size = 1000000): grid = sobol_grid.generate( num_vars , grid_size ) # Scale grid. grid[:,0] = grid[:,0] * ( 0.01 - 0.0001 ) + 0.0001 grid[:,1] = grid[:,1] * ( 0.01 - 0.0001 ) + 0.0001 grid[:,2] = grid[:,2] * ( 3.0 - 1.0 ) + 1.0 print("Statistics over the objectives and constraints") print("==============================================") first_obj_observations = obj1(grid) second_obj_observations = obj2(grid) first_con_observations = c1(grid) max_first_obj = np.max(first_obj_observations) min_first_obj = np.min(first_obj_observations) max_second_obj = np.max(second_obj_observations) min_second_obj = np.min(second_obj_observations) max_first_con = np.max(first_con_observations) min_first_con = np.min(first_con_observations) print("Maximum observation of the first objective") print(max_first_obj) print("Minimum observation of the first objective") print(min_first_obj) print("Maximum observation of the second objective") print(max_second_obj) print("Minimum observation of the second objective") print(min_second_obj) print("Maximum observation of the first constraint") print(max_first_con) print("Minimum observation of the first constraint") print(min_first_con)
def solve_using_grid(self, grid = None): if grid is None: grid = sobol_grid.generate(self.num_dims, 20000) values = np.ones((grid.shape[ 0 ], len(self.funs))) for i in range(len(self.funs)): values[ :, i ] = self.funs[ i ](grid, gradient = False) #Values must satisfy constraints, if there are constraints in the problem. if len(self.constraints) > 0: con_evals = np.ones(grid.shape[0]).astype('bool') values_satisfying_constraints = values for con_fun in self.constraints: con_evals = np.logical_and(con_evals, con_fun(grid, gradient = False) >= 0) values_satisfying_constraints = values[ con_evals, : ] else: con_evals = np.ones(grid.shape[0]).astype('bool') values_satisfying_constraints = values pareto_indices = _cull_algorithm(values_satisfying_constraints) grid_points_satisfying_constraints = grid[con_evals, : ] grid_to_add = grid_points_satisfying_constraints[ pareto_indices, : ] self.pop = population(self, 0) for i in range(grid_to_add.shape[ 0 ]): self.pop.push_back(grid_to_add[ i, : ].tolist())
def get_functions_borders(num_vars=4, grid_size=1000000): grid = sobol_grid.generate(num_vars, grid_size) # Scale grid. grid[:, 0] = grid[:, 0] * (5.0 - 0.125) + 0.125 grid[:, 1] = grid[:, 1] * (5.0 - 0.125) + 0.125 grid[:, 2] = grid[:, 2] * (10.0 - 0.1) + 0.1 grid[:, 3] = grid[:, 3] * (10.0 - 0.1) + 0.1 print("Statistics over the objectives and constraints") print("==============================================") first_obj_observations = obj1(grid) second_obj_observations = obj2(grid) first_con_observations = c1(grid) second_con_observations = c2(grid) third_con_observations = c3(grid) fourth_con_observations = c4(grid) max_first_obj = np.max(first_obj_observations) min_first_obj = np.min(first_obj_observations) max_second_obj = np.max(second_obj_observations) min_second_obj = np.min(second_obj_observations) max_first_con = np.max(first_con_observations) min_first_con = np.min(first_con_observations) max_second_con = np.max(second_con_observations) min_second_con = np.min(second_con_observations) max_third_con = np.max(third_con_observations) min_third_con = np.min(third_con_observations) max_fourth_con = np.max(fourth_con_observations) min_fourth_con = np.min(fourth_con_observations) print("Maximum observation of the first objective") print(max_first_obj) print("Minimum observation of the first objective") print(min_first_obj) print("Maximum observation of the second objective") print(max_second_obj) print("Minimum observation of the second objective") print(min_second_obj) print("Maximum observation of the first constraint") print(max_first_con) print("Minimum observation of the first constraint") print(min_first_con) print("Maximum observation of the second constraint") print(max_second_con) print("Minimum observation of the second constraint") print(min_second_con) print("Maximum observation of the third constraint") print(max_third_con) print("Minimum observation of the third constraint") print(min_third_con) print("Maximum observation of the fourth constraint") print(max_fourth_con) print("Minimum observation of the fourth constraint") print(min_fourth_con)
def get_functions_borders(num_vars=2, grid_size=1000000, noise=0.1): grid = sobol_grid.generate(num_vars, grid_size) # Scale grid. grid[:, 0] = grid[:, 0] * (3.141592 - 0.000001) + 0.000001 grid[:, 1] = grid[:, 1] * (3.141592 - 0.000001) + 0.000001 print("Statistics over the objectives and constraints") print("==============================================") first_obj_observations = obj1(grid) second_obj_observations = obj2(grid) first_con_observations = c1(grid) second_con_observations = c2(grid) max_first_obj = np.max(first_obj_observations) min_first_obj = np.min(first_obj_observations) max_second_obj = np.max(second_obj_observations) min_second_obj = np.min(second_obj_observations) max_first_con = np.max(first_con_observations) min_first_con = np.min(first_con_observations) max_second_con = np.max(second_con_observations) min_second_con = np.min(second_con_observations) print("Maximum observation of the first objective") print(max_first_obj) print("Minimum observation of the first objective") print(min_first_obj) print("Noise factor") print((max_first_obj - min_first_obj) * noise) print("Maximum observation of the second objective") print(max_second_obj) print("Minimum observation of the second objective") print(min_second_obj) print("Noise factor") print((max_second_obj - min_second_obj) * noise) print("Maximum observation of the first constraint") print(max_first_con) print("Minimum observation of the first constraint") print(min_first_con) print("Noise factor") print((max_first_con - min_first_con) * noise) print("Maximum observation of the second constraint") print(max_second_con) print("Minimum observation of the second constraint") print(min_second_con) print("Noise factor") print((max_second_con - min_second_con) * noise)
def solve_using_grid(self, grid = None): if grid is None or len(grid)==0: grid = sobol_grid.generate(self.input_space.num_dims, 20000) values = np.ones((grid.shape[ 0 ], len(self.models.keys()))) n_task = 0 for key in self.tasks: if self.avg_over_hypers: values[ :, n_task ] = self.models[ key ].function_over_hypers(self.models[ key ].predict, grid)[ 0 ] else: values[ :, n_task ] = self.models[ key ].predict(grid)[ 0 ] n_task += 1 if self.extended_domination_rule: values = self.apply_extended_domination_rule_to_values(values) pareto_indices = _cull_algorithm(values) values = values[ pareto_indices, : ] grid = grid[ pareto_indices, : ] # We remove repeated entries from the pareto front and set frontier = values X = frontier[ 0 : 1, : ] pareto_set = grid[ 0 : 1, : ] for i in range(frontier.shape[ 0 ]): if np.min(cdist(frontier[ i : (i + 1), : ], X)) > 1e-8: X = np.vstack((X, frontier[ i, ])) pareto_set = np.vstack((pareto_set, grid[ i, ])) grid = pareto_set frontier = X self.pop = population(self, 0) for i in range(grid.shape[ 0 ]): self.pop.push_back(grid[ i, : ].tolist())
def solve_using_grid(self, grid=None): if grid is None: grid = sobol_grid.generate(self.num_dims, 20000) values = np.ones((grid.shape[0], len(self.funs))) for i in range(len(self.funs)): values[:, i] = self.funs[i](grid, gradient=False) pareto_indices = _cull_algorithm(values) grid_to_add = grid[pareto_indices, :] values = values[pareto_indices, :] self.pop = population(self, 0) for i in range(grid_to_add.shape[0]): self.pop.push_back(grid_to_add[i, :].tolist())
def main(expt_dir): os.chdir(expt_dir) sys.path.append(expt_dir) options = parse_config_file(expt_dir, 'config.json') experiment_name = options["experiment-name"] # main_file = options['main_file'] main_file = 'OSY_no_noisy' if main_file[-3:] == '.py': main_file = main_file[:-3] module = __import__(main_file) input_space = InputSpace(options["variables"]) chooser_module = importlib.import_module('spearmint.choosers.' + options['chooser']) chooser = chooser_module.init(input_space, options) db = MongoDB(database_address=options['database']['address']) jobs = load_jobs(db, experiment_name) hypers = db.load(experiment_name, 'hypers') tasks = parse_tasks_from_jobs(jobs, experiment_name, options, input_space) if len(tasks) < 2: print 'Not a multi-objective problem!' return -1 if options['language'] != "PYTHON": print 'Only python programs supported!' return -1 objectives = dict() contraints = dict() for task in tasks: if tasks[task].type == 'objective': objectives[task] = tasks[task] else: contraints[task] = tasks[task] assert len(objectives) >= 2 and len(contraints) >= 1 def create_fun(task): def fun(params, gradient=False): if len(params.shape) > 1 and params.shape[1] > 1: values = np.zeros(params.shape[0]) params_orig = params for i in range(params_orig.shape[0]): param = params[i, :] param = param.flatten() param = input_space.from_unit(np.array([param])).flatten() values[i] = module.main( 0, paramify_no_types(input_space.paramify(param)))[task] else: return module.main( 0, paramify_no_types(input_space.paramify(params)))[task] return values return fun funs_o = [create_fun(task) for task in objectives] funs_c = [create_fun(task) for task in contraints] moop = MOOP_basis_functions(funs_o, input_space.num_dims, constraints=funs_c) grid = sobol_grid.generate(input_space.num_dims, grid_size=1000 * input_space.num_dims) # We only retain the feasible points moop.solve_using_grid(grid) reference = np.ones(len(objectives)) * 1e3 hyper_volume_solution = moop.get_hypervolume(reference.tolist()) result = moop.compute_pareto_front_and_set() front = result['frontier'] pareto_set = result['pareto_set'] with open('hypervolume_solution.txt', 'a') as f: print >> f, "%lf" % (hyper_volume_solution) # We iterate through each recommendation made i = 0 more_recommendations = True while more_recommendations: recommendation = db.load(experiment_name, 'recommendations', {'id': i + 1}) if recommendation == None: more_recommendations = False else: solution = input_space.to_unit( input_space.vectorify(recommendation['params'])) if len(solution.shape) == 1: solution = solution.reshape((1, len(solution))) # We compute the objective values associated to this recommendation values_solution = np.zeros((solution.shape[0], len(objectives))) for j in range(values_solution.shape[0]): for k in range(values_solution.shape[1]): values_solution[j, k] = funs_o[k](solution[j:(j + 1), :]) moop = MOOP_basis_functions(funs_o, input_space.num_dims) moop.set_population(solution) hyper_volume = moop.get_hypervolume(reference.tolist()) # We make sure that there are no infeasible points recommended # If there are infeasible recommendations we return 0 as the hypervolume all_feasible = True for k in range(len(funs_c)): all_feasible = all_feasible and not np.any( funs_c[k](solution) < 0) if not all_feasible: hyper_volume = 0.0 with open('hypervolumes.txt', 'a') as f: print >> f, "%lf" % (hyper_volume) with open('evaluations.txt', 'a') as f_handle: np.savetxt( f_handle, np.array([recommendation['num_complete_tasks'].values()]), delimiter=' ', newline='\n') i += 1
def test_generate(): grid = sobol_grid.generate(10, grid_size=100, grid_seed=1) assert grid.shape == (100, 10) assert np.all(grid[0] == 0.5)
def compute_cell_information(self, obj_model_dict): cached_information = dict() # First we obtain a sample from the Pareto Frontier of NUM_POINTS_FRONTIER moop = MOOP(obj_model_dict, obj_model_dict, self.input_space, False) grid = sobol_grid.generate(self.input_space.num_dims, self.input_space.num_dims * GRID_SIZE) if USE_GRID_ONLY == True: moop.solve_using_grid(grid) for i in range(len(obj_model_dict.keys())): result = self.find_optimum_gp(obj_model_dict[ obj_model_dict.keys()[ i ] ], grid) moop.append_to_population(result) else: assert NSGA_POP > len(obj_model_dict.keys()) + 1 moop.solve_using_grid(grid) for i in range(len(obj_model_dict.keys())): result = self.find_optimum_gp(obj_model_dict[ obj_model_dict.keys()[ i ] ], grid) moop.append_to_population(result) pareto_set = moop.compute_pareto_front_and_set_summary(NSGA_POP)['pareto_set'] moop.initialize_population(np.maximum(NSGA_POP - pareto_set.shape[ 0 ], 0)) for i in range(pareto_set.shape[ 0 ]): moop.append_to_population(pareto_set[ i, : ]) moop.evolve_population_only(NSGA_EPOCHS) for i in range(pareto_set.shape[ 0 ]): moop.append_to_population(pareto_set[ i, : ]) result = moop.compute_pareto_front_and_set_summary(NUM_POINTS_FRONTIER) print 'Inner multi-objective problem solved!' means_objectives = np.zeros((obj_model_dict[ obj_model_dict.keys()[ 0 ] ].inputs.shape[ 0 ], len(obj_model_dict))) k = 0 for obj in obj_model_dict: means_objectives[ :, k ] = obj_model_dict[ obj ].predict(obj_model_dict[ obj ].inputs)[ 0 ] k += 1 v_inf = np.ones((1, len(obj_model_dict))) * np.inf v_ref = np.ones((1, len(obj_model_dict))) * 1e3 # We add the non-dominated prediction and the observed inputs to the frontier frontier = result['frontier'] frontier = np.vstack((frontier, means_objectives)) frontier = frontier[ _cull_algorithm(frontier), ] # We remove repeated entries from the pareto front X = frontier[ 0 : 1, : ] for i in range(frontier.shape[ 0 ]): if np.min(cdist(frontier[ i : (i + 1), : ], X)) > 1e-8: X = np.vstack((X, frontier[ i, ])) frontier = X cached_information['frontier'] = frontier # We sort the entries in the pareto frontier frontier_sorted = np.vstack((-v_inf, cached_information['frontier'], v_ref, v_inf)) for i in range(len(obj_model_dict)): frontier_sorted[ :, i ] = np.sort(frontier_sorted[ :, i ]) # Now we build the info associated to each cell n_repeat = (frontier_sorted.shape[ 0 ] - 2) ** frontier_sorted.shape[ 1 ] cached_information['cells'] = dict() added_cells = 0 for i in range(n_repeat): cell = dict() indices = np.zeros(len(obj_model_dict)).astype(int) j = i for k in range(len(obj_model_dict)): indices[ k ] = int(j % (frontier_sorted.shape[ 0 ] - 2)) j = np.floor(j / (frontier_sorted.shape[ 0 ] - 2)) u = np.zeros(len(obj_model_dict)) for k in range(len(obj_model_dict)): u[ k ] = frontier_sorted[ int(indices[ k ] + 1), k ] l = np.zeros(len(obj_model_dict)) for k in range(len(obj_model_dict)): l[ k ] = frontier_sorted[ indices[ k ], k ] # If the cell is dominated we discard it is_dominated = False for k in range(frontier.shape[ 0 ]): if np.all(l >= frontier[ k, : ]): is_dominated = True if is_dominated: continue # We find the vector v v = np.zeros(len(obj_model_dict)) for k in range(len(obj_model_dict)): l_tmp = np.copy(l) for j in range(int(frontier_sorted.shape[ 0 ] - indices[ k ] - 1)): l_tmp[ k ] = frontier_sorted[ indices[ k ] + j, k ] dominates_all = True for h in range(frontier.shape[ 0 ]): if np.all(frontier[ h, : ] <= l_tmp): dominates_all = False break if dominates_all == False: break if dominates_all == False: v[ k ] = l_tmp[ k ] else: v[ k ] = v_ref[ 0, k ] # We compute the quantities required for evaluating the gain in hyper-volume # We find the points dominated by u dominated_by_u = frontier h = 0 while (h < dominated_by_u.shape[ 0 ]): if (not np.any(u < dominated_by_u[ h, : ])) and (not np.all(u == dominated_by_u[ h, : ])): dominated_by_u = np.delete(dominated_by_u, (h), axis = 0) else: h+= 1 # The value of minusQ2plusQ3 is given by the hypervolume of the dominated points with reference v if dominated_by_u.shape[ 0 ] == 0: minusQ2plusQ3 = 0.0 else: hv = HyperVolume(v.tolist()) minusQ2plusQ3 = -hv.compute(dominated_by_u.tolist()) cell['u'] = u cell['l'] = l cell['v'] = v cell['dominated_by_u'] = dominated_by_u cell['minusQ2plusQ3'] = minusQ2plusQ3 cached_information['cells'][ str(added_cells) ] = cell added_cells += 1 n_cells = added_cells cached_information['n_cells'] = n_cells cached_information['v_ref'] = v_ref[ 0, : ] cached_information['n_objectives'] = len(obj_model_dict) # self.print_cell_info(cached_information) return cached_information
def compute_information(self, obj_model_dict): cached_information = dict() # First we obtain a sample from the Pareto Frontier of NUM_POINTS_FRONTIER moop = MOOP(obj_model_dict, obj_model_dict, self.input_space, False) grid = sobol_grid.generate(self.input_space.num_dims, self.input_space.num_dims * GRID_SIZE) if USE_GRID_ONLY == True: moop.solve_using_grid(grid) for i in range(len(obj_model_dict.keys())): result = self.find_optimum_gp( obj_model_dict[obj_model_dict.keys()[i]], grid) moop.append_to_population(result) else: assert NSGA_POP > len(obj_model_dict.keys()) + 1 moop.solve_using_grid(grid) for i in range(len(obj_model_dict.keys())): result = self.find_optimum_gp( obj_model_dict[obj_model_dict.keys()[i]], grid) moop.append_to_population(result) pareto_set = moop.compute_pareto_front_and_set_summary( NSGA_POP)['pareto_set'] moop.initialize_population( np.maximum(NSGA_POP - pareto_set.shape[0], 0)) for i in range(pareto_set.shape[0]): moop.append_to_population(pareto_set[i, :]) moop.evolve_population_only(NSGA_EPOCHS) for i in range(pareto_set.shape[0]): moop.append_to_population(pareto_set[i, :]) result = moop.compute_pareto_front_and_set_summary(NUM_POINTS_FRONTIER) print 'Internal optimization finished' # We remove repeated entries from the pareto front frontier = result['frontier'] X = frontier[0:1, :] for i in range(frontier.shape[0]): if np.min(cdist(frontier[i:(i + 1), :], X)) > 1e-8: X = np.vstack((X, frontier[i, ])) frontier = X cached_information['frontier'] = frontier cached_information['v_ref'] = np.ones(len(obj_model_dict)) for k in range(frontier.shape[1]): cached_information['v_ref'][k] = np.max(frontier[:, k]) + 1.0 return cached_information
def compute_cell_information_2_objectives(self, obj_model_dict, cand): assert len(obj_model_dict) == 2 cached_information = dict() # First we obtain a sample from the Pareto Frontier of NUM_POINTS_FRONTIER moop = MOOP(obj_model_dict, obj_model_dict, self.input_space, False) grid = sobol_grid.generate(self.input_space.num_dims, self.input_space.num_dims * GRID_SIZE) if USE_GRID_ONLY == True: moop.solve_using_grid(grid) for i in range(len(obj_model_dict.keys())): result = self.find_optimum_gp(obj_model_dict[ obj_model_dict.keys()[ i ] ], grid) moop.append_to_population(result) else: assert NSGA_POP > len(obj_model_dict.keys()) + 1 moop.solve_using_grid(grid) for i in range(len(obj_model_dict.keys())): result = self.find_optimum_gp(obj_model_dict[ obj_model_dict.keys()[ i ] ], grid) moop.append_to_population(result) pareto_set = moop.compute_pareto_front_and_set_summary(NSGA_POP)['pareto_set'] moop.initialize_population(np.maximum(NSGA_POP - pareto_set.shape[ 0 ], 0)) for i in range(pareto_set.shape[ 0 ]): moop.append_to_population(pareto_set[ i, : ]) moop.evolve_population_only(NSGA_EPOCHS) for i in range(pareto_set.shape[ 0 ]): moop.append_to_population(pareto_set[ i, : ]) result = moop.compute_pareto_front_and_set_summary(NUM_POINTS_FRONTIER) # First we obtain a sample from the Pareto Frontier of NUM_POINTS_FRONTIER means_objectives = np.zeros((obj_model_dict[ obj_model_dict.keys()[ 0 ] ].inputs.shape[ 0 ], len(obj_model_dict))) k = 0 for obj in obj_model_dict: means_objectives[ :, k ] = obj_model_dict[ obj ].predict(obj_model_dict[ obj ].inputs)[ 0 ] k += 1 v_inf = np.ones((1, len(obj_model_dict))) * 1e3 # We obtain the pareto frontier approximation which is added the observations frontier = result['frontier'] frontier = np.vstack((frontier, means_objectives)) frontier = frontier[ _cull_algorithm(frontier), ] # We remove repeated entries from the pareto front X = frontier[ 0 : 1, : ] for i in range(frontier.shape[ 0 ]): if np.min(cdist(frontier[ i : (i + 1), : ], X)) > 1e-8: X = np.vstack((X, frontier[ i, ])) frontier = X cached_information['frontier'] = frontier # We sort the entries in the pareto frontier frontier_sorted = np.vstack((-v_inf, cached_information['frontier'], v_inf)) frontier_sorted[ :, 0 ] = np.sort(frontier_sorted[ :, 0 ]) frontier_sorted[ :, 1 ] = np.sort(frontier_sorted[ :, 1 ] * -1.0) * -1.0 # Now we build the info associated to each cell n_cells = (frontier_sorted.shape[ 0 ] - 1) + (frontier_sorted.shape[ 0 ] - 2) # We add first the non dominated cells cached_information['cells'] = dict() added_cells = 0 for i in range(frontier_sorted.shape[ 0 ] - 1): cell = dict() cell['l'] = np.array([ frontier_sorted[ i, 0 ], frontier_sorted[ 0, 0 ] ]) cell['u'] = np.array([ frontier_sorted[ i + 1, 0 ], frontier_sorted[ i, 1 ] ]) cell['is_dominated'] = False cached_information['cells'][ str(added_cells) ] = cell added_cells += 1 # # Now the dominated cells # # for i in range(frontier_sorted.shape[ 0 ] - 2): # # cell = dict() # cell['l'] = np.array([ frontier_sorted[ i + 1, 0 ], frontier_sorted[ i + 1, 1 ] ]) # cell['u'] = np.array([ frontier_sorted[ frontier_sorted.shape[ 0 ] - 1, 0 ], frontier_sorted[ i, 1 ] ]) # cell['is_dominated'] = True # cached_information['cells'][ str(added_cells) ] = cell # added_cells += 1 # cached_information['n_cells'] = n_cells cached_information['n_cells'] = added_cells cached_information['n_objectives'] = len(obj_model_dict) # We compute a sobol grid to approximate the integral over x. By default we use # 100 points per dimension (too much?) if not 'sur_points_per_dimension' in self.options.keys(): # cached_information['grid'] = np.array(sobol_grid.generate(self.num_dims, 100 * self.num_dims)) cached_information['grid'] = np.random.uniform(size = (100 * self.num_dims, self.num_dims)) else: # cached_information['grid'] = np.array(sobol_grid.generate(self.num_dims, \ # int(self.options['sur_points_per_dimension']) * self.num_dims)) cached_information['grid'] = np.random.uniform(size = (int(self.options['sur_points_per_dimension']) \ * self.num_dims, self.num_dims)) # We obtain the samples needed for a Monte Carlo approximation of the objective cached_information['gauss_samples_grid'] = np.random.normal(size = (cached_information['grid'].shape[ 0 ], \ len(obj_model_dict), N_SAMPLES)) cached_information['gauss_sample_cand'] = np.random.normal(size = N_SAMPLES) # self.print_cell_info(cached_information) return cached_information
def get_functions_borders(num_vars = 6, grid_size = 1000000, noise=0.1): grid = sobol_grid.generate( num_vars , grid_size ) # Scale grid. grid[:,0] = grid[:,0] * ( 10.0 - 0.0 ) + 0.0 grid[:,1] = grid[:,1] * ( 10.0 - 0.0 ) + 0.0 grid[:,2] = grid[:,2] * ( 5.0 - 1.0 ) + 1.0 grid[:,3] = grid[:,3] * ( 6.0 - 0.0 ) + 0.0 grid[:,4] = grid[:,4] * ( 5.0 - 1.0 ) + 1.0 grid[:,5] = grid[:,5] * ( 10.0 - 0.0 ) + 0.0 print("Statistics over the objectives and constraints") print("==============================================") first_obj_observations = obj1(grid) second_obj_observations = obj2(grid) first_con_observations = c1(grid) second_con_observations = c2(grid) third_con_observations = c3(grid) fourth_con_observations = c4(grid) fifth_con_observations = c5(grid) sixth_con_observations = c6(grid) max_first_obj = np.max(first_obj_observations) min_first_obj = np.min(first_obj_observations) max_second_obj = np.max(second_obj_observations) min_second_obj = np.min(second_obj_observations) max_first_con = np.max(first_con_observations) min_first_con = np.min(first_con_observations) max_second_con = np.max(second_con_observations) min_second_con = np.min(second_con_observations) max_third_con = np.max(third_con_observations) min_third_con = np.min(third_con_observations) max_fourth_con = np.max(fourth_con_observations) min_fourth_con = np.min(fourth_con_observations) max_fifth_con = np.max(fifth_con_observations) min_fifth_con = np.min(fifth_con_observations) max_sixth_con = np.max(sixth_con_observations) min_sixth_con = np.min(sixth_con_observations) print("Maximum observation of the first objective") print(max_first_obj) print("Minimum observation of the first objective") print(min_first_obj) print("Noise factor") print((max_first_obj-min_first_obj)*noise) print("Maximum observation of the second objective") print(max_second_obj) print("Minimum observation of the second objective") print(min_second_obj) print("Noise factor") print((max_second_obj-min_second_obj)*noise) print("Maximum observation of the first constraint") print(max_first_con) print("Minimum observation of the first constraint") print(min_first_con) print("Noise factor") print((max_first_con-min_first_con)*noise) print("Maximum observation of the second constraint") print(max_second_con) print("Minimum observation of the second constraint") print(min_second_con) print("Noise factor") print((max_second_con-min_second_con)*noise) print("Maximum observation of the third constraint") print(max_third_con) print("Minimum observation of the third constraint") print(min_third_con) print("Noise factor") print((max_third_con-min_third_con)*noise) print("Maximum observation of the fourth constraint") print(max_fourth_con) print("Minimum observation of the fourth constraint") print(min_fourth_con) print("Noise factor") print((max_fourth_con-min_fourth_con)*noise) print("Maximum observation of the fifth constraint") print(max_fifth_con) print("Minimum observation of the fifth constraint") print(min_fifth_con) print("Noise factor") print((max_fifth_con-min_fifth_con)*noise) print("Maximum observation of the sixth constraint") print(max_sixth_con) print("Minimum observation of the sixth constraint") print(min_sixth_con) print("Noise factor") print((max_sixth_con-min_sixth_con)*noise)
def test_generate(): grid = sobol_grid.generate(10, grid_size=100, grid_seed=1) assert grid.shape == (100,10) assert np.all(grid[0] == 0.5)
def find_reference_point(tasks, module, input_space, grid_size = 20000): def create_fun_neg(task): def fun(params, gradient = False): if len(params.shape) > 1 and params.shape[ 1 ] > 1: params = params.flatten() params = input_space.from_unit(np.array([ params ])).flatten() return -1.0 * module.main(0, paramify_no_types(input_space.paramify(params)))[ task ] return fun funs_neg = [ create_fun_neg(task) for task in tasks ] moop_neg = MOOP_basis_functions(funs_neg, input_space.num_dims) moop_neg.evolve(400, 400) result = moop_neg.compute_pareto_front_and_set() front = result['frontier'] pareto_set = result['pareto_set'] grid = sobol_grid.generate(input_space.num_dims, grid_size = grid_size, grid_seed = npr.randint(0, grid_size)) grid = np.vstack((grid, pareto_set)) # We add the borders of the hyper-cube to the grid since there it is likely to be the maximum for i in range(2**input_space.num_dims): vector = np.zeros(input_space.num_dims) for j in range(input_space.num_dims): if bin(i & 2**j) != bin(0): vector[ j ] = 1.0 grid = np.vstack((grid, vector.reshape((1, input_space.num_dims)))) reference_point = np.zeros(len(funs_neg)) for i in range(len(funs_neg)): grid_values = np.zeros(grid.shape[ 0 ]) for j in range(grid.shape[ 0 ]): grid_values[ j ] = funs_neg[ i ](grid[ j, : ]) best = grid[ np.argmin(grid_values), : ] def f(x): if x.ndim == 1: x = x[None,:] value = funs_neg[ i ](x) return (value) bounds = [ (0.0, 1.0) ] * input_space.num_dims x_opt, y_opt, opt_info = spo.fmin_l_bfgs_b(f, best, bounds = bounds, disp = 0, approx_grad = True) reference_point[ i ] = -1.0 * y_opt + np.abs(-1.0 * y_opt * 0.01) return reference_point
def main(expt_dir): os.chdir(expt_dir) sys.path.append(expt_dir) options = parse_config_file(expt_dir, 'config.json') experiment_name = options["experiment-name"] options['main_file'] = 'prog_no_noisy' main_file = options['main_file'] if main_file[-3:] == '.py': main_file = main_file[:-3] module = __import__(main_file) input_space = InputSpace(options["variables"]) chooser_module = importlib.import_module('spearmint.choosers.' + options['chooser']) chooser = chooser_module.init(input_space, options) db = MongoDB(database_address=options['database']['address']) jobs = load_jobs(db, experiment_name) hypers = db.load(experiment_name, 'hypers') tasks = parse_tasks_from_jobs(jobs, experiment_name, options, input_space) if len(tasks) < 2: print 'Not a multi-objective problem!' return -1 if options['language'] != "PYTHON": print 'Only python programs supported!' return -1 for task in tasks: if tasks[ task ].type != 'objective': print 'Not a multi-objective problem!' return -1 def create_fun(task): def fun(params, gradient = False): if len(params.shape) > 1 and params.shape[ 1 ] > 1: params = params.flatten() params = input_space.from_unit(np.array([ params ])).flatten() return module.main(0, paramify_no_types(input_space.paramify(params)))[ task ] return fun funs = [ create_fun(task) for task in tasks ] moop = MOOP_basis_functions(funs, input_space.num_dims) # moop.evolve(1, 8) grid = sobol_grid.generate(input_space.num_dims, grid_size = 1000 * input_space.num_dims) moop.solve_using_grid(grid) # reference = find_reference_point_using_direct(tasks, module, input_space) # reference = reference + np.abs(reference) * 0.1 reference = np.ones(len(tasks)) * 7 hyper_volume_solution = moop.get_hypervolume(reference.tolist()) result = moop.compute_pareto_front_and_set() front = result['frontier'] pareto_set = result['pareto_set'] # os.remove('hypervolume_solution.txt') with open('hypervolume_solution.txt', 'a') as f: print >> f, "%lf" % (hyper_volume_solution) # os.remove('hypervolumes.txt') # We iterate through each recommendation made i = 0 more_recommendations = True while more_recommendations: recommendation = db.load(experiment_name, 'recommendations', {'id' : i + 1}) if recommendation == None: more_recommendations = False else: solution = input_space.to_unit(input_space.vectorify(recommendation[ 'params' ])) if len(solution.shape) == 1: solution = solution.reshape((1, len(solution))) # We compute the objective values associated to this recommendation values_solution = np.zeros((solution.shape[ 0 ], len(tasks))) for j in range(values_solution.shape[ 0 ]): for k in range(values_solution.shape[ 1 ]): values_solution[ j, k ] = funs[ k ](solution[ j : (j + 1), : ]) moop = MOOP_basis_functions(funs, input_space.num_dims) moop.set_population(solution) hyper_volume = moop.get_hypervolume(reference.tolist()) with open('hypervolumes.txt', 'a') as f: print >> f, "%lf" % (hyper_volume) with open('mean_min_distance_to_frontier.txt', 'a') as f: print >> f, "%lf" % (average_min_distance(values_solution, front)) with open('mean_min_distance_from_frontier.txt', 'a') as f: print >> f, "%lf" % (average_min_distance(front, values_solution)) with open('mean_min_distance_to_pareto_set.txt', 'a') as f: print >> f, "%lf" % (average_min_distance(input_space.from_unit(solution), \ input_space.from_unit(pareto_set))) with open('mean_min_distance_from_pareto_set.txt', 'a') as f: print >> f, "%lf" % (average_min_distance(input_space.from_unit(pareto_set), \ input_space.from_unit(solution))) with open('evaluations.txt','a') as f_handle: np.savetxt(f_handle, np.array([recommendation['num_complete_tasks'].values()]), delimiter = ' ', newline = '\n') i += 1