source: trunk/sources/HeuristicLab.Tests/HeuristicLab-3.3/SamplesTest.cs @ 8740

Last change on this file since 8740 was 8740, checked in by gkronber, 10 years ago

#1902: removed assertion for test R² in GPR unit test as we are testing on a benchmark problem where the test set is randomly created.

File size: 56.7 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Linq;
24using System.Threading;
25using HeuristicLab.Algorithms.DataAnalysis;
26using HeuristicLab.Algorithms.EvolutionStrategy;
27using HeuristicLab.Algorithms.GeneticAlgorithm;
28using HeuristicLab.Algorithms.LocalSearch;
29using HeuristicLab.Algorithms.ParticleSwarmOptimization;
30using HeuristicLab.Algorithms.SimulatedAnnealing;
31using HeuristicLab.Algorithms.TabuSearch;
32using HeuristicLab.Algorithms.VariableNeighborhoodSearch;
33using HeuristicLab.Data;
34using HeuristicLab.Encodings.BinaryVectorEncoding;
35using HeuristicLab.Encodings.PermutationEncoding;
36using HeuristicLab.Encodings.RealVectorEncoding;
37using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
38using HeuristicLab.Optimization;
39using HeuristicLab.Optimization.Operators;
40using HeuristicLab.ParallelEngine;
41using HeuristicLab.Persistence.Default.Xml;
42using HeuristicLab.Problems.ArtificialAnt;
43using HeuristicLab.Problems.DataAnalysis;
44using HeuristicLab.Problems.DataAnalysis.Symbolic;
45using HeuristicLab.Problems.DataAnalysis.Symbolic.Classification;
46using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
47using HeuristicLab.Problems.Instances;
48using HeuristicLab.Problems.Instances.DataAnalysis;
49using HeuristicLab.Problems.Instances.TSPLIB;
50using HeuristicLab.Problems.Instances.VehicleRouting;
51using HeuristicLab.Problems.Knapsack;
52using HeuristicLab.Problems.TestFunctions;
53using HeuristicLab.Problems.TravelingSalesman;
54using HeuristicLab.Problems.VehicleRouting;
55using HeuristicLab.Problems.VehicleRouting.Encodings.General;
56using HeuristicLab.Problems.VehicleRouting.Encodings.Potvin;
57using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
58using HeuristicLab.Selection;
59using Microsoft.VisualStudio.TestTools.UnitTesting;
60
61
62namespace HeuristicLab_33.Tests {
63  [TestClass]
64  [DeploymentItem(@"HeuristicLab-3.3/Resources/C101.opt.txt")]
65  [DeploymentItem(@"HeuristicLab-3.3/Resources/C101.txt")]
66  public class SamplesTest {
67    #region GA
68    #region TSP
69    [TestMethod]
70    public void CreateGaTspSampleTest() {
71      var ga = CreateGaTspSample();
72      XmlGenerator.Serialize(ga, "../../GA_TSP.hl");
73    }
74    [TestMethod]
75    public void RunGaTspSampleTest() {
76      var ga = CreateGaTspSample();
77      ga.SetSeedRandomly.Value = false;
78      RunAlgorithm(ga);
79      Assert.AreEqual(12332, GetDoubleResult(ga, "BestQuality"));
80      Assert.AreEqual(13123.2, GetDoubleResult(ga, "CurrentAverageQuality"));
81      Assert.AreEqual(14538, GetDoubleResult(ga, "CurrentWorstQuality"));
82      Assert.AreEqual(99100, GetIntResult(ga, "EvaluatedSolutions"));
83    }
84
85    private GeneticAlgorithm CreateGaTspSample() {
86      GeneticAlgorithm ga = new GeneticAlgorithm();
87      #region Problem Configuration
88      var provider = new TSPLIBTSPInstanceProvider();
89      var instance = provider.GetDataDescriptors().Where(x => x.Name == "ch130").Single();
90      TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
91      tspProblem.Load(provider.LoadData(instance));
92      tspProblem.UseDistanceMatrix.Value = true;
93      #endregion
94      #region Algorithm Configuration
95      ga.Name = "Genetic Algorithm - TSP";
96      ga.Description = "A genetic algorithm which solves the \"ch130\" traveling salesman problem (imported from TSPLIB)";
97      ga.Problem = tspProblem;
98      ConfigureGeneticAlgorithmParameters<ProportionalSelector, OrderCrossover2, InversionManipulator>(
99        ga, 100, 1, 1000, 0.05);
100      #endregion
101      return ga;
102    }
103    #endregion
104    #region VRP
105    [TestMethod]
106    public void CreateGaVrpSampleTest() {
107      var ga = CreateGaVrpSample();
108      XmlGenerator.Serialize(ga, "../../GA_VRP.hl");
109    }
110
111    [TestMethod]
112    public void RunGaVrpSampleTest() {
113      var ga = CreateGaVrpSample();
114      ga.SetSeedRandomly.Value = false;
115      RunAlgorithm(ga);
116      Assert.AreEqual(1828.9368669428338, GetDoubleResult(ga, "BestQuality"));
117      Assert.AreEqual(1830.1444308908331, GetDoubleResult(ga, "CurrentAverageQuality"));
118      Assert.AreEqual(1871.7128510304112, GetDoubleResult(ga, "CurrentWorstQuality"));
119      Assert.AreEqual(99100, GetIntResult(ga, "EvaluatedSolutions"));
120    }
121
122    private GeneticAlgorithm CreateGaVrpSample() {
123      GeneticAlgorithm ga = new GeneticAlgorithm();
124      #region Problem Configuration
125      VehicleRoutingProblem vrpProblem = new VehicleRoutingProblem();
126
127      SolomonFormatInstanceProvider instanceProvider = new SolomonInstanceProvider();
128      IVRPData data = instanceProvider.Import("C101.txt", "C101.opt.txt");
129      vrpProblem.Load(data);
130      vrpProblem.Name = "C101 VRP (imported from Solomon)";
131      vrpProblem.Description = "Represents a Vehicle Routing Problem.";
132      CVRPTWProblemInstance instance = vrpProblem.ProblemInstance as CVRPTWProblemInstance;
133      instance.DistanceFactor.Value = 1;
134      instance.FleetUsageFactor.Value = 100;
135      instance.OverloadPenalty.Value = 100;
136      instance.TardinessPenalty.Value = 100;
137      instance.TimeFactor.Value = 0;
138      vrpProblem.MaximizationParameter.Value.Value = false;
139      instance.UseDistanceMatrix.Value = true;
140      instance.Vehicles.Value = 25;
141      #endregion
142      #region Algorithm Configuration
143      ga.Name = "Genetic Algorithm - VRP";
144      ga.Description = "A genetic algorithm which solves the \"C101\" vehicle routing problem (imported from Solomon)";
145      ga.Problem = vrpProblem;
146      ConfigureGeneticAlgorithmParameters<TournamentSelector, MultiVRPSolutionCrossover, MultiVRPSolutionManipulator>(
147        ga, 100, 1, 1000, 0.05, 3);
148
149      var xOver = (MultiVRPSolutionCrossover)ga.Crossover;
150      foreach (var op in xOver.Operators) {
151        xOver.Operators.SetItemCheckedState(op, false);
152      }
153      xOver.Operators.SetItemCheckedState(xOver.Operators
154        .OfType<PotvinRouteBasedCrossover>()
155        .Single(), true);
156      xOver.Operators.SetItemCheckedState(xOver.Operators
157        .OfType<PotvinSequenceBasedCrossover>()
158        .Single(), true);
159
160      var manipulator = (MultiVRPSolutionManipulator)ga.Mutator;
161      foreach (var op in manipulator.Operators) {
162        manipulator.Operators.SetItemCheckedState(op, false);
163      }
164      manipulator.Operators.SetItemCheckedState(manipulator.Operators
165        .OfType<PotvinOneLevelExchangeMainpulator>()
166        .Single(), true);
167      manipulator.Operators.SetItemCheckedState(manipulator.Operators
168        .OfType<PotvinTwoLevelExchangeManipulator>()
169        .Single(), true);
170      #endregion
171      return ga;
172    }
173    #endregion
174    #region ArtificialAnt
175    [TestMethod]
176    public void CreateGpArtificialAntSampleTest() {
177      var ga = CreateGpArtificialAntSample();
178      XmlGenerator.Serialize(ga, "../../SGP_SantaFe.hl");
179    }
180
181    [TestMethod]
182    public void RunGpArtificialAntSampleTest() {
183      var ga = CreateGpArtificialAntSample();
184      ga.SetSeedRandomly.Value = false;
185      RunAlgorithm(ga);
186      Assert.AreEqual(81, GetDoubleResult(ga, "BestQuality"));
187      Assert.AreEqual(48.19, GetDoubleResult(ga, "CurrentAverageQuality"));
188      Assert.AreEqual(0, GetDoubleResult(ga, "CurrentWorstQuality"));
189      Assert.AreEqual(50950, GetIntResult(ga, "EvaluatedSolutions"));
190    }
191
192    public GeneticAlgorithm CreateGpArtificialAntSample() {
193      GeneticAlgorithm ga = new GeneticAlgorithm();
194      #region Problem Configuration
195      ArtificialAntProblem antProblem = new ArtificialAntProblem();
196      antProblem.BestKnownQuality.Value = 89;
197      antProblem.MaxExpressionDepth.Value = 10;
198      antProblem.MaxExpressionLength.Value = 100;
199      antProblem.MaxFunctionArguments.Value = 3;
200      antProblem.MaxFunctionDefinitions.Value = 3;
201      antProblem.MaxTimeSteps.Value = 600;
202      #endregion
203      #region Algorithm Configuration
204      ga.Name = "Genetic Programming - Artificial Ant";
205      ga.Description = "A standard genetic programming algorithm to solve the artificial ant problem (Santa-Fe trail)";
206      ga.Problem = antProblem;
207      ConfigureGeneticAlgorithmParameters<TournamentSelector, SubtreeCrossover, MultiSymbolicExpressionTreeArchitectureManipulator>(
208        ga, 1000, 1, 50, 0.15, 5);
209      var mutator = (MultiSymbolicExpressionTreeArchitectureManipulator)ga.Mutator;
210      mutator.Operators.SetItemCheckedState(mutator.Operators
211        .OfType<FullTreeShaker>()
212        .Single(), false);
213      mutator.Operators.SetItemCheckedState(mutator.Operators
214        .OfType<OnePointShaker>()
215        .Single(), false);
216      mutator.Operators.SetItemCheckedState(mutator.Operators
217        .OfType<ArgumentDeleter>()
218        .Single(), false);
219      mutator.Operators.SetItemCheckedState(mutator.Operators
220        .OfType<SubroutineDeleter>()
221        .Single(), false);
222      #endregion
223      return ga;
224    }
225    #endregion
226    #region Symbolic Regression
227    [TestMethod]
228    public void CreateGpSymbolicRegressionSampleTest() {
229      var ga = CreateGpSymbolicRegressionSample();
230      XmlGenerator.Serialize(ga, "../../SGP_SymbReg.hl");
231    }
232    [TestMethod]
233    public void RunGpSymbolicRegressionSampleTest() {
234      var ga = CreateGpSymbolicRegressionSample();
235      ga.SetSeedRandomly.Value = false;
236      RunAlgorithm(ga);
237      Assert.AreEqual(0.790111952286997, GetDoubleResult(ga, "BestQuality"), 1E-8);
238      Assert.AreEqual(0.547381191721895, GetDoubleResult(ga, "CurrentAverageQuality"), 1E-8);
239      Assert.AreEqual(0, GetDoubleResult(ga, "CurrentWorstQuality"), 1E-8);
240      Assert.AreEqual(50950, GetIntResult(ga, "EvaluatedSolutions"));
241    }
242
243    private GeneticAlgorithm CreateGpSymbolicRegressionSample() {
244      GeneticAlgorithm ga = new GeneticAlgorithm();
245      #region Problem Configuration
246      SymbolicRegressionSingleObjectiveProblem symbRegProblem = new SymbolicRegressionSingleObjectiveProblem();
247      symbRegProblem.Name = "Tower Symbolic Regression Problem";
248      symbRegProblem.Description = "Tower Dataset (downloaded from: http://vanillamodeling.com/realproblems.html)";
249      RegressionRealWorldInstanceProvider provider = new RegressionRealWorldInstanceProvider();
250      var instance = provider.GetDataDescriptors().Where(x => x.Name.Equals("TowerData")).Single();
251      var towerProblemData = (RegressionProblemData)provider.LoadData(instance);
252      towerProblemData.TargetVariableParameter.Value = towerProblemData.TargetVariableParameter.ValidValues
253        .First(v => v.Value == "towerResponse");
254      towerProblemData.InputVariables.SetItemCheckedState(
255        towerProblemData.InputVariables.Single(x => x.Value == "x1"), true);
256      towerProblemData.InputVariables.SetItemCheckedState(
257        towerProblemData.InputVariables.Single(x => x.Value == "x7"), false);
258      towerProblemData.InputVariables.SetItemCheckedState(
259        towerProblemData.InputVariables.Single(x => x.Value == "x11"), false);
260      towerProblemData.InputVariables.SetItemCheckedState(
261        towerProblemData.InputVariables.Single(x => x.Value == "x16"), false);
262      towerProblemData.InputVariables.SetItemCheckedState(
263        towerProblemData.InputVariables.Single(x => x.Value == "x21"), false);
264      towerProblemData.InputVariables.SetItemCheckedState(
265        towerProblemData.InputVariables.Single(x => x.Value == "x25"), false);
266      towerProblemData.InputVariables.SetItemCheckedState(
267        towerProblemData.InputVariables.Single(x => x.Value == "towerResponse"), false);
268      towerProblemData.TrainingPartition.Start = 0;
269      towerProblemData.TrainingPartition.End = 4000;
270      towerProblemData.TestPartition.Start = 4000;
271      towerProblemData.TestPartition.End = 4999;
272      towerProblemData.Name = "Data imported from towerData.txt";
273      towerProblemData.Description = "Chemical concentration at top of distillation tower, dataset downloaded from: http://vanillamodeling.com/realproblems.html, best R² achieved with nu-SVR = 0.97";
274      symbRegProblem.ProblemData = towerProblemData;
275
276      // configure grammar
277      var grammar = new TypeCoherentExpressionGrammar();
278      grammar.ConfigureAsDefaultRegressionGrammar();
279      grammar.Symbols.OfType<VariableCondition>().Single().InitialFrequency = 0.0;
280      var varSymbol = grammar.Symbols.OfType<Variable>().Where(x => !(x is LaggedVariable)).Single();
281      varSymbol.WeightMu = 1.0;
282      varSymbol.WeightSigma = 1.0;
283      varSymbol.WeightManipulatorMu = 0.0;
284      varSymbol.WeightManipulatorSigma = 0.05;
285      varSymbol.MultiplicativeWeightManipulatorSigma = 0.03;
286      var constSymbol = grammar.Symbols.OfType<Constant>().Single();
287      constSymbol.MaxValue = 20;
288      constSymbol.MinValue = -20;
289      constSymbol.ManipulatorMu = 0.0;
290      constSymbol.ManipulatorSigma = 1;
291      constSymbol.MultiplicativeManipulatorSigma = 0.03;
292      symbRegProblem.SymbolicExpressionTreeGrammar = grammar;
293
294      // configure remaining problem parameters
295      symbRegProblem.BestKnownQuality.Value = 0.97;
296      symbRegProblem.FitnessCalculationPartition.Start = 0;
297      symbRegProblem.FitnessCalculationPartition.End = 2800;
298      symbRegProblem.ValidationPartition.Start = 2800;
299      symbRegProblem.ValidationPartition.End = 4000;
300      symbRegProblem.RelativeNumberOfEvaluatedSamples.Value = 1;
301      symbRegProblem.MaximumSymbolicExpressionTreeLength.Value = 150;
302      symbRegProblem.MaximumSymbolicExpressionTreeDepth.Value = 12;
303      symbRegProblem.MaximumFunctionDefinitions.Value = 0;
304      symbRegProblem.MaximumFunctionArguments.Value = 0;
305
306      symbRegProblem.EvaluatorParameter.Value = new SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator();
307      #endregion
308      #region Algorithm Configuration
309      ga.Problem = symbRegProblem;
310      ga.Name = "Genetic Programming - Symbolic Regression";
311      ga.Description = "A standard genetic programming algorithm to solve a symbolic regression problem (tower dataset)";
312      ConfigureGeneticAlgorithmParameters<TournamentSelector, SubtreeCrossover, MultiSymbolicExpressionTreeManipulator>(
313        ga, 1000, 1, 50, 0.15, 5);
314      var mutator = (MultiSymbolicExpressionTreeManipulator)ga.Mutator;
315      mutator.Operators.OfType<FullTreeShaker>().Single().ShakingFactor = 0.1;
316      mutator.Operators.OfType<OnePointShaker>().Single().ShakingFactor = 1.0;
317
318      ga.Analyzer.Operators.SetItemCheckedState(
319        ga.Analyzer.Operators
320        .OfType<SymbolicRegressionSingleObjectiveOverfittingAnalyzer>()
321        .Single(), false);
322      ga.Analyzer.Operators.SetItemCheckedState(
323        ga.Analyzer.Operators
324        .OfType<SymbolicDataAnalysisAlleleFrequencyAnalyzer>()
325        .First(), false);
326      #endregion
327      return ga;
328    }
329    #endregion
330    #region Symbolic Classification
331    [TestMethod]
332    public void CreateGpSymbolicClassificationSampleTest() {
333      var ga = CreateGpSymbolicClassificationSample();
334      XmlGenerator.Serialize(ga, "../../SGP_SymbClass.hl");
335    }
336
337    [TestMethod]
338    public void RunGpSymbolicClassificationSampleTest() {
339      var ga = CreateGpSymbolicClassificationSample();
340      ga.SetSeedRandomly.Value = false;
341      RunAlgorithm(ga);
342      Assert.AreEqual(0.14458636369766503, GetDoubleResult(ga, "BestQuality"), 1E-8);
343      Assert.AreEqual(2.5613992769560352, GetDoubleResult(ga, "CurrentAverageQuality"), 1E-8);
344      Assert.AreEqual(100.62175156249987, GetDoubleResult(ga, "CurrentWorstQuality"), 1E-8);
345      Assert.AreEqual(100900, GetIntResult(ga, "EvaluatedSolutions"));
346      var bestTrainingSolution = (IClassificationSolution)ga.Results["Best training solution"].Value;
347      Assert.AreEqual(0.80625, bestTrainingSolution.TrainingAccuracy, 1E-8);
348      Assert.AreEqual(0.782608695652174, bestTrainingSolution.TestAccuracy, 1E-8);
349    }
350
351    private GeneticAlgorithm CreateGpSymbolicClassificationSample() {
352      GeneticAlgorithm ga = new GeneticAlgorithm();
353      #region Problem Configuration
354      SymbolicClassificationSingleObjectiveProblem symbClassProblem = new SymbolicClassificationSingleObjectiveProblem();
355      symbClassProblem.Name = "Mammography Classification Problem";
356      symbClassProblem.Description = "Mammography dataset imported from the UCI machine learning repository (http://archive.ics.uci.edu/ml/datasets/Mammographic+Mass)";
357      UCIInstanceProvider provider = new UCIInstanceProvider();
358      var instance = provider.GetDataDescriptors().Where(x => x.Name.Equals("Mammography")).Single();
359      var mammoData = (ClassificationProblemData)provider.LoadData(instance);
360      mammoData.TargetVariableParameter.Value = mammoData.TargetVariableParameter.ValidValues
361        .First(v => v.Value == "Severity");
362      mammoData.InputVariables.SetItemCheckedState(
363        mammoData.InputVariables.Single(x => x.Value == "BI-RADS"), false);
364      mammoData.InputVariables.SetItemCheckedState(
365        mammoData.InputVariables.Single(x => x.Value == "Age"), true);
366      mammoData.InputVariables.SetItemCheckedState(
367        mammoData.InputVariables.Single(x => x.Value == "Shape"), true);
368      mammoData.InputVariables.SetItemCheckedState(
369        mammoData.InputVariables.Single(x => x.Value == "Margin"), true);
370      mammoData.InputVariables.SetItemCheckedState(
371        mammoData.InputVariables.Single(x => x.Value == "Density"), true);
372      mammoData.InputVariables.SetItemCheckedState(
373        mammoData.InputVariables.Single(x => x.Value == "Severity"), false);
374      mammoData.TrainingPartition.Start = 0;
375      mammoData.TrainingPartition.End = 800;
376      mammoData.TestPartition.Start = 800;
377      mammoData.TestPartition.End = 961;
378      mammoData.Name = "Data imported from mammographic_masses.csv";
379      mammoData.Description = "Original dataset: http://archive.ics.uci.edu/ml/datasets/Mammographic+Mass, missing values have been replaced with median values.";
380      symbClassProblem.ProblemData = mammoData;
381
382      // configure grammar
383      var grammar = new TypeCoherentExpressionGrammar();
384      grammar.ConfigureAsDefaultClassificationGrammar();
385      grammar.Symbols.OfType<VariableCondition>().Single().Enabled = false;
386      var varSymbol = grammar.Symbols.OfType<Variable>().Where(x => !(x is LaggedVariable)).Single();
387      varSymbol.WeightMu = 1.0;
388      varSymbol.WeightSigma = 1.0;
389      varSymbol.WeightManipulatorMu = 0.0;
390      varSymbol.WeightManipulatorSigma = 0.05;
391      varSymbol.MultiplicativeWeightManipulatorSigma = 0.03;
392      var constSymbol = grammar.Symbols.OfType<Constant>().Single();
393      constSymbol.MaxValue = 20;
394      constSymbol.MinValue = -20;
395      constSymbol.ManipulatorMu = 0.0;
396      constSymbol.ManipulatorSigma = 1;
397      constSymbol.MultiplicativeManipulatorSigma = 0.03;
398      symbClassProblem.SymbolicExpressionTreeGrammar = grammar;
399
400      // configure remaining problem parameters
401      symbClassProblem.BestKnownQuality.Value = 0.0;
402      symbClassProblem.FitnessCalculationPartition.Start = 0;
403      symbClassProblem.FitnessCalculationPartition.End = 400;
404      symbClassProblem.ValidationPartition.Start = 400;
405      symbClassProblem.ValidationPartition.End = 800;
406      symbClassProblem.RelativeNumberOfEvaluatedSamples.Value = 1;
407      symbClassProblem.MaximumSymbolicExpressionTreeLength.Value = 100;
408      symbClassProblem.MaximumSymbolicExpressionTreeDepth.Value = 10;
409      symbClassProblem.MaximumFunctionDefinitions.Value = 0;
410      symbClassProblem.MaximumFunctionArguments.Value = 0;
411      symbClassProblem.EvaluatorParameter.Value = new SymbolicClassificationSingleObjectiveMeanSquaredErrorEvaluator();
412      #endregion
413      #region Algorithm Configuration
414      ga.Problem = symbClassProblem;
415      ga.Name = "Genetic Programming - Symbolic Classification";
416      ga.Description = "A standard genetic programming algorithm to solve a classification problem (Mammographic+Mass dataset)";
417      ConfigureGeneticAlgorithmParameters<TournamentSelector, SubtreeCrossover, MultiSymbolicExpressionTreeManipulator>(
418        ga, 1000, 1, 100, 0.15, 5
419        );
420
421      var mutator = (MultiSymbolicExpressionTreeManipulator)ga.Mutator;
422      mutator.Operators.OfType<FullTreeShaker>().Single().ShakingFactor = 0.1;
423      mutator.Operators.OfType<OnePointShaker>().Single().ShakingFactor = 1.0;
424
425      ga.Analyzer.Operators.SetItemCheckedState(
426        ga.Analyzer.Operators
427        .OfType<SymbolicClassificationSingleObjectiveOverfittingAnalyzer>()
428        .Single(), false);
429      ga.Analyzer.Operators.SetItemCheckedState(
430        ga.Analyzer.Operators
431        .OfType<SymbolicDataAnalysisAlleleFrequencyAnalyzer>()
432        .First(), false);
433      #endregion
434      return ga;
435    }
436    #endregion
437    #region LawnMower
438    [TestMethod]
439    public void RunGpLawnMowerSampleTest() {
440      var ga = CreateGpLawnMowerSample();
441      ga.SetSeedRandomly.Value = false;
442      RunAlgorithm(ga);
443    }
444
445    public GeneticAlgorithm CreateGpLawnMowerSample() {
446      GeneticAlgorithm ga = new GeneticAlgorithm();
447      #region Problem Configuration
448      var problem = new HeuristicLab.Problems.LawnMower.Problem();
449      #endregion
450      #region Algorithm Configuration
451      ga.Name = "Genetic Programming - Lawn Mower";
452      ga.Description = "A standard genetic programming algorithm to solve the lawn mower problem";
453      ga.Problem = problem;
454      ConfigureGeneticAlgorithmParameters<TournamentSelector, SubtreeCrossover, MultiSymbolicExpressionTreeArchitectureManipulator>(
455        ga, 1000, 1, 50, 0.25, 5);
456      var mutator = (MultiSymbolicExpressionTreeArchitectureManipulator)ga.Mutator;
457      mutator.Operators.SetItemCheckedState(mutator.Operators
458        .OfType<OnePointShaker>()
459        .Single(), false);
460      #endregion
461      return ga;
462    }
463    #endregion
464    #endregion
465
466    #region ES
467    #region Griewank
468    [TestMethod]
469    public void CreateEsGriewankSampleTest() {
470      var es = CreateEsGriewankSample();
471      XmlGenerator.Serialize(es, "../../ES_Griewank.hl");
472    }
473    [TestMethod]
474    public void RunEsGriewankSampleTest() {
475      var es = CreateEsGriewankSample();
476      es.SetSeedRandomly.Value = false;
477      RunAlgorithm(es);
478      Assert.AreEqual(0, GetDoubleResult(es, "BestQuality"));
479      Assert.AreEqual(0, GetDoubleResult(es, "CurrentAverageQuality"));
480      Assert.AreEqual(0, GetDoubleResult(es, "CurrentWorstQuality"));
481      Assert.AreEqual(100020, GetIntResult(es, "EvaluatedSolutions"));
482    }
483
484    private EvolutionStrategy CreateEsGriewankSample() {
485      EvolutionStrategy es = new EvolutionStrategy();
486      #region Problem Configuration
487      SingleObjectiveTestFunctionProblem problem = new SingleObjectiveTestFunctionProblem();
488
489      problem.ProblemSize.Value = 10;
490      problem.EvaluatorParameter.Value = new GriewankEvaluator();
491      problem.SolutionCreatorParameter.Value = new UniformRandomRealVectorCreator();
492      problem.Maximization.Value = false;
493      problem.Bounds = new DoubleMatrix(new double[,] { { -600, 600 } });
494      problem.BestKnownQuality.Value = 0;
495      problem.BestKnownSolutionParameter.Value = new RealVector(10);
496      problem.Name = "Single Objective Test Function";
497      problem.Description = "Test function with real valued inputs and a single objective.";
498      #endregion
499      #region Algorithm Configuration
500      es.Name = "Evolution Strategy - Griewank";
501      es.Description = "An evolution strategy which solves the 10-dimensional Griewank test function";
502      es.Problem = problem;
503      ConfigureEvolutionStrategyParameters<AverageCrossover, NormalAllPositionsManipulator,
504        StdDevStrategyVectorCreator, StdDevStrategyVectorCrossover, StdDevStrategyVectorManipulator>(
505        es, 20, 500, 2, 200, false);
506
507      StdDevStrategyVectorCreator strategyCreator = (StdDevStrategyVectorCreator)es.StrategyParameterCreator;
508      strategyCreator.BoundsParameter.Value = new DoubleMatrix(new double[,] { { 1, 20 } });
509
510      StdDevStrategyVectorManipulator strategyManipulator = (StdDevStrategyVectorManipulator)es.StrategyParameterManipulator;
511      strategyManipulator.BoundsParameter.Value = new DoubleMatrix(new double[,] { { 1E-12, 30 } });
512      strategyManipulator.GeneralLearningRateParameter.Value = new DoubleValue(0.22360679774997896);
513      strategyManipulator.LearningRateParameter.Value = new DoubleValue(0.39763536438352531);
514      #endregion
515      return es;
516    }
517    #endregion
518    #endregion
519
520    #region Island GA
521    #region TSP
522    [TestMethod]
523    public void CreateIslandGaTspSampleTest() {
524      var ga = CreateIslandGaTspSample();
525      XmlGenerator.Serialize(ga, "../../IslandGA_TSP.hl");
526    }
527    [TestMethod]
528    public void RunIslandGaTspSampleTest() {
529      var ga = CreateIslandGaTspSample();
530      ga.SetSeedRandomly.Value = false;
531      RunAlgorithm(ga);
532      Assert.AreEqual(9918, GetDoubleResult(ga, "BestQuality"));
533      Assert.AreEqual(10324.64, GetDoubleResult(ga, "CurrentAverageQuality"));
534      Assert.AreEqual(11823, GetDoubleResult(ga, "CurrentWorstQuality"));
535      Assert.AreEqual(495500, GetIntResult(ga, "EvaluatedSolutions"));
536    }
537
538    private IslandGeneticAlgorithm CreateIslandGaTspSample() {
539      IslandGeneticAlgorithm ga = new IslandGeneticAlgorithm();
540      #region Problem Configuration
541      var provider = new TSPLIBTSPInstanceProvider();
542      var instance = provider.GetDataDescriptors().Where(x => x.Name == "ch130").Single();
543      TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
544      tspProblem.Load(provider.LoadData(instance));
545      tspProblem.UseDistanceMatrix.Value = true;
546      #endregion
547      #region Algorithm Configuration
548      ga.Name = "Island Genetic Algorithm - TSP";
549      ga.Description = "An island genetic algorithm which solves the \"ch130\" traveling salesman problem (imported from TSPLIB)";
550      ga.Problem = tspProblem;
551      ConfigureIslandGeneticAlgorithmParameters<ProportionalSelector, OrderCrossover2, InversionManipulator,
552        UnidirectionalRingMigrator, BestSelector, WorstReplacer>(
553        ga, 100, 1, 1000, 0.05, 5, 50, 0.25);
554      #endregion
555      return ga;
556    }
557    #endregion
558    #endregion
559
560    #region LS
561    #region Knapsack
562    [TestMethod]
563    public void CreateLocalSearchKnapsackSampleTest() {
564      var ls = CreateLocalSearchKnapsackSample();
565      XmlGenerator.Serialize(ls, "../../LS_Knapsack.hl");
566    }
567    [TestMethod]
568    public void RunLocalSearchKnapsackSampleTest() {
569      var ls = CreateLocalSearchKnapsackSample();
570      ls.SetSeedRandomly.Value = false;
571      RunAlgorithm(ls);
572      Assert.AreEqual(345, GetDoubleResult(ls, "BestQuality"));
573      Assert.AreEqual(340.70731707317071, GetDoubleResult(ls, "CurrentAverageQuality"));
574      Assert.AreEqual(337, GetDoubleResult(ls, "CurrentWorstQuality"));
575      Assert.AreEqual(82000, GetIntResult(ls, "EvaluatedMoves"));
576    }
577
578    private LocalSearch CreateLocalSearchKnapsackSample() {
579      LocalSearch ls = new LocalSearch();
580      #region Problem Configuration
581      KnapsackProblem problem = new KnapsackProblem();
582      problem.BestKnownQuality = new DoubleValue(362);
583      problem.BestKnownSolution = new HeuristicLab.Encodings.BinaryVectorEncoding.BinaryVector(new bool[] {
584       true , false, false, true , true , true , true , true , false, true , true , true , true , true , true , false, true , false, true , true , false, true , true , false, true , false, true , true , true , false, true , true , false, true , true , false, true , false, true , true , true , true , true , true , true , true , true , true , true , true , true , false, true , false, false, true , true , false, true , true , true , true , true , true , true , true , false, true , false, true , true , true , true , false, true , true , true , true , true , true , true , true});
585      problem.EvaluatorParameter.Value = new KnapsackEvaluator();
586      problem.SolutionCreatorParameter.Value = new RandomBinaryVectorCreator();
587      problem.KnapsackCapacity.Value = 297;
588      problem.Maximization.Value = true;
589      problem.Penalty.Value = 1;
590      problem.Values = new IntArray(new int[] {
591  6, 1, 1, 6, 7, 8, 7, 4, 2, 5, 2, 6, 7, 8, 7, 1, 7, 1, 9, 4, 2, 6, 5,  3, 5, 3, 3, 6, 5, 2, 4, 9, 4, 5, 7, 1, 4, 3, 5, 5, 8, 3, 6, 7, 3, 9, 7, 7, 5, 5, 7, 1, 4, 4, 3, 9, 5, 1, 6, 2, 2, 6, 1, 6, 5, 4, 4, 7, 1,  8, 9, 9, 7, 4, 3, 8, 7, 5, 7, 4, 4, 5});
592      problem.Weights = new IntArray(new int[] {
593 1, 9, 3, 6, 5, 3, 8, 1, 7, 4, 2, 1, 2, 7, 9, 9, 8, 4, 9, 2, 4, 8, 3, 7, 5, 7, 5, 5, 1, 9, 8, 7, 8, 9, 1, 3, 3, 8, 8, 5, 1, 2, 4, 3, 6, 9, 4, 4, 9, 7, 4, 5, 1, 9, 7, 6, 7, 4, 7, 1, 2, 1, 2, 9, 8, 6, 8, 4, 7, 6, 7, 5, 3, 9, 4, 7, 4, 6, 1, 2, 5, 4});
594      problem.Name = "Knapsack Problem";
595      problem.Description = "Represents a Knapsack problem.";
596      #endregion
597      #region Algorithm Configuration
598      ls.Name = "Local Search - Knapsack";
599      ls.Description = "A local search algorithm that solves a randomly generated Knapsack problem";
600      ls.Problem = problem;
601      ls.MaximumIterations.Value = 1000;
602      ls.MoveEvaluator = ls.MoveEvaluatorParameter.ValidValues
603        .OfType<KnapsackOneBitflipMoveEvaluator>()
604        .Single();
605      ls.MoveGenerator = ls.MoveGeneratorParameter.ValidValues
606        .OfType<ExhaustiveOneBitflipMoveGenerator>()
607        .Single();
608      ls.MoveMaker = ls.MoveMakerParameter.ValidValues
609        .OfType<OneBitflipMoveMaker>()
610        .Single();
611      ls.SampleSize.Value = 100;
612      ls.Seed.Value = 0;
613      ls.SetSeedRandomly.Value = true;
614      #endregion
615      ls.Engine = new ParallelEngine();
616      return ls;
617    }
618    #endregion
619    #endregion
620
621    #region PSO
622    #region Schwefel
623    [TestMethod]
624    public void CreatePsoSchwefelSampleTest() {
625      var pso = CreatePsoSchwefelSample();
626      XmlGenerator.Serialize(pso, "../../PSO_Schwefel.hl");
627    }
628    [TestMethod]
629    public void RunPsoSchwefelSampleTest() {
630      var pso = CreatePsoSchwefelSample();
631      pso.SetSeedRandomly.Value = false;
632      RunAlgorithm(pso);
633      if (!Environment.Is64BitProcess) {
634        Assert.AreEqual(118.44027985932837, GetDoubleResult(pso, "BestQuality"));
635        Assert.AreEqual(140.71570105946438, GetDoubleResult(pso, "CurrentAverageQuality"));
636        Assert.AreEqual(220.956806502853, GetDoubleResult(pso, "CurrentWorstQuality"));
637        Assert.AreEqual(1000, GetIntResult(pso, "Iterations"));
638      } else {
639        Assert.AreEqual(118.43958282879345, GetDoubleResult(pso, "BestQuality"));
640        Assert.AreEqual(139.43946864779372, GetDoubleResult(pso, "CurrentAverageQuality"));
641        Assert.AreEqual(217.14654589055152, GetDoubleResult(pso, "CurrentWorstQuality"));
642        Assert.AreEqual(1000, GetIntResult(pso, "Iterations"));
643      }
644    }
645    private ParticleSwarmOptimization CreatePsoSchwefelSample() {
646      ParticleSwarmOptimization pso = new ParticleSwarmOptimization();
647      #region Problem Configuration
648      var problem = new SingleObjectiveTestFunctionProblem();
649      problem.BestKnownQuality.Value = 0.0;
650      problem.BestKnownSolutionParameter.Value = new RealVector(new double[] { 420.968746, 420.968746 });
651      problem.Bounds = new DoubleMatrix(new double[,] { { -500, 500 } });
652      problem.EvaluatorParameter.Value = new SchwefelEvaluator();
653      problem.Maximization.Value = false;
654      problem.ProblemSize.Value = 2;
655      problem.SolutionCreatorParameter.Value = new UniformRandomRealVectorCreator();
656      #endregion
657      #region Algorithm Configuration
658      pso.Name = "Particle Swarm Optimization - Schwefel";
659      pso.Description = "A particle swarm optimization algorithm which solves the 2-dimensional Schwefel test function (based on the description in Pedersen, M.E.H. (2010). PhD thesis. University of Southampton)";
660      pso.Problem = problem;
661      pso.Inertia.Value = 10;
662      pso.MaxIterations.Value = 1000;
663      pso.NeighborBestAttraction.Value = 0.5;
664      pso.PersonalBestAttraction.Value = -0.01;
665      pso.SwarmSize.Value = 50;
666
667      var inertiaUpdater = pso.InertiaUpdaterParameter.ValidValues
668        .OfType<ExponentialDiscreteDoubleValueModifier>()
669        .Single();
670      inertiaUpdater.StartValueParameter.Value = new DoubleValue(10);
671      inertiaUpdater.EndValueParameter.Value = new DoubleValue(1);
672      pso.InertiaUpdater = inertiaUpdater;
673
674      pso.ParticleCreator = pso.ParticleCreatorParameter.ValidValues
675        .OfType<RealVectorParticleCreator>()
676        .Single();
677      var swarmUpdater = pso.SwarmUpdaterParameter.ValidValues
678        .OfType<RealVectorSwarmUpdater>()
679        .Single();
680      swarmUpdater.VelocityBoundsIndexParameter.ActualName = "Iterations";
681      swarmUpdater.VelocityBoundsParameter.Value = new DoubleMatrix(new double[,] { { -10, 10 } });
682      swarmUpdater.VelocityBoundsStartValueParameter.Value = new DoubleValue(10.0);
683      swarmUpdater.VelocityBoundsEndValueParameter.Value = new DoubleValue(1.0);
684      swarmUpdater.VelocityBoundsScalingOperatorParameter.Value = swarmUpdater.VelocityBoundsScalingOperatorParameter.ValidValues
685        .OfType<ExponentialDiscreteDoubleValueModifier>()
686        .Single();
687
688      pso.TopologyInitializer = null;
689      pso.TopologyUpdater = null;
690      pso.SwarmUpdater = swarmUpdater;
691      pso.Seed.Value = 0;
692      pso.SetSeedRandomly.Value = true;
693      #endregion
694      pso.Engine = new ParallelEngine();
695      return pso;
696    }
697    #endregion
698    #endregion
699
700    #region SA
701    #region Rastrigin
702    [TestMethod]
703    public void CreateSimulatedAnnealingRastriginSampleTest() {
704      var sa = CreateSimulatedAnnealingRastriginSample();
705      XmlGenerator.Serialize(sa, "../../SA_Rastrigin.hl");
706    }
707    [TestMethod]
708    public void RunSimulatedAnnealingRastriginSampleTest() {
709      var sa = CreateSimulatedAnnealingRastriginSample();
710      sa.SetSeedRandomly.Value = false;
711      RunAlgorithm(sa);
712      Assert.AreEqual(0.00014039606034543795, GetDoubleResult(sa, "BestQuality"));
713      Assert.AreEqual(5000, GetIntResult(sa, "EvaluatedMoves"));
714    }
715    private SimulatedAnnealing CreateSimulatedAnnealingRastriginSample() {
716      SimulatedAnnealing sa = new SimulatedAnnealing();
717      #region Problem Configuration
718      var problem = new SingleObjectiveTestFunctionProblem();
719      problem.BestKnownQuality.Value = 0.0;
720      problem.BestKnownSolutionParameter.Value = new RealVector(new double[] { 0, 0 });
721      problem.Bounds = new DoubleMatrix(new double[,] { { -5.12, 5.12 } });
722      problem.EvaluatorParameter.Value = new RastriginEvaluator();
723      problem.Maximization.Value = false;
724      problem.ProblemSize.Value = 2;
725      problem.SolutionCreatorParameter.Value = new UniformRandomRealVectorCreator();
726      #endregion
727      #region Algorithm Configuration
728      sa.Name = "Simulated Annealing - Rastrigin";
729      sa.Description = "A simulated annealing algorithm that solves the 2-dimensional Rastrigin test function";
730      sa.Problem = problem;
731      var annealingOperator = sa.AnnealingOperatorParameter.ValidValues
732        .OfType<ExponentialDiscreteDoubleValueModifier>()
733        .Single();
734      annealingOperator.StartIndexParameter.Value = new IntValue(0);
735      sa.AnnealingOperator = annealingOperator;
736
737      sa.EndTemperature.Value = 1E-6;
738      sa.InnerIterations.Value = 50;
739      sa.MaximumIterations.Value = 100;
740      var moveEvaluator = sa.MoveEvaluatorParameter.ValidValues
741        .OfType<RastriginAdditiveMoveEvaluator>()
742        .Single();
743      moveEvaluator.A.Value = 10;
744      sa.MoveEvaluator = moveEvaluator;
745
746      var moveGenerator = sa.MoveGeneratorParameter.ValidValues
747        .OfType<StochasticNormalMultiMoveGenerator>()
748        .Single();
749      moveGenerator.SigmaParameter.Value = new DoubleValue(1);
750      sa.MoveGenerator = moveGenerator;
751
752      sa.MoveMaker = sa.MoveMakerParameter.ValidValues
753        .OfType<AdditiveMoveMaker>()
754        .Single();
755
756      sa.Seed.Value = 0;
757      sa.SetSeedRandomly.Value = true;
758      sa.StartTemperature.Value = 1;
759      #endregion
760      sa.Engine = new ParallelEngine();
761      return sa;
762    }
763    #endregion
764    #endregion
765
766    #region TS
767    #region TSP
768    [TestMethod]
769    public void CreateTabuSearchTspSampleTest() {
770      var ts = CreateTabuSearchTspSample();
771      XmlGenerator.Serialize(ts, "../../TS_TSP.hl");
772    }
773    [TestMethod]
774    public void RunTabuSearchTspSampleTest() {
775      var ts = CreateTabuSearchTspSample();
776      ts.SetSeedRandomly.Value = false;
777      RunAlgorithm(ts);
778      Assert.AreEqual(6441, GetDoubleResult(ts, "BestQuality"));
779      Assert.AreEqual(7401.666666666667, GetDoubleResult(ts, "CurrentAverageQuality"));
780      Assert.AreEqual(8418, GetDoubleResult(ts, "CurrentWorstQuality"));
781      Assert.AreEqual(750000, GetIntResult(ts, "EvaluatedMoves"));
782    }
783
784    private TabuSearch CreateTabuSearchTspSample() {
785      TabuSearch ts = new TabuSearch();
786      #region Problem Configuration
787      var provider = new TSPLIBTSPInstanceProvider();
788      var instance = provider.GetDataDescriptors().Where(x => x.Name == "ch130").Single();
789      TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
790      tspProblem.Load(provider.LoadData(instance));
791      tspProblem.UseDistanceMatrix.Value = true;
792      #endregion
793      #region Algorithm Configuration
794      ts.Name = "Tabu Search - TSP";
795      ts.Description = "A tabu search algorithm that solves the \"ch130\" TSP (imported from TSPLIB)";
796      ts.Problem = tspProblem;
797
798      ts.MaximumIterations.Value = 1000;
799      // move generator has to be set first
800      var moveGenerator = ts.MoveGeneratorParameter.ValidValues
801        .OfType<StochasticInversionMultiMoveGenerator>()
802        .Single();
803      ts.MoveGenerator = moveGenerator;
804      var moveEvaluator = ts.MoveEvaluatorParameter.ValidValues
805        .OfType<TSPInversionMoveRoundedEuclideanPathEvaluator>()
806        .Single();
807      ts.MoveEvaluator = moveEvaluator;
808      var moveMaker = ts.MoveMakerParameter.ValidValues
809        .OfType<InversionMoveMaker>()
810        .Single();
811      ts.MoveMaker = moveMaker;
812      ts.SampleSize.Value = 750;
813      ts.Seed.Value = 0;
814      ts.SetSeedRandomly.Value = true;
815
816      var tabuChecker = ts.TabuCheckerParameter.ValidValues
817        .OfType<InversionMoveSoftTabuCriterion>()
818        .Single();
819      tabuChecker.UseAspirationCriterion.Value = true;
820      ts.TabuChecker = tabuChecker;
821
822      var tabuMaker = ts.TabuMakerParameter.ValidValues
823        .OfType<InversionMoveTabuMaker>()
824        .Single();
825      ts.TabuMaker = tabuMaker;
826      ts.TabuTenure.Value = 60;
827
828      #endregion
829      ts.Engine = new ParallelEngine();
830      return ts;
831    }
832    #endregion
833    #endregion
834
835    #region VNS
836    #region TSP
837    [TestMethod]
838    public void CreateVnsTspSampleTest() {
839      var vns = CreateVnsTspSample();
840      XmlGenerator.Serialize(vns, "../../VNS_TSP.hl");
841    }
842    [TestMethod]
843    public void RunVnsTspSampleTest() {
844      var vns = CreateVnsTspSample();
845      vns.SetSeedRandomly = false;
846      RunAlgorithm(vns);
847      Assert.AreEqual(867, GetDoubleResult(vns, "BestQuality"));
848      Assert.AreEqual(867, GetDoubleResult(vns, "CurrentAverageQuality"));
849      Assert.AreEqual(867, GetDoubleResult(vns, "CurrentWorstQuality"));
850      Assert.AreEqual(12975173, GetIntResult(vns, "EvaluatedSolutions"));
851    }
852
853    private VariableNeighborhoodSearch CreateVnsTspSample() {
854      VariableNeighborhoodSearch vns = new VariableNeighborhoodSearch();
855      #region Problem Configuration
856      TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
857      tspProblem.BestKnownSolution = new Permutation(PermutationTypes.Absolute, new int[] {
858117, 65, 73, 74, 75, 76, 82, 86, 87, 94, 100, 106, 115, 120, 124, 107, 101, 108, 109, 102, 97, 90, 96, 95, 88, 89, 84, 78, 69, 57, 68, 56, 44, 55, 45, 36, 46, 37, 38, 47, 48, 59, 49, 58, 70, 77, 83, 79, 50, 80, 85, 98, 103, 110, 116, 121, 125, 133, 132, 138, 139, 146, 147, 159, 168, 169, 175, 182, 188, 201, 213, 189, 214, 221, 230, 246, 262, 276, 284, 275, 274, 261, 245, 229, 220, 228, 243, 259, 273, 282, 272, 258, 242, 257, 293, 292, 302, 310, 319, 320, 327, 326, 333, 340, 346, 339, 345, 344, 337, 338, 332, 325, 318, 309, 301, 291, 271, 251, 270, 233, 250, 269, 268, 280, 290, 300, 415, 440, 416, 417, 441, 458, 479, 418, 419, 395, 420, 442, 421, 396, 397, 422, 423, 461, 481, 502, 460, 501, 459, 480, 500, 517, 531, 516, 530, 499, 478, 457, 439, 414, 413, 412, 438, 456, 477, 498, 515, 529, 538, 547, 558, 559, 560, 548, 539, 549, 561, 562, 551, 550, 532, 540, 533, 541, 518, 534, 542, 552, 553, 554, 555, 535, 543, 556, 544, 536, 522, 505, 521, 520, 504, 519, 503, 482, 462, 463, 464, 483, 443, 465, 484, 506, 485, 507, 508, 487, 467, 486, 466, 445, 428, 444, 424, 425, 426, 427, 398, 399, 400, 381, 382, 371, 372, 401, 429, 446, 430, 402, 383, 366, 356, 357, 352, 385, 384, 403, 431, 447, 469, 468, 488, 489, 490, 470, 471, 448, 432, 433, 404, 405, 386, 373, 374, 367, 376, 375, 387, 491, 509, 537, 510, 492, 472, 449, 388, 389, 406, 450, 407, 377, 368, 359, 354, 350, 335, 324, 330, 390, 434, 451, 473, 493, 511, 523, 545, 563, 565, 567, 570, 569, 578, 577, 576, 575, 574, 573, 572, 580, 584, 583, 582, 587, 586, 585, 581, 579, 571, 568, 566, 564, 557, 546, 527, 513, 526, 525, 524, 512, 495, 494, 474, 452, 436, 409, 435, 453, 475, 496, 514, 528, 497, 455, 476, 454, 437, 411, 410, 394, 393, 392, 380, 370, 379, 408, 391, 378, 369, 364, 365, 361, 355, 351, 343, 336, 331, 317, 299, 286, 287, 278, 263, 264, 265, 223, 202, 248, 266, 279, 288, 289, 281, 267, 249, 232, 224, 216, 215, 204, 192, 193, 194, 186, 179, 185, 203, 191, 190, 177, 171, 161, 128, 135, 140, 149, 162, 150, 163, 172, 178, 173, 164, 152, 151, 141, 153, 165, 154, 142, 155, 143, 137, 136, 130, 129, 118, 114, 113, 105, 119, 123, 131, 144, 156, 157, 145, 158, 166, 167, 174, 180, 181, 187, 195, 205, 217, 226, 236, 225, 234, 252, 235, 253, 254, 255, 238, 239, 240, 241, 256, 237, 206, 207, 208, 196, 197, 198, 209, 199, 200, 211, 212, 219, 210, 218, 227, 244, 260, 283, 294, 295, 303, 296, 311, 304, 297, 298, 305, 285, 306, 314, 329, 321, 313, 312, 328, 334, 341, 347, 348, 353, 358, 362, 363, 360, 349, 342, 322, 323, 315, 316, 308, 307, 277, 247, 231, 222, 184, 183, 176, 170, 160, 148, 134, 127, 126, 111, 104, 92, 91, 71, 60, 51, 52, 40, 32, 23, 21, 20, 18, 17, 16, 14, 13, 11, 10, 7, 6, 5, 2, 1, 0, 3, 4, 31, 39, 25, 30, 35, 34, 33, 43, 54, 42, 27, 28, 29, 9, 8, 12, 15, 19, 22, 24, 26, 41, 67, 66, 64, 63, 53, 62, 61, 72, 81, 93, 99, 112, 122,
859      });
860      tspProblem.Coordinates = new DoubleMatrix(new double[,] {
861{48, 71}, {49, 71}, {50, 71}, {44, 70}, {45, 70}, {52, 70}, {53, 70}, {54, 70}, {41, 69}, {42, 69}, {55, 69}, {56, 69}, {40, 68}, {56, 68}, {57, 68}, {39, 67}, {57, 67}, {58, 67}, {59, 67}, {38, 66}, {59, 66}, {60, 66}, {37, 65}, {60, 65}, {36, 64}, {43, 64}, {35, 63}, {37, 63}, {41, 63}, {42, 63}, {43, 63}, {47, 63}, {61, 63}, {40, 62}, {41, 62}, {42, 62}, {43, 62}, {45, 62}, {46, 62}, {47, 62}, {62, 62}, {34, 61}, {38, 61}, {39, 61}, {42, 61}, {43, 61}, {44, 61}, {45, 61}, {46, 61}, {47, 61}, {52, 61}, {62, 61}, {63, 61}, {26, 60}, {38, 60}, {42, 60}, {43, 60}, {44, 60}, {46, 60}, {47, 60}, {63, 60}, {23, 59}, {24, 59}, {27, 59}, {29, 59}, {30, 59}, {31, 59}, {33, 59}, {42, 59}, {46, 59}, {47, 59}, {63, 59}, {21, 58}, {32, 58}, {33, 58}, {34, 58}, {35, 58}, {46, 58}, {47, 58}, {48, 58}, {53, 58}, {21, 57}, {35, 57}, {47, 57}, {48, 57}, {53, 57}, {36, 56}, {37, 56}, {46, 56}, {47, 56}, {48, 56}, {64, 56}, {65, 56}, {20, 55}, {38, 55}, {46, 55}, {47, 55}, {48, 55}, {52, 55}, {21, 54}, {40, 54}, {47, 54}, {48, 54}, {52, 54}, {65, 54}, {30, 53}, {41, 53}, {46, 53}, {47, 53}, {48, 53}, {52, 53}, {65, 53}, {21, 52}, {32, 52}, {33, 52}, {42, 52}, {51, 52}, {21, 51}, {33, 51}, {34, 51}, {43, 51}, {51, 51}, {21, 50}, {35, 50}, {44, 50}, {50, 50}, {66, 50}, {67, 50}, {21, 49}, {34, 49}, {36, 49}, {37, 49}, {46, 49}, {49, 49}, {67, 49}, {22, 48}, {36, 48}, {37, 48}, {46, 48}, {47, 48}, {22, 47}, {30, 47}, {34, 47}, {37, 47}, {38, 47}, {39, 47}, {47, 47}, {48, 47}, {67, 47}, {23, 46}, {28, 46}, {29, 46}, {30, 46}, {31, 46}, {32, 46}, {35, 46}, {37, 46}, {38, 46}, {39, 46}, {49, 46}, {67, 46}, {23, 45}, {28, 45}, {29, 45}, {31, 45}, {32, 45}, {40, 45}, {41, 45}, {49, 45}, {50, 45}, {68, 45}, {24, 44}, {29, 44}, {32, 44}, {41, 44}, {51, 44}, {68, 44}, {25, 43}, {30, 43}, {32, 43}, {42, 43}, {43, 43}, {51, 43}, {68, 43}, {69, 43}, {31, 42}, {32, 42}, {43, 42}, {52, 42}, {55, 42}, {26, 41}, {27, 41}, {31, 41}, {32, 41}, {33, 41}, {44, 41}, {45, 41}, {46, 41}, {47, 41}, {48, 41}, {49, 41}, {53, 41}, {25, 40}, {27, 40}, {32, 40}, {43, 40}, {44, 40}, {45, 40}, {46, 40}, {48, 40}, {49, 40}, {50, 40}, {51, 40}, {53, 40}, {56, 40}, {32, 39}, {33, 39}, {43, 39}, {50, 39}, {51, 39}, {54, 39}, {56, 39}, {69, 39}, {24, 38}, {32, 38}, {41, 38}, {42, 38}, {51, 38}, {52, 38}, {54, 38}, {57, 38}, {69, 38}, {31, 37}, {32, 37}, {40, 37}, {41, 37}, {42, 37}, {43, 37}, {44, 37}, {45, 37}, {46, 37}, {47, 37}, {48, 37}, {51, 37}, {52, 37}, {55, 37}, {57, 37}, {69, 37}, {24, 36}, {31, 36}, {32, 36}, {39, 36}, {40, 36}, {41, 36}, {42, 36}, {43, 36}, {45, 36}, {48, 36}, {49, 36}, {51, 36}, {53, 36}, {55, 36}, {58, 36}, {22, 35}, {23, 35}, {24, 35}, {25, 35}, {30, 35}, {31, 35}, {32, 35}, {39, 35}, {41, 35}, {49, 35}, {51, 35}, {55, 35}, {56, 35}, {58, 35}, {71, 35}, {20, 34}, {27, 34}, {30, 34}, {31, 34}, {51, 34}, {53, 34}, {57, 34}, {60, 34}, {18, 33}, {19, 33}, {29, 33}, {30, 33}, {31, 33}, {45, 33}, {46, 33}, {47, 33}, {52, 33}, {53, 33}, {55, 33}, {57, 33}, {58, 33}, {17, 32}, {30, 32}, {44, 32}, {47, 32}, {54, 32}, {57, 32}, {59, 32}, {61, 32}, {71, 32}, {72, 32}, {43, 31}, {47, 31}, {56, 31}, {58, 31}, {59, 31}, {61, 31}, {72, 31}, {74, 31}, {16, 30}, {43, 30}, {46, 30}, {47, 30}, {59, 30}, {63, 30}, {71, 30}, {75, 30}, {43, 29}, {46, 29}, {47, 29}, {59, 29}, {60, 29}, {75, 29}, {15, 28}, {43, 28}, {46, 28}, {61, 28}, {76, 28}, {15, 27}, {43, 27}, {44, 27}, {45, 27}, {46, 27}, {60, 27}, {62, 27}, {15, 26}, {43, 26}, {44, 26}, {46, 26}, {59, 26}, {60, 26}, {64, 26}, {77, 26}, {15, 25}, {58, 25}, {61, 25}, {77, 25}, {15, 24}, {53, 24}, {55, 24}, {61, 24}, {77, 24}, {62, 23}, {16, 22}, {61, 22}, {62, 22}, {15, 21}, {16, 21}, {52, 21}, {63, 21}, {77, 21}, {16, 20}, {17, 20}, {46, 20}, {47, 20}, {60, 20}, {62, 20}, {63, 20}, {65, 20}, {76, 20}, {15, 19}, {17, 19}, {18, 19}, {44, 19}, {45, 19}, {48, 19}, {53, 19}, {56, 19}, {60, 19}, {62, 19}, {67, 19}, {68, 19}, {76, 19}, {15, 18}, {18, 18}, {19, 18}, {20, 18}, {32, 18}, {33, 18}, {34, 18}, {41, 18}, {42, 18}, {43, 18}, {46, 18}, {48, 18}, {53, 18}, {59, 18}, {60, 18}, {69, 18}, {75, 18}, {16, 17}, {17, 17}, {20, 17}, {21, 17}, {22, 17}, {23, 17}, {24, 17}, {26, 17}, {28, 17}, {29, 17}, {30, 17}, {31, 17}, {32, 17}, {34, 17}, {35, 17}, {36, 17}, {37, 17}, {38, 17}, {39, 17}, {40, 17}, {44, 17}, {46, 17}, {48, 17}, {53, 17}, {56, 17}, {58, 17}, {75, 17}, {17, 16}, {18, 16}, {20, 16}, {24, 16}, {26, 16}, {27, 16}, {29, 16}, {33, 16}, {41, 16}, {42, 16}, {44, 16}, {47, 16}, {52, 16}, {57, 16}, {70, 16}, {73, 16}, {74, 16}, {17, 15}, {18, 15}, {20, 15}, {22, 15}, {24, 15}, {27, 15}, {29, 15}, {31, 15}, {33, 15}, {35, 15}, {36, 15}, {38, 15}, {39, 15}, {42, 15}, {45, 15}, {47, 15}, {52, 15}, {53, 15}, {55, 15}, {56, 15}, {70, 15}, {73, 15}, {17, 14}, {19, 14}, {21, 14}, {24, 14}, {26, 14}, {29, 14}, {31, 14}, {34, 14}, {37, 14}, {40, 14}, {42, 14}, {44, 14}, {46, 14}, {47, 14}, {53, 14}, {54, 14}, {55, 14}, {62, 14}, {70, 14}, {72, 14}, {17, 13}, {19, 13}, {21, 13}, {23, 13}, {25, 13}, {27, 13}, {30, 13}, {32, 13}, {34, 13}, {36, 13}, {38, 13}, {41, 13}, {43, 13}, {44, 13}, {45, 13}, {60, 13}, {70, 13}, {71, 13}, {18, 12}, {21, 12}, {23, 12}, {26, 12}, {28, 12}, {31, 12}, {34, 12}, {37, 12}, {39, 12}, {41, 12}, {42, 12}, {70, 12}, {18, 11}, {19, 11}, {20, 11}, {21, 11}, {24, 11}, {25, 11}, {27, 11}, {29, 11}, {31, 11}, {33, 11}, {35, 11}, {38, 11}, {41, 11}, {59, 11}, {26, 10}, {29, 10}, {32, 10}, {34, 10}, {36, 10}, {39, 10}, {40, 10}, {69, 10}, {21, 9}, {26, 9}, {28, 9}, {30, 9}, {32, 9}, {33, 9}, {35, 9}, {36, 9}, {37, 9}, {38, 9}, {39, 9}, {22, 8}, {27, 8}, {28, 8}, {29, 8}, {30, 8}, {31, 8}, {68, 8}, {23, 7}, {66, 7}, {24, 6}, {65, 6}, {25, 5}, {62, 5}, {63, 5}, {26, 4}, {55, 4}, {56, 4}, {57, 4}, {58, 4}, {59, 4}, {60, 4}, {61, 4}, {28, 3}, {53, 3}, {29, 2}, {50, 2}, {51, 2}, {52, 2}, {31, 1}, {32, 1}, {48, 1}
862      });
863      tspProblem.BestKnownQuality = new DoubleValue(867);
864
865      tspProblem.EvaluatorParameter.Value = new TSPRoundedEuclideanPathEvaluator();
866      tspProblem.SolutionCreatorParameter.Value = new RandomPermutationCreator();
867      tspProblem.UseDistanceMatrix.Value = true;
868      tspProblem.Name = "Funny TSP";
869      tspProblem.Description = "Represents a symmetric Traveling Salesman Problem.";
870      #endregion
871      #region Algorithm Configuration
872      vns.Name = "Variable Neighborhood Search - TSP";
873      vns.Description = "A variable neighborhood search algorithm which solves a funny TSP instance";
874      vns.Problem = tspProblem;
875
876      var localImprovement = vns.LocalImprovementParameter.ValidValues
877        .OfType<LocalSearchImprovementOperator>()
878        .Single();
879      // move generator has to be set first
880      localImprovement.MoveGenerator = localImprovement.MoveGeneratorParameter.ValidValues
881        .OfType<StochasticInversionMultiMoveGenerator>()
882        .Single();
883      localImprovement.MoveEvaluator = localImprovement.MoveEvaluatorParameter.ValidValues
884        .OfType<TSPInversionMoveRoundedEuclideanPathEvaluator>()
885        .Single();
886      localImprovement.MoveMaker = localImprovement.MoveMakerParameter.ValidValues
887        .OfType<InversionMoveMaker>()
888        .Single();
889      localImprovement.SampleSizeParameter.Value = new IntValue(500);
890      vns.LocalImprovement = localImprovement;
891
892      vns.LocalImprovementMaximumIterations = 150;
893      vns.MaximumIterations = 25;
894      vns.Seed = 0;
895      vns.SetSeedRandomly = true;
896      var shakingOperator = vns.ShakingOperatorParameter.ValidValues
897        .OfType<PermutationShakingOperator>()
898        .Single();
899      shakingOperator.Operators.SetItemCheckedState(shakingOperator.Operators
900        .OfType<Swap2Manipulator>()
901        .Single(), false);
902      shakingOperator.Operators.SetItemCheckedState(shakingOperator.Operators
903        .OfType<Swap3Manipulator>()
904        .Single(), false);
905      vns.ShakingOperator = shakingOperator;
906      #endregion
907      vns.Engine = new ParallelEngine();
908      return vns;
909    }
910    #endregion
911    #endregion
912
913
914    #region Gaussian Process Regression
915    [TestMethod]
916    public void CreateGaussianProcessRegressionSampleTest() {
917      var vns = CreateGaussianProcessRegressionSample();
918      XmlGenerator.Serialize(vns, "../../GaussianProcessRegression.hl");
919    }
920    [TestMethod]
921    public void RunGaussianProcessRegressionSample() {
922      var gpr = CreateGaussianProcessRegressionSample();
923      gpr.SetSeedRandomly = false;
924      gpr.Seed = 1618551877;
925      RunAlgorithm(gpr);
926      Assert.AreEqual(-940.48768748097029, GetDoubleResult(gpr, "NegativeLogLikelihood"));
927      Assert.AreEqual(0.99561947047986976, GetDoubleResult(gpr, "Training R²"));
928    }
929
930    private GaussianProcessRegression CreateGaussianProcessRegressionSample() {
931      var gpr = new GaussianProcessRegression();
932      var provider = new VariousInstanceProvider();
933      var instance = provider.GetDataDescriptors().Where(x => x.Name.Contains("Spatial co-evolution")).Single();
934      var regProblem = new RegressionProblem();
935      regProblem.Load(provider.LoadData(instance));
936      #region Algorithm Configuration
937      gpr.Name = "Gaussian Process Regression";
938      gpr.Description = "A Gaussian process regression algorithm applied to the spatial co-evolution benchmark problem.";
939      gpr.Problem = regProblem;
940
941      gpr.CovarianceFunction = new CovarianceSquaredExponentialIso();
942      gpr.MeanFunction = new MeanConst();
943      gpr.MinimizationIterations = 20;
944      gpr.Seed = 0;
945      gpr.SetSeedRandomly = true;
946      #endregion
947      gpr.Engine = new ParallelEngine();
948      return gpr;
949    }
950    #endregion
951
952    #region Helpers
953    private void ConfigureEvolutionStrategyParameters<R, M, SC, SR, SM>(EvolutionStrategy es, int popSize, int children, int parentsPerChild, int maxGens, bool plusSelection)
954      where R : ICrossover
955      where M : IManipulator
956      where SC : IStrategyParameterCreator
957      where SR : IStrategyParameterCrossover
958      where SM : IStrategyParameterManipulator {
959      es.PopulationSize.Value = popSize;
960      es.Children.Value = children;
961      es.ParentsPerChild.Value = parentsPerChild;
962      es.MaximumGenerations.Value = maxGens;
963      es.PlusSelection.Value = false;
964
965      es.Seed.Value = 0;
966      es.SetSeedRandomly.Value = true;
967
968      es.Recombinator = es.RecombinatorParameter.ValidValues
969        .OfType<R>()
970        .Single();
971
972      es.Mutator = es.MutatorParameter.ValidValues
973        .OfType<M>()
974        .Single();
975
976      es.StrategyParameterCreator = es.StrategyParameterCreatorParameter.ValidValues
977        .OfType<SC>()
978        .Single();
979      es.StrategyParameterCrossover = es.StrategyParameterCrossoverParameter.ValidValues
980        .OfType<SR>()
981        .Single();
982      es.StrategyParameterManipulator = es.StrategyParameterManipulatorParameter.ValidValues
983        .OfType<SM>()
984        .Single();
985      es.Engine = new ParallelEngine();
986    }
987
988    private void ConfigureGeneticAlgorithmParameters<S, C, M>(GeneticAlgorithm ga, int popSize, int elites, int maxGens, double mutationRate, int tournGroupSize = 0)
989      where S : ISelector
990      where C : ICrossover
991      where M : IManipulator {
992      ga.Elites.Value = elites;
993      ga.MaximumGenerations.Value = maxGens;
994      ga.MutationProbability.Value = mutationRate;
995      ga.PopulationSize.Value = popSize;
996      ga.Seed.Value = 0;
997      ga.SetSeedRandomly.Value = true;
998      ga.Selector = ga.SelectorParameter.ValidValues
999        .OfType<S>()
1000        .First();
1001
1002      ga.Crossover = ga.CrossoverParameter.ValidValues
1003        .OfType<C>()
1004        .First();
1005
1006      ga.Mutator = ga.MutatorParameter.ValidValues
1007        .OfType<M>()
1008        .First();
1009
1010      var tSelector = ga.Selector as TournamentSelector;
1011      if (tSelector != null) {
1012        tSelector.GroupSizeParameter.Value.Value = tournGroupSize;
1013      }
1014      ga.Engine = new ParallelEngine();
1015    }
1016
1017    private void ConfigureIslandGeneticAlgorithmParameters<S, C, M, Mi, MiS, MiR>(IslandGeneticAlgorithm ga, int popSize, int elites, int maxGens, double mutationRate, int numberOfIslands, int migrationInterval, double migrationRate)
1018      where S : ISelector
1019      where C : ICrossover
1020      where M : IManipulator
1021      where Mi : IMigrator
1022      where MiS : ISelector
1023      where MiR : IReplacer {
1024      ga.Elites.Value = elites;
1025      ga.MaximumGenerations.Value = maxGens;
1026      ga.MutationProbability.Value = mutationRate;
1027      ga.PopulationSize.Value = popSize;
1028      ga.NumberOfIslands.Value = numberOfIslands;
1029      ga.MigrationInterval.Value = migrationInterval;
1030      ga.MigrationRate.Value = migrationRate;
1031      ga.Seed.Value = 0;
1032      ga.SetSeedRandomly.Value = true;
1033      ga.Selector = ga.SelectorParameter.ValidValues
1034        .OfType<S>()
1035        .Single();
1036
1037      ga.Crossover = ga.CrossoverParameter.ValidValues
1038        .OfType<C>()
1039        .Single();
1040
1041      ga.Mutator = ga.MutatorParameter.ValidValues
1042        .OfType<M>()
1043        .Single();
1044      ga.Migrator = ga.MigratorParameter.ValidValues
1045        .OfType<Mi>()
1046        .Single();
1047      ga.EmigrantsSelector = ga.EmigrantsSelectorParameter.ValidValues
1048        .OfType<MiS>()
1049        .Single();
1050      ga.ImmigrationReplacer = ga.ImmigrationReplacerParameter.ValidValues
1051        .OfType<MiR>()
1052        .Single();
1053      ga.Engine = new ParallelEngine();
1054    }
1055
1056
1057    private void RunAlgorithm(IAlgorithm a) {
1058      var trigger = new EventWaitHandle(false, EventResetMode.ManualReset);
1059      Exception ex = null;
1060      a.Stopped += (src, e) => { trigger.Set(); };
1061      a.ExceptionOccurred += (src, e) => { ex = e.Value; trigger.Set(); };
1062      a.Prepare();
1063      a.Start();
1064      trigger.WaitOne();
1065
1066      Assert.AreEqual(ex, null);
1067    }
1068
1069    private double GetDoubleResult(IAlgorithm a, string resultName) {
1070      return ((DoubleValue)a.Results[resultName].Value).Value;
1071    }
1072    private int GetIntResult(IAlgorithm a, string resultName) {
1073      return ((IntValue)a.Results[resultName].Value).Value;
1074    }
1075    #endregion
1076  }
1077}
Note: See TracBrowser for help on using the repository browser.