Changeset 17303 for branches/2994-AutoDiffForIntervals/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/VectorAutoDiffEvaluator.cs

Timestamp:

10/03/19 12:30:19 (5 years ago)

Author:

gkronber

Message:

#2994 continued refactoring and extended unit tests. Interval calculation still fails for some edge cases (mainly for undefined behaviour). VectorEvaluator and VectorAutoDiffEvaluator produce the same results as the LinearInterpreter. TODO: check gradient calculation

File:

• branches/2994-AutoDiffForIntervals/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/VectorAutoDiffEvaluator.cs (modified) (5 diffs)

branches/2994-AutoDiffForIntervals/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/VectorAutoDiffEvaluator.cs

@@ -5 +5 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  public sealed class VectorAutoDiffEvaluator : InterpreterBase<MultivariateDual<AlgebraicDoubleVector>> {
+  public sealed class VectorAutoDiffEvaluator : InterpreterBase<VectorOfAlgebraic<MultivariateDual<AlgebraicDouble>>> {
     private const int BATCHSIZE = 128;
     [ThreadStatic]
@@ -57 +57 @@
       for (rowIndex = 0; rowIndex < roundedTotal; rowIndex += BATCHSIZE) {
         Evaluate(code);
-        code[0].value.Value.CopyTo(fi, rowIndex, BATCHSIZE);
 
-        // TRANSPOSE into JAC
-        var g = code[0].value.Gradient;
-        for (int j = 0; j < nParams; ++j) {
-          if (g.Elements.TryGetValue(j, out AlgebraicDoubleVector v)) {
-            v.CopyColumnTo(jac, j, rowIndex, BATCHSIZE);
-          } else {
-            for (int r = 0; r < BATCHSIZE; r++) jac[rowIndex + r, j] = 0.0;
+        // code[0].value.Value.CopyTo(fi, rowIndex, BATCHSIZE);
+        var v = code[0].value;
+        for (int k = 0; k < BATCHSIZE; k++) {
+          fi[rowIndex + k] = v[k].Value.Value;
+
+          // copy gradient to Jacobian
+          var g = v[k].Gradient;
+          for (int j = 0; j < nParams; ++j) {
+            if (g.Elements.TryGetValue(j, out AlgebraicDouble gj)) {
+              jac[rowIndex + k, j] = gj.Value;
+            } else {
+              jac[rowIndex + k, j] = 0.0;
+            }
           }
         }
@@ -72 +77 @@
       if (remainingRows > 0) {
         Evaluate(code);
-        code[0].value.Value.CopyTo(fi, roundedTotal, remainingRows);
+        // code[0].value.Value.CopyTo(fi, roundedTotal, remainingRows);
+        var v = code[0].value;
+        for (int k = 0; k < remainingRows; k++) {
+          fi[roundedTotal + k] = v[k].Value.Value;
 
-        var g = code[0].value.Gradient;
-        for (int j = 0; j < nParams; ++j)
-          if (g.Elements.TryGetValue(j, out AlgebraicDoubleVector v)) {
-            v.CopyColumnTo(jac, j, roundedTotal, remainingRows);
-          } else {
-            for (int r = 0; r < remainingRows; r++) jac[roundedTotal + r, j] = 0.0;
+          var g = v[k].Gradient;
+          for (int j = 0; j < nParams; ++j) {
+            if (g.Elements.TryGetValue(j, out AlgebraicDouble gj)) {
+              jac[roundedTotal + k, j] = gj.Value;
+            } else {
+              jac[roundedTotal + k, j] = 0.0;
+            }
           }
+        }
       }
     }
 
     protected override void InitializeInternalInstruction(ref Instruction instruction, ISymbolicExpressionTreeNode node) {
-      var zero = new AlgebraicDoubleVector(BATCHSIZE);
-      instruction.value = new MultivariateDual<AlgebraicDoubleVector>(zero);
+      instruction.value = new VectorOfAlgebraic<MultivariateDual<AlgebraicDouble>>(BATCHSIZE).Zero; // XXX zero needed?
     }
 
     protected override void InitializeTerminalInstruction(ref Instruction instruction, ConstantTreeNode constant) {
-      var g_arr = new double[BATCHSIZE];
       if (node2paramIdx.TryGetValue(constant, out var paramIdx)) {
-        for (int i = 0; i < BATCHSIZE; i++) g_arr[i] = 1.0;
-        var g = new AlgebraicDoubleVector(g_arr);
-        instruction.value = new MultivariateDual<AlgebraicDoubleVector>(new AlgebraicDoubleVector(BATCHSIZE), paramIdx, g); // only a single column for the gradient
+        instruction.value = new VectorOfAlgebraic<MultivariateDual<AlgebraicDouble>>(BATCHSIZE);
+        for (int k = 0; k < BATCHSIZE; k++) {
+          instruction.value[k] = new MultivariateDual<AlgebraicDouble>(constant.Value, paramIdx, 1.0); // gradient is 1.0 for all elements
+        }
       } else {
-        instruction.value = new MultivariateDual<AlgebraicDoubleVector>(new AlgebraicDoubleVector(BATCHSIZE));
+        instruction.value = new VectorOfAlgebraic<MultivariateDual<AlgebraicDouble>>(BATCHSIZE);
+        for (int k = 0; k < BATCHSIZE; k++) {
+          instruction.value[k] = new MultivariateDual<AlgebraicDouble>(constant.Value); // zero gradient
+        }
       }
 
-      instruction.dblVal = constant.Value;
-      instruction.value.Value.AssignConstant(instruction.dblVal);
+      instruction.dblVal = constant.Value; // also store the parameter value in the instruction (not absolutely necessary, will not be used)
     }
 
@@ -115 +126 @@
       if (node2paramIdx.ContainsKey(variable)) {
         paramIdx = node2paramIdx[variable];
-        var f = new AlgebraicDoubleVector(BATCHSIZE);
-        var g = new AlgebraicDoubleVector(BATCHSIZE);
-        instruction.value = new MultivariateDual<AlgebraicDoubleVector>(f, paramIdx, g);
+        instruction.value = new VectorOfAlgebraic<MultivariateDual<AlgebraicDouble>>(BATCHSIZE);
+        for(int k=0;k<BATCHSIZE;k++) {
+          instruction.value[k] = new MultivariateDual<AlgebraicDouble>(0.0, paramIdx, 0.0); // values are set in LoadVariable()
+        }
       } else {
         var f = new AlgebraicDoubleVector(BATCHSIZE);
-        instruction.value = new MultivariateDual<AlgebraicDoubleVector>(f);
+        instruction.value = new VectorOfAlgebraic<MultivariateDual<AlgebraicDouble>>(BATCHSIZE);
+        for (int k = 0; k < BATCHSIZE; k++) {
+          instruction.value[k] = new MultivariateDual<AlgebraicDouble>(0.0); // values are set in LoadVariable()
+        }
       }
 
-      instruction.dblVal = variable.Weight;
+      instruction.dblVal = variable.Weight; 
       instruction.data = new object[] { data, paramIdx };
     }
@@ -131 +146 @@
       var data = (double[])((object[])a.data)[0];
 
-      for (int i = rowIndex; i < rows.Length && i - rowIndex < BATCHSIZE; i++) a.value.Value[i - rowIndex] = data[rows[i]];
-      a.value.Scale(a.dblVal);
+      for (int i = rowIndex; i < rows.Length && i - rowIndex < BATCHSIZE; i++) {
+        a.value[i - rowIndex].Value.Assign(a.dblVal * data[rows[i]]);
+      }
 
       if (paramIdx >= 0) {
         // update gradient with variable values
-        var g = a.value.Gradient.Elements[paramIdx];
         for (int i = rowIndex; i < rows.Length && i - rowIndex < BATCHSIZE; i++) {
-          g[i - rowIndex] = data[rows[i]];
+          a.value[i - rowIndex].Gradient.Elements[paramIdx].Assign(data[rows[i]]);
         }
       }