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

Last change on this file since 15773 was 15773, checked in by lkammere, 19 months ago

#2886: Update unit tests to cover problems with exp, log and sine.

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