def main(): cs = ConfigurationSpace() cell_size = CategoricalHyperparameter("cell_size", [128], default_value=128) # kick up to 256 n_cell = CategoricalHyperparameter("n_cell", [2], default_value=2) dropout = CategoricalHyperparameter("dropout", [0.5], default_value=0.5) activation = CategoricalHyperparameter("activation", ['sigmoid'], default_value='sigmoid') optimizer = CategoricalHyperparameter("optimizer", ['adam'], default_value='adam') optimizer_lr = CategoricalHyperparameter( "optimizer_lr", [.001, .003, .006, .01, 0.03, 0.1], default_value=.01) learning_decay_rate = UniformFloatHyperparameter("learning_decay_rate", 0, 0.9, default_value=.6) nn_type = CategoricalHyperparameter("nn_type", ['RNN', 'LSTM', 'GRU'], default_value='LSTM') epochs = CategoricalHyperparameter("epochs", [10], default_value=10) cs.add_hyperparameters([ cell_size, n_cell, dropout, nn_type, activation, optimizer, optimizer_lr, learning_decay_rate, epochs ]) scenario = Scenario({ "run_obj": "quality", "runcount-limit": 32, "cs": cs, "deterministic": "true" }) scenario.output_dir_for_this_run = "C:\\NNwork\\HFSF\\SMAC3out" scenario.output_dir = "C:\\NNwork\\HFSF\\SMAC3out" smac = SMAC(scenario=scenario, rng=np.random.RandomState(23), tae_runner=rnn_from_cfg) best_model = smac.optimize() print_incumb(best_model) np.save("C:\\NNwork\\HFSF\\SMAC3out\\best.cfg", best_model)
def fit(self, dataset: BinaryDataset, clustering_algs: List[str], feature_selection_algs: List[str], n_evaluations: int = 30, cutoff_time=20, evaluator: Callable = Measures.silhouette, experiments_dir: str = "../../experiments", n_optimizers=2, top_algorithms_count=5) -> List[str]: cs = build_config_space(clustering_ls=clustering_algs, feature_selection_ls=feature_selection_algs) config_name: str = "mixed" if len(clustering_algs) == 1 and len(feature_selection_algs) == 1: config_name: str = f"{feature_selection_algs[0]}_{clustering_algs[0]}" base_dir_name = _create_smac_directory(experiments_dir, evaluator.__name__, config_name) scenario_params: dict = { "run_obj": "quality", "runcount-limit": n_evaluations, "cutoff_time": cutoff_time, "cs": cs, "deterministic": "false", "output_dir": base_dir_name, "abort_on_first_run_crash": False, "shared_model": True, "input_psmac_dirs": _create_psmac_dirs(base_dir_name, n_optimizers) } scenario = Scenario(scenario_params) dataset_content = dataset.load_dataset() def fit_models(cfg: dict, data: np.ndarray): feature_selection_alg = Mapper.get_class(cfg["feature_selection_choice"]) cfg_feature_selection: dict = { decode_parameter(k, feature_selection_alg.name): v for k, v in cfg.items() if decode_parameter(k, feature_selection_alg.name) is not None } feature_selection_model = feature_selection_alg.model(**cfg_feature_selection) selected_data: np.ndarray = feature_selection_model.fit_transform(data) clustering_alg = Mapper.get_class(cfg["clustering_choice"]) cfg_clustering: dict = { decode_parameter(k, clustering_alg.name): v for k, v in cfg.items() if decode_parameter(k, clustering_alg.name) is not None } clustering_model = clustering_alg.model(**cfg_clustering) clustering_result = clustering_model.fit_predict(selected_data) return feature_selection_model, clustering_model, clustering_result def cfg_to_dict(cfg): cfg = {k: cfg[k] for k in cfg if cfg[k]} return {k: v for k, v in cfg.items() if v is not None} def evaluate_model(cfg): cfg_dict = cfg_to_dict(cfg) _, _, y_pred = fit_models(cfg_dict, dataset_content) if len(np.unique(y_pred)) < 2: return np.inf else: return evaluator(dataset_content, y_pred) optimal_config = None smac = SMAC( scenario=scenario, rng=np.random.RandomState(42), tae=evaluate_model, n_optimizers=n_optimizers, validate=False, n_incs=top_algorithms_count ) # for some reason smac sets output dir to None in constructor, so we inject it manually smac.output_dir = base_dir_name scenario.output_dir = base_dir_name self._smac = smac optimal_configs: List[Configuration] = self._smac.optimize() best_algorithms: List[str] = [] for i, optimal_config in enumerate(optimal_configs): dict_config = cfg_to_dict(optimal_config) feature_selection_model, clustering_model, clustering_result = \ fit_models(dict_config, dataset_content) if len(np.unique(clustering_result)) < 2: measure_value = np.inf else: measure_value = evaluator(dataset_content, clustering_result) result = { "optimal_config": dict_config, "smac": self._smac, "feature_selection_model": feature_selection_model, "clustering_model": clustering_model, "clustering_result": clustering_result, "measure_value": measure_value } _save_clustering_result(result, f"{base_dir_name}", name=f"config_{i}") best_algorithms.append(_encode(dict_config["clustering_choice"], dict_config["feature_selection_choice"])) _save_best_algorithms(experiments_dir, best_algorithms, clustering_algs, feature_selection_algs) return best_algorithms
default_value=2) optimizer = CategoricalHyperparameter("optimizer", ['adam', 'sgd', 'nadam', 'RMSprop'], default_value='RMSprop') optimizer_lr = CategoricalHyperparameter("optimizer_lr", [.0001, .0003, .001, .003, .01], default_value=.0003) learning_decay_rate = UniformFloatHyperparameter("learning_decay_rate", 0, 0.9, default_value=.6) cs.add_hyperparameters([ first_kernel_size, conv_filters, n_conv, dropout, activation, dense_width, dense_length, optimizer, optimizer_lr, learning_decay_rate ]) scenario = Scenario({ "run_obj": "quality", "runcount-limit": 128, "cs": cs, "deterministic": "true" }) scenario.output_dir_for_this_run = "C:\\NNwork\\SMAC3out" scenario.output_dir = "C:\\NNwork\\SMAC3out" smac = SMAC(scenario=scenario, rng=np.random.RandomState(23), tae_runner=cnn_from_cfg) print_incumb(smac.optimize())