def _decode(self, value): if self._allow_none and value is None: return None if isinstance(value, str): return locate(value) return value
def plot(args, experiment=None): """ febo plot """ if experiment is None: path = os.path.join(main_config.experiment_dir, args.experiment) load_config(os.path.join(path, 'experiment.yaml')) experiment = main_config.experiment(main_config.experiment_dir) experiment.load(args.experiment) if args.plots is None or len(args.plots) == 0: logger.warning('No plots specified. Use "--plots path.to.PlottingClass1 path.to.PlottingClass2" to specify plots.') for plot_class in args.plots: plot_class = plot_class.split(':') plot = None try: plot = locate(plot_class[0]) except: logger.error(f'Could not locate {plot_class}') if plot is not None: plot = plot(experiment) group_id = None if len(plot_class) > 1 and plot_class[1]: group_id = int(plot_class[1]) run_id = None if len(plot_class) > 2 and plot_class[2]: run_id = int(plot_class[2]) plot.plot(show=True, group_id=group_id, run_id=run_id)
def _init_noise_function(self): """""" if self.config.noise_function: # if self.config.noise_function is a number if isinstance(self.config.noise_function, (float, int)): noise_var = self.config.noise_function # define noise _function def noise_function(x): x = np.atleast_2d(x) return noise_var * np.ones(shape=(x.shape[0], 1)) elif isinstance(self.config.noise_function, str): noise_function = locate(self.config.noise_function) else: raise Exception("Invalid setting for 'noise_function'.") # if noise_function is a function, assume it provides std for GaussianNoiseFunction if isinstance(noise_function, FunctionType): self._noise_function_cls = type( f"__{noise_function.__name__}_Noise", (GaussianNoiseFunction, ), { 'std': lambda self, x: noise_function(x) }) elif issubclass(noise_function, NoiseFunction): self._noise_function_cls = noise_function else: self._noise_function_cls = NoiseFunction self._noise_function = self._noise_function_cls(self._domain, self.f)
def _decode(self, value): if self._allow_none and value is None: return None list_decoded = [] for item in value: if isinstance(item, str): list_decoded.append(locate(item)) else: list_decoded.append(item) return list_decoded
def register_modules(config_manager): """ Registers modules as given by MainConfig with the config_manager. Args: config_manager: """ for m in main_config.modules: if isinstance(m, str): m = locate(m) config_manager.register(m) logger.info(f'Registered module "{m.__name__}".')
def _get_kernel(self): kernel = None for kernel_module, kernel_params in self.config.kernels: input_dim = self.domain.d if 'active_dims' in kernel_params: input_dim = len(kernel_params['active_dims']) kernel_part = locate(kernel_module)(input_dim=input_dim, **kernel_params) if kernel is None: kernel = kernel_part else: kernel += kernel_part return kernel
def __init__(self, domain): super().__init__(domain) self._beta_function = None if not self.config.beta is None: if isinstance(self.config.beta, str): self._beta_function = locate(self.config.beta) self.__beta = self.__beta_function logger.info(f"Using beta function={self.config.beta} .") elif isinstance(self.config.beta, (int, float)): def _beta(): return self.config.beta self.__beta = _beta logger.info(f"Using beta={self.config.beta} .")
def finalize(self, *args, **kwargs): res = super().finalize(*args, **kwargs) for plot_cls in self.config.plots: try: plot = locate(plot_cls) plot = plot(self.experiment) plot.plot(show=False, group_id=self.group_id, run_id=self.run_id) except Exception as e: logger.error(f'Error {str(e)} while plotting {plot_cls}') logger.info( f"Here is the stack trace:\n{traceback.format_exc()} ") return res
def aggregate(args, experiment=None): """ febo aggregate """ if experiment is None: path = os.path.join(main_config.experiment_dir, args.experiment) load_config(os.path.join(path, 'experiment.yaml')) experiment = main_config.experiment(main_config.experiment_dir) experiment.load(args.experiment) for cls in args.aggregator: aggr = locate(cls) aggr(experiment)
def initialize(self, **kwargs): super(SubDomainBO, self).initialize(**kwargs) self._best_x = self.x0.copy() self._best_direction = None self._phase = 'best' self._iteration = 0 self._parameter_names = kwargs.get('parameter_names') self._max_queries_line = dimension_setting_helper(self.config.max_queries_line, self.domain.d) self._min_queries_line = dimension_setting_helper(self.config.min_queries_line, self.domain.d) self._max_queries_tr = dimension_setting_helper(self.config.max_queries_tr, self.domain.d) self._minx_queries_tr = dimension_setting_helper(self.config.min_queries_tr, self.domain.d) self._point_type_addition = '' self.__acquisition = locate(self.config.acquisition)
def _decode(self, value): if isinstance(value, str): value = locate(value)() decoded_list = [] for benchmark in value: benchmark_settings = {} for section, settings in benchmark.items(): # support for flattend syntax '{section:setting : value }' if ':' in section: section, setting = section.rsplit(':') settings = { setting : settings} for setting, value in settings.items(): if not section in benchmark_settings: benchmark_settings[section] = {} if section in config_manager._fields and setting in config_manager._fields[section]: field = config_manager._fields[section][setting] benchmark_settings[section][setting] = field._encode(value) decoded_list.append(benchmark_settings) return decoded_list
def register_modules(modules): for m in modules: if isinstance(m, str): m = locate(m) config_manager.register(m) logger.info(f'Registered module "{m.__name__}".')