Changeset 17602 for branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/VectorTreeSimplifier.cs

Timestamp:

06/16/20 11:21:34 (4 years ago)

Author:

pfleck

Message:

#3040

• Changed stddev, variance, etc. to population variant
• Added multiplicative simplifications for stdev and variance symbols

File:

• branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/VectorTreeSimplifier.cs (modified) (5 diffs)

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/VectorTreeSimplifier.cs

@@ -62 +62 @@
     private static readonly Mean meanSymbol = new Mean();
     private static readonly Length lengthSymbol = new Length();
+    private static readonly StandardDeviation standardDeviationSymbol = new StandardDeviation();
+    private static readonly Variance varianceSymbol = new Variance();
 
     private readonly SymbolicDataAnalysisExpressionTreeVectorInterpreter interpreter;
@@ -271 +273 @@
     private static bool IsLength(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Length;
+    }
+
+    private static bool IsStandardDeviation(ISymbolicExpressionTreeNode node) {
+      return node.Symbol is StandardDeviation;
+    }
+
+    private static bool IsVariance(ISymbolicExpressionTreeNode node) {
+      return node.Symbol is Variance;
     }
     #endregion
@@ -351 +361 @@
       } else if (IsLength(original)) {
         return SimplifyLengthAggregation(original);
+      } else if (IsStandardDeviation(original)) {
+        return SimplifyStandardDeviationAggregation(original);
+      } else if (IsVariance(original)) {
+        return SimplifyVarianceAggregation(original);
       } else {
         return SimplifyAny(original);
@@ -554 +568 @@
     private ISymbolicExpressionTreeNode SimplifyLengthAggregation(ISymbolicExpressionTreeNode original) {
       return MakeLengthAggregation(GetSimplifiedTree(original.GetSubtree(0)));
+    }
+
+    private ISymbolicExpressionTreeNode SimplifyStandardDeviationAggregation(ISymbolicExpressionTreeNode original) {
+      return MakeStandardDeviationAggregation(GetSimplifiedTree(original.GetSubtree(0)));
+    }
+
+    private ISymbolicExpressionTreeNode SimplifyVarianceAggregation(ISymbolicExpressionTreeNode original) {
+      return MakeVarianceAggregation(GetSimplifiedTree(original.GetSubtree(0)));
     }
     #endregion
@@ -1561 +1583 @@
     }
 
+    private ISymbolicExpressionTreeNode MakeStandardDeviationAggregation(ISymbolicExpressionTreeNode node) {
+      if (IsConstant(node)) {
+        return MakeConstant(0.0);
+      } else if (IsMultiplication(node) || IsDivision(node)) {
+        var factors = node.Subtrees;
+        if (IsDivision(node)) factors = InvertNodes(factors, Invert);
+
+        var scalarFactors = factors.Where(IsScalarNode).ToList();
+        var remainingFactors = factors.Except(scalarFactors).ToList();
+
+        if (scalarFactors.Any() && remainingFactors.Any()) {
+          var scalarNode = scalarFactors.Aggregate(MakeProduct);
+          var vectorNode = remainingFactors.Aggregate(MakeProduct);
+
+          var stdevNode = MakeStandardDeviationAggregation(vectorNode);
+
+          return MakeProduct(scalarNode, stdevNode);
+        } else if (scalarFactors.Any()) {
+          var scalarNode = scalarFactors.Aggregate(MakeProduct);
+          return scalarNode;
+        } else if (remainingFactors.Any()) {
+          var vectorNode = remainingFactors.Aggregate(MakeProduct);
+          var stdevNode = standardDeviationSymbol.CreateTreeNode();
+          stdevNode.AddSubtree(vectorNode);
+          return stdevNode;
+        } else
+          throw new InvalidOperationException("Multiplication does not contain any terms to simplify.");
+      } else if (IsVariableBase(node)) { // weight is like multiplication
+        var variableNode = (VariableTreeNodeBase)node;
+        var weight = variableNode.Weight;
+        variableNode.Weight = 1.0;
+        var stdevNode = standardDeviationSymbol.CreateTreeNode();
+        stdevNode.AddSubtree(node);
+        return MakeProduct(MakeConstant(weight), stdevNode);
+      } else {
+        var stdevNode = standardDeviationSymbol.CreateTreeNode();
+        stdevNode.AddSubtree(node);
+        return stdevNode;
+      }
+    }
+
+    private ISymbolicExpressionTreeNode MakeVarianceAggregation(ISymbolicExpressionTreeNode node) {
+      if (IsConstant(node)) {
+        return MakeConstant(0.0);
+      } else if (IsMultiplication(node) || IsDivision(node)) {
+        var factors = node.Subtrees;
+        if (IsDivision(node)) factors = InvertNodes(factors, Invert);
+
+        var scalarFactors = factors.Where(IsScalarNode).ToList();
+        var remainingFactors = factors.Except(scalarFactors).ToList();
+
+        if (scalarFactors.Any() && remainingFactors.Any()) {
+          var scalarNode = scalarFactors.Aggregate(MakeProduct);
+          var vectorNode = remainingFactors.Aggregate(MakeProduct);
+
+          var varNode = MakeVarianceAggregation(vectorNode);
+
+          return MakeProduct(MakeSquare(scalarNode), varNode);
+        } else if (scalarFactors.Any()) {
+          var scalarNode = scalarFactors.Aggregate(MakeProduct);
+          return MakeSquare(scalarNode);
+        } else if (remainingFactors.Any()) {
+          var vectorNode = remainingFactors.Aggregate(MakeProduct);
+          var varNode = varianceSymbol.CreateTreeNode();
+          varNode.AddSubtree(vectorNode);
+          return varNode;
+        } else
+          throw new InvalidOperationException("Multiplication does not contain any terms to simplify.");
+      } else if (IsVariableBase(node)) { // weight is like multiplication
+        var variableNode = (VariableTreeNodeBase)node;
+        var weight = variableNode.Weight;
+        variableNode.Weight = 1.0;
+        var varNode = varianceSymbol.CreateTreeNode();
+        varNode.AddSubtree(node);
+        return MakeProduct(MakeSquare(MakeConstant(weight)), varNode);
+      } else {
+        var varNode = varianceSymbol.CreateTreeNode();
+        varNode.AddSubtree(node);
+        return varNode;
+      }
+    }
     #endregion