Changeset 8823 for trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective

Timestamp:

10/19/12 15:00:31 (12 years ago)

Author:

mkommend

Message:

#1976: Updated constant optimization evaluator to allow optimization of subtraction and added a parameter stating if constants should be updated in the tree.

File:

• trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionConstantOptimizationEvaluator.cs (modified) (10 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionConstantOptimizationEvaluator.cs

@@ -39 +39 @@
     private const string ConstantOptimizationProbabilityParameterName = "ConstantOptimizationProbability";
     private const string ConstantOptimizationRowsPercentageParameterName = "ConstantOptimizationRowsPercentage";
+    private const string UpdateConstantsInTreeParameterName = "UpdateConstantsInSymbolicExpressionTree";
 
     private const string EvaluatedTreesResultName = "EvaluatedTrees";
@@ -62 +63 @@
       get { return (IFixedValueParameter<PercentValue>)Parameters[ConstantOptimizationRowsPercentageParameterName]; }
     }
+    public IFixedValueParameter<BoolValue> UpdateConstantsInTreeParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateConstantsInTreeParameterName]; }
+    }
 
     public IntValue ConstantOptimizationIterations {
@@ -74 +78 @@
     public PercentValue ConstantOptimizationRowsPercentage {
       get { return ConstantOptimizationRowsPercentageParameter.Value; }
+    }
+    public bool UpdateConstantsInTree {
+      get { return UpdateConstantsInTreeParameter.Value.Value; }
+      set { UpdateConstantsInTreeParameter.Value.Value = value; }
     }
 
@@ -91 +99 @@
       Parameters.Add(new FixedValueParameter<PercentValue>(ConstantOptimizationProbabilityParameterName, "Determines the probability that the constants are optimized", new PercentValue(1), true));
       Parameters.Add(new FixedValueParameter<PercentValue>(ConstantOptimizationRowsPercentageParameterName, "Determines the percentage of the rows which should be used for constant optimization", new PercentValue(1), true));
+      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateConstantsInTreeParameterName, "Determines if the constants in the tree should be overwritten by the optimized constants.", new BoolValue(true)));
 
       Parameters.Add(new LookupParameter<IntValue>(EvaluatedTreesResultName));
@@ -98 +107 @@
     public override IDeepCloneable Clone(Cloner cloner) {
       return new SymbolicRegressionConstantOptimizationEvaluator(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(UpdateConstantsInTreeParameterName))
+        Parameters.Add(new FixedValueParameter<BoolValue>(UpdateConstantsInTreeParameterName, "Determines if the constants in the tree should be overwritten by the optimized constants.", new BoolValue(true)));
     }
 
@@ -108 +123 @@
         quality = OptimizeConstants(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, ProblemDataParameter.ActualValue,
            constantOptimizationRows, ApplyLinearScalingParameter.ActualValue.Value, ConstantOptimizationIterations.Value,
-           EstimationLimitsParameter.ActualValue.Upper, EstimationLimitsParameter.ActualValue.Lower,
+           EstimationLimitsParameter.ActualValue.Upper, EstimationLimitsParameter.ActualValue.Lower, UpdateConstantsInTree,
           EvaluatedTreesParameter.ActualValue, EvaluatedTreeNodesParameter.ActualValue);
         if (ConstantOptimizationRowsPercentage.Value != RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value) {
@@ -157 +172 @@
     }
 
+    #region derivations of functions
     // create function factory for arctangent
     private readonly Func<Term, UnaryFunc> arctan = UnaryFunc.Factory(
-        x => Math.Atan(x),      // evaluate
-        x => 1 / (1 + x * x));  // derivative of atan
-
+      eval: Math.Atan,
+      diff: x => 1 / (1 + x * x));
     private static readonly Func<Term, UnaryFunc> sin = UnaryFunc.Factory(
-      x => Math.Sin(x),
-      x => Math.Cos(x));
+      eval: Math.Sin,
+      diff: Math.Cos);
     private static readonly Func<Term, UnaryFunc> cos = UnaryFunc.Factory(
-      x => Math.Cos(x),
-      x => -Math.Sin(x));
+       eval: Math.Cos,
+       diff: x => -Math.Sin(x));
     private static readonly Func<Term, UnaryFunc> tan = UnaryFunc.Factory(
-      x => Math.Tan(x),
-      x => 1 + Math.Tan(x) * Math.Tan(x));
+      eval: Math.Tan,
+      diff: x => 1 + Math.Tan(x) * Math.Tan(x));
     private static readonly Func<Term, UnaryFunc> square = UnaryFunc.Factory(
-      x => x * x,
-      x => 2 * x);
+       eval: x => x * x,
+       diff: x => 2 * x);
     private static readonly Func<Term, UnaryFunc> erf = UnaryFunc.Factory(
-      x => alglib.errorfunction(x),
-      x => 2.0 * Math.Exp(-(x * x)) / Math.Sqrt(Math.PI));
-
+      eval: alglib.errorfunction,
+      diff: x => 2.0 * Math.Exp(-(x * x)) / Math.Sqrt(Math.PI));
     private static readonly Func<Term, UnaryFunc> norm = UnaryFunc.Factory(
-      x => alglib.normaldistribution(x),
-      x => -(Math.Exp(-(x * x)) * Math.Sqrt(Math.Exp(x * x)) * x) / Math.Sqrt(2 * Math.PI)
-      );
+      eval: alglib.normaldistribution,
+      diff: x => -(Math.Exp(-(x * x)) * Math.Sqrt(Math.Exp(x * x)) * x) / Math.Sqrt(2 * Math.PI));
+    #endregion
 
 
     public static double OptimizeConstants(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree tree, IRegressionProblemData problemData,
-      IEnumerable<int> rows, bool applyLinearScaling, int maxIterations, double upperEstimationLimit = double.MaxValue, double lowerEstimationLimit = double.MinValue, IntValue evaluatedTrees = null, IntValue evaluatedTreeNodes = null) {
+      IEnumerable<int> rows, bool applyLinearScaling, int maxIterations, double upperEstimationLimit = double.MaxValue, double lowerEstimationLimit = double.MinValue, bool updateConstantsInTree = true, IntValue evaluatedTrees = null, IntValue evaluatedTreeNodes = null) {
 
       List<AutoDiff.Variable> variables = new List<AutoDiff.Variable>();
@@ -249 +263 @@
         return 0.0;
       }
+      var newTree = tree;
+      if (!updateConstantsInTree) newTree = (ISymbolicExpressionTree)tree.Clone();
       {
         // only when no error occurred
         // set constants in tree
         int i = 2;
-        foreach (var node in terminalNodes) {
+        foreach (var node in newTree.Root.IterateNodesPrefix().OfType<SymbolicExpressionTreeTerminalNode>()) {
           ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
           VariableTreeNode variableTreeNode = node as VariableTreeNode;
@@ -261 +277 @@
             variableTreeNode.Weight = c[i++];
         }
-      }
-
-      return SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, tree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling);
+
+      }
+      return SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, newTree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling);
     }
 
@@ -310 +326 @@
             return false;
           }
+          terms.Add(t);
+        }
+        term = AutoDiff.TermBuilder.Sum(terms);
+        return true;
+      }
+      if (node.Symbol is Subtraction) {
+        List<AutoDiff.Term> terms = new List<Term>();
+        for (int i = 0; i < node.SubtreeCount; i++) {
+          AutoDiff.Term t;
+          if (!TryTransformToAutoDiff(node.GetSubtree(i), variables, parameters, variableNames, out t)) {
+            term = null;
+            return false;
+          }
+          if (i > 0) t = -t;
           terms.Add(t);
         }