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())
