Changeset 1230 for branches/CEDMA-Refactoring-Ticket419

Timestamp:

02/26/09 13:54:45 (16 years ago)

Author:

gkronber

Message:

Added a base class for GP algorithms. (#419 Refactor CEDMA plugins)

Location:

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

Files:

• AlgorithmBase.cs (added)
• HeuristicLab.GP.StructureIdentification.csproj (modified) (1 diff)
• StandardGP.cs (modified) (5 diffs)

branches/CEDMA-Refactoring-Ticket419/HeuristicLab.GP.StructureIdentification/HeuristicLab.GP.StructureIdentification.csproj

@@ -71 +71 @@
     <Compile Include="BakedTreeEvaluator.cs" />
     <Compile Include="Constant.cs" />
+    <Compile Include="AlgorithmBase.cs" />
     <Compile Include="FunctionLibraryInjector.cs" />
     <Compile Include="OffspringSelectionGP.cs" />

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

@@ -36 +36 @@
 
 namespace HeuristicLab.GP.StructureIdentification {
-  public class StandardGP : ItemBase, IEditable {
+  public class StandardGP : AlgorithmBase {
+
     private IntData maxGenerations = new IntData();
     public int MaxGenerations {
@@ -48 +49 @@
       set { tournamentSize.Data = value; }
     }
-    private DoubleData mutationRate = new DoubleData();
-    public double MutationRate {
-      get { return mutationRate.Data; }
-      set { mutationRate.Data = value; }
-    }
-    private IntData parents = new IntData();
-    private IntData populationSize = new IntData();
-    public int PopulationSize {
-      get { return populationSize.Data; }
-      set {
-        populationSize.Data = value;
-        parents.Data = value * 2;
-      }
-    }
-
-    private BoolData setSeedRandomly = new BoolData();
-    public bool SetSeedRandomly {
-      get { return setSeedRandomly.Data; }
-      set { setSeedRandomly.Data = value; }
-    }
-
-    private IntData seed = new IntData();
-    public int Seed {
-      get { return seed.Data; }
-      set { seed.Data = value; }
-    }
-
-    public IOperator ProblemInjector {
-      get { return algorithm.SubOperators[0]; }
-      set {
-        value.Name = "ProblemInjector";
-        algorithm.RemoveSubOperator(0);
-        algorithm.AddSubOperator(value, 0);
-      }
-    }
-
-    private IntData elites = new IntData();
-    public int Elites {
-      get { return elites.Data; }
-      set { elites.Data = value; }
-    }
-
-    private int maxTreeSize = 50;
-    public int MaxTreeSize {
-      get { return maxTreeSize; }
-      set { maxTreeSize = value; }
-    }
-
-    private int maxTreeHeight = 8;
-    public int MaxTreeHeight {
-      get { return maxTreeHeight; }
-      set { maxTreeHeight = value; }
-    }
-    private double punishmentFactor = 10.0;
-    private bool useEstimatedTargetValue = false;
-    private double fullTreeShakingFactor = 0.1;
-    private double onepointShakingFactor = 1.0;
-    private IOperator algorithm;
-
-    private SequentialEngine.SequentialEngine engine;
-    public IEngine Engine {
-      get { return engine; }
-    }
-
-    public StandardGP() {
+
+    public StandardGP() : base() {
       PopulationSize = 10000;
       MaxGenerations = 100;
@@ -121 +59 @@
       MaxTreeHeight = 10;
       engine = new SequentialEngine.SequentialEngine();
-      CombinedOperator algo = CreateAlgorithm();
+      IOperator algo = CreateAlgorithm();
       engine.OperatorGraph.AddOperator(algo);
       engine.OperatorGraph.InitialOperator = algo;
     }
 
-    private CombinedOperator CreateAlgorithm() {
-      CombinedOperator algo = new CombinedOperator();
-      algo.Name = "StandardGP";
-      SequentialProcessor seq = new SequentialProcessor();
-      EmptyOperator problemInjectorPlaceholder = new EmptyOperator();
-      RandomInjector randomInjector = new RandomInjector();
-      randomInjector.GetVariable("SetSeedRandomly").Value = setSeedRandomly;
-      randomInjector.GetVariable("Seed").Value = seed;
-      randomInjector.Name = "Random Injector";
-      VariableInjector globalInjector = CreateGlobalInjector();
-      CombinedOperator initialization = CreateInitialization();
-      initialization.Name = "Initialization";
-      FunctionLibraryInjector funLibInjector = new FunctionLibraryInjector();
-      CombinedOperator mainLoop = CreateMainLoop();
-      mainLoop.Name = "Main loop";
-
-      ProbabilisticTreeCreator treeCreator = new ProbabilisticTreeCreator();
-      treeCreator.Name = "Tree generator";
-      treeCreator.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-      treeCreator.GetVariableInfo("MinTreeSize").Local = true;
-      treeCreator.AddVariable(new HeuristicLab.Core.Variable("MinTreeSize", new IntData(3)));
-      MeanSquaredErrorEvaluator evaluator = new MeanSquaredErrorEvaluator();
-      evaluator.GetVariableInfo("MSE").ActualName = "Quality";
-      evaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
-      evaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
-      evaluator.Name = "Evaluator";
-      StandardCrossOver crossover = new StandardCrossOver();
-      crossover.Name = "Crossover";
-      crossover.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
-      CombinedOperator manipulator = CreateManipulator();
-      manipulator.Name = "Manipulator";
+    override IOperator CreateSelector()  {
       TournamentSelector selector = new TournamentSelector();
       selector.Name = "Selector";
@@ -163 +71 @@
       selector.RemoveVariable("GroupSize");
       selector.GetVariableInfo("GroupSize").ActualName = "TournamentSize";
-      LeftReducer cleanUp = new LeftReducer();
-
-      seq.AddSubOperator(problemInjectorPlaceholder);
-      seq.AddSubOperator(randomInjector);
-      seq.AddSubOperator(globalInjector);
-      seq.AddSubOperator(funLibInjector);
-      seq.AddSubOperator(initialization);
-      seq.AddSubOperator(mainLoop);
-      seq.AddSubOperator(cleanUp);
-
-      initialization.AddSubOperator(treeCreator);
-      initialization.AddSubOperator(evaluator);
-
-      mainLoop.AddSubOperator(selector);
-      mainLoop.AddSubOperator(crossover);
-      mainLoop.AddSubOperator(manipulator);
-      mainLoop.AddSubOperator(evaluator);
-      algo.OperatorGraph.AddOperator(seq);
-      algo.OperatorGraph.InitialOperator = seq;
-      this.algorithm = seq;
-      return algo;
-    }
-
-    private VariableInjector CreateGlobalInjector() {
-      VariableInjector injector = new VariableInjector();
-      injector.Name = "Global Injector";
-      injector.AddVariable(new HeuristicLab.Core.Variable("Generations", new IntData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MaxGenerations", maxGenerations));
-      injector.AddVariable(new HeuristicLab.Core.Variable("MutationRate", mutationRate));
-      injector.AddVariable(new HeuristicLab.Core.Variable("PopulationSize", populationSize));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Parents", parents));
-      injector.AddVariable(new HeuristicLab.Core.Variable("Elites", elites));
-      injector.AddVariable(new HeuristicLab.Core.Variable("TournamentSize", tournamentSize));
-      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("EvaluatedSolutions", new IntData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("TotalEvaluatedNodes", new DoubleData(0)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData(punishmentFactor)));
-      injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData(useEstimatedTargetValue)));
-      return injector;
-    }
-
-    private CombinedOperator CreateManipulator() {
+      return selector;
+    }
+
+
+    override IOperator CreateCrossover() {
+      StandardCrossOver crossover = new StandardCrossOver();
+      crossover.Name = "Crossover";
+      crossover.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
+      return crossover;
+    }
+
+    override IOperator CreateTreeCreator() {
+      ProbabilisticTreeCreator treeCreator = new ProbabilisticTreeCreator();
+      treeCreator.Name = "Tree generator";
+      treeCreator.GetVariableInfo("OperatorLibrary").ActualName = "FunctionLibrary";
+      treeCreator.GetVariableInfo("MinTreeSize").Local = true;
+      treeCreator.AddVariable(new HeuristicLab.Core.Variable("MinTreeSize", new IntData(3)));
+      return treeCreator;
+    }
+
+    override IOperator CreateFunctionLibraryInjector() {
+      return new FunctionLibraryInjector();
+    }
+
+    override IOperator CreateManipulator()  {
       CombinedOperator manipulator = new CombinedOperator();
+      manipulator.Name = "Manipulator";
       StochasticMultiBranch multibranch = new StochasticMultiBranch();
       FullTreeShaker fullTreeShaker = new FullTreeShaker();
@@ -245 +135 @@
       manipulator.OperatorGraph.InitialOperator = multibranch;
       return manipulator;
+    }
+
+    override IOperator CreateBestSolutionProcessor() {
+      SequentialProcessor bestSolutionProcessor = new SequentialProcessor();
+      MeanAbsolutePercentageErrorEvaluator trainingMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
+      trainingMapeEvaluator.Name = "TrainingMapeEvaluator";
+      trainingMapeEvaluator.GetVariableInfo("MAPE").ActualName = "TrainingMAPE";
+      trainingMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "TrainingSamplesStart";
+      trainingMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "TrainingSamplesEnd";
+      MeanAbsolutePercentageErrorEvaluator validationMapeEvaluator = new MeanAbsolutePercentageErrorEvaluator();
+      validationMapeEvaluator.Name = "ValidationMapeEvaluator";
+      validationMapeEvaluator.GetVariableInfo("MAPE").ActualName = "ValidationMAPE";
+      validationMapeEvaluator.GetVariableInfo("SamplesStart").ActualName = "ValidationSamplesStart";
+      validationMapeEvaluator.GetVariableInfo("SamplesEnd").ActualName = "ValidationSamplesEnd";
+      ProgrammableOperator progOperator = new ProgrammableOperator();
+      progOperator.RemoveVariableInfo("Result");
+      progOperator.AddVariableInfo(new HeuristicLab.Core.VariableInfo("EvaluatedSolutions", "", typeof(IntData), VariableKind.In));
+      progOperator.Code = @"
+int evalSolutions = EvaluatedSolutions.Data;
+scope.AddVariable(new Variable(""EvaluatedSolutions"", new IntData(evalSolutions)));
+";
+      bestSolutionProcessor.AddSubOperator(trainingMapeEvaluator);
+      bestSolutionProcessor.AddSubOperator(validationMapeEvaluator);
+      bestSolutionProcessor.AddSubOperator(progOperator);
+      return bestSolutionProcessor;
     }