def main():
"""Test for the DD classes."""
# import logging
# from pymhlib.demos.common import data_dir
parser = get_settings_parser()
parser.add("--inst_file",
type=str,
default=data_dir + 'mknap-small.txt',
help='problem instance file')
# parser.set_defaults(seed=3)
parse_settings()
init_logger()
logger = logging.getLogger("pymhlib")
logger.info("pymhlib demo for using decision diagrams for the MKP")
logger.info(get_settings_as_str())
instance = MKPInstance(settings.inst_file)
logger.info("MKP instance read:\n%s", str(instance))
# solution = MKPSolution(instance)
# solution.initialize(0)
dd = MKPDecisionDiag(instance)
dd.expand_all('relaxed')
logger.info(dd)
sol = dd.derive_solution()
# sol.check()
logger.info("Solution: %s, obj=%f", sol, sol.obj())
def run_algorithm_visualisation(config: Configuration):
settings.mh_out = sum_log_vis_path
settings.mh_log = iter_log_vis_path
settings.mh_log_step = step_log_path
init_logger()
settings.seed = config.seed
seed_random_generators()
solution = run_algorithm(config,True)
return get_log_data(config.problem.name.lower(), config.algorithm.name.lower()), solution.inst
def run_algorithm_comparison(config: Configuration):
settings.mh_out = sum_log_path
settings.mh_log = iter_log_path
settings.mh_log_step = 'None'
init_logger()
settings.seed = config.seed
seed_random_generators()
for i in range(config.runs):
_ = run_algorithm(config)
log_df = read_iter_log(config.name)
summary = read_sum_log()
return log_df, summary
def run_optimization(problem_name: str,
instance_class,
solution_class,
default_inst_file: str = "inst.dat",
own_settings: dict = None,
embedded: bool = False,
iter_cb: Callable = None,
seed: int = 0) -> Solution:
"""Initialize and run optimization algorithm given by parameter alg on given problem instance.
First, some general parameters for the algorithm to be applied, the instance file, and the methods to
be applied are registered and the settings are parsed.
Then the loggers are initialized, instance and solution objects are created and the chosen algorithm is
performed. The resulting solution is finally returned.
:param problem_name: name of the problem to be printed
:param instance_class: class of the instance to be solved
:param solution_class: concrete solution class to be used
:param default_inst_file: default instance file to be loaded and solved
:param own_settings: optional run-specific settings dictionary
:param embedded: if set it is assumed that the call is embedded in a Notebook or other larger framework,
and therefore, the parameters are assumed to be already registered and parsed
:param iter_cb: optional callback function that is called each iteration by some of the algorithms
:param seed: optional seed value for the random number generators; 0: random initialization
"""
if not embedded:
add_general_arguments_and_parse_settings(default_inst_file, seed=seed)
init_logger()
logger = logging.getLogger("pymhlib")
logger.info("pymhlib demo for solving %s", problem_name)
logger.info(get_settings_as_str())
instance = instance_class(settings.inst_file)
logger.info("%s instance read:\n%s", problem_name, str(instance))
solution = solution_class(instance)
# solution.initialize(0)
logger.info("Solution: %s, obj=%f\n", solution, solution.obj())
if settings.alg == 'gvns':
alg = GVNS(solution, [
Method(f"ch{i}", solution_class.construct, i)
for i in range(settings.meths_ch)
], [
Method(f"li{i}", solution_class.local_improve, i)
for i in range(1, settings.meths_li + 1)
], [
Method(f"sh{i}", solution_class.shaking, i)
for i in range(1, settings.meths_sh + 1)
], own_settings)
elif settings.alg == 'alns':
alg = ALNS(solution, [
Method(f"ch{i}", solution_class.construct, i)
for i in range(settings.meths_ch)
], [
Method(f"de{i}", solution_class.destroy, i)
for i in range(1, settings.meths_de + 1)
], [
Method(f"re{i}", solution_class.repair, i)
for i in range(1, settings.meths_re + 1)
], own_settings)
elif settings.alg == 'pbig':
alg = PBIG(solution, [
Method(f"ch{i}", solution_class.construct, i)
for i in range(settings.meths_ch)
], [
Method(f"li{i}", solution_class.local_improve, i)
for i in range(1, settings.meths_li + 1)
] + [
Method(f"sh{i}", solution_class.shaking, i)
for i in range(1, settings.meths_sh + 1)
], own_settings)
elif settings.alg == 'par_alns':
alg = ParallelALNS(solution, [
Method(f"ch{i}", solution_class.construct, i)
for i in range(settings.meths_ch)
], [
Method(f"de{i}", solution_class.destroy, i)
for i in range(1, settings.meths_de + 1)
], [
Method(f"re{i}", solution_class.repair, i)
for i in range(1, settings.meths_re + 1)
], own_settings)
elif settings.alg == 'ssga':
alg = SteadyStateGeneticAlgorithm(
solution, [
Method("ch{i}", solution_class.construct, i)
for i in range(settings.meths_ch)
], solution_class.crossover, Method("mu", solution_class.shaking,
1),
Method("ls", solution_class.local_improve, 1), own_settings)
elif settings.alg == 'sa':
alg = SA(solution, [
Method(f"ch{i}", solution_class.construct, i)
for i in range(settings.meths_ch)
], solution_class.random_move_delta_eval,
solution_class.apply_neighborhood_move, iter_cb, own_settings)
else:
raise ValueError(
'Invalid optimization algorithm selected (settings.alg): ',
settings.alg)
alg.run()
logger.info("")
alg.method_statistics()
alg.main_results()
return solution
def run_optimization(problem_name: str, Instance, Solution, default_inst_file: str, own_settings=None, embedded=False, iter_cb=None):
"""Run optimization algorithm given by parameter alg on given problem instance."""
if not embedded:
parser = get_settings_parser()
parser.add("--alg", type=str, default='gvns', help='optimization algorithm to be used '
'(gvns, alns, parallel_alns, ssga)')
parser.add("--inst_file", type=str, default=default_inst_file,
help='problem instance file')
parser.add("--meths_ch", type=int, default=1,
help='number of construction heuristics to be used')
parser.add("--meths_li", type=int, default=1,
help='number of local improvement methods to be used')
parser.add("--meths_sh", type=int, default=5,
help='number of shaking methods to be used')
parser.add("--meths_de", type=int, default=3,
help='number of destroy methods to be used')
parser.add("--meths_re", type=int, default=3,
help='number of repair methods to be used')
# parser.set_defaults(seed=3)
parse_settings()
init_logger()
logger = logging.getLogger("pymhlib")
logger.info(f"pymhlib demo for solving {problem_name}")
logger.info(get_settings_as_str())
instance = Instance(settings.inst_file)
logger.info(f"{problem_name} instance read:\n" + str(instance))
solution = Solution(instance)
# solution.initialize(0)
logger.info(f"Solution: {solution}, obj={solution.obj()}\n")
if settings.alg == 'gvns':
alg = GVNS(solution,
[Method(f"ch{i}", Solution.construct, i) for i in range(settings.meths_ch)],
[Method(f"li{i}", Solution.local_improve, i) for i in range(1, settings.meths_li + 1)],
[Method(f"sh{i}", Solution.shaking, i) for i in range(1, settings.meths_sh + 1)],
own_settings)
elif settings.alg == 'alns':
alg = ALNS(solution,
[Method(f"ch{i}", Solution.construct, i) for i in range(settings.meths_ch)],
[Method(f"de{i}", Solution.destroy, i) for i in range(1, settings.meths_de + 1)],
[Method(f"re{i}", Solution.repair, i) for i in range(1, settings.meths_re + 1)],
own_settings)
elif settings.alg == 'pbig':
alg = PBIG(solution,
[Method(f"ch{i}", Solution.construct, i) for i in range(settings.meths_ch)],
[Method(f"li{i}", Solution.local_improve, i) for i in range(1, settings.meths_li + 1)] +
[Method(f"sh{i}", Solution.shaking, i) for i in range(1, settings.meths_sh + 1)],
own_settings)
elif settings.alg == 'par_alns':
alg = ParallelALNS(solution,
[Method(f"ch{i}", Solution.construct, i) for i in range(settings.meths_ch)],
[Method(f"de{i}", Solution.destroy, i) for i in range(1, settings.meths_de + 1)],
[Method(f"re{i}", Solution.repair, i) for i in range(1, settings.meths_re + 1)],
own_settings)
elif settings.alg == 'ssga':
alg = SteadyStateGeneticAlgorithm(solution,
[Method(f"ch{i}", Solution.construct, i) for i in range(settings.meths_ch)],
Solution.crossover,
Method(f"mu", Solution.shaking, 1),
Method(f"ls", Solution.local_improve, 1),
own_settings)
elif settings.alg == 'sa':
alg = SA(solution,
[Method(f"ch{i}", Solution.construct, i) for i in range(settings.meths_ch)],
Solution.random_move_delta_eval, Solution.apply_neighborhood_move, iter_cb, own_settings)
else:
raise ValueError('Invalid optimization algorithm selected (settings.alg): ', settings.alg)
alg.run()
logger.info("")
alg.method_statistics()
alg.main_results()