Changeset 5087 for branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test

Timestamp:

12/12/10 11:34:13 (14 years ago)

Author:

cneumuel

Message:

#1215

• enabled multiple problems
• enabled n repetitions
• improved results output
• reduced memory footprint significantly
• removed viewhost icons for less screen space waste

File:

• branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs (modified) (7 diffs)

branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs

@@ -17 +17 @@
 using System.Text;
 using HeuristicLab.Selection;
+using HeuristicLab.Algorithms.EvolutionStrategy;
 
 namespace HeuristicLab.MetaOptimization.Test {
   class Program {
-    private static int metaAlgorithmPopulationSize = 40;
+    private static int metaAlgorithmPopulationSize = 50;
     private static int metaAlgorithmMaxGenerations = 30;
-
-    private static int baseAlgorithmMaxGenerations = 100;
+    private static int metaProblemRepetitions = 3;
+
+    private static int baseAlgorithmMaxGenerations = 250;
 
     static void Main(string[] args) {
+      //TestShorten();
+
       //TestIntSampling();
       //TestDoubleSampling();
 
       GeneticAlgorithm baseLevelAlgorithm = new GeneticAlgorithm();
+
       MetaOptimizationProblem metaOptimizationProblem = new MetaOptimizationProblem();
-      GeneticAlgorithm metaLevelAlgorithm = GetMetaAlgorithm(metaOptimizationProblem);
-
-      IValueConfiguration algorithmVc = SetupAlgorithm(baseLevelAlgorithm, metaOptimizationProblem);
+      ((MetaOptimizationEvaluator)metaOptimizationProblem.Evaluator).Repetitions.Value = metaProblemRepetitions;
+      GeneticAlgorithm metaLevelAlgorithm = GetMetaGA(metaOptimizationProblem);
+      //EvolutionStrategy metaLevelAlgorithm = GetMetaES(metaOptimizationProblem);
+
+      IValueConfiguration algorithmVc = SetupGAAlgorithm(baseLevelAlgorithm, metaOptimizationProblem);
 
       //Console.WriteLine("Press enter to start");
       //Console.ReadLine();
       //TestConfiguration(algorithmVc, baseLevelAlgorithm);
-
+      
       //Console.WriteLine("Press enter to start");
       //Console.ReadLine();
@@ -69 +76 @@
     }
 
-    private static GeneticAlgorithm GetMetaAlgorithm(MetaOptimizationProblem metaOptimizationProblem) {
+    private static GeneticAlgorithm GetMetaGA(MetaOptimizationProblem metaOptimizationProblem) {
       GeneticAlgorithm metaLevelAlgorithm = new GeneticAlgorithm();
       metaLevelAlgorithm.PopulationSize.Value = metaAlgorithmPopulationSize;
@@ -83 +90 @@
     }
 
-    private static IValueConfiguration SetupAlgorithm(GeneticAlgorithm baseLevelAlgorithm, MetaOptimizationProblem metaOptimizationProblem) {
-      baseLevelAlgorithm.Problem = new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() { 
-        Evaluator = new GriewankEvaluator(),
-        ProblemSize = new IntValue(1000) 
-      };
+    private static EvolutionStrategy GetMetaES(MetaOptimizationProblem metaOptimizationProblem) {
+      EvolutionStrategy metaLevelAlgorithm = new EvolutionStrategy();
+      metaLevelAlgorithm.PopulationSize.Value = metaAlgorithmPopulationSize;
+      metaLevelAlgorithm.MaximumGenerations.Value = metaAlgorithmMaxGenerations;
+
+      metaLevelAlgorithm.Problem = metaOptimizationProblem;
+      metaLevelAlgorithm.Engine = new SequentialEngine.SequentialEngine();
+
+      metaLevelAlgorithm.Mutator = new ParameterConfigurationManipulator();
+      //metaLevelAlgorithm.MutationProbability.Value = 0.15;
+
+      return metaLevelAlgorithm;
+    }
+
+    private static IValueConfiguration SetupGAAlgorithm(GeneticAlgorithm baseLevelAlgorithm, MetaOptimizationProblem metaOptimizationProblem) {
+      baseLevelAlgorithm.Problem = new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem();
       baseLevelAlgorithm.MaximumGenerations.Value = baseAlgorithmMaxGenerations;
 
       metaOptimizationProblem.Algorithm = baseLevelAlgorithm;
       IValueConfiguration algorithmVc = metaOptimizationProblem.AlgorithmParameterConfiguration;
-      metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem());
+
+      metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() {
+        Evaluator = new GriewankEvaluator(),
+        ProblemSize = new IntValue(500)
+      });
+      metaOptimizationProblem.Problems.Add(new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() {
+        Evaluator = new GriewankEvaluator(),
+        ProblemSize = new IntValue(1000)
+      });
 
       ConfigurePopulationSize(algorithmVc);
@@ -189 +215 @@
           vc.Optimize = true;
           ConfigureTournamentGroupSize(vc);
+        } else if (vc.ActualValue.ValueDataType == typeof(RandomSelector)) {
+          selectionOperatorPc.ValueConfigurations.SetItemCheckedState(vc, true);
         } else {
-          selectionOperatorPc.ValueConfigurations.SetItemCheckedState(vc, false);
+          selectionOperatorPc.ValueConfigurations.SetItemCheckedState(vc, true);
         }
       }
@@ -235 +263 @@
     }
 
-    private static void TestOptimization(GeneticAlgorithm metaLevelAlgorithm) {
+    private static void TestOptimization(EngineAlgorithm metaLevelAlgorithm) {
       ContentManager.Initialize(new PersistenceContentManager());
       string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Results");
-      if(!Directory.Exists(path))
+      if (!Directory.Exists(path))
         Directory.CreateDirectory(path);
-      string id = DateTime.Now.ToString("MM.dd.yy - HH;mm;ss,ffff");
-      string resultPath = Path.Combine(path, string.Format("Test - {0} - Result.hl", id));
-      string outputPath = Path.Combine(path, string.Format("Test - {0} - Console.txt", id));
+      string id = DateTime.Now.ToString("yyyy.MM.dd - HH;mm;ss,ffff");
+      string resultPath = Path.Combine(path, string.Format("{0} - Result.hl", id));
+      string outputPath = Path.Combine(path, string.Format("{0} - Console.txt", id));
+
 
       using (var sw = new StreamWriter(outputPath)) {
+        sw.AutoFlush = true;
+
+        StringBuilder sb1 = new StringBuilder();
+        sb1.AppendLine(string.Format("Meta.PopulationSize: {0}", metaAlgorithmPopulationSize));
+        sb1.AppendLine(string.Format("Meta.MaxGenerations: {0}", metaAlgorithmMaxGenerations));
+        sb1.AppendLine(string.Format("Meta.Repetitions   : {0}", metaProblemRepetitions));
+        sb1.AppendLine(string.Format("Base.MaxGenerations: {0}", baseAlgorithmMaxGenerations));
+        sw.WriteLine(sb1.ToString());
+        Console.WriteLine(sb1.ToString());
+
         metaLevelAlgorithm.Start();
         int i = 0;
@@ -250 +289 @@
         do {
           Thread.Sleep(500);
-          try {
-            if (metaLevelAlgorithm.Results.ContainsKey("Generations") && ((IntValue)metaLevelAlgorithm.Results["Generations"].Value).Value != currentGeneration) {
-              StringBuilder sb = new StringBuilder();
-              sb.AppendLine(DateTime.Now.ToLongTimeString());
-              sb.AppendLine("=================================");
-
-              foreach (var result in metaLevelAlgorithm.Results) {
-                sb.AppendLine(result.ToString());
-                if (result.Name == "Population") {
-                  RunCollection rc = (RunCollection)result.Value;
-                  var orderedRuns = rc.OrderBy(x => x.Results["BestQuality"]);
-                  
-                  sb.AppendLine("Qality PoSi MutRa Eli GrSi MutOp");
-                  foreach (IRun run in orderedRuns) {
-                    sb.AppendLine(string.Format("{0} {1} {2} {3} {4} {5}",
-                      ((DoubleValue)run.Results["BestQuality"]).Value.ToString("#0.00").PadLeft(7, ' '),
-                      ((IntValue)run.Parameters["PopulationSize"]).Value.ToString().PadLeft(3, ' ').PadRight(3, ' '),
-                      ((DoubleValue)run.Parameters["MutationProbability"]).Value.ToString("0.00").PadLeft(5, ' '),
-                      ((IntValue)run.Parameters["Elites"]).Value.ToString().PadLeft(3, ' '),
-                      ((TournamentSelector)run.Parameters["Selector"]).GroupSizeParameter.Value.ToString().PadLeft(4, ' '),
-                      run.Parameters["Mutator"]));
+          if (metaLevelAlgorithm.Results.ContainsKey("Generations") && ((IntValue)metaLevelAlgorithm.Results["Generations"].Value).Value != currentGeneration) {
+            while (metaLevelAlgorithm.Results.Count < 3) Thread.Sleep(100);
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine(DateTime.Now.ToLongTimeString());
+            sb.AppendLine("=================================");
+
+            foreach (var result in metaLevelAlgorithm.Results) {
+              sb.AppendLine(result.ToString());
+              if (result.Name == "Population") {
+                RunCollection rc = (RunCollection)result.Value;
+                var orderedRuns = rc.OrderBy(x => x.Results["RunsAverageQuality"]);
+
+                sb.AppendLine("Qual.  PoSi MutRa Eli GrSi MutOp");
+                foreach (IRun run in orderedRuns) {
+                  string selector;
+                  if (run.Parameters["Selector"] is TournamentSelector) {
+                    selector = string.Format("{0} ({1})", run.Parameters["Selector"].ToString(), ((TournamentSelector)run.Parameters["Selector"]).GroupSizeParameter.Value.ToString());
+                  } else {
+                    selector = string.Format("{0}", run.Parameters["Selector"].ToString());
                   }
+
+                  sb.AppendLine(string.Format("{0} {1} {2} {3} {4} {5}",
+                    ((DoubleValue)run.Results["RunsAverageQuality"]).Value.ToString("#0.00").PadLeft(7, ' '),
+                    ((IntValue)run.Parameters["PopulationSize"]).Value.ToString().PadLeft(3, ' ').PadRight(3, ' '),
+                    ((DoubleValue)run.Parameters["MutationProbability"]).Value.ToString("0.00").PadLeft(5, ' '),
+                    ((IntValue)run.Parameters["Elites"]).Value.ToString().PadLeft(3, ' '),
+                    Shorten(selector, 20).PadRight(20, ' '),
+                    run.Parameters["Mutator"].ToString()));
                 }
-              } // foreach
-              Console.Clear();
-              Console.WriteLine(sb.ToString());
-              sw.WriteLine(sb.ToString());
-              sw.Flush();
-              currentGeneration = ((IntValue)metaLevelAlgorithm.Results["Generations"].Value).Value;
-            } // if
-            if (i % 30 == 0) GC.Collect();
-            i++;
-          }
-          catch { }
+              }
+            } // foreach
+            Console.Clear();
+            Console.WriteLine(sb.ToString());
+            sw.WriteLine(sb.ToString());
+            currentGeneration = ((IntValue)metaLevelAlgorithm.Results["Generations"].Value).Value;
+          } // if
+          if (i % 30 == 0) GC.Collect();
+          i++;
         } while (metaLevelAlgorithm.ExecutionState != ExecutionState.Stopped);
       }
@@ -290 +333 @@
       Console.WriteLine("Storing...");
 
-      ContentManager.Save(metaLevelAlgorithm, resultPath, true);
+      ContentManager.Save((IStorableContent)metaLevelAlgorithm, resultPath, true);
       Console.WriteLine("Finished");
+    }
+
+    private static void TestShorten() {
+      int n = 8;
+      Console.WriteLine(Shorten("1", n));
+      Console.WriteLine(Shorten("12", n));
+      Console.WriteLine(Shorten("123", n));
+      Console.WriteLine(Shorten("1234", n));
+      Console.WriteLine(Shorten("12345", n));
+      Console.WriteLine(Shorten("123456", n));
+      Console.WriteLine(Shorten("1234567", n));
+      Console.WriteLine(Shorten("12345678", n));
+      Console.WriteLine(Shorten("123456789", n));
+      Console.WriteLine(Shorten("1234567890", n));
+      Console.WriteLine(Shorten("12345678901", n));
+    }
+
+    private static string Shorten(string s, int n) {
+      string placeholder = "..";
+      if (s.Length <= n) return s;
+      int len = n / 2 - placeholder.Length / 2;
+      string start = s.Substring(0, len);
+      string end = s.Substring(s.Length - len, len);
+      return start + placeholder + end;
     }