Merge pull request #2 from FedorSmirnov89/master

Adjustment of Stagnation Restart

opendse-optimization/src/main/java/net/sf/opendse/optimization/OptimizationModule.java

@@ -30,6 +30,7 @@
 import net.sf.opendse.optimization.encoding.Encoding.RoutingEncoding;
 
 import org.opt4j.core.config.annotations.Parent;
+import org.opt4j.core.config.annotations.Required;
 import org.opt4j.core.problem.ProblemModule;
 import org.opt4j.core.start.Constant;
 import org.opt4j.viewer.VisualizationModule;
@@ -40,14 +41,19 @@
 public class OptimizationModule extends ProblemModule {
 
 	protected RoutingEncoding routingEncoding = RoutingEncoding.FLOW;
-	
+
 	@Constant(value = "preprocessing", namespace = SATConstraints.class)
 	protected boolean usePreprocessing = true;
+
+	protected boolean stagnationRestartEnabled = true;
 
-
+	@Required(property = "stagnationRestartEnabled", elements = { "TRUE" })
+	@Constant(value = "maximalNumberStagnatingGenerations", namespace = StagnationRestart.class)
+	protected int maximalNumberStagnatingGenerations = 20;
+
 	@Constant(value = "variableorder", namespace = SATCreatorDecoder.class)
 	protected boolean useVariableOrder = true;
-	
+
 	public RoutingEncoding getRoutingEncoding() {
 		return routingEncoding;
 	}
@@ -72,6 +78,22 @@ public void setUseVariableOrder(boolean useVariableOrder) {
 		this.useVariableOrder = useVariableOrder;
 	}
 
+	public boolean isStagnationRestartEnabled() {
+		return stagnationRestartEnabled;
+	}
+
+	public void setStagnationRestartEnabled(boolean stagnationRestartEnabled) {
+		this.stagnationRestartEnabled = stagnationRestartEnabled;
+	}
+
+	public int getMaximalNumberStagnatingGenerations() {
+		return maximalNumberStagnatingGenerations;
+	}
+
+	public void setMaximalNumberStagnatingGenerations(int maximalNumberStagnatingGenerations) {
+		this.maximalNumberStagnatingGenerations = maximalNumberStagnatingGenerations;
+	}
+
 	@Override
 	protected void config() {
 		bindProblem(DesignSpaceExplorationCreator.class, DesignSpaceExplorationDecoder.class,
@@ -90,11 +112,13 @@ protected void config() {
 
 		Multibinder.newSetBinder(binder(), ImplementationEvaluator.class);
 
-		addOptimizerIterationListener(StagnationRestart.class);
-
+		if (stagnationRestartEnabled) {
+			addOptimizerIterationListener(StagnationRestart.class);
+		}
+
 		bind(RoutingEncoding.class).toInstance(routingEncoding);
 
-		if (useVariableOrder){
+		if (useVariableOrder) {
 			bind(RoutingVariableClassOrder.class).asEagerSingleton();
 		}
 	}

opendse-optimization/src/main/java/net/sf/opendse/optimization/StagnationRestart.java

@@ -28,21 +28,35 @@
 import org.opt4j.core.optimizer.Archive;
 import org.opt4j.core.optimizer.OptimizerIterationListener;
 import org.opt4j.core.optimizer.Population;
+import org.opt4j.core.start.Constant;
 
 import com.google.inject.Inject;
 
+/**
+ * A class that clears the population if no new individuals (individuals that
+ * are either dominated or dominate other population members) came into the
+ * population for a defined number of iterations. This state, where no new
+ * individuals are generated for a defined period of time is considered as a
+ * stagnation. The population is then cleared and new individuals are created
+ * from scratch to prevent being stuck in a local optimum.
+ * 
+ * @author lukasiewycz
+ *
+ */
 public class StagnationRestart implements IndividualSetListener, OptimizerIterationListener {
 
 	protected final Archive archive = new CrowdingArchive(100);
 	protected final Population population;
 
 	protected int iteration = 0;
 	protected int lastUpdate = 0;
-	protected final int diff = 20;
+	protected final int diff;
 
 	@Inject
-	public StagnationRestart(Population population) {
+	public StagnationRestart(Population population,
+			@Constant(value = "maximalNumberStagnatingGenerations", namespace = StagnationRestart.class) int diff) {
 		this.population = population;
+		this.diff = diff;
 	}
 
 	@Override
@@ -52,32 +66,32 @@ public void iterationComplete(int iteration) {
 		for (Individual in0 : population) {
 			for (Individual in1 : archive) {
 				if (in0.getObjectives().dominates(in1.getObjectives())) {
+					// new individuals are found
 					lastUpdate = iteration;
 				}
 			}
 		}
 
 		archive.update(population);
 
-		// System.out.println(iteration-lastUpdate);
-
 		if (iteration - lastUpdate > diff) {
+			// the case where no individuals were found for the last diff
+			// generations
 			lastUpdate = iteration;
 			archive.clear();
 			population.clear();
 		}
 
 	}
 
-
 	@Override
 	public void individualAdded(IndividualSet collection, Individual individual) {
-		// TODO Auto-generated method stub
+		// No reaction needed
 	}
 
 	@Override
 	public void individualRemoved(IndividualSet collection, Individual individual) {
-		// TODO Auto-generated method stub	
+		// No reaction needed
 	}
 
 }

opendse-optimization/src/test/java/net/sf/opendse/optimization/StagnationRestartTest.java

@@ -0,0 +1,75 @@
+package net.sf.opendse.optimization;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.opt4j.core.Individual;
+import org.opt4j.core.Objectives;
+import org.opt4j.core.optimizer.Population;
+
+public class StagnationRestartTest {
+
+	class MockIndividual extends Individual {
+		public MockIndividual(boolean dominated) {
+			super();
+			setObjectives(dominated ? new MockDominatedObjectives() : new MockDominantObjectives());
+		}
+	}
+
+	class MockPopulation extends Population {
+
+	}
+
+	class MockDominatedObjectives extends Objectives {
+		@Override
+		public boolean dominates(Objectives opponent) {
+			return false;
+		}
+	}
+
+	class MockDominantObjectives extends Objectives {
+		@Override
+		public boolean dominates(Objectives opponent) {
+			return true;
+		}
+	}
+
+	@Test
+	public void testNoStagnation() {
+		Population population = new Population();
+		Individual indi1 = new MockIndividual(false);
+		Individual indi2 = new MockIndividual(false);
+		population.add(indi1);
+		population.add(indi2);
+		StagnationRestart restart = new StagnationRestart(population, 20);
+		restart.archive.add(indi1);
+		restart.archive.add(indi2);
+		assertEquals(0, restart.lastUpdate);
+		restart.iterationComplete(21);
+		assertEquals(21, restart.lastUpdate);
+		assertFalse(population.isEmpty());
+		assertFalse(restart.archive.isEmpty());
+	}
+
+	@Test
+	public void testStagnation() {
+		Population population = new Population();
+		Individual indi1 = new MockIndividual(true);
+		Individual indi2 = new MockIndividual(true);
+		population.add(indi1);
+		population.add(indi2);
+		StagnationRestart restart = new StagnationRestart(population, 20);
+		restart.archive.add(indi1);
+		restart.archive.add(indi2);
+		assertEquals(0, restart.lastUpdate);
+		restart.iterationComplete(5);
+		assertEquals(0, restart.lastUpdate);
+		assertFalse(population.isEmpty());
+		assertFalse(restart.archive.isEmpty());
+		restart.iterationComplete(21);
+		assertEquals(21, restart.lastUpdate);
+		assertTrue(population.isEmpty());
+		assertTrue(restart.archive.isEmpty());
+	}
+
+}