Changeset 17726 for branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4

Timestamp:

08/26/20 16:43:25 (5 years ago)

Author:

pfleck

Message:

#3040 Added a constant opt evaluator for vectors that uses the existing AutoDiff library by unrolling all vector operations.

Location:

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

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj (modified) (1 diff)
• SingleObjective/Evaluators/VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator.cs (copied) (copied from branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/NonlinearLeastSquaresConstantOptimizationEvaluator.cs) (8 diffs)

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj

@@ -141 +141 @@
     <Compile Include="Plugin.cs" />
     <Compile Include="SingleObjective\ConstantOptimizationAnalyzer.cs" />
+    <Compile Include="SingleObjective\Evaluators\VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\NonlinearLeastSquaresConstantOptimizationEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionMeanRelativeErrorEvaluator.cs" />

branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator.cs

@@ -30 +30 @@
 using HeuristicLab.Parameters;
 using HEAL.Attic;
+using DoubleVector = MathNet.Numerics.LinearAlgebra.Vector<double>;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
-  [StorableType("24B68851-036D-4446-BD6F-3823E9028FF4")]
-  [Item("NonlinearLeastSquaresOptimizer", "")]
-  public class NonlinearLeastSquaresConstantOptimizationEvaluator : SymbolicRegressionConstantOptimizationEvaluator {
+  [StorableType("5F8DB251-C6F7-40AC-BC30-3C55AF655A2F")]
+  [Item("VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator", "")]
+  public class VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator : SymbolicRegressionConstantOptimizationEvaluator {
 
     private const string ConstantOptimizationIterationsName = "ConstantOptimizationIterations";
@@ -51 +52 @@
     #endregion
 
-    public NonlinearLeastSquaresConstantOptimizationEvaluator()
+    public VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator()
       : base() {
       Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptimizationIterationsName, "Determines how many iterations should be calculated while optimizing the constant of a symbolic expression tree(0 indicates other or default stopping criterion).", new IntValue(10)));
     }
 
-    protected NonlinearLeastSquaresConstantOptimizationEvaluator(NonlinearLeastSquaresConstantOptimizationEvaluator original, Cloner cloner)
+    protected VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator(VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator original, Cloner cloner)
       : base(original, cloner) {
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new NonlinearLeastSquaresConstantOptimizationEvaluator(this, cloner);
+      return new VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator(this, cloner);
     }
     [StorableConstructor]
-    protected NonlinearLeastSquaresConstantOptimizationEvaluator(StorableConstructorFlag _) : base(_) { }
+    protected VectorUnrollingNonlinearLeastSquaresConstantOptimizationEvaluator(StorableConstructorFlag _) : base(_) { }
 
     protected override ISymbolicExpressionTree OptimizeConstants(
       ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows,
       CancellationToken cancellationToken = default(CancellationToken), EvaluationsCounter counter = null) {
-      return OptimizeTree(tree,
+      return OptimizeTree(tree, (SymbolicDataAnalysisExpressionTreeVectorInterpreter)SymbolicDataAnalysisTreeInterpreterParameter.ActualValue,
         problemData, rows,
         ApplyLinearScalingParameter.ActualValue.Value, ConstantOptimizationIterations, UpdateVariableWeights,
@@ -76 +77 @@
     public static ISymbolicExpressionTree OptimizeTree(
       ISymbolicExpressionTree tree,
+      SymbolicDataAnalysisExpressionTreeVectorInterpreter interpreter,
       IRegressionProblemData problemData, IEnumerable<int> rows,
       bool applyLinearScaling, int maxIterations, bool updateVariableWeights,
       CancellationToken cancellationToken = default(CancellationToken), EvaluationsCounter counter = null, Action<double[], double, object> iterationCallback = null) {
+
+      var vectorLengths = problemData.Dataset.DoubleVectorVariables
+        .SelectMany(var => problemData.Dataset.GetDoubleVectorValues(var, rows))
+        .Select(v => v.Count);
+      var vectorlength = vectorLengths.First();
+      if (vectorLengths.Any(l => l != vectorlength))
+        throw new InvalidOperationException("All vectors must be of same length.");
+      var evaluationTraces = interpreter.GetIntermediateNodeValues(tree, problemData.Dataset, rows);
+      var evaluationTrace = evaluationTraces.First(); // assume all vector lengths are the same
+
 
       // numeric constants in the tree become variables for constant opt
@@ -85 +97 @@
       // variable name, variable value (for factor vars) and lag as a DataForVariable object.
       // A dictionary is used to find parameters
-      bool success = TreeToAutoDiffTermConverter.TryConvertToAutoDiff(
-        tree, updateVariableWeights, applyLinearScaling,
+      bool success = VectorUnrollingTreeToAutoDiffTermConverter.TryConvertToAutoDiff(
+        tree, evaluationTrace,
+        updateVariableWeights, applyLinearScaling,
         out var parameters, out var initialConstants, out var func, out var func_grad);
       if (!success)
@@ -114 +127 @@
           } else if (ds.VariableHasType<string>(info.variableName)) {
             x[row, col] = ds.GetStringValue(info.variableName, r) == info.variableValue ? 1 : 0;
+          } else if (ds.VariableHasType<DoubleVector>(info.variableName)) {
+            x[row, col] = ds.GetDoubleVectorValue(info.variableName, r)[info.index];
           } else throw new InvalidProgramException("found a variable of unknown type");
           col++;
@@ -182 +197 @@
     }
 
-    private static alglib.ndimensional_pfunc CreatePFunc(TreeToAutoDiffTermConverter.ParametricFunction func) {
+    private static alglib.ndimensional_pfunc CreatePFunc(VectorUnrollingTreeToAutoDiffTermConverter.ParametricFunction func) {
       return (double[] c, double[] x, ref double fx, object o) => {
         fx = func(c, x);
@@ -190 +205 @@
     }
 
-    private static alglib.ndimensional_pgrad CreatePGrad(TreeToAutoDiffTermConverter.ParametricFunctionGradient func_grad) {
+    private static alglib.ndimensional_pgrad CreatePGrad(VectorUnrollingTreeToAutoDiffTermConverter.ParametricFunctionGradient func_grad) {
       return (double[] c, double[] x, ref double fx, double[] grad, object o) => {
         var tuple = func_grad(c, x);
@@ -201 +216 @@
 
     public static bool CanOptimizeConstants(ISymbolicExpressionTree tree) {
-      return TreeToAutoDiffTermConverter.IsCompatible(tree);
+      return VectorUnrollingTreeToAutoDiffTermConverter.IsCompatible(tree);
     }
   }