Changeset 18190 for branches/3136_Structural_GP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression

Timestamp:

01/13/22 11:35:38 (3 years ago)

Author:

mkommend

Message:

#3136:
Added parameters for paramter optimization / linear scaling in StructeredSymRegProblem.
Added license headers to StructureTemplate and StructeredSymRegProblem.
Fixed type in NMSEConstraint evaluator.

Location:

branches/3136_Structural_GP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective

Files:

• Evaluators/NMSESingleObjectiveConstraintsEvaluator.cs (modified) (2 diffs)
• StructuredSymbolicRegressionSingleObjectiveProblem.cs (modified) (13 diffs)

branches/3136_Structural_GP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/NMSESingleObjectiveConstraintsEvaluator.cs

@@ -287 +287 @@
       var parameterEntries = parameters.ToArray(); // order of entries must be the same for x
 
-      // extract inital parameters
+      // extract initial parameters
       double[] c = (double[])initialParameters.Clone();
 
@@ -380 +380 @@
         if (numberTreeNode != null) {
           if (numberTreeNode.Parent.Symbol is Power
-              && numberTreeNode.Parent.GetSubtree(1) == numberTreeNode) continue; // exponents in powers are not optimizated (see TreeToAutoDiffTermConverter)
+              && numberTreeNode.Parent.GetSubtree(1) == numberTreeNode) continue; // exponents in powers are not optimized (see TreeToAutoDiffTermConverter)
           numberTreeNode.Value = parameters[i++];
         } else if (updateVariableWeights && variableTreeNodeBase != null)

branches/3136_Structural_GP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/StructuredSymbolicRegressionSingleObjectiveProblem.cs

@@ -1 @@
-using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
 using System.Linq;
 using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Optimization;
@@ -24 +46 @@
     private const string EstimationLimitsParameterName = "EstimationLimits";
     private const string BestTrainingSolutionParameterName = "Best Training Solution";
+    private const string ApplyLinearScalingParameterName = "Apply Linear Scaling";
+    private const string OptimizeParametersParameterName = "Optimize Parameters";
 
     private const string SymbolicExpressionTreeName = "SymbolicExpressionTree";
@@ -42 +66 @@
     public IFixedValueParameter<DoubleLimit> EstimationLimitsParameter => (IFixedValueParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName];
     public IResultParameter<ISymbolicRegressionSolution> BestTrainingSolutionParameter => (IResultParameter<ISymbolicRegressionSolution>)Parameters[BestTrainingSolutionParameterName];
+
+    public IFixedValueParameter<BoolValue> ApplyLinearScalingParameter => (IFixedValueParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName];
+    public IFixedValueParameter<BoolValue> OptimizeParametersParameter => (IFixedValueParameter<BoolValue>)Parameters[OptimizeParametersParameterName];
     #endregion
 
@@ -64 +91 @@
 
     public DoubleLimit EstimationLimits => EstimationLimitsParameter.Value;
+
+    public bool ApplyLinearScaling {
+      get => ApplyLinearScalingParameter.Value.Value;
+      set => ApplyLinearScalingParameter.Value.Value = value;
+    }
+
+    public bool OptimizeParameters {
+      get => OptimizeParametersParameter.Value.Value;
+      set => OptimizeParametersParameter.Value.Value = value;
+    }
 
     public override bool Maximization => false;
@@ -99 +136 @@
         structureTemplate));
 
+      Parameters.Add(new FixedValueParameter<BoolValue>(
+        ApplyLinearScalingParameterName, new BoolValue(true)
+        ));
+
+      Parameters.Add(new FixedValueParameter<BoolValue>(
+        OptimizeParametersParameterName, new BoolValue(true)
+        ));
+
       Parameters.Add(new ValueParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(
         InterpreterParameterName,
         new SymbolicDataAnalysisExpressionTreeBatchInterpreter()) { Hidden = true });
-
       Parameters.Add(new FixedValueParameter<DoubleLimit>(
         EstimationLimitsParameterName,
         new DoubleLimit(double.NegativeInfinity, double.PositiveInfinity)) { Hidden = true });
-
       Parameters.Add(new ResultParameter<ISymbolicRegressionSolution>(BestTrainingSolutionParameterName, "") { Hidden = true });
 
@@ -116 +159 @@
 
       RegisterEventHandlers();
+
+      StructureTemplate.ApplyLinearScaling = ApplyLinearScaling;
       StructureTemplate.Template =
         "(" +
@@ -137 +182 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(ApplyLinearScalingParameterName)) {
+        Parameters.Add(new FixedValueParameter<BoolValue>(ApplyLinearScalingParameterName, new BoolValue(StructureTemplate.ApplyLinearScaling)));
+      }
+
+      if (!Parameters.ContainsKey(OptimizeParametersParameterName)) {
+        Parameters.Add(new FixedValueParameter<BoolValue>(OptimizeParametersParameterName, new BoolValue(false)));
+      }
+
       RegisterEventHandlers();
     }
@@ -148 +201 @@
 
       ProblemDataParameter.ValueChanged += ProblemDataParameterValueChanged;
+      ApplyLinearScalingParameter.Value.ValueChanged += (o, e) => StructureTemplate.ApplyLinearScaling = ApplyLinearScaling;
+      OptimizeParametersParameter.Value.ValueChanged += (o, e) => {
+        if (OptimizeParameters) ApplyLinearScaling = true;
+      };
+
     }
 
@@ -156 +214 @@
 
     private void OnTemplateChanged(object sender, EventArgs args) {
+      ApplyLinearScaling = StructureTemplate.ApplyLinearScaling;
       SetupEncoding();
     }
@@ -165 +224 @@
       foreach (var subFunction in StructureTemplate.SubFunctions) {
         subFunction.SetupVariables(ProblemData.AllowedInputVariables);
-        // to prevent the same encoding twice
-        if (Encoding.Encodings.Any(x => x.Name == subFunction.Name)) continue; // duplicate subfunction
+        // prevent the same encoding twice
+        if (Encoding.Encodings.Any(x => x.Name == subFunction.Name)) continue;
 
         var encoding = new SymbolicExpressionTreeEncoding(
@@ -196 +255 @@
 
       var tree = (ISymbolicExpressionTree)best[SymbolicExpressionTreeName];
-
       var model = new SymbolicRegressionModel(ProblemData.TargetVariable, tree, Interpreter);
       var solution = model.CreateRegressionSolution(ProblemData);
@@ -227 +285 @@
     }
 
-    private static void AdjustLinearScalingParams(IRegressionProblemData problemData, ISymbolicExpressionTree tree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter) {
-      var offsetNode = tree.Root.GetSubtree(0).GetSubtree(0);
-      var scalingNode = offsetNode.Subtrees.Where(x => !(x is NumberTreeNode)).First();
-
-      var offsetNumberNode = (NumberTreeNode)offsetNode.Subtrees.Where(x => x is NumberTreeNode).First();
-      var scalingNumberNode = (NumberTreeNode)scalingNode.Subtrees.Where(x => x is NumberTreeNode).First();
-
-      var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, problemData.TrainingIndices);
-      var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, problemData.TrainingIndices);
-
-      OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out double a, out double b, out OnlineCalculatorError error);
-      if (error == OnlineCalculatorError.None) {
-        offsetNumberNode.Value = a;
-        scalingNumberNode.Value = b;
-      }
-    }
-
     private static ISymbolicExpressionTree BuildTree(ISymbolicExpressionTree template, Individual individual) {
       var resolvedTree = (ISymbolicExpressionTree)template.Clone();
-
       // build main tree
       foreach (var subFunctionTreeNode in resolvedTree.IterateNodesPrefix().OfType<SubFunctionTreeNode>()) {
@@ -260 +300 @@
     }
 
+    private static void AdjustLinearScalingParams(IRegressionProblemData problemData, ISymbolicExpressionTree tree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter) {
+      var offsetNode = tree.Root.GetSubtree(0).GetSubtree(0);
+      var scalingNode = offsetNode.Subtrees.Where(x => !(x is NumberTreeNode)).First();
+
+      var offsetNumberNode = (NumberTreeNode)offsetNode.Subtrees.Where(x => x is NumberTreeNode).First();
+      var scalingNumberNode = (NumberTreeNode)scalingNode.Subtrees.Where(x => x is NumberTreeNode).First();
+
+      var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, problemData.TrainingIndices);
+      var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, problemData.TrainingIndices);
+
+      OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out double a, out double b, out OnlineCalculatorError error);
+      if (error == OnlineCalculatorError.None) {
+        offsetNumberNode.Value = a;
+        scalingNumberNode.Value = b;
+      }
+    }
+
+
+
+
+
 
     public void Load(IRegressionProblemData data) {