1 | using System;
|
---|
2 | using System.Collections;
|
---|
3 | using System.Collections.Generic;
|
---|
4 | using System.Linq;
|
---|
5 | using HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration;
|
---|
6 | using HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.GrammarEnumeration;
|
---|
7 | using HeuristicLab.Common;
|
---|
8 | using HeuristicLab.Core;
|
---|
9 | using HeuristicLab.Problems.DataAnalysis;
|
---|
10 | using HeuristicLab.Problems.Instances.DataAnalysis;
|
---|
11 | using HeuristicLab.Random;
|
---|
12 | using Microsoft.VisualStudio.TestTools.UnitTesting;
|
---|
13 |
|
---|
14 | namespace 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 | foreach (IGrammarEnumerationAnalyzer grammarEnumerationAnalyzer in alg.Analyzers) {
|
---|
34 | alg.Analyzers.SetItemCheckedState(grammarEnumerationAnalyzer, grammarEnumerationAnalyzer is RSquaredEvaluator);
|
---|
35 | }
|
---|
36 | }
|
---|
37 |
|
---|
38 | [TestCleanup]
|
---|
39 | public void Cleanup() {
|
---|
40 | if (alg.BestTrainingSentence != null) {
|
---|
41 | Console.WriteLine("Training: " + alg.Grammar.ToInfixString(alg.BestTrainingSentence));
|
---|
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 (Training)"), "No training solution returned!");
|
---|
52 |
|
---|
53 | // Check resultss
|
---|
54 | Assert.AreEqual(1.0, ((IRegressionSolution)alg.Results["Best solution (Training)"].Value).TestRSquared, eps, "Test quality too low!");
|
---|
55 | }
|
---|
56 |
|
---|
57 |
|
---|
58 | [TestMethod]
|
---|
59 | [TestProperty("Goal", "structure search")]
|
---|
60 | public void NoConstants_Nguyen1() {
|
---|
61 | // x³ + x² + x
|
---|
62 | alg.MaxComplexity = 6;
|
---|
63 | alg.Problem.ProblemData = new NguyenFunctionOne(Seed).GenerateRegressionData();
|
---|
64 |
|
---|
65 | alg.Start();
|
---|
66 |
|
---|
67 | TerminalSymbol constSymbol = alg.Grammar.Const;
|
---|
68 | TerminalSymbol varSymbol = alg.Grammar.VarTerminals.First();
|
---|
69 | TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
|
---|
70 | TerminalSymbol addSymbol = alg.Grammar.Addition;
|
---|
71 |
|
---|
72 | SymbolString targetSolution = new SymbolString(new[] {
|
---|
73 | constSymbol, varSymbol, varSymbol, varSymbol, mulSymbol, mulSymbol, mulSymbol,
|
---|
74 | constSymbol, varSymbol, varSymbol, mulSymbol, mulSymbol, addSymbol,
|
---|
75 | constSymbol, varSymbol, mulSymbol, addSymbol,
|
---|
76 | constSymbol, addSymbol
|
---|
77 | });
|
---|
78 |
|
---|
79 | int targetSolutionHash = alg.Grammar.Hasher.CalcHashCode(targetSolution);
|
---|
80 | int actualSolutionHash = alg.Grammar.Hasher.CalcHashCode(alg.BestTrainingSentence);
|
---|
81 |
|
---|
82 | Assert.IsTrue(alg.DistinctSentencesComplexity.ContainsKey(targetSolutionHash), "Actual solution was not generated!");
|
---|
83 |
|
---|
84 | Assert.AreEqual(targetSolutionHash, actualSolutionHash, "Actual solution was not recognized as best one.");
|
---|
85 |
|
---|
86 | // Evaluate
|
---|
87 | EvaluateGrammarEnumeration();
|
---|
88 | }
|
---|
89 |
|
---|
90 | // Too "large" target model for now...
|
---|
91 | //[TestMethod]
|
---|
92 | [TestProperty("Goal", "structure search")]
|
---|
93 | public void NoConstants_Nguyen2() {
|
---|
94 | // x^4 + x³ + x² + x
|
---|
95 | alg.MaxComplexity = 11;
|
---|
96 | alg.Problem.ProblemData = new NguyenFunctionTwo(Seed).GenerateRegressionData();
|
---|
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 NoConstants_Nguyen3() {
|
---|
106 | // x^5 + x^4 + x^3 + x^2 + x
|
---|
107 | alg.MaxComplexity = 32;
|
---|
108 | alg.Problem.ProblemData = new NguyenFunctionThree(Seed).GenerateRegressionData();
|
---|
109 |
|
---|
110 | alg.Start();
|
---|
111 |
|
---|
112 | EvaluateGrammarEnumeration();
|
---|
113 | }
|
---|
114 |
|
---|
115 | [TestMethod]
|
---|
116 | [TestProperty("Goal", "structure search")]
|
---|
117 | public void NoConstants_Nguyen6() {
|
---|
118 | // sin(x) + sin(x + x²)
|
---|
119 | alg.MaxComplexity = 4;
|
---|
120 | alg.Problem.ProblemData = new NguyenFunctionSix(Seed).GenerateRegressionData();
|
---|
121 |
|
---|
122 | alg.Start();
|
---|
123 |
|
---|
124 | TerminalSymbol constSymbol = alg.Grammar.Const;
|
---|
125 | TerminalSymbol varSymbol = alg.Grammar.VarTerminals.First();
|
---|
126 | TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
|
---|
127 | TerminalSymbol addSymbol = alg.Grammar.Addition;
|
---|
128 | TerminalSymbol sinSymbol = alg.Grammar.Sin;
|
---|
129 |
|
---|
130 | // c * sin(c x + c) + c * sin(c * x * x + c * x) + c
|
---|
131 | SymbolString targetSolution = new SymbolString(new[] {
|
---|
132 | varSymbol, constSymbol, mulSymbol, constSymbol, addSymbol, sinSymbol, constSymbol, mulSymbol,
|
---|
133 | varSymbol, varSymbol, mulSymbol, constSymbol, mulSymbol, varSymbol, constSymbol, mulSymbol, addSymbol, constSymbol, addSymbol, sinSymbol, constSymbol, mulSymbol, addSymbol,
|
---|
134 | constSymbol, addSymbol
|
---|
135 | });
|
---|
136 |
|
---|
137 | int targetSolutionHash = alg.Grammar.Hasher.CalcHashCode(targetSolution);
|
---|
138 | int actualSolutionHash = alg.Grammar.Hasher.CalcHashCode(alg.BestTrainingSentence);
|
---|
139 |
|
---|
140 | Assert.IsTrue(alg.DistinctSentencesComplexity.ContainsKey(targetSolutionHash), "Actual solution was not generated!");
|
---|
141 | Assert.AreEqual(targetSolutionHash, actualSolutionHash, "Actual solution was not recognized as best one.");
|
---|
142 |
|
---|
143 | EvaluateGrammarEnumeration();
|
---|
144 | }
|
---|
145 |
|
---|
146 | [TestMethod]
|
---|
147 | [TestProperty("Goal", "structure search")]
|
---|
148 | public void NoConstants_Nguyen9() {
|
---|
149 | // sin(x) + sin(y²)
|
---|
150 | alg.MaxComplexity = 3;
|
---|
151 | alg.Problem.ProblemData = new NguyenFunctionNine(Seed).GenerateRegressionData();
|
---|
152 |
|
---|
153 | alg.Start();
|
---|
154 |
|
---|
155 | TerminalSymbol xSymbol = alg.Grammar.VarTerminals.First(v => v.StringRepresentation == "X");
|
---|
156 | TerminalSymbol ySymbol = alg.Grammar.VarTerminals.First(v => v.StringRepresentation == "Y");
|
---|
157 | TerminalSymbol constSymbol = alg.Grammar.Const;
|
---|
158 | TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
|
---|
159 | TerminalSymbol addSymbol = alg.Grammar.Addition;
|
---|
160 | TerminalSymbol sinSymbol = alg.Grammar.Sin;
|
---|
161 |
|
---|
162 | // c*sin(c*x + c) + c*sin(c*y*y + c) + c
|
---|
163 | SymbolString targetSolution = new SymbolString(new[] {
|
---|
164 | xSymbol, constSymbol, mulSymbol, constSymbol, addSymbol, sinSymbol, constSymbol, mulSymbol,
|
---|
165 | ySymbol, ySymbol, mulSymbol, constSymbol, mulSymbol, constSymbol, addSymbol, sinSymbol, constSymbol, mulSymbol, addSymbol,
|
---|
166 | constSymbol, addSymbol
|
---|
167 | });
|
---|
168 |
|
---|
169 | int targetSolutionHash = alg.Grammar.Hasher.CalcHashCode(targetSolution);
|
---|
170 | int actualSolutionHash = alg.Grammar.Hasher.CalcHashCode(alg.BestTrainingSentence);
|
---|
171 |
|
---|
172 | Assert.IsTrue(alg.DistinctSentencesComplexity.ContainsKey(targetSolutionHash), "Actual solution was not generated!");
|
---|
173 | Assert.AreEqual(targetSolutionHash, actualSolutionHash, "Actual solution was not recognized as best one.");
|
---|
174 |
|
---|
175 | EvaluateGrammarEnumeration();
|
---|
176 | }
|
---|
177 |
|
---|
178 | // Too much variables for now...
|
---|
179 | //[TestMethod]
|
---|
180 | [TestProperty("Goal", "structure search")]
|
---|
181 | public void MctsSymbReg_NoConstants_Poly10() {
|
---|
182 | alg.MaxComplexity = 10;
|
---|
183 | alg.Problem.ProblemData = new PolyTen(Seed).GenerateRegressionData();
|
---|
184 |
|
---|
185 | alg.Start();
|
---|
186 | EvaluateGrammarEnumeration();
|
---|
187 | }
|
---|
188 |
|
---|
189 | [TestMethod]
|
---|
190 | [TestProperty("Goal", "structure search")]
|
---|
191 | public void NoConstants_Inverse() {
|
---|
192 | // x / (log(x)*x + x)
|
---|
193 | alg.MaxComplexity = 4;
|
---|
194 |
|
---|
195 | var x = Enumerable.Range(0, 100).Select(_ => rand.NextDouble() + 1.1).ToList();
|
---|
196 | var y = x.Select(xi => xi / (Math.Log(xi) * xi + xi)).ToList();
|
---|
197 | alg.Problem.ProblemData = new RegressionProblemData(new Dataset(new List<string>() { "x", "y" }, new List<IList>() { x, y }), "x".ToEnumerable(), "y");
|
---|
198 |
|
---|
199 | alg.Start();
|
---|
200 | EvaluateGrammarEnumeration();
|
---|
201 | }
|
---|
202 |
|
---|
203 | [TestMethod]
|
---|
204 | [TestProperty("Goal", "structure search + const op")]
|
---|
205 | public void Constants_Nguyen7() {
|
---|
206 | // log(x+1) + log(x*x + 1)
|
---|
207 | alg.MaxComplexity = 3;
|
---|
208 | alg.Problem.ProblemData = new NguyenFunctionSeven().GenerateRegressionData();
|
---|
209 |
|
---|
210 | alg.Start();
|
---|
211 |
|
---|
212 | TerminalSymbol constSymbol = alg.Grammar.Const;
|
---|
213 | TerminalSymbol varSymbol = alg.Grammar.VarTerminals.First();
|
---|
214 | TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
|
---|
215 | TerminalSymbol addSymbol = alg.Grammar.Addition;
|
---|
216 | TerminalSymbol logSymbol = alg.Grammar.Log;
|
---|
217 |
|
---|
218 | SymbolString targetSolution = new SymbolString(new[] {
|
---|
219 | varSymbol, constSymbol, mulSymbol, constSymbol, addSymbol, logSymbol, constSymbol, mulSymbol,
|
---|
220 | varSymbol, varSymbol, mulSymbol, constSymbol, mulSymbol, constSymbol, addSymbol, logSymbol, constSymbol, mulSymbol, addSymbol,
|
---|
221 | constSymbol, addSymbol
|
---|
222 | });
|
---|
223 |
|
---|
224 | int targetSolutionHash = alg.Grammar.Hasher.CalcHashCode(targetSolution);
|
---|
225 | int actualSolutionHash = alg.Grammar.Hasher.CalcHashCode(alg.BestTrainingSentence);
|
---|
226 |
|
---|
227 | Assert.IsTrue(alg.DistinctSentencesComplexity.ContainsKey(targetSolutionHash), "Actual solution was not generated!");
|
---|
228 | Assert.AreEqual(targetSolutionHash, actualSolutionHash, "Actual solution was not recognized as best one.");
|
---|
229 |
|
---|
230 | // Evaluate
|
---|
231 | EvaluateGrammarEnumeration();
|
---|
232 | }
|
---|
233 |
|
---|
234 | [TestMethod]
|
---|
235 | [TestProperty("Goal", "structure search + const op")]
|
---|
236 | public void Constants_Nguyen12() {
|
---|
237 | // x*x*x*x - x*x*x + y*y/2 -y
|
---|
238 | alg.MaxComplexity = 10;
|
---|
239 | alg.Problem.ProblemData = new NguyenFunctionTwelve().GenerateRegressionData();
|
---|
240 |
|
---|
241 | alg.Start();
|
---|
242 |
|
---|
243 | // Evaluate
|
---|
244 | EvaluateGrammarEnumeration();
|
---|
245 | }
|
---|
246 |
|
---|
247 | [TestMethod]
|
---|
248 | [TestProperty("Goal", "structure search + const op")]
|
---|
249 | public void Constants_Keijzer3() {
|
---|
250 | // 0.3*x*sin(2*pi*x)
|
---|
251 | alg.MaxComplexity = 2;
|
---|
252 | alg.Problem.ProblemData = new KeijzerFunctionThree().GenerateRegressionData();
|
---|
253 |
|
---|
254 | alg.Start();
|
---|
255 |
|
---|
256 | TerminalSymbol constSymbol = alg.Grammar.Const;
|
---|
257 | TerminalSymbol varSymbol = alg.Grammar.VarTerminals.First();
|
---|
258 | TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
|
---|
259 | TerminalSymbol addSymbol = alg.Grammar.Addition;
|
---|
260 |
|
---|
261 | SymbolString targetSolution = new SymbolString(new[] {
|
---|
262 | constSymbol, varSymbol, mulSymbol, constSymbol, addSymbol, alg.Grammar.Sin,
|
---|
263 | varSymbol, mulSymbol,
|
---|
264 | constSymbol, mulSymbol,
|
---|
265 | constSymbol, addSymbol
|
---|
266 | });
|
---|
267 |
|
---|
268 | int targetSolutionHash = alg.Grammar.Hasher.CalcHashCode(targetSolution);
|
---|
269 | int actualSolutionHash = alg.Grammar.Hasher.CalcHashCode(alg.BestTrainingSentence);
|
---|
270 |
|
---|
271 | Assert.IsTrue(alg.DistinctSentencesComplexity.ContainsKey(targetSolutionHash), "Actual solution was not generated!");
|
---|
272 | Assert.AreEqual(targetSolutionHash, actualSolutionHash, "Actual solution was not recognized as best one.");
|
---|
273 |
|
---|
274 | // Evaluate
|
---|
275 | EvaluateGrammarEnumeration();
|
---|
276 | }
|
---|
277 |
|
---|
278 | [TestMethod]
|
---|
279 | [TestProperty("Goal", "structure search + const op")]
|
---|
280 | public void Constants_Keijzer5() {
|
---|
281 | // (30*x*z) / ((x - 10)*y*y)
|
---|
282 | alg.MaxComplexity = 5;
|
---|
283 | alg.Problem.ProblemData = new KeijzerFunctionFive().GenerateRegressionData();
|
---|
284 |
|
---|
285 | alg.Start();
|
---|
286 |
|
---|
287 | TerminalSymbol constSymbol = alg.Grammar.Const;
|
---|
288 | TerminalSymbol xSymbol = alg.Grammar.VarTerminals.First(s => s.StringRepresentation == "X");
|
---|
289 | TerminalSymbol ySymbol = alg.Grammar.VarTerminals.First(s => s.StringRepresentation == "Y");
|
---|
290 | TerminalSymbol zSymbol = alg.Grammar.VarTerminals.First(s => s.StringRepresentation == "Z");
|
---|
291 | TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
|
---|
292 | TerminalSymbol addSymbol = alg.Grammar.Addition;
|
---|
293 | TerminalSymbol invSymbol = alg.Grammar.Inv;
|
---|
294 |
|
---|
295 | // 30 * x * z * 1/(x*y*y - 10*y*y)
|
---|
296 | // --> x z * c * x y * y * c * y y * c * + c + inv c +
|
---|
297 | SymbolString targetSolution = new SymbolString(new[] {
|
---|
298 | xSymbol, zSymbol, mulSymbol, constSymbol, mulSymbol,
|
---|
299 | xSymbol, ySymbol, mulSymbol, ySymbol, mulSymbol, constSymbol, mulSymbol,
|
---|
300 | ySymbol, ySymbol, mulSymbol, constSymbol, mulSymbol, addSymbol, constSymbol, addSymbol, invSymbol,
|
---|
301 | constSymbol, addSymbol
|
---|
302 | });
|
---|
303 |
|
---|
304 | int targetSolutionHash = alg.Grammar.Hasher.CalcHashCode(targetSolution);
|
---|
305 | int actualSolutionHash = alg.Grammar.Hasher.CalcHashCode(alg.BestTrainingSentence);
|
---|
306 |
|
---|
307 | Assert.IsTrue(alg.DistinctSentencesComplexity.ContainsKey(targetSolutionHash), "Actual solution was not generated!");
|
---|
308 |
|
---|
309 | Assert.AreEqual(targetSolutionHash, actualSolutionHash, "Actual solution was not recognized as best one.");
|
---|
310 |
|
---|
311 | // Evaluate
|
---|
312 | EvaluateGrammarEnumeration();
|
---|
313 | }
|
---|
314 |
|
---|
315 |
|
---|
316 | [TestMethod]
|
---|
317 | [TestProperty("Goal", "structure search + const op")]
|
---|
318 | public void Constants_Keijzer12() {
|
---|
319 | // x*x*x*x - x*x*x + y*y/2 - y
|
---|
320 | alg.MaxComplexity = 10;
|
---|
321 | alg.Problem.ProblemData = new KeijzerFunctionTwelve().GenerateRegressionData();
|
---|
322 |
|
---|
323 | alg.Start();
|
---|
324 |
|
---|
325 | TerminalSymbol constSymbol = alg.Grammar.Const;
|
---|
326 | TerminalSymbol xSymbol = alg.Grammar.VarTerminals.First();
|
---|
327 | TerminalSymbol ySymbol = alg.Grammar.VarTerminals.Last();
|
---|
328 | TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
|
---|
329 | TerminalSymbol addSymbol = alg.Grammar.Addition;
|
---|
330 |
|
---|
331 | SymbolString targetSolution = new SymbolString(new[] {
|
---|
332 | xSymbol, xSymbol, mulSymbol, xSymbol, mulSymbol, xSymbol, mulSymbol, constSymbol, mulSymbol,
|
---|
333 | xSymbol, xSymbol, mulSymbol, xSymbol, mulSymbol, constSymbol, mulSymbol, addSymbol,
|
---|
334 | ySymbol, ySymbol, mulSymbol, constSymbol, mulSymbol, addSymbol,
|
---|
335 | ySymbol, constSymbol, mulSymbol, addSymbol,
|
---|
336 | constSymbol, addSymbol
|
---|
337 | });
|
---|
338 |
|
---|
339 | var x = alg.Grammar.ToInfixString(targetSolution);
|
---|
340 |
|
---|
341 | int targetSolutionHash = alg.Grammar.Hasher.CalcHashCode(targetSolution);
|
---|
342 | int actualSolutionHash = alg.Grammar.Hasher.CalcHashCode(alg.BestTrainingSentence);
|
---|
343 |
|
---|
344 | Assert.IsTrue(alg.DistinctSentencesComplexity.ContainsKey(targetSolutionHash), "Actual solution was not generated!");
|
---|
345 | Assert.AreEqual(targetSolutionHash, actualSolutionHash, "Actual solution was not recognized as best one.");
|
---|
346 |
|
---|
347 | // Evaluate
|
---|
348 | EvaluateGrammarEnumeration();
|
---|
349 | }
|
---|
350 |
|
---|
351 | [TestMethod]
|
---|
352 | [TestProperty("Goal", "structure search + const op")]
|
---|
353 | public void Constants_Keijzer14() {
|
---|
354 | // 8 / (2 + x*x + y*y
|
---|
355 | alg.MaxComplexity = 4;
|
---|
356 | alg.Problem.ProblemData = new KeijzerFunctionFourteen().GenerateRegressionData();
|
---|
357 |
|
---|
358 | alg.Start();
|
---|
359 |
|
---|
360 | TerminalSymbol constSymbol = alg.Grammar.Const;
|
---|
361 | TerminalSymbol xSymbol = alg.Grammar.VarTerminals.First();
|
---|
362 | TerminalSymbol ySymbol = alg.Grammar.VarTerminals.Last();
|
---|
363 | TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
|
---|
364 | TerminalSymbol addSymbol = alg.Grammar.Addition;
|
---|
365 | TerminalSymbol divSymbol = alg.Grammar.Inv;
|
---|
366 |
|
---|
367 |
|
---|
368 | // x x mul c mul y y mul c mul add const add inv const mul const add
|
---|
369 | SymbolString targetSolution = new SymbolString(new[] {
|
---|
370 | xSymbol, xSymbol, mulSymbol, constSymbol, mulSymbol,
|
---|
371 | ySymbol, ySymbol, mulSymbol, constSymbol, mulSymbol, addSymbol,
|
---|
372 | constSymbol, addSymbol, divSymbol,
|
---|
373 | constSymbol, mulSymbol,
|
---|
374 | constSymbol, addSymbol
|
---|
375 | });
|
---|
376 |
|
---|
377 | int targetSolutionHash = alg.Grammar.Hasher.CalcHashCode(targetSolution);
|
---|
378 | int actualSolutionHash = alg.Grammar.Hasher.CalcHashCode(alg.BestTrainingSentence);
|
---|
379 |
|
---|
380 | Assert.IsTrue(alg.DistinctSentencesComplexity.ContainsKey(targetSolutionHash), "Actual solution was not generated!");
|
---|
381 | Assert.AreEqual(targetSolutionHash, actualSolutionHash, "Actual solution was not recognized as best one.");
|
---|
382 |
|
---|
383 | // Evaluate
|
---|
384 | EvaluateGrammarEnumeration();
|
---|
385 | }
|
---|
386 |
|
---|
387 |
|
---|
388 | [TestMethod]
|
---|
389 | [TestProperty("Goal", "structure search + const op")]
|
---|
390 | public void Constants_Keijzer15() {
|
---|
391 | // x*x*x / 5 + y*y*y / 2 - y - x
|
---|
392 | alg.MaxComplexity = 8;
|
---|
393 | alg.Problem.ProblemData = new KeijzerFunctionFifteen().GenerateRegressionData();
|
---|
394 |
|
---|
395 | alg.Start();
|
---|
396 |
|
---|
397 | TerminalSymbol constSymbol = alg.Grammar.Const;
|
---|
398 | TerminalSymbol xSymbol = alg.Grammar.VarTerminals.First();
|
---|
399 | TerminalSymbol ySymbol = alg.Grammar.VarTerminals.Last();
|
---|
400 | TerminalSymbol mulSymbol = alg.Grammar.Multiplication;
|
---|
401 | TerminalSymbol addSymbol = alg.Grammar.Addition;
|
---|
402 |
|
---|
403 | // x x * x * const * y y * y * const * + y const * + x const * const +
|
---|
404 | SymbolString targetSolution = new SymbolString(new[] {
|
---|
405 | xSymbol, xSymbol, mulSymbol, xSymbol, mulSymbol, constSymbol, mulSymbol,
|
---|
406 | ySymbol, ySymbol, mulSymbol, ySymbol, mulSymbol, constSymbol, mulSymbol, addSymbol,
|
---|
407 | ySymbol, constSymbol, mulSymbol, addSymbol,
|
---|
408 | xSymbol, constSymbol, mulSymbol, addSymbol,
|
---|
409 | constSymbol, addSymbol
|
---|
410 | });
|
---|
411 |
|
---|
412 | int targetSolutionHash = alg.Grammar.Hasher.CalcHashCode(targetSolution);
|
---|
413 | int actualSolutionHash = alg.Grammar.Hasher.CalcHashCode(alg.BestTrainingSentence);
|
---|
414 |
|
---|
415 | Assert.IsTrue(alg.DistinctSentencesComplexity.ContainsKey(targetSolutionHash), "Actual solution was not generated!");
|
---|
416 | Assert.AreEqual(targetSolutionHash, actualSolutionHash, "Actual solution was not recognized as best one.");
|
---|
417 |
|
---|
418 | // Evaluate
|
---|
419 | EvaluateGrammarEnumeration();
|
---|
420 | }
|
---|
421 |
|
---|
422 |
|
---|
423 |
|
---|
424 |
|
---|
425 | #if false
|
---|
426 |
|
---|
427 | [TestMethod]
|
---|
428 | [TestProperty("Goal", "structure search")]
|
---|
429 | public void MctsSymbReg_NoConstants_15() {
|
---|
430 | alg.MaxTreeSize = 5;
|
---|
431 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
|
---|
432 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("15")));
|
---|
433 | alg.Problem.ProblemData = regProblem;
|
---|
434 |
|
---|
435 | alg.Start();
|
---|
436 | EvaluateGrammarEnumeration();
|
---|
437 | }
|
---|
438 |
|
---|
439 |
|
---|
440 | [TestMethod]
|
---|
441 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
442 | [TestProperty("Time", "short")]
|
---|
443 | public void MctsSymbReg_NoConstants_Nguyen7() {
|
---|
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 |
|
---|
450 | [TestMethod]
|
---|
451 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
452 | [TestProperty("Time", "short")]
|
---|
453 | public void MctsSymbReg_NoConstants_Poly10_Part1() {
|
---|
454 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
|
---|
455 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
|
---|
456 |
|
---|
457 | // Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
|
---|
458 | // Y' = X1*X2 + X3*X4 + X5*X6
|
---|
459 | // simplify problem by changing target
|
---|
460 | var ds = ((Dataset)regProblem.Dataset).ToModifiable();
|
---|
461 | var ys = ds.GetDoubleValues("Y").ToArray();
|
---|
462 | var x1 = ds.GetDoubleValues("X1").ToArray();
|
---|
463 | var x2 = ds.GetDoubleValues("X2").ToArray();
|
---|
464 | var x3 = ds.GetDoubleValues("X3").ToArray();
|
---|
465 | var x4 = ds.GetDoubleValues("X4").ToArray();
|
---|
466 | var x5 = ds.GetDoubleValues("X5").ToArray();
|
---|
467 | var x6 = ds.GetDoubleValues("X6").ToArray();
|
---|
468 | var x7 = ds.GetDoubleValues("X7").ToArray();
|
---|
469 | var x8 = ds.GetDoubleValues("X8").ToArray();
|
---|
470 | var x9 = ds.GetDoubleValues("X9").ToArray();
|
---|
471 | var x10 = ds.GetDoubleValues("X10").ToArray();
|
---|
472 | for (int i = 0; i < ys.Length; i++) {
|
---|
473 | ys[i] -= x1[i] * x7[i] * x9[i];
|
---|
474 | ys[i] -= x3[i] * x6[i] * x10[i];
|
---|
475 | }
|
---|
476 | ds.ReplaceVariable("Y", ys.ToList());
|
---|
477 |
|
---|
478 | var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
|
---|
479 |
|
---|
480 | TestGrammarEnumeration(modifiedProblemData);
|
---|
481 | }
|
---|
482 |
|
---|
483 | [TestMethod]
|
---|
484 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
485 | [TestProperty("Time", "short")]
|
---|
486 | public void MctsSymbReg_NoConstants_Poly10_Part2() {
|
---|
487 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
|
---|
488 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
|
---|
489 |
|
---|
490 | // Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
|
---|
491 | // Y' = X1*X7*X9 + X3*X6*X10
|
---|
492 | // simplify problem by changing target
|
---|
493 | var ds = ((Dataset)regProblem.Dataset).ToModifiable();
|
---|
494 | var ys = ds.GetDoubleValues("Y").ToArray();
|
---|
495 | var x1 = ds.GetDoubleValues("X1").ToArray();
|
---|
496 | var x2 = ds.GetDoubleValues("X2").ToArray();
|
---|
497 | var x3 = ds.GetDoubleValues("X3").ToArray();
|
---|
498 | var x4 = ds.GetDoubleValues("X4").ToArray();
|
---|
499 | var x5 = ds.GetDoubleValues("X5").ToArray();
|
---|
500 | var x6 = ds.GetDoubleValues("X6").ToArray();
|
---|
501 | var x7 = ds.GetDoubleValues("X7").ToArray();
|
---|
502 | var x8 = ds.GetDoubleValues("X8").ToArray();
|
---|
503 | var x9 = ds.GetDoubleValues("X9").ToArray();
|
---|
504 | var x10 = ds.GetDoubleValues("X10").ToArray();
|
---|
505 | for (int i = 0; i < ys.Length; i++) {
|
---|
506 | ys[i] -= x1[i] * x2[i];
|
---|
507 | ys[i] -= x3[i] * x4[i];
|
---|
508 | ys[i] -= x5[i] * x6[i];
|
---|
509 | }
|
---|
510 | ds.ReplaceVariable("Y", ys.ToList());
|
---|
511 |
|
---|
512 | var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
|
---|
513 |
|
---|
514 | TestGrammarEnumeration(modifiedProblemData);
|
---|
515 | }
|
---|
516 |
|
---|
517 | [TestMethod]
|
---|
518 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
519 | [TestProperty("Time", "short")]
|
---|
520 | public void MctsSymbReg_NoConstants_Poly10_Part3() {
|
---|
521 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
|
---|
522 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
|
---|
523 |
|
---|
524 | // Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
|
---|
525 | // Y' = X1*X2 + X1*X7*X9
|
---|
526 | // simplify problem by changing target
|
---|
527 | var ds = ((Dataset)regProblem.Dataset).ToModifiable();
|
---|
528 | var ys = ds.GetDoubleValues("Y").ToArray();
|
---|
529 | var x1 = ds.GetDoubleValues("X1").ToArray();
|
---|
530 | var x2 = ds.GetDoubleValues("X2").ToArray();
|
---|
531 | var x3 = ds.GetDoubleValues("X3").ToArray();
|
---|
532 | var x4 = ds.GetDoubleValues("X4").ToArray();
|
---|
533 | var x5 = ds.GetDoubleValues("X5").ToArray();
|
---|
534 | var x6 = ds.GetDoubleValues("X6").ToArray();
|
---|
535 | var x7 = ds.GetDoubleValues("X7").ToArray();
|
---|
536 | var x8 = ds.GetDoubleValues("X8").ToArray();
|
---|
537 | var x9 = ds.GetDoubleValues("X9").ToArray();
|
---|
538 | var x10 = ds.GetDoubleValues("X10").ToArray();
|
---|
539 | for (int i = 0; i < ys.Length; i++) {
|
---|
540 | ys[i] -= x3[i] * x4[i];
|
---|
541 | ys[i] -= x5[i] * x6[i];
|
---|
542 | ys[i] -= x3[i] * x6[i] * x10[i];
|
---|
543 | }
|
---|
544 | ds.ReplaceVariable("Y", ys.ToList());
|
---|
545 |
|
---|
546 | var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
|
---|
547 |
|
---|
548 | TestGrammarEnumeration(modifiedProblemData);
|
---|
549 | }
|
---|
550 |
|
---|
551 | [TestMethod]
|
---|
552 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
553 | [TestProperty("Time", "short")]
|
---|
554 | public void MctsSymbReg_NoConstants_Poly10_Part4() {
|
---|
555 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
|
---|
556 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
|
---|
557 |
|
---|
558 | // Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
|
---|
559 | // Y' = X3*X4 + X5*X6 + X3*X6*X10
|
---|
560 | // simplify problem by changing target
|
---|
561 | var ds = ((Dataset)regProblem.Dataset).ToModifiable();
|
---|
562 | var ys = ds.GetDoubleValues("Y").ToArray();
|
---|
563 | var x1 = ds.GetDoubleValues("X1").ToArray();
|
---|
564 | var x2 = ds.GetDoubleValues("X2").ToArray();
|
---|
565 | var x3 = ds.GetDoubleValues("X3").ToArray();
|
---|
566 | var x4 = ds.GetDoubleValues("X4").ToArray();
|
---|
567 | var x5 = ds.GetDoubleValues("X5").ToArray();
|
---|
568 | var x6 = ds.GetDoubleValues("X6").ToArray();
|
---|
569 | var x7 = ds.GetDoubleValues("X7").ToArray();
|
---|
570 | var x8 = ds.GetDoubleValues("X8").ToArray();
|
---|
571 | var x9 = ds.GetDoubleValues("X9").ToArray();
|
---|
572 | var x10 = ds.GetDoubleValues("X10").ToArray();
|
---|
573 | for (int i = 0; i < ys.Length; i++) {
|
---|
574 | ys[i] -= x1[i] * x2[i];
|
---|
575 | ys[i] -= x1[i] * x7[i] * x9[i];
|
---|
576 | }
|
---|
577 | ds.ReplaceVariable("Y", ys.ToList());
|
---|
578 | var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
|
---|
579 |
|
---|
580 |
|
---|
581 | TestGrammarEnumeration(modifiedProblemData);
|
---|
582 | }
|
---|
583 |
|
---|
584 | [TestMethod]
|
---|
585 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
586 | [TestProperty("Time", "short")]
|
---|
587 | public void MctsSymbReg_NoConstants_Poly10_Part5() {
|
---|
588 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
|
---|
589 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
|
---|
590 |
|
---|
591 | // Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
|
---|
592 | // Y' = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9
|
---|
593 | // simplify problem by changing target
|
---|
594 | var ds = ((Dataset)regProblem.Dataset).ToModifiable();
|
---|
595 | var ys = ds.GetDoubleValues("Y").ToArray();
|
---|
596 | var x1 = ds.GetDoubleValues("X1").ToArray();
|
---|
597 | var x2 = ds.GetDoubleValues("X2").ToArray();
|
---|
598 | var x3 = ds.GetDoubleValues("X3").ToArray();
|
---|
599 | var x4 = ds.GetDoubleValues("X4").ToArray();
|
---|
600 | var x5 = ds.GetDoubleValues("X5").ToArray();
|
---|
601 | var x6 = ds.GetDoubleValues("X6").ToArray();
|
---|
602 | var x7 = ds.GetDoubleValues("X7").ToArray();
|
---|
603 | var x8 = ds.GetDoubleValues("X8").ToArray();
|
---|
604 | var x9 = ds.GetDoubleValues("X9").ToArray();
|
---|
605 | var x10 = ds.GetDoubleValues("X10").ToArray();
|
---|
606 | for (int i = 0; i < ys.Length; i++) {
|
---|
607 | ys[i] -= x3[i] * x6[i] * x10[i];
|
---|
608 | }
|
---|
609 | ds.ReplaceVariable("Y", ys.ToList());
|
---|
610 | var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
|
---|
611 |
|
---|
612 |
|
---|
613 | TestGrammarEnumeration(modifiedProblemData);
|
---|
614 | }
|
---|
615 |
|
---|
616 | [TestMethod]
|
---|
617 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
618 | [TestProperty("Time", "short")]
|
---|
619 | public void MctsSymbReg_NoConstants_Poly10_Part6() {
|
---|
620 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
|
---|
621 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
|
---|
622 |
|
---|
623 | // Y = X1*X2 + X3*X4 + X5*X6 + X1*X7*X9 + X3*X6*X10
|
---|
624 | // Y' = X1*X2 + X3*X4 + X5*X6 + X3*X6*X10
|
---|
625 | // simplify problem by changing target
|
---|
626 | var ds = ((Dataset)regProblem.Dataset).ToModifiable();
|
---|
627 | var ys = ds.GetDoubleValues("Y").ToArray();
|
---|
628 | var x1 = ds.GetDoubleValues("X1").ToArray();
|
---|
629 | var x2 = ds.GetDoubleValues("X2").ToArray();
|
---|
630 | var x3 = ds.GetDoubleValues("X3").ToArray();
|
---|
631 | var x4 = ds.GetDoubleValues("X4").ToArray();
|
---|
632 | var x5 = ds.GetDoubleValues("X5").ToArray();
|
---|
633 | var x6 = ds.GetDoubleValues("X6").ToArray();
|
---|
634 | var x7 = ds.GetDoubleValues("X7").ToArray();
|
---|
635 | var x8 = ds.GetDoubleValues("X8").ToArray();
|
---|
636 | var x9 = ds.GetDoubleValues("X9").ToArray();
|
---|
637 | var x10 = ds.GetDoubleValues("X10").ToArray();
|
---|
638 | for (int i = 0; i < ys.Length; i++) {
|
---|
639 | ys[i] -= x1[i] * x7[i] * x9[i];
|
---|
640 | }
|
---|
641 | ds.ReplaceVariable("Y", ys.ToList());
|
---|
642 | var modifiedProblemData = new RegressionProblemData(ds, regProblem.AllowedInputVariables, regProblem.TargetVariable);
|
---|
643 |
|
---|
644 | TestGrammarEnumeration(modifiedProblemData);
|
---|
645 | }
|
---|
646 |
|
---|
647 |
|
---|
648 | [TestMethod]
|
---|
649 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
650 | [TestProperty("Time", "long")]
|
---|
651 | public void MctsSymbReg_NoConstants_Poly10_250rows() {
|
---|
652 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.VariousInstanceProvider(Seed);
|
---|
653 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Poly-10")));
|
---|
654 | regProblem.TrainingPartition.Start = 0;
|
---|
655 | regProblem.TrainingPartition.End = regProblem.Dataset.Rows;
|
---|
656 | regProblem.TestPartition.Start = 0;
|
---|
657 | regProblem.TestPartition.End = 2;
|
---|
658 | TestGrammarEnumeration(regProblem);
|
---|
659 | }
|
---|
660 |
|
---|
661 | [TestMethod]
|
---|
662 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
663 | [TestProperty("Time", "long")]
|
---|
664 | public void MctsSymbReg_NoConstants_Poly10_10000rows() {
|
---|
665 | // as poly-10 but more rows
|
---|
666 | var x1 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
|
---|
667 | var x2 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
|
---|
668 | var x3 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
|
---|
669 | var x4 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
|
---|
670 | var x5 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
|
---|
671 | var x6 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
|
---|
672 | var x7 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
|
---|
673 | var x8 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
|
---|
674 | var x9 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
|
---|
675 | var x10 = Enumerable.Range(0, 10000).Select(_ => rand.NextDouble()).ToList();
|
---|
676 | var ys = new List<double>();
|
---|
677 | for (int i = 0; i < x1.Count; i++) {
|
---|
678 | 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]);
|
---|
679 | }
|
---|
680 |
|
---|
681 | var ds = new Dataset(new string[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "y" },
|
---|
682 | new[] { x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, ys });
|
---|
683 |
|
---|
684 |
|
---|
685 | var problemData = new RegressionProblemData(ds, new string[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j" }, "y");
|
---|
686 |
|
---|
687 | problemData.TrainingPartition.Start = 0;
|
---|
688 | problemData.TrainingPartition.End = problemData.Dataset.Rows;
|
---|
689 | problemData.TestPartition.Start = 0;
|
---|
690 | problemData.TestPartition.End = 2; // must not be empty
|
---|
691 |
|
---|
692 |
|
---|
693 | TestGrammarEnumeration(problemData);
|
---|
694 | }
|
---|
695 |
|
---|
696 | [TestMethod]
|
---|
697 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
698 | [TestProperty("Time", "short")]
|
---|
699 | public void MctsSymbReg_NoConstants_TwoVars() {
|
---|
700 |
|
---|
701 | // y = x1 + x2 + x1*x2 + x1*x2*x2 + x1*x1*x2
|
---|
702 | var x1 = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
|
---|
703 | var x2 = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
|
---|
704 | var ys = x1.Zip(x2, (x1i, x2i) => x1i + x2i + x1i * x2i + x1i * x2i * x2i + x1i * x1i * x2i).ToList();
|
---|
705 |
|
---|
706 | var ds = new Dataset(new string[] { "a", "b", "y" }, new[] { x1, x2, ys });
|
---|
707 | var problemData = new RegressionProblemData(ds, new string[] { "a", "b" }, "y");
|
---|
708 |
|
---|
709 | TestGrammarEnumeration(problemData);
|
---|
710 | }
|
---|
711 |
|
---|
712 | [TestMethod]
|
---|
713 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
714 | [TestProperty("Time", "short")]
|
---|
715 | public void MctsSymbReg_NoConstants_Misleading() {
|
---|
716 |
|
---|
717 | // y = a + baaaaa (the effect of the second term should be very small)
|
---|
718 | // the alg will quickly find that a has big effect and will search below a
|
---|
719 | // since we prevent a + a... the algorithm must find the correct expression via a + b...
|
---|
720 | // however b has a small effect so the branch might not be identified as relevant
|
---|
721 | var @as = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
|
---|
722 | var bs = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
|
---|
723 | var cs = Enumerable.Range(0, 100).Select(_ => rand.NextDouble() * 1.0e-3).ToList();
|
---|
724 | var ds = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
|
---|
725 | var es = Enumerable.Range(0, 100).Select(_ => rand.NextDouble()).ToList();
|
---|
726 | var ys = new double[@as.Count];
|
---|
727 | for (int i = 0; i < ys.Length; i++)
|
---|
728 | ys[i] = @as[i] + bs[i] + @as[i] * bs[i] * cs[i];
|
---|
729 |
|
---|
730 | var dataset = new Dataset(new string[] { "a", "b", "c", "d", "e", "y" }, new[] { @as, bs, cs, ds, es, ys.ToList() });
|
---|
731 |
|
---|
732 | var problemData = new RegressionProblemData(dataset, new string[] { "a", "b", "c", "d", "e" }, "y");
|
---|
733 |
|
---|
734 | TestGrammarEnumeration(problemData);
|
---|
735 | }
|
---|
736 |
|
---|
737 | [TestMethod]
|
---|
738 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
739 | [TestProperty("Time", "short")]
|
---|
740 | public void MctsSymbRegKeijzer7() {
|
---|
741 | // ln(x)
|
---|
742 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
|
---|
743 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 7 f(")));
|
---|
744 | // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
|
---|
745 | if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
|
---|
746 | TestGrammarEnumeration(regProblem);
|
---|
747 | }
|
---|
748 |
|
---|
749 |
|
---|
750 | [TestMethod]
|
---|
751 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
752 | [TestProperty("Time", "short")]
|
---|
753 | public void MctsSymbRegBenchmarkNguyen5() {
|
---|
754 | // sin(x²)cos(x) - 1
|
---|
755 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
|
---|
756 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F5 ")));
|
---|
757 | TestGrammarEnumeration(regProblem);
|
---|
758 | }
|
---|
759 |
|
---|
760 | [TestMethod]
|
---|
761 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
762 | [TestProperty("Time", "short")]
|
---|
763 | public void MctsSymbRegBenchmarkNguyen6() {
|
---|
764 | // sin(x) + sin(x + x²)
|
---|
765 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
|
---|
766 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F6 ")));
|
---|
767 | TestGrammarEnumeration(regProblem);
|
---|
768 | }
|
---|
769 |
|
---|
770 | [TestMethod]
|
---|
771 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
772 | [TestProperty("Time", "short")]
|
---|
773 | public void MctsSymbRegBenchmarkNguyen7() {
|
---|
774 | // log(x + 1) + log(x² + 1)
|
---|
775 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
|
---|
776 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F7 ")));
|
---|
777 | TestGrammarEnumeration(regProblem);
|
---|
778 | }
|
---|
779 | [TestMethod]
|
---|
780 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
781 | [TestProperty("Time", "short")]
|
---|
782 | public void MctsSymbRegBenchmarkNguyen8() {
|
---|
783 | // Sqrt(x)
|
---|
784 | // = x ^ 0.5
|
---|
785 | // = exp(0.5 * log(x))
|
---|
786 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
|
---|
787 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F8 ")));
|
---|
788 | TestGrammarEnumeration(regProblem);
|
---|
789 | }
|
---|
790 |
|
---|
791 | // [TestMethod]
|
---|
792 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
793 | [TestProperty("Time", "short")]
|
---|
794 | public void MctsSymbRegBenchmarkNguyen9() {
|
---|
795 | // sin(x) + sin(y²)
|
---|
796 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
|
---|
797 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F9 ")));
|
---|
798 | TestGrammarEnumeration(regProblem);
|
---|
799 | }
|
---|
800 |
|
---|
801 | // [TestMethod]
|
---|
802 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
803 | [TestProperty("Time", "short")]
|
---|
804 | public void MctsSymbRegBenchmarkNguyen10() {
|
---|
805 | // 2sin(x)cos(y)
|
---|
806 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider();
|
---|
807 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F10 ")));
|
---|
808 | TestGrammarEnumeration(regProblem);
|
---|
809 | }
|
---|
810 |
|
---|
811 | [TestMethod]
|
---|
812 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
813 | [TestProperty("Time", "short")]
|
---|
814 | public void MctsSymbRegBenchmarkNguyen11() {
|
---|
815 | // x ^ y , x > 0, y > 0
|
---|
816 | // = exp(y * log(x))
|
---|
817 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
|
---|
818 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F11 ")));
|
---|
819 | TestGrammarEnumeration(regProblem);
|
---|
820 | }
|
---|
821 | [TestMethod]
|
---|
822 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
823 | [TestProperty("Time", "short")]
|
---|
824 | public void MctsSymbRegBenchmarkNguyen12() {
|
---|
825 | // x^4 - x³ + y²/2 - y
|
---|
826 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.NguyenInstanceProvider(Seed);
|
---|
827 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("F12 ")));
|
---|
828 | TestGrammarEnumeration(regProblem);
|
---|
829 | }
|
---|
830 |
|
---|
831 | [TestMethod]
|
---|
832 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
833 | [TestProperty("Time", "long")]
|
---|
834 | public void MctsSymbRegBenchmarkKeijzer5() {
|
---|
835 | // (30 * x * z) / ((x - 10) * y²)
|
---|
836 | // = 30 x z / (xy² - y²)
|
---|
837 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
|
---|
838 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 5 f(")));
|
---|
839 | // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
|
---|
840 | if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
|
---|
841 | TestGrammarEnumeration(regProblem);
|
---|
842 | }
|
---|
843 |
|
---|
844 | [TestMethod]
|
---|
845 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
846 | [TestProperty("Time", "short")]
|
---|
847 | public void MctsSymbRegBenchmarkKeijzer6() {
|
---|
848 | // Keijzer 6 f(x) = Sum(1 / i) From 1 to X , x \in [0..120]
|
---|
849 | // we can only approximate this
|
---|
850 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
|
---|
851 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 6 f(")));
|
---|
852 | // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
|
---|
853 | if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
|
---|
854 | TestGrammarEnumeration(regProblem);
|
---|
855 | }
|
---|
856 |
|
---|
857 | [TestMethod]
|
---|
858 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
859 | [TestProperty("Time", "short")]
|
---|
860 | public void MctsSymbRegBenchmarkKeijzer8() {
|
---|
861 | // sqrt(x)
|
---|
862 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
|
---|
863 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 8 f(")));
|
---|
864 | // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
|
---|
865 | if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
|
---|
866 | TestGrammarEnumeration(regProblem);
|
---|
867 | }
|
---|
868 |
|
---|
869 | [TestMethod]
|
---|
870 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
871 | [TestProperty("Time", "short")]
|
---|
872 | public void MctsSymbRegBenchmarkKeijzer9() {
|
---|
873 | // arcsinh(x) i.e. ln(x + sqrt(x² + 1))
|
---|
874 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
|
---|
875 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 9 f(")));
|
---|
876 | // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
|
---|
877 | if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
|
---|
878 | TestGrammarEnumeration(regProblem);
|
---|
879 | }
|
---|
880 |
|
---|
881 | [TestMethod]
|
---|
882 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
883 | [TestProperty("Time", "short")]
|
---|
884 | public void MctsSymbRegBenchmarkKeijzer11() {
|
---|
885 | // xy + sin( (x-1) (y-1) )
|
---|
886 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider();
|
---|
887 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 11 f(")));
|
---|
888 | // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
|
---|
889 | if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
|
---|
890 | TestGrammarEnumeration(regProblem);
|
---|
891 | }
|
---|
892 |
|
---|
893 | [TestMethod]
|
---|
894 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
895 | [TestProperty("Time", "short")]
|
---|
896 | public void MctsSymbRegBenchmarkKeijzer12() {
|
---|
897 | // x^4 - x³ + y² / 2 - y, same as Nguyen 12
|
---|
898 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
|
---|
899 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 12 f(")));
|
---|
900 | // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
|
---|
901 | if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
|
---|
902 | TestGrammarEnumeration(regProblem);
|
---|
903 | }
|
---|
904 |
|
---|
905 | [TestMethod]
|
---|
906 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
907 | [TestProperty("Time", "short")]
|
---|
908 | public void MctsSymbRegBenchmarkKeijzer14() {
|
---|
909 | // 8 / (2 + x² + y²)
|
---|
910 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
|
---|
911 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 14 f(")));
|
---|
912 | // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
|
---|
913 | if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
|
---|
914 | TestGrammarEnumeration(regProblem);
|
---|
915 | }
|
---|
916 |
|
---|
917 | [TestMethod]
|
---|
918 | [TestCategory("Algorithms.DataAnalysis")]
|
---|
919 | [TestProperty("Time", "short")]
|
---|
920 | public void MctsSymbRegBenchmarkKeijzer15() {
|
---|
921 | // x³ / 5 + y³ / 2 - y - x
|
---|
922 | var provider = new HeuristicLab.Problems.Instances.DataAnalysis.KeijzerInstanceProvider(Seed);
|
---|
923 | var regProblem = provider.LoadData(provider.GetDataDescriptors().Single(x => x.Name.Contains("Keijzer 15 f(")));
|
---|
924 | // some Keijzer problem instances have very large test partitions (here we are not concerened about test performance)
|
---|
925 | if (regProblem.TestPartition.End - regProblem.TestPartition.Start > 1000) regProblem.TestPartition.End = regProblem.TestPartition.Start + 1000;
|
---|
926 | TestGrammarEnumeration(regProblem);
|
---|
927 | }
|
---|
928 | #endif
|
---|
929 | }
|
---|
930 | }
|
---|