Changes between Version 3 and Version 4 of Documentation/Howto/Implement Genetic Programming Problems

Timestamp:

06/04/12 09:01:21 (12 years ago)

Author:

gkronber

Comment:

more description about the problem

Documentation/Howto/Implement Genetic Programming Problems

@@ -716 +716 @@
 
 === Problem Class ===
-Finally, we implement the {Problem} class. 
+Finally, we implement the {{{Problem}}} class. The {{{Problem}}} holds all necessary information of a lawn mower problem instance. It has multiple parameters which are set to instances of the classes that we implemented so far. 
+
+The parameters for the problem are:
+ * LawnWidth: Width of the lawn (integer, default value: 8)
+ * LawnHeight: Height of the lawn (integer, default value: 8)
+ * MaxProgramLength: Maximal length of the lawn mower program represented as a symbolic expression tree in number of nodes (integer, default value: 13)
+ * MaxProgramDepth: Maximal depth of the lawn mower program represented as a symbolic expression tree (integer, default value: 1000 = no limit)
+ * Grammar: The grammar for lawn mower programs that specifies syntactically correct lawn mower programs (Grammar, default value: new Grammar())
+
+These parameters are created in the constructor of the {{{Problem}}} class. The integer-valued parameters are created as {{{FixedValueParameters}}} to make sure that the contained IntValue instance cannot be replaced. The {{{Problem}}} class also provides properties for the parameters for convenience.
+
+In the {{{Problem}}} constructor we also instantiate our {{{Evaluator}}} for the lawn mower problem and a solution creator for symbolic expression trees (in this case the {{{RampedHalfAndHalfTreeCreator}}}). The solution creator and the {{{Evaluator}}} are necessary for the constructor of the base class ({{{SingleObjectiveHeuristicOptimizationProblem<Evaluator,ISymbolicExpressionTreeCreator>}}}).
+
+At the end of the {{{Problem}}} constructor we set the {{{Maximization}}} property to true (we want to maximize the mowed cells). Finally, we initialize the operators list for algorithms with {{{InitializeOperators()}}}.
+{{{
+#!csharp
+    // default constructor for the problem
+    // also creates the fitness evaluation operator (Evaluator), 
+    // and the tree creation operator (RampedHalfAndHalfTreeCreator)
+    public Problem()
+      : base(new Evaluator(), new RampedHalfAndHalfTreeCreator()) {
+      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 ValueParameter<Grammar>(
+          LawnMowerGrammarParameterName, 
+          "Grammar for the lawn mower program.",
+          new Grammar()));
+      Maximization.Value = true;
+      InitializeOperators();
+    }
+}}}
+
+
+{{{InitializeOperator}}} must create the operators that algorithms can use to solve the problem and add them to the {{{Operators}}} list. Our lawn mower problem uses the symbolic expression tree encoding. Thus we can add all operators for symbolic expression trees. Usually we also want to add some analyzers to generate results but this  is optional. In this case we add a tree-length analyzer, a symbol-frequency analyzer and a best solution analyzer.
+{{{
+#!csharp
+ // ...
+ Operators.AddRange(
+        ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeOperator>());
+ Operators.Add(new MinAverageMaxSymbolicExpressionTreeLengthAnalyzer());
+ Operators.Add(new SymbolicExpressionSymbolFrequencyAnalyzer());
+ Operators.Add(new BestSolutionAnalyzer()); 
+}}}
+
+Next the operators must be configured. The actual parameter names of the operators must match the parameter names of the problem to guarantee that the operator will find the necessary parameter values when executed.
+This operator parameter matching is at the core of all remaining code.
+
+In {{{ParameterizeOperators()}}} we iterate over all kinds of interfaces for symbolic expression tree operators and set the actual names of parameters defined in these interfaces to the names of the parameters supplied by the lawn mower problem.
+{{{
+#!csharp
+    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.ChildParameter.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;
+      }
+    }
+}}}
 
 {{{Problem.cs}}}