source: branches/2952_RF-ModelStorage/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesAlgorithm.cs @ 17152

Last change on this file since 17152 was 17152, checked in by gkronber, 3 months ago

#2952: readded backwards compatibility code for very old versions of GBT and RF

File size: 15.3 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 * and the BEACON Center for the Study of Evolution in Action.
5 *
6 * This file is part of HeuristicLab.
7 *
8 * HeuristicLab is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * HeuristicLab is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
20 */
21#endregion
22
23using System;
24using System.Linq;
25using System.Threading;
26using HeuristicLab.Algorithms.DataAnalysis.GradientBoostedTrees;
27using HeuristicLab.Analysis;
28using HeuristicLab.Common;
29using HeuristicLab.Core;
30using HeuristicLab.Data;
31using HeuristicLab.Optimization;
32using HeuristicLab.Parameters;
33using HEAL.Attic;
34using HeuristicLab.PluginInfrastructure;
35using HeuristicLab.Problems.DataAnalysis;
36
37namespace HeuristicLab.Algorithms.DataAnalysis {
38  [Item("Gradient Boosted Trees (GBT)", "Gradient boosted trees algorithm. Specific implementation of gradient boosting for regression trees. Friedman, J. \"Greedy Function Approximation: A Gradient Boosting Machine\", IMS 1999 Reitz Lecture.")]
39  [StorableType("8CCB55BD-4935-4868-855F-D3E5D55127AA")]
40  [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 125)]
41  public class GradientBoostedTreesAlgorithm : FixedDataAnalysisAlgorithm<IRegressionProblem> {
42    #region ParameterNames
43    private const string IterationsParameterName = "Iterations";
44    private const string MaxSizeParameterName = "Maximum Tree Size";
45    private const string NuParameterName = "Nu";
46    private const string RParameterName = "R";
47    private const string MParameterName = "M";
48    private const string SeedParameterName = "Seed";
49    private const string SetSeedRandomlyParameterName = "SetSeedRandomly";
50    private const string LossFunctionParameterName = "LossFunction";
51    private const string UpdateIntervalParameterName = "UpdateInterval";
52    private const string ModelCreationParameterName = "ModelCreation";
53    #endregion
54
55    #region ParameterProperties
56    public IFixedValueParameter<IntValue> IterationsParameter {
57      get { return (IFixedValueParameter<IntValue>)Parameters[IterationsParameterName]; }
58    }
59    public IFixedValueParameter<IntValue> MaxSizeParameter {
60      get { return (IFixedValueParameter<IntValue>)Parameters[MaxSizeParameterName]; }
61    }
62    public IFixedValueParameter<DoubleValue> NuParameter {
63      get { return (IFixedValueParameter<DoubleValue>)Parameters[NuParameterName]; }
64    }
65    public IFixedValueParameter<DoubleValue> RParameter {
66      get { return (IFixedValueParameter<DoubleValue>)Parameters[RParameterName]; }
67    }
68    public IFixedValueParameter<DoubleValue> MParameter {
69      get { return (IFixedValueParameter<DoubleValue>)Parameters[MParameterName]; }
70    }
71    public IFixedValueParameter<IntValue> SeedParameter {
72      get { return (IFixedValueParameter<IntValue>)Parameters[SeedParameterName]; }
73    }
74    public FixedValueParameter<BoolValue> SetSeedRandomlyParameter {
75      get { return (FixedValueParameter<BoolValue>)Parameters[SetSeedRandomlyParameterName]; }
76    }
77    public IConstrainedValueParameter<ILossFunction> LossFunctionParameter {
78      get { return (IConstrainedValueParameter<ILossFunction>)Parameters[LossFunctionParameterName]; }
79    }
80    public IFixedValueParameter<IntValue> UpdateIntervalParameter {
81      get { return (IFixedValueParameter<IntValue>)Parameters[UpdateIntervalParameterName]; }
82    }
83    private IFixedValueParameter<EnumValue<ModelCreation>> ModelCreationParameter {
84      get { return (IFixedValueParameter<EnumValue<ModelCreation>>)Parameters[ModelCreationParameterName]; }
85    }
86    #endregion
87
88    #region Properties
89    public int Iterations {
90      get { return IterationsParameter.Value.Value; }
91      set { IterationsParameter.Value.Value = value; }
92    }
93    public int Seed {
94      get { return SeedParameter.Value.Value; }
95      set { SeedParameter.Value.Value = value; }
96    }
97    public bool SetSeedRandomly {
98      get { return SetSeedRandomlyParameter.Value.Value; }
99      set { SetSeedRandomlyParameter.Value.Value = value; }
100    }
101    public int MaxSize {
102      get { return MaxSizeParameter.Value.Value; }
103      set { MaxSizeParameter.Value.Value = value; }
104    }
105    public double Nu {
106      get { return NuParameter.Value.Value; }
107      set { NuParameter.Value.Value = value; }
108    }
109    public double R {
110      get { return RParameter.Value.Value; }
111      set { RParameter.Value.Value = value; }
112    }
113    public double M {
114      get { return MParameter.Value.Value; }
115      set { MParameter.Value.Value = value; }
116    }
117    public ModelCreation ModelCreation {
118      get { return ModelCreationParameter.Value.Value; }
119      set { ModelCreationParameter.Value.Value = value; }
120    }
121    #endregion
122
123    #region ResultsProperties
124    private double ResultsBestQuality {
125      get { return ((DoubleValue)Results["Best Quality"].Value).Value; }
126      set { ((DoubleValue)Results["Best Quality"].Value).Value = value; }
127    }
128    private DataTable ResultsQualities {
129      get { return ((DataTable)Results["Qualities"].Value); }
130    }
131    #endregion
132
133    [StorableConstructor]
134    protected GradientBoostedTreesAlgorithm(StorableConstructorFlag _) : base(_) { }
135
136    protected GradientBoostedTreesAlgorithm(GradientBoostedTreesAlgorithm original, Cloner cloner)
137      : base(original, cloner) {
138    }
139
140    public override IDeepCloneable Clone(Cloner cloner) {
141      return new GradientBoostedTreesAlgorithm(this, cloner);
142    }
143
144    public GradientBoostedTreesAlgorithm() {
145      Problem = new RegressionProblem(); // default problem
146
147      Parameters.Add(new FixedValueParameter<IntValue>(IterationsParameterName, "Number of iterations (set as high as possible, adjust in combination with nu, when increasing iterations also decrease nu)", new IntValue(1000)));
148      Parameters.Add(new FixedValueParameter<IntValue>(SeedParameterName, "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
149      Parameters.Add(new FixedValueParameter<BoolValue>(SetSeedRandomlyParameterName, "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
150      Parameters.Add(new FixedValueParameter<IntValue>(MaxSizeParameterName, "Maximal size of the tree learned in each step (prefer smaller sizes (3 to 10) if possible)", new IntValue(10)));
151      Parameters.Add(new FixedValueParameter<DoubleValue>(RParameterName, "Ratio of training rows selected randomly in each step (0 < R <= 1)", new DoubleValue(0.5)));
152      Parameters.Add(new FixedValueParameter<DoubleValue>(MParameterName, "Ratio of variables selected randomly in each step (0 < M <= 1)", new DoubleValue(0.5)));
153      Parameters.Add(new FixedValueParameter<DoubleValue>(NuParameterName, "Learning rate nu (step size for the gradient update, should be small 0 < nu < 0.1)", new DoubleValue(0.002)));
154      Parameters.Add(new FixedValueParameter<IntValue>(UpdateIntervalParameterName, "", new IntValue(100)));
155      Parameters[UpdateIntervalParameterName].Hidden = true;
156      Parameters.Add(new FixedValueParameter<EnumValue<ModelCreation>>(ModelCreationParameterName, "Defines the results produced at the end of the run (Surrogate => Less disk space, lazy recalculation of model)", new EnumValue<ModelCreation>(ModelCreation.Model)));
157      Parameters[ModelCreationParameterName].Hidden = true;
158
159      var lossFunctions = ApplicationManager.Manager.GetInstances<ILossFunction>();
160      Parameters.Add(new ConstrainedValueParameter<ILossFunction>(LossFunctionParameterName, "The loss function", new ItemSet<ILossFunction>(lossFunctions)));
161      LossFunctionParameter.Value = LossFunctionParameter.ValidValues.First(f => f.ToString().Contains("Squared")); // squared error loss is the default
162    }
163
164    [StorableHook(HookType.AfterDeserialization)]
165    private void AfterDeserialization() {
166      // BackwardsCompatibility3.4
167      #region Backwards compatible code, remove with 3.5
168
169      #region LossFunction
170      // parameter type has been changed
171      var lossFunctionParam = Parameters[LossFunctionParameterName] as ConstrainedValueParameter<StringValue>;
172      if (lossFunctionParam != null) {
173        Parameters.Remove(LossFunctionParameterName);
174        var selectedValue = lossFunctionParam.Value; // to be restored below
175
176        var lossFunctions = ApplicationManager.Manager.GetInstances<ILossFunction>();
177        Parameters.Add(new ConstrainedValueParameter<ILossFunction>(LossFunctionParameterName, "The loss function", new ItemSet<ILossFunction>(lossFunctions)));
178        // try to restore selected value
179        var selectedLossFunction =
180          LossFunctionParameter.ValidValues.FirstOrDefault(f => f.ToString() == selectedValue.Value);
181        if (selectedLossFunction != null) {
182          LossFunctionParameter.Value = selectedLossFunction;
183        } else {
184          LossFunctionParameter.Value = LossFunctionParameter.ValidValues.First(f => f.ToString().Contains("Squared")); // default: SE
185        }
186      }
187      #endregion
188
189      #region CreateSolution
190      // parameter type has been changed
191      if (Parameters.ContainsKey("CreateSolution")) {
192        var createSolutionParam = Parameters["CreateSolution"] as FixedValueParameter<BoolValue>;
193        Parameters.Remove(createSolutionParam);
194
195        ModelCreation value = createSolutionParam.Value.Value ? ModelCreation.Model : ModelCreation.QualityOnly;
196        Parameters.Add(new FixedValueParameter<EnumValue<ModelCreation>>(ModelCreationParameterName, "Defines the results produced at the end of the run (Surrogate => Less disk space, lazy recalculation of model)", new EnumValue<ModelCreation>(value)));
197        Parameters[ModelCreationParameterName].Hidden = true;
198      } else if (!Parameters.ContainsKey(ModelCreationParameterName)) {
199        // very old version contains neither ModelCreationParameter nor CreateSolutionParameter
200        Parameters.Add(new FixedValueParameter<EnumValue<ModelCreation>>(ModelCreationParameterName, "Defines the results produced at the end of the run (Surrogate => Less disk space, lazy recalculation of model)", new EnumValue<ModelCreation>(ModelCreation.Model)));
201      }
202      #endregion
203      #endregion
204    }
205
206    protected override void Run(CancellationToken cancellationToken) {
207      // Set up the algorithm
208      if (SetSeedRandomly) Seed = Random.RandomSeedGenerator.GetSeed();
209
210      // Set up the results display
211      var iterations = new IntValue(0);
212      Results.Add(new Result("Iterations", iterations));
213
214      var table = new DataTable("Qualities");
215      table.Rows.Add(new DataRow("Loss (train)"));
216      table.Rows.Add(new DataRow("Loss (test)"));
217      table.Rows["Loss (train)"].VisualProperties.StartIndexZero = true;
218      table.Rows["Loss (test)"].VisualProperties.StartIndexZero = true;
219
220      Results.Add(new Result("Qualities", table));
221      var curLoss = new DoubleValue();
222      Results.Add(new Result("Loss (train)", curLoss));
223
224      // init
225      var problemData = (IRegressionProblemData)Problem.ProblemData.Clone();
226      var lossFunction = LossFunctionParameter.Value;
227      var state = GradientBoostedTreesAlgorithmStatic.CreateGbmState(problemData, lossFunction, (uint)Seed, MaxSize, R, M, Nu);
228
229      var updateInterval = UpdateIntervalParameter.Value.Value;
230      // Loop until iteration limit reached or canceled.
231      for (int i = 0; i < Iterations; i++) {
232        cancellationToken.ThrowIfCancellationRequested();
233
234        GradientBoostedTreesAlgorithmStatic.MakeStep(state);
235
236        // iteration results
237        if (i % updateInterval == 0) {
238          curLoss.Value = state.GetTrainLoss();
239          table.Rows["Loss (train)"].Values.Add(curLoss.Value);
240          table.Rows["Loss (test)"].Values.Add(state.GetTestLoss());
241          iterations.Value = i;
242        }
243      }
244
245      // final results
246      iterations.Value = Iterations;
247      curLoss.Value = state.GetTrainLoss();
248      table.Rows["Loss (train)"].Values.Add(curLoss.Value);
249      table.Rows["Loss (test)"].Values.Add(state.GetTestLoss());
250
251      // produce variable relevance
252      var orderedImpacts = state.GetVariableRelevance().Select(t => new { name = t.Key, impact = t.Value }).ToList();
253
254      var impacts = new DoubleMatrix();
255      var matrix = impacts as IStringConvertibleMatrix;
256      matrix.Rows = orderedImpacts.Count;
257      matrix.RowNames = orderedImpacts.Select(x => x.name);
258      matrix.Columns = 1;
259      matrix.ColumnNames = new string[] { "Relative variable relevance" };
260
261      int rowIdx = 0;
262      foreach (var p in orderedImpacts) {
263        matrix.SetValue(string.Format("{0:N2}", p.impact), rowIdx++, 0);
264      }
265
266      Results.Add(new Result("Variable relevance", impacts));
267      Results.Add(new Result("Loss (test)", new DoubleValue(state.GetTestLoss())));
268
269      // produce solution
270      if (ModelCreation == ModelCreation.SurrogateModel || ModelCreation == ModelCreation.Model) {
271        IRegressionModel model = state.GetModel();
272
273        if (ModelCreation == ModelCreation.SurrogateModel) {
274          model = new GradientBoostedTreesModelSurrogate((GradientBoostedTreesModel)model, problemData, (uint)Seed, lossFunction, Iterations, MaxSize, R, M, Nu);
275        }
276
277        // for logistic regression we produce a classification solution
278        if (lossFunction is LogisticRegressionLoss) {
279          var classificationModel = new DiscriminantFunctionClassificationModel(model,
280            new AccuracyMaximizationThresholdCalculator());
281          var classificationProblemData = new ClassificationProblemData(problemData.Dataset,
282            problemData.AllowedInputVariables, problemData.TargetVariable, problemData.Transformations);
283          classificationProblemData.TrainingPartition.Start = Problem.ProblemData.TrainingPartition.Start;
284          classificationProblemData.TrainingPartition.End = Problem.ProblemData.TrainingPartition.End;
285          classificationProblemData.TestPartition.Start = Problem.ProblemData.TestPartition.Start;
286          classificationProblemData.TestPartition.End = Problem.ProblemData.TestPartition.End;
287
288          classificationModel.SetThresholdsAndClassValues(new double[] { double.NegativeInfinity, 0.0 }, new[] { 0.0, 1.0 });
289
290
291          var classificationSolution = new DiscriminantFunctionClassificationSolution(classificationModel, classificationProblemData);
292          Results.Add(new Result("Solution", classificationSolution));
293        } else {
294          // otherwise we produce a regression solution
295          Results.Add(new Result("Solution", new GradientBoostedTreesSolution(model, problemData)));
296        }
297      } else if (ModelCreation == ModelCreation.QualityOnly) {
298        //Do nothing
299      } else {
300        throw new NotImplementedException("Selected parameter for CreateSolution isn't implemented yet");
301      }
302    }
303  }
304}
Note: See TracBrowser for help on using the repository browser.