Free cookie consent management tool by TermsFeed Policy Generator

source: branches/2886_SymRegGrammarEnumeration/Test/GrammarEnumerationTest.cs @ 15726

Last change on this file since 15726 was 15726, checked in by lkammere, 6 years ago

#2886: Overwrite long sentences when a shorter one with same hash was found.

File size: 29.4 KB
Line 
1using System;
2using System.Linq;
3using HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration;
4using HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.GrammarEnumeration;
5using HeuristicLab.Common;
6using HeuristicLab.Core;
7using HeuristicLab.Data;
8using HeuristicLab.Optimization;
9using HeuristicLab.Problems.DataAnalysis;
10using HeuristicLab.Random;
11using Microsoft.VisualStudio.TestTools.UnitTesting;
12
13namespace HeuristicLab.Algorithms.DataAnalysis.MctsSymbolicRegression {
14  [TestClass]
15  public class MctsSymbolicRegressionTest {
16    private const int Seed = 1234;
17    private IRandom rand;
18
19    private const double SuccessThreshold = 0.9999999;
20
21    private GrammarEnumerationAlgorithm alg;
22    private RegressionProblem problem;
23
24    [TestInitialize]
25    public void InitTest() {
26      Console.Write("init called... ");
27      rand = new FastRandom(Seed);
28
29      alg = new GrammarEnumerationAlgorithm();
30      problem = new RegressionProblem();
31      alg.Problem = problem;
32      alg.GuiUpdateInterval = int.MaxValue;
33    }
34
35    [TestCleanup()]
36    public void Cleanup() {
37      if (alg.BestTrainingSentence != null) {
38        Console.WriteLine("Training: " + alg.Grammar.PostfixToInfixParser(alg.BestTrainingSentence));
39      }
40      if (alg.BestTestSentence != null) {
41        Console.WriteLine("Test: " + alg.Grammar.PostfixToInfixParser(alg.BestTestSentence));
42      }
43    }
44
45
46    private void EvaluateGrammarEnumeration() {
47      // Evaluate results
48      var eps = 1.0 - SuccessThreshold;
49
50      // Check if algorithm terminated correctly
51      Assert.IsTrue(alg.Results.ContainsKey("Best solution quality (training)"), "No training solution returned!");
52      Assert.IsTrue(alg.Results.ContainsKey("Best solution quality (test)"), "No test solution returned!");
53
54      // Check resultss
55      Assert.AreEqual(1.0, ((DoubleValue)alg.Results["Best solution quality (training)"].Value).Value, eps, "Training quality too low!");
56      Assert.AreEqual(1.0, ((DoubleValue)alg.Results["Best solution quality (test)"].Value).Value, eps, "Test quality too low!");
57
58      // Check overfitting
59      Assert.AreEqual(alg.Grammar.CalcHashCode(alg.BestTrainingSentence),
60                    alg.Grammar.CalcHashCode(alg.BestTestSentence),
61                    "Training and Test solution are not equal!");
62    }
63
64
65    #region test structure search (no constants)
66    [TestMethod]
67    [TestProperty("Goal", "structure search")]
68    public void MctsSymbReg_NoConstants_Nguyen1() {
69      // x³ + x² + x
70      alg.MaxTreeSize = 30;
71      Console.WriteLine(alg.MaxTreeSize);
72      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
73      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F1 ")));
74      alg.Problem.ProblemData = regProblem;
75
76      alg.Start();
77
78      // Evaluate
79      // EvaluateGrammarEnumeration();
80
81      TerminalSymbol varSymbol = alg.Grammar.Var.VariableTerminalSymbols.First();
82      TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
83      TerminalSymbol addSymbol = alg.Grammar.Addition;
84
85      SymbolString targetSolution = new SymbolString(new[] {
86        varSymbol, varSymbol, varSymbol, mulSymbol, mulSymbol,
87        varSymbol, varSymbol, mulSymbol, addSymbol,
88        varSymbol, addSymbol
89      });
90
91      int targetSolutionHash = alg.Grammar.CalcHashCode(targetSolution);
92      int actualSolutionHash = alg.Grammar.CalcHashCode(alg.BestTestSentence);
93
94      Assert.IsTrue(alg.DistinctGenerated.Select(tuple => tuple.Item2).Contains(actualSolutionHash));
95
96      // last because long sentences are overwritten by short ones.
97      Console.WriteLine(alg.Grammar.PostfixToInfixParser(alg.DistinctGenerated.Last(tuple => tuple.Item2 == targetSolutionHash).Item1));
98
99
100      Assert.AreEqual(targetSolutionHash, actualSolutionHash);
101    }
102
103    [TestMethod]
104    [TestProperty("Goal", "structure search")]
105    public void MctsSymbReg_NoConstants_Nguyen2() {
106      // x^4 + x³ + x² + x
107      alg.MaxTreeSize = 30;
108      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
109      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F2 ")));
110      alg.Problem.ProblemData = regProblem;
111
112      alg.Start();
113
114      // Evaluate
115      EvaluateGrammarEnumeration();
116    }
117
118    /*  NEXT UP
119    [TestMethod]
120    [TestProperty("Goal", "structure search")]
121    public void MctsSymbReg_NoConstants_Nguyen3() {
122      // x^5 + x^4 + x³ + x² + x
123      alg.MaxTreeSize = 25;
124      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
125      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F3 ")));
126      TestGrammarEnumeration(regProblem);
127    }
128    [TestMethod]
129    [TestProperty("Goal", "structure search")]
130    public void MctsSymbReg_NoConstants_Nguyen4() {
131
132      // x^6 + x^5 + x^4 + x³ + x² + x
133      alg.MaxTreeSize = 30;
134      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
135      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F4 ")));
136      TestGrammarEnumeration(regProblem);
137    } */
138
139
140    #endregion
141
142    #region TODO
143
144#if false
145    [TestMethod]
146    [TestCategory("Algorithms.DataAnalysis")]
147    [TestProperty("Time", "short")]
148    public void MctsSymbReg_NoConstants_Nguyen7() {
149      // log(x + 1) + log(x² + 1)
150      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
151      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F7 ")));
152      TestGrammarEnumeration(regProblem);
153    }
154
155    [TestMethod]
156    [TestCategory("Algorithms.DataAnalysis")]
157    [TestProperty("Time", "short")]
158    public void MctsSymbReg_NoConstants_Poly10_Part1() {
159      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
160      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
161
162      //  Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
163      //  Y' = X1*X2 + X3*X4 + X5*X6
164      // simplify problem by changing target
165      var ds = ((Dataset)regProblem.Dataset).ToModifiable();
166      var ys = ds.GetDoubleValues("Y").ToArray();
167      var x1 = ds.GetDoubleValues("X1").ToArray();
168      var x2 = ds.GetDoubleValues("X2").ToArray();
169      var x3 = ds.GetDoubleValues("X3").ToArray();
170      var x4 = ds.GetDoubleValues("X4").ToArray();
171      var x5 = ds.GetDoubleValues("X5").ToArray();
172      var x6 = ds.GetDoubleValues("X6").ToArray();
173      var x7 = ds.GetDoubleValues("X7").ToArray();
174      var x8 = ds.GetDoubleValues("X8").ToArray();
175      var x9 = ds.GetDoubleValues("X9").ToArray();
176      var x10 = ds.GetDoubleValues("X10").ToArray();
177      for (int i = 0; i < ys.Length; i++) {
178        ys[i] -= x1[i] * x7[i] * x9[i];
179        ys[i] -= x3[i] * x6[i] * x10[i];
180      }
181      ds.ReplaceVariable("Y", ys.ToList());
182
183      var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
184
185      TestGrammarEnumeration(modifiedProblemData);
186    }
187
188    [TestMethod]
189    [TestCategory("Algorithms.DataAnalysis")]
190    [TestProperty("Time", "short")]
191    public void MctsSymbReg_NoConstants_Poly10_Part2() {
192      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
193      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
194
195      //  Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
196      //  Y' = X1*X7*X9 + X3*X6*X10
197      // simplify problem by changing target
198      var ds = ((Dataset)regProblem.Dataset).ToModifiable();
199      var ys = ds.GetDoubleValues("Y").ToArray();
200      var x1 = ds.GetDoubleValues("X1").ToArray();
201      var x2 = ds.GetDoubleValues("X2").ToArray();
202      var x3 = ds.GetDoubleValues("X3").ToArray();
203      var x4 = ds.GetDoubleValues("X4").ToArray();
204      var x5 = ds.GetDoubleValues("X5").ToArray();
205      var x6 = ds.GetDoubleValues("X6").ToArray();
206      var x7 = ds.GetDoubleValues("X7").ToArray();
207      var x8 = ds.GetDoubleValues("X8").ToArray();
208      var x9 = ds.GetDoubleValues("X9").ToArray();
209      var x10 = ds.GetDoubleValues("X10").ToArray();
210      for (int i = 0; i < ys.Length; i++) {
211        ys[i] -= x1[i] * x2[i];
212        ys[i] -= x3[i] * x4[i];
213        ys[i] -= x5[i] * x6[i];
214      }
215      ds.ReplaceVariable("Y", ys.ToList());
216
217      var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
218
219      TestGrammarEnumeration(modifiedProblemData);
220    }
221
222    [TestMethod]
223    [TestCategory("Algorithms.DataAnalysis")]
224    [TestProperty("Time", "short")]
225    public void MctsSymbReg_NoConstants_Poly10_Part3() {
226      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
227      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
228
229      //  Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
230      //  Y' = X1*X2 + X1*X7*X9
231      // simplify problem by changing target
232      var ds = ((Dataset)regProblem.Dataset).ToModifiable();
233      var ys = ds.GetDoubleValues("Y").ToArray();
234      var x1 = ds.GetDoubleValues("X1").ToArray();
235      var x2 = ds.GetDoubleValues("X2").ToArray();
236      var x3 = ds.GetDoubleValues("X3").ToArray();
237      var x4 = ds.GetDoubleValues("X4").ToArray();
238      var x5 = ds.GetDoubleValues("X5").ToArray();
239      var x6 = ds.GetDoubleValues("X6").ToArray();
240      var x7 = ds.GetDoubleValues("X7").ToArray();
241      var x8 = ds.GetDoubleValues("X8").ToArray();
242      var x9 = ds.GetDoubleValues("X9").ToArray();
243      var x10 = ds.GetDoubleValues("X10").ToArray();
244      for (int i = 0; i < ys.Length; i++) {
245        ys[i] -= x3[i] * x4[i];
246        ys[i] -= x5[i] * x6[i];
247        ys[i] -= x3[i] * x6[i] * x10[i];
248      }
249      ds.ReplaceVariable("Y", ys.ToList());
250
251      var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
252
253      TestGrammarEnumeration(modifiedProblemData);
254    }
255
256    [TestMethod]
257    [TestCategory("Algorithms.DataAnalysis")]
258    [TestProperty("Time", "short")]
259    public void MctsSymbReg_NoConstants_Poly10_Part4() {
260      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
261      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
262
263      //  Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
264      //  Y' = X3*X4 + X5*X6 + X3*X6*X10
265      // simplify problem by changing target
266      var ds = ((Dataset)regProblem.Dataset).ToModifiable();
267      var ys = ds.GetDoubleValues("Y").ToArray();
268      var x1 = ds.GetDoubleValues("X1").ToArray();
269      var x2 = ds.GetDoubleValues("X2").ToArray();
270      var x3 = ds.GetDoubleValues("X3").ToArray();
271      var x4 = ds.GetDoubleValues("X4").ToArray();
272      var x5 = ds.GetDoubleValues("X5").ToArray();
273      var x6 = ds.GetDoubleValues("X6").ToArray();
274      var x7 = ds.GetDoubleValues("X7").ToArray();
275      var x8 = ds.GetDoubleValues("X8").ToArray();
276      var x9 = ds.GetDoubleValues("X9").ToArray();
277      var x10 = ds.GetDoubleValues("X10").ToArray();
278      for (int i = 0; i < ys.Length; i++) {
279        ys[i] -= x1[i] * x2[i];
280        ys[i] -= x1[i] * x7[i] * x9[i];
281      }
282      ds.ReplaceVariable("Y", ys.ToList());
283      var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
284
285
286      TestGrammarEnumeration(modifiedProblemData);
287    }
288
289    [TestMethod]
290    [TestCategory("Algorithms.DataAnalysis")]
291    [TestProperty("Time", "short")]
292    public void MctsSymbReg_NoConstants_Poly10_Part5() {
293      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
294      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
295
296      //  Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
297      //  Y' = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9
298      // simplify problem by changing target
299      var ds = ((Dataset)regProblem.Dataset).ToModifiable();
300      var ys = ds.GetDoubleValues("Y").ToArray();
301      var x1 = ds.GetDoubleValues("X1").ToArray();
302      var x2 = ds.GetDoubleValues("X2").ToArray();
303      var x3 = ds.GetDoubleValues("X3").ToArray();
304      var x4 = ds.GetDoubleValues("X4").ToArray();
305      var x5 = ds.GetDoubleValues("X5").ToArray();
306      var x6 = ds.GetDoubleValues("X6").ToArray();
307      var x7 = ds.GetDoubleValues("X7").ToArray();
308      var x8 = ds.GetDoubleValues("X8").ToArray();
309      var x9 = ds.GetDoubleValues("X9").ToArray();
310      var x10 = ds.GetDoubleValues("X10").ToArray();
311      for (int i = 0; i < ys.Length; i++) {
312        ys[i] -= x3[i] * x6[i] * x10[i];
313      }
314      ds.ReplaceVariable("Y", ys.ToList());
315      var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
316
317
318      TestGrammarEnumeration(modifiedProblemData);
319    }
320
321    [TestMethod]
322    [TestCategory("Algorithms.DataAnalysis")]
323    [TestProperty("Time", "short")]
324    public void MctsSymbReg_NoConstants_Poly10_Part6() {
325      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
326      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
327
328      //  Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
329      //  Y' = X1*X2 + X3*X4 + X5*X6 + X3*X6*X10
330      // simplify problem by changing target
331      var ds = ((Dataset)regProblem.Dataset).ToModifiable();
332      var ys = ds.GetDoubleValues("Y").ToArray();
333      var x1 = ds.GetDoubleValues("X1").ToArray();
334      var x2 = ds.GetDoubleValues("X2").ToArray();
335      var x3 = ds.GetDoubleValues("X3").ToArray();
336      var x4 = ds.GetDoubleValues("X4").ToArray();
337      var x5 = ds.GetDoubleValues("X5").ToArray();
338      var x6 = ds.GetDoubleValues("X6").ToArray();
339      var x7 = ds.GetDoubleValues("X7").ToArray();
340      var x8 = ds.GetDoubleValues("X8").ToArray();
341      var x9 = ds.GetDoubleValues("X9").ToArray();
342      var x10 = ds.GetDoubleValues("X10").ToArray();
343      for (int i = 0; i < ys.Length; i++) {
344        ys[i] -= x1[i] * x7[i] * x9[i];
345      }
346      ds.ReplaceVariable("Y", ys.ToList());
347      var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
348
349      TestGrammarEnumeration(modifiedProblemData);
350    }
351
352
353    [TestMethod]
354    [TestCategory("Algorithms.DataAnalysis")]
355    [TestProperty("Time", "long")]
356    public void MctsSymbReg_NoConstants_Poly10_250rows() {
357      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
358      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
359      regProblem.TrainingPartition.Start = 0;
360      regProblem.TrainingPartition.End = regProblem.Dataset.Rows;
361      regProblem.TestPartition.Start = 0;
362      regProblem.TestPartition.End = 2;
363      TestGrammarEnumeration(regProblem);
364    }
365
366    [TestMethod]
367    [TestCategory("Algorithms.DataAnalysis")]
368    [TestProperty("Time", "long")]
369    public void MctsSymbReg_NoConstants_Poly10_10000rows() {
370      // as poly-10 but more rows
371      var x1 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
372      var x2 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
373      var x3 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
374      var x4 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
375      var x5 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
376      var x6 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
377      var x7 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
378      var x8 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
379      var x9 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
380      var x10 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
381      var ys = new List<double>();
382      for (int i = 0; i < x1.Count; i++) {
383        ys.Add(x1[i] * x2[i] + x3[i] * x4[i] + x5[i] * x6[i] + x1[i] * x7[i] * x9[i] + x3[i] * x6[i] * x10[i]);
384      }
385
386      var ds = new Dataset(new string[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "y" },
387        new[] { x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, ys });
388
389
390      var problemData = new RegressionProblemData(ds, new string[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j" }, "y");
391
392      problemData.TrainingPartition.Start = 0;
393      problemData.TrainingPartition.End = problemData.Dataset.Rows;
394      problemData.TestPartition.Start = 0;
395      problemData.TestPartition.End = 2; // must not be empty
396
397
398      TestGrammarEnumeration(problemData);
399    }
400
401    [TestMethod]
402    [TestCategory("Algorithms.DataAnalysis")]
403    [TestProperty("Time", "short")]
404    public void MctsSymbReg_NoConstants_TwoVars() {
405
406      // y = x1 + x2 + x1*x2 + x1*x2*x2 + x1*x1*x2
407      var x1 = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
408      var x2 = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
409      var ys = x1.Zip(x2, (x1i, x2i) => x1i + x2i + x1i * x2i + x1i * x2i * x2i + x1i * x1i * x2i).ToList();
410
411      var ds = new Dataset(new string[] { "a", "b", "y" }, new[] { x1, x2, ys });
412      var problemData = new RegressionProblemData(ds, new string[] { "a", "b" }, "y");
413
414      TestGrammarEnumeration(problemData);
415    }
416
417    [TestMethod]
418    [TestCategory("Algorithms.DataAnalysis")]
419    [TestProperty("Time", "short")]
420    public void MctsSymbReg_NoConstants_Misleading() {
421
422      // y = a + baaaaa (the effect of the second term should be very small)
423      // the alg will quickly find that a has big effect and will search below a
424      // since we prevent a + a... the algorithm must find the correct expression via a + b...
425      // however b has a small effect so the branch might not be identified as relevant
426      var @as = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
427      var bs = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
428      var cs = Enumerable.Range(0, 100).Select(_ => rand.NextDouble() * 1.0e-3).ToList();
429      var ds = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
430      var es = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
431      var ys = new double[@as.Count];
432      for (int i = 0; i < ys.Length; i++)
433        ys[i] = @as[i] + bs[i] + @as[i] * bs[i] * cs[i];
434
435      var dataset = new Dataset(new string[] { "a", "b", "c", "d", "e", "y" }, new[] { @as, bs, cs, ds, es, ys.ToList() });
436
437      var problemData = new RegressionProblemData(dataset, new string[] { "a", "b", "c", "d", "e" }, "y");
438
439      TestGrammarEnumeration(problemData);
440    }
441
442    #region restricted structure but including numeric constants
443
444    [TestMethod]
445    [TestCategory("Algorithms.DataAnalysis")]
446    [TestProperty("Time", "short")]
447    public void MctsSymbRegKeijzer7() {
448      // ln(x)
449      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
450      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 7 f(")));
451      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
452      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
453      TestGrammarEnumeration(regProblem);
454    }
455
456   
457    [TestMethod]
458    [TestCategory("Algorithms.DataAnalysis")]
459    [TestProperty("Time", "short")]
460    public void MctsSymbRegBenchmarkNguyen5() {
461      // sin(x²)cos(x) - 1
462      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
463      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F5 ")));
464      TestGrammarEnumeration(regProblem);
465    }
466
467    [TestMethod]
468    [TestCategory("Algorithms.DataAnalysis")]
469    [TestProperty("Time", "short")]
470    public void MctsSymbRegBenchmarkNguyen6() {
471      // sin(x) + sin(x + x²)
472      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
473      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F6 ")));
474      TestGrammarEnumeration(regProblem);
475    }
476   
477    [TestMethod]
478    [TestCategory("Algorithms.DataAnalysis")]
479    [TestProperty("Time", "short")]
480    public void MctsSymbRegBenchmarkNguyen7() {
481      //  log(x + 1) + log(x² + 1)
482      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
483      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F7 ")));
484      TestGrammarEnumeration(regProblem);
485    }
486    [TestMethod]
487    [TestCategory("Algorithms.DataAnalysis")]
488    [TestProperty("Time", "short")]
489    public void MctsSymbRegBenchmarkNguyen8() {
490      // Sqrt(x)
491      // = x ^ 0.5
492      // = exp(0.5 * log(x))
493      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
494      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F8 ")));
495      TestGrammarEnumeration(regProblem);
496    }
497   
498    // [TestMethod]
499    [TestCategory("Algorithms.DataAnalysis")]
500    [TestProperty("Time", "short")]
501    public void MctsSymbRegBenchmarkNguyen9() {
502      //  sin(x) + sin(y²)
503      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
504      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F9 ")));
505      TestGrammarEnumeration(regProblem);
506    }
507
508    // [TestMethod]
509    [TestCategory("Algorithms.DataAnalysis")]
510    [TestProperty("Time", "short")]
511    public void MctsSymbRegBenchmarkNguyen10() {
512      // 2sin(x)cos(y)
513      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
514      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F10 ")));
515      TestGrammarEnumeration(regProblem);
516    }
517   
518    [TestMethod]
519    [TestCategory("Algorithms.DataAnalysis")]
520    [TestProperty("Time", "short")]
521    public void MctsSymbRegBenchmarkNguyen11() {
522      // x ^ y  , x > 0, y > 0   
523      // = exp(y * log(x))
524      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
525      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F11 ")));
526      TestGrammarEnumeration(regProblem);
527    }
528    [TestMethod]
529    [TestCategory("Algorithms.DataAnalysis")]
530    [TestProperty("Time", "short")]
531    public void MctsSymbRegBenchmarkNguyen12() {
532      // x^4 - x³ + y²/2 - y
533      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
534      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F12 ")));
535      TestGrammarEnumeration(regProblem);
536    }
537
538    #endregion
539
540    #region keijzer
541    [TestMethod]
542    [TestCategory("Algorithms.DataAnalysis")]
543    [TestProperty("Time", "long")]
544    public void MctsSymbRegBenchmarkKeijzer5() {
545      // (30 * x * z) / ((x - 10)  * y²)
546      // = 30 x z / (xy² - y²)
547      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
548      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 5 f(")));
549      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
550      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
551      TestGrammarEnumeration(regProblem);
552    }
553
554    [TestMethod]
555    [TestCategory("Algorithms.DataAnalysis")]
556    [TestProperty("Time", "short")]
557    public void MctsSymbRegBenchmarkKeijzer6() {
558      // Keijzer 6 f(x) = Sum(1 / i) From 1 to X  , x \in [0..120]
559      // we can only approximate this
560      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
561      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 6 f(")));
562      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
563      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
564      TestGrammarEnumeration(regProblem);
565    }
566
567    [TestMethod]
568    [TestCategory("Algorithms.DataAnalysis")]
569    [TestProperty("Time", "short")]
570    public void MctsSymbRegBenchmarkKeijzer8() {
571      // sqrt(x)
572      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
573      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 8 f(")));
574      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
575      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
576      TestGrammarEnumeration(regProblem);
577    }
578
579    [TestMethod]
580    [TestCategory("Algorithms.DataAnalysis")]
581    [TestProperty("Time", "short")]
582    public void MctsSymbRegBenchmarkKeijzer9() {
583      // arcsinh(x)  i.e. ln(x + sqrt(x² + 1))
584      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
585      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 9 f(")));
586      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
587      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
588      TestGrammarEnumeration(regProblem);
589    }
590
591    [TestMethod]
592    [TestCategory("Algorithms.DataAnalysis")]
593    [TestProperty("Time", "short")]
594    public void MctsSymbRegBenchmarkKeijzer11() {
595      // xy + sin( (x-1) (y-1) )
596      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
597      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 11 f(")));
598      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
599      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
600      TestGrammarEnumeration(regProblem);
601    }
602
603    [TestMethod]
604    [TestCategory("Algorithms.DataAnalysis")]
605    [TestProperty("Time", "short")]
606    public void MctsSymbRegBenchmarkKeijzer12() {
607      // x^4 - x³ + y² / 2 - y,  same as Nguyen 12             
608      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
609      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 12 f(")));
610      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
611      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
612      TestGrammarEnumeration(regProblem);
613    }
614
615    [TestMethod]
616    [TestCategory("Algorithms.DataAnalysis")]
617    [TestProperty("Time", "short")]
618    public void MctsSymbRegBenchmarkKeijzer14() {
619      // 8 / (2 + x² + y²)
620      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
621      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 14 f(")));
622      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
623      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
624      TestGrammarEnumeration(regProblem);
625    }
626
627    [TestMethod]
628    [TestCategory("Algorithms.DataAnalysis")]
629    [TestProperty("Time", "short")]
630    public void MctsSymbRegBenchmarkKeijzer15() {
631      // x³ / 5 + y³ / 2 - y - x
632      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
633      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 15 f(")));
634      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
635      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
636      TestGrammarEnumeration(regProblem);
637    }
638    #endregion
639
640#endif
641    #endregion
642  }
643}
Note: See TracBrowser for help on using the repository browser.