def _setup_zoopt(self): if self._metric is None and self._mode: # If only a mode was passed, use anonymous metric self._metric = DEFAULT_METRIC _dim_list = [] for k in self._dim_dict: self._dim_keys.append(k) _dim_list.append(self._dim_dict[k]) init_samples = None if self._points_to_evaluate: logger.warning( "`points_to_evaluate` seems to be ignored by ZOOpt.") init_samples = [ Solution(x=tuple(point[dim] for dim in self._dim_keys)) for point in self._points_to_evaluate ] dim = zoopt.Dimension2(_dim_list) par = zoopt.Parameter(budget=self._budget, init_samples=init_samples) if self._algo == "sracos" or self._algo == "asracos": from zoopt.algos.opt_algorithms.racos.sracos import SRacosTune self.optimizer = SRacosTune(dimension=dim, parameter=par, parallel_num=self.parallel_num, **self.kwargs) if init_samples: self.optimizer.init_attribute()
def minimize(self, cost_function, initial_params): '''minimize using the zeroth order optimization algorithm Args: cost function: the function to minized. initial_params: starting point for the optimization process. Returns: tuple: optimization results dict and the optimized parameters. ''' def zoopt_help_function(self, solution): params = solution.get_x() value = cost_function(params) history.append({'params': params, 'value': value}) print(f'Function evaluation {len(history)}: {value}', flush=True) print(f'{params}', flush=True) return value dim_size = np.shape(initial_params) range_dim = [[]]*dim_size min_bounds = [-np.pi for _ in range(dim_size)] max_bounds = [np.pi for _ in range(dim_size)] for i in range(dim_size): range_dim[i] = [min_bounds[i],max_bounds[i]] dim = zoopt.Dimension(dim_size, range_dim, [True]*dim_size) objective = zoopt.Objective(zoopt_help_function,dim) par = zoopt.Parameter(budget = self.iterations) result = zoopt.Opt.min(objective, par) optimization_results = {} optimization_results['opt_value'] = result.get_value() optimization_results['opt_params'] = result.get_x() optimization_results['history'] = history
def setup_zoopt(self): _dim_list = [] for k in self._dim_dict: self._dim_keys.append(k) _dim_list.append(self._dim_dict[k]) dim = zoopt.Dimension2(_dim_list) par = zoopt.Parameter(budget=self._budget) if self._algo == "sracos" or self._algo == "asracos": from zoopt.algos.opt_algorithms.racos.sracos import SRacosTune self.optimizer = SRacosTune(dimension=dim, parameter=par)
def _setup_zoopt(self): if self._metric is None and self._mode: # If only a mode was passed, use anonymous metric self._metric = DEFAULT_METRIC _dim_list = [] for k in self._dim_dict: self._dim_keys.append(k) _dim_list.append(self._dim_dict[k]) dim = zoopt.Dimension2(_dim_list) par = zoopt.Parameter(budget=self._budget) if self._algo == "sracos" or self._algo == "asracos": from zoopt.algos.opt_algorithms.racos.sracos import SRacosTune self.optimizer = SRacosTune( dimension=dim, parameter=par, **self.kwargs)
def __init__(self, algo="asracos", budget=None, dim_dict=None, max_concurrent=10, metric="episode_reward_mean", mode="min", **kwargs): assert zoopt is not None, "Zoopt not found - please install zoopt." 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 = zoopt.Dimension2(_dim_list) par = zoopt.Parameter(budget=budget) if _algo == "sracos" or _algo == "asracos": from zoopt.algos.opt_algorithms.racos.sracos import SRacosTune self.optimizer = SRacosTune(dimension=dim, parameter=par) self.solution_dict = {} self.best_solution_list = [] super(ZOOptSearch, self).__init__( metric=self._metric, mode=mode, **kwargs)