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

Last change on this file since 15723 was 15723, checked in by lkammere, 20 months ago

#2886: Add simple data analysis tests and further informations about algorithm run.

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