source: branches/M5Regression/HeuristicLab.Algorithms.DataAnalysis/3.4/M5Regression/Spliting/OrderSplitType.cs @ 15470

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2017 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.DataAnalysis;

namespace HeuristicLab.Algorithms.DataAnalysis {
  [StorableClass]
  [Item("OrderSplitType", "A split selector that uses the ratio between Variances^1/Order to determine good splits")]
  public class OrderSplitType : ParameterizedNamedItem, ISplitType {
    public const string OrderParameterName = "Order";
    public IFixedValueParameter<DoubleValue> OrderParameter {
      get { return Parameters[OrderParameterName] as IFixedValueParameter<DoubleValue>; }
    }
    public double Order {
      get { return OrderParameter.Value.Value; }
    }

    #region Constructors & Cloning
    [StorableConstructor]
    private OrderSplitType(bool deserializing) { }
    private OrderSplitType(OrderSplitType original, Cloner cloner) : base(original, cloner) { }
    public OrderSplitType() {
      Parameters.Add(new FixedValueParameter<DoubleValue>(OrderParameterName, "The exponent in the split calculation sum (x_i - x_avg)^Order.", new DoubleValue(4)));
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new OrderSplitType(this, cloner);
    }
    #endregion

    #region ISplitType
    public bool Split(IRegressionProblemData splitData, int minLeafSize, out string splitAttr, out double splitValue) {
      var bestPos = 0;
      var bestImpurity = double.MinValue;
      var bestSplitValue = 0.0;
      var bestSplitAttr = string.Empty;
      splitAttr = bestSplitAttr;
      splitValue = bestSplitValue;
      if (splitData.Dataset.Rows < minLeafSize) return false;
      //find best Attribute for the Split
      foreach (var attr in splitData.AllowedInputVariables) {
        int pos;
        double impurity, sValue;
        var sortedData = splitData.Dataset.GetDoubleValues(attr).Zip(splitData.Dataset.GetDoubleValues(splitData.TargetVariable), Tuple.Create).OrderBy(x => x.Item1).ToArray();
        AttributeSplit(sortedData.Select(x => x.Item1).ToArray(), sortedData.Select(x => x.Item2).ToArray(), minLeafSize, out pos, out impurity, out sValue);
        if (!(bestImpurity < impurity)) continue;
        bestImpurity = impurity;
        bestPos = pos;
        bestSplitValue = sValue;
        bestSplitAttr = attr;
      }

      splitAttr = bestSplitAttr;
      splitValue = bestSplitValue;
      //if no suitable split exists => leafNode
      return bestPos >= minLeafSize && bestPos <= splitData.Dataset.Rows - minLeafSize;
    }

    private void AttributeSplit(IReadOnlyList<double> attValues, IReadOnlyList<double> targetValues, int minLeafSize, out int position, out double maxImpurity, out double splitValue) {
      position = 0;
      maxImpurity = -1E20;
      splitValue = 0.0;
      var length = targetValues.Count;
      var imp = new OrderImpurityCalculator(minLeafSize, targetValues, Order);
      if (imp.Impurity > maxImpurity) {
        maxImpurity = imp.Impurity;
        splitValue = (attValues[minLeafSize - 1] + attValues[minLeafSize]) / 2;
        position = minLeafSize;
      }
      for (var i = minLeafSize; i < length - minLeafSize; i++) {
        imp.Increment(targetValues[i], OrderImpurityCalculator.IncrementType.Left);
        if (imp.Impurity < maxImpurity) continue;
        maxImpurity = imp.Impurity;
        splitValue = (attValues[i] + attValues[i + 1]) / 2;
        position = i + 1;
      }
    }
    #endregion
  }
}