Changeset 12025 for branches/HeuristicLab.Problems.GrammaticalOptimization/Test

Timestamp:

02/17/15 16:04:20 (10 years ago)

Author:

gkronber

Message:

#2283: unit test cases for symbolic regression

Location:

branches/HeuristicLab.Problems.GrammaticalOptimization/Test

Files:

• TestSymbRegInstances.cs (modified) (1 diff)
• TestTunedSettings.cs (modified) (6 diffs)

branches/HeuristicLab.Problems.GrammaticalOptimization/Test/TestSymbRegInstances.cs

@@ -32 +32 @@
 
     [TestMethod]
+    [Timeout(1000 * 60 * 60 * 8)] // 8 hours
     public void TestSequentialSolverForTower() {
       var problem = new SymbolicRegressionProblem(new Random(), "Tower");
       var random = new Random(31415);
-      var solver = new SequentialSearch(problem, 30, random, 0, new GenericGrammarPolicy(problem, new UCB1TunedPolicy(), true));
+      var solver = new SequentialSearch(problem, 50, random, 0, new GenericFunctionApproximationGrammarPolicy(problem, true));
       solver.FoundNewBestSolution += (s, d) => {
         Console.WriteLine("{0:F3} {1}", d, s);
       };
-      solver.Run(100);
+      solver.Run(100000);
     }
 

branches/HeuristicLab.Problems.GrammaticalOptimization/Test/TestTunedSettings.cs

@@ -11 +11 @@
 using HeuristicLab.Algorithms.GrammaticalOptimization;
 using HeuristicLab.Common;
+using HeuristicLab.Problems.GrammaticalOptimization.SymbReg;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using RandomPolicy = HeuristicLab.Algorithms.Bandits.BanditPolicies.RandomPolicy;
@@ -28 +29 @@
     }
     [TestMethod]
+    [Timeout(1000 * 60 * 60 * 12)] // 12 hours
     // this configuration worked especially well in the experiments
-    public void TestThresholdAscentArtificialAnt() {
+    public void TestAllPoliciesArtificialAnt() {
       CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
 
@@ -40 +42 @@
         {
          () => new RandomPolicy(), 
-          () => new ActiveLearningPolicy(),  
+         () => new ActiveLearningPolicy(),  
          () => new EpsGreedyPolicy(0.01, (aInfo)=> aInfo.MaxReward, "max"), 
          () => new EpsGreedyPolicy(0.05, (aInfo)=> aInfo.MaxReward, "max"), 
@@ -81 +83 @@
          () => new BoltzmannExplorationPolicy(200),
          () => new BoltzmannExplorationPolicy(500),
-          () => new ChernoffIntervalEstimationPolicy( 0.01), 
-          () => new ChernoffIntervalEstimationPolicy( 0.05),
-          () => new ChernoffIntervalEstimationPolicy( 0.1),
-          () => new ChernoffIntervalEstimationPolicy( 0.2),
+         () => new ChernoffIntervalEstimationPolicy( 0.01), 
+         () => new ChernoffIntervalEstimationPolicy( 0.05),
+         () => new ChernoffIntervalEstimationPolicy( 0.1),
+         () => new ChernoffIntervalEstimationPolicy( 0.2),
          () => new ThresholdAscentPolicy(5, 0.01), 
          () => new ThresholdAscentPolicy(5, 0.05),
@@ -110 +112 @@
       var maxSizes = new int[] { 17 };  // necessary size for ant programm
       int nReps = 20;
-      int maxIterations = 20000;
+      int maxIterations = 100000;
       foreach (var instanceFactory in instanceFactories) {
         var sumBestQ = 0.0;
@@ -135 +137 @@
         // Assert.AreEqual(5461.7, sumItersToBest / (double)nReps, 1E-6);
       }
-
+    }
+
+
+    [TestMethod]
+    [Timeout(1000 * 60 * 60 * 12)] // 12 hours
+    // this configuration worked especially well in the experiments
+    public void TestPoly10WithOutConstantOpt() {
+      CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
+
+      var instanceFactories = new Func<int, ISymbolicExpressionTreeProblem>[]
+      {
+        (randSeed) => (ISymbolicExpressionTreeProblem)new SymbolicRegressionPoly10Problem(), 
+      };
+
+      var maxSizes = new int[] { 23 };  
+      int nReps = 20;
+      int maxIterations = 100000;
+      foreach (var instanceFactory in instanceFactories) {
+        var sumBestQ = 0.0;
+        var sumItersToBest = 0;
+        double fractionSolved = 0.0;
+        foreach (var conf in GenerateConfigurations(instanceFactory, nReps, maxSizes)) {
+          var prob = conf.Problem;
+          var maxLen = conf.MaxSize;
+          var rand = new Random(conf.RandSeed);
+
+          var solver = new SequentialSearch(prob, maxLen, rand, 0,
+            new GenericFunctionApproximationGrammarPolicy(prob, true));
+
+          var problemName = prob.GetType().Name;
+          double bestQ; int itersToBest;
+          RunSolver(solver, problemName, string.Empty, 1.0, maxIterations, maxLen, out bestQ, out itersToBest);
+          sumBestQ += bestQ;
+          sumItersToBest += itersToBest;
+          if (bestQ.IsAlmost(1.0)) fractionSolved += 1.0 / nReps;
+        }
+        // Assert.AreEqual(0.85, fractionSolved, 1E-6);
+        // Assert.AreEqual(0.99438202247191, sumBestQ / nReps, 1E-6);
+        // Assert.AreEqual(5461.7, sumItersToBest / (double)nReps, 1E-6);
+      }
+    }
+
+    [TestMethod]
+    [Timeout(1000 * 60 * 60 * 12)] // 12 hours
+    // this configuration worked especially well in the experiments
+    public void TestPoly10WithConstantOpt() {
+      CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
+
+      var instanceFactories = new Func<int, ISymbolicExpressionTreeProblem>[]
+      {
+        (randSeed) => (ISymbolicExpressionTreeProblem)new SymbolicRegressionProblem(new Random(randSeed), "Poly-10", true ), 
+      };
+
+      var maxSizes = new int[] { 23 };  
+      int nReps = 20;
+      int maxIterations = 100000;
+      foreach (var instanceFactory in instanceFactories) {
+        var sumBestQ = 0.0;
+        var sumItersToBest = 0;
+        double fractionSolved = 0.0;
+        foreach (var conf in GenerateConfigurations(instanceFactory, nReps, maxSizes)) {
+          var prob = conf.Problem;
+          var maxLen = conf.MaxSize;
+          var rand = new Random(conf.RandSeed);
+
+          var solver = new SequentialSearch(prob, maxLen, rand, 0,
+            new GenericFunctionApproximationGrammarPolicy(prob, true));
+
+          var problemName = prob.GetType().Name;
+          double bestQ; int itersToBest;
+          RunSolver(solver, problemName, string.Empty, 1.0, maxIterations, maxLen, out bestQ, out itersToBest);
+          sumBestQ += bestQ;
+          sumItersToBest += itersToBest;
+          if (bestQ.IsAlmost(1.0)) fractionSolved += 1.0 / nReps;
+        }
+        // Assert.AreEqual(0.85, fractionSolved, 1E-6);
+        // Assert.AreEqual(0.99438202247191, sumBestQ / nReps, 1E-6);
+        // Assert.AreEqual(5461.7, sumItersToBest / (double)nReps, 1E-6);
+      }
     }