diff --git a/.github/workflows/alns.yml b/.github/workflows/alns.yml index 6327368f..88960ee2 100644 --- a/.github/workflows/alns.yml +++ b/.github/workflows/alns.yml @@ -26,11 +26,11 @@ jobs: pip install poetry poetry install - name: Run tests - run: | - poetry run pytest + run: poetry run pytest + - name: Black + uses: psf/black@stable - name: Run static analysis - run: | - poetry run mypy alns + run: poetry run mypy alns - uses: codecov/codecov-action@v2 deploy: needs: build diff --git a/LICENSE.md b/LICENSE.md index 3e3939e3..7a7d9d39 100644 --- a/LICENSE.md +++ b/LICENSE.md @@ -1,6 +1,6 @@ The MIT License (MIT) -Copyright (c) 2019 Niels Wouda +Copyright (c) 2019 Niels Wouda and contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/README.md b/README.md index a69f0d8c..e55d1e3a 100644 --- a/README.md +++ b/README.md @@ -25,11 +25,11 @@ showing how the ALNS library may be used. These include: using a number of different operators and enhancement techniques from the literature. -Finally, the weight schemes and acceptance criteria notebook gives an overview -of various options available in the `alns` package (explained below). In the -notebook we use these different options to solve a toy 0/1-knapsack problem. The -notebook is a good starting point for when you want to use the different schemes -and criteria yourself. It is available [here][5]. +Finally, the features notebook gives an overview of various options available +in the `alns` package (explained below). In the notebook we use these different +options to solve a toy 0/1-knapsack problem. The notebook is a good starting +point for when you want to use different schemes, acceptance or stopping criteria +yourself. It is available [here][5]. ## How to use The `alns` package exposes two classes, `ALNS` and `State`. The first @@ -43,7 +43,7 @@ criterion_. ### Weight scheme The weight scheme determines how to select destroy and repair operators in each iteration of the ALNS algorithm. Several have already been implemented for you, -in `alns.weight_schemes`: +in `alns.weights`: - `SimpleWeights`. This weight scheme applies a convex combination of the existing weight vector, and a reward given for the current candidate @@ -60,7 +60,7 @@ your own. The acceptance criterion determines the acceptance of a new solution state at each iteration. An overview of common acceptance criteria is given in [Santini et al. (2018)][3]. Several have already been implemented for you, in -`alns.criteria`: +`alns.accept`: - `HillClimbing`. The simplest acceptance criterion, hill-climbing solely accepts solutions improving the objective value. @@ -70,8 +70,21 @@ each iteration. An overview of common acceptance criteria is given in scaled probability is bigger than some random number, using an updating temperature. -Each acceptance criterion inherits from `AcceptanceCriterion`, which may -be used to write your own. +Each acceptance criterion inherits from `AcceptanceCriterion`, which may be used +to write your own. + +### Stoppping criterion +The stopping criterion determines when ALNS should stop iterating. Several +commonly used stopping criteria have already been implemented for you, in +`alns.stop`: + +- `MaxIterations`. This stopping criterion stops the heuristic search after a + given number of iterations. +- `MaxRuntime`. This stopping criterion stops the heuristic search after a given + number of seconds. + +Each stopping criterion inherits from `StoppingCriterion`, which may be used to +write your own. ## References - Pisinger, D., and Ropke, S. (2010). Large Neighborhood Search. In M. @@ -85,5 +98,5 @@ be used to write your own. [2]: https://github.com/N-Wouda/ALNS/blob/master/examples/travelling_salesman_problem.ipynb [3]: https://link.springer.com/article/10.1007%2Fs10732-018-9377-x [4]: https://github.com/N-Wouda/ALNS/blob/master/examples/cutting_stock_problem.ipynb -[5]: https://github.com/N-Wouda/ALNS/blob/master/examples/weight_schemes_acceptance_criteria.ipynb +[5]: https://github.com/N-Wouda/ALNS/blob/master/examples/alns_features.ipynb [6]: https://github.com/N-Wouda/ALNS/blob/master/examples/resource_constrained_project_scheduling_problem.ipynb diff --git a/alns/ALNS.py b/alns/ALNS.py index 3faef7c0..6ae99d02 100644 --- a/alns/ALNS.py +++ b/alns/ALNS.py @@ -6,9 +6,9 @@ from alns.Result import Result from alns.State import State from alns.Statistics import Statistics -from alns.criteria import AcceptanceCriterion -from alns.weight_schemes import WeightScheme -from alns.stopping_criteria import StoppingCriterion +from alns.accept import AcceptanceCriterion +from alns.stop import StoppingCriterion +from alns.weights import WeightScheme # Potential candidate solution consideration outcomes. _BEST = 0 @@ -22,26 +22,27 @@ class ALNS: - def __init__(self, rnd_state: rnd.RandomState = rnd.RandomState()): - """ - Implements the adaptive large neighbourhood search (ALNS) algorithm. - The implementation optimises for a minimisation problem, as explained - in the text by Pisinger and Røpke (2010). - - Parameters - ---------- - rnd_state - Optional random state to use for random number generation. When - passed, this state is used for operator selection and general - computations requiring random numbers. It is also passed to the - destroy and repair operators, as a second argument. + """ + Implements the adaptive large neighbourhood search (ALNS) algorithm. + The implementation optimises for a minimisation problem, as explained + in the text by Pisinger and Røpke (2010). + + Parameters + ---------- + rnd_state + Optional random state to use for random number generation. When + passed, this state is used for operator selection and general + computations requiring random numbers. It is also passed to the + destroy and repair operators, as a second argument. + + References + ---------- + [1]: Pisinger, D., and Røpke, S. (2010). Large Neighborhood Search. In + M. Gendreau (Ed.), *Handbook of Metaheuristics* (2 ed., pp. 399 + - 420). Springer. + """ - References - ---------- - [1]: Pisinger, D., and Røpke, S. (2010). Large Neighborhood Search. In - M. Gendreau (Ed.), *Handbook of Metaheuristics* (2 ed., pp. 399 - - 420). Springer. - """ + def __init__(self, rnd_state: rnd.RandomState = rnd.RandomState()): self._destroy_operators: Dict[str, _OperatorType] = {} self._repair_operators: Dict[str, _OperatorType] = {} diff --git a/alns/Result.py b/alns/Result.py index 7f703daf..e3583dee 100644 --- a/alns/Result.py +++ b/alns/Result.py @@ -9,19 +9,19 @@ class Result: + """ + Stores ALNS results. An instance of this class is returned once the + algorithm completes. - def __init__(self, best: State, statistics: Statistics): - """ - Stores ALNS results. An instance of this class is returned once the - algorithm completes. + Parameters + ---------- + best + The best state observed during the entire iteration. + statistics + Statistics collected during iteration. + """ - Parameters - ---------- - best - The best state observed during the entire iteration. - statistics - Statistics collected during iteration. - """ + def __init__(self, best: State, statistics: Statistics): self._best = best self._statistics = statistics @@ -39,10 +39,12 @@ def statistics(self) -> Statistics: """ return self._statistics - def plot_objectives(self, - ax: Optional[Axes] = None, - title: Optional[str] = None, - **kwargs: Dict[str, Any]): + def plot_objectives( + self, + ax: Optional[Axes] = None, + title: Optional[str] = None, + **kwargs: Dict[str, Any] + ): """ Plots the collected objective values at each iteration. @@ -75,11 +77,13 @@ def plot_objectives(self, plt.draw_if_interactive() - def plot_operator_counts(self, - fig: Optional[Figure] = None, - title: Optional[str] = None, - legend: Optional[List[str]] = None, - **kwargs: Dict[str, Any]): + def plot_operator_counts( + self, + fig: Optional[Figure] = None, + title: Optional[str] = None, + legend: Optional[List[str]] = None, + **kwargs: Dict[str, Any] + ): """ Plots an overview of the destroy and repair operators' performance. @@ -114,17 +118,21 @@ def plot_operator_counts(self, if legend is None: legend = ["Best", "Better", "Accepted", "Rejected"] - self._plot_op_counts(d_ax, - self.statistics.destroy_operator_counts, - "Destroy operators", - min(len(legend), 4), - **kwargs) - - self._plot_op_counts(r_ax, - self.statistics.repair_operator_counts, - "Repair operators", - min(len(legend), 4), - **kwargs) + self._plot_op_counts( + d_ax, + self.statistics.destroy_operator_counts, + "Destroy operators", + min(len(legend), 4), + **kwargs + ) + + self._plot_op_counts( + r_ax, + self.statistics.repair_operator_counts, + "Repair operators", + min(len(legend), 4), + **kwargs + ) fig.legend(legend[:4], ncol=len(legend), loc="lower center") @@ -155,7 +163,7 @@ def _plot_op_counts(ax, operator_counts, title, num_types, **kwargs): ax.barh(operator_names, widths, left=starts, height=0.5, **kwargs) for y, (x, label) in enumerate(zip(starts + widths / 2, widths)): - ax.text(x, y, str(label), ha='center', va='center') + ax.text(x, y, str(label), ha="center", va="center") ax.set_title(title) ax.set_xlabel("Iterations where operator resulted in this outcome (#)") diff --git a/alns/Statistics.py b/alns/Statistics.py index a5b801c6..9b34fda4 100644 --- a/alns/Statistics.py +++ b/alns/Statistics.py @@ -5,12 +5,12 @@ class Statistics: + """ + Statistics object that stores some iteration results. Populated by the ALNS + algorithm. + """ def __init__(self): - """ - Statistics object that stores some iteration results, which is - optionally populated by the ALNS algorithm. - """ self._objectives = [] self._runtimes = [] diff --git a/alns/criteria/AcceptanceCriterion.py b/alns/accept/AcceptanceCriterion.py similarity index 83% rename from alns/criteria/AcceptanceCriterion.py rename to alns/accept/AcceptanceCriterion.py index 41daca79..8edc6309 100644 --- a/alns/criteria/AcceptanceCriterion.py +++ b/alns/accept/AcceptanceCriterion.py @@ -11,11 +11,9 @@ class AcceptanceCriterion(ABC): """ @abstractmethod - def __call__(self, - rnd: RandomState, - best: State, - current: State, - candidate: State) -> bool: + def __call__( + self, rnd: RandomState, best: State, current: State, candidate: State + ) -> bool: """ Determines whether to accept the proposed, candidate solution based on this acceptance criterion and the other solution states. diff --git a/alns/criteria/HillClimbing.py b/alns/accept/HillClimbing.py similarity index 81% rename from alns/criteria/HillClimbing.py rename to alns/accept/HillClimbing.py index a8bde38a..0232b990 100644 --- a/alns/criteria/HillClimbing.py +++ b/alns/accept/HillClimbing.py @@ -1,4 +1,4 @@ -from alns.criteria.AcceptanceCriterion import AcceptanceCriterion +from alns.accept.AcceptanceCriterion import AcceptanceCriterion class HillClimbing(AcceptanceCriterion): diff --git a/alns/accept/RecordToRecordTravel.py b/alns/accept/RecordToRecordTravel.py new file mode 100644 index 00000000..c183a13b --- /dev/null +++ b/alns/accept/RecordToRecordTravel.py @@ -0,0 +1,89 @@ +from alns.accept.AcceptanceCriterion import AcceptanceCriterion +from alns.accept.update import update + + +class RecordToRecordTravel(AcceptanceCriterion): + """ + Record-to-record travel, using an updating threshold. The threshold is + updated as, + + ``threshold = max(end_threshold, threshold - step)`` (linear) + + ``threshold = max(end_threshold, step * threshold)`` (exponential) + + where the initial threshold is set to ``start_threshold``. + + Parameters + ---------- + start_threshold + The initial threshold. + end_threshold + The final threshold. + step + The updating step. + method + The updating method, one of {'linear', 'exponential'}. Default + 'linear'. + + References + ---------- + [1]: Santini, A., Ropke, S. & Hvattum, L.M. A comparison of acceptance + criteria for the adaptive large neighbourhood search metaheuristic. + *Journal of Heuristics* (2018) 24 (5): 783–815. + [2]: Dueck, G., Scheuer, T. Threshold accepting: A general purpose + optimization algorithm appearing superior to simulated annealing. + *Journal of Computational Physics* (1990) 90 (1): 161-175. + """ + + def __init__( + self, + start_threshold: float, + end_threshold: float, + step: float, + method: str = "linear", + ): + if start_threshold < 0 or end_threshold < 0 or step < 0: + raise ValueError("Thresholds must be positive.") + + if start_threshold < end_threshold: + raise ValueError( + "End threshold must be bigger than start threshold." + ) + + if method == "exponential" and step > 1: + raise ValueError( + "Exponential updating cannot have explosive step parameter." + ) + + self._start_threshold = start_threshold + self._end_threshold = end_threshold + self._step = step + self._method = method + + self._threshold = start_threshold + + @property + def start_threshold(self) -> float: + return self._start_threshold + + @property + def end_threshold(self) -> float: + return self._end_threshold + + @property + def step(self) -> float: + return self._step + + @property + def method(self) -> str: + return self._method + + def __call__(self, rnd, best, current, candidate): + # This follows from the paper by Dueck and Scheueur (1990), p. 162. + result = (candidate.objective() - best.objective()) <= self._threshold + + self._threshold = max( + self.end_threshold, update(self._threshold, self.step, self.method) + ) + + return result diff --git a/alns/criteria/SimulatedAnnealing.py b/alns/accept/SimulatedAnnealing.py similarity index 61% rename from alns/criteria/SimulatedAnnealing.py rename to alns/accept/SimulatedAnnealing.py index 378b9658..b637262c 100644 --- a/alns/criteria/SimulatedAnnealing.py +++ b/alns/accept/SimulatedAnnealing.py @@ -1,56 +1,60 @@ import numpy as np -from alns.criteria.AcceptanceCriterion import AcceptanceCriterion -from alns.criteria.update import update +from alns.accept.AcceptanceCriterion import AcceptanceCriterion +from alns.accept.update import update class SimulatedAnnealing(AcceptanceCriterion): - - def __init__(self, - start_temperature: float, - end_temperature: float, - step: float, - method: str = "exponential"): - """ - Simulated annealing, using an updating temperature. The temperature is - updated as, - - ``temperature = max(end_temperature, temperature - step)`` (linear) - - ``temperature = max(end_temperature, step * temperature)`` (exponential) - - where the initial temperature is set to ``start_temperature``. - - Parameters - ---------- - start_temperature - The initial temperature. - end_temperature - The final temperature. - step - The updating step. - method - The updating method, one of {'linear', 'exponential'}. Default - 'exponential'. - - References - ---------- - [1]: Santini, A., Ropke, S. & Hvattum, L.M. A comparison of acceptance - criteria for the adaptive large neighbourhood search metaheuristic. - *Journal of Heuristics* (2018) 24 (5): 783–815. - [2]: Kirkpatrick, S., Gerlatt, C. D. Jr., and Vecchi, M. P. Optimization - by Simulated Annealing. *IBM Research Report* RC 9355, 1982. - """ + """ + Simulated annealing, using an updating temperature. The temperature is + updated as, + + ``temperature = max(end_temperature, temperature - step)`` (linear) + + ``temperature = max(end_temperature, step * temperature)`` (exponential) + + where the initial temperature is set to ``start_temperature``. + + Parameters + ---------- + start_temperature + The initial temperature. + end_temperature + The final temperature. + step + The updating step. + method + The updating method, one of {'linear', 'exponential'}. Default + 'exponential'. + + References + ---------- + [1]: Santini, A., Ropke, S. & Hvattum, L.M. A comparison of acceptance + criteria for the adaptive large neighbourhood search metaheuristic. + *Journal of Heuristics* (2018) 24 (5): 783–815. + [2]: Kirkpatrick, S., Gerlatt, C. D. Jr., and Vecchi, M. P. Optimization + by Simulated Annealing. *IBM Research Report* RC 9355, 1982. + """ + + def __init__( + self, + start_temperature: float, + end_temperature: float, + step: float, + method: str = "exponential", + ): if start_temperature <= 0 or end_temperature <= 0 or step < 0: raise ValueError("Temperatures must be strictly positive.") if start_temperature < end_temperature: - raise ValueError("Start temperature must be bigger than end " - "temperature.") + raise ValueError( + "Start temperature must be bigger than end temperature." + ) if method == "exponential" and step > 1: - raise ValueError("For exponential updating, the step parameter " - "must not be explosive.") + raise ValueError( + "Exponential updating cannot have explosive step parameter." + ) self._start_temperature = start_temperature self._end_temperature = end_temperature @@ -76,14 +80,16 @@ def method(self) -> str: return self._method def __call__(self, rnd, best, current, candidate): - probability = np.exp((current.objective() - candidate.objective()) - / self._temperature) + probability = np.exp( + (current.objective() - candidate.objective()) / self._temperature + ) # We should not set a temperature that is lower than the end # temperature. - self._temperature = max(self.end_temperature, update(self._temperature, - self.step, - self.method)) + self._temperature = max( + self.end_temperature, + update(self._temperature, self.step, self.method), + ) # TODO deprecate RandomState in favour of Generator - which uses # random(), rather than random_sample(). @@ -93,11 +99,9 @@ def __call__(self, rnd, best, current, candidate): return probability >= rnd.random_sample() @classmethod - def autofit(cls, - init_obj: float, - worse: float, - accept_prob: float, - num_iters: int) -> "SimulatedAnnealing": + def autofit( + cls, init_obj: float, worse: float, accept_prob: float, num_iters: int + ) -> "SimulatedAnnealing": """ Returns an SA object with initial temperature such that there is a ``accept_prob`` chance of selecting a solution up to ``worse`` percent diff --git a/alns/criteria/__init__.py b/alns/accept/__init__.py similarity index 100% rename from alns/criteria/__init__.py rename to alns/accept/__init__.py diff --git a/alns/criteria/tests/__init__.py b/alns/accept/tests/__init__.py similarity index 100% rename from alns/criteria/tests/__init__.py rename to alns/accept/tests/__init__.py diff --git a/alns/criteria/tests/test_hill_climbing.py b/alns/accept/tests/test_hill_climbing.py similarity index 95% rename from alns/criteria/tests/test_hill_climbing.py rename to alns/accept/tests/test_hill_climbing.py index b9d64217..a73d3791 100644 --- a/alns/criteria/tests/test_hill_climbing.py +++ b/alns/accept/tests/test_hill_climbing.py @@ -1,7 +1,7 @@ import numpy.random as rnd from numpy.testing import assert_ -from alns.criteria import HillClimbing +from alns.accept import HillClimbing from alns.tests.states import Zero, One diff --git a/alns/criteria/tests/test_record_to_record_travel.py b/alns/accept/tests/test_record_to_record_travel.py similarity index 87% rename from alns/criteria/tests/test_record_to_record_travel.py rename to alns/accept/tests/test_record_to_record_travel.py index 7890dfc9..273d7033 100644 --- a/alns/criteria/tests/test_record_to_record_travel.py +++ b/alns/accept/tests/test_record_to_record_travel.py @@ -1,7 +1,7 @@ import numpy.random as rnd from numpy.testing import assert_, assert_equal, assert_raises -from alns.criteria import RecordToRecordTravel +from alns.accept import RecordToRecordTravel from alns.tests.states import One, Zero @@ -10,13 +10,13 @@ def test_raises_negative_parameters(): Record-to-record travel does not work with negative parameters, so those should not be accepted. """ - with assert_raises(ValueError): # start threshold cannot be - RecordToRecordTravel(-1, 1, 1) # negative + with assert_raises(ValueError): # start threshold cannot be negative + RecordToRecordTravel(-1, 1, 1) - with assert_raises(ValueError): # nor can the end threshold + with assert_raises(ValueError): # nor can the end threshold RecordToRecordTravel(1, -1, 1) - with assert_raises(ValueError): # nor the updating step + with assert_raises(ValueError): # nor the updating step RecordToRecordTravel(1, 1, -1) @@ -28,7 +28,7 @@ def test_raises_explosive_step(): with assert_raises(ValueError): RecordToRecordTravel(2, 1, 2, "exponential") - RecordToRecordTravel(2, 1, 1, "exponential") # boundary should be fine + RecordToRecordTravel(2, 1, 1, "exponential") # boundary should be fine def test_threshold_boundary(): @@ -47,7 +47,7 @@ def test_raises_start_smaller_than_end(): with assert_raises(ValueError): RecordToRecordTravel(0, 1, 1) - RecordToRecordTravel(1, 1, 1) # should not raise for equality + RecordToRecordTravel(1, 1, 1) # should not raise for equality def test_does_not_raise(): @@ -123,4 +123,3 @@ def test_exponential_threshold_update(): # second should be rejected. assert_(record_travel(rnd.RandomState(), Zero(), Zero(), One())) assert_(not record_travel(rnd.RandomState(), Zero(), Zero(), One())) - diff --git a/alns/criteria/tests/test_simulated_annealing.py b/alns/accept/tests/test_simulated_annealing.py similarity index 79% rename from alns/criteria/tests/test_simulated_annealing.py rename to alns/accept/tests/test_simulated_annealing.py index df4cf24d..673e13f7 100644 --- a/alns/criteria/tests/test_simulated_annealing.py +++ b/alns/accept/tests/test_simulated_annealing.py @@ -1,17 +1,25 @@ import numpy as np import numpy.random as rnd -from numpy.testing import (assert_, assert_almost_equal, assert_equal, - assert_raises) +from numpy.testing import ( + assert_, + assert_almost_equal, + assert_equal, + assert_raises, +) from pytest import mark -from alns.criteria import SimulatedAnnealing +from alns.accept import SimulatedAnnealing from alns.tests.states import One, Zero -@mark.parametrize("start,end,step", - [(-1, 1, 1), # negative start temp - (1, -1, 1), # negative end temp - (1, 1, -1)]) # negative step +@mark.parametrize( + "start,end,step", + [ + (-1, 1, 1), + (1, -1, 1), + (1, 1, -1), + ], +) def test_raises_negative_parameters(start: float, end: float, step: float): """ Simulated annealing does not work with negative parameters, so those should @@ -154,28 +162,32 @@ def random(self): # pylint: disable=no-self-use assert_(simulated_annealing(New(), One(), One(), Zero())) -@mark.parametrize("worse,accept_prob,iters", - [(1, 0, 10), # zero accept prob - (1, 1.2, 10), # prob outside unit interval - (1, 1, 10), # unit accept prob - (-1, 0.5, 10), # negative worse - (0, -1, 10), # negative prob - (1.5, 0.5, 10), # worse outside unit interval - (1, .9, -10)]) # negative number of iterations -def test_autofit_raises_for_invalid_inputs(worse: float, - accept_prob: float, - iters: int): +@mark.parametrize( + "worse,accept_prob,iters", + [ + (1, 0, 10), # zero accept prob + (1, 1.2, 10), # prob outside unit interval + (1, 1, 10), # unit accept prob + (-1, 0.5, 10), # negative worse + (0, -1, 10), # negative prob + (1.5, 0.5, 10), # worse outside unit interval + (1, 0.9, -10), + ], +) # negative number of iterations +def test_autofit_raises_for_invalid_inputs( + worse: float, accept_prob: float, iters: int +): with assert_raises(ValueError): - SimulatedAnnealing.autofit(1., worse, accept_prob, iters) + SimulatedAnnealing.autofit(1.0, worse, accept_prob, iters) -@mark.parametrize("init_obj,worse,accept_prob,iters", - [(1_000, 1, .9, 1), - (1_000, .5, .05, 1)]) -def test_autofit_on_several_examples(init_obj: float, - worse: float, - accept_prob: float, - iters: int): +@mark.parametrize( + "init_obj,worse,accept_prob,iters", + [(1_000, 1, 0.9, 1), (1_000, 0.5, 0.05, 1)], +) +def test_autofit_on_several_examples( + init_obj: float, worse: float, accept_prob: float, iters: int +): # We have: # prob = exp{-(f^c - f^i) / T}, # where T is start temp, f^i is init sol objective, and f^c is the candidate diff --git a/alns/criteria/tests/test_update.py b/alns/accept/tests/test_update.py similarity index 73% rename from alns/criteria/tests/test_update.py rename to alns/accept/tests/test_update.py index fa9443b9..c83d1309 100644 --- a/alns/criteria/tests/test_update.py +++ b/alns/accept/tests/test_update.py @@ -1,4 +1,4 @@ -from alns.criteria.update import update +from alns.accept.update import update from numpy.testing import assert_raises, assert_equal @@ -6,18 +6,15 @@ def test_raises_unknown_method(): with assert_raises(ValueError): update(1, 0.5, "unknown_method") - update(1, 0.5, "linear") # this should work + update(1, 0.5, "linear") # this should work def test_accepts_any_case_method(): """ - ``update`` should be indifferent about the passed-in method casing. + ``update`` should be indifferent about the passed-in method case. """ - assert_equal(update(1, 0.5, "linear"), - update(1, 0.5, "LINEAR")) - - assert_equal(update(1, 0.5, "exponential"), - update(1, 0.5, "EXPONENTIAL")) + assert_equal(update(1, 0.5, "linear"), update(1, 0.5, "LINEAR")) + assert_equal(update(1, 0.5, "exponential"), update(1, 0.5, "EXPONENTIAL")) def test_linear(): diff --git a/alns/criteria/update.py b/alns/accept/update.py similarity index 100% rename from alns/criteria/update.py rename to alns/accept/update.py diff --git a/alns/criteria/RecordToRecordTravel.py b/alns/criteria/RecordToRecordTravel.py deleted file mode 100644 index 15a042a2..00000000 --- a/alns/criteria/RecordToRecordTravel.py +++ /dev/null @@ -1,84 +0,0 @@ -from alns.criteria.AcceptanceCriterion import AcceptanceCriterion -from alns.criteria.update import update - - -class RecordToRecordTravel(AcceptanceCriterion): - - def __init__(self, - start_threshold: float, - end_threshold: float, - step: float, - method: str = "linear"): - """ - Record-to-record travel, using an updating threshold. The threshold is - updated as, - - ``threshold = max(end_threshold, threshold - step)`` (linear) - - ``threshold = max(end_threshold, step * threshold)`` (exponential) - - where the initial threshold is set to ``start_threshold``. - - Parameters - ---------- - start_threshold - The initial threshold. - end_threshold - The final threshold. - step - The updating step. - method - The updating method, one of {'linear', 'exponential'}. Default - 'linear'. - - References - ---------- - [1]: Santini, A., Ropke, S. & Hvattum, L.M. A comparison of acceptance - criteria for the adaptive large neighbourhood search metaheuristic. - *Journal of Heuristics* (2018) 24 (5): 783–815. - [2]: Dueck, G., Scheuer, T. Threshold accepting: A general purpose - optimization algorithm appearing superior to simulated annealing. - *Journal of Computational Physics* (1990) 90 (1): 161-175. - """ - if start_threshold < 0 or end_threshold < 0 or step < 0: - raise ValueError("Thresholds must be positive.") - - if start_threshold < end_threshold: - raise ValueError("Start threshold must be bigger than end " - "threshold.") - - if method == "exponential" and step > 1: - raise ValueError("For exponential updating, the step parameter " - "must not be explosive.") - - self._start_threshold = start_threshold - self._end_threshold = end_threshold - self._step = step - self._method = method - - self._threshold = start_threshold - - @property - def start_threshold(self) -> float: - return self._start_threshold - - @property - def end_threshold(self) -> float: - return self._end_threshold - - @property - def step(self) -> float: - return self._step - - @property - def method(self) -> str: - return self._method - - def __call__(self, rnd, best, current, candidate): - # This follows from the paper by Dueck and Scheueur (1990), p. 162. - result = (candidate.objective() - best.objective()) <= self._threshold - - self._threshold = max(self.end_threshold, - update(self._threshold, self.step, self.method)) - - return result diff --git a/alns/stopping_criteria/MaxIterations.py b/alns/stop/MaxIterations.py similarity index 78% rename from alns/stopping_criteria/MaxIterations.py rename to alns/stop/MaxIterations.py index 6e46b5ba..a5fd5a52 100644 --- a/alns/stopping_criteria/MaxIterations.py +++ b/alns/stop/MaxIterations.py @@ -1,14 +1,15 @@ from numpy.random import RandomState from alns.State import State -from alns.stopping_criteria.StoppingCriterion import StoppingCriterion +from alns.stop.StoppingCriterion import StoppingCriterion class MaxIterations(StoppingCriterion): + """ + Criterion that stops after a maximum number of iterations. + """ + def __init__(self, max_iterations: int): - """ - Criterion that stops after a maximum number of iterations. - """ if max_iterations < 0: raise ValueError("Max iterations must be non-negative.") diff --git a/alns/stopping_criteria/MaxRuntime.py b/alns/stop/MaxRuntime.py similarity index 72% rename from alns/stopping_criteria/MaxRuntime.py rename to alns/stop/MaxRuntime.py index fdde6473..4c8fc719 100644 --- a/alns/stopping_criteria/MaxRuntime.py +++ b/alns/stop/MaxRuntime.py @@ -4,14 +4,15 @@ from numpy.random import RandomState from alns.State import State -from alns.stopping_criteria.StoppingCriterion import StoppingCriterion +from alns.stop.StoppingCriterion import StoppingCriterion class MaxRuntime(StoppingCriterion): + """ + Criterion that stops after a specified maximum runtime. + """ + def __init__(self, max_runtime: float): - """ - Criterion that stops after a specified maximum runtime. - """ if max_runtime < 0: raise ValueError("Max runtime must be non-negative.") @@ -26,4 +27,4 @@ def __call__(self, rnd: RandomState, best: State, current: State) -> bool: if self._start_runtime is None: self._start_runtime = time.perf_counter() - return time.perf_counter () - self._start_runtime > self.max_runtime + return time.perf_counter() - self._start_runtime > self.max_runtime diff --git a/alns/stopping_criteria/StoppingCriterion.py b/alns/stop/StoppingCriterion.py similarity index 91% rename from alns/stopping_criteria/StoppingCriterion.py rename to alns/stop/StoppingCriterion.py index 3bf6960b..0bfec0ac 100644 --- a/alns/stopping_criteria/StoppingCriterion.py +++ b/alns/stop/StoppingCriterion.py @@ -26,6 +26,6 @@ def __call__(self, rnd: RandomState, best: State, current: State) -> bool: Returns ------- - Whether to stop the iteration (True), or not (False). + Whether to stop iterating (True), or not (False). """ return NotImplemented diff --git a/alns/stopping_criteria/__init__.py b/alns/stop/__init__.py similarity index 100% rename from alns/stopping_criteria/__init__.py rename to alns/stop/__init__.py diff --git a/alns/stopping_criteria/tests/__init__.py b/alns/stop/tests/__init__.py similarity index 100% rename from alns/stopping_criteria/tests/__init__.py rename to alns/stop/tests/__init__.py diff --git a/alns/stopping_criteria/tests/test_max_iterations.py b/alns/stop/tests/test_max_iterations.py similarity index 96% rename from alns/stopping_criteria/tests/test_max_iterations.py rename to alns/stop/tests/test_max_iterations.py index f8eae995..a2c72764 100644 --- a/alns/stopping_criteria/tests/test_max_iterations.py +++ b/alns/stop/tests/test_max_iterations.py @@ -1,9 +1,8 @@ import pytest - from numpy.random import RandomState from numpy.testing import assert_, assert_raises -from alns.stopping_criteria import MaxIterations +from alns.stop import MaxIterations from alns.tests.states import Zero diff --git a/alns/stopping_criteria/tests/test_max_runtime.py b/alns/stop/tests/test_max_runtime.py similarity index 93% rename from alns/stopping_criteria/tests/test_max_runtime.py rename to alns/stop/tests/test_max_runtime.py index e3e9a2ef..a7a77a91 100644 --- a/alns/stopping_criteria/tests/test_max_runtime.py +++ b/alns/stop/tests/test_max_runtime.py @@ -1,10 +1,10 @@ import time -import pytest +import pytest from numpy.random import RandomState -from numpy.testing import assert_, assert_almost_equal, assert_raises +from numpy.testing import assert_, assert_raises -from alns.stopping_criteria import MaxRuntime +from alns.stop import MaxRuntime from alns.tests.states import Zero diff --git a/alns/tests/states.py b/alns/tests/states.py index e7a00816..537cf9ed 100644 --- a/alns/tests/states.py +++ b/alns/tests/states.py @@ -32,4 +32,3 @@ class Sentinel(Zero): """ Placeholder state. """ - pass diff --git a/alns/tests/test_alns.py b/alns/tests/test_alns.py index 67c0e2cc..10fbfa3e 100644 --- a/alns/tests/test_alns.py +++ b/alns/tests/test_alns.py @@ -1,19 +1,25 @@ import numpy.random as rnd -from numpy.testing import (assert_, assert_almost_equal, assert_equal, - assert_raises) +from numpy.testing import ( + assert_, + assert_almost_equal, + assert_equal, + assert_raises, +) from pytest import mark from alns import ALNS, State -from alns.criteria import HillClimbing, SimulatedAnnealing -from alns.stopping_criteria import MaxIterations, MaxRuntime -from alns.weight_schemes import SimpleWeights +from alns.accept import HillClimbing, SimulatedAnnealing +from alns.stop import MaxIterations, MaxRuntime +from alns.weights import SimpleWeights from .states import One, Zero # HELPERS ---------------------------------------------------------------------- -def get_alns_instance(repair_operators=None, destroy_operators=None, seed=None): +def get_alns_instance( + repair_operators=None, destroy_operators=None, seed=None +): """ Test helper method. """ @@ -49,15 +55,16 @@ def test_on_best_is_called(): """ Tests if the callback is invoked when a new global best is found. """ - alns = get_alns_instance([lambda state, rnd: Zero()], - [lambda state, rnd: Zero()]) + alns = get_alns_instance( + [lambda state, rnd: Zero()], [lambda state, rnd: Zero()] + ) # Called when a new global best is found. In this case, that happens once: # in the only iteration below. It returns a state with value 10, which # should then also be returned by the entire algorithm. alns.on_best(lambda *args: ValueState(10)) - weights = SimpleWeights([1, 1, 1, 1], 1, 1, .5) + weights = SimpleWeights([1, 1, 1, 1], 1, 1, 0.5) result = alns.iterate(One(), weights, HillClimbing(), MaxIterations(1)) assert_equal(result.best_state.objective(), 10) @@ -204,10 +211,12 @@ def test_operator(state, rnd, item): alns = get_alns_instance([lambda state, rnd, item: state], [test_operator]) init_sol = One() - weights = SimpleWeights([1, 1, 1, 1], 1, 1, .5) + weights = SimpleWeights([1, 1, 1, 1], 1, 1, 0.5) orig_item = object() - alns.iterate(init_sol, weights, HillClimbing(), MaxIterations(10), item=orig_item) + alns.iterate( + init_sol, weights, HillClimbing(), MaxIterations(10), item=orig_item + ) def test_bugfix_pass_kwargs_to_on_best(): diff --git a/alns/tests/test_result.py b/alns/tests/test_result.py index faaeb8af..e0106b71 100644 --- a/alns/tests/test_result.py +++ b/alns/tests/test_result.py @@ -10,6 +10,7 @@ try: from matplotlib.testing.decorators import check_figures_equal except ImportError: + def check_figures_equal(*args, **kwargs): # placeholder return check_figures_equal @@ -54,7 +55,7 @@ def get_objective_plot(ax, data, **kwargs): """ Helper method. """ - title = kwargs.pop('title', None) + title = kwargs.pop("title", None) if title is None: title = "Objective value at each iteration" @@ -69,8 +70,9 @@ def get_objective_plot(ax, data, **kwargs): ax.legend(["Current", "Best"], loc="upper right") -def get_operator_plot(figure, destroy, repair, legend=None, suptitle=None, - **kwargs): +def get_operator_plot( + figure, destroy, repair, legend=None, suptitle=None, **kwargs +): """ Helper method. """ @@ -79,7 +81,7 @@ def _helper(ax, operator_counts, title): operator_names = list(operator_counts.keys()) operator_counts = np.array(list(operator_counts.values())) - cumulative_counts = operator_counts[:, :len(legend)].cumsum(axis=1) + cumulative_counts = operator_counts[:, : len(legend)].cumsum(axis=1) ax.set_xlim(right=cumulative_counts[:, -1].max()) @@ -90,7 +92,7 @@ def _helper(ax, operator_counts, title): ax.barh(operator_names, widths, left=starts, height=0.5, **kwargs) for y, (x, label) in enumerate(zip(starts + widths / 2, widths)): - ax.text(x, y, str(label), ha='center', va='center') + ax.text(x, y, str(label), ha="center", va="center") ax.set_title(title) ax.set_xlabel("Iterations where operator resulted in this outcome (#)") @@ -107,9 +109,7 @@ def _helper(ax, operator_counts, title): _helper(d_ax, destroy, "Destroy operators") _helper(r_ax, repair, "Repair operators") - figure.legend(legend, - ncol=len(legend), - loc="lower center") + figure.legend(legend, ncol=len(legend), loc="lower center") # TESTS ------------------------------------------------------------------------ @@ -125,7 +125,7 @@ def test_result_state(): @pytest.mark.matplotlib -@check_figures_equal(extensions=['png']) +@check_figures_equal(extensions=["png"]) def test_plot_objectives(fig_test, fig_ref): """ Tests if the ``plot_objectives`` method returns the same figure as a @@ -141,22 +141,22 @@ def test_plot_objectives(fig_test, fig_ref): @pytest.mark.matplotlib -@check_figures_equal(extensions=['png']) +@check_figures_equal(extensions=["png"]) def test_plot_objectives_kwargs(fig_test, fig_ref): """ Tests if the passed-in keyword arguments to ``plot_objectives`` are correctly passed to the ``plot`` method. """ result = get_result(Sentinel()) - kwargs = dict(lw=5, marker='*') + kwargs = dict(lw=5, marker="*") # Tested plot result.plot_objectives(fig_test.subplots(), **kwargs) # Reference plot - get_objective_plot(fig_ref.subplots(), - result.statistics.objectives, - **kwargs) + get_objective_plot( + fig_ref.subplots(), result.statistics.objectives, **kwargs + ) @pytest.mark.matplotlib @@ -172,7 +172,7 @@ def test_plot_objectives_default_axes(): @pytest.mark.matplotlib -@check_figures_equal(extensions=['png']) +@check_figures_equal(extensions=["png"]) def test_plot_operator_counts(fig_test, fig_ref): """ Tests if the ``plot_operator_counts`` method returns the same figure as a @@ -184,13 +184,15 @@ def test_plot_operator_counts(fig_test, fig_ref): result.plot_operator_counts(fig_test) # Reference plot - get_operator_plot(fig_ref, - result.statistics.destroy_operator_counts, - result.statistics.repair_operator_counts) + get_operator_plot( + fig_ref, + result.statistics.destroy_operator_counts, + result.statistics.repair_operator_counts, + ) @pytest.mark.matplotlib -@check_figures_equal(extensions=['png']) +@check_figures_equal(extensions=["png"]) def test_plot_operator_counts_title(fig_test, fig_ref): """ Tests if ``plot_operator_counts`` sets a plot title correctly. @@ -201,10 +203,12 @@ def test_plot_operator_counts_title(fig_test, fig_ref): result.plot_operator_counts(fig_test, title="A random test title") # Reference plot - get_operator_plot(fig_ref, - result.statistics.destroy_operator_counts, - result.statistics.repair_operator_counts, - suptitle="A random test title") + get_operator_plot( + fig_ref, + result.statistics.destroy_operator_counts, + result.statistics.repair_operator_counts, + suptitle="A random test title", + ) @pytest.mark.matplotlib @@ -220,27 +224,29 @@ def test_plot_operator_counts_default_figure(): @pytest.mark.matplotlib -@check_figures_equal(extensions=['png']) +@check_figures_equal(extensions=["png"]) def test_plot_operator_counts_kwargs(fig_test, fig_ref): """ Tests if the passed-in keyword arguments to ``plot_operator_counts`` are correctly passed to the ``barh`` method. """ result = get_result(Sentinel()) - kwargs = dict(alpha=.5, lw=2) + kwargs = dict(alpha=0.5, lw=2) # Tested plot result.plot_operator_counts(fig_test, **kwargs) # Reference plot - get_operator_plot(fig_ref, - result.statistics.destroy_operator_counts, - result.statistics.repair_operator_counts, - **kwargs) + get_operator_plot( + fig_ref, + result.statistics.destroy_operator_counts, + result.statistics.repair_operator_counts, + **kwargs + ) @pytest.mark.matplotlib -@check_figures_equal(extensions=['png']) +@check_figures_equal(extensions=["png"]) def test_plot_operator_counts_legend_length(fig_test, fig_ref): """ Tests if the length of the passed-in legend is used to determine which @@ -252,7 +258,9 @@ def test_plot_operator_counts_legend_length(fig_test, fig_ref): result.plot_operator_counts(fig_test, legend=["Best"]) # Reference plot - get_operator_plot(fig_ref, - result.statistics.destroy_operator_counts, - result.statistics.repair_operator_counts, - legend=["Best"]) + get_operator_plot( + fig_ref, + result.statistics.destroy_operator_counts, + result.statistics.repair_operator_counts, + legend=["Best"], + ) diff --git a/alns/tests/test_statistics.py b/alns/tests/test_statistics.py index f042c204..ea831602 100644 --- a/alns/tests/test_statistics.py +++ b/alns/tests/test_statistics.py @@ -65,7 +65,6 @@ def test_total_runtime(): assert_equal(statistics.total_runtime, 99) - def test_collect_destroy_counts_example(): """ Tests if collecting for a destroy operator works as expected in a simple @@ -79,8 +78,9 @@ def test_collect_destroy_counts_example(): statistics.collect_destroy_operator("destroy_test", 1) for idx, count in enumerate([0, 2, 0, 0]): - assert_equal(statistics.destroy_operator_counts["destroy_test"][idx], - count) + assert_equal( + statistics.destroy_operator_counts["destroy_test"][idx], count + ) def test_collect_repair_counts_example(): @@ -95,5 +95,6 @@ def test_collect_repair_counts_example(): statistics.collect_repair_operator("repair_test", 2) for idx, count in enumerate([0, 0, 1, 0]): - assert_equal(statistics.repair_operator_counts["repair_test"][idx], - count) + assert_equal( + statistics.repair_operator_counts["repair_test"][idx], count + ) diff --git a/alns/weight_schemes/SimpleWeights.py b/alns/weight_schemes/SimpleWeights.py deleted file mode 100644 index 7b5d7aa7..00000000 --- a/alns/weight_schemes/SimpleWeights.py +++ /dev/null @@ -1,41 +0,0 @@ -from typing import List - -from .WeightScheme import WeightScheme - - -class SimpleWeights(WeightScheme): - - def __init__(self, - scores: List[float], - num_destroy: int, - num_repair: int, - op_decay: float): - """ - A simple weighting scheme, where the operator weights are adjusted - continuously throughout the algorithm runs. This works as follows. - In each iteration, the old weight is updated with a score based on a - convex combination of the existing weight and the new score, as: - - ``new_weight = op_decay * old_weight + (1 - op_decay) * score`` - - Parameters - ---------- - (other arguments are explained in ``WeightScheme``) - - op_decay - Decay parameter in [0, 1]. This parameter is used to weigh the - running performance of each operator. - """ - super().__init__(scores, num_destroy, num_repair) - - if not (0 <= op_decay <= 1): - raise ValueError("op_decay outside [0, 1] not understood.") - - self._op_decay = op_decay - - def update_weights(self, d_idx, r_idx, s_idx): - self._d_weights[d_idx] *= self._op_decay - self._d_weights[d_idx] += (1 - self._op_decay) * self._scores[s_idx] - - self._r_weights[r_idx] *= self._op_decay - self._r_weights[r_idx] += (1 - self._op_decay) * self._scores[s_idx] diff --git a/alns/weight_schemes/tests/test_segmented_weights.py b/alns/weight_schemes/tests/test_segmented_weights.py deleted file mode 100644 index 34d6ab0a..00000000 --- a/alns/weight_schemes/tests/test_segmented_weights.py +++ /dev/null @@ -1,62 +0,0 @@ -from typing import List - -import numpy as np -from numpy.testing import assert_almost_equal, assert_raises -from pytest import mark - -from alns.weight_schemes import SegmentedWeights - - -@mark.parametrize("seg_decay", [1.01, -0.01, -0.5, 1.5]) -def test_raises_invalid_seg_decay(seg_decay: float): - with assert_raises(ValueError): - SegmentedWeights([0, 0, 0, 0], 1, 1, seg_decay) - - -@mark.parametrize("seg_decay", np.linspace(0, 1, num=5)) -def test_does_not_raise_valid_seg_decay(seg_decay: float): - SegmentedWeights([0, 0, 0, 0], 1, 1, seg_decay) - - -@mark.parametrize("scores,seg_decay,expected", - [([5, 3, 2, 1], 0, [3, 3]), # 1 * 0 + (0 + 3) * 1 = 3 - ([5, 3, 2, 1], 1, [1, 1]), # 1 * 1 + (0 + 3) * 0 = 1 - ([5, 3, 2, 1], .5, [2, 2]), # .5 * 1 + (0 + 3) * .5 = 2 - ([5, 5, 5, 5], 0, [5, 5]), # etc. etc. - ([5, 5, 5, 5], 1, [1, 1]), - ([5, 5, 5, 5], .5, [3, 3])]) -def test_update_weights(scores: List[float], - seg_decay: float, - expected: List[float]): - rnd_state = np.random.RandomState(1) - weights = SegmentedWeights(scores, 1, 1, seg_decay, 1) - - # TODO other weights? - weights.update_weights(0, 0, 1) - weights.select_operators(rnd_state) - - assert_almost_equal(weights.destroy_weights[0], expected[0]) - assert_almost_equal(weights.repair_weights[0], expected[1]) - - -@mark.parametrize("scores,num_destroy,num_repair,seg_decay,seg_length", - [ - ([5, 3, 2, -1], 1, 1, 0, 1), # negative score - ([5, 3, 2], 1, 1, 0, 1), # len(score) < 4 - ([5, 3, 2, 1], 0, 1, 0, 1), # no destroy operator - ([5, 3, 2, 1], 1, 0, 0, 1), # no repair operator - ([5, 3, 2, 1], 1, 1, -1, 1), # seg_decay < 0 - ([5, 3, 2, 1], 1, 1, 2, 1), # seg_decay > 1 - ([5, 3, 2, 1], 1, 1, .5, 0), # seg_length < 1 - ]) -def test_raises_invalid_arguments(scores: List[float], - num_destroy: int, - num_repair: int, - seg_decay: float, - seg_length: int): - with assert_raises(ValueError): - SegmentedWeights(scores, num_destroy, num_repair, seg_decay, - seg_length) - - -# TODO test select weights, at iteration start diff --git a/alns/weight_schemes/SegmentedWeights.py b/alns/weights/SegmentedWeights.py similarity index 55% rename from alns/weight_schemes/SegmentedWeights.py rename to alns/weights/SegmentedWeights.py index 48de9267..a6775c67 100644 --- a/alns/weight_schemes/SegmentedWeights.py +++ b/alns/weights/SegmentedWeights.py @@ -2,39 +2,41 @@ import numpy as np -from alns.weight_schemes.WeightScheme import WeightScheme +from alns.weights.WeightScheme import WeightScheme class SegmentedWeights(WeightScheme): - - def __init__(self, - scores: List[float], - num_destroy: int, - num_repair: int, - seg_decay: float, - seg_length: int = 100): - """ - A segmented weight scheme. Weights are not updated in each iteration, - but only after each segment. Scores are gathered during each segment, - as: - - ``seg_weight += score`` - - At the start of each segment, ``seg_weight`` is reset to zero. At the - end of a segment, the weights are updated as: - - ``new_weight = seg_decay * old_weight + (1 - seg_decay) * seg_weight`` - - Parameters - ---------- - (other arguments are explained in ``WeightScheme``) - - seg_decay - Decay parameter in [0, 1]. This parameter is used to weigh segment - and overall performance of each operator. - seg_length - Length of a single segment. Default 100. - """ + """ + A segmented weight scheme. Weights are not updated in each iteration, + but only after each segment. Scores are gathered during each segment, + as: + + ``seg_weight += score`` + + At the start of each segment, ``seg_weight`` is reset to zero. At the + end of a segment, the weights are updated as: + + ``new_weight = seg_decay * old_weight + (1 - seg_decay) * seg_weight`` + + Parameters + ---------- + (other arguments are explained in ``WeightScheme``) + + seg_decay + Decay parameter in [0, 1]. This parameter is used to weigh segment + and overall performance of each operator. + seg_length + Length of a single segment. Default 100. + """ + + def __init__( + self, + scores: List[float], + num_destroy: int, + num_repair: int, + seg_decay: float, + seg_length: int = 100, + ): super().__init__(scores, num_destroy, num_repair) if not (0 <= seg_decay <= 1): diff --git a/alns/weights/SimpleWeights.py b/alns/weights/SimpleWeights.py new file mode 100644 index 00000000..6d81a2cd --- /dev/null +++ b/alns/weights/SimpleWeights.py @@ -0,0 +1,43 @@ +from typing import List + +from .WeightScheme import WeightScheme + + +class SimpleWeights(WeightScheme): + """ + A simple weighting scheme, where the operator weights are adjusted + continuously throughout the algorithm runs. This works as follows. + In each iteration, the old weight is updated with a score based on a + convex combination of the existing weight and the new score, as: + + ``new_weight = op_decay * old_weight + (1 - op_decay) * score`` + + Parameters + ---------- + (other arguments are explained in ``WeightScheme``) + + op_decay + Decay parameter in [0, 1]. This parameter is used to weigh the + running performance of each operator. + """ + + def __init__( + self, + scores: List[float], + num_destroy: int, + num_repair: int, + op_decay: float, + ): + super().__init__(scores, num_destroy, num_repair) + + if not (0 <= op_decay <= 1): + raise ValueError("op_decay outside [0, 1] not understood.") + + self._op_decay = op_decay + + def update_weights(self, d_idx, r_idx, s_idx): + self._d_weights[d_idx] *= self._op_decay + self._d_weights[d_idx] += (1 - self._op_decay) * self._scores[s_idx] + + self._r_weights[r_idx] *= self._op_decay + self._r_weights[r_idx] += (1 - self._op_decay) * self._scores[s_idx] diff --git a/alns/weight_schemes/WeightScheme.py b/alns/weights/WeightScheme.py similarity index 75% rename from alns/weight_schemes/WeightScheme.py rename to alns/weights/WeightScheme.py index e50d726f..6f525981 100644 --- a/alns/weight_schemes/WeightScheme.py +++ b/alns/weights/WeightScheme.py @@ -6,23 +6,23 @@ class WeightScheme(ABC): + """ + Base class from which to implement a weight scheme. + + Parameters + ---------- + scores + A list of four non-negative elements, representing the weight + updates when the candidate solution results in a new global best + (idx 0), is better than the current solution (idx 1), the solution + is accepted (idx 2), or rejected (idx 3). + num_destroy + Number of destroy operators. + num_repair + Number of repair operators. + """ def __init__(self, scores: List[float], num_destroy: int, num_repair: int): - """ - Base class from which to implement a weight scheme. - - Parameters - ---------- - scores - A list of four non-negative elements, representing the weight - updates when the candidate solution results in a new global best - (idx 0), is better than the current solution (idx 1), the solution - is accepted (idx 2), or rejected (idx 3). - num_destroy - Number of destroy operators. - num_repair - Number of repair operators. - """ self._validate_arguments(scores, num_destroy, num_repair) self._scores = scores @@ -85,8 +85,7 @@ def _validate_arguments(scores, num_destroy, num_repair): if len(scores) < 4: # More than four is not problematic, but we only use the first four. - raise ValueError("Unsupported number of scores: expected 4, " - "found {0}".format(len(scores))) + raise ValueError(f"Expected four scores, found {len(scores)}") if num_destroy <= 0 or num_repair <= 0: - raise ValueError("Missing at least one destroy or repair operator.") + raise ValueError("Missing destroy or repair operators.") diff --git a/alns/weight_schemes/__init__.py b/alns/weights/__init__.py similarity index 100% rename from alns/weight_schemes/__init__.py rename to alns/weights/__init__.py diff --git a/alns/weight_schemes/tests/__init__.py b/alns/weights/tests/__init__.py similarity index 100% rename from alns/weight_schemes/tests/__init__.py rename to alns/weights/tests/__init__.py diff --git a/alns/weights/tests/test_segmented_weights.py b/alns/weights/tests/test_segmented_weights.py new file mode 100644 index 00000000..4813fea8 --- /dev/null +++ b/alns/weights/tests/test_segmented_weights.py @@ -0,0 +1,71 @@ +from typing import List + +import numpy as np +from numpy.testing import assert_almost_equal, assert_raises +from pytest import mark + +from alns.weights import SegmentedWeights + + +@mark.parametrize("seg_decay", [1.01, -0.01, -0.5, 1.5]) +def test_raises_invalid_seg_decay(seg_decay: float): + with assert_raises(ValueError): + SegmentedWeights([0, 0, 0, 0], 1, 1, seg_decay) + + +@mark.parametrize("seg_decay", np.linspace(0, 1, num=5)) +def test_does_not_raise_valid_seg_decay(seg_decay: float): + SegmentedWeights([0, 0, 0, 0], 1, 1, seg_decay) + + +@mark.parametrize( + "scores,seg_decay,expected", + [ + ([5, 3, 2, 1], 0, [3, 3]), # 1 * 0 + (0 + 3) * 1 = 3 + ([5, 3, 2, 1], 1, [1, 1]), # 1 * 1 + (0 + 3) * 0 = 1 + ([5, 3, 2, 1], 0.5, [2, 2]), # .5 * 1 + (0 + 3) * .5 = 2 + ([5, 5, 5, 5], 0, [5, 5]), # etc. etc. + ([5, 5, 5, 5], 1, [1, 1]), + ([5, 5, 5, 5], 0.5, [3, 3]), + ], +) +def test_update_weights( + scores: List[float], seg_decay: float, expected: List[float] +): + rnd_state = np.random.RandomState(1) + weights = SegmentedWeights(scores, 1, 1, seg_decay, 1) + + # TODO other weights? + weights.update_weights(0, 0, 1) + weights.select_operators(rnd_state) + + assert_almost_equal(weights.destroy_weights[0], expected[0]) + assert_almost_equal(weights.repair_weights[0], expected[1]) + + +@mark.parametrize( + "scores,num_destroy,num_repair,seg_decay,seg_length", + [ + ([5, 3, 2, -1], 1, 1, 0, 1), # negative score + ([5, 3, 2], 1, 1, 0, 1), # len(score) < 4 + ([5, 3, 2, 1], 0, 1, 0, 1), # no destroy operator + ([5, 3, 2, 1], 1, 0, 0, 1), # no repair operator + ([5, 3, 2, 1], 1, 1, -1, 1), # seg_decay < 0 + ([5, 3, 2, 1], 1, 1, 2, 1), # seg_decay > 1 + ([5, 3, 2, 1], 1, 1, 0.5, 0), # seg_length < 1 + ], +) +def test_raises_invalid_arguments( + scores: List[float], + num_destroy: int, + num_repair: int, + seg_decay: float, + seg_length: int, +): + with assert_raises(ValueError): + SegmentedWeights( + scores, num_destroy, num_repair, seg_decay, seg_length + ) + + +# TODO test select weights, at iteration start diff --git a/alns/weight_schemes/tests/test_simple_weights.py b/alns/weights/tests/test_simple_weights.py similarity index 62% rename from alns/weight_schemes/tests/test_simple_weights.py rename to alns/weights/tests/test_simple_weights.py index 67b8ba0b..00ba1e2f 100644 --- a/alns/weight_schemes/tests/test_simple_weights.py +++ b/alns/weights/tests/test_simple_weights.py @@ -4,7 +4,7 @@ from numpy.testing import assert_raises, assert_almost_equal from pytest import mark -from alns.weight_schemes import SimpleWeights +from alns.weights import SimpleWeights @mark.parametrize("op_decay", [1.01, -0.01, -0.5, 1.5]) @@ -18,13 +18,17 @@ def test_does_not_raise_valid_op_decay(op_decay: float): SimpleWeights([0, 0, 0, 0], 1, 1, op_decay) -@mark.parametrize("scores,op_decay,expected", - [([0, 0, 0, 0], 1, [1, 1]), # scores are not used - ([0, 0, 0, 0], 0, [0, 0]), # initial weights are not used - ([.5, .5, .5, .5], .5, [.75, .75])]) # convex combination -def test_update_weights(scores: List[float], - op_decay: float, - expected: List[float]): +@mark.parametrize( + "scores,op_decay,expected", + [ + ([0, 0, 0, 0], 1, [1, 1]), # scores are not used + ([0, 0, 0, 0], 0, [0, 0]), # initial weights are not used + ([0.5, 0.5, 0.5, 0.5], 0.5, [0.75, 0.75]), + ], +) # convex combination +def test_update_weights( + scores: List[float], op_decay: float, expected: List[float] +): weights = SimpleWeights(scores, 1, 1, op_decay) # TODO other weights? diff --git a/examples/weight_schemes_acceptance_criteria.ipynb b/examples/alns_features.ipynb similarity index 82% rename from examples/weight_schemes_acceptance_criteria.ipynb rename to examples/alns_features.ipynb index 9ecc9483..c72b4a72 100644 --- a/examples/weight_schemes_acceptance_criteria.ipynb +++ b/examples/alns_features.ipynb @@ -13,8 +13,9 @@ "import numpy as np\n", "\n", "from alns import ALNS, State\n", - "from alns.criteria import *\n", - "from alns.weight_schemes import *" + "from alns.accept import *\n", + "from alns.stop import *\n", + "from alns.weights import *" ] }, { @@ -64,7 +65,7 @@ "source": [ "# Weight schemes and acceptance criteria\n", "\n", - "The `alns` package offers a number of different weight schemes and acceptance criteria. In this notebook, we show all of these in action solving a toy knapsack problem. Along the way we explain how they work, and show how you can use them in your ALNS heuristic.\n", + "The `alns` package offers a number of different weight schemes, and acceptance and stopping criteria. In this notebook, we show these in action solving a toy knapsack problem. Along the way we explain how they work, and show how you can use them in your ALNS heuristic.\n", "\n", "In our toy [0/1-knapsack problem](https://en.wikipedia.org/wiki/Knapsack_problem), there are $n = 100$ items $i$ with profit $p_i > 0$ and weight $w_i > 0$. The goal is to find a subset of the items that maximizes the profit, while keeping the total weight below a given limit $W$. The problem then reads follows:\n", "\\begin{align}\n", @@ -380,7 +381,7 @@ " op_decay=0.8)\n", "\n", "alns = make_alns()\n", - "res = alns.iterate(init_sol, weights, crit)\n", + "res = alns.iterate(init_sol, weights, crit, MaxIterations(10_000))\n", "\n", "print(f\"Found solution with objective {-res.best_state.objective()}.\")" ], @@ -453,7 +454,7 @@ " seg_length=500)\n", "\n", "alns = make_alns()\n", - "res = alns.iterate(init_sol, weights, crit)\n", + "res = alns.iterate(init_sol, weights, crit, MaxIterations(10_000))\n", "\n", "print(f\"Found solution with objective {-res.best_state.objective()}.\")" ], @@ -574,7 +575,7 @@ " method=\"linear\")\n", "\n", "alns = make_alns()\n", - "res = alns.iterate(init_sol, weights, crit)\n", + "res = alns.iterate(init_sol, weights, crit, MaxIterations(10_000))\n", "\n", "print(f\"Found solution with objective {-res.best_state.objective()}.\")" ], @@ -648,7 +649,7 @@ " method=\"exponential\")\n", "\n", "alns = make_alns()\n", - "res = alns.iterate(init_sol, weights, crit)\n", + "res = alns.iterate(init_sol, weights, crit, MaxIterations(10_000))\n", "\n", "print(f\"Found solution with objective {-res.best_state.objective()}.\")" ], @@ -688,11 +689,78 @@ { "cell_type": "markdown", "source": [ - "# Conclusions\n", + "Rather than a fixed number of iterations, we can also fix the runtime, and allow as many iterations as fit in that timeframe." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 23, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found solution with objective 2954.0.\n" + ] + } + ], + "source": [ + "crit = SimulatedAnnealing(start_temperature=1_000,\n", + " end_temperature=1,\n", + " step=1 - 1e-3,\n", + " method=\"exponential\")\n", "\n", - "This notebook has shown the various weight schemes and acceptance criteria that can be used with the `alns` package. The `alns` package is designed to be flexible, and it is easy to add new weight schemes and acceptance criteria yourself, by subclassing `alns.criteria.AcceptanceCriterion`, or `alns.weight_schemes.WeightScheme`.\n", + "alns = make_alns()\n", + "res = alns.iterate(init_sol, weights, crit, MaxRuntime(60)) # one minute\n", + "\n", + "print(f\"Found solution with objective {-res.best_state.objective()}.\")" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 24, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "_, ax = plt.subplots(figsize=(12, 6))\n", + "res.plot_objectives(ax=ax, lw=2)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "# Conclusions\n", "\n", - "Acceptance criteria and weight schemes have many parameters that influence the performance of the ALNS metaheuristic. These parameters should all be tuned for your specific problem. This notebook has not attempted to do this, and instead just presents _which_ parameters there are." + "This notebook has shown the various weight schemes, acceptance and stopping criteria that can be used with the `alns` package.\n", + "The `alns` package is designed to be flexible, and it is easy to add new weight schemes and criteria yourself, by subclassing `alns.weights.WeightScheme`, `alns.accept.AcceptanceCriterion`, or `alns.stop.StoppingCriterion`.\n" ], "metadata": { "collapsed": false, @@ -703,7 +771,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 24, "outputs": [], "source": [], "metadata": { diff --git a/examples/cutting_stock_problem.ipynb b/examples/cutting_stock_problem.ipynb index 3d35e7ff..f2ce63e5 100644 --- a/examples/cutting_stock_problem.ipynb +++ b/examples/cutting_stock_problem.ipynb @@ -7,7 +7,6 @@ "outputs": [], "source": [ "import copy\n", - "\n", "from functools import partial\n", "\n", "import matplotlib.pyplot as plt\n", @@ -15,8 +14,9 @@ "import numpy.random as rnd\n", "\n", "from alns import ALNS, State\n", - "from alns.criteria import HillClimbing\n", - "from alns.weight_schemes import SimpleWeights" + "from alns.accept import HillClimbing\n", + "from alns.stop import MaxIterations\n", + "from alns.weights import SimpleWeights" ] }, { @@ -384,8 +384,9 @@ "source": [ "criterion = HillClimbing()\n", "weights = SimpleWeights([3, 2, 1, 0.5], 2, 2, 0.8)\n", + "stop = MaxIterations(5000)\n", "\n", - "result = alns.iterate(init_sol, weights, criterion, iterations=5000)\n", + "result = alns.iterate(init_sol, weights, criterion, stop)\n", "solution = result.best_state\n", "objective = solution.objective()" ] diff --git a/examples/resource_constrained_project_scheduling_problem.ipynb b/examples/resource_constrained_project_scheduling_problem.ipynb index e22e1d47..e7a08544 100644 --- a/examples/resource_constrained_project_scheduling_problem.ipynb +++ b/examples/resource_constrained_project_scheduling_problem.ipynb @@ -16,8 +16,9 @@ "import numpy.random as rnd\n", "\n", "from alns import ALNS, State\n", - "from alns.criteria import HillClimbing\n", - "from alns.weight_schemes import SegmentedWeights" + "from alns.accept import HillClimbing\n", + "from alns.stop import MaxIterations\n", + "from alns.weights import SegmentedWeights" ], "metadata": { "collapsed": false, @@ -741,8 +742,9 @@ "source": [ "crit = HillClimbing()\n", "weights = SegmentedWeights(WEIGHTS, 3, 1, THETA, SEG_LENGTH)\n", + "stop = MaxIterations(ITERS)\n", "\n", - "res = alns.iterate(init_sol, weights, crit, iterations=ITERS)\n", + "res = alns.iterate(init_sol, weights, crit, stop)\n", "sol = res.best_state\n", "\n", "print(f\"Heuristic solution has objective {sol.objective()}.\")" diff --git a/examples/travelling_salesman_problem.ipynb b/examples/travelling_salesman_problem.ipynb index efc900a9..c7f0c5d3 100644 --- a/examples/travelling_salesman_problem.ipynb +++ b/examples/travelling_salesman_problem.ipynb @@ -6,21 +6,19 @@ "metadata": {}, "outputs": [], "source": [ - "from alns import ALNS, State\n", - "from alns.criteria import HillClimbing\n", - "from alns.weight_schemes import SimpleWeights\n", - "\n", "import copy\n", "import itertools\n", "\n", - "import numpy.random as rnd\n", - "\n", + "import matplotlib.pyplot as plt\n", "import networkx as nx\n", - "\n", + "import numpy.random as rnd\n", "import tsplib95\n", "import tsplib95.distances as distances\n", "\n", - "import matplotlib.pyplot as plt" + "from alns import ALNS, State\n", + "from alns.accept import HillClimbing\n", + "from alns.stop import MaxRuntime\n", + "from alns.weights import SimpleWeights" ] }, { @@ -382,7 +380,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Heuristic solution" + "# Heuristic solution\n", + "\n", + "Here we perform the ALNS procedure. The heuristic is given 60 seconds of runtime." ] }, { @@ -408,11 +408,9 @@ "source": [ "criterion = HillClimbing()\n", "weight_scheme = SimpleWeights([3, 2, 1, 0.5], 3, 1, 0.8)\n", + "stop = MaxRuntime(60)\n", "\n", - "result = alns.iterate(init_sol,\n", - " weight_scheme,\n", - " criterion,\n", - " iterations=5000)" + "result = alns.iterate(init_sol, weight_scheme, criterion, stop)" ] }, { @@ -423,8 +421,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Best heuristic objective is 606.\n", - "This is 7.4% worse than the optimal solution, which is 564.\n" + "Best heuristic objective is 590.\n", + "This is 4.6% worse than the optimal solution, which is 564.\n" ] } ], @@ -451,7 +449,7 @@ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": { "needs_background": "light" @@ -468,39 +466,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Having obtained a reasonable solution, we now want to investigate each operator's performance. This may be done via the `plot_operator_counts()` method on the `result` object, like below. " - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "figure = plt.figure(\"operator_counts\", figsize=(14, 6))\n", - "figure.subplots_adjust(bottom=0.15, hspace=.5)\n", - "result.plot_operator_counts(figure, title=\"Operator diagnostics\", legend=[\"Best\", \"Better\", \"Accepted\"])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Several conclusions follow.\n", - "\n", - "* Of the destroy operators, `random_removal` and `path_removal` perform similarly: while `random_removal` results in more accepted solution states, both find globally best states at about the same rate. Observe that `worst_removal` does not actually result in many better or equivalent states, which suggests it is inferior to the other two destroy operators. \n", - "* The `greedy_repair` repair heuristic leads to many solution states that are inferior to the current best state, and are thus rejected by the ALNS algorithm. This is unfortunate, and suggests a better repair heuristic should be found. Ideally, such a heuristic would better exploit the problem structure." + "Let's have a look at the solution:" ] }, { @@ -511,7 +477,7 @@ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -606,8 +572,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "New heuristic objective is 576.\n", - "This is 2.1% worse than the optimal solution, which is 564.\n" + "New heuristic objective is 575.\n", + "This is 2.0% worse than the optimal solution, which is 564.\n" ] } ], @@ -628,7 +594,7 @@ { "data": { "text/plain": "
", - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" @@ -644,7 +610,7 @@ "source": [ "# Conclusions\n", "\n", - "In the code above we implemented a very simple heuristic for the TSP, using the ALNS meta-heuristic framework. We did not tinker too much with the various hyperparameters available on the ALNS implementation, but even for these relatively basic heuristic methods and workflow we find a very good result - just 2.1% worse than the optimal tour.\n", + "In the code above we implemented a very simple heuristic for the TSP, using the ALNS meta-heuristic framework. We did not tinker too much with the various hyperparameters available on the ALNS implementation, but even for these relatively basic heuristic methods and workflow we find a very good result - just 2% worse than the optimal tour.\n", "\n", "This notebook showcases how the ALNS library may be put to use to construct powerful, efficient heuristic pipelines from simple, locally greedy operators." ] diff --git a/pyproject.toml b/pyproject.toml index 544ef2ca..d62deb5d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "alns" -version = "2.1.2" +version = "3.0.0" description = "A flexible implementation of the adaptive large neighbourhood search (ALNS) algorithm." authors = ["Niels Wouda "] license = "MIT" @@ -39,6 +39,7 @@ pytest = ">=6.0.0" pytest-cov = ">=2.6.1" mypy = ">=0.670" codecov = "*" +black = "^22.3.0" # These are solely for work on the example notebooks, and not required for # the package itself. @@ -79,6 +80,11 @@ exclude_lines = [ +[tool.black] +line-length = 79 + + + [build-system] requires = ["poetry-core>=1.0.0"] build-backend = "poetry.core.masonry.api"