Changeset 18071

Timestamp:

10/20/21 14:39:46 (3 years ago)

Author:

dpiringe

Message:

#3136

• added linear scaling logic in Evaluate and (for UI reasons) Analyze
• added logic forSubFunctionSymbol (modified OpCodes) -> the SubFunctionTreeNode is display in the tree but has no effect on evaluation (works like a flag)
  • works now with SymbolicDataAnalysisExpressionTreeInterpreter
• default grammar for SubFunction is now ArithmeticExpressionGrammar instead of LinearScalingGrammar

Location:

branches/3136_Structural_GP

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/StructuredSymbolicRegressionSingleObjectiveProblem.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/StructureTemplate/StructureTemplateView.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/StructureTemplate/StructureTemplate.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/StructureTemplate/SubFunction.cs (modified) (1 diff)

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

@@ -49 +49 @@
     }
 
+    public ISymbolicDataAnalysisExpressionTreeInterpreter Interpreter { get; } = new SymbolicDataAnalysisExpressionTreeInterpreter();
+
     IParameter IDataAnalysisProblem.ProblemDataParameter => ProblemDataParameter;
     IDataAnalysisProblemData IDataAnalysisProblem.ProblemData => ProblemData;
@@ -110 +112 @@
       }
 
-      if (results.TryGetValue("Best Tree", out IResult result))
-        result.Value = BuildTree(individuals[bestIdx]);
-      else
-        results.Add(new Result("Best Tree", BuildTree(individuals[bestIdx])));
+      if (results.TryGetValue("Best Tree", out IResult result)) {
+        var tree = BuildTree(individuals[bestIdx]);
+        AdjustLinearScalingParams(tree, Interpreter);
+        result.Value = tree;
+      }
+      else {
+        var tree = BuildTree(individuals[bestIdx]);
+        AdjustLinearScalingParams(tree, Interpreter);
+        results.Add(new Result("Best Tree", tree));
+      }
+        
     }
 
     public override double Evaluate(Individual individual, IRandom random) {
       var tree = BuildTree(individual);
-      var interpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
+
+      AdjustLinearScalingParams(tree, Interpreter);
       var estimationInterval = ProblemData.VariableRanges.GetInterval(ProblemData.TargetVariable);
       var quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(
-        interpreter, tree, 
+        Interpreter, tree, 
         estimationInterval.LowerBound, estimationInterval.UpperBound, 
         ProblemData, ProblemData.TrainingIndices, false);
      
       return quality;
+    }
+
+    private void AdjustLinearScalingParams(ISymbolicExpressionTree tree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter) {
+      var offsetNode = tree.Root.GetSubtree(0).GetSubtree(0);
+      var scalingNode = offsetNode.Subtrees.Where(x => !(x is ConstantTreeNode)).First();
+
+      var offsetConstantNode = (ConstantTreeNode)offsetNode.Subtrees.Where(x => x is ConstantTreeNode).First();
+      var scalingConstantNode = (ConstantTreeNode)scalingNode.Subtrees.Where(x => x is ConstantTreeNode).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) {
+        offsetConstantNode.Value = a;
+        scalingConstantNode.Value = b;
+      }
     }
 
@@ -136 +163 @@
           var subFunctionTreeNode = n as SubFunctionTreeNode;
           var subFunctionTree = individual.SymbolicExpressionTree(subFunctionTreeNode.Name);
-          var parent = n.Parent;
+          //var parent = n.Parent;
 
           // remove SubFunctionTreeNode
-          parent.RemoveSubtree(parent.IndexOfSubtree(subFunctionTreeNode));
+          //parent.RemoveSubtree(parent.IndexOfSubtree(subFunctionTreeNode));
 
           // add new tree
           var subTree = subFunctionTree.Root.GetSubtree(0)  // Start
                                             .GetSubtree(0); // Offset
-          parent.AddSubtree(subTree);
+          //parent.AddSubtree(subTree);
+          subFunctionTreeNode.AddSubtree(subTree);
         }
       }

branches/3136_Structural_GP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/StructureTemplate/StructureTemplateView.cs

@@ -33 +33 @@
       if(visualTreeNode != null) {
         var subFunctionTreeNode = visualTreeNode.Content as SubFunctionTreeNode;
-        if(Content.SubFunctions.TryGetValue(subFunctionTreeNode.Name, out SubFunction subFunction))
+        if(subFunctionTreeNode != null && Content.SubFunctions.TryGetValue(subFunctionTreeNode.Name, out SubFunction subFunction))
           viewHost.Content = subFunction;
       }
@@ -55 +55 @@
       infoLabel.ForeColor = Color.DarkOrange;
     }
-
 
     private void PaintTree() {

branches/3136_Structural_GP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

@@ -79 +79 @@
     CubeRoot = 51,
     Tanh = 52,
+    SubFunction = 53
   };
   public static class OpCodes {
@@ -134 +135 @@
     public const byte CubeRoot = (byte)OpCode.CubeRoot;
     public const byte Tanh = (byte)OpCode.Tanh;
-
+    public const byte SubFunction = (byte)OpCode.SubFunction;
 
     private static Dictionary<Type, byte> symbolToOpcode = new Dictionary<Type, byte>() {
-       { typeof(Addition), OpCodes.Add },
+      { typeof(Addition), OpCodes.Add },
       { typeof(Subtraction), OpCodes.Sub },
       { typeof(Multiplication), OpCodes.Mul },
@@ -189 +190 @@
       { typeof(AnalyticQuotient), OpCodes.AnalyticQuotient },
       { typeof(Cube), OpCodes.Cube },
-      { typeof(CubeRoot), OpCodes.CubeRoot }
+      { typeof(CubeRoot), OpCodes.CubeRoot },
+      { typeof(SubFunctionSymbol), OpCodes.SubFunction }
     };
 

branches/3136_Structural_GP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs

@@ -528 +528 @@
             }
           }
+        case OpCodes.SubFunction: {
+            return Evaluate(dataset, ref row, state);
+          }
         default:
           throw new NotSupportedException();

branches/3136_Structural_GP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/StructureTemplate/StructureTemplate.cs

@@ -46 +46 @@
       set {
         applyLinearScaling = value;
-        //subFunctions = GetSubFunctions();
         OnChanged();
       }

branches/3136_Structural_GP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/StructureTemplate/SubFunction.cs

@@ -52 +52 @@
     #region Constructors
     public SubFunction() {
-      Parameters.Add(new ValueParameter<ISymbolicDataAnalysisGrammar>(GrammarParameterName, new LinearScalingGrammar()));
-      Parameters.Add(new FixedValueParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, new IntValue(10)));
-      Parameters.Add(new FixedValueParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, new IntValue(30)));
+      Parameters.Add(new ValueParameter<ISymbolicDataAnalysisGrammar>(GrammarParameterName, new ArithmeticExpressionGrammar()));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, new IntValue(8)));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, new IntValue(20)));
 
-      // TODO: separate events for each parameter
       GrammarParameter.ValueChanged += OnParameterValueChanged;
       MaximumSymbolicExpressionTreeDepthParameter.Value.ValueChanged += OnParameterValueChanged;