Changeset 17325 for branches/2994-AutoDiffForIntervals/HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Extensions/ConstrainedNLSInternal.cs

Timestamp:

10/09/19 11:13:11 (5 years ago)

Author:

gkronber

Message:

#2994: worked on ConstrainedNLS

File:

• branches/2994-AutoDiffForIntervals/HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Extensions/ConstrainedNLSInternal.cs (modified) (15 diffs)

branches/2994-AutoDiffForIntervals/HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Extensions/ConstrainedNLSInternal.cs

@@ -6 +6 @@
 using HeuristicLab.Common;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Extensions;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
@@ -40 +41 @@
     private double[] bestConstraintValues;
     public double[] BestConstraintValues => bestConstraintValues;
+
+    private bool disposed = false;
 
 
@@ -120 +123 @@
       }
 
+      // all trees are linearly scaled (to improve GP performance)
       #region linear scaling
       var predStDev = pred.StandardDeviationPop();
@@ -134 +138 @@
 
       // convert constants to variables named theta...
-      var treeForDerivation = ReplaceConstWithVar(scaledTree, out List<string> thetaNames, out thetaValues); // copies the tree
+      var treeForDerivation = ReplaceAndExtractParameters(scaledTree, out List<string> thetaNames, out thetaValues); // copies the tree
 
       // create trees for relevant derivatives
@@ -220 +224 @@
 
     ~ConstrainedNLSInternal() {
-      Dispose();
-    }
-
-
-    internal void Optimize() {
+      Dispose(false);
+    }
+
+
+    public enum OptimizationMode { ReadOnly, UpdateParameters, UpdateParametersAndKeepLinearScaling };
+
+    internal void Optimize(OptimizationMode mode) {
       if (invalidProblem) return;
       var x = thetaValues.ToArray();  /* initial guess */
@@ -233 +239 @@
         // throw new InvalidOperationException($"NLOpt failed {res} {NLOpt.nlopt_get_errmsg(nlopt)}");
         return;
-      } else if (minf <= bestError) {
+      } else /*if ( minf <= bestError ) */{
         bestSolution = x;
         bestError = minf;
@@ -245 +251 @@
 
         // update parameters in tree
-        var pIdx = 0;
-        // here we lose the two last parameters (for linear scaling)
-        foreach (var node in scaledTree.IterateNodesPostfix()) {
-          if (node is ConstantTreeNode constTreeNode) {
-            constTreeNode.Value = x[pIdx++];
-          } else if (node is VariableTreeNode varTreeNode) {
-            varTreeNode.Weight = x[pIdx++];
-          }
-        }
-        if (pIdx != x.Length) throw new InvalidProgramException();
-      }
-      bestTree = scaledTree;
-    }
+        UpdateParametersInTree(scaledTree, x);
+
+        if (mode == OptimizationMode.UpdateParameters) {
+          // update original expression (when called from evaluator we want to write back optimized parameters)
+          expr.Root.GetSubtree(0).RemoveSubtree(0); // delete old tree
+          expr.Root.GetSubtree(0).InsertSubtree(0,
+            scaledTree.Root.GetSubtree(0).GetSubtree(0).GetSubtree(0).GetSubtree(0) // insert the optimized sub-tree (without scaling nodes)
+            );
+        } else if (mode == OptimizationMode.UpdateParametersAndKeepLinearScaling) {
+          expr.Root.GetSubtree(0).RemoveSubtree(0); // delete old tree
+          expr.Root.GetSubtree(0).InsertSubtree(0, scaledTree.Root.GetSubtree(0).GetSubtree(0)); // insert the optimized sub-tree (including scaling nodes)
+        }
+      }
+      bestTree = expr;
+    }
+
 
     double CalculateObjective(uint dim, double[] curX, double[] grad, IntPtr data) {
@@ -314 +323 @@
       }
 
-      // UpdateBestSolution(sse / target.Length, curX);
+      UpdateBestSolution(sse / target.Length, curX);
       RaiseFunctionEvaluated();
 
@@ -427 +436 @@
       UpdateConstraintViolations(constraintData.Idx, interval.UpperBound);
       if (double.IsNaN(interval.UpperBound)) {
-        if(grad!=null)Array.Clear(grad, 0, grad.Length);
+        if (grad != null) Array.Clear(grad, 0, grad.Length);
         return double.MaxValue;
       } else return interval.UpperBound;
@@ -463 +472 @@
     }
 
-    private static void UpdateConstants(ISymbolicExpressionTreeNode[] nodes, double[] constants) {
-      if (nodes.Length != constants.Length) throw new InvalidOperationException();
-      for (int i = 0; i < nodes.Length; i++) {
-        if (nodes[i] is VariableTreeNode varNode) varNode.Weight = constants[i];
-        else if (nodes[i] is ConstantTreeNode constNode) constNode.Value = constants[i];
-      }
-    }
 
     private NLOpt.nlopt_algorithm GetSolver(string solver) {
@@ -514 +516 @@
     }
 
+    // determines the nodes over which we can calculate the partial derivative
+    // this is different from the vector of all parameters because not every tree contains all parameters
     private static ISymbolicExpressionTreeNode[] GetParameterNodes(ISymbolicExpressionTree tree, List<ConstantTreeNode>[] allNodes) {
       // TODO better solution necessary
@@ -553 +557 @@
     }
 
-    private static ISymbolicExpressionTree ReplaceConstWithVar(ISymbolicExpressionTree tree, out List<string> thetaNames, out List<double> thetaValues) {
+
+
+
+    private void UpdateParametersInTree(ISymbolicExpressionTree scaledTree, double[] x) {
+      var pIdx = 0;
+      // here we lose the two last parameters (for linear scaling)
+      foreach (var node in scaledTree.IterateNodesPostfix()) {
+        if (node is ConstantTreeNode constTreeNode) {
+          constTreeNode.Value = x[pIdx++];
+        } else if (node is VariableTreeNode varTreeNode) {
+          if (varTreeNode.Weight != 1.0) // see ReplaceAndExtractParameters
+            varTreeNode.Weight = x[pIdx++];
+        }
+      }
+      if (pIdx != x.Length) throw new InvalidProgramException();
+    }
+
+    private static ISymbolicExpressionTree ReplaceAndExtractParameters(ISymbolicExpressionTree tree, out List<string> thetaNames, out List<double> thetaValues) {
       thetaNames = new List<string>();
       thetaValues = new List<double>();
@@ -578 +599 @@
         }
         if (node is VariableTreeNode varTreeNode) {
+          if (varTreeNode.Weight == 1) continue; // NOTE: here we assume that we do not tune variable weights when they are originally exactly 1 because we assume that the tree has been parsed and the tree explicitly has the structure w * var
+
           var thetaVar = (VariableTreeNode)new Problems.DataAnalysis.Symbolic.Variable().CreateTreeNode();
           thetaVar.Weight = 1;
@@ -626 +649 @@
 
     public void Dispose() {
+      Dispose(true);
+      GC.SuppressFinalize(this);
+    }
+
+    protected virtual void Dispose(bool disposing) {
+      if (disposed)
+        return;
+
+      if (disposing) {
+        // Free any other managed objects here.
+      }
+
+      // Free any unmanaged objects here.
       if (nlopt != IntPtr.Zero) {
         NLOpt.nlopt_destroy(nlopt);
@@ -637 +673 @@
           }
       }
+
+      disposed = true;
     }
     #endregion