Changeset 12658 for branches/GBT-trunkintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees

Timestamp:

07/07/15 17:42:24 (9 years ago)

Author:

gkronber

Message:

#2261: made TreeNode immutable and prevent change of TreeNode[] tree in RegressionTreeModel
ToString() override to make debugging easier and to enable inspection in unit test

Location:

branches/GBT-trunkintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees

Files:

• RegressionTreeBuilder.cs (modified) (3 diffs)
• RegressionTreeModel.cs (modified) (3 diffs)

branches/GBT-trunkintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeBuilder.cs

@@ -207 +207 @@
         Debug.Assert(endIdx < internalIdx.Length);
 
-        // transform the leaf node into an internal node
-        tree[f.ParentNodeIdx].VarName = f.SplittingVariable;
-        tree[f.ParentNodeIdx].Val = f.SplittingThreshold;
-
         // split partition into left and right
         int splitIdx;
@@ -218 +214 @@
 
         // create two leaf nodes (and enqueue best splits for both)
-        tree[f.ParentNodeIdx].LeftIdx = CreateLeafNode(startIdx, splitIdx, lineSearch);
-        tree[f.ParentNodeIdx].RightIdx = CreateLeafNode(splitIdx + 1, endIdx, lineSearch);
+        var leftTreeIdx = CreateLeafNode(startIdx, splitIdx, lineSearch);
+        var rightTreeIdx = CreateLeafNode(splitIdx + 1, endIdx, lineSearch);
+
+        // overwrite existing leaf node with an internal node
+        tree[f.ParentNodeIdx] = new RegressionTreeModel.TreeNode(f.SplittingVariable, f.SplittingThreshold, leftTreeIdx, rightTreeIdx);
       }
     }
@@ -226 +225 @@
     // returns the index of the newly created tree node
     private int CreateLeafNode(int startIdx, int endIdx, LineSearchFunc lineSearch) {
-      tree[curTreeNodeIdx].VarName = RegressionTreeModel.TreeNode.NO_VARIABLE;
-      tree[curTreeNodeIdx].Val = lineSearch(internalIdx, startIdx, endIdx);
+      // write a leaf node
+      var val = lineSearch(internalIdx, startIdx, endIdx);
+      tree[curTreeNodeIdx] = new RegressionTreeModel.TreeNode(RegressionTreeModel.TreeNode.NO_VARIABLE, val);
 
       EnqueuePartitionSplit(curTreeNodeIdx, startIdx, endIdx);

branches/GBT-trunkintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs

@@ -21 +21 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
+using System.Text;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -31 +34 @@
   [StorableClass]
   [Item("RegressionTreeModel", "Represents a decision tree for regression.")]
-  public class RegressionTreeModel : NamedItem, IRegressionModel {
+  public sealed class RegressionTreeModel : NamedItem, IRegressionModel {
 
     // trees are represented as a flat array
-    public struct TreeNode {
+    internal struct TreeNode {
       public readonly static string NO_VARIABLE = string.Empty;
-      public string VarName { get; set; } // name of the variable for splitting or NO_VARIABLE if terminal node
-      public double Val { get; set; } // threshold
-      public int LeftIdx { get; set; }
-      public int RightIdx { get; set; }
 
+      public TreeNode(string varName, double val, int leftIdx = -1, int rightIdx = -1)
+        : this() {
+        VarName = varName;
+        Val = val;
+        LeftIdx = leftIdx;
+        RightIdx = rightIdx;
+      }
+
+      public string VarName { get; private set; } // name of the variable for splitting or NO_VARIABLE if terminal node
+      public double Val { get; private set; } // threshold
+      public int LeftIdx { get; private set; }
+      public int RightIdx { get; private set; }
+
+      // necessary because the default implementation of GetHashCode for structs in .NET would only return the hashcode of val here
       public override int GetHashCode() {
         return LeftIdx ^ RightIdx ^ Val.GetHashCode();
+      }
+      // necessary because of GetHashCode override
+      public override bool Equals(object obj) {
+        if (obj is TreeNode) {
+          var other = (TreeNode)obj;
+          return Val.Equals(other.Val) &&
+            VarName.Equals(other.VarName) &&
+            LeftIdx.Equals(other.LeftIdx) &&
+            RightIdx.Equals(other.RightIdx);
+        } else {
+          return false;
+        }
       }
     }
 
     [Storable]
-    public readonly TreeNode[] tree;
+    private readonly TreeNode[] tree;
 
     [StorableConstructor]
     private RegressionTreeModel(bool serializing) : base(serializing) { }
     // cloning ctor
-    public RegressionTreeModel(RegressionTreeModel original, Cloner cloner)
+    private RegressionTreeModel(RegressionTreeModel original, Cloner cloner)
       : base(original, cloner) {
       this.tree = original.tree; // shallow clone, tree must be readonly
     }
 
-    public RegressionTreeModel(TreeNode[] tree)
+    internal RegressionTreeModel(TreeNode[] tree)
       : base("RegressionTreeModel", "Represents a decision tree for regression.") {
       this.tree = tree;
@@ -84 +109 @@
       return new RegressionSolution(this, new RegressionProblemData(problemData));
     }
+
+    // mainly for debugging
+    public override string ToString() {
+      return TreeToString(0, "");
+    }
+
+    private string TreeToString(int idx, string part) {
+      var n = tree[idx];
+      if (n.VarName == TreeNode.NO_VARIABLE) {
+        return string.Format(CultureInfo.InvariantCulture, "{0} -> {1:F}{2}", part, n.Val, Environment.NewLine);
+      } else {
+        return
+          TreeToString(n.LeftIdx, string.Format(CultureInfo.InvariantCulture, "{0}{1}{2} <= {3:F}", part, string.IsNullOrEmpty(part) ? "" : " and ", n.VarName, n.Val))
+        + TreeToString(n.RightIdx, string.Format(CultureInfo.InvariantCulture, "{0}{1}{2} >  {3:F}", part, string.IsNullOrEmpty(part) ? "" : " and ", n.VarName, n.Val));
+      }
+    }
+
   }