feat: restart when max rejections reached

Author: zepfred

core/src/main/java/ai/timefold/solver/core/impl/localsearch/decider/acceptor/AcceptorFactory.java

@@ -223,7 +223,7 @@ private Optional<MoveTabuAcceptor<Solution_>> buildMoveTabuAcceptor(HeuristicCon
                 || (!acceptorTypeListsContainsAcceptorType(AcceptorType.DIVERSIFIED_LATE_ACCEPTANCE)
                         && acceptorConfig.getLateAcceptanceSize() != null)) {
             StuckCriterion<Solution_> strategy = new DiminishedReturnsStuckCriterion<>();
-            var acceptor = new LateAcceptanceAcceptor<>(strategy);
+            var acceptor = new LateAcceptanceAcceptor<>(true, strategy);
             acceptor.setLateAcceptanceSize(Objects.requireNonNullElse(acceptorConfig.getLateAcceptanceSize(), 400));
             return Optional.of(acceptor);
         }

core/src/main/java/ai/timefold/solver/core/impl/localsearch/decider/acceptor/RestartableAcceptor.java

@@ -13,50 +13,62 @@ public abstract class RestartableAcceptor<Solution_> extends AbstractAcceptor<So
 
     private final StuckCriterion<Solution_> stuckCriterion;
     protected boolean restartTriggered;
+    private boolean enabled;
 
-    protected RestartableAcceptor(StuckCriterion<Solution_> stuckCriterion) {
+    protected RestartableAcceptor(boolean enabled, StuckCriterion<Solution_> stuckCriterion) {
+        this.enabled = enabled;
         this.stuckCriterion = stuckCriterion;
     }
 
     @Override
     public void solvingStarted(SolverScope<Solution_> solverScope) {
         super.solvingStarted(solverScope);
-        stuckCriterion.solvingStarted(solverScope);
+        if (enabled) {
+            stuckCriterion.solvingStarted(solverScope);
+        }
     }
 
     @Override
     public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
         super.phaseStarted(phaseScope);
-        stuckCriterion.phaseStarted(phaseScope);
+        if (enabled) {
+            stuckCriterion.phaseStarted(phaseScope);
+        }
     }
 
     @Override
     public void phaseEnded(LocalSearchPhaseScope<Solution_> phaseScope) {
         super.phaseEnded(phaseScope);
-        stuckCriterion.phaseEnded(phaseScope);
+        if (enabled) {
+            stuckCriterion.phaseEnded(phaseScope);
+        }
     }
 
     @Override
     public void stepStarted(LocalSearchStepScope<Solution_> stepScope) {
         super.stepStarted(stepScope);
-        stuckCriterion.stepStarted(stepScope);
+        if (enabled) {
+            stuckCriterion.stepStarted(stepScope);
+        }
     }
 
     @Override
     public void stepEnded(LocalSearchStepScope<Solution_> stepScope) {
         super.stepEnded(stepScope);
-        if (stuckCriterion.isSolverStuck(stepScope)) {
-            if (rejectRestartEvent()) {
-                // We need to reset the criterion,
-                // or it will trigger the restart event in the next evaluation
-                stuckCriterion.reset(stepScope);
-                restartTriggered = false;
-            } else {
-                stepScope.getPhaseScope().setSolverStuck(true);
-                restartTriggered = true;
+        if (enabled) {
+            if (stuckCriterion.isSolverStuck(stepScope)) {
+                if (rejectRestartEvent()) {
+                    // We need to reset the criterion,
+                    // or it will trigger the restart event in the next evaluation
+                    stuckCriterion.reset(stepScope);
+                    restartTriggered = false;
+                } else {
+                    stepScope.getPhaseScope().setSolverStuck(true);
+                    restartTriggered = true;
+                }
             }
+            stuckCriterion.stepEnded(stepScope);
         }
-        stuckCriterion.stepEnded(stepScope);
     }
 
     /**

core/src/main/java/ai/timefold/solver/core/impl/localsearch/decider/acceptor/lateacceptance/LateAcceptanceAcceptor.java

@@ -15,26 +15,27 @@
 public class LateAcceptanceAcceptor<Solution_> extends RestartableAcceptor<Solution_> {
 
     protected static final double MIN_DIVERSITY_RATIO = 0.05;
-    // The goal is to increase from hundreds to thousands in the first restart event and then increment it linearly
-    protected static final int SCALING_FACTOR = 10;
+    protected static final int SCALE_FACTOR = 3;
+    private static final int MAX_REJECTED_EVENTS = 3;
 
     protected int lateAcceptanceSize = -1;
     protected boolean hillClimbingEnabled = true;
 
     protected Score<?>[] previousScores;
     protected int lateScoreIndex = -1;
 
-    private int maxBestScoreSize;
     private Score<?> bestStepScore;
     private Score<?> currentBestScore;
     // Keep track of the best scores accumulated so far. This list will be used to reseed the later elements list.
     protected Deque<Score<?>> bestScoreQueue;
-    private int defaultLateAcceptanceSize;
+    protected int defaultLateAcceptanceSize;
+    protected int maxBestScoreSize;
     protected int coefficient;
-    private int countRestartWithoutImprovement;
+    private boolean allowDecrease;
+    private int countRejected;
 
-    public LateAcceptanceAcceptor(StuckCriterion<Solution_> stuckCriterionDetection) {
-        super(stuckCriterionDetection);
+    public LateAcceptanceAcceptor(boolean enableRestart, StuckCriterion<Solution_> stuckCriterionDetection) {
+        super(enableRestart, stuckCriterionDetection);
     }
 
     public void setLateAcceptanceSize(int lateAcceptanceSize) {
@@ -64,13 +65,13 @@ public void phaseStarted(LocalSearchPhaseScope<Solution_> phaseScope) {
         var initialScore = phaseScope.getBestScore();
         Arrays.fill(previousScores, initialScore);
         lateScoreIndex = 0;
-        coefficient = 0;
-        countRestartWithoutImprovement = 0;
-        defaultLateAcceptanceSize = lateAcceptanceSize;
-        // The maximum size is three times the size of the initial element list
-        maxBestScoreSize = defaultLateAcceptanceSize * 3 * SCALING_FACTOR;
+        coefficient = 1;
+        allowDecrease = false;
+        countRejected = 0;
+        maxBestScoreSize = lateAcceptanceSize * 3;
         bestScoreQueue = new ArrayDeque<>(maxBestScoreSize);
         bestScoreQueue.addLast(initialScore);
+        defaultLateAcceptanceSize = lateAcceptanceSize;
     }
 
     private void validate() {
@@ -106,14 +107,14 @@ public void stepEnded(LocalSearchStepScope<Solution_> stepScope) {
         previousScores[lateScoreIndex] = stepScope.getScore();
         lateScoreIndex = (lateScoreIndex + 1) % lateAcceptanceSize;
         if (((Score) currentBestScore).compareTo(stepScope.getScore()) < 0) {
-            if (countRestartWithoutImprovement > 0 && coefficient > 0) {
+            if (allowDecrease) {
                 // We decrease the coefficient
                 // if there is an improvement
                 // to avoid altering the late element size in the next restart event.
                 // This action is performed only once after a restart event
-                coefficient--;
+                coefficient /= SCALE_FACTOR;
+                allowDecrease = false;
             }
-            countRestartWithoutImprovement = 0;
             if (bestScoreQueue.size() < maxBestScoreSize) {
                 bestScoreQueue.addLast(stepScope.getScore());
             } else {
@@ -137,18 +138,26 @@ public boolean rejectRestartEvent() {
         // and the proposed approach requires some diversity to reseed the scores.
         var reject = diversity > MIN_DIVERSITY_RATIO || bestScoreQueue.size() == 1;
         if (reject) {
+            countRejected++;
+            if (countRejected > MAX_REJECTED_EVENTS && bestScoreQueue.size() > 1) {
+                logger.info(
+                        "Restart event not rejected. Diversity ({}), Count best scores ({}), Distinct Elements ({}), Rejection Count ({})",
+                        diversity, bestScoreQueue.size(), distinctElements, countRejected);
+                return false;
+            }
             logger.info(
-                    "Restart event delayed. Diversity ({}), Count best scores ({}), Distinct Elements ({}), Restart without Improvement ({})",
-                    diversity, bestScoreQueue.size(), distinctElements, countRestartWithoutImprovement);
+                    "Restart event delayed. Diversity ({}), Count best scores ({}), Distinct Elements ({}), Rejection Count ({})",
+                    diversity, bestScoreQueue.size(), distinctElements, countRejected);
         }
         return reject;
     }
 
     @Override
     public void restart(LocalSearchStepScope<Solution_> stepScope) {
-        countRestartWithoutImprovement++;
-        coefficient++;
-        var newLateAcceptanceSize = defaultLateAcceptanceSize * coefficient * SCALING_FACTOR;
+        coefficient *= SCALE_FACTOR;
+        allowDecrease = true;
+        countRejected = 0;
+        var newLateAcceptanceSize = defaultLateAcceptanceSize * coefficient;
         if (logger.isInfoEnabled()) {
             if (lateAcceptanceSize == newLateAcceptanceSize) {
                 logger.info("Keeping the lateAcceptanceSize as {}.", lateAcceptanceSize);
@@ -171,15 +180,15 @@ public void restart(LocalSearchStepScope<Solution_> stepScope) {
      */
     private void rebuildLateElementsList(int newLateAcceptanceSize) {
         var newPreviousScores = new Score[newLateAcceptanceSize];
-        var countPerScore = newLateAcceptanceSize / bestScoreQueue.size() + 1;
-        var count = new MutableInt(newLateAcceptanceSize - 1);
-        var iterator = bestScoreQueue.descendingIterator();
-        while (count.intValue() >= 0 && iterator.hasNext()) {
+        var countPerScore = Math.min(newLateAcceptanceSize / 2, (newLateAcceptanceSize / bestScoreQueue.size()) * 2);
+        var count = new MutableInt(0);
+        var iterator = bestScoreQueue.iterator();
+        while (count.intValue() < newLateAcceptanceSize && iterator.hasNext()) {
             var score = iterator.next();
             for (var i = 0; i < countPerScore; i++) {
                 newPreviousScores[count.intValue()] = score;
-                count.decrement();
-                if (count.intValue() < 0) {
+                count.increment();
+                if (count.intValue() == newLateAcceptanceSize) {
                     break;
                 }
             }

core/src/main/java/ai/timefold/solver/core/impl/localsearch/decider/acceptor/stuckcriterion/AbstractGeometricStuckCriterion.java

@@ -10,15 +10,15 @@
 /**
  * Restart strategy, which exponentially increases the metric that triggers the restart process.
  * The first restart occurs after the {@code scalingFactor * GEOMETRIC_FACTOR^restartCount} metric.
- * Following that, the metric increases exponentially: 1, 2, 3, 5, 7...
+ * Following that, the metric increases exponentially: 1, 3, 9, 27...
  * <p>
  * The strategy is based on the work: Search in a Small World by Toby Walsh
  * 
  * @param <Solution_> the solution type
  */
 public abstract class AbstractGeometricStuckCriterion<Solution_> implements StuckCriterion<Solution_> {
     protected static final Logger logger = LoggerFactory.getLogger(AbstractGeometricStuckCriterion.class);
-    private static final double GEOMETRIC_FACTOR = 1.4; // Value extracted from the cited paper
+    private static final double GEOMETRIC_FACTOR = 3; // Value extracted from the cited paper
 
     private double scalingFactor;
     protected long nextRestart;

core/src/main/java/ai/timefold/solver/core/impl/localsearch/decider/acceptor/stuckcriterion/DiminishedReturnsStuckCriterion.java

@@ -7,22 +7,19 @@
 
 public class DiminishedReturnsStuckCriterion<Solution_, Score_ extends Score<Score_>>
         extends AbstractGeometricStuckCriterion<Solution_> {
-    // Time window used at the beginning of the solving process
-    protected static final long START_TIME_WINDOW_MILLIS = 10_000;
-    // Time window used once the first restart event is triggered and accepted
-    protected static final long REGULAR_TIME_WINDOW_MILLIS = 600_000;
+    protected static final long TIME_WINDOW_MILLIS = 10_000;
     private static final double MINIMAL_IMPROVEMENT = 0.0001;
 
     private DiminishedReturnsTermination<Solution_, Score_> diminishedReturnsCriterion;
 
-    private boolean triggered;
+    protected boolean triggered;
 
     public DiminishedReturnsStuckCriterion() {
-        this(new DiminishedReturnsTermination<>(START_TIME_WINDOW_MILLIS, MINIMAL_IMPROVEMENT));
+        this(new DiminishedReturnsTermination<>(TIME_WINDOW_MILLIS, MINIMAL_IMPROVEMENT));
     }
 
     protected DiminishedReturnsStuckCriterion(DiminishedReturnsTermination<Solution_, Score_> diminishedReturnsCriterion) {
-        super(START_TIME_WINDOW_MILLIS);
+        super(TIME_WINDOW_MILLIS);
         this.diminishedReturnsCriterion = diminishedReturnsCriterion;
     }
 
@@ -47,11 +44,6 @@ public void reset(LocalSearchStepScope<Solution_> stepScope) {
     @Override
     public void stepStarted(LocalSearchStepScope<Solution_> stepScope) {
         if (triggered) {
-            // Once the first restart event is triggered and accepted, we adjust the time window to the regular one.
-            // The aim is to give the solver more time to operate after applying the restart configuration.
-            if (getScalingFactor() == START_TIME_WINDOW_MILLIS) {
-                setScalingFactor(REGULAR_TIME_WINDOW_MILLIS);
-            }
             reset(stepScope);
         }
     }