LSSurrogate.py 3.4 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495
  1. """Local Search algorithm
  2. """
  3. # main imports
  4. import logging
  5. # module imports
  6. from macop.algorithms.Algorithm import Algorithm
  7. class LocalSearchSurrogate(Algorithm):
  8. """Local Search with surrogate used as exploitation optimization algorithm
  9. Attributes:
  10. initalizer: {function} -- basic function strategy to initialize solution
  11. evaluator: {function} -- basic function in order to obtained fitness (mono or multiple objectives)
  12. operators: {[Operator]} -- list of operator to use when launching algorithm
  13. policy: {Policy} -- Policy class implementation strategy to select operators
  14. validator: {function} -- basic function to check if solution is valid or not under some constraints
  15. maximise: {bool} -- specify kind of optimization problem
  16. currentSolution: {Solution} -- current solution managed for current evaluation
  17. bestSolution: {Solution} -- best solution found so far during running algorithm
  18. callbacks: {[Callback]} -- list of Callback class implementation to do some instructions every number of evaluations and `load` when initializing algorithm
  19. """
  20. def run(self, evaluations):
  21. """
  22. Run the local search algorithm
  23. Args:
  24. evaluations: {int} -- number of Local search evaluations
  25. Returns:
  26. {Solution} -- best solution found
  27. """
  28. # by default use of mother method to initialize variables
  29. super().run(evaluations)
  30. # do not use here the best solution known (default use of initRun and current solution)
  31. # if self.parent:
  32. # self.bestSolution = self.parent.bestSolution
  33. # initialize current solution
  34. self.initRun()
  35. solutionSize = self._currentSolution._size
  36. # local search algorithm implementation
  37. while not self.stop():
  38. for _ in range(solutionSize):
  39. # update current solution using policy
  40. newSolution = self.update(self._currentSolution)
  41. # if better solution than currently, replace it
  42. if self.isBetter(newSolution):
  43. self._bestSolution = newSolution
  44. # increase number of evaluations
  45. self.increaseEvaluation()
  46. self.progress()
  47. logging.info(f"---- Current {newSolution} - SCORE {newSolution.fitness()}")
  48. # add to surrogate pool file if necessary (using ILS parent reference)
  49. # if self.parent.start_train_surrogate >= self.getGlobalEvaluation():
  50. # self.parent.add_to_surrogate(newSolution)
  51. # stop algorithm if necessary
  52. if self.stop():
  53. break
  54. # after applying local search on currentSolution, we switch into new local area using known current bestSolution
  55. self._currentSolution = self._bestSolution
  56. logging.info(f"End of {type(self).__name__}, best solution found {self._bestSolution}")
  57. return self._bestSolution
  58. def addCallback(self, callback):
  59. """Add new callback to algorithm specifying usefull parameters
  60. Args:
  61. callback: {Callback} -- specific Callback instance
  62. """
  63. # specify current main algorithm reference
  64. if self._parent is not None:
  65. callback.setAlgo(self._parent)
  66. else:
  67. callback.setAlgo(self)
  68. # set as new
  69. self._callbacks.append(callback)