Changeset 1262 for branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/AlgorithmBase.cs

Timestamp:

03/05/09 18:32:59 (16 years ago)

Author:

gkronber

Message:

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:

• branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/AlgorithmBase.cs (modified) (7 diffs)

branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/AlgorithmBase.cs

@@ -37 +37 @@
 namespace HeuristicLab.GP.StructureIdentification {
   public abstract class AlgorithmBase : ItemBase {
-    private DoubleData mutationRate = new DoubleData();
     public virtual double MutationRate {
-      get { return mutationRate.Data; }
-      set { mutationRate.Data = value; }
-    }
-    private IntData populationSize = new IntData();
+      get { return GetVariableInjector().GetVariable("MutationRate").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("MutationRate").GetValue<DoubleData>().Data = value; }
+    }
     public virtual int PopulationSize {
-      get { return populationSize.Data; }
-      set {
-        populationSize.Data = value;
-      }
-    }
-
-    private BoolData setSeedRandomly = new BoolData();
+      get { return GetVariableInjector().GetVariable("PopulationSize").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("PopulationSize").GetValue<IntData>().Data = value; }
+    }
+
     public virtual bool SetSeedRandomly {
-      get { return setSeedRandomly.Data; }
-      set { setSeedRandomly.Data = value; }
-    }
-
-    private IntData seed = new IntData();
+      get { return GetRandomInjector().GetVariable("SetSeedRandomly").GetValue<BoolData>().Data; }
+      set { GetRandomInjector().GetVariable("SetSeedRandomly").GetValue<BoolData>().Data = value; }
+    }
+
     public virtual int Seed {
-      get { return seed.Data; }
-      set { seed.Data = value; }
+      get { return GetRandomInjector().GetVariable("Seed").GetValue<IntData>().Data; }
+      set { GetRandomInjector().GetVariable("Seed").GetValue<IntData>().Data = value; }
     }
 
@@ -71 +65 @@
     }
 
-    private IntData elites = new IntData();
     public virtual int Elites {
-      get { return elites.Data; }
-      set { elites.Data = value; }
-    }
-
-    private int maxTreeSize = 50;
+      get { return GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("Elites").GetValue<IntData>().Data = value; }
+    }
+
     public virtual int MaxTreeSize {
-      get { return maxTreeSize; }
-      set { maxTreeSize = value; }
-    }
-
-    private int maxTreeHeight = 8;
+      get { return GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxTreeSize").GetValue<IntData>().Data = value; }
+    }
+
     public virtual int MaxTreeHeight {
-      get { return maxTreeHeight; }
-      set { maxTreeHeight = value; }
-    }
-
-    private IntData parents = new IntData();
+      get { return GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("MaxTreeHeight").GetValue<IntData>().Data = value; }
+    }
+
     public virtual int Parents {
-      get { return parents.Data; }
-      protected set { parents.Data = value; }
-    }
-
-    private double punishmentFactor = 10.0;
-    private bool useEstimatedTargetValue = false;
+      get { return GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data; }
+      set { GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data = value; }
+    }
+
+    public virtual double PunishmentFactor {
+      get { return GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data; }
+      set { GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data = value; }
+    }
+
+    public virtual bool UseEstimatedTargetValue {
+      get { return GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data; }
+      set { GetVariableInjector().GetVariable("UseEstimatedTargetValue").GetValue<BoolData>().Data = value; }
+    }
+
     private IOperator algorithm;
 
@@ -119 +117 @@
 
       RandomInjector randomInjector = new RandomInjector();
-      randomInjector.GetVariable("SetSeedRandomly").Value = setSeedRandomly;
-      randomInjector.GetVariable("Seed").Value = seed;
       randomInjector.Name = "Random Injector";
 
       IOperator globalInjector = CreateGlobalInjector();
       IOperator initialization = CreateInitialization();
-      IOperator funLibInjector = CreateFunctionLibraryInjector(); 
+      IOperator funLibInjector = CreateFunctionLibraryInjector();
       IOperator mainLoop = CreateMainLoop();
       mainLoop.Name = "Main loop";
 
       IOperator treeCreator = CreateTreeCreator();
-      
+
       MeanSquaredErrorEvaluator evaluator = new MeanSquaredErrorEvaluator();
       evaluator.GetVariableInfo("MSE").ActualName = "Quality";
@@ -136 +132 @@
       evaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
       evaluator.Name = "Evaluator";
-      
+
       IOperator crossover = CreateCrossover();
       IOperator manipulator = CreateManipulator();
@@ -180 +176 @@
       injector.Name = "Global Injector";
       injector.AddVariable(new HeuristicLab.Core.Variable("Generations", new IntData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MutationRate", mutationRate));
-      injector.AddVariable(new HeuristicLab.Core.Variable("PopulationSize", populationSize));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Elites", elites));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MutationRate", new DoubleData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("PopulationSize", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("Elites", new IntData()));
       injector.AddVariable(new HeuristicLab.Core.Variable("Maximization", new BoolData(false)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeHeight", new IntData(maxTreeHeight)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeSize", new IntData(maxTreeSize)));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeHeight", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("MaxTreeSize", new IntData()));
       injector.AddVariable(new HeuristicLab.Core.Variable("EvaluatedSolutions", new IntData(0)));
       injector.AddVariable(new HeuristicLab.Core.Variable("TotalEvaluatedNodes", new DoubleData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Parents", parents));
-      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(punishmentFactor)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData(useEstimatedTargetValue)));
+      injector.AddVariable(new HeuristicLab.Core.Variable("Parents", new IntData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData()));
+      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData()));
       return injector;
     }
@@ -392 +388 @@
     }
 
-    #region SetReferences Method
-    private void SetReferences() {
-      // SGA
+    protected VariableInjector GetVariableInjector() {
       CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
-      // SequentialProcessor in SGA
+      // SequentialProcessor in GP
       algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
-      // RandomInjector
-      RandomInjector ri = (RandomInjector)algorithm.SubOperators[1];
-      setSeedRandomly = ri.GetVariable("SetSeedRandomly").GetValue<BoolData>();
-      seed = ri.GetVariable("Seed").GetValue<IntData>();
-      // VariableInjector
-      VariableInjector vi = (VariableInjector)algorithm.SubOperators[2];
-      populationSize = vi.GetVariable("PopulationSize").GetValue<IntData>();
-      mutationRate = vi.GetVariable("MutationRate").GetValue<DoubleData>();
-      elites = vi.GetVariable("Elites").GetValue<IntData>();
-      parents = vi.GetVariable("Parents").GetValue<IntData>();
-    }
-    #endregion
+      return (VariableInjector)algorithm.SubOperators[2];
+    }
+
+    protected RandomInjector GetRandomInjector() {
+      CombinedOperator co1 = (CombinedOperator)Engine.OperatorGraph.InitialOperator;
+      // SequentialProcessor in GP
+      algorithm = (SequentialProcessor)co1.OperatorGraph.InitialOperator;
+      return (RandomInjector)algorithm.SubOperators[1];
+    }
 
     #region Persistence Methods
@@ -420 +411 @@
       base.Populate(node, restoredObjects);
       engine = (SequentialEngine.SequentialEngine)PersistenceManager.Restore(node.SelectSingleNode("Engine"), restoredObjects);
-      SetReferences();
     }
     #endregion