Changeset 12868

Timestamp:

08/17/15 16:11:47 (9 years ago)

Author:

gkronber

Message:

#2450: introduced surrogate for GBT-models which recalculates the actual model on demand to improve persistence of GBT solutions

Location:

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4

Files:

• GradientBoostedTrees/GradientBoostedTreesAlgorithm.cs (modified) (2 diffs)
• GradientBoostedTrees/GradientBoostedTreesModel.cs (modified) (2 diffs)
• GradientBoostedTrees/GradientBoostedTreesModelSurrogate.cs (added)
• GradientBoostedTrees/RegressionTreeModel.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis-3.4.csproj (modified) (1 diff)

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesAlgorithm.cs

@@ -233 +233 @@
       // produce solution 
       if (CreateSolution) {
+        var surrogateModel = new GradientBoostedTreesModelSurrogate(problemData, (uint)Seed, lossFunction.ToString(),
+          Iterations, MaxSize, R, M, Nu, state.GetModel());
+
         // for logistic regression we produce a classification solution
         if (lossFunction is LogisticRegressionLoss) {
-          var model = new DiscriminantFunctionClassificationModel(state.GetModel(),
+          var model = new DiscriminantFunctionClassificationModel(surrogateModel,
             new AccuracyMaximizationThresholdCalculator());
           var classificationProblemData = new ClassificationProblemData(problemData.Dataset,
@@ -245 +248 @@
         } else {
           // otherwise we produce a regression solution
-          Results.Add(new Result("Solution", new RegressionSolution(state.GetModel(), problemData)));
+          Results.Add(new Result("Solution", new RegressionSolution(surrogateModel, problemData)));
         }
       }

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesModel.cs

@@ -34 +34 @@
   // this is essentially a collection of weighted regression models
   public sealed class GradientBoostedTreesModel : NamedItem, IRegressionModel {
-    [Storable]
+    // BackwardsCompatibility3.4 for allowing deserialization & serialization of old models
+    #region Backwards compatible code, remove with 3.5
+    private bool isCompatibilityLoaded = false; // only set to true if the model is deserialized from the old format, needed to make sure that information is serialized again if it was loaded from the old format
+
+    [Storable(Name = "models")]
+    private IList<IRegressionModel> __persistedModels {
+      set {
+        this.isCompatibilityLoaded = true;
+        this.models.Clear();
+        foreach (var m in value) this.models.Add(m);
+      }
+      get { if (this.isCompatibilityLoaded) return models; else return null; }
+    }
+    [Storable(Name = "weights")]
+    private IList<double> __persistedWeights {
+      set {
+        this.isCompatibilityLoaded = true;
+        this.weights.Clear();
+        foreach (var w in value) this.weights.Add(w);
+      }
+      get { if (this.isCompatibilityLoaded) return weights; else return null; }
+    }
+    #endregion
+
     private readonly IList<IRegressionModel> models;
     public IEnumerable<IRegressionModel> Models { get { return models; } }
 
-    [Storable]
     private readonly IList<double> weights;
     public IEnumerable<double> Weights { get { return weights; } }
 
     [StorableConstructor]
-    private GradientBoostedTreesModel(bool deserializing) : base(deserializing) { }
+    private GradientBoostedTreesModel(bool deserializing)
+      : base(deserializing) {
+      models = new List<IRegressionModel>();
+      weights = new List<double>();
+    }
     private GradientBoostedTreesModel(GradientBoostedTreesModel original, Cloner cloner)
       : base(original, cloner) {
       this.weights = new List<double>(original.weights);
       this.models = new List<IRegressionModel>(original.models.Select(m => cloner.Clone(m)));
+      this.isCompatibilityLoaded = original.isCompatibilityLoaded;
     }
     public GradientBoostedTreesModel(IEnumerable<IRegressionModel> models, IEnumerable<double> weights)
@@ -64 +91 @@
       // allocate target array go over all models and add up weighted estimation for each row
       if (!rows.Any()) return Enumerable.Empty<double>(); // return immediately if rows is empty. This prevents multiple iteration over lazy rows enumerable.
-                                                          // (which essentially looks up indexes in a dictionary)
+      // (which essentially looks up indexes in a dictionary)
       var res = new double[rows.Count()];
       for (int i = 0; i < models.Count; i++) {

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs

@@ -82 +82 @@
     [Storable]
     // to prevent storing the references to data caches in nodes
+    // seemingly it is bad (performance-wise) to persist tuples (tuples are used as keys in a dictionary) TODO
     private Tuple<string, double, int, int>[] SerializedTree {
       get { return tree.Select(t => Tuple.Create(t.VarName, t.Val, t.LeftIdx, t.RightIdx)).ToArray(); }

trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj

@@ -195 +195 @@
     <Compile Include="GaussianProcess\GaussianProcessRegressionSolution.cs" />
     <Compile Include="GaussianProcess\ICovarianceFunction.cs" />
+    <Compile Include="GradientBoostedTrees\GradientBoostedTreesModelSurrogate.cs" />
     <Compile Include="GradientBoostedTrees\GradientBoostedTreesAlgorithm.cs" />
     <Compile Include="GradientBoostedTrees\GradientBoostedTreesAlgorithmStatic.cs" />