Changeset 11865 for branches/HeuristicLab.Problems.GrammaticalOptimization/Main/Program.cs

Timestamp:

02/02/15 20:41:11 (10 years ago)

Author:

gkronber

Message:

#2283: implemented royal tree problem and grid test for tree-based gp variants

File:

• branches/HeuristicLab.Problems.GrammaticalOptimization/Main/Program.cs (modified) (4 diffs)

branches/HeuristicLab.Problems.GrammaticalOptimization/Main/Program.cs

@@ -25 +25 @@
 
       //RunDemo();
-      RunGpDemo();
+      //RunGpDemo();
       // RunGridTest();
+      RunGpGridTest();
     }
 
@@ -174 +175 @@
 
     private static void RunDemo() {
-      // TODO: implement bridge to HL-GP 
       // TODO: unify MCTS, TD and ContextMCTS Solvers (stateInfos)
       // TODO: test with eps-greedy using max instead of average as value (seems to work well for symb-reg! explore further!)
       // TODO: separate value function from policy
-      // TODO: in contextual MCTS store a bandit info for each node in the _graph_ and also update all bandit infos of all parents
-      // TODO: exhaustive search with priority list
       // TODO: warum funktioniert die alte Implementierung von GaussianThompson besser fÃŒr SantaFe als neue? Siehe Vergleich: alte vs. neue implementierung GaussianThompsonSampling
       // TODO: why does GaussianThompsonSampling work so well with MCTS for the artificial ant problem?
       // TODO: research thompson sampling for max bandit?
-      // TODO: ausfÃŒhrlicher test von strategien fÃŒr numCorrectPhrases-armed max bandit
       // TODO: verify TA implementation using example from the original paper      
-      // TODO: separate policy from MCTS tree data structure to allow sharing of information over disconnected parts of the tree (semantic equivalence)
       // TODO: implement thompson sampling for gaussian mixture models
-      // TODO: implement inspection for MCTS (eventuell interactive command line fÃŒr statistiken aus dem baum anzeigen)
-      // TODO: implement ACO-style bandit policy
       // TODO: gleichzeitige modellierung von transformierter zielvariable (y, 1/y, log(y), exp(y), sqrt(y), ...)
       // TODO: vergleich bei complete-randomly möglichst kurze sÀtze generieren vs. einfach zufÀllig alternativen wÀhlen
@@ -299 +293 @@
 
     public static void RunGpDemo() {
-
       int iterations = 0;
+      const int seed = 31415;
       const int maxIterations = 100000;
+
+    }
+
+
+    private static void RunGpGridTest() {
+      const int nReps = 20;
       const int seed = 31415;
-      var globalStatistics = new SentenceSetStatistics(512);
-
-      var gp = new StandardGP(new HardPalindromeProblem(), new Random(seed));
-      gp.FoundNewBestSolution += (sentence, quality) => {
-        Console.WriteLine("{0}", globalStatistics);
-      };
+      const int maxIters = 100000;
+      var rand = new Random(seed);
+      var problemFactories = new Func<ISymbolicExpressionTreeProblem>[]
+      {
+        () => new SantaFeAntProblem(), 
+        () => new SymbolicRegressionPoly10Problem(), 
+      };
+      foreach (var popSize in new int[] { 50, 100, 250, 500, 1000, 2500, 5000 }) {
+        foreach (var mutationRate in new double[] {/* 0.05, 0.10, */ 0.15, /* 0.25, 0.3 */ }) {
+          foreach (var maxSize in new int[] { 30, 50, 100 }) {
+            foreach (var problemFactory in problemFactories)
+              for (int i = 0; i < nReps; i++) {
+                var solverSeed = rand.Next();
+                {
+                  var prob = problemFactory();
+                  RunStandardGP(prob, solverSeed, maxIters, popSize, mutationRate, maxSize);
+                }
+                {
+                  var prob = problemFactory();
+                  RunOSGP(prob, solverSeed, maxIters, popSize, mutationRate, maxSize);
+                }
+              }
+          }
+        }
+      }
+    }
+
+    private static void RunStandardGP(ISymbolicExpressionTreeProblem prob, int solverSeed, int maxIters, int popSize, double mutationRate, int maxSize) {
+      int iterations = 0;
+      var globalStatistics = new SentenceSetStatistics(prob.BestKnownQuality(maxSize));
+
+      var gp = new StandardGP(prob, new Random(solverSeed));
       gp.SolutionEvaluated += (sentence, quality) => {
         iterations++;
@@ -314 +340 @@
 
         if (iterations % 10000 == 0) {
-          Console.WriteLine("{0}", globalStatistics);
-        }
-      };
-
-      gp.PopulationSize = 1000;
-      gp.MaxSolutionSize = 31 + 2;
-      gp.MaxSolutionDepth = 20;
+          Console.WriteLine("\"{0,25}\" \"{1,25}\" {2}", gp, prob, globalStatistics);
+        }
+      };
+
+      gp.PopulationSize = popSize;
+      gp.MutationRate = mutationRate;
+      gp.MaxSolutionSize = maxSize + 2;
+      gp.MaxSolutionDepth = maxSize + 2;
 
       var sw = new Stopwatch();
 
       sw.Start();
-      gp.Run(maxIterations);
+      gp.Run(maxIters);
       sw.Stop();
 
-      Console.WriteLine(globalStatistics);
-      Console.WriteLine("{0:F2} sec {1,10:F1} sols/sec {2,10:F1} ns/sol",
-        sw.Elapsed.TotalSeconds,
-        maxIterations / (double)sw.Elapsed.TotalSeconds,
-        (double)sw.ElapsedMilliseconds * 1000 / maxIterations);
+      Console.WriteLine("\"{0,25}\" \"{1,25}\" {2}", gp, prob, globalStatistics);
+
+      // Console.WriteLine("{0:F2} sec {1,10:F1} sols/sec {2,10:F1} ns/sol",
+      //   sw.Elapsed.TotalSeconds,
+      //   maxIters / (double)sw.Elapsed.TotalSeconds,
+      //   (double)sw.ElapsedMilliseconds * 1000 / maxIters);
+    }
+
+    private static void RunOSGP(ISymbolicExpressionTreeProblem prob, int solverSeed, int maxIters, int popSize, double mutationRate, int maxSize) {
+      int iterations = 0;
+      var globalStatistics = new SentenceSetStatistics(prob.BestKnownQuality(maxSize));
+
+      var gp = new OffspringSelectionGP(prob, new Random(solverSeed));
+      gp.SolutionEvaluated += (sentence, quality) => {
+        iterations++;
+        globalStatistics.AddSentence(sentence, quality);
+
+        if (iterations % 10000 == 0) {
+          Console.WriteLine("\"{0,25}\" \"{1,25}\" {2}", gp, prob, globalStatistics);
+        }
+      };
+
+      gp.PopulationSize = popSize;
+      gp.MutationRate = mutationRate;
+      gp.MaxSolutionSize = maxSize + 2;
+      gp.MaxSolutionDepth = maxSize + 2;
+
+      var sw = new Stopwatch();
+
+      sw.Start();
+      gp.Run(maxIters);
+      sw.Stop();
+
+      Console.WriteLine("\"{0,25}\" \"{1,25}\" {2}", gp, prob, globalStatistics);
+
+      // Console.WriteLine("{0:F2} sec {1,10:F1} sols/sec {2,10:F1} ns/sol",
+      //   sw.Elapsed.TotalSeconds,
+      //   maxIters / (double)sw.Elapsed.TotalSeconds,
+      //   (double)sw.ElapsedMilliseconds * 1000 / maxIters);
     }
   }