Free cookie consent management tool by TermsFeed Policy Generator

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

Last change on this file since 2290 was 2290, checked in by gkronber, 15 years ago
  • introduced a variablename to index mapping for SVM models (to make sure we can use the model for prediction in the model analyzer)
  • added support to enable and disable algorithms in the dispatcher and removed DispatcherBase
  • fixed bugs when calculating variable impacts and reading the final model of GP algorithms

#722 (IModel should provide a Predict() method to get predicted values for an input vector)

File size: 23.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.DataAnalysis;
28using HeuristicLab.Evolutionary;
29using HeuristicLab.GP.Interfaces;
30using HeuristicLab.Logging;
31using HeuristicLab.Modeling;
32using HeuristicLab.Operators;
33using HeuristicLab.Random;
34using HeuristicLab.Selection;
35
36namespace HeuristicLab.GP.StructureIdentification {
37  public abstract class AlgorithmBase : ItemBase, IAlgorithm, IStochasticAlgorithm {
38    public virtual string Name { get { return "GP"; } }
39    public virtual string Description { get { return "TODO"; } }
40
41    public abstract Dataset Dataset { get; set; }
42    public abstract int TargetVariable { get; set; }
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[1]; }
65      set {
66        value.Name = "ProblemInjector";
67        algorithm.RemoveSubOperator(1);
68        algorithm.AddSubOperator(value, 1);
69      }
70    }
71
72    private IAnalyzerModel model;
73    public virtual IAnalyzerModel Model {
74      get {
75        if (!engine.Terminated) throw new InvalidOperationException("The algorithm is still running. Wait until the algorithm is terminated to retrieve the result.");
76        if (model == null) {
77          IScope bestModelScope = engine.GlobalScope.GetVariableValue<IScope>("BestValidationSolution", false);
78          model = CreateGPModel(bestModelScope);
79        }
80        return model;
81      }
82    }
83
84    public virtual int Elites {
85      get { return GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data; }
86      set { GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data = value; }
87    }
88
89    public virtual int MaxTreeSize {
90      get { return GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data; }
91      set { GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data = value; }
92    }
93
94    public virtual int MaxTreeHeight {
95      get { return GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data; }
96      set { GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data = value; }
97    }
98
99    public virtual int Parents {
100      get { return GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data; }
101      set { GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data = value; }
102    }
103
104    public virtual bool UseEstimatedTargetValue {
105      get { return GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data; }
106      set { GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data = value; }
107    }
108
109    private IOperator algorithm;
110
111    private SequentialEngine.SequentialEngine engine;
112    public IEngine Engine {
113      get { return engine; }
114      protected set { engine = (SequentialEngine.SequentialEngine)value; }
115    }
116
117    public AlgorithmBase() {
118      engine = new SequentialEngine.SequentialEngine();
119      CombinedOperator algo = CreateAlgorithm();
120      engine.OperatorGraph.AddOperator(algo);
121      engine.OperatorGraph.InitialOperator = algo;
122      SetSeedRandomly = true;
123      Elites = 1;
124      MutationRate = 0.15;
125      PopulationSize = 1000;
126      MaxTreeSize = 100;
127      MaxTreeHeight = 10;
128      Parents = 2000;
129      UseEstimatedTargetValue = false;
130    }
131
132    protected internal virtual CombinedOperator CreateAlgorithm() {
133      CombinedOperator algo = new CombinedOperator();
134      algo.Name = "GP";
135      SequentialProcessor seq = new SequentialProcessor();
136      IOperator problemInjector = CreateProblemInjector();
137
138      RandomInjector randomInjector = new RandomInjector();
139      randomInjector.Name = "Random Injector";
140
141      IOperator globalInjector = CreateGlobalInjector();
142      IOperator initialization = CreateInitialization();
143      IOperator funLibInjector = CreateFunctionLibraryInjector();
144
145      IOperator mainLoop = CreateMainLoop();
146      mainLoop.Name = "Main loop";
147
148      IOperator treeCreator = CreateTreeCreator();
149
150      MeanSquaredErrorEvaluator evaluator = new MeanSquaredErrorEvaluator();
151      evaluator.GetVariableInfo("MSE").ActualName = "Quality";
152      evaluator.GetVariableInfo("SamplesStart").ActualName = "ActualTrainingSamplesStart";
153      evaluator.GetVariableInfo("SamplesEnd").ActualName = "ActualTrainingSamplesEnd";
154      evaluator.Name = "Evaluator";
155
156      IOperator crossover = CreateCrossover();
157      IOperator manipulator = CreateManipulator();
158
159      IOperator selector = CreateSelector();
160      LeftReducer cleanUp = new LeftReducer();
161
162      seq.AddSubOperator(randomInjector);
163      seq.AddSubOperator(problemInjector);
164      seq.AddSubOperator(globalInjector);
165      seq.AddSubOperator(funLibInjector);
166      seq.AddSubOperator(initialization);
167      seq.AddSubOperator(mainLoop);
168      seq.AddSubOperator(cleanUp);
169
170      initialization.AddSubOperator(treeCreator);
171      initialization.AddSubOperator(evaluator);
172
173      mainLoop.AddSubOperator(selector);
174      mainLoop.AddSubOperator(crossover);
175      mainLoop.AddSubOperator(manipulator);
176      mainLoop.AddSubOperator(evaluator);
177      algo.OperatorGraph.AddOperator(seq);
178      algo.OperatorGraph.InitialOperator = seq;
179      this.algorithm = seq;
180      return algo;
181    }
182
183    protected internal virtual IOperator CreateProblemInjector() {
184      return new EmptyOperator();
185    }
186
187    protected internal abstract IOperator CreateSelector();
188
189    protected internal abstract IOperator CreateCrossover();
190
191    protected internal abstract IOperator CreateTreeCreator();
192
193    protected internal abstract IOperator CreateFunctionLibraryInjector();
194
195    protected internal virtual IOperator CreateGlobalInjector() {
196      VariableInjector injector = new VariableInjector();
197      injector.Name = "Global Injector";
198      injector.AddVariable(new HeuristicLab.Core.Variable("Generations", new IntData(0)));
199      injector.AddVariable(new HeuristicLab.Core.Variable("MutationRate", new DoubleData()));
200      injector.AddVariable(new HeuristicLab.Core.Variable("PopulationSize", new IntData()));
201      injector.AddVariable(new HeuristicLab.Core.Variable("Elites", new IntData()));
202      injector.AddVariable(new HeuristicLab.Core.Variable("Maximization", new BoolData(false)));
203      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeHeight", new IntData()));
204      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeSize", 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      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData()));
209      injector.AddVariable(new HeuristicLab.Core.Variable("TreeEvaluator", new HL2TreeEvaluator()));
210      return injector;
211    }
212
213    protected internal abstract IOperator CreateManipulator();
214
215    protected internal virtual IOperator CreateInitialization() {
216      CombinedOperator init = new CombinedOperator();
217      init.Name = "Initialization";
218      SequentialProcessor seq = new SequentialProcessor();
219      SubScopesCreater subScopesCreater = new SubScopesCreater();
220      subScopesCreater.GetVariableInfo("SubScopes").ActualName = "PopulationSize";
221      UniformSequentialSubScopesProcessor subScopesProc = new UniformSequentialSubScopesProcessor();
222      SequentialProcessor individualSeq = new SequentialProcessor();
223      OperatorExtractor treeCreater = new OperatorExtractor();
224      treeCreater.Name = "Tree generator (extr.)";
225      treeCreater.GetVariableInfo("Operator").ActualName = "Tree generator";
226      OperatorExtractor evaluator = new OperatorExtractor();
227      evaluator.Name = "Evaluator (extr.)";
228      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
229      MeanSquaredErrorEvaluator validationEvaluator = new MeanSquaredErrorEvaluator();
230      validationEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
231      validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
232      validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
233      Counter evalCounter = new Counter();
234      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
235      Sorter sorter = new Sorter();
236      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
237      sorter.GetVariableInfo("Value").ActualName = "Quality";
238
239      seq.AddSubOperator(subScopesCreater);
240      seq.AddSubOperator(subScopesProc);
241      seq.AddSubOperator(sorter);
242
243      subScopesProc.AddSubOperator(individualSeq);
244      individualSeq.AddSubOperator(treeCreater);
245      individualSeq.AddSubOperator(evaluator);
246      individualSeq.AddSubOperator(validationEvaluator);
247      individualSeq.AddSubOperator(evalCounter);
248
249      init.OperatorGraph.AddOperator(seq);
250      init.OperatorGraph.InitialOperator = seq;
251      return init;
252    }
253
254    protected internal virtual IOperator CreateMainLoop() {
255      CombinedOperator main = new CombinedOperator();
256      SequentialProcessor seq = new SequentialProcessor();
257      IOperator childCreater = CreateChildCreater();
258      IOperator replacement = CreateReplacement();
259
260      BestSolutionStorer solutionStorer = new BestSolutionStorer();
261      solutionStorer.GetVariableInfo("Quality").ActualName = "ValidationQuality";
262      solutionStorer.GetVariableInfo("BestSolution").ActualName = "BestValidationSolution";
263      solutionStorer.AddSubOperator(CreateBestSolutionProcessor());
264
265      BestAverageWorstQualityCalculator qualityCalculator = new BestAverageWorstQualityCalculator();
266      BestAverageWorstQualityCalculator validationQualityCalculator = new BestAverageWorstQualityCalculator();
267      validationQualityCalculator.Name = "BestAverageWorstValidationQualityCalculator";
268      validationQualityCalculator.GetVariableInfo("Quality").ActualName = "ValidationQuality";
269      validationQualityCalculator.GetVariableInfo("BestQuality").ActualName = "BestValidationQuality";
270      validationQualityCalculator.GetVariableInfo("AverageQuality").ActualName = "AverageValidationQuality";
271      validationQualityCalculator.GetVariableInfo("WorstQuality").ActualName = "WorstValidationQuality";
272      IOperator loggingOperator = CreateLoggingOperator();
273      Counter counter = new Counter();
274      counter.GetVariableInfo("Value").ActualName = "Generations";
275      IOperator loopCondition = CreateLoopCondition(seq);
276
277      seq.AddSubOperator(childCreater);
278      seq.AddSubOperator(replacement);
279      seq.AddSubOperator(solutionStorer);
280      seq.AddSubOperator(qualityCalculator);
281      seq.AddSubOperator(validationQualityCalculator);
282      seq.AddSubOperator(loggingOperator);
283      seq.AddSubOperator(counter);
284      seq.AddSubOperator(loopCondition);
285
286      main.OperatorGraph.AddOperator(seq);
287      main.OperatorGraph.InitialOperator = seq;
288      return main;
289    }
290
291    protected internal virtual IOperator CreateLoggingOperator() {
292      return new EmptyOperator();
293    }
294
295    protected internal virtual IOperator CreateLoopCondition(IOperator loop) {
296      SequentialProcessor seq = new SequentialProcessor();
297      seq.Name = "Loop Condition";
298      LessThanComparator comparator = new LessThanComparator();
299      comparator.GetVariableInfo("LeftSide").ActualName = "Generations";
300      comparator.GetVariableInfo("RightSide").ActualName = "MaxGenerations";
301      comparator.GetVariableInfo("Result").ActualName = "GenerationsCondition";
302      ConditionalBranch cond = new ConditionalBranch();
303      cond.GetVariableInfo("Condition").ActualName = "GenerationsCondition";
304
305      seq.AddSubOperator(comparator);
306      seq.AddSubOperator(cond);
307
308      cond.AddSubOperator(loop);
309      return seq;
310    }
311
312    protected internal virtual IOperator CreateBestSolutionProcessor() {
313      return new EmptyOperator();
314    }
315
316    protected internal virtual IOperator CreateReplacement() {
317      CombinedOperator replacement = new CombinedOperator();
318      replacement.Name = "Replacement";
319      SequentialProcessor seq = new SequentialProcessor();
320      SequentialSubScopesProcessor seqScopeProc = new SequentialSubScopesProcessor();
321      SequentialProcessor selectedProc = new SequentialProcessor();
322      LeftSelector leftSelector = new LeftSelector();
323      leftSelector.GetVariableInfo("Selected").ActualName = "Elites";
324      RightReducer rightReducer = new RightReducer();
325
326      SequentialProcessor remainingProc = new SequentialProcessor();
327      RightSelector rightSelector = new RightSelector();
328      rightSelector.GetVariableInfo("Selected").ActualName = "Elites";
329      LeftReducer leftReducer = new LeftReducer();
330      MergingReducer mergingReducer = new MergingReducer();
331      Sorter sorter = new Sorter();
332      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
333      sorter.GetVariableInfo("Value").ActualName = "Quality";
334
335      seq.AddSubOperator(seqScopeProc);
336      seqScopeProc.AddSubOperator(selectedProc);
337      selectedProc.AddSubOperator(leftSelector);
338      selectedProc.AddSubOperator(rightReducer);
339
340      seqScopeProc.AddSubOperator(remainingProc);
341      remainingProc.AddSubOperator(rightSelector);
342      remainingProc.AddSubOperator(leftReducer);
343      seq.AddSubOperator(mergingReducer);
344      seq.AddSubOperator(sorter);
345      replacement.OperatorGraph.AddOperator(seq);
346      replacement.OperatorGraph.InitialOperator = seq;
347      return replacement;
348    }
349
350    protected internal virtual IOperator CreateChildCreater() {
351      CombinedOperator childCreater = new CombinedOperator();
352      childCreater.Name = "Create children";
353      SequentialProcessor seq = new SequentialProcessor();
354      OperatorExtractor selector = new OperatorExtractor();
355      selector.Name = "Selector (extr.)";
356      selector.GetVariableInfo("Operator").ActualName = "Selector";
357
358      SequentialSubScopesProcessor seqScopesProc = new SequentialSubScopesProcessor();
359      EmptyOperator emptyOpt = new EmptyOperator();
360      SequentialProcessor selectedProc = new SequentialProcessor();
361      ChildrenInitializer childInitializer = new ChildrenInitializer();
362      ((IntData)childInitializer.GetVariable("ParentsPerChild").Value).Data = 2;
363
364      OperatorExtractor crossover = new OperatorExtractor();
365      crossover.Name = "Crossover (extr.)";
366      crossover.GetVariableInfo("Operator").ActualName = "Crossover";
367      UniformSequentialSubScopesProcessor individualProc = new UniformSequentialSubScopesProcessor();
368      SequentialProcessor individualSeqProc = new SequentialProcessor();
369      StochasticBranch cond = new StochasticBranch();
370      cond.GetVariableInfo("Probability").ActualName = "MutationRate";
371      OperatorExtractor manipulator = new OperatorExtractor();
372      manipulator.Name = "Manipulator (extr.)";
373      manipulator.GetVariableInfo("Operator").ActualName = "Manipulator";
374      OperatorExtractor evaluator = new OperatorExtractor();
375      evaluator.Name = "Evaluator (extr.)";
376      evaluator.GetVariableInfo("Operator").ActualName = "Evaluator";
377      MeanSquaredErrorEvaluator validationEvaluator = new MeanSquaredErrorEvaluator();
378      validationEvaluator.GetVariableInfo("MSE").ActualName = "ValidationQuality";
379      validationEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
380      validationEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
381      Counter evalCounter = new Counter();
382      evalCounter.GetVariableInfo("Value").ActualName = "EvaluatedSolutions";
383      SubScopesRemover parentRefRemover = new SubScopesRemover();
384
385      Sorter sorter = new Sorter();
386      sorter.GetVariableInfo("Descending").ActualName = "Maximization";
387      sorter.GetVariableInfo("Value").ActualName = "Quality";
388
389
390      seq.AddSubOperator(selector);
391      seq.AddSubOperator(seqScopesProc);
392      seqScopesProc.AddSubOperator(emptyOpt);
393      seqScopesProc.AddSubOperator(selectedProc);
394      selectedProc.AddSubOperator(childInitializer);
395      selectedProc.AddSubOperator(individualProc);
396      individualProc.AddSubOperator(individualSeqProc);
397      individualSeqProc.AddSubOperator(crossover);
398      individualSeqProc.AddSubOperator(cond);
399      cond.AddSubOperator(manipulator);
400      individualSeqProc.AddSubOperator(evaluator);
401      individualSeqProc.AddSubOperator(validationEvaluator);
402      individualSeqProc.AddSubOperator(evalCounter);
403      individualSeqProc.AddSubOperator(parentRefRemover);
404      selectedProc.AddSubOperator(sorter);
405
406      childCreater.OperatorGraph.AddOperator(seq);
407      childCreater.OperatorGraph.InitialOperator = seq;
408      return childCreater;
409    }
410
411    protected internal virtual IAnalyzerModel CreateGPModel(IScope bestModelScope) {
412      Engine.GlobalScope.AddSubScope(bestModelScope);
413      IGeneticProgrammingModel tree = bestModelScope.GetVariableValue<IGeneticProgrammingModel>("FunctionTree", false);
414      ITreeEvaluator evaluator = bestModelScope.GetVariableValue<ITreeEvaluator>("TreeEvaluator", true);
415      IAnalyzerModel model = new AnalyzerModel();
416      model.Predictor = new Predictor(evaluator, tree);
417      Dataset ds = bestModelScope.GetVariableValue<Dataset>("Dataset", true);
418      model.Dataset = ds;
419      model.TargetVariable = ds.GetVariableName(bestModelScope.GetVariableValue<IntData>("TargetVariable", true).Data);
420      model.TrainingSamplesStart = bestModelScope.GetVariableValue<IntData>("TrainingSamplesStart", true).Data;
421      model.TrainingSamplesEnd = bestModelScope.GetVariableValue<IntData>("TrainingSamplesEnd", true).Data;
422      model.ValidationSamplesStart = bestModelScope.GetVariableValue<IntData>("ValidationSamplesStart", true).Data;
423      model.ValidationSamplesEnd = bestModelScope.GetVariableValue<IntData>("ValidationSamplesEnd", true).Data;
424      model.TestSamplesStart = bestModelScope.GetVariableValue<IntData>("TestSamplesStart", true).Data;
425      model.TestSamplesEnd = bestModelScope.GetVariableValue<IntData>("TestSamplesEnd", true).Data;
426
427      model.TrainingMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("Quality", false).Data;
428      model.ValidationMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("ValidationQuality", false).Data;
429      // calculate and set variable impacts
430      VariableEvaluationImpactCalculator evaluationImpactCalculator = new VariableEvaluationImpactCalculator();
431      evaluationImpactCalculator.GetVariableInfo("TrainingSamplesStart").ActualName = "ActualTrainingSamplesStart";
432      evaluationImpactCalculator.GetVariableInfo("TrainingSamplesEnd").ActualName = "ActualTrainingSamplesEnd";
433      VariableQualityImpactCalculator qualityImpactCalculator = new VariableQualityImpactCalculator();
434      qualityImpactCalculator.GetVariableInfo("TrainingSamplesStart").ActualName = "ActualTrainingSamplesStart";
435      qualityImpactCalculator.GetVariableInfo("TrainingSamplesEnd").ActualName = "ActualTrainingSamplesEnd";
436       
437
438      evaluationImpactCalculator.Apply(bestModelScope);
439      qualityImpactCalculator.Apply(bestModelScope);
440
441      ItemList evaluationImpacts = bestModelScope.GetVariableValue<ItemList>("VariableEvaluationImpacts", false);
442      ItemList qualityImpacts = bestModelScope.GetVariableValue<ItemList>("VariableQualityImpacts", false);
443      foreach (ItemList row in evaluationImpacts) {
444        string variableName = ((StringData)row[0]).Data;
445        double impact = ((DoubleData)row[1]).Data;
446        model.SetVariableEvaluationImpact(variableName, impact);
447        model.AddInputVariable(variableName);
448      }
449      foreach (ItemList row in qualityImpacts) {
450        string variableName = ((StringData)row[0]).Data;
451        double impact = ((DoubleData)row[1]).Data;
452        model.SetVariableQualityImpact(variableName, impact);
453        model.AddInputVariable(variableName);
454      }
455      Engine.GlobalScope.RemoveSubScope(bestModelScope);
456      return model;
457    }
458
459    public override object Clone(IDictionary<Guid, object> clonedObjects) {
460      AlgorithmBase clone = (AlgorithmBase)base.Clone(clonedObjects);
461      clonedObjects.Add(Guid, clone);
462      clone.engine = (SequentialEngine.SequentialEngine)Auxiliary.Clone(Engine, clonedObjects);
463      return clone;
464    }
465
466    protected VariableInjector GetVariableInjector() {
467      CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
468      // SequentialProcessor in GP
469      algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
470      return (VariableInjector)algorithm.SubOperators[2];
471    }
472
473    protected RandomInjector GetRandomInjector() {
474      CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
475      // SequentialProcessor in GP
476      algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
477      return (RandomInjector)algorithm.SubOperators[0];
478    }
479
480    #region Persistence Methods
481    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
482      XmlNode node = base.GetXmlNode(name, document, persistedObjects);
483      node.AppendChild(PersistenceManager.Persist("Engine", Engine, document, persistedObjects));
484      return node;
485    }
486    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
487      base.Populate(node, restoredObjects);
488      engine = (SequentialEngine.SequentialEngine)PersistenceManager.Restore(node.SelectSingleNode("Engine"), restoredObjects);
489    }
490    #endregion
491
492
493  }
494}
Note: See TracBrowser for help on using the repository browser.