Coverage for sparkle/platform/settings_objects.py: 72%
1163 statements
« prev ^ index » next coverage.py v7.6.12, created at 2025-03-05 13:48 +0000
1"""Classes and Enums to control settings."""
2from __future__ import annotations
3import configparser
4from enum import Enum
5import ast
6from pathlib import Path
7from pathlib import PurePath
9from runrunner import Runner
11from sparkle.types import SparkleObjective, resolve_objective
12from sparkle.types.objective import PAR
13from sparkle.configurator.configurator import Configurator
14from sparkle.configurator import implementations as cim
15from sparkle.platform.cli_types import VerbosityLevel
18class SettingState(Enum):
19 """Enum of possible setting states."""
21 NOT_SET = 0
22 DEFAULT = 1
23 FILE = 2
24 CMD_LINE = 3
27class Settings:
28 """Class to read, write, set, and get settings."""
29 # CWD Prefix
30 cwd_prefix = Path() # Empty for now
32 # Library prefix
33 lib_prefix = Path(__file__).parent.parent.resolve()
35 # Default directory names
36 rawdata_dir = Path("Raw_Data")
37 analysis_dir = Path("Analysis")
38 DEFAULT_settings_dir = Path("Settings")
39 __settings_file = Path("sparkle_settings.ini")
41 # Default settings path
42 DEFAULT_settings_path = PurePath(cwd_prefix / DEFAULT_settings_dir / __settings_file)
43 DEFAULT_reference_dir = DEFAULT_settings_dir / "Reference_Lists"
45 # Default library pathing
46 DEFAULT_components = lib_prefix / "Components"
48 # Example settings path
49 DEFAULT_example_settings_path = PurePath(DEFAULT_components / "sparkle_settings.ini")
51 # Runsolver component
52 DEFAULT_runsolver_dir = DEFAULT_components / "runsolver" / "src"
53 DEFAULT_runsolver_exec = DEFAULT_runsolver_dir / "runsolver"
55 # Ablation component
56 DEFAULT_ablation_dir = DEFAULT_components / "ablationAnalysis-0.9.4"
57 DEFAULT_ablation_exec = DEFAULT_ablation_dir / "ablationAnalysis"
58 DEFAULT_ablation_validation_exec = DEFAULT_ablation_dir / "ablationValidation"
60 # Report component
61 DEFAULT_latex_source = DEFAULT_components / "Sparkle-latex-source"
62 DEFAULT_latex_bib = DEFAULT_latex_source / "SparkleReport.bib"
64 # Default input directory pathing
65 DEFAULT_solver_dir = cwd_prefix / "Solvers"
66 DEFAULT_instance_dir = cwd_prefix / "Instances"
67 DEFAULT_extractor_dir = cwd_prefix / "Extractors"
68 DEFAULT_snapshot_dir = cwd_prefix / "Snapshots"
70 # Default output directory pathing
71 DEFAULT_tmp_output = cwd_prefix / "Tmp"
72 DEFAULT_output = cwd_prefix / "Output"
73 DEFAULT_configuration_output = DEFAULT_output / "Configuration"
74 DEFAULT_selection_output = DEFAULT_output / "Selection"
75 DEFAULT_parallel_portfolio_output = DEFAULT_output / "Parallel_Portfolio"
76 DEFAULT_ablation_output = DEFAULT_output / "Ablation"
77 DEFAULT_log_output = DEFAULT_output / "Log"
79 # Default output subdirs
80 DEFAULT_configuration_output_raw = DEFAULT_configuration_output / rawdata_dir
81 DEFAULT_configuration_output_analysis = DEFAULT_configuration_output / analysis_dir
82 DEFAULT_selection_output_raw = DEFAULT_selection_output / rawdata_dir
83 DEFAULT_selection_output_analysis = DEFAULT_selection_output / analysis_dir
84 DEFAULT_parallel_portfolio_output_raw =\
85 DEFAULT_parallel_portfolio_output / rawdata_dir
86 DEFAULT_parallel_portfolio_output_analysis =\
87 DEFAULT_parallel_portfolio_output / analysis_dir
89 # Old default output dirs which should be part of something else
90 DEFAULT_feature_data = DEFAULT_output / "Feature_Data"
91 DEFAULT_performance_data = DEFAULT_output / "Performance_Data"
93 # Collection of all working dirs for platform
94 DEFAULT_working_dirs = [
95 DEFAULT_solver_dir, DEFAULT_instance_dir, DEFAULT_extractor_dir,
96 DEFAULT_output, DEFAULT_configuration_output,
97 DEFAULT_selection_output,
98 DEFAULT_tmp_output, DEFAULT_log_output,
99 DEFAULT_feature_data, DEFAULT_performance_data,
100 DEFAULT_settings_dir, DEFAULT_reference_dir,
101 ]
103 # Old default file paths from GV which should be turned into variables
104 DEFAULT_feature_data_path =\
105 DEFAULT_feature_data / "feature_data.csv"
106 DEFAULT_performance_data_path =\
107 DEFAULT_performance_data / "performance_data.csv"
109 # Constant default values
110 DEFAULT_general_sparkle_objective = PAR(10)
111 DEFAULT_general_sparkle_configurator = cim.SMAC2.__name__
112 DEFAULT_general_target_cutoff_time = 60
113 DEFAULT_general_extractor_cutoff_time = 60
114 DEFAULT_number_of_jobs_in_parallel = 25
115 DEFAULT_general_verbosity = VerbosityLevel.STANDARD
116 DEFAULT_general_check_interval = 10
117 DEFAULT_general_run_on = "local"
119 DEFAULT_configurator_number_of_runs = 25
120 DEFAULT_configurator_solver_calls = 100
121 DEFAULT_configurator_maximum_iterations = None
123 # Default SMAC2 settings
124 DEFAULT_smac2_wallclock_time = None
125 DEFAULT_smac2_cpu_time = None
126 DEFAULT_smac2_target_cutoff_length = "max"
127 DEFAULT_smac2_use_cpu_time_in_tunertime = None
128 DEFAULT_smac2_cli_cores = None
129 DEFAULT_smac2_max_iterations = None
131 # Default SMAC3 settings
132 DEFAULT_smac3_number_of_runs = None
133 DEFAULT_smac3_facade = "AlgorithmConfigurationFacade"
134 DEFAULT_smac3_facade_max_ratio = None
135 DEFAULT_smac3_crash_cost = None
136 DEFAULT_smac3_termination_cost_threshold = None
137 DEFAULT_smac3_walltime_limit = None
138 DEFAULT_smac3_cputime_limit = None
139 DEFAULT_smac3_use_default_config = None
140 DEFAULT_smac3_min_budget = None
141 DEFAULT_smac3_max_budget = None
143 # Default IRACE settings
144 DEFAULT_irace_max_time = 0 # IRACE equivalent of None in this case
145 DEFAULT_irace_max_experiments = 0
146 DEFAULT_irace_first_test = None
147 DEFAULT_irace_mu = None
148 DEFAULT_irace_max_iterations = None
150 # Default ParamILS settings
151 DEFAULT_paramils_focused_ils = False
152 DEFAULT_paramils_tuner_timeout = None
153 DEFAULT_paramils_focused_approach = None
154 DEFAULT_paramils_min_runs = None
155 DEFAULT_paramils_max_runs = None
156 DEFAULT_paramils_random_restart = None
157 DEFAULT_paramils_initial_configurations = None
158 DEFAULT_paramils_use_cpu_time_in_tunertime = None
159 DEFAULT_paramils_cli_cores = None
160 DEFAULT_paramils_max_iterations = None
162 DEFAULT_slurm_max_parallel_runs_per_node = 8
163 DEFAULT_slurm_job_submission_limit = None
164 DEFAULT_slurm_job_prepend = ""
166 DEFAULT_ablation_racing = False
168 DEFAULT_parallel_portfolio_check_interval = 4
169 DEFAULT_parallel_portfolio_num_seeds_per_solver = 1
171 # Default selection settings
172 DEFAULT_selector_class = "MultiClassClassifier"
173 DEFAULT_selector_model = "RandomForestClassifier"
175 def __init__(self: Settings, file_path: PurePath = None) -> None:
176 """Initialise a settings object."""
177 # Settings 'dictionary' in configparser format
178 self.__settings = configparser.ConfigParser()
180 # Setting flags
181 self.__general_sparkle_objective_set = SettingState.NOT_SET
182 self.__general_sparkle_configurator_set = SettingState.NOT_SET
183 self.__general_target_cutoff_time_set = SettingState.NOT_SET
184 self.__general_extractor_cutoff_time_set = SettingState.NOT_SET
185 self.__general_verbosity_set = SettingState.NOT_SET
186 self.__general_check_interval_set = SettingState.NOT_SET
188 self.__config_solver_calls_set = SettingState.NOT_SET
189 self.__config_number_of_runs_set = SettingState.NOT_SET
190 self.__config_max_iterations_set = SettingState.NOT_SET
192 self.__smac2_wallclock_time_set = SettingState.NOT_SET
193 self.__smac2_cpu_time_set = SettingState.NOT_SET
194 self.__smac2_use_cpu_time_in_tunertime_set = SettingState.NOT_SET
195 self.__smac2_cli_cores_set = SettingState.NOT_SET
196 self.__smac2_max_iterations_set = SettingState.NOT_SET
197 self.__smac2_target_cutoff_length_set = SettingState.NOT_SET
199 self.__smac3_number_of_trials_set = SettingState.NOT_SET
200 self.__smac3_smac_facade_set = SettingState.NOT_SET
201 self.__smac3_facade_max_ratio_set = SettingState.NOT_SET
202 self.__smac3_crash_cost_set = SettingState.NOT_SET
203 self.__smac3_termination_cost_threshold_set = SettingState.NOT_SET
204 self.__smac3_walltime_limit_set = SettingState.NOT_SET
205 self.__smac3_cputime_limit_set = SettingState.NOT_SET
206 self.__smac3_use_default_config_set = SettingState.NOT_SET
207 self.__smac3_min_budget_set = SettingState.NOT_SET
208 self.__smac3_max_budget_set = SettingState.NOT_SET
210 self.__irace_max_time_set = SettingState.NOT_SET
211 self.__irace_max_experiments_set = SettingState.NOT_SET
212 self.__irace_first_test_set = SettingState.NOT_SET
213 self.__irace_mu_set = SettingState.NOT_SET
214 self.__irace_max_iterations_set = SettingState.NOT_SET
216 self.__paramils_min_runs_set = SettingState.NOT_SET
217 self.__paramils_max_runs_set = SettingState.NOT_SET
218 self.__paramils_tuner_timeout_set = SettingState.NOT_SET
219 self.__paramils_focused_approach_set = SettingState.NOT_SET
220 self.__paramils_random_restart_set = SettingState.NOT_SET
221 self.__paramils_initial_configurations_set = SettingState.NOT_SET
222 self.__paramils_use_cpu_time_in_tunertime_set = SettingState.NOT_SET
223 self.__paramils_cli_cores_set = SettingState.NOT_SET
224 self.__paramils_max_iterations_set = SettingState.NOT_SET
226 self.__run_on_set = SettingState.NOT_SET
227 self.__number_of_jobs_in_parallel_set = SettingState.NOT_SET
228 self.__ablation_racing_flag_set = SettingState.NOT_SET
230 self.__parallel_portfolio_check_interval_set = SettingState.NOT_SET
231 self.__parallel_portfolio_num_seeds_per_solver_set = SettingState.NOT_SET
233 self.__selection_model_set = SettingState.NOT_SET
234 self.__selection_class_set = SettingState.NOT_SET
236 self.__slurm_max_parallel_runs_per_node_set = SettingState.NOT_SET
237 self.__slurm_job_prepend_set = SettingState.NOT_SET
238 self.__slurm_job_submission_limit_set = SettingState.NOT_SET
240 self.__general_sparkle_configurator = None
242 self.__slurm_extra_options_set = dict()
244 if file_path is None:
245 # Initialise settings from default file path
246 self.read_settings_ini()
247 else:
248 # Initialise settings from a given file path
249 self.read_settings_ini(file_path)
251 def read_settings_ini(self: Settings, file_path: PurePath = DEFAULT_settings_path,
252 state: SettingState = SettingState.FILE) -> None:
253 """Read the settings from an INI file."""
254 # Read file
255 file_settings = configparser.ConfigParser()
256 file_settings.read(file_path)
258 # Set internal settings based on data read from FILE if they were read
259 # successfully
260 if file_settings.sections() != []:
261 section = "general"
262 option_names = ("objectives", )
263 for option in option_names:
264 if file_settings.has_option(section, option):
265 value = [resolve_objective(obj) for obj in
266 file_settings.get(section, option).split(",")]
267 self.set_general_sparkle_objectives(value, state)
268 file_settings.remove_option(section, option)
270 # Comma so python understands it's a tuple...
271 option_names = ("configurator", )
272 for option in option_names:
273 if file_settings.has_option(section, option):
274 value = file_settings.get(section, option)
275 self.set_general_sparkle_configurator(value, state)
276 file_settings.remove_option(section, option)
278 option_names = ("target_cutoff_time",
279 "cutoff_time_each_solver_call")
280 for option in option_names:
281 if file_settings.has_option(section, option):
282 value = file_settings.getint(section, option)
283 self.set_general_target_cutoff_time(value, state)
284 file_settings.remove_option(section, option)
286 option_names = ("extractor_cutoff_time",
287 "cutoff_time_each_feature_computation")
288 for option in option_names:
289 if file_settings.has_option(section, option):
290 value = file_settings.getint(section, option)
291 self.set_general_extractor_cutoff_time(value, state)
292 file_settings.remove_option(section, option)
294 option_names = ("run_on", )
295 for option in option_names:
296 if file_settings.has_option(section, option):
297 value = file_settings.get(section, option)
298 self.set_run_on(value, state)
299 file_settings.remove_option(section, option)
301 option_names = ("verbosity", )
302 for option in option_names:
303 if file_settings.has_option(section, option):
304 value = VerbosityLevel.from_string(
305 file_settings.get(section, option))
306 self.set_general_verbosity(value, state)
307 file_settings.remove_option(section, option)
309 option_names = ("check_interval", )
310 for option in option_names:
311 if file_settings.has_option(section, option):
312 value = int(file_settings.get(section, option))
313 self.set_general_check_interval(value, state)
314 file_settings.remove_option(section, option)
316 section = "configuration"
317 option_names = ("solver_calls", )
318 for option in option_names:
319 if file_settings.has_option(section, option):
320 value = file_settings.getint(section, option)
321 self.set_configurator_solver_calls(value, state)
322 file_settings.remove_option(section, option)
324 option_names = ("number_of_runs", )
325 for option in option_names:
326 if file_settings.has_option(section, option):
327 value = file_settings.getint(section, option)
328 self.set_configurator_number_of_runs(value, state)
329 file_settings.remove_option(section, option)
331 option_name = "max_iterations"
332 if file_settings.has_option(section, option_name):
333 value = file_settings.getint(section, option_name)
334 self.set_configurator_max_iterations(value, state)
335 file_settings.remove_option(section, option_name)
337 section = "smac2"
338 option_names = ("wallclock_time", )
339 for option in option_names:
340 if file_settings.has_option(section, option):
341 value = file_settings.getint(section, option)
342 self.set_smac2_wallclock_time(value, state)
343 file_settings.remove_option(section, option)
345 option_names = ("cpu_time", )
346 for option in option_names:
347 if file_settings.has_option(section, option):
348 value = file_settings.getint(section, option)
349 self.set_smac2_cpu_time(value, state)
350 file_settings.remove_option(section, option)
352 option_names = ("target_cutoff_length", "each_run_cutoff_length")
353 for option in option_names:
354 if file_settings.has_option(section, option):
355 value = file_settings.get(section, option)
356 self.set_smac2_target_cutoff_length(value, state)
357 file_settings.remove_option(section, option)
359 option_names = ("use_cpu_time_in_tunertime", "countSMACTimeAsTunerTime")
360 for option in option_names:
361 if file_settings.has_option(section, option):
362 value = file_settings.getboolean(section, option)
363 self.set_smac2_use_cpu_time_in_tunertime(value, state)
364 file_settings.remove_option(section, option)
366 option_names = ("cli_cores", )
367 for option in option_names:
368 if file_settings.has_option(section, option):
369 value = file_settings.getint(section, option)
370 self.set_smac2_cli_cores(value, state)
371 file_settings.remove_option(section, option)
373 options_names = ("iteration_limit", "numIterations", "numberOfIterations",
374 "max_iterations")
375 for option in options_names:
376 if file_settings.has_option(section, option):
377 value = file_settings.getint(section, option)
378 self.set_smac2_max_iterations(value, state)
379 file_settings.remove_option(section, option)
381 section = "smac3"
383 option_names = ("n_trials", "number_of_trials", "solver_calls")
384 for option in option_names:
385 if file_settings.has_option(section, option):
386 value = file_settings.getint(section, option)
387 self.set_smac3_number_of_trials(value, state)
388 file_settings.remove_option(section, option)
390 options_names = ("facade", "smac_facade", "smac3_facade")
391 for option in options_names:
392 if file_settings.has_option(section, option):
393 value = file_settings.get(section, option)
394 self.set_smac3_smac_facade(value, state)
395 file_settings.remove_option(section, option)
397 option_names = ("max_ratio", "facade_max_ratio", "initial_trials_max_ratio")
398 for option in option_names:
399 if file_settings.has_option(section, option):
400 value = file_settings.getfloat(section, option)
401 self.set_smac3_facade_max_ratio(value, state)
402 file_settings.remove_option(section, option)
404 options_names = ("crash_cost", )
405 for option in options_names:
406 if file_settings.has_option(section, option):
407 value = file_settings.get(section, option)
408 self.set_smac3_crash_cost(value, state)
409 file_settings.remove_option(section, option)
411 options_names = ("termination_cost_threshold", )
412 for option in options_names:
413 if file_settings.has_option(section, option):
414 value = file_settings.get(section, option)
415 self.set_smac3_termination_cost_threshold(value, state)
416 file_settings.remove_option(section, option)
418 options_names = ("walltime_limit", "wallclock_time")
419 for option in options_names:
420 if file_settings.has_option(section, option):
421 value = file_settings.getfloat(section, option)
422 self.set_smac3_walltime_limit(value, state)
423 file_settings.remove_option(section, option)
425 options_names = ("cputime_limit", )
426 for option in options_names:
427 if file_settings.has_option(section, option):
428 value = file_settings.getfloat(section, option)
429 self.set_smac3_cputime_limit(value, state)
430 file_settings.remove_option(section, option)
432 options_names = ("use_default_config", )
433 for option in options_names:
434 if file_settings.has_option(section, option):
435 value = file_settings.getboolean(section, option)
436 self.set_smac3_use_default_config(value, state)
437 file_settings.remove_option(section, option)
439 options_names = ("min_budget", )
440 for option in options_names:
441 if file_settings.has_option(section, option):
442 value = file_settings.getfloat(section, option)
443 self.set_smac3_min_budget(value, state)
444 file_settings.remove_option(section, option)
446 options_names = ("max_budget", )
447 for option in options_names:
448 if file_settings.has_option(section, option):
449 value = file_settings.getfloat(section, option)
450 self.set_smac3_max_budget(value, state)
451 file_settings.remove_option(section, option)
453 section = "irace"
454 option_names = ("max_time", )
455 for option in option_names:
456 if file_settings.has_option(section, option):
457 value = file_settings.getint(section, option)
458 self.set_irace_max_time(value, state)
459 file_settings.remove_option(section, option)
461 option_names = ("max_experiments", )
462 for option in option_names:
463 if file_settings.has_option(section, option):
464 value = file_settings.getint(section, option)
465 self.set_irace_max_experiments(value, state)
466 file_settings.remove_option(section, option)
468 option_names = ("first_test", )
469 for option in option_names:
470 if file_settings.has_option(section, option):
471 value = file_settings.getint(section, option)
472 self.set_irace_first_test(value, state)
473 file_settings.remove_option(section, option)
475 option_names = ("mu", )
476 for option in option_names:
477 if file_settings.has_option(section, option):
478 value = file_settings.getint(section, option)
479 self.set_irace_mu(value, state)
480 file_settings.remove_option(section, option)
482 option_names = ("nb_iterations", "iterations", "max_iterations")
483 for option in option_names:
484 if file_settings.has_option(section, option):
485 value = file_settings.getint(section, option)
486 self.set_irace_max_iterations(value, state)
487 file_settings.remove_option(section, option)
489 section = "paramils"
491 option_names = ("min_runs", )
492 for option in option_names:
493 if file_settings.has_option(section, option):
494 value = file_settings.getint(section, option)
495 self.set_paramils_min_runs(value, state)
496 file_settings.remove_option(section, option)
498 option_names = ("max_runs", )
499 for option in option_names:
500 if file_settings.has_option(section, option):
501 value = file_settings.getint(section, option)
502 self.set_paramils_max_runs(value, state)
503 file_settings.remove_option(section, option)
505 option_names = ("cputime_limit", "cputime_limit", "tunertime_limit",
506 "tuner_timeout", "tunerTimeout")
507 for option in option_names:
508 if file_settings.has_option(section, option):
509 value = file_settings.getint(section, option)
510 self.set_paramils_tuner_timeout(value, state)
511 file_settings.remove_option(section, option)
513 option_names = ("random_restart", )
514 for option in option_names:
515 if file_settings.has_option(section, option):
516 value = file_settings.getfloat(section, option)
517 self.set_paramils_random_restart(value, state)
518 file_settings.remove_option(section, option)
520 option_names = ("focused_approach", )
521 for option in option_names:
522 if file_settings.has_option(section, option):
523 value = file_settings.getboolean(section, option)
524 self.set_paramils_focused_approach(value, state)
525 file_settings.remove_option(section, option)
527 option_names = ("use_cpu_time_in_tunertime", )
528 for option in option_names:
529 if file_settings.has_option(section, option):
530 value = file_settings.getboolean(section, option)
531 self.set_paramils_use_cpu_time_in_tunertime(value, state)
532 file_settings.remove_option(section, option)
534 option_names = ("cli_cores", )
535 for option in option_names:
536 if file_settings.has_option(section, option):
537 value = file_settings.getint(section, option)
538 self.set_paramils_cli_cores(value, state)
539 file_settings.remove_option(section, option)
541 options_names = ("iteration_limit", "numIterations", "numberOfIterations",
542 "max_iterations")
543 for option in options_names:
544 if file_settings.has_option(section, option):
545 value = file_settings.getint(section, option)
546 self.set_paramils_max_iterations(value, state)
547 file_settings.remove_option(section, option)
549 section = "selection"
551 option_names = ("selector_class", )
552 for option in option_names:
553 if file_settings.has_option(section, option):
554 value = file_settings.get(section, option)
555 self.set_selection_class(value, state)
556 file_settings.remove_option(section, option)
558 option_names = ("selector_model")
559 for option in option_names:
560 if file_settings.has_option(section, option):
561 value = file_settings.get(section, option)
562 self.set_selection_model(value, state)
563 file_settings.remove_option(section, option)
565 section = "slurm"
566 option_names = ("number_of_jobs_in_parallel", "num_job_in_parallel")
567 for option in option_names:
568 if file_settings.has_option(section, option):
569 value = file_settings.getint(section, option)
570 self.set_number_of_jobs_in_parallel(value, state)
571 file_settings.remove_option(section, option)
573 option_names = ("max_parallel_runs_per_node", "clis_per_node")
574 for option in option_names:
575 if file_settings.has_option(section, option):
576 value = file_settings.getint(section, option)
577 self.set_slurm_max_parallel_runs_per_node(value, state)
578 file_settings.remove_option(section, option)
580 option_names = ("job_submission_limit", "max_jobs_submit")
581 for option in option_names:
582 if file_settings.has_option(section, option):
583 value = file_settings.getint(section, option)
584 self.set_slurm_job_submission_limit(value, state)
585 file_settings.remove_option(section, option)
587 option_names = ("job_prepend", "prepend", "prepend_script")
588 for option in option_names:
589 if file_settings.has_option(section, option):
590 value = file_settings.get(section, option)
591 self.set_slurm_job_prepend(value, state)
592 file_settings.remove_option(section, option)
594 section = "ablation"
595 option_names = ("racing", "ablation_racing")
596 for option in option_names:
597 if file_settings.has_option(section, option):
598 value = file_settings.getboolean(section, option)
599 self.set_ablation_racing_flag(value, state)
600 file_settings.remove_option(section, option)
602 section = "parallel_portfolio"
603 option_names = ("check_interval", )
604 for option in option_names:
605 if file_settings.has_option(section, option):
606 value = int(file_settings.get(section, option))
607 self.set_parallel_portfolio_check_interval(value, state)
608 file_settings.remove_option(section, option)
610 option_names = ("num_seeds_per_solver", )
611 for option in option_names:
612 if file_settings.has_option(section, option):
613 value = int(file_settings.get(section, option))
614 self.set_parallel_portfolio_number_of_seeds_per_solver(value, state)
615 file_settings.remove_option(section, option)
617 # TODO: Report on any unknown settings that were read
618 sections = file_settings.sections()
620 for section in sections:
621 for option in file_settings[section]:
622 # TODO: Should check the options are valid Slurm options
623 if section == "slurm":
624 value = file_settings.get(section, option)
625 self.add_slurm_extra_option(option, value, state)
626 else:
627 print(f'Unrecognised section - option combination: "{section} '
628 f'{option}" in file {file_path} ignored')
630 # Print error if unable to read the settings
631 elif Path(file_path).exists():
632 print(f"ERROR: Failed to read settings from {file_path} The file may have "
633 "been empty or be in another format than INI. Default Setting values "
634 "will be used.")
636 def write_used_settings(self: Settings) -> None:
637 """Write the used settings to the default locations."""
638 # Write to latest settings file
639 self.write_settings_ini(self.DEFAULT_settings_dir / "latest.ini")
641 def write_settings_ini(self: Settings, file_path: Path) -> None:
642 """Write the settings to an INI file."""
643 # Create needed directories if they don't exist
644 file_path.parent.mkdir(parents=True, exist_ok=True)
645 slurm_extra_section_options = None
646 if self.__settings.has_section("slurm_extra"):
647 # Slurm extra options are not written as a seperate section
648 slurm_extra_section_options = {}
649 for key in self.__settings["slurm_extra"]:
650 self.__settings["slurm"][key] = self.__settings["slurm_extra"][key]
651 slurm_extra_section_options[key] = self.__settings["slurm_extra"][key]
652 self.__settings.remove_section("slurm_extra")
653 # We do not write None values
654 removed = []
655 for section in self.__settings.sections():
656 for option in self.__settings[section]:
657 try:
658 if ast.literal_eval(str(self.__settings[section][option])) is None:
659 del self.__settings[section][option]
660 removed.append((section, option))
661 except Exception:
662 pass
663 # Write the settings to file
664 with file_path.open("w") as settings_file:
665 self.__settings.write(settings_file)
666 # Rebuild slurm extra if needed
667 if slurm_extra_section_options is not None:
668 self.__settings.add_section("slurm_extra")
669 for key in slurm_extra_section_options:
670 self.__settings["slurm_extra"][key] = slurm_extra_section_options[key]
671 # Rebuild None if needed
672 for section, option in removed:
673 self.__settings[section][option] = "None"
675 def __init_section(self: Settings, section: str) -> None:
676 if section not in self.__settings:
677 self.__settings[section] = {}
679 @staticmethod
680 def __check_setting_state(current_state: SettingState,
681 new_state: SettingState, name: str) -> bool:
682 change_setting_ok = True
684 if current_state == SettingState.FILE and new_state == SettingState.DEFAULT:
685 change_setting_ok = False
686 print(f"Warning: Attempting to overwrite setting for {name} with default "
687 "value; keeping the value read from file!")
688 elif (current_state == SettingState.CMD_LINE
689 and new_state == SettingState.DEFAULT):
690 change_setting_ok = False
691 print(f"Warning: Attempting to overwrite setting for {name} with default "
692 "value; keeping the value read from command line!")
693 elif current_state == SettingState.CMD_LINE and new_state == SettingState.FILE:
694 change_setting_ok = False
695 print(f"Warning: Attempting to overwrite setting for {name} with value from "
696 "file; keeping the value read from command line!")
698 return change_setting_ok
700 # General settings ###
701 def set_general_sparkle_objectives(
702 self: Settings,
703 value: list[SparkleObjective] = [DEFAULT_general_sparkle_objective, ],
704 origin: SettingState = SettingState.DEFAULT) -> None:
705 """Set the sparkle objective."""
706 section = "general"
707 name = "objectives"
709 if value is not None and self.__check_setting_state(
710 self.__general_sparkle_objective_set, origin, name):
711 if isinstance(value, list):
712 value = ",".join([str(obj) for obj in value])
713 else:
714 value = str(value)
716 # Append standard Sparkle Objectives
717 if "status" not in value:
718 value += ",status:metric"
719 if "cpu_time" not in value:
720 value += ",cpu_time:metric"
721 if "wall_time" not in value:
722 value += ",wall_time:metric"
723 if "memory" not in value:
724 value += ",memory:metric"
726 self.__init_section(section)
727 self.__general_sparkle_objective_set = origin
728 self.__settings[section][name] = value
730 def get_general_sparkle_objectives(
731 self: Settings,
732 filter_metric: bool = False) -> list[SparkleObjective]:
733 """Return the Sparkle objectives."""
734 if self.__general_sparkle_objective_set == SettingState.NOT_SET:
735 self.set_general_sparkle_objectives()
737 objectives = [resolve_objective(obj)
738 for obj in self.__settings["general"]["objectives"].split(",")]
740 if filter_metric:
741 return [obj for obj in objectives if not obj.metric]
743 return objectives
745 def set_general_sparkle_configurator(
746 self: Settings,
747 value: str = DEFAULT_general_sparkle_configurator,
748 origin: SettingState = SettingState.DEFAULT) -> None:
749 """Set the Sparkle configurator."""
750 section = "general"
751 name = "configurator"
752 if value is not None and self.__check_setting_state(
753 self.__general_sparkle_configurator_set, origin, name):
754 self.__init_section(section)
755 self.__general_sparkle_configurator_set = origin
756 self.__settings[section][name] = value
758 def get_general_sparkle_configurator(self: Settings) -> Configurator:
759 """Return the configurator init method."""
760 if self.__general_sparkle_configurator_set == SettingState.NOT_SET:
761 self.set_general_sparkle_configurator()
762 configurator_var = self.__settings["general"]["configurator"]
763 if (self.__general_sparkle_configurator is None
764 or self.__general_sparkle_configurator.name != configurator_var):
765 configurator_subclass =\
766 cim.resolve_configurator(self.__settings["general"]["configurator"])
767 if configurator_subclass is not None:
768 self.__general_sparkle_configurator = configurator_subclass(
769 base_dir=Path(),
770 output_path=Settings.DEFAULT_configuration_output_raw)
771 else:
772 print("WARNING: Configurator class name not recognised: "
773 f'{self.__settings["general"]["configurator"]}. '
774 "Configurator not set.")
775 return self.__general_sparkle_configurator
777 def set_general_target_cutoff_time(
778 self: Settings, value: int = DEFAULT_general_target_cutoff_time,
779 origin: SettingState = SettingState.DEFAULT) -> None:
780 """Set the cutoff time in seconds for target algorithms."""
781 section = "general"
782 name = "target_cutoff_time"
784 if value is not None and self.__check_setting_state(
785 self.__general_target_cutoff_time_set, origin, name):
786 self.__init_section(section)
787 self.__general_target_cutoff_time_set = origin
788 self.__settings[section][name] = str(value)
790 def get_general_target_cutoff_time(self: Settings) -> int:
791 """Return the cutoff time in seconds for target algorithms."""
792 if self.__general_target_cutoff_time_set == SettingState.NOT_SET:
793 self.set_general_target_cutoff_time()
794 return int(self.__settings["general"]["target_cutoff_time"])
796 def set_general_extractor_cutoff_time(
797 self: Settings, value: int = DEFAULT_general_extractor_cutoff_time,
798 origin: SettingState = SettingState.DEFAULT) -> None:
799 """Set the cutoff time in seconds for feature extraction."""
800 section = "general"
801 name = "extractor_cutoff_time"
803 if value is not None and self.__check_setting_state(
804 self.__general_extractor_cutoff_time_set, origin, name):
805 self.__init_section(section)
806 self.__general_extractor_cutoff_time_set = origin
807 self.__settings[section][name] = str(value)
809 def get_general_extractor_cutoff_time(self: Settings) -> int:
810 """Return the cutoff time in seconds for feature extraction."""
811 if self.__general_extractor_cutoff_time_set == SettingState.NOT_SET:
812 self.set_general_extractor_cutoff_time()
813 return int(self.__settings["general"]["extractor_cutoff_time"])
815 def set_number_of_jobs_in_parallel(
816 self: Settings, value: int = DEFAULT_number_of_jobs_in_parallel,
817 origin: SettingState = SettingState.DEFAULT) -> None:
818 """Set the number of runs Sparkle can do in parallel."""
819 section = "slurm"
820 name = "number_of_jobs_in_parallel"
822 if value is not None and self.__check_setting_state(
823 self.__number_of_jobs_in_parallel_set, origin, name):
824 self.__init_section(section)
825 self.__number_of_jobs_in_parallel_set = origin
826 self.__settings[section][name] = str(value)
828 def get_number_of_jobs_in_parallel(self: Settings) -> int:
829 """Return the number of runs Sparkle can do in parallel."""
830 if self.__number_of_jobs_in_parallel_set == SettingState.NOT_SET:
831 self.set_number_of_jobs_in_parallel()
833 return int(self.__settings["slurm"]["number_of_jobs_in_parallel"])
835 def set_general_verbosity(
836 self: Settings, value: VerbosityLevel = DEFAULT_general_verbosity,
837 origin: SettingState = SettingState.DEFAULT) -> None:
838 """Set the general verbosity to use."""
839 section = "general"
840 name = "verbosity"
842 if value is not None and self.__check_setting_state(
843 self.__general_verbosity_set, origin, name):
844 self.__init_section(section)
845 self.__general_verbosity_set = origin
846 self.__settings[section][name] = value.name
848 def get_general_verbosity(self: Settings) -> VerbosityLevel:
849 """Return the general verbosity."""
850 if self.__general_verbosity_set == SettingState.NOT_SET:
851 self.set_general_verbosity()
853 return VerbosityLevel.from_string(
854 self.__settings["general"]["verbosity"])
856 def set_general_check_interval(
857 self: Settings,
858 value: int = DEFAULT_general_check_interval,
859 origin: SettingState = SettingState.DEFAULT) -> None:
860 """Set the general check interval."""
861 section = "general"
862 name = "check_interval"
864 if value is not None and self.__check_setting_state(
865 self.__general_check_interval_set, origin, name):
866 self.__init_section(section)
867 self.__general_check_interval_set = origin
868 self.__settings[section][name] = str(value)
870 def get_general_check_interval(self: Settings) -> int:
871 """Return the general check interval."""
872 if self.__general_check_interval_set == SettingState.NOT_SET:
873 self.set_general_check_interval()
875 return int(self.__settings["general"]["check_interval"])
877 # Configuration settings General ###
879 def get_configurator_settings(self: Settings,
880 configurator_name: str) -> dict[str, any]:
881 """Return the configurator settings."""
882 configurator_settings = {
883 "number_of_runs": self.get_configurator_number_of_runs(),
884 "solver_calls": self.get_configurator_solver_calls(),
885 "cutoff_time": self.get_general_target_cutoff_time(),
886 "max_iterations": self.get_configurator_max_iterations()
887 }
888 # In the settings below, we default to the configurator general settings if no
889 # specific configurator settings are given, by using the [None] or [Value]
890 if configurator_name == cim.SMAC2.__name__:
891 # Return all settings from the SMAC2 section
892 configurator_settings.update({
893 "cpu_time": self.get_smac2_cpu_time(),
894 "wallclock_time": self.get_smac2_wallclock_time(),
895 "target_cutoff_length": self.get_smac2_target_cutoff_length(),
896 "use_cpu_time_in_tunertime": self.get_smac2_use_cpu_time_in_tunertime(),
897 "cli_cores": self.get_smac2_cli_cores(),
898 "max_iterations": self.get_smac2_max_iterations()
899 or configurator_settings["max_iterations"],
900 })
901 elif configurator_name == cim.SMAC3.__name__:
902 # Return all settings from the SMAC3 section
903 del configurator_settings["max_iterations"] # SMAC3 does not have this?
904 configurator_settings.update({
905 "smac_facade": self.get_smac3_smac_facade(),
906 "max_ratio": self.get_smac3_facade_max_ratio(),
907 "crash_cost": self.get_smac3_crash_cost(),
908 "termination_cost_threshold":
909 self.get_smac3_termination_cost_threshold(),
910 "walltime_limit": self.get_smac3_walltime_limit(),
911 "cputime_limit": self.get_smac3_cputime_limit(),
912 "use_default_config": self.get_smac3_use_default_config(),
913 "min_budget": self.get_smac3_min_budget(),
914 "max_budget": self.get_smac3_max_budget(),
915 "solver_calls": self.get_smac3_number_of_trials()
916 or configurator_settings["solver_calls"],
917 })
918 # Do not pass None values to SMAC3, it Scenario resolves default settings
919 configurator_settings = {key: value
920 for key, value in configurator_settings.items()
921 if value is not None}
922 elif configurator_name == cim.IRACE.__name__:
923 # Return all settings from the IRACE section
924 configurator_settings.update({
925 "solver_calls": self.get_irace_max_experiments(),
926 "max_time": self.get_irace_max_time(),
927 "first_test": self.get_irace_first_test(),
928 "mu": self.get_irace_mu(),
929 "max_iterations": self.get_irace_max_iterations()
930 or configurator_settings["max_iterations"],
931 })
932 if (configurator_settings["solver_calls"] == 0
933 and configurator_settings["max_time"] == 0): # Default to base
934 configurator_settings["solver_calls"] =\
935 self.get_configurator_solver_calls()
936 elif configurator_name == cim.ParamILS.__name__:
937 configurator_settings.update({
938 "tuner_timeout": self.get_paramils_tuner_timeout(),
939 "min_runs": self.get_paramils_min_runs(),
940 "max_runs": self.get_paramils_max_runs(),
941 "focused_ils": self.get_paramils_focused_approach(),
942 "initial_configurations": self.get_paramils_initial_configurations(),
943 "random_restart": self.get_paramils_random_restart(),
944 "cli_cores": self.get_paramils_cli_cores(),
945 "use_cpu_time_in_tunertime":
946 self.get_paramils_use_cpu_time_in_tunertime(),
947 "max_iterations": self.set_paramils_max_iterations()
948 or configurator_settings["max_iterations"],
949 })
950 return configurator_settings
952 def set_configurator_solver_calls(
953 self: Settings, value: int = DEFAULT_configurator_solver_calls,
954 origin: SettingState = SettingState.DEFAULT) -> None:
955 """Set the number of solver calls."""
956 section = "configuration"
957 name = "solver_calls"
959 if value is not None and self.__check_setting_state(
960 self.__config_solver_calls_set, origin, name):
961 self.__init_section(section)
962 self.__config_solver_calls_set = origin
963 self.__settings[section][name] = str(value)
965 def get_configurator_solver_calls(self: Settings) -> int | None:
966 """Return the maximum number of solver calls the configurator can do."""
967 if self.__config_solver_calls_set == SettingState.NOT_SET:
968 self.set_configurator_solver_calls()
970 return int(self.__settings["configuration"]["solver_calls"])
972 def set_configurator_number_of_runs(
973 self: Settings, value: int = DEFAULT_configurator_number_of_runs,
974 origin: SettingState = SettingState.DEFAULT) -> None:
975 """Set the number of configuration runs."""
976 section = "configuration"
977 name = "number_of_runs"
979 if value is not None and self.__check_setting_state(
980 self.__config_number_of_runs_set, origin, name):
981 self.__init_section(section)
982 self.__config_number_of_runs_set = origin
983 self.__settings[section][name] = str(value)
985 def get_configurator_number_of_runs(self: Settings) -> int:
986 """Return the number of configuration runs."""
987 if self.__config_number_of_runs_set == SettingState.NOT_SET:
988 self.set_configurator_number_of_runs()
990 return int(self.__settings["configuration"]["number_of_runs"])
992 def set_configurator_max_iterations(
993 self: Settings, value: int = DEFAULT_configurator_maximum_iterations,
994 origin: SettingState = SettingState.DEFAULT) -> None:
995 """Set the number of configuration runs."""
996 section = "configuration"
997 name = "max_iterations"
999 if self.__check_setting_state(
1000 self.__config_max_iterations_set, origin, name):
1001 self.__init_section(section)
1002 self.__config_max_iterations_set = origin
1003 self.__settings[section][name] = str(value)
1005 def get_configurator_max_iterations(self: Settings) -> int | None:
1006 """Get the maximum number of configurator iterations."""
1007 if self.__config_max_iterations_set == SettingState.NOT_SET:
1008 self.set_configurator_max_iterations()
1009 max_iterations = self.__settings["configuration"]["max_iterations"]
1010 return int(max_iterations) if max_iterations.isdigit() else None
1012 # Configuration: SMAC2 specific settings ###
1014 def set_smac2_wallclock_time(
1015 self: Settings, value: int = DEFAULT_smac2_wallclock_time,
1016 origin: SettingState = SettingState.DEFAULT) -> None:
1017 """Set the budget per configuration run in seconds (wallclock)."""
1018 section = "smac2"
1019 name = "wallclock_time"
1021 if self.__check_setting_state(
1022 self.__smac2_wallclock_time_set, origin, name):
1023 self.__init_section(section)
1024 self.__smac2_wallclock_time_set = origin
1025 self.__settings[section][name] = str(value)
1027 def get_smac2_wallclock_time(self: Settings) -> int | None:
1028 """Return the budget per configuration run in seconds (wallclock)."""
1029 if self.__smac2_wallclock_time_set == SettingState.NOT_SET:
1030 self.set_smac2_wallclock_time()
1031 wallclock_time = self.__settings["smac2"]["wallclock_time"]
1032 return int(wallclock_time) if wallclock_time.isdigit() else None
1034 def set_smac2_cpu_time(
1035 self: Settings, value: int = DEFAULT_smac2_cpu_time,
1036 origin: SettingState = SettingState.DEFAULT) -> None:
1037 """Set the budget per configuration run in seconds (cpu)."""
1038 section = "smac2"
1039 name = "cpu_time"
1041 if self.__check_setting_state(
1042 self.__smac2_cpu_time_set, origin, name):
1043 self.__init_section(section)
1044 self.__smac2_cpu_time_set = origin
1045 self.__settings[section][name] = str(value)
1047 def get_smac2_cpu_time(self: Settings) -> int | None:
1048 """Return the budget per configuration run in seconds (cpu)."""
1049 if self.__smac2_cpu_time_set == SettingState.NOT_SET:
1050 self.set_smac2_cpu_time()
1051 cpu_time = self.__settings["smac2"]["cpu_time"]
1052 return int(cpu_time) if cpu_time.isdigit() else None
1054 def set_smac2_target_cutoff_length(
1055 self: Settings, value: str = DEFAULT_smac2_target_cutoff_length,
1056 origin: SettingState = SettingState.DEFAULT) -> None:
1057 """Set the target algorithm cutoff length."""
1058 section = "smac2"
1059 name = "target_cutoff_length"
1061 if value is not None and self.__check_setting_state(
1062 self.__smac2_target_cutoff_length_set, origin, name):
1063 self.__init_section(section)
1064 self.__smac2_target_cutoff_length_set = origin
1065 self.__settings[section][name] = str(value)
1067 def get_smac2_target_cutoff_length(self: Settings) -> str:
1068 """Return the target algorithm cutoff length.
1070 'A domain specific measure of when the algorithm should consider itself done.'
1072 Returns:
1073 The target algorithm cutoff length.
1074 """
1075 if self.__smac2_target_cutoff_length_set == SettingState.NOT_SET:
1076 self.set_smac2_target_cutoff_length()
1077 return self.__settings["smac2"]["target_cutoff_length"]
1079 def set_smac2_use_cpu_time_in_tunertime(
1080 self: Settings, value: bool = DEFAULT_smac2_use_cpu_time_in_tunertime,
1081 origin: SettingState = SettingState.DEFAULT) -> None:
1082 """Set whether to use CPU time in tunertime."""
1083 section = "smac2"
1084 name = "use_cpu_time_in_tunertime"
1086 if self.__check_setting_state(
1087 self.__smac2_use_cpu_time_in_tunertime_set, origin, name):
1088 self.__init_section(section)
1089 self.__smac2_use_cpu_time_in_tunertime_set = origin
1090 self.__settings[section][name] = str(value)
1092 def get_smac2_use_cpu_time_in_tunertime(self: Settings) -> bool:
1093 """Return whether to use CPU time in tunertime."""
1094 if self.__smac2_use_cpu_time_in_tunertime_set == SettingState.NOT_SET:
1095 self.set_smac2_use_cpu_time_in_tunertime()
1096 return ast.literal_eval(self.__settings["smac2"]["use_cpu_time_in_tunertime"])
1098 def set_smac2_cli_cores(
1099 self: Settings, value: int = DEFAULT_smac2_cli_cores,
1100 origin: SettingState = SettingState.DEFAULT) -> None:
1101 """Set the number of cores to use for SMAC2 CLI."""
1102 section = "smac2"
1103 name = "cli_cores"
1105 if self.__check_setting_state(
1106 self.__smac2_cli_cores_set, origin, name):
1107 self.__init_section(section)
1108 self.__smac2_cli_cores_set = origin
1109 self.__settings[section][name] = str(value)
1111 def get_smac2_cli_cores(self: Settings) -> int | None:
1112 """Number of cores to use to execute runs.
1114 In other words, the number of requests to run at a given time.
1115 """
1116 if self.__smac2_cli_cores_set == SettingState.NOT_SET:
1117 self.set_smac2_cli_cores()
1118 cli_cores = self.__settings["smac2"]["cli_cores"]
1119 return int(cli_cores) if cli_cores.isdigit() else None
1121 def set_smac2_max_iterations(
1122 self: Settings, value: int = DEFAULT_smac2_max_iterations,
1123 origin: SettingState = SettingState.DEFAULT) -> None:
1124 """Set the maximum number of SMAC2 iterations."""
1125 section = "smac2"
1126 name = "max_iterations"
1128 if self.__check_setting_state(
1129 self.__smac2_max_iterations_set, origin, name):
1130 self.__init_section(section)
1131 self.__smac2_max_iterations_set = origin
1132 self.__settings[section][name] = str(value)
1134 def get_smac2_max_iterations(self: Settings) -> int | None:
1135 """Get the maximum number of SMAC2 iterations."""
1136 if self.__smac2_max_iterations_set == SettingState.NOT_SET:
1137 self.set_smac2_max_iterations()
1138 max_iterations = self.__settings["smac2"]["max_iterations"]
1139 return int(max_iterations) if max_iterations.isdigit() else None
1141 # Configuration: SMAC3 specific settings ###
1143 def set_smac3_number_of_trials(
1144 self: Settings, value: int = DEFAULT_smac3_number_of_runs,
1145 origin: SettingState = SettingState.DEFAULT) -> None:
1146 """Set the number of SMAC3 trials."""
1147 section = "smac3"
1148 name = "number_of_runs"
1150 if self.__check_setting_state(
1151 self.__smac3_number_of_trials_set, origin, name):
1152 self.__init_section(section)
1153 self.__smac3_number_of_trials_set = origin
1154 self.__settings[section][name] = str(value)
1156 def get_smac3_number_of_trials(self: Settings) -> int | None:
1157 """Return the number of SMAC3 trials (Solver calls).
1159 'The maximum number of trials (combination of configuration, seed, budget,
1160 and instance, depending on the task) to run.'
1161 """
1162 if self.__smac3_number_of_trials_set == SettingState.NOT_SET:
1163 self.set_smac3_number_of_trials()
1164 number_of_runs = self.__settings["smac3"]["number_of_runs"]
1165 return int(number_of_runs) if number_of_runs.isdigit() else None
1167 def set_smac3_smac_facade(
1168 self: Settings, value: str = DEFAULT_smac3_facade,
1169 origin: SettingState = SettingState.DEFAULT) -> None:
1170 """Set the SMAC3 facade."""
1171 section = "smac3"
1172 name = "facade"
1174 if self.__check_setting_state(self.__smac3_smac_facade_set, origin, name):
1175 self.__init_section(section)
1176 self.__smac3_smac_facade_set = origin
1177 self.__settings[section][name] = str(value)
1179 def get_smac3_smac_facade(self: Settings) -> str:
1180 """Return the SMAC3 facade."""
1181 if self.__smac3_smac_facade_set == SettingState.NOT_SET:
1182 self.set_smac3_smac_facade()
1183 return self.__settings["smac3"]["facade"]
1185 def set_smac3_facade_max_ratio(
1186 self: Settings, value: float = DEFAULT_smac3_facade_max_ratio,
1187 origin: SettingState = SettingState.DEFAULT) -> None:
1188 """Set the SMAC3 facade max ratio."""
1189 section = "smac3"
1190 name = "facade_max_ratio"
1192 if self.__check_setting_state(
1193 self.__smac3_facade_max_ratio_set, origin, name):
1194 self.__init_section(section)
1195 self.__smac3_facade_max_ratio_set = origin
1196 self.__settings[section][name] = str(value)
1198 def get_smac3_facade_max_ratio(self: Settings) -> float:
1199 """Return the SMAC3 facade max ratio."""
1200 if self.__smac3_facade_max_ratio_set == SettingState.NOT_SET:
1201 self.set_smac3_facade_max_ratio()
1202 return ast.literal_eval(self.__settings["smac3"]["facade_max_ratio"])
1204 def set_smac3_crash_cost(self: Settings, value: float = DEFAULT_smac3_crash_cost,
1205 origin: SettingState = SettingState.DEFAULT) -> None:
1206 """Set the SMAC3 objective crash cost."""
1207 section = "smac3"
1208 name = "crash_cost"
1210 if self.__check_setting_state(self.__smac3_crash_cost_set, origin, name):
1211 self.__init_section(section)
1212 self.__smac3_smac_facade_set = origin
1213 self.__settings[section][name] = str(value)
1215 def get_smac3_crash_cost(self: Settings) -> float | list[float]:
1216 """Get the SMAC3 objective crash cost.
1218 'crash_cost : float | list[float], defaults to np.inf
1219 Defines the cost for a failed trial. In case of multi-objective,
1220 each objective can be associated with a different cost.'
1221 """
1222 if self.__smac3_crash_cost_set == SettingState.NOT_SET:
1223 self.set_smac3_crash_cost()
1224 return ast.literal_eval(self.__settings["smac3"]["crash_cost"])
1226 def set_smac3_termination_cost_threshold(
1227 self: Settings,
1228 value: float = DEFAULT_smac3_termination_cost_threshold,
1229 origin: SettingState = SettingState.DEFAULT) -> None:
1230 """Set the SMAC3 termination cost threshold."""
1231 section = "smac3"
1232 name = "termination_cost_threshold"
1234 if self.__check_setting_state(
1235 self.__smac3_termination_cost_threshold_set, origin, name):
1236 self.__init_section(section)
1237 self.__smac3_termination_cost_threshold_set = origin
1238 self.__settings[section][name] = str(value)
1240 def get_smac3_termination_cost_threshold(self: Settings) -> float | list[float]:
1241 """Get the SMAC3 termination cost threshold.
1243 'Defines a cost threshold when the optimization should stop. In case of
1244 multi-objective, each objective *must* be associated with a cost.
1245 The optimization stops when all objectives crossed the threshold.'
1246 """
1247 if self.__smac3_termination_cost_threshold_set == SettingState.NOT_SET:
1248 self.set_smac3_termination_cost_threshold()
1249 return ast.literal_eval(self.__settings["smac3"]["termination_cost_threshold"])
1251 def set_smac3_walltime_limit(
1252 self: Settings, value: float = DEFAULT_smac3_walltime_limit,
1253 origin: SettingState = SettingState.DEFAULT) -> None:
1254 """Set the SMAC3 walltime limit."""
1255 section = "smac3"
1256 name = "walltime_limit"
1258 if self.__check_setting_state(self.__smac3_walltime_limit_set, origin, name):
1259 self.__init_section(section)
1260 self.__smac3_walltime_limit_set = origin
1261 self.__settings[section][name] = str(value)
1263 def get_smac3_walltime_limit(self: Settings) -> float:
1264 """Get the SMAC3 walltime limit.
1266 'The maximum time in seconds that SMAC is allowed to run.'
1267 """
1268 if self.__smac3_walltime_limit_set == SettingState.NOT_SET:
1269 self.set_smac3_walltime_limit()
1270 return ast.literal_eval(self.__settings["smac3"]["walltime_limit"])
1272 def set_smac3_cputime_limit(
1273 self: Settings, value: float = DEFAULT_smac3_cputime_limit,
1274 origin: SettingState = SettingState.DEFAULT) -> None:
1275 """Set the SMAC3 CPU time limit."""
1276 section = "smac3"
1277 name = "cputime_limit"
1279 if self.__check_setting_state(self.__smac3_cputime_limit_set, origin, name):
1280 self.__init_section(section)
1281 self.__smac3_cputime_limit_set = origin
1282 self.__settings[section][name] = str(value)
1284 def get_smac3_cputime_limit(self: Settings) -> float:
1285 """Get the SMAC3 CPU time limit.
1287 'The maximum CPU time in seconds that SMAC is allowed to run.'
1288 """
1289 if self.__smac3_cputime_limit_set == SettingState.NOT_SET:
1290 self.set_smac3_cputime_limit()
1291 return ast.literal_eval(self.__settings["smac3"]["cputime_limit"])
1293 def set_smac3_use_default_config(
1294 self: Settings, value: bool = DEFAULT_smac3_use_default_config,
1295 origin: SettingState = SettingState.DEFAULT) -> None:
1296 """Set the SMAC3 to use default config."""
1297 section = "smac3"
1298 name = "use_default_config"
1300 if self.__check_setting_state(self.__smac3_use_default_config_set, origin, name):
1301 self.__init_section(section)
1302 self.__smac3_use_default_config_set = origin
1303 self.__settings[section][name] = str(value)
1305 def get_smac3_use_default_config(self: Settings) -> bool:
1306 """Get the SMAC3 to use default config.
1308 'If True, the configspace's default configuration is evaluated in the
1309 initial design. For historic benchmark reasons, this is False by default.
1310 Notice, that this will result in n_configs + 1 for the initial design.
1311 Respecting n_trials, this will result in one fewer evaluated
1312 configuration in the optimization.'
1313 """
1314 if self.__smac3_use_default_config_set == SettingState.NOT_SET:
1315 self.set_smac3_use_default_config()
1316 return ast.literal_eval(self.__settings["smac3"]["use_default_config"])
1318 def set_smac3_min_budget(
1319 self: Settings, value: int | float = DEFAULT_smac3_min_budget,
1320 origin: SettingState = SettingState.DEFAULT) -> None:
1321 """Set the SMAC3 min budget."""
1322 section = "smac3"
1323 name = "min_budget"
1325 if self.__check_setting_state(self.__smac3_min_budget_set, origin, name):
1326 self.__init_section(section)
1327 self.__smac3_min_budget_set = origin
1328 self.__settings[section][name] = str(value)
1330 def get_smac3_min_budget(self: Settings) -> int | float:
1331 """Get the SMAC3 min budget.
1333 'The minimum budget (epochs, subset size, number of instances, ...) that
1334 is used for the optimization. Use this argument if you use multi-fidelity
1335 or instance optimization.'
1336 """
1337 if self.__smac3_min_budget_set == SettingState.NOT_SET:
1338 self.set_smac3_min_budget()
1339 return ast.literal_eval(self.__settings["smac3"]["min_budget"])
1341 def set_smac3_max_budget(
1342 self: Settings, value: int | float = DEFAULT_smac3_max_budget,
1343 origin: SettingState = SettingState.DEFAULT) -> None:
1344 """Set the SMAC3 max budget."""
1345 section = "smac3"
1346 name = "max_budget"
1348 if self.__check_setting_state(self.__smac3_max_budget_set, origin, name):
1349 self.__init_section(section)
1350 self.__smac3_max_budget_set = origin
1351 self.__settings[section][name] = str(value)
1353 def get_smac3_max_budget(self: Settings) -> int | float:
1354 """Get the SMAC3 max budget.
1356 'The maximum budget (epochs, subset size, number of instances, ...) that
1357 is used for the optimization. Use this argument if you use multi-fidelity
1358 or instance optimization.'
1359 """
1360 if self.__smac3_max_budget_set == SettingState.NOT_SET:
1361 self.set_smac3_max_budget()
1362 return ast.literal_eval(self.__settings["smac3"]["max_budget"])
1364 # Configuration: IRACE specific settings ###
1366 def get_irace_max_time(self: Settings) -> int:
1367 """Return the max time in seconds for IRACE."""
1368 if self.__irace_max_time_set == SettingState.NOT_SET:
1369 self.set_irace_max_time()
1370 return int(self.__settings["irace"]["max_time"])
1372 def set_irace_max_time(
1373 self: Settings, value: int = DEFAULT_irace_max_time,
1374 origin: SettingState = SettingState.DEFAULT) -> None:
1375 """Set the max time in seconds for IRACE."""
1376 section = "irace"
1377 name = "max_time"
1379 if value is not None and self.__check_setting_state(
1380 self.__irace_max_time_set, origin, name):
1381 self.__init_section(section)
1382 self.__irace_max_time_set = origin
1383 self.__settings[section][name] = str(value)
1385 def get_irace_max_experiments(self: Settings) -> int:
1386 """Return the max number of experiments for IRACE."""
1387 if self.__irace_max_experiments_set == SettingState.NOT_SET:
1388 self.set_irace_max_experiments()
1389 return int(self.__settings["irace"]["max_experiments"])
1391 def set_irace_max_experiments(
1392 self: Settings, value: int = DEFAULT_irace_max_experiments,
1393 origin: SettingState = SettingState.DEFAULT) -> None:
1394 """Set the max number of experiments for IRACE."""
1395 section = "irace"
1396 name = "max_experiments"
1398 if value is not None and self.__check_setting_state(
1399 self.__irace_max_experiments_set, origin, name):
1400 self.__init_section(section)
1401 self.__irace_max_experiments_set = origin
1402 self.__settings[section][name] = str(value)
1404 def get_irace_first_test(self: Settings) -> int | None:
1405 """Return the first test for IRACE.
1407 Specifies how many instances are evaluated before the first
1408 elimination test. IRACE Default: 5. [firstTest]
1409 """
1410 if self.__irace_first_test_set == SettingState.NOT_SET:
1411 self.set_irace_first_test()
1412 first_test = self.__settings["irace"]["first_test"]
1413 return int(first_test) if first_test.isdigit() else None
1415 def set_irace_first_test(
1416 self: Settings, value: int = DEFAULT_irace_first_test,
1417 origin: SettingState = SettingState.DEFAULT) -> None:
1418 """Set the first test for IRACE."""
1419 section = "irace"
1420 name = "first_test"
1422 if self.__check_setting_state(
1423 self.__irace_first_test_set, origin, name):
1424 self.__init_section(section)
1425 self.__irace_first_test_set = origin
1426 self.__settings[section][name] = str(value)
1428 def get_irace_mu(self: Settings) -> int | None:
1429 """Return the mu for IRACE.
1431 Parameter used to define the number of configurations sampled and
1432 evaluated at each iteration. IRACE Default: 5. [mu]
1433 """
1434 if self.__irace_mu_set == SettingState.NOT_SET:
1435 self.set_irace_mu()
1436 mu = self.__settings["irace"]["mu"]
1437 return int(mu) if mu.isdigit() else None
1439 def set_irace_mu(
1440 self: Settings, value: int = DEFAULT_irace_mu,
1441 origin: SettingState = SettingState.DEFAULT) -> None:
1442 """Set the mu for IRACE."""
1443 section = "irace"
1444 name = "mu"
1446 if self.__check_setting_state(
1447 self.__irace_mu_set, origin, name):
1448 self.__init_section(section)
1449 self.__irace_mu_set = origin
1450 self.__settings[section][name] = str(value)
1452 def get_irace_max_iterations(self: Settings) -> int:
1453 """Return the number of iterations for IRACE."""
1454 if self.__irace_max_iterations_set == SettingState.NOT_SET:
1455 self.set_irace_max_iterations()
1456 max_iterations = self.__settings["irace"]["max_iterations"]
1457 return int(max_iterations) if max_iterations.isdigit() else None
1459 def set_irace_max_iterations(
1460 self: Settings, value: int = DEFAULT_irace_max_iterations,
1461 origin: SettingState = SettingState.DEFAULT) -> None:
1462 """Set the number of iterations for IRACE.
1464 Maximum number of iterations to be executed. Each iteration involves the
1465 generation of new configurations and the use of racing to select the best
1466 configurations. By default (with 0), irace calculates a minimum number of
1467 iterations as N^iter = ⌊2 + log2 N param⌋, where N^param is the number of
1468 non-fixed parameters to be tuned.
1469 Setting this parameter may make irace stop sooner than it should without using
1470 all the available budget. IRACE recommends to use the default value (Empty).
1471 """
1472 section = "irace"
1473 name = "max_iterations"
1475 if self.__check_setting_state(
1476 self.__irace_max_iterations_set, origin, name):
1477 self.__init_section(section)
1478 self.__irace_max_iterations_set = origin
1479 self.__settings[section][name] = str(value)
1481 # Configuration: ParamILS specific settings ###
1483 def get_paramils_min_runs(self: Settings) -> int | None:
1484 """Return the minimum number of runs for ParamILS."""
1485 if self.__paramils_min_runs_set == SettingState.NOT_SET:
1486 self.set_paramils_min_runs()
1487 min_runs = self.__settings["paramils"]["min_runs"]
1488 return int(min_runs) if min_runs.isdigit() else None
1490 def set_paramils_min_runs(
1491 self: Settings, value: int = DEFAULT_paramils_min_runs,
1492 origin: SettingState = SettingState.DEFAULT) -> None:
1493 """Set the minimum number of runs for ParamILS."""
1494 section = "paramils"
1495 name = "min_runs"
1497 if self.__check_setting_state(
1498 self.__paramils_min_runs_set, origin, name):
1499 self.__init_section(section)
1500 self.__paramils_min_runs_set = origin
1501 self.__settings[section][name] = str(value)
1503 def get_paramils_max_runs(self: Settings) -> int | None:
1504 """Return the maximum number of runs for ParamILS."""
1505 if self.__paramils_max_runs_set == SettingState.NOT_SET:
1506 self.set_paramils_max_runs()
1507 max_runs = self.__settings["paramils"]["min_runs"]
1508 return int(max_runs) if max_runs.isdigit() else None
1510 def set_paramils_max_runs(
1511 self: Settings, value: int = DEFAULT_paramils_max_runs,
1512 origin: SettingState = SettingState.DEFAULT) -> None:
1513 """Set the maximum number of runs for ParamILS."""
1514 section = "paramils"
1515 name = "max_runs"
1517 if self.__check_setting_state(
1518 self.__paramils_max_runs_set, origin, name):
1519 self.__init_section(section)
1520 self.__paramils_max_runs_set = origin
1521 self.__settings[section][name] = str(value)
1523 def get_paramils_tuner_timeout(self: Settings) -> int | None:
1524 """Return the maximum CPU time for ParamILS."""
1525 if self.__paramils_tuner_timeout_set == SettingState.NOT_SET:
1526 self.set_paramils_tuner_timeout()
1527 tuner_timeout = self.__settings["paramils"]["tuner_timeout"]
1528 return int(tuner_timeout) if tuner_timeout.isdigit() else None
1530 def set_paramils_tuner_timeout(
1531 self: Settings, value: int = DEFAULT_paramils_tuner_timeout,
1532 origin: SettingState = SettingState.DEFAULT) -> None:
1533 """Set the maximum CPU time for ParamILS."""
1534 section = "paramils"
1535 name = "tuner_timeout"
1537 if self.__check_setting_state(
1538 self.__paramils_tuner_timeout_set, origin, name):
1539 self.__init_section(section)
1540 self.__paramils_tuner_timeout_set = origin
1541 self.__settings[section][name] = str(value)
1543 def get_paramils_focused_approach(self: Settings) -> bool:
1544 """Return the focused approach for ParamILS."""
1545 if self.__paramils_focused_approach_set == SettingState.NOT_SET:
1546 self.set_paramils_focused_approach()
1547 return bool(self.__settings["paramils"]["focused_approach"])
1549 def set_paramils_focused_approach(
1550 self: Settings, value: bool = DEFAULT_paramils_focused_approach,
1551 origin: SettingState = SettingState.DEFAULT) -> None:
1552 """Set the focused approach for ParamILS."""
1553 section = "paramils"
1554 name = "focused_approach"
1556 if self.__check_setting_state(
1557 self.__paramils_focused_approach_set, origin, name):
1558 self.__init_section(section)
1559 self.__paramils_focused_approach_set = origin
1560 self.__settings[section][name] = str(value)
1562 def get_paramils_initial_configurations(self: Settings) -> int | None:
1563 """Return the initial configurations for ParamILS."""
1564 if self.__paramils_initial_configurations_set == SettingState.NOT_SET:
1565 self.set_paramils_initial_configurations()
1566 intial_confs = self.__settings["paramils"]["initial_configurations"]
1567 return int(intial_confs) if intial_confs.isdigit() else None
1569 def set_paramils_initial_configurations(
1570 self: Settings, value: int = DEFAULT_paramils_initial_configurations,
1571 origin: SettingState = SettingState.DEFAULT) -> None:
1572 """Set the initial configurations for ParamILS."""
1573 section = "paramils"
1574 name = "initial_configurations"
1576 if self.__check_setting_state(
1577 self.__paramils_initial_configurations_set, origin, name):
1578 self.__init_section(section)
1579 self.__paramils_initial_configurations_set = origin
1580 self.__settings[section][name] = str(value)
1582 def get_paramils_random_restart(self: Settings) -> float | None:
1583 """Return the random restart chance for ParamILS."""
1584 if self.__paramils_random_restart_set == SettingState.NOT_SET:
1585 self.set_paramils_random_restart()
1586 return ast.literal_eval(self.__settings["paramils"]["random_restart"])
1588 def set_paramils_random_restart(
1589 self: Settings, value: float = DEFAULT_paramils_random_restart,
1590 origin: SettingState = SettingState.DEFAULT) -> None:
1591 """Set the random restart chance for ParamILS."""
1592 section = "paramils"
1593 name = "random_restart"
1595 if self.__check_setting_state(
1596 self.__paramils_random_restart_set, origin, name):
1597 self.__init_section(section)
1598 self.__paramils_random_restart_set = origin
1599 self.__settings[section][name] = str(value)
1601 def set_paramils_use_cpu_time_in_tunertime(
1602 self: Settings, value: bool = DEFAULT_paramils_use_cpu_time_in_tunertime,
1603 origin: SettingState = SettingState.DEFAULT) -> None:
1604 """Set whether to use CPU time in tunertime."""
1605 section = "paramils"
1606 name = "use_cpu_time_in_tunertime"
1608 if self.__check_setting_state(
1609 self.__paramils_use_cpu_time_in_tunertime_set, origin, name):
1610 self.__init_section(section)
1611 self.__paramils_use_cpu_time_in_tunertime_set = origin
1612 self.__settings[section][name] = str(value)
1614 def get_paramils_use_cpu_time_in_tunertime(self: Settings) -> bool:
1615 """Return whether to use CPU time in tunertime."""
1616 if self.__paramils_use_cpu_time_in_tunertime_set == SettingState.NOT_SET:
1617 self.set_paramils_use_cpu_time_in_tunertime()
1618 return ast.literal_eval(self.__settings["paramils"]["use_cpu_time_in_tunertime"])
1620 def set_paramils_cli_cores(
1621 self: Settings, value: int = DEFAULT_paramils_cli_cores,
1622 origin: SettingState = SettingState.DEFAULT) -> None:
1623 """Set the number of cores to use for ParamILS CLI."""
1624 section = "paramils"
1625 name = "cli_cores"
1627 if self.__check_setting_state(
1628 self.__paramils_cli_cores_set, origin, name):
1629 self.__init_section(section)
1630 self.__paramils_cli_cores_set = origin
1631 self.__settings[section][name] = str(value)
1633 def get_paramils_cli_cores(self: Settings) -> int | None:
1634 """Number of cores to use to execute runs.
1636 In other words, the number of requests to run at a given time.
1637 """
1638 if self.__paramils_cli_cores_set == SettingState.NOT_SET:
1639 self.set_paramils_cli_cores()
1640 cli_cores = self.__settings["paramils"]["cli_cores"]
1641 return int(cli_cores) if cli_cores.isdigit() else None
1643 def set_paramils_max_iterations(
1644 self: Settings, value: int = DEFAULT_paramils_max_iterations,
1645 origin: SettingState = SettingState.DEFAULT) -> None:
1646 """Set the maximum number of ParamILS iterations."""
1647 section = "paramils"
1648 name = "max_iterations"
1650 if self.__check_setting_state(
1651 self.__paramils_max_iterations_set, origin, name):
1652 self.__init_section(section)
1653 self.__paramils_max_iterations_set = origin
1654 self.__settings[section][name] = str(value)
1656 def get_paramils_max_iterations(self: Settings) -> int | None:
1657 """Get the maximum number of paramils iterations."""
1658 if self.__smac2_max_iterations_set == SettingState.NOT_SET:
1659 self.set_paramils_max_iterations()
1660 max_iterations = self.__settings["paramils"]["max_iterations"]
1661 return int(max_iterations) if max_iterations.isdigit() else None
1663 # Selection settings ###
1665 def set_selection_class(
1666 self: Settings,
1667 value: str = DEFAULT_selector_class,
1668 origin: SettingState = SettingState.DEFAULT) -> None:
1669 """Set the Sparkle selector.
1671 Can contain any of the class names as defined in asf.selectors.
1672 """
1673 section = "selection"
1674 name = "selector_class"
1675 if value is not None and self.__check_setting_state(
1676 self.__selection_class_set, origin, name):
1677 self.__init_section(section)
1678 self.__selection_class_set = origin
1679 self.__settings[section][name] = str(value)
1681 def get_selection_class(self: Settings) -> type:
1682 """Return the selector class."""
1683 if self.__selection_class_set == SettingState.NOT_SET:
1684 self.set_selection_class()
1685 from asf import selectors
1686 return getattr(selectors, self.__settings["selection"]["selector_class"])
1688 def set_selection_model(
1689 self: Settings,
1690 value: str = DEFAULT_selector_model,
1691 origin: SettingState = SettingState.DEFAULT) -> None:
1692 """Set the selector model.
1694 Can be any of the sklearn.ensemble models.
1695 """
1696 section = "selection"
1697 name = "selector_model"
1698 if value is not None and self.__check_setting_state(
1699 self.__selection_model_set, origin, name):
1700 self.__init_section(section)
1701 self.__selection_model_set = origin
1702 self.__settings[section][name] = str(value)
1704 def get_selection_model(self: Settings) -> type:
1705 """Return the selector model class."""
1706 if self.__selection_model_set == SettingState.NOT_SET:
1707 self.set_selection_model()
1708 from sklearn import ensemble
1709 return getattr(ensemble, self.__settings["selection"]["selector_model"])
1711 # Slurm settings ###
1713 def set_slurm_max_parallel_runs_per_node(
1714 self: Settings,
1715 value: int = DEFAULT_slurm_max_parallel_runs_per_node,
1716 origin: SettingState = SettingState.DEFAULT) -> None:
1717 """Set the number of algorithms Slurm can run in parallel per node."""
1718 section = "slurm"
1719 name = "max_parallel_runs_per_node"
1721 if value is not None and self.__check_setting_state(
1722 self.__slurm_max_parallel_runs_per_node_set, origin, name):
1723 self.__init_section(section)
1724 self.__slurm_max_parallel_runs_per_node_set = origin
1725 self.__settings[section][name] = str(value)
1727 def get_slurm_max_parallel_runs_per_node(self: Settings) -> int:
1728 """Return the number of algorithms Slurm can run in parallel per node."""
1729 if self.__slurm_max_parallel_runs_per_node_set == SettingState.NOT_SET:
1730 self.set_slurm_max_parallel_runs_per_node()
1732 return int(self.__settings["slurm"]["max_parallel_runs_per_node"])
1734 def set_slurm_job_submission_limit(
1735 self: Settings,
1736 value: int = DEFAULT_slurm_job_submission_limit,
1737 origin: SettingState = SettingState.DEFAULT) -> None:
1738 """[NOT ACTIVE YET] Set the number of jobs that can be submitted to Slurm."""
1739 section = "slurm"
1740 name = "job_submission_limit"
1742 if value is not None and self.__check_setting_state(
1743 self.__slurm_job_submission_limit_set, origin, name):
1744 self.__init_section(section)
1745 self.__slurm_job_submission_limit_set = origin
1746 self.__settings[section][name] = str(value)
1748 def get_slurm_job_submission_limit(self: Settings) -> int:
1749 """[NOT ACTIVE YET] Return the maximum number of jobs you can submit to Slurm."""
1750 if self.__slurm_job_submission_limit_set == SettingState.NOT_SET:
1751 self.set_slurm_job_submission_limit()
1753 return int(self.__settings["slurm"]["job_submission_limit"])
1755 def set_slurm_job_prepend(
1756 self: Settings,
1757 value: str = DEFAULT_slurm_job_prepend,
1758 origin: SettingState = SettingState.DEFAULT) -> None:
1759 """Set the Slurm job prepend."""
1760 section = "slurm"
1761 name = "job_prepend"
1763 if self.__check_setting_state(
1764 self.__slurm_job_prepend_set, origin, name):
1765 try:
1766 path = Path(value)
1767 if path.is_file():
1768 value = path.open().read()
1769 except TypeError:
1770 pass
1771 self.__init_section(section)
1772 self.__slurm_job_prepend_set = origin
1773 self.__settings[section][name] = str(value)
1775 def get_slurm_job_prepend(self: Settings) -> str:
1776 """Return the Slurm job prepend."""
1777 if self.__slurm_job_prepend_set == SettingState.NOT_SET:
1778 self.set_slurm_job_prepend()
1780 return self.__settings["slurm"]["job_prepend"]
1782 # SLURM extra options
1784 def add_slurm_extra_option(self: Settings, name: str, value: str,
1785 origin: SettingState = SettingState.DEFAULT) -> None:
1786 """Add additional Slurm options."""
1787 section = "slurm_extra"
1789 current_state = (self.__slurm_extra_options_set[name]
1790 if name in self.__slurm_extra_options_set
1791 else SettingState.NOT_SET)
1793 if value is not None and self.__check_setting_state(current_state, origin, name):
1794 self.__init_section(section)
1795 self.__slurm_extra_options_set[name] = origin
1796 self.__settings[section][name] = str(value)
1798 def get_slurm_extra_options(self: Settings,
1799 as_args: bool = False) -> dict | list:
1800 """Return a dict with additional Slurm options."""
1801 section = "slurm_extra"
1802 options = dict()
1804 if "slurm_extra" in self.__settings.sections():
1805 for option in self.__settings["slurm_extra"]:
1806 options[option] = self.__settings.get(section, option)
1807 if as_args:
1808 return [f"--{key}={options[key]}" for key in options.keys()]
1809 return options
1811 # Ablation settings ###
1813 def set_ablation_racing_flag(self: Settings, value: bool = DEFAULT_ablation_racing,
1814 origin: SettingState = SettingState.DEFAULT) -> None:
1815 """Set a flag indicating whether racing should be used for ablation."""
1816 section = "ablation"
1817 name = "racing"
1819 if value is not None and self.__check_setting_state(
1820 self.__ablation_racing_flag_set, origin, name):
1821 self.__init_section(section)
1822 self.__ablation_racing_flag_set = origin
1823 self.__settings[section][name] = str(value)
1825 def get_ablation_racing_flag(self: Settings) -> bool:
1826 """Return a bool indicating whether the racing flag is set for ablation."""
1827 if self.__ablation_racing_flag_set == SettingState.NOT_SET:
1828 self.set_ablation_racing_flag()
1830 return bool(self.__settings["ablation"]["racing"])
1832 # Parallel Portfolio settings
1834 def set_parallel_portfolio_check_interval(
1835 self: Settings,
1836 value: int = DEFAULT_parallel_portfolio_check_interval,
1837 origin: SettingState = SettingState.DEFAULT) -> None:
1838 """Set the parallel portfolio check interval."""
1839 section = "parallel_portfolio"
1840 name = "check_interval"
1842 if value is not None and self.__check_setting_state(
1843 self.__parallel_portfolio_check_interval_set, origin, name):
1844 self.__init_section(section)
1845 self.__parallel_portfolio_check_interval_set = origin
1846 self.__settings[section][name] = str(value)
1848 def get_parallel_portfolio_check_interval(self: Settings) -> int:
1849 """Return the parallel portfolio check interval."""
1850 if self.__parallel_portfolio_check_interval_set == SettingState.NOT_SET:
1851 self.set_parallel_portfolio_check_interval()
1853 return int(
1854 self.__settings["parallel_portfolio"]["check_interval"])
1856 def set_parallel_portfolio_number_of_seeds_per_solver(
1857 self: Settings,
1858 value: int = DEFAULT_parallel_portfolio_num_seeds_per_solver,
1859 origin: SettingState = SettingState.DEFAULT) -> None:
1860 """Set the parallel portfolio seeds per solver to start."""
1861 section = "parallel_portfolio"
1862 name = "num_seeds_per_solver"
1864 if value is not None and self.__check_setting_state(
1865 self.__parallel_portfolio_num_seeds_per_solver_set, origin, name):
1866 self.__init_section(section)
1867 self.__parallel_portfolio_num_seeds_per_solver_set = origin
1868 self.__settings[section][name] = str(value)
1870 def get_parallel_portfolio_number_of_seeds_per_solver(self: Settings) -> int:
1871 """Return the parallel portfolio seeds per solver to start."""
1872 if self.__parallel_portfolio_num_seeds_per_solver_set == SettingState.NOT_SET:
1873 self.set_parallel_portfolio_number_of_seeds_per_solver()
1875 return int(
1876 self.__settings["parallel_portfolio"]["num_seeds_per_solver"])
1878 def set_run_on(self: Settings, value: Runner = DEFAULT_general_run_on,
1879 origin: SettingState = SettingState.DEFAULT) -> None:
1880 """Set the compute on which to run."""
1881 section = "general"
1882 name = "run_on"
1884 if value is not None and self.__check_setting_state(
1885 self.__run_on_set, origin, name):
1886 self.__init_section(section)
1887 self.__run_on_set = origin
1888 self.__settings[section][name] = value
1890 def get_run_on(self: Settings) -> Runner:
1891 """Return the compute on which to run."""
1892 if self.__run_on_set == SettingState.NOT_SET:
1893 self.set_run_on()
1895 return Runner(self.__settings["general"]["run_on"])
1897 @staticmethod
1898 def check_settings_changes(cur_settings: Settings, prev_settings: Settings) -> bool:
1899 """Check if there are changes between the previous and the current settings.
1901 Prints any section changes, printing None if no setting was found.
1903 Args:
1904 cur_settings: The current settings
1905 prev_settings: The previous settings
1907 Returns:
1908 True iff there are no changes.
1909 """
1910 cur_dict = cur_settings.__settings._sections
1911 prev_dict = prev_settings.__settings._sections
1913 cur_sections_set = set(cur_dict.keys())
1914 prev_sections_set = set(prev_dict.keys())
1915 sections_removed = prev_sections_set - cur_sections_set
1916 if sections_removed:
1917 print("Warning: the following sections have been removed:")
1918 for section in sections_removed:
1919 print(f" - Section '{section}'")
1921 sections_added = cur_sections_set - prev_sections_set
1922 if sections_added:
1923 print("Warning: the following sections have been added:")
1924 for section in sections_added:
1925 print(f" - Section '{section}'")
1927 sections_remained = cur_sections_set & prev_sections_set
1928 option_changed = False
1929 for section in sections_remained:
1930 printed_section = False
1931 names = set(cur_dict[section].keys()) | set(prev_dict[section].keys())
1932 for name in names:
1933 # if name is not present in one of the two dicts, get None as placeholder
1934 cur_val = cur_dict[section].get(name, None)
1935 prev_val = prev_dict[section].get(name, None)
1937 # If cur val is None, it is default
1938 if cur_val is not None and cur_val != prev_val:
1939 # Have we printed the initial warning?
1940 if not option_changed:
1941 print("Warning: The following attributes/options have changed:")
1942 option_changed = True
1944 # do we have yet to print the section?
1945 if not printed_section:
1946 print(f" - In the section '{section}':")
1947 printed_section = True
1949 # print actual change
1950 print(f" · '{name}' changed from '{prev_val}' to '{cur_val}'")
1952 return not (sections_removed or sections_added or option_changed)