Changeset 17604 for branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic

Timestamp:

06/17/20 11:23:37 (4 years ago)

Author:

pfleck

Message:

#3040 Stores the datatype of a tree node (e.g. variable nodes) in the tree itself for the interpreter to derive the datatypes for subtrees. This way, the interpreter (and simplifier) do not need an actual dataset to figure out datatypes for subtrees.

Location:

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• Converters/VectorTreeSimplifier.cs (modified) (3 diffs)
• Grammars/TypeCoherentVectorExpressionGrammar.cs (modified) (3 diffs)
• Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs (modified) (2 diffs)
• Symbols/ConstantTreeNode.cs (modified) (2 diffs)
• Symbols/FactorVariableTreeNode.cs (modified) (1 diff)
• Symbols/VariableBase.cs (modified) (2 diffs)
• Symbols/VariableTreeNodeBase.cs (modified) (2 diffs)

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

@@ -27 +27 @@
 using HeuristicLab.Common;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+
+using DoubleVector = MathNet.Numerics.LinearAlgebra.Vector<double>;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -66 +68 @@
 
     private readonly SymbolicDataAnalysisExpressionTreeVectorInterpreter interpreter;
-    private readonly IDataAnalysisProblemData problemData;
-
-    public VectorTreeSimplifier(SymbolicDataAnalysisExpressionTreeVectorInterpreter interpreter, IDataAnalysisProblemData problemData) {
+
+    public VectorTreeSimplifier(SymbolicDataAnalysisExpressionTreeVectorInterpreter interpreter) {
       this.interpreter = interpreter;
-      this.problemData = problemData;
     }
 
@@ -286 +286 @@
     #region type predicates
     public bool IsScalarNode(ISymbolicExpressionTreeNode node) {
-      var results = interpreter.EvaluateNode(node, problemData.Dataset, problemData.TrainingIndices);
-      return results.All(r => r.IsScalar);
+      return interpreter.GetNodeType(node) == typeof(double);
     }
     public bool IsVectorNode(ISymbolicExpressionTreeNode node) {
-      var results = interpreter.EvaluateNode(node, problemData.Dataset, problemData.TrainingIndices);
-      return results.All(r => r.IsVector);
+      return interpreter.GetNodeType(node) == typeof(DoubleVector);
     }
     #endregion

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentVectorExpressionGrammar.cs

@@ -130 +130 @@
       var powerSymbols = new GroupSymbol(PowerFunctionsName, new List<ISymbol> { square, sqrt, cube, cubeRoot, power, root });
       var terminalSymbols = new GroupSymbol(TerminalsName, new List<ISymbol> { constant, variable, binFactorVariable, factorVariable });
-      var statisticsSymbols = new GroupSymbol(VectorStatisticsName, new List<ISymbol> {mean, sd, sum, length, min, max, variance, skewness, kurtosis});
+      var statisticsSymbols = new GroupSymbol(VectorStatisticsName, new List<ISymbol> { mean, sd, sum, length, min, max, variance, skewness, kurtosis });
       var distancesSymbols = new GroupSymbol(VectorDistancesName, new List<ISymbol> { euclideanDistance, covariance });
       var aggregationSymbols = new GroupSymbol(VectorAggregationName, new List<ISymbol> { statisticsSymbols, distancesSymbols });
@@ -217 +217 @@
           varSymbol.AllVariableNames = problemData.InputVariables.Select(x => x.Value).Where(x => dataset.VariableHasType<double>(x));
           varSymbol.VariableNames = problemData.AllowedInputVariables.Where(x => dataset.VariableHasType<double>(x));
+          varSymbol.VariableDataType = typeof(double);
         }
       }
@@ -223 +224 @@
           varSymbol.AllVariableNames = problemData.InputVariables.Select(x => x.Value).Where(x => dataset.VariableHasType<DoubleVector>(x));
           varSymbol.VariableNames = problemData.AllowedInputVariables.Where(x => dataset.VariableHasType<DoubleVector>(x));
+          varSymbol.VariableDataType = typeof(DoubleVector);
         }
       }

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs

@@ -46 +46 @@
       Exception
     }
+
+    #region Aggregation Symbols
+    private static Type[] AggregationSymbols = new[] {
+      typeof(Sum), typeof(Mean), typeof(Length), typeof(StandardDeviation), typeof(Variance),
+      typeof(EuclideanDistance), typeof(Covariance)
+    };
+    #endregion
 
     private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
@@ -254 +261 @@
     }
 
-    public virtual IEnumerable<EvaluationResult> EvaluateNode(ISymbolicExpressionTreeNode node, IDataset dataset, IEnumerable<int> rows) {
-      //lock (syncRoot) {
-      //  EvaluatedSolutions++; // increment the evaluated solutions counter
-      //}
-
-      var startNode = new StartSymbol().CreateTreeNode();
-      startNode.AddSubtree(node);
-      var programNode = new ProgramRootSymbol().CreateTreeNode();
-      programNode.AddSubtree(startNode);
-      var tree = new SymbolicExpressionTree(programNode);
-
-      var state = PrepareInterpreterState(tree, dataset);
-
-      foreach (var rowEnum in rows) {
-        int row = rowEnum;
-        var result = Evaluate(dataset, ref row, state);
-        yield return result;
-        state.Reset();
-      }
+    public virtual Type GetNodeType(ISymbolicExpressionTreeNode node) {
+      if (node.DataType != null)
+        return node.DataType;
+
+      if (AggregationSymbols.Contains(node.Symbol.GetType()))
+        return typeof(double);
+
+      var argumentTypes = node.Subtrees.Select(GetNodeType);
+      if (argumentTypes.Any(t => t == typeof(DoubleVector)))
+        return typeof(DoubleVector);
+
+      return typeof(double);
     }
 

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/ConstantTreeNode.cs

@@ -20 +20 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -37 +38 @@
       get { return constantValue; }
       set { constantValue = value; }
+    }
+
+    public override Type DataType {
+      get { return typeof(double); }
     }
 

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/FactorVariableTreeNode.cs

@@ -44 +44 @@
       get { return variableName; }
       set { variableName = value; }
+    }
+
+    public override Type DataType {
+      get { return typeof(double); }
     }
 

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableBase.cs

@@ -142 +142 @@
       get { return maximumArity; }
     }
+
+    [Storable]
+    private Type variableDataType;
+    public Type VariableDataType {
+      get { return variableDataType; }
+      set {
+        if (variableDataType == value) return;
+        variableDataType = value;
+        OnChanged(EventArgs.Empty);
+      }
+    }
     #endregion
 
@@ -166 +177 @@
       multiplicativeWeightManipulatorSigma = original.multiplicativeWeightManipulatorSigma;
       variableChangeProbability = original.variableChangeProbability;
+      variableDataType = original.variableDataType;
     }
     protected VariableBase(string name, string description)

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableTreeNodeBase.cs

@@ -20 +20 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -42 +43 @@
       get { return variableName; }
       set { variableName = value; }
+    }
+
+    public override Type DataType {
+      get { return Symbol.VariableDataType; }
     }