Free cookie consent management tool by TermsFeed Policy Generator

source: branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/AlgorithmBase.cs @ 1262

Last change on this file since 1262 was 1262, checked in by gkronber, 15 years ago

Fixed a few issues in persistence of hard-coded GP algorithms. #224 (Simple frontend for GP for non-expert users (similar to HeurisicLab.SGA))
File size: 19.1 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2008 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.Collections.Generic;
24using System.Linq;
25using System.Text;
26using HeuristicLab.Core;
27using System.Xml;
28using System.Diagnostics;
29using HeuristicLab.DataAnalysis;
30using HeuristicLab.Operators;
31using HeuristicLab.Random;
32using HeuristicLab.Selection;
33using HeuristicLab.Logging;
34using HeuristicLab.Data;
35using HeuristicLab.Operators.Programmable;
36
37namespace HeuristicLab.GP.StructureIdentification {
38  public abstract class AlgorithmBase : ItemBase {
39    public virtual double MutationRate {
40      get { return GetVariableInjector().GetVariable("MutationRate").GetValue<DoubleData>().Data; }
41      set { GetVariableInjector().GetVariable("MutationRate").GetValue<DoubleData>().Data = value; }
42    }
43    public virtual int PopulationSize {
44      get { return GetVariableInjector().GetVariable("PopulationSize").GetValue<IntData>().Data; }
45      set { GetVariableInjector().GetVariable("PopulationSize").GetValue<IntData>().Data = value; }
46    }
47
48    public virtual bool SetSeedRandomly {
49      get { return GetRandomInjector().GetVariable("SetSeedRandomly").GetValue<BoolData>().Data; }
50      set { GetRandomInjector().GetVariable("SetSeedRandomly").GetValue<BoolData>().Data = value; }
51    }
52
53    public virtual int Seed {
54      get { return GetRandomInjector().GetVariable("Seed").GetValue<IntData>().Data; }
55      set { GetRandomInjector().GetVariable("Seed").GetValue<IntData>().Data = value; }
56    }
57
58    public virtual IOperator ProblemInjector {
59      get { return algorithm.SubOperators[0]; }
60      set {
61        value.Name = "ProblemInjector";
62        algorithm.RemoveSubOperator(0);
63        algorithm.AddSubOperator(value, 0);
64      }
65    }
66
67    public virtual int Elites {
68      get { return GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data; }
69      set { GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data = value; }
70    }
71
72    public virtual int MaxTreeSize {
73      get { return GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data; }
74      set { GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data = value; }
75    }
76
77    public virtual int MaxTreeHeight {
78      get { return GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data; }
79      set { GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data = value; }
80    }
81
82    public virtual int Parents {
83      get { return GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data; }
84      set { GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data = value; }
85    }
86
87    public virtual double PunishmentFactor {
88      get { return GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data; }
89      set { GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data = value; }
90    }
91
92    public virtual bool UseEstimatedTargetValue {
93      get { return GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data; }
94      set { GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data = value; }
95    }
96
97    private IOperator algorithm;
98
99    private SequentialEngine.SequentialEngine engine;
100    public IEngine Engine {
101      get { return engine; }
102      protected set { engine = (SequentialEngine.SequentialEngine)value; }
103    }
104
105    public AlgorithmBase() {
106      engine = new SequentialEngine.SequentialEngine();
107      CombinedOperator algo = CreateAlgorithm();
108      engine.OperatorGraph.AddOperator(algo);
109      engine.OperatorGraph.InitialOperator = algo;
110    }
111
112    protected internal virtual CombinedOperator CreateAlgorithm() {
113      CombinedOperator algo = new CombinedOperator();
114      algo.Name = "GP";
115      SequentialProcessor seq = new SequentialProcessor();
116      IOperator problemInjector = CreateProblemInjector();
117
118      RandomInjector randomInjector = new RandomInjector();
119      randomInjector.Name = "Random Injector";
120
121      IOperator globalInjector = CreateGlobalInjector();
122      IOperator initialization = CreateInitialization();
123      IOperator funLibInjector = CreateFunctionLibraryInjector();
124      IOperator mainLoop = CreateMainLoop();
125      mainLoop.Name = "Main loop";
126
127      IOperator treeCreator = CreateTreeCreator();
128
129      MeanSquaredErrorEvaluator evaluator = new MeanSquaredErrorEvaluator();
130      evaluator.GetVariableInfo("MSE").ActualName = "Quality";
131      evaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
132      evaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
133      evaluator.Name = "Evaluator";
134
135      IOperator crossover = CreateCrossover();
136      IOperator manipulator = CreateManipulator();
137
138      IOperator selector = CreateSelector();
139      LeftReducer cleanUp = new LeftReducer();
140
141      seq.AddSubOperator(problemInjector);
142      seq.AddSubOperator(randomInjector);
143      seq.AddSubOperator(globalInjector);
144      seq.AddSubOperator(funLibInjector);
145      seq.AddSubOperator(initialization);
146      seq.AddSubOperator(mainLoop);
147      seq.AddSubOperator(cleanUp);
148
149      initialization.AddSubOperator(treeCreator);
150      initialization.AddSubOperator(evaluator);
151
152      mainLoop.AddSubOperator(selector);
153      mainLoop.AddSubOperator(crossover);
154      mainLoop.AddSubOperator(manipulator);
155      mainLoop.AddSubOperator(evaluator);
156      algo.OperatorGraph.AddOperator(seq);
157      algo.OperatorGraph.InitialOperator = seq;
158      this.algorithm = seq;
159      return algo;
160    }
161
162    protected internal virtual IOperator CreateProblemInjector() {
163      return new EmptyOperator();
164    }
165
166    protected internal abstract IOperator CreateSelector();
167
168    protected internal abstract IOperator CreateCrossover();
169
170    protected internal abstract IOperator CreateTreeCreator();
171
172    protected internal abstract IOperator CreateFunctionLibraryInjector();
173
174    protected internal virtual IOperator CreateGlobalInjector() {
175      VariableInjector injector = new VariableInjector();
176      injector.Name = "Global Injector";
177      injector.AddVariable(new HeuristicLab.Core.Variable("Generations", new IntData(0)));
178      injector.AddVariable(new HeuristicLab.Core.Variable("MutationRate", new DoubleData()));
179      injector.AddVariable(new HeuristicLab.Core.Variable("PopulationSize", new IntData()));
180      injector.AddVariable(new HeuristicLab.Core.Variable("Elites", new IntData()));
181      injector.AddVariable(new HeuristicLab.Core.Variable("Maximization", new BoolData(false)));
182      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeHeight", new IntData()));
183      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeSize", new IntData()));
184      injector.AddVariable(new HeuristicLab.Core.Variable("EvaluatedSolutions", new IntData(0)));
185      injector.AddVariable(new HeuristicLab.Core.Variable("TotalEvaluatedNodes", new DoubleData(0)));
186      injector.AddVariable(new HeuristicLab.Core.Variable("Parents", new IntData()));
187      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData()));
188      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData()));
189      return injector;
190    }
191
192    protected internal abstract IOperator CreateManipulator();
193
194    protected internal virtual IOperator CreateInitialization() {
195      CombinedOperator init = new CombinedOperator();
196      init.Name = "Initialization";
197      SequentialProcessor seq = new SequentialProcessor();
198      SubScopesCreater subScopesCreater = new SubScopesCreater();
199      subScopesCreater.GetVariableInfo("SubScopes").ActualName = "PopulationSize";
200      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
201      SequentialProcessor individualSeq = new SequentialProcessor();
202      OperatorExtractor treeCreater = new OperatorExtractor();
203      treeCreater.Name = "Tree generator (extr.)";
204      treeCreater.GetVariableInfo("Operator").ActualName = "Tree generator";
205      OperatorExtractor evaluator = new OperatorExtractor();
206      evaluator.Name = "Evaluator (extr.)";
207      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
208      MeanSquaredErrorEvaluator validationEvaluator = new MeanSquaredErrorEvaluator();
209      validationEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
210      validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
211      validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
212      Counter evalCounter = new Counter();
213      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
214      Sorter sorter = new Sorter();
215      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
216      sorter.GetVariableInfo("Value").ActualName = "Quality";
217
218      seq.AddSubOperator(subScopesCreater);
219      seq.AddSubOperator(subScopesProc);
220      seq.AddSubOperator(sorter);
221
222      subScopesProc.AddSubOperator(individualSeq);
223      individualSeq.AddSubOperator(treeCreater);
224      individualSeq.AddSubOperator(evaluator);
225      individualSeq.AddSubOperator(validationEvaluator);
226      individualSeq.AddSubOperator(evalCounter);
227
228      init.OperatorGraph.AddOperator(seq);
229      init.OperatorGraph.InitialOperator = seq;
230      return init;
231    }
232
233    protected internal virtual IOperator CreateMainLoop() {
234      CombinedOperator main = new CombinedOperator();
235      SequentialProcessor seq = new SequentialProcessor();
236      IOperator childCreater = CreateChildCreater();
237      IOperator replacement = CreateReplacement();
238
239      BestSolutionStorer solutionStorer = new BestSolutionStorer();
240      solutionStorer.GetVariableInfo("Quality").ActualName = "ValidationQuality";
241      solutionStorer.GetVariableInfo("BestSolution").ActualName = "BestValidationSolution";
242      solutionStorer.AddSubOperator(CreateBestSolutionProcessor());
243
244      BestAverageWorstQualityCalculator qualityCalculator = new BestAverageWorstQualityCalculator();
245      BestAverageWorstQualityCalculator validationQualityCalculator = new BestAverageWorstQualityCalculator();
246      validationQualityCalculator.Name = "BestAverageWorstValidationQualityCalculator";
247      validationQualityCalculator.GetVariableInfo("Quality").ActualName = "ValidationQuality";
248      validationQualityCalculator.GetVariableInfo("BestQuality").ActualName = "BestValidationQuality";
249      validationQualityCalculator.GetVariableInfo("AverageQuality").ActualName = "AverageValidationQuality";
250      validationQualityCalculator.GetVariableInfo("WorstQuality").ActualName = "WorstValidationQuality";
251      IOperator loggingOperator = CreateLoggingOperator();
252      Counter counter = new Counter();
253      counter.GetVariableInfo("Value").ActualName = "Generations";
254      IOperator loopCondition = CreateLoopCondition(seq);
255
256      seq.AddSubOperator(childCreater);
257      seq.AddSubOperator(replacement);
258      seq.AddSubOperator(solutionStorer);
259      seq.AddSubOperator(qualityCalculator);
260      seq.AddSubOperator(validationQualityCalculator);
261      seq.AddSubOperator(loggingOperator);
262      seq.AddSubOperator(counter);
263      seq.AddSubOperator(loopCondition);
264
265      main.OperatorGraph.AddOperator(seq);
266      main.OperatorGraph.InitialOperator = seq;
267      return main;
268    }
269
270    protected internal virtual IOperator CreateLoggingOperator() {
271      return new EmptyOperator();
272    }
273
274    protected internal virtual IOperator CreateLoopCondition(IOperator loop) {
275      SequentialProcessor seq = new SequentialProcessor();
276      seq.Name = "Loop Condition";
277      LessThanComparator comparator = new LessThanComparator();
278      comparator.GetVariableInfo("LeftSide").ActualName = "Generations";
279      comparator.GetVariableInfo("RightSide").ActualName = "MaxGenerations";
280      comparator.GetVariableInfo("Result").ActualName = "GenerationsCondition";
281      ConditionalBranch cond = new ConditionalBranch();
282      cond.GetVariableInfo("Condition").ActualName = "GenerationsCondition";
283
284      seq.AddSubOperator(comparator);
285      seq.AddSubOperator(cond);
286
287      cond.AddSubOperator(loop);
288      return seq;
289    }
290
291    protected internal virtual IOperator CreateBestSolutionProcessor() {
292      return new EmptyOperator();
293    }
294
295    protected internal virtual IOperator CreateReplacement() {
296      CombinedOperator replacement = new CombinedOperator();
297      replacement.Name = "Replacement";
298      SequentialProcessor seq = new SequentialProcessor();
299      SequentialSubScopesProcessor seqScopeProc = new SequentialSubScopesProcessor();
300      SequentialProcessor selectedProc = new SequentialProcessor();
301      LeftSelector leftSelector = new LeftSelector();
302      leftSelector.GetVariableInfo("Selected").ActualName = "Elites";
303      RightReducer rightReducer = new RightReducer();
304
305      SequentialProcessor remainingProc = new SequentialProcessor();
306      RightSelector rightSelector = new RightSelector();
307      rightSelector.GetVariableInfo("Selected").ActualName = "Elites";
308      LeftReducer leftReducer = new LeftReducer();
309      MergingReducer mergingReducer = new MergingReducer();
310      Sorter sorter = new Sorter();
311      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
312      sorter.GetVariableInfo("Value").ActualName = "Quality";
313
314      seq.AddSubOperator(seqScopeProc);
315      seqScopeProc.AddSubOperator(selectedProc);
316      selectedProc.AddSubOperator(leftSelector);
317      selectedProc.AddSubOperator(rightReducer);
318
319      seqScopeProc.AddSubOperator(remainingProc);
320      remainingProc.AddSubOperator(rightSelector);
321      remainingProc.AddSubOperator(leftReducer);
322      seq.AddSubOperator(mergingReducer);
323      seq.AddSubOperator(sorter);
324      replacement.OperatorGraph.AddOperator(seq);
325      replacement.OperatorGraph.InitialOperator = seq;
326      return replacement;
327    }
328
329    protected internal virtual IOperator CreateChildCreater() {
330      CombinedOperator childCreater = new CombinedOperator();
331      childCreater.Name = "Create children";
332      SequentialProcessor seq = new SequentialProcessor();
333      OperatorExtractor selector = new OperatorExtractor();
334      selector.Name = "Selector (extr.)";
335      selector.GetVariableInfo("Operator").ActualName = "Selector";
336      SequentialSubScopesProcessor seqScopesProc = new SequentialSubScopesProcessor();
337      EmptyOperator emptyOpt = new EmptyOperator();
338      SequentialProcessor selectedProc = new SequentialProcessor();
339      OperatorExtractor crossover = new OperatorExtractor();
340      crossover.Name = "Crossover (extr.)";
341      crossover.GetVariableInfo("Operator").ActualName = "Crossover";
342      UniformSequentialSubScopesProcessor individualProc = new UniformSequentialSubScopesProcessor();
343      SequentialProcessor individualSeqProc = new SequentialProcessor();
344      StochasticBranch cond = new StochasticBranch();
345      cond.GetVariableInfo("Probability").ActualName = "MutationRate";
346      OperatorExtractor manipulator = new OperatorExtractor();
347      manipulator.Name = "Manipulator (extr.)";
348      manipulator.GetVariableInfo("Operator").ActualName = "Manipulator";
349      OperatorExtractor evaluator = new OperatorExtractor();
350      evaluator.Name = "Evaluator (extr.)";
351      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
352      MeanSquaredErrorEvaluator validationEvaluator = new MeanSquaredErrorEvaluator();
353      validationEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
354      validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
355      validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
356      Counter evalCounter = new Counter();
357      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
358
359      Sorter sorter = new Sorter();
360      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
361      sorter.GetVariableInfo("Value").ActualName = "Quality";
362
363
364      seq.AddSubOperator(selector);
365      seq.AddSubOperator(seqScopesProc);
366      seqScopesProc.AddSubOperator(emptyOpt);
367      seqScopesProc.AddSubOperator(selectedProc);
368      selectedProc.AddSubOperator(crossover);
369      selectedProc.AddSubOperator(individualProc);
370      individualProc.AddSubOperator(individualSeqProc);
371      individualSeqProc.AddSubOperator(cond);
372      cond.AddSubOperator(manipulator);
373      individualSeqProc.AddSubOperator(evaluator);
374      individualSeqProc.AddSubOperator(validationEvaluator);
375      individualSeqProc.AddSubOperator(evalCounter);
376      selectedProc.AddSubOperator(sorter);
377
378      childCreater.OperatorGraph.AddOperator(seq);
379      childCreater.OperatorGraph.InitialOperator = seq;
380      return childCreater;
381    }
382
383    public override object Clone(IDictionary<Guid, object> clonedObjects) {
384      AlgorithmBase clone = (AlgorithmBase)base.Clone(clonedObjects);
385      clonedObjects.Add(Guid, clone);
386      clone.engine = (SequentialEngine.SequentialEngine)Auxiliary.Clone(Engine, clonedObjects);
387      return clone;
388    }
389
390    protected VariableInjector GetVariableInjector() {
391      CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
392      // SequentialProcessor in GP
393      algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
394      return (VariableInjector)algorithm.SubOperators[2];
395    }
396
397    protected RandomInjector GetRandomInjector() {
398      CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
399      // SequentialProcessor in GP
400      algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
401      return (RandomInjector)algorithm.SubOperators[1];
402    }
403
404    #region Persistence Methods
405    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
406      XmlNode node = base.GetXmlNode(name, document, persistedObjects);
407      node.AppendChild(PersistenceManager.Persist("Engine", Engine, document, persistedObjects));
408      return node;
409    }
410    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
411      base.Populate(node, restoredObjects);
412      engine = (SequentialEngine.SequentialEngine)PersistenceManager.Restore(node.SelectSingleNode("Engine"), restoredObjects);
413    }
414    #endregion
415  }
416}
Note: See TracBrowser for help on using the repository browser.