Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/AlgorithmBase.cs @ 1857

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

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