def test_name_flattening(self): num_tests = 1000 for i in range(num_tests): random_config = self.cache_param_space.random() flat_dimensions = [] for dimension_name, value in random_config: original_dimension = self.cache_param_space[dimension_name] flat_dimension = original_dimension.copy() flat_dimension.name = Dimension.flatten_dimension_name( dimension_name) flat_dimensions.append(flat_dimension) # Let's create a flat hypergrid that contains that random_config flat_cache_param_space = SimpleHypergrid( name=f"Flat{self.cache_param_space.name}", dimensions=flat_dimensions) flat_random_config = random_config.flat_copy() self.assertTrue(flat_random_config in flat_cache_param_space) # let's try another random config another_random_config = self.cache_param_space.random() flattened_config = another_random_config.flat_copy() try: if flattened_config in flat_cache_param_space: ... self.assertTrue(True) except: self.assertTrue(False)
def __init__(self, adaptee: Hypergrid): HypergridAdapter.__init__(self, name=adaptee.name, random_state=adaptee.random_state) self._adaptee: Hypergrid = adaptee self._target: SimpleHypergrid = None self._forward_name_mapping = dict() self._backward_name_mapping = dict() if HypergridAdapter.is_like_simple_hypergrid(self._adaptee): # Need to flatten all the names target_dimensions = [] for adaptee_dimension in self._adaptee.dimensions: target_dimension_name = Dimension.flatten_dimension_name( adaptee_dimension.name) self._forward_name_mapping[ adaptee_dimension.name] = target_dimension_name self._backward_name_mapping[ target_dimension_name] = adaptee_dimension.name target_dimension = adaptee_dimension.copy() target_dimension.name = target_dimension_name target_dimensions.append(target_dimension) self._target = SimpleHypergrid(name=self._adaptee.name, dimensions=target_dimensions) else: raise TypeError( f"Cannot build CompositeToSImpleHypergridAdapter for object of type {type(self._adaptee)}." )
def suggest(self, random=False, context=None): # pylint: disable=redefined-outer-name,unused-argument suggested_params = None if random: suggested_params = self.current_search_space.random().to_dict() else: if not self.focused: self._optimizer._space._bounds = self._format_parameter_bounds( self._full_parameter_space_bounds) else: self._optimizer._space._bounds = self._format_parameter_bounds( self._focused_parameter_space_bounds) suggested_params = self._optimizer.suggest( utility_function=self._utility_function) for param_name, param_value in suggested_params.items(): param_dimension = self.feature_space[param_name] if isinstance(param_dimension, DiscreteDimension): # we need to round the parameter suggested_params[param_name] = int(round(param_value)) elif isinstance(param_dimension, CategoricalDimension): # we need to round and index into the dimension suggested_params[param_name] = param_dimension[int( round(param_value))] # we also have to remove the parameter root grid name param_names = [ param_name for param_name in suggested_params.keys() ] for param_name in param_names: _, param_name_without_subgrid_name = Dimension.split_dimension_name( param_name) suggested_params[ param_name_without_subgrid_name] = suggested_params[ param_name] del suggested_params[param_name] retries_remaining = 100 while retries_remaining > 0 and (suggested_params in self._registered_param_combos): suggested_params = self.current_search_space.random().to_dict() retries_remaining -= 1 assert Point(**suggested_params) in self.parameter_space return suggested_params
def _create_random_flat_subspace(original_space, subspace_name, max_num_dimensions): """ Creates a random simple hypergrid from the hypergrid with up to max_num_dimensions dimensions. TODO: move this to the *Hypergrid classes. :param original_space: :return: """ random_point = original_space.random() dimensions_for_point = original_space.get_dimensions_for_point(random_point, return_join_dimensions=False) selected_dimensions = random.sample(dimensions_for_point, min(len(dimensions_for_point), max_num_dimensions)) flat_dimensions = [] for dimension in selected_dimensions: flat_dimension = dimension.copy() flat_dimension.name = Dimension.flatten_dimension_name(flat_dimension.name) flat_dimensions.append(flat_dimension) flat_hypergrid = SimpleHypergrid( name=subspace_name, dimensions=flat_dimensions ) return flat_hypergrid
def __init__( self, model_config: RegressionEnhancedRandomForestRegressionModelConfig, input_space: Hypergrid, output_space: Hypergrid, logger=None ): if logger is None: logger = create_logger("RegressionEnhancedRandomForestRegressionModel") self.logger = logger assert RegressionEnhancedRandomForestRegressionModelConfig.contains(model_config) RegressionModel.__init__( self, model_type=type(self), model_config=model_config, input_space=input_space, output_space=output_space ) self.input_dimension_names = [dimension.name for dimension in self.input_space.dimensions] self.output_dimension_names = [dimension.name for dimension in self.output_space.dimensions] self._input_space_dimension_name_mappings = { dimension.name: Dimension.flatten_dimension_name(dimension.name) for dimension in self.input_space.dimensions } self._output_space_dimension_name_mappings = { dimension.name: Dimension.flatten_dimension_name(dimension.name) for dimension in self.output_space.dimensions } self.base_regressor_ = None self.base_regressor_config = dict() self.base_regressor_config = self.model_config.boosting_root_model_config if self.model_config.boosting_root_model_name == SklearnLassoRegressionModelConfig.__name__: self.base_regressor_ = linear_model.Lasso( alpha=self.base_regressor_config.alpha, fit_intercept=self.base_regressor_config.fit_intercept, normalize=self.base_regressor_config.normalize, precompute=self.base_regressor_config.precompute, copy_X=self.base_regressor_config.copy_x, max_iter=self.base_regressor_config.max_iter, tol=self.base_regressor_config.tol, warm_start=self.base_regressor_config.warm_start, positive=self.base_regressor_config.positive, random_state=self.base_regressor_config.random_state, selection=self.base_regressor_config.selection ) elif self.model_config.boosting_root_model_name == SklearnRidgeRegressionModelConfig.__name__: self.base_regressor_ = linear_model.Ridge( alpha=self.base_regressor_config.alpha, fit_intercept=self.base_regressor_config.fit_intercept, normalize=self.base_regressor_config.normalize, copy_X=self.base_regressor_config.copy_x, max_iter=self.base_regressor_config.max_iter, tol=self.base_regressor_config.tol, random_state=self.base_regressor_config.random_state, solver=self.base_regressor_config.solver ) else: self.logger('Boosting base model name "{0}" not supported currently.' \ .format(self.model_config.boosting_root_model_name)) rf_config = self.model_config.random_forest_model_config self.random_forest_regressor_ = RandomForestRegressor( n_estimators=rf_config.n_estimators, criterion=rf_config.criterion, max_depth=rf_config.max_depth_value, min_samples_split=rf_config.min_samples_split, min_samples_leaf=rf_config.min_samples_leaf, min_weight_fraction_leaf=rf_config.min_weight_fraction_leaf, max_features=rf_config.max_features, max_leaf_nodes=rf_config.max_leaf_nodes_value, min_impurity_decrease=rf_config.min_impurity_decrease, bootstrap=rf_config.bootstrap, oob_score=rf_config.oob_score, n_jobs=rf_config.n_jobs, warm_start=rf_config.warm_start, ccp_alpha=rf_config.ccp_alpha, max_samples=rf_config.max_sample_value ) # set up basis feature transform self.polynomial_features_transform_ = None if self.model_config.max_basis_function_degree > 1: self.polynomial_features_transform_ = \ PolynomialFeatures(degree=self.model_config.max_basis_function_degree) self.random_forest_kwargs = None self.root_model_kwargs = None self.detected_feature_indices_ = None self.screening_root_model_coef_ = None self.fit_X_ = None self.partial_hat_matrix_ = None self.base_regressor_standard_error_ = None self.dof_ = None self.variance_estimate_ = None self.root_model_gradient_coef_ = None