Changeset 5023 for branches/HeuristicLab.MetaOptimization/HeuristicLab.MetaOptimization.Test/Program.cs

Timestamp:

12/04/10 18:08:43 (13 years ago)

Author:

cneumuel

Message:

#1215 worked on metaoptimization

File:

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

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

@@ -12 +12 @@
 using HeuristicLab.Random;
 using HeuristicLab.Optimization;
+using HeuristicLab.Common;
+using System.IO;
+using HeuristicLab.Problems.TestFunctions;
+using System.Text;
+using HeuristicLab.Selection;
 
 namespace HeuristicLab.MetaOptimization.Test {
   class Program {
-    private static int metaAlgorithmPopulationSize = 20;
-    private static int metaAlgorithmMaxGenerations = 100;
-
-    private static int baseAlgorithmPopulationSize = 20;
-    private static int baseAlgorithmMaxGenerations = 30;
+    private static int metaAlgorithmPopulationSize = 40;
+    private static int metaAlgorithmMaxGenerations = 30;
+
+    private static int baseAlgorithmMaxGenerations = 100;
 
     static void Main(string[] args) {
@@ -31 +35 @@
       IValueConfiguration algorithmVc = SetupAlgorithm(baseLevelAlgorithm, metaOptimizationProblem);
 
-      Console.WriteLine("Press enter to start");
-      Console.ReadLine();
-      TestConfiguration(algorithmVc, baseLevelAlgorithm);
-
-      Console.WriteLine("Press enter to start");
-      Console.ReadLine();
+      //Console.WriteLine("Press enter to start");
+      //Console.ReadLine();
+      //TestConfiguration(algorithmVc, baseLevelAlgorithm);
+
+      //Console.WriteLine("Press enter to start");
+      //Console.ReadLine();
       TestOptimization(metaLevelAlgorithm);
 
@@ -50 +54 @@
       Console.ReadLine();
 
+      var clones = new List<object>();
       for (int i = 0; i < 1000; i++) {
         var clone = algorithmVc.Clone();
+        clones.Add(clone);
       }
 
@@ -70 +76 @@
       metaLevelAlgorithm.Problem = metaOptimizationProblem;
       metaLevelAlgorithm.Engine = new SequentialEngine.SequentialEngine();
+
+      metaLevelAlgorithm.Mutator = new ParameterConfigurationManipulator();
+      metaLevelAlgorithm.MutationProbability.Value = 0.15;
+
       return metaLevelAlgorithm;
     }
 
     private static IValueConfiguration SetupAlgorithm(GeneticAlgorithm baseLevelAlgorithm, MetaOptimizationProblem metaOptimizationProblem) {
-      baseLevelAlgorithm.Problem = new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() { ProblemSize = new IntValue(2000) };
-      baseLevelAlgorithm.PopulationSize.Value = baseAlgorithmPopulationSize;
+      baseLevelAlgorithm.Problem = new HeuristicLab.Problems.TestFunctions.SingleObjectiveTestFunctionProblem() { 
+        Evaluator = new GriewankEvaluator(),
+        ProblemSize = new IntValue(1000) 
+      };
       baseLevelAlgorithm.MaximumGenerations.Value = baseAlgorithmMaxGenerations;
 
@@ -85 +97 @@
       ConfigureMutationRate(algorithmVc);
       ConfigureMutationOperator(algorithmVc);
+      ConfigureElites(algorithmVc);
+      ConfigureSelectionOperator(algorithmVc);
       return algorithmVc;
     }
 
     private static void TestConfiguration(IValueConfiguration algorithmVc, GeneticAlgorithm baseLevelAlgorithm) {
-      IRandom rand = new MersenneTwister();
+      IRandom rand = new FastRandom(0);
       // set random values
       for (int i = 0; i < 10; i++) {
@@ -99 +113 @@
         Console.WriteLine(string.Format("MutRate: original: {0}, randomized: {1}", baseLevelAlgorithm.MutationProbability, newAlg.MutationProbability));
         Console.WriteLine(string.Format("MutOp: original: {0}, randomized: {1}", baseLevelAlgorithm.Mutator, newAlg.Mutator));
-      }
-
+        Console.WriteLine(string.Format("SelOp: original: {0}, randomized: {1}", baseLevelAlgorithm.Selector, newAlg.Selector));
+        Console.WriteLine(string.Format("GrSi: original: {0}, randomized: {1}", "?", ((TournamentSelector)newAlg.Selector).GroupSizeParameter.Value));
+        Console.WriteLine("---");
+      }
+
+      Console.WriteLine("=======================");
+      algorithmVc.Randomize(rand);
+      algorithmVc.Parameterize(baseLevelAlgorithm);
       // mutate
       for (int i = 0; i < 10; i++) {
@@ -110 +130 @@
         Console.WriteLine(string.Format("MutRate: original: {0}, mutated: {1}", baseLevelAlgorithm.MutationProbability, newAlg.MutationProbability));
         Console.WriteLine(string.Format("MutOp: original: {0}, mutated: {1}", baseLevelAlgorithm.Mutator, newAlg.Mutator));
-      }
-
+        Console.WriteLine(string.Format("SelOp: original: {0}, mutated: {1}", baseLevelAlgorithm.Selector, newAlg.Selector));
+        Console.WriteLine(string.Format("GrSi: original: {0}, mutated: {1}", ((TournamentSelector)baseLevelAlgorithm.Selector).GroupSizeParameter.Value, ((TournamentSelector)newAlg.Selector).GroupSizeParameter.Value));
+        Console.WriteLine("---");
+      }
+
+      Console.WriteLine("=======================");
       // cross
       for (int i = 0; i < 10; i++) {
         IValueConfiguration clonedVc1 = (IValueConfiguration)algorithmVc.Clone();
+        IValueConfiguration clonedVc2 = (IValueConfiguration)algorithmVc.Clone();
+
+        GeneticAlgorithm first = (GeneticAlgorithm)clonedVc1.ActualValue.Value.Clone();
+        GeneticAlgorithm second = (GeneticAlgorithm)clonedVc2.ActualValue.Value.Clone();
+
         clonedVc1.Randomize(rand);
-        clonedVc1.Parameterize(baseLevelAlgorithm);
-
-        IValueConfiguration clonedVc2 = (IValueConfiguration)algorithmVc.Clone();
-        GeneticAlgorithm first = (GeneticAlgorithm)clonedVc1.ActualValue.Value;
-        GeneticAlgorithm second = (GeneticAlgorithm)clonedVc2.ActualValue.Value;
+        clonedVc1.Parameterize(first);
+
+        clonedVc2.Randomize(rand);
+        clonedVc2.Parameterize(second);
 
         var popSizeBefore = first.PopulationSize.Value;
         var mutRateBefore = first.MutationProbability.Value;
         var mutOpBefore = first.Mutator;
+        var selOpBefore = first.Selector;
+        var groupSizeBefore = ((TournamentSelector)first.Selector).GroupSizeParameter.Value.Value;
 
         clonedVc1.Cross(clonedVc2, rand);
-        clonedVc1.Parameterize((GeneticAlgorithm)clonedVc2.ActualValue.Value);
+        clonedVc1.Parameterize(first);
 
         Console.WriteLine(string.Format("PopSize: first: {0}, second: {1}, crossed: {2}", popSizeBefore, second.PopulationSize, first.PopulationSize));
         Console.WriteLine(string.Format("MutRate: first: {0}, second: {1}, crossed: {2}", mutRateBefore, second.MutationProbability, first.MutationProbability));
-        Console.WriteLine(string.Format("MutRate: first: {0}, second: {1}, crossed: {2}", mutOpBefore, second.Mutator, first.Mutator));
-      }
+        Console.WriteLine(string.Format("MutOp: first: {0}, second: {1}, crossed: {2}", mutOpBefore, second.Mutator, first.Mutator));
+        Console.WriteLine(string.Format("SelOp: first: {0}, second: {1}, crossed: {2}", selOpBefore, second.Selector, first.Selector));
+        Console.WriteLine(string.Format("GrSi: first: {0}, second: {1}, crossed: {2}", groupSizeBefore, ((TournamentSelector)second.Selector).GroupSizeParameter.Value, ((TournamentSelector)first.Selector).GroupSizeParameter.Value));
+        Console.WriteLine("---");
+      }
+      Console.WriteLine("=======================");
     }
 
@@ -144 +178 @@
         mutationOperator.ValueConfigurations.SetItemCheckedState(multiMutator, false);
       }
+    }
+
+    private static void ConfigureSelectionOperator(IValueConfiguration algorithmVc) {
+      var selectionOperatorPc = algorithmVc.ParameterConfigurations.Where(x => x.Name == "Selector").SingleOrDefault();
+      selectionOperatorPc.Optimize = true;
+
+      foreach (var vc in selectionOperatorPc.ValueConfigurations) {
+        if (vc.ActualValue.ValueDataType == typeof(TournamentSelector)) {
+          selectionOperatorPc.ValueConfigurations.SetItemCheckedState(vc, true);
+          vc.Optimize = true;
+          ConfigureTournamentGroupSize(vc);
+        } else {
+          selectionOperatorPc.ValueConfigurations.SetItemCheckedState(vc, false);
+        }
+      }
+    }
+
+    private static void ConfigureTournamentGroupSize(IValueConfiguration tournamentVc) {
+      var groupSizePc = tournamentVc.ParameterConfigurations.Where(x => x.ParameterName == "GroupSize").SingleOrDefault();
+      groupSizePc.Optimize = true;
+
+      groupSizePc.ValueConfigurations.First().Optimize = true;
+      groupSizePc.ValueConfigurations.First().RangeConstraint.LowerBound = new IntValue(0);
+      groupSizePc.ValueConfigurations.First().RangeConstraint.UpperBound = new IntValue(100);
+      groupSizePc.ValueConfigurations.First().RangeConstraint.StepSize = new IntValue(1);
     }
 
@@ -151 +210 @@
       var populationSizeVc = populationSizePc.ValueConfigurations.First();
       populationSizeVc.Optimize = true;
-      populationSizeVc.RangeConstraint.LowerBound = new IntValue(0);
+      populationSizeVc.RangeConstraint.LowerBound = new IntValue(20);
       populationSizeVc.RangeConstraint.UpperBound = new IntValue(100);
       populationSizeVc.RangeConstraint.StepSize = new IntValue(1);
@@ -166 +225 @@
     }
 
+    private static void ConfigureElites(IValueConfiguration algorithmVc) {
+      var elitesPc = algorithmVc.ParameterConfigurations.Where(x => x.Name == "Elites").SingleOrDefault();
+      elitesPc.Optimize = true;
+      var elitesVc = elitesPc.ValueConfigurations.First();
+      elitesVc.Optimize = true;
+      elitesVc.RangeConstraint.LowerBound = new IntValue(0);
+      elitesVc.RangeConstraint.UpperBound = new IntValue(20);
+      elitesVc.RangeConstraint.StepSize = new IntValue(1);
+    }
+
     private static void TestOptimization(GeneticAlgorithm metaLevelAlgorithm) {
-      metaLevelAlgorithm.Start();
-      do {
-        Thread.Sleep(1000);
-        Console.Clear();
-        try {
-          foreach (var result in metaLevelAlgorithm.Results) {
-            Console.WriteLine(result.ToString());
-            if (result.Name == "Population") {
-              RunCollection rc = (RunCollection)result.Value;
-              var orderedRuns = rc.OrderBy(x => x.Results["BestQuality"]);
-              foreach (IRun run in orderedRuns) {
-                Console.WriteLine("Q: {0} PoSi: {1} MuRa: {2} MuOp: {3}",
-                  ((DoubleValue)run.Results["BestQuality"]).Value.ToString("0.00").PadLeft(4, ' '),
-                  ((IntValue)run.Parameters["PopulationSize"]).Value.ToString().PadLeft(3, ' '),
-                  ((DoubleValue)run.Parameters["MutationProbability"]).Value.ToString("0.00").PadRight(3, ' '),
-                  run.Parameters["Mutator"]);
-              }
-            }
+      ContentManager.Initialize(new PersistenceContentManager());
+      string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Results");
+      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));
+
+      using (var sw = new StreamWriter(outputPath)) {
+        metaLevelAlgorithm.Start();
+        int i = 0;
+        int currentGeneration = -1;
+        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"]));
+                  }
+                }
+              } // 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 { }
-      } while (metaLevelAlgorithm.ExecutionState != ExecutionState.Stopped);
-
+          catch { }
+        } while (metaLevelAlgorithm.ExecutionState != ExecutionState.Stopped);
+      }
+
+      Console.WriteLine();
+      Console.WriteLine("Storing...");
+
+      ContentManager.Save(metaLevelAlgorithm, resultPath, true);
       Console.WriteLine("Finished");
     }