Changeset 12899 for trunk/sources/HeuristicLab.Problems.LawnMower/3.4/Problem.cs

Timestamp:

08/25/15 14:18:07 (9 years ago)

Author:

gkronber

Message:

#2422: ported lawn mower problem to use BasicProblem and SymbolicExpressionTreeEncoding

Location:

trunk/sources/HeuristicLab.Problems.LawnMower/3.4

Files:

• . (copied) (copied from trunk/sources/HeuristicLab.Problems.LawnMower/3.3)
• Problem.cs (modified) (5 diffs)

trunk/sources/HeuristicLab.Problems.LawnMower/3.4/Problem.cs

@@ -30 +30 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.LawnMower {
@@ -35 +36 @@
   [Creatable(CreatableAttribute.Categories.GeneticProgrammingProblems, Priority = 160)]
   [Item("Lawn Mower Problem", "The lawn mower demo problem for genetic programming.")]
-  public class Problem : SingleObjectiveHeuristicOptimizationProblem<Evaluator, ISymbolicExpressionTreeCreator> {
+  public class Problem : SymbolicExpressionTreeProblem {
     private const string LawnWidthParameterName = "LawnWidth";
     private const string LawnLengthParameterName = "LawnLength";
-    private const string LawnMowerProgramParameterName = "Program";
-    private const string MaxLawnMowerProgramLengthParameterName = "MaxProgramLength";
-    private const string MaxLawnMowerProgramDepthParameterName = "MaxProgramDepth";
-    private const string LawnMowerGrammarParameterName = "Grammar";
-    private const string MaxFunctionDefinitionsParameterName = "MaxFunctionDefinitions";
-    private const string MaxArgumentDefinitionsParameterName = "MaxArgumentDefinitions";
 
     public IFixedValueParameter<IntValue> LawnWidthParameter {
@@ -51 +46 @@
       get { return (IFixedValueParameter<IntValue>)Parameters[LawnLengthParameterName]; }
     }
-    public IFixedValueParameter<IntValue> MaxLawnMowerProgramLengthParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[MaxLawnMowerProgramLengthParameterName]; }
-    }
-    public IFixedValueParameter<IntValue> MaxLawnMowerProgramDepthParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[MaxLawnMowerProgramDepthParameterName]; }
-    }
-    public IValueParameter<Grammar> GrammarParameter {
-      get { return (IValueParameter<Grammar>)Parameters[LawnMowerGrammarParameterName]; }
-    }
-    public IFixedValueParameter<IntValue> MaxFunctionDefinitionsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[MaxFunctionDefinitionsParameterName]; }
-    }
-    public IFixedValueParameter<IntValue> MaxArgumentDefinitionsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[MaxArgumentDefinitionsParameterName]; }
+
+    public override bool Maximization {
+      get { return true; }
     }
 
@@ -73 +57 @@
     protected Problem(Problem original, Cloner cloner)
       : base(original, cloner) {
-      RegisterEventHandlers();
     }
     public Problem()
-      : base(new Evaluator(), new RampedHalfAndHalfTreeCreator()) {
+      : base() {
       Parameters.Add(new FixedValueParameter<IntValue>(LawnWidthParameterName, "Width of the lawn.", new IntValue(8)));
       Parameters.Add(new FixedValueParameter<IntValue>(LawnLengthParameterName, "Length of the lawn.", new IntValue(8)));
-      Parameters.Add(new FixedValueParameter<IntValue>(MaxLawnMowerProgramDepthParameterName, "Maximal depth of the lawn mower program.", new IntValue(13)));
-      Parameters.Add(new FixedValueParameter<IntValue>(MaxLawnMowerProgramLengthParameterName, "Maximal length of the lawn mower program.", new IntValue(1000)));
-      Parameters.Add(new FixedValueParameter<IntValue>(MaxFunctionDefinitionsParameterName, "Maximal number of automatically defined functions (ADF).", new IntValue(3)));
-      Parameters.Add(new FixedValueParameter<IntValue>(MaxArgumentDefinitionsParameterName, "Maximal number of automatically defined arguments.", new IntValue(3)));
-      Parameters.Add(new ValueParameter<Grammar>(LawnMowerGrammarParameterName, "Grammar for the lawn mower program.",
-                     new Grammar()));
-      Maximization.Value = true;
 
-      GrammarParameter.Value.MaximumFunctionDefinitions = MaxFunctionDefinitionsParameter.Value.Value;
-      GrammarParameter.Value.MaximumFunctionArguments = MaxArgumentDefinitionsParameter.Value.Value;
+      var g = new SimpleSymbolicExpressionGrammar();
+      g.AddSymbols(new string[] { "Sum", "Prog" }, 2, 2);
+      g.AddSymbols(new string[] { "Frog" }, 1, 1);
+      g.AddTerminalSymbols(new string[] { "Left", "Forward" });
+      // initialize 20 ephemeral random constants in [0..32[
+      var fastRand = new FastRandom(314159);
+      for (int i = 0; i < 20; i++) {
+        g.AddTerminalSymbol(string.Format("{0},{1}", fastRand.Next(0, 32), fastRand.Next(0, 32)));
+      }
 
-      InitializeOperators();
-      RegisterEventHandlers();
+      Encoding = new SymbolicExpressionTreeEncoding(g, 1000, 17);
+    }
+
+    public override void Analyze(ISymbolicExpressionTree[] trees, double[] qualities, ResultCollection results, IRandom random) {
+      const string bestSolutionResultName = "Best Solution";
+      var bestQuality = Maximization ? qualities.Max() : qualities.Min();
+      var bestIdx = Array.IndexOf(qualities, bestQuality);
+
+      if (!results.ContainsKey(bestSolutionResultName)) {
+        results.Add(new Result(bestSolutionResultName, new Solution(trees[bestIdx], LawnLengthParameter.Value.Value, LawnWidthParameter.Value.Value, bestQuality)));
+      } else if (((Solution)(results[bestSolutionResultName].Value)).Quality < qualities[bestIdx]) {
+        results[bestSolutionResultName].Value = new Solution(trees[bestIdx], LawnLengthParameter.Value.Value, LawnWidthParameter.Value.Value, bestQuality);
+      }
     }
 
 
     [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      RegisterEventHandlers();
+    private void AfterDeserialization() { }
+
+    public override double Evaluate(ISymbolicExpressionTree tree, IRandom random) {
+      var length = LawnLengthParameter.Value.Value;
+      var width = LawnWidthParameter.Value.Value;
+
+      var lawn = Interpreter.EvaluateLawnMowerProgram(length, width, tree);
+      // count number of squares that have been mowed
+      int numberOfMowedCells = 0;
+      for (int i = 0; i < length; i++)
+        for (int j = 0; j < width; j++)
+          if (lawn[i, j]) {
+            numberOfMowedCells++;
+          }
+      return numberOfMowedCells;
     }
 
@@ -103 +110 @@
       return new Problem(this, cloner);
     }
-
-    private void InitializeOperators() {
-      Operators.AddRange(ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeOperator>());
-      Operators.Add(new MinAverageMaxSymbolicExpressionTreeLengthAnalyzer());
-      Operators.Add(new SymbolicExpressionSymbolFrequencyAnalyzer());
-      Operators.Add(new BestSolutionAnalyzer());
-      ParameterizeOperators();
-      ParameterizeAnalyzers();
-    }
-
-
-    private void RegisterEventHandlers() {
-      Evaluator.QualityParameter.ActualNameChanged += QualityParameterOnActualNameChanged;
-      SolutionCreator.SymbolicExpressionTreeParameter.ActualNameChanged +=
-        SymbolicExpressionTreeParameterOnActualNameChanged;
-      MaxArgumentDefinitionsParameter.ValueChanged += ParameterizeGrammar;
-      MaxFunctionDefinitionsParameter.ValueChanged += ParameterizeGrammar;
-    }
-
-    protected override void OnEvaluatorChanged() {
-      Evaluator.LawnMowerProgramParameter.ActualName = LawnMowerProgramParameterName;
-      Evaluator.LawnLengthParameter.ActualName = LawnLengthParameterName;
-      Evaluator.LawnWidthParameter.ActualName = LawnWidthParameterName;
-      Evaluator.QualityParameter.ActualNameChanged += QualityParameterOnActualNameChanged;
-      ParameterizeAnalyzers();
-      ParameterizeOperators();
-      base.OnEvaluatorChanged();
-    }
-
-    protected override void OnSolutionCreatorChanged() {
-      SolutionCreator.SymbolicExpressionTreeParameter.ActualName = LawnMowerProgramParameterName;
-      SolutionCreator.SymbolicExpressionTreeParameter.ActualNameChanged += SymbolicExpressionTreeParameterOnActualNameChanged;
-      ParameterizeAnalyzers();
-      ParameterizeOperators();
-      base.OnSolutionCreatorChanged();
-    }
-
-    private void SymbolicExpressionTreeParameterOnActualNameChanged(object sender, EventArgs eventArgs) {
-      ParameterizeAnalyzers();
-      ParameterizeOperators();
-    }
-
-    private void QualityParameterOnActualNameChanged(object sender, EventArgs eventArgs) {
-      ParameterizeAnalyzers();
-      ParameterizeOperators();
-    }
-
-    private void ParameterizeGrammar(object sender, EventArgs eventArgs) {
-      GrammarParameter.Value.MaximumFunctionArguments = MaxArgumentDefinitionsParameter.Value.Value;
-      GrammarParameter.Value.MaximumFunctionDefinitions = MaxFunctionDefinitionsParameter.Value.Value;
-    }
-
-    private void ParameterizeAnalyzers() {
-      var analyzers = Operators.OfType<IAnalyzer>();
-      foreach (var o in analyzers.OfType<ISymbolicExpressionTreeAnalyzer>()) {
-        o.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
-      }
-      foreach (var o in analyzers.OfType<BestSolutionAnalyzer>()) {
-        o.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
-      }
-    }
-
-    private void ParameterizeOperators() {
-      var operators = Parameters
-        .OfType<IValueParameter>()
-        .Select(p => p.Value)
-        .OfType<IOperator>()
-        .Union(Operators);
-      foreach (var o in operators.OfType<ISymbolicExpressionTreeGrammarBasedOperator>()) {
-        o.SymbolicExpressionTreeGrammarParameter.ActualName = LawnMowerGrammarParameterName;
-      }
-      foreach (var o in operators.OfType<ISymbolicExpressionTreeSizeConstraintOperator>()) {
-        o.MaximumSymbolicExpressionTreeDepthParameter.ActualName = MaxLawnMowerProgramDepthParameterName;
-        o.MaximumSymbolicExpressionTreeLengthParameter.ActualName = MaxLawnMowerProgramLengthParameterName;
-      }
-      foreach (var op in operators.OfType<Evaluator>()) {
-        op.LawnMowerProgramParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
-        op.LawnLengthParameter.ActualName = LawnLengthParameterName;
-        op.LawnWidthParameter.ActualName = LawnWidthParameterName;
-      }
-      foreach (var op in operators.OfType<ISymbolicExpressionTreeCrossover>()) {
-        op.ParentsParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
-        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
-      }
-      foreach (var op in operators.OfType<ISymbolicExpressionTreeManipulator>()) {
-        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
-      }
-      foreach (var op in operators.OfType<ISymbolicExpressionTreeCreator>()) {
-        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
-      }
-      foreach (ISymbolicExpressionTreeArchitectureAlteringOperator op in operators.OfType<ISymbolicExpressionTreeArchitectureAlteringOperator>()) {
-        op.MaximumFunctionDefinitionsParameter.ActualName = MaxFunctionDefinitionsParameter.Name;
-        op.MaximumFunctionArgumentsParameter.ActualName = MaxArgumentDefinitionsParameter.Name;
-      }
-    }
   }
 }