source: branches/GBT-trunkintegration/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/Test.cs @ 12620

using System;
using System.Collections;
using System.Globalization;
using System.Linq;
using System.Runtime.CompilerServices;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Random;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace HeuristicLab.Algorithms.DataAnalysis.GradientBoostedTrees {
  [TestClass()]
  public class Test {
    [TestMethod]
    [TestCategory("Algorithms.DataAnalysis")]
    [TestProperty("Time", "short")]
    public void DecisionTreeTest() {
      {
        var xy = new double[,]
        {
          {1, 20, 0},
          {1, 20, 0},
          {2, 10, 0},
          {2, 10, 0},
        };
        var allVariables = new string[] { "y", "x1", "x2" };

        // x1 <= 15 -> 1 
        // x1 >  15 -> 2
        BuildTree(xy, allVariables, 10);
      }


      {
        var xy = new double[,]
        {
          {1, 20,  1},
          {1, 20, -1},
          {2, 10, -1},
          {2, 10, 1},
        };
        var allVariables = new string[] { "y", "x1", "x2" };

        // ignore irrelevant variables
        // x1 <= 15 -> 1 
        // x1 >  15 -> 2
        BuildTree(xy, allVariables, 10);
      }

      {
        // split must be by x1 first 
        var xy = new double[,]
        {
          {1, 20,  1},
          {2, 20, -1},
          {3, 10, -1},
          {4, 10, 1},
        };

        var allVariables = new string[] { "y", "x1", "x2" };

        // x1 <= 15 AND x2 <= 0 -> 3 
        // x1 <= 15 AND x2 >  0 -> 4 
        // x1 >  15 AND x2 <= 0 -> 1
        // x1 >  15 AND x2 >  0 -> 2
        BuildTree(xy, allVariables, 10);
      }

      {
        // averaging ys
        var xy = new double[,]
        {
          {0.5, 20,  1},
          {1.5, 20,  1},
          {1.5, 20, -1},
          {2.5, 20, -1},
          {2.5, 10, -1},
          {3.5, 10, -1},
          {3.5, 10, 1},
          {4.5, 10, 1},
        };

        var allVariables = new string[] { "y", "x1", "x2" };

        // x1 <= 15 AND x2 <= 0 -> 3 
        // x1 <= 15 AND x2 >  0 -> 4 
        // x1 >  15 AND x2 <= 0 -> 1
        // x1 >  15 AND x2 >  0 -> 2
        BuildTree(xy, allVariables, 10);
      }


      {
        // diagonal split (no split possible)
        var xy = new double[,]
        {
          {10, 1, 1},
          {1, 1, 2},
          {1, 2, 1},
          {10, 2, 2},
        };

        var allVariables = new string[] { "y", "x1", "x2" };

        // split cannot be found
        BuildTree(xy, allVariables, 3);
      }
      {
        // almost diagonal split 
        var xy = new double[,]
        {
          {10, 1, 1},
          {1, 1, 2},
          {1, 2, 1},
          {10.1, 2, 2},
        };

        var allVariables = new string[] { "y", "x1", "x2" };
        // x1 <= 1.5 AND x2 <= 1.5 -> 10 
        // x1 <= 1.5 AND x2 >  1.5 -> 1 
        // x1 >  1.5 AND x2 <= 1.5 -> 1
        // x1 >  1.5 AND x2 >  1.5 -> 10.1
        BuildTree(xy, allVariables, 3);
      }
      {
        // unbalanced split
        var xy = new double[,]
        {
          {-1, 1, 1},
          {-1, 1, 2},
          {0.9, 2, 1},
          {1.1, 2, 2},
        };

        var allVariables = new string[] { "y", "x1", "x2" };
        // x1 <= 1.5 -> -1.0 
        // x1 >  1.5 AND x2 <= 1.5 -> 0.9
        // x1 >  1.5 AND x2 >  1.5 -> 1.1
        BuildTree(xy, allVariables, 3);
      }

    }

    private void BuildTree(double[,] xy, string[] allVariables, int maxDepth) {
      int nRows = xy.GetLength(0);
      var allowedInputs = allVariables.Skip(1);
      var dataset = new Dataset(allVariables, xy);
      var problemData = new RegressionProblemData(dataset, allowedInputs, allVariables.First());
      problemData.TrainingPartition.Start = 0;
      problemData.TrainingPartition.End = nRows;
      problemData.TestPartition.Start = nRows;
      problemData.TestPartition.End = nRows;
      var rand = new MersenneTwister(31415);
      var builder = new RegressionTreeBuilder(problemData, rand);
      var model = (GradientBoostedTreesModel)builder.CreateRegressionTree(maxDepth, 1, 1); // maximal depth and use all rows and cols
      var constM = model.Models.First() as ConstantRegressionModel;
      var treeM = model.Models.Skip(1).First() as RegressionTreeModel;
      WriteTree(treeM.tree, 0, "", constM.Constant);
      Console.WriteLine();
    }

    private void WriteTree(RegressionTreeModel.TreeNode[] tree, int idx, string partialRule, double offset) {
      var n = tree[idx];
      if (n.varName == RegressionTreeModel.TreeNode.NO_VARIABLE) {
        Console.WriteLine("{0} -> {1:F}", partialRule, n.val + offset);
      } else {
        WriteTree(tree, n.leftIdx,
          string.Format(CultureInfo.InvariantCulture, "{0}{1}{2} <= {3:F}",
          partialRule,
          string.IsNullOrEmpty(partialRule) ? "" : " and ",
          n.varName,
          n.val), offset);
        WriteTree(tree, n.rightIdx,
          string.Format(CultureInfo.InvariantCulture, "{0}{1}{2} >  {3:F}",
          partialRule,
          string.IsNullOrEmpty(partialRule) ? "" : " and ",
          n.varName,
          n.val), offset);
      }
    }
  }
}