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

Last change on this file since 15734 was 15734, checked in by gkronber, 20 months ago

#2886 worked on grammar enumeration

File size: 30.5 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 = 3;
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.distinctSentences.Select(tuple => tuple.Item2).Contains(actualSolutionHash));
95
96      // last because long sentences are overwritten by short ones.
97      Console.WriteLine(alg.Grammar.PostfixToInfixParser(alg.distinctSentences.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    [TestMethod]
119    [TestProperty("Goal", "structure search")]
120    public void MctsSymbReg_NoConstants_Poly10() {
121      alg.MaxTreeSize = 10;
122      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
123      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly")));
124      alg.Problem.ProblemData = regProblem;
125
126      alg.Start();
127
128      Assert.AreEqual(alg.distinctSentences.Count(), 110);
129
130      // Evaluate
131      // EvaluateGrammarEnumeration();
132    }
133
134    [TestMethod]
135    [TestProperty("Goal", "structure search")]
136    public void MctsSymbReg_NoConstants_15() {
137      alg.MaxTreeSize = 5;
138      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
139      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("15")));
140      alg.Problem.ProblemData = regProblem;
141
142      alg.Start();
143
144      Assert.AreEqual(alg.distinctSentences.Count(), 16);
145
146      // Evaluate
147      // EvaluateGrammarEnumeration();
148    }
149
150    /*  NEXT UP
151    [TestMethod]
152    [TestProperty("Goal", "structure search")]
153    public void MctsSymbReg_NoConstants_Nguyen3() {
154      // x^5 + x^4 + x³ + x² + x
155      alg.MaxTreeSize = 25;
156      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
157      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F3 ")));
158      TestGrammarEnumeration(regProblem);
159    }
160    [TestMethod]
161    [TestProperty("Goal", "structure search")]
162    public void MctsSymbReg_NoConstants_Nguyen4() {
163
164      // x^6 + x^5 + x^4 + x³ + x² + x
165      alg.MaxTreeSize = 30;
166      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
167      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F4 ")));
168      TestGrammarEnumeration(regProblem);
169    } */
170
171
172    #endregion
173
174    #region TODO
175
176#if false
177    [TestMethod]
178    [TestCategory("Algorithms.DataAnalysis")]
179    [TestProperty("Time", "short")]
180    public void MctsSymbReg_NoConstants_Nguyen7() {
181      // log(x + 1) + log(x² + 1)
182      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
183      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F7 ")));
184      TestGrammarEnumeration(regProblem);
185    }
186
187    [TestMethod]
188    [TestCategory("Algorithms.DataAnalysis")]
189    [TestProperty("Time", "short")]
190    public void MctsSymbReg_NoConstants_Poly10_Part1() {
191      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
192      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
193
194      //  Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
195      //  Y' = X1*X2 + X3*X4 + X5*X6
196      // simplify problem by changing target
197      var ds = ((Dataset)regProblem.Dataset).ToModifiable();
198      var ys = ds.GetDoubleValues("Y").ToArray();
199      var x1 = ds.GetDoubleValues("X1").ToArray();
200      var x2 = ds.GetDoubleValues("X2").ToArray();
201      var x3 = ds.GetDoubleValues("X3").ToArray();
202      var x4 = ds.GetDoubleValues("X4").ToArray();
203      var x5 = ds.GetDoubleValues("X5").ToArray();
204      var x6 = ds.GetDoubleValues("X6").ToArray();
205      var x7 = ds.GetDoubleValues("X7").ToArray();
206      var x8 = ds.GetDoubleValues("X8").ToArray();
207      var x9 = ds.GetDoubleValues("X9").ToArray();
208      var x10 = ds.GetDoubleValues("X10").ToArray();
209      for (int i = 0; i < ys.Length; i++) {
210        ys[i] -= x1[i] * x7[i] * x9[i];
211        ys[i] -= x3[i] * x6[i] * x10[i];
212      }
213      ds.ReplaceVariable("Y", ys.ToList());
214
215      var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
216
217      TestGrammarEnumeration(modifiedProblemData);
218    }
219
220    [TestMethod]
221    [TestCategory("Algorithms.DataAnalysis")]
222    [TestProperty("Time", "short")]
223    public void MctsSymbReg_NoConstants_Poly10_Part2() {
224      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
225      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
226
227      //  Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
228      //  Y' = X1*X7*X9 + X3*X6*X10
229      // simplify problem by changing target
230      var ds = ((Dataset)regProblem.Dataset).ToModifiable();
231      var ys = ds.GetDoubleValues("Y").ToArray();
232      var x1 = ds.GetDoubleValues("X1").ToArray();
233      var x2 = ds.GetDoubleValues("X2").ToArray();
234      var x3 = ds.GetDoubleValues("X3").ToArray();
235      var x4 = ds.GetDoubleValues("X4").ToArray();
236      var x5 = ds.GetDoubleValues("X5").ToArray();
237      var x6 = ds.GetDoubleValues("X6").ToArray();
238      var x7 = ds.GetDoubleValues("X7").ToArray();
239      var x8 = ds.GetDoubleValues("X8").ToArray();
240      var x9 = ds.GetDoubleValues("X9").ToArray();
241      var x10 = ds.GetDoubleValues("X10").ToArray();
242      for (int i = 0; i < ys.Length; i++) {
243        ys[i] -= x1[i] * x2[i];
244        ys[i] -= x3[i] * x4[i];
245        ys[i] -= x5[i] * x6[i];
246      }
247      ds.ReplaceVariable("Y", ys.ToList());
248
249      var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
250
251      TestGrammarEnumeration(modifiedProblemData);
252    }
253
254    [TestMethod]
255    [TestCategory("Algorithms.DataAnalysis")]
256    [TestProperty("Time", "short")]
257    public void MctsSymbReg_NoConstants_Poly10_Part3() {
258      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
259      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
260
261      //  Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
262      //  Y' = X1*X2 + X1*X7*X9
263      // simplify problem by changing target
264      var ds = ((Dataset)regProblem.Dataset).ToModifiable();
265      var ys = ds.GetDoubleValues("Y").ToArray();
266      var x1 = ds.GetDoubleValues("X1").ToArray();
267      var x2 = ds.GetDoubleValues("X2").ToArray();
268      var x3 = ds.GetDoubleValues("X3").ToArray();
269      var x4 = ds.GetDoubleValues("X4").ToArray();
270      var x5 = ds.GetDoubleValues("X5").ToArray();
271      var x6 = ds.GetDoubleValues("X6").ToArray();
272      var x7 = ds.GetDoubleValues("X7").ToArray();
273      var x8 = ds.GetDoubleValues("X8").ToArray();
274      var x9 = ds.GetDoubleValues("X9").ToArray();
275      var x10 = ds.GetDoubleValues("X10").ToArray();
276      for (int i = 0; i < ys.Length; i++) {
277        ys[i] -= x3[i] * x4[i];
278        ys[i] -= x5[i] * x6[i];
279        ys[i] -= x3[i] * x6[i] * x10[i];
280      }
281      ds.ReplaceVariable("Y", ys.ToList());
282
283      var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
284
285      TestGrammarEnumeration(modifiedProblemData);
286    }
287
288    [TestMethod]
289    [TestCategory("Algorithms.DataAnalysis")]
290    [TestProperty("Time", "short")]
291    public void MctsSymbReg_NoConstants_Poly10_Part4() {
292      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
293      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
294
295      //  Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
296      //  Y' = X3*X4 + X5*X6 + X3*X6*X10
297      // simplify problem by changing target
298      var ds = ((Dataset)regProblem.Dataset).ToModifiable();
299      var ys = ds.GetDoubleValues("Y").ToArray();
300      var x1 = ds.GetDoubleValues("X1").ToArray();
301      var x2 = ds.GetDoubleValues("X2").ToArray();
302      var x3 = ds.GetDoubleValues("X3").ToArray();
303      var x4 = ds.GetDoubleValues("X4").ToArray();
304      var x5 = ds.GetDoubleValues("X5").ToArray();
305      var x6 = ds.GetDoubleValues("X6").ToArray();
306      var x7 = ds.GetDoubleValues("X7").ToArray();
307      var x8 = ds.GetDoubleValues("X8").ToArray();
308      var x9 = ds.GetDoubleValues("X9").ToArray();
309      var x10 = ds.GetDoubleValues("X10").ToArray();
310      for (int i = 0; i < ys.Length; i++) {
311        ys[i] -= x1[i] * x2[i];
312        ys[i] -= x1[i] * x7[i] * x9[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_Part5() {
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 + X1*X7*X9
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] -= x3[i] * x6[i] * x10[i];
345      }
346      ds.ReplaceVariable("Y", ys.ToList());
347      var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
348
349
350      TestGrammarEnumeration(modifiedProblemData);
351    }
352
353    [TestMethod]
354    [TestCategory("Algorithms.DataAnalysis")]
355    [TestProperty("Time", "short")]
356    public void MctsSymbReg_NoConstants_Poly10_Part6() {
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
360      //  Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
361      //  Y' = X1*X2 + X3*X4 + X5*X6 + X3*X6*X10
362      // simplify problem by changing target
363      var ds = ((Dataset)regProblem.Dataset).ToModifiable();
364      var ys = ds.GetDoubleValues("Y").ToArray();
365      var x1 = ds.GetDoubleValues("X1").ToArray();
366      var x2 = ds.GetDoubleValues("X2").ToArray();
367      var x3 = ds.GetDoubleValues("X3").ToArray();
368      var x4 = ds.GetDoubleValues("X4").ToArray();
369      var x5 = ds.GetDoubleValues("X5").ToArray();
370      var x6 = ds.GetDoubleValues("X6").ToArray();
371      var x7 = ds.GetDoubleValues("X7").ToArray();
372      var x8 = ds.GetDoubleValues("X8").ToArray();
373      var x9 = ds.GetDoubleValues("X9").ToArray();
374      var x10 = ds.GetDoubleValues("X10").ToArray();
375      for (int i = 0; i < ys.Length; i++) {
376        ys[i] -= x1[i] * x7[i] * x9[i];
377      }
378      ds.ReplaceVariable("Y", ys.ToList());
379      var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
380
381      TestGrammarEnumeration(modifiedProblemData);
382    }
383
384
385    [TestMethod]
386    [TestCategory("Algorithms.DataAnalysis")]
387    [TestProperty("Time", "long")]
388    public void MctsSymbReg_NoConstants_Poly10_250rows() {
389      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
390      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
391      regProblem.TrainingPartition.Start = 0;
392      regProblem.TrainingPartition.End = regProblem.Dataset.Rows;
393      regProblem.TestPartition.Start = 0;
394      regProblem.TestPartition.End = 2;
395      TestGrammarEnumeration(regProblem);
396    }
397
398    [TestMethod]
399    [TestCategory("Algorithms.DataAnalysis")]
400    [TestProperty("Time", "long")]
401    public void MctsSymbReg_NoConstants_Poly10_10000rows() {
402      // as poly-10 but more rows
403      var x1 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
404      var x2 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
405      var x3 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
406      var x4 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
407      var x5 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
408      var x6 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
409      var x7 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
410      var x8 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
411      var x9 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
412      var x10 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
413      var ys = new List<double>();
414      for (int i = 0; i < x1.Count; i++) {
415        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]);
416      }
417
418      var ds = new Dataset(new string[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "y" },
419        new[] { x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, ys });
420
421
422      var problemData = new RegressionProblemData(ds, new string[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j" }, "y");
423
424      problemData.TrainingPartition.Start = 0;
425      problemData.TrainingPartition.End = problemData.Dataset.Rows;
426      problemData.TestPartition.Start = 0;
427      problemData.TestPartition.End = 2; // must not be empty
428
429
430      TestGrammarEnumeration(problemData);
431    }
432
433    [TestMethod]
434    [TestCategory("Algorithms.DataAnalysis")]
435    [TestProperty("Time", "short")]
436    public void MctsSymbReg_NoConstants_TwoVars() {
437
438      // y = x1 + x2 + x1*x2 + x1*x2*x2 + x1*x1*x2
439      var x1 = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
440      var x2 = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
441      var ys = x1.Zip(x2, (x1i, x2i) => x1i + x2i + x1i * x2i + x1i * x2i * x2i + x1i * x1i * x2i).ToList();
442
443      var ds = new Dataset(new string[] { "a", "b", "y" }, new[] { x1, x2, ys });
444      var problemData = new RegressionProblemData(ds, new string[] { "a", "b" }, "y");
445
446      TestGrammarEnumeration(problemData);
447    }
448
449    [TestMethod]
450    [TestCategory("Algorithms.DataAnalysis")]
451    [TestProperty("Time", "short")]
452    public void MctsSymbReg_NoConstants_Misleading() {
453
454      // y = a + baaaaa (the effect of the second term should be very small)
455      // the alg will quickly find that a has big effect and will search below a
456      // since we prevent a + a... the algorithm must find the correct expression via a + b...
457      // however b has a small effect so the branch might not be identified as relevant
458      var @as = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
459      var bs = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
460      var cs = Enumerable.Range(0, 100).Select(_ => rand.NextDouble() * 1.0e-3).ToList();
461      var ds = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
462      var es = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
463      var ys = new double[@as.Count];
464      for (int i = 0; i < ys.Length; i++)
465        ys[i] = @as[i] + bs[i] + @as[i] * bs[i] * cs[i];
466
467      var dataset = new Dataset(new string[] { "a", "b", "c", "d", "e", "y" }, new[] { @as, bs, cs, ds, es, ys.ToList() });
468
469      var problemData = new RegressionProblemData(dataset, new string[] { "a", "b", "c", "d", "e" }, "y");
470
471      TestGrammarEnumeration(problemData);
472    }
473
474    #region restricted structure but including numeric constants
475
476    [TestMethod]
477    [TestCategory("Algorithms.DataAnalysis")]
478    [TestProperty("Time", "short")]
479    public void MctsSymbRegKeijzer7() {
480      // ln(x)
481      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
482      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 7 f(")));
483      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
484      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
485      TestGrammarEnumeration(regProblem);
486    }
487
488   
489    [TestMethod]
490    [TestCategory("Algorithms.DataAnalysis")]
491    [TestProperty("Time", "short")]
492    public void MctsSymbRegBenchmarkNguyen5() {
493      // sin(x²)cos(x) - 1
494      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
495      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F5 ")));
496      TestGrammarEnumeration(regProblem);
497    }
498
499    [TestMethod]
500    [TestCategory("Algorithms.DataAnalysis")]
501    [TestProperty("Time", "short")]
502    public void MctsSymbRegBenchmarkNguyen6() {
503      // sin(x) + sin(x + x²)
504      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
505      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F6 ")));
506      TestGrammarEnumeration(regProblem);
507    }
508   
509    [TestMethod]
510    [TestCategory("Algorithms.DataAnalysis")]
511    [TestProperty("Time", "short")]
512    public void MctsSymbRegBenchmarkNguyen7() {
513      //  log(x + 1) + log(x² + 1)
514      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
515      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F7 ")));
516      TestGrammarEnumeration(regProblem);
517    }
518    [TestMethod]
519    [TestCategory("Algorithms.DataAnalysis")]
520    [TestProperty("Time", "short")]
521    public void MctsSymbRegBenchmarkNguyen8() {
522      // Sqrt(x)
523      // = x ^ 0.5
524      // = exp(0.5 * log(x))
525      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
526      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F8 ")));
527      TestGrammarEnumeration(regProblem);
528    }
529   
530    // [TestMethod]
531    [TestCategory("Algorithms.DataAnalysis")]
532    [TestProperty("Time", "short")]
533    public void MctsSymbRegBenchmarkNguyen9() {
534      //  sin(x) + sin(y²)
535      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
536      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F9 ")));
537      TestGrammarEnumeration(regProblem);
538    }
539
540    // [TestMethod]
541    [TestCategory("Algorithms.DataAnalysis")]
542    [TestProperty("Time", "short")]
543    public void MctsSymbRegBenchmarkNguyen10() {
544      // 2sin(x)cos(y)
545      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
546      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F10 ")));
547      TestGrammarEnumeration(regProblem);
548    }
549   
550    [TestMethod]
551    [TestCategory("Algorithms.DataAnalysis")]
552    [TestProperty("Time", "short")]
553    public void MctsSymbRegBenchmarkNguyen11() {
554      // x ^ y  , x > 0, y > 0   
555      // = exp(y * log(x))
556      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
557      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F11 ")));
558      TestGrammarEnumeration(regProblem);
559    }
560    [TestMethod]
561    [TestCategory("Algorithms.DataAnalysis")]
562    [TestProperty("Time", "short")]
563    public void MctsSymbRegBenchmarkNguyen12() {
564      // x^4 - x³ + y²/2 - y
565      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
566      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F12 ")));
567      TestGrammarEnumeration(regProblem);
568    }
569
570    #endregion
571
572    #region keijzer
573    [TestMethod]
574    [TestCategory("Algorithms.DataAnalysis")]
575    [TestProperty("Time", "long")]
576    public void MctsSymbRegBenchmarkKeijzer5() {
577      // (30 * x * z) / ((x - 10)  * y²)
578      // = 30 x z / (xy² - y²)
579      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
580      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 5 f(")));
581      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
582      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
583      TestGrammarEnumeration(regProblem);
584    }
585
586    [TestMethod]
587    [TestCategory("Algorithms.DataAnalysis")]
588    [TestProperty("Time", "short")]
589    public void MctsSymbRegBenchmarkKeijzer6() {
590      // Keijzer 6 f(x) = Sum(1 / i) From 1 to X  , x \in [0..120]
591      // we can only approximate this
592      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
593      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 6 f(")));
594      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
595      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
596      TestGrammarEnumeration(regProblem);
597    }
598
599    [TestMethod]
600    [TestCategory("Algorithms.DataAnalysis")]
601    [TestProperty("Time", "short")]
602    public void MctsSymbRegBenchmarkKeijzer8() {
603      // sqrt(x)
604      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
605      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 8 f(")));
606      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
607      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
608      TestGrammarEnumeration(regProblem);
609    }
610
611    [TestMethod]
612    [TestCategory("Algorithms.DataAnalysis")]
613    [TestProperty("Time", "short")]
614    public void MctsSymbRegBenchmarkKeijzer9() {
615      // arcsinh(x)  i.e. ln(x + sqrt(x² + 1))
616      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
617      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 9 f(")));
618      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
619      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
620      TestGrammarEnumeration(regProblem);
621    }
622
623    [TestMethod]
624    [TestCategory("Algorithms.DataAnalysis")]
625    [TestProperty("Time", "short")]
626    public void MctsSymbRegBenchmarkKeijzer11() {
627      // xy + sin( (x-1) (y-1) )
628      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
629      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 11 f(")));
630      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
631      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
632      TestGrammarEnumeration(regProblem);
633    }
634
635    [TestMethod]
636    [TestCategory("Algorithms.DataAnalysis")]
637    [TestProperty("Time", "short")]
638    public void MctsSymbRegBenchmarkKeijzer12() {
639      // x^4 - x³ + y² / 2 - y,  same as Nguyen 12             
640      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
641      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 12 f(")));
642      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
643      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
644      TestGrammarEnumeration(regProblem);
645    }
646
647    [TestMethod]
648    [TestCategory("Algorithms.DataAnalysis")]
649    [TestProperty("Time", "short")]
650    public void MctsSymbRegBenchmarkKeijzer14() {
651      // 8 / (2 + x² + y²)
652      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
653      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 14 f(")));
654      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
655      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
656      TestGrammarEnumeration(regProblem);
657    }
658
659    [TestMethod]
660    [TestCategory("Algorithms.DataAnalysis")]
661    [TestProperty("Time", "short")]
662    public void MctsSymbRegBenchmarkKeijzer15() {
663      // x³ / 5 + y³ / 2 - y - x
664      var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
665      var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 15 f(")));
666      // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
667      if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
668      TestGrammarEnumeration(regProblem);
669    }
670    #endregion
671
672#endif
673    #endregion
674  }
675}
Note: See TracBrowser for help on using the repository browser.