Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.GP.Algorithms/3.2/AlgorithmBase.cs @ 2361

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

Fixed #742 (Consistent naming scheme for data-modeling engines).
File size: 21.4 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.Xml;
25using HeuristicLab.Core;
26using HeuristicLab.Data;
27using HeuristicLab.Evolutionary;
28using HeuristicLab.Logging;
29using HeuristicLab.Operators;
30using HeuristicLab.Random;
31using HeuristicLab.Selection;
32using HeuristicLab.GP.Operators;
33
34namespace HeuristicLab.GP.Algorithms {
35  public abstract class AlgorithmBase : ItemBase {
36    public virtual string Name { get { return "GP"; } }
37    public virtual string Description { get { return "TODO"; } }
38
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 int MaxGenerations {
49      get { return GetVariableInjector().GetVariable("MaxGenerations").GetValue<IntData>().Data; }
50      set { GetVariableInjector().GetVariable("MaxGenerations").GetValue<IntData>().Data = value; }
51    }
52
53    public virtual int Elites {
54      get { return GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data; }
55      set { GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data = value; }
56    }
57
58    public virtual int MaxTreeSize {
59      get { return GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data; }
60      set { GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data = value; }
61    }
62
63    public virtual int MinTreeSize {
64      get { return GetVariableInjector().GetVariable("MinTreeSize").GetValue<IntData>().Data; }
65      set { GetVariableInjector().GetVariable("MinTreeSize").GetValue<IntData>().Data = value; }
66    }
67
68    public virtual int MaxTreeHeight {
69      get { return GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data; }
70      set { GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data = value; }
71    }
72
73    public virtual int Parents {
74      get { return GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data; }
75      set { GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data = value; }
76    }
77
78    public virtual bool SetSeedRandomly {
79      get { return GetRandomInjector().GetVariable("SetSeedRandomly").GetValue<BoolData>().Data; }
80      set { GetRandomInjector().GetVariable("SetSeedRandomly").GetValue<BoolData>().Data = value; }
81    }
82
83    public virtual int RandomSeed {
84      get { return GetRandomInjector().GetVariable("Seed").GetValue<IntData>().Data; }
85      set { GetRandomInjector().GetVariable("Seed").GetValue<IntData>().Data = value; }
86    }
87
88    public virtual IOperator ProblemInjector {
89      get { return GetInitializationOperator().SubOperators[0]; }
90      set {
91        value.Name = "ProblemInjector";
92        IOperator init = GetInitializationOperator();
93        init.RemoveSubOperator(0);
94        init.AddSubOperator(value, 0);
95      }
96    }
97
98    public virtual IOperator FunctionLibraryInjector {
99      get { return GetInitializationOperator().SubOperators[1]; }
100      set {
101        value.Name = "FunctionLibraryInjector";
102        IOperator init = GetInitializationOperator();
103        init.RemoveSubOperator(1);
104        init.AddSubOperator(value, 1);
105      }
106    }
107
108    private IOperator algorithm;
109
110    private SequentialEngine.SequentialEngine engine;
111    public IEngine Engine {
112      get { return engine; }
113      protected set { engine = (SequentialEngine.SequentialEngine)value; }
114    }
115
116    public AlgorithmBase() {
117      engine = new SequentialEngine.SequentialEngine();
118      CombinedOperator algo = CreateAlgorithm();
119      engine.OperatorGraph.AddOperator(algo);
120      engine.OperatorGraph.InitialOperator = algo;
121      SetSeedRandomly = true;
122      Elites = 1;
123      MutationRate = 0.15;
124      PopulationSize = 1000;
125      MaxGenerations = 100;
126      MaxTreeSize = 100;
127      MinTreeSize = 1;
128      MaxTreeHeight = 10;
129      Parents = 2000;
130    }
131
132    protected internal virtual CombinedOperator CreateAlgorithm() {
133      CombinedOperator algo = new CombinedOperator();
134      algo.Name = Name;
135      SequentialProcessor seq = new SequentialProcessor();
136      seq.Name = Name;
137      IOperator init = CreateInitializationOperator();
138      init.AddSubOperator(CreateProblemInjector());
139      init.AddSubOperator(CreateFunctionLibraryInjector());
140      seq.AddSubOperator(init);
141
142      IOperator initPopulation = CreateInitialPopulationGenerator();
143      initPopulation.AddSubOperator(CreateRandomSolutionGenerator());
144      initPopulation.AddSubOperator(CreateInitialPopulationEvaluator());
145      seq.AddSubOperator(initPopulation);
146
147      IOperator mainLoop = CreateMainLoop();
148      mainLoop.AddSubOperator(CreateSelectionOperator());
149      mainLoop.AddSubOperator(CreateCrossoverOperator());
150      mainLoop.AddSubOperator(CreateManipulationOperator());
151      mainLoop.AddSubOperator(CreateEvaluationOperator());
152      mainLoop.AddSubOperator(CreateTerminationCondition());
153      seq.AddSubOperator(mainLoop);
154
155      IOperator postProcess = CreatePostProcessingOperator();
156      seq.AddSubOperator(postProcess);
157
158      algo.OperatorGraph.AddOperator(seq);
159      algo.OperatorGraph.InitialOperator = seq;
160      this.algorithm = seq;
161      return algo;
162    }
163
164    #region global init
165    protected virtual IOperator CreateInitializationOperator() {
166      CombinedOperator init = new CombinedOperator();
167      init.Name = "Initialization";
168      SequentialProcessor seq = new SequentialProcessor();
169      seq.AddSubOperator(CreateRandomInjector());
170      seq.AddSubOperator(CreateGlobalInjector());
171
172      OperatorExtractor probInjectorExtractor = new OperatorExtractor();
173      probInjectorExtractor.Name = "ProblemInjector";
174      probInjectorExtractor.GetVariableInfo("Operator").ActualName = "ProblemInjector";
175      seq.AddSubOperator(probInjectorExtractor);
176
177      OperatorExtractor funLibInjectorExtractor = new OperatorExtractor();
178      funLibInjectorExtractor.Name = "FunctionLibraryInjector";
179      funLibInjectorExtractor.GetVariableInfo("Operator").ActualName = "FunctionLibraryInjector";
180      seq.AddSubOperator(funLibInjectorExtractor);
181
182      init.OperatorGraph.AddOperator(seq);
183      init.OperatorGraph.InitialOperator = seq;
184      return init;
185    }
186
187    protected virtual IOperator CreateRandomInjector() {
188      RandomInjector randomInjector = new RandomInjector();
189      randomInjector.Name = "Random Injector";
190      return randomInjector;
191    }
192
193    protected virtual VariableInjector CreateGlobalInjector() {
194      VariableInjector injector = new VariableInjector();
195      injector.Name = "Global Injector";
196      injector.AddVariable(new HeuristicLab.Core.Variable("Generations", new IntData(0)));
197      injector.AddVariable(new HeuristicLab.Core.Variable("MaxGenerations", new IntData()));
198      injector.AddVariable(new HeuristicLab.Core.Variable("MutationRate", new DoubleData()));
199      injector.AddVariable(new HeuristicLab.Core.Variable("PopulationSize", new IntData()));
200      injector.AddVariable(new HeuristicLab.Core.Variable("Elites", new IntData()));
201      injector.AddVariable(new HeuristicLab.Core.Variable("Maximization", new BoolData(false)));
202      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeHeight", new IntData()));
203      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeSize", new IntData()));
204      injector.AddVariable(new HeuristicLab.Core.Variable("MinTreeSize", new IntData()));
205      injector.AddVariable(new HeuristicLab.Core.Variable("EvaluatedSolutions", new IntData(0)));
206      injector.AddVariable(new HeuristicLab.Core.Variable("TotalEvaluatedNodes", new DoubleData(0)));
207      injector.AddVariable(new HeuristicLab.Core.Variable("Parents", new IntData()));
208      return injector;
209    }
210
211
212    protected virtual IOperator CreateProblemInjector() {
213      return new EmptyOperator();
214    }
215
216    protected virtual IOperator CreateFunctionLibraryInjector() {
217      return new EmptyOperator();
218    }
219    #endregion
220
221    #region population init
222    private IOperator CreateInitialPopulationGenerator() {
223      CombinedOperator initPopulation = new CombinedOperator();
224      initPopulation.Name = "Init population";
225      SequentialProcessor seq = new SequentialProcessor();
226      SubScopesCreater subScopesCreater = new SubScopesCreater();
227      subScopesCreater.GetVariableInfo("SubScopes").ActualName = "PopulationSize";
228      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
229      SequentialProcessor individualSeq = new SequentialProcessor();
230      OperatorExtractor treeCreater = new OperatorExtractor();
231      treeCreater.Name = "Tree generator (extr.)";
232      treeCreater.GetVariableInfo("Operator").ActualName = "Solution generator";
233
234      OperatorExtractor evaluator = new OperatorExtractor();
235      evaluator.Name = "Evaluator (extr.)";
236      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
237      Counter evalCounter = new Counter();
238      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
239      Sorter sorter = new Sorter();
240      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
241      sorter.GetVariableInfo("Value").ActualName = "Quality";
242
243      seq.AddSubOperator(subScopesCreater);
244      seq.AddSubOperator(subScopesProc);
245      seq.AddSubOperator(sorter);
246
247      subScopesProc.AddSubOperator(individualSeq);
248      individualSeq.AddSubOperator(treeCreater);
249      individualSeq.AddSubOperator(evaluator);
250      individualSeq.AddSubOperator(evalCounter);
251
252      initPopulation.OperatorGraph.AddOperator(seq);
253      initPopulation.OperatorGraph.InitialOperator = seq;
254      return initPopulation;
255    }
256
257    protected virtual IOperator CreateRandomSolutionGenerator() {
258      ProbabilisticTreeCreator treeCreator = new ProbabilisticTreeCreator();
259      treeCreator.Name = "Solution generator";
260      return treeCreator;
261    }
262
263    protected virtual IOperator CreateInitialPopulationEvaluator() {
264      return new EmptyOperator();
265    }
266    #endregion
267
268    #region mainloop
269    protected virtual IOperator CreateMainLoop() {
270      CombinedOperator main = new CombinedOperator();
271      main.Name = "Main";
272      SequentialProcessor seq = new SequentialProcessor();
273      IOperator childCreater = CreateChildCreater();
274      IOperator replacement = CreateReplacement();
275
276      BestAverageWorstQualityCalculator qualityCalculator = new BestAverageWorstQualityCalculator();
277      IOperator loggingOperator = CreateLoggingOperator();
278      Counter counter = new Counter();
279      counter.GetVariableInfo("Value").ActualName = "Generations";
280
281      OperatorExtractor terminationCriterionExtractor = new OperatorExtractor();
282      terminationCriterionExtractor.Name = "TerminationCondition (extr.)";
283      terminationCriterionExtractor.GetVariableInfo("Operator").ActualName = "TerminationCondition";
284
285      ConditionalBranch loop = new ConditionalBranch();
286      loop.Name = "Main loop";
287      loop.GetVariableInfo("Condition").ActualName = "TerminationCriterion";
288      loop.AddSubOperator(new EmptyOperator());
289      loop.AddSubOperator(seq);
290
291      seq.AddSubOperator(childCreater);
292      seq.AddSubOperator(replacement);
293      seq.AddSubOperator(qualityCalculator);
294      seq.AddSubOperator(CreateGenerationStepHook());
295      seq.AddSubOperator(loggingOperator);
296      seq.AddSubOperator(counter);
297      seq.AddSubOperator(terminationCriterionExtractor);
298      seq.AddSubOperator(loop);
299
300      main.OperatorGraph.AddOperator(seq);
301      main.OperatorGraph.InitialOperator = seq;
302      return main;
303    }
304
305    protected virtual IOperator CreateChildCreater() {
306      CombinedOperator childCreater = new CombinedOperator();
307      childCreater.Name = "Create children";
308      SequentialProcessor seq = new SequentialProcessor();
309      OperatorExtractor selector = new OperatorExtractor();
310      selector.Name = "Selector (extr.)";
311      selector.GetVariableInfo("Operator").ActualName = "Selector";
312
313      SequentialSubScopesProcessor seqScopesProc = new SequentialSubScopesProcessor();
314      EmptyOperator emptyOpt = new EmptyOperator();
315      SequentialProcessor selectedProc = new SequentialProcessor();
316      ChildrenInitializer childInitializer = new ChildrenInitializer();
317      ((IntData)childInitializer.GetVariable("ParentsPerChild").Value).Data = 2;
318
319      OperatorExtractor crossover = new OperatorExtractor();
320      crossover.Name = "Crossover (extr.)";
321      crossover.GetVariableInfo("Operator").ActualName = "Crossover";
322      UniformSequentialSubScopesProcessor individualProc = new UniformSequentialSubScopesProcessor();
323      SequentialProcessor individualSeqProc = new SequentialProcessor();
324      StochasticBranch cond = new StochasticBranch();
325      cond.GetVariableInfo("Probability").ActualName = "MutationRate";
326      OperatorExtractor manipulator = new OperatorExtractor();
327      manipulator.Name = "Manipulator (extr.)";
328      manipulator.GetVariableInfo("Operator").ActualName = "Manipulator";
329      OperatorExtractor evaluator = new OperatorExtractor();
330      evaluator.Name = "Evaluator (extr.)";
331      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
332      Counter evalCounter = new Counter();
333      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
334      SubScopesRemover parentRefRemover = new SubScopesRemover();
335
336      Sorter sorter = new Sorter();
337      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
338      sorter.GetVariableInfo("Value").ActualName = "Quality";
339
340
341      seq.AddSubOperator(selector);
342      seq.AddSubOperator(seqScopesProc);
343      seqScopesProc.AddSubOperator(emptyOpt);
344      seqScopesProc.AddSubOperator(selectedProc);
345      selectedProc.AddSubOperator(childInitializer);
346      selectedProc.AddSubOperator(individualProc);
347      individualProc.AddSubOperator(individualSeqProc);
348      individualSeqProc.AddSubOperator(crossover);
349      individualSeqProc.AddSubOperator(cond);
350      cond.AddSubOperator(manipulator);
351      individualSeqProc.AddSubOperator(evaluator);
352      individualSeqProc.AddSubOperator(evalCounter);
353      individualSeqProc.AddSubOperator(parentRefRemover);
354      selectedProc.AddSubOperator(sorter);
355
356      childCreater.OperatorGraph.AddOperator(seq);
357      childCreater.OperatorGraph.InitialOperator = seq;
358      return childCreater;
359    }
360
361    protected virtual IOperator CreateReplacement() {
362      CombinedOperator replacement = new CombinedOperator();
363      replacement.Name = "Replacement";
364      SequentialProcessor seq = new SequentialProcessor();
365      SequentialSubScopesProcessor seqScopeProc = new SequentialSubScopesProcessor();
366      SequentialProcessor selectedProc = new SequentialProcessor();
367      LeftSelector leftSelector = new LeftSelector();
368      leftSelector.GetVariableInfo("Selected").ActualName = "Elites";
369      RightReducer rightReducer = new RightReducer();
370
371      SequentialProcessor remainingProc = new SequentialProcessor();
372      RightSelector rightSelector = new RightSelector();
373      rightSelector.GetVariableInfo("Selected").ActualName = "Elites";
374      LeftReducer leftReducer = new LeftReducer();
375      MergingReducer mergingReducer = new MergingReducer();
376      Sorter sorter = new Sorter();
377      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
378      sorter.GetVariableInfo("Value").ActualName = "Quality";
379
380      seq.AddSubOperator(seqScopeProc);
381      seqScopeProc.AddSubOperator(selectedProc);
382      selectedProc.AddSubOperator(leftSelector);
383      selectedProc.AddSubOperator(rightReducer);
384
385      seqScopeProc.AddSubOperator(remainingProc);
386      remainingProc.AddSubOperator(rightSelector);
387      remainingProc.AddSubOperator(leftReducer);
388      seq.AddSubOperator(mergingReducer);
389      seq.AddSubOperator(sorter);
390      replacement.OperatorGraph.AddOperator(seq);
391      replacement.OperatorGraph.InitialOperator = seq;
392      return replacement;
393    }
394
395    protected virtual IOperator CreateLoggingOperator() {
396      CombinedOperator loggingOperator = new CombinedOperator();
397      loggingOperator.Name = "Logging";
398      SequentialProcessor seq = new SequentialProcessor();
399
400      DataCollector collector = new DataCollector();
401      ItemList<StringData> names = collector.GetVariable("VariableNames").GetValue<ItemList<StringData>>();
402      names.Add(new StringData("BestQuality"));
403      names.Add(new StringData("AverageQuality"));
404      names.Add(new StringData("WorstQuality"));
405      LinechartInjector lineChartInjector = new LinechartInjector();
406      lineChartInjector.GetVariableInfo("Linechart").ActualName = "Quality Linechart";
407      lineChartInjector.GetVariable("NumberOfLines").GetValue<IntData>().Data = 3;
408      QualityLogger qualityLogger = new QualityLogger();
409
410      seq.AddSubOperator(collector);
411      seq.AddSubOperator(lineChartInjector);
412      seq.AddSubOperator(qualityLogger);
413
414      loggingOperator.OperatorGraph.AddOperator(seq);
415      loggingOperator.OperatorGraph.InitialOperator = seq;
416      return loggingOperator;
417    }
418
419    protected virtual IOperator CreateGenerationStepHook() {
420      return new EmptyOperator();
421    }
422
423    protected virtual IOperator CreateTerminationCondition() {
424      CombinedOperator terminationCriterion = new CombinedOperator();
425      terminationCriterion.Name = "TerminationCondition";
426      SequentialProcessor seq = new SequentialProcessor();
427      GreaterThanComparator comparator = new GreaterThanComparator();
428      comparator.GetVariableInfo("LeftSide").ActualName = "Generations";
429      comparator.GetVariableInfo("RightSide").ActualName = "MaxGenerations";
430      comparator.GetVariableInfo("Result").ActualName = "TerminationCriterion";
431
432      seq.AddSubOperator(comparator);
433      terminationCriterion.OperatorGraph.AddOperator(seq);
434      terminationCriterion.OperatorGraph.InitialOperator = seq;
435      return terminationCriterion;
436    }
437
438    protected virtual IOperator CreateEvaluationOperator() {
439      return new EmptyOperator();
440    }
441
442    protected virtual IOperator CreateManipulationOperator() {
443      ChangeNodeTypeManipulation manipulator = new ChangeNodeTypeManipulation();
444      manipulator.Name = "Manipulator";
445      return manipulator;
446    }
447
448    protected virtual IOperator CreateCrossoverOperator() {
449      StandardCrossOver crossover = new StandardCrossOver();
450      crossover.Name = "Crossover";
451      return crossover;
452    }
453
454    protected virtual IOperator CreateSelectionOperator() {
455      TournamentSelector selector = new TournamentSelector();
456      selector.GetVariableInfo("Selected").ActualName = "Parents";
457      selector.GetVariable("GroupSize").Value = new IntData(7);
458      selector.Name = "Selector";
459      return selector;
460    }
461
462    #endregion
463
464    protected virtual IOperator CreatePostProcessingOperator() {
465      return new EmptyOperator();
466    }
467
468
469    public override object Clone(IDictionary<Guid, object> clonedObjects) {
470      AlgorithmBase clone = (AlgorithmBase)base.Clone(clonedObjects);
471      clonedObjects.Add(Guid, clone);
472      clone.engine = (SequentialEngine.SequentialEngine)Auxiliary.Clone(Engine, clonedObjects);
473      return clone;
474    }
475
476    protected virtual IOperator GetVariableInjector() {
477      CombinedOperator init = (CombinedOperator)GetInitializationOperator();
478      return init.OperatorGraph.InitialOperator.SubOperators[1];
479    }
480
481    protected virtual IOperator GetRandomInjector() {
482      CombinedOperator init = (CombinedOperator)GetInitializationOperator();
483      return init.OperatorGraph.InitialOperator.SubOperators[0];
484    }
485
486    protected virtual IOperator GetInitializationOperator() {
487      return algorithm.SubOperators[0];
488    }
489
490    #region Persistence Methods
491    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
492      XmlNode node = base.GetXmlNode(name, document, persistedObjects);
493      node.AppendChild(PersistenceManager.Persist("Engine", Engine, document, persistedObjects));
494      return node;
495    }
496    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
497      base.Populate(node, restoredObjects);
498      engine = (SequentialEngine.SequentialEngine)PersistenceManager.Restore(node.SelectSingleNode("Engine"), restoredObjects);
499    }
500    #endregion
501
502
503  }
504}
Note: See TracBrowser for help on using the repository browser.