decision_tree_regressor.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_DECISION_TREE_DECISION_TREE_REGRESSOR_HPP
#define MLPACK_METHODS_DECISION_TREE_DECISION_TREE_REGRESSOR_HPP

#include <mlpack/prereqs.hpp>
#include "mad_gain.hpp"
#include "mse_gain.hpp"
#include "best_binary_numeric_split.hpp"
#include "all_categorical_split.hpp"
#include "random_binary_numeric_split.hpp"
#include "all_dimension_select.hpp"
#include <type_traits>


namespace mlpack {
namespace tree {

template<typename FitnessFunction = MSEGain,
         template<typename> class NumericSplitType = BestBinaryNumericSplit,
         template<typename> class CategoricalSplitType = AllCategoricalSplit,
         typename DimensionSelectionType = AllDimensionSelect,
         bool NoRecursion = false>
class DecisionTreeRegressor :
    public NumericSplitType<FitnessFunction>::AuxiliarySplitInfo,
    public CategoricalSplitType<FitnessFunction>::AuxiliarySplitInfo
{
 public:
  typedef NumericSplitType<FitnessFunction> NumericSplit;
  typedef CategoricalSplitType<FitnessFunction> CategoricalSplit;
  typedef DimensionSelectionType DimensionSelection;

  DecisionTreeRegressor();

  template<typename MatType, typename ResponsesType>
  DecisionTreeRegressor(MatType data,
                        const data::DatasetInfo& datasetInfo,
                        ResponsesType responses,
                        const size_t minimumLeafSize = 10,
                        const double minimumGainSplit = 1e-7,
                        const size_t maximumDepth = 0,
                        DimensionSelectionType dimensionSelector =
                            DimensionSelectionType());

  template<typename MatType, typename ResponsesType>
  DecisionTreeRegressor(MatType data,
                        ResponsesType responses,
                        const size_t minimumLeafSize = 10,
                        const double minimumGainSplit = 1e-7,
                        const size_t maximumDepth = 0,
                        DimensionSelectionType dimensionSelector =
                            DimensionSelectionType());

  template<typename MatType, typename ResponsesType, typename WeightsType>
  DecisionTreeRegressor(
      MatType data,
      const data::DatasetInfo& datasetInfo,
      ResponsesType responses,
      WeightsType weights,
      const size_t minimumLeafSize = 10,
      const double minimumGainSplit = 1e-7,
      const size_t maximumDepth = 0,
      DimensionSelectionType dimensionSelector = DimensionSelectionType(),
      const std::enable_if_t<arma::is_arma_type<
          typename std::remove_reference<WeightsType>::type>::value>* = 0);

  template<typename MatType, typename ResponsesType, typename WeightsType>
  DecisionTreeRegressor(
      MatType data,
      ResponsesType responses,
      WeightsType weights,
      const size_t minimumLeafSize = 10,
      const double minimumGainSplit = 1e-7,
      const size_t maximumDepth = 0,
      DimensionSelectionType dimensionSelector = DimensionSelectionType(),
      const std::enable_if_t<arma::is_arma_type<
          typename std::remove_reference<WeightsType>::type>::value>* = 0);

  template<typename MatType, typename ResponsesType, typename WeightsType>
  DecisionTreeRegressor(
      const DecisionTreeRegressor& other,
      MatType data,
      const data::DatasetInfo& datasetInfo,
      ResponsesType responses,
      WeightsType weights,
      const size_t minimumLeafSize = 10,
      const double minimumGainSplit = 1e-7,
      const std::enable_if_t<arma::is_arma_type<
          typename std::remove_reference<WeightsType>::type>::value>* = 0);

  template<typename MatType, typename ResponsesType, typename WeightsType>
  DecisionTreeRegressor(
      const DecisionTreeRegressor& other,
      MatType data,
      ResponsesType responses,
      WeightsType weights,
      const size_t minimumLeafSize = 10,
      const double minimumGainSplit = 1e-7,
      const size_t maximumDepth = 0,
      DimensionSelectionType dimensionSelector = DimensionSelectionType(),
      const std::enable_if_t<arma::is_arma_type<
          typename std::remove_reference<WeightsType>::type>::value>* = 0);

  DecisionTreeRegressor(const DecisionTreeRegressor& other);

  DecisionTreeRegressor(DecisionTreeRegressor&& other);

  DecisionTreeRegressor& operator=(const DecisionTreeRegressor& other);

  DecisionTreeRegressor& operator=(DecisionTreeRegressor&& other);

  ~DecisionTreeRegressor();

  template<typename MatType, typename ResponsesType>
  double Train(MatType data,
               const data::DatasetInfo& datasetInfo,
               ResponsesType responses,
               const size_t minimumLeafSize = 10,
               const double minimumGainSplit = 1e-7,
               const size_t maximumDepth = 0,
               DimensionSelectionType dimensionSelector =
                   DimensionSelectionType(),
               FitnessFunction fitnessFunction = FitnessFunction());

  template<typename MatType, typename ResponsesType>
  double Train(MatType data,
               ResponsesType responses,
               const size_t minimumLeafSize = 10,
               const double minimumGainSplit = 1e-7,
               const size_t maximumDepth = 0,
               DimensionSelectionType dimensionSelector =
                   DimensionSelectionType(),
               FitnessFunction fitnessFunction = FitnessFunction());

  template<typename MatType, typename ResponsesType, typename WeightsType>
  double Train(MatType data,
               const data::DatasetInfo& datasetInfo,
               ResponsesType responses,
               WeightsType weights,
               const size_t minimumLeafSize = 10,
               const double minimumGainSplit = 1e-7,
               const size_t maximumDepth = 0,
               DimensionSelectionType dimensionSelector =
                   DimensionSelectionType(),
               FitnessFunction fitnessFunction = FitnessFunction(),
               const std::enable_if_t<arma::is_arma_type<typename
                   std::remove_reference<WeightsType>::type>::value>* = 0);

  template<typename MatType, typename ResponsesType, typename WeightsType>
  double Train(MatType data,
               ResponsesType responses,
               WeightsType weights,
               const size_t minimumLeafSize = 10,
               const double minimumGainSplit = 1e-7,
               const size_t maximumDepth = 0,
               DimensionSelectionType dimensionSelector =
                   DimensionSelectionType(),
               FitnessFunction fitnessFunction = FitnessFunction(),
               const std::enable_if_t<arma::is_arma_type<typename
                   std::remove_reference<WeightsType>::type>::value>* = 0);

  template<typename VecType>
  double Predict(const VecType& point) const;

  template<typename MatType>
  void Predict(const MatType& data,
                arma::Row<double>& predictions) const;

  template<typename Archive>
  void serialize(Archive& ar, const uint32_t /* version */);

  size_t NumChildren() const { return children.size(); }

  size_t NumLeaves() const;

  const DecisionTreeRegressor& Child(const size_t i) const
  {
    return *children[i];
  }
  DecisionTreeRegressor& Child(const size_t i) { return *children[i]; }

  size_t SplitDimension() const { return splitDimension; }

  template<typename VecType>
  size_t CalculateDirection(const VecType& point) const;

 private:
  std::vector<DecisionTreeRegressor*> children;
  size_t splitDimension;
  size_t dimensionType;
  double splitPointOrPrediction;

  typedef typename NumericSplit::AuxiliarySplitInfo
      NumericAuxiliarySplitInfo;
  typedef typename CategoricalSplit::AuxiliarySplitInfo
      CategoricalAuxiliarySplitInfo;

  template<bool UseWeights, typename MatType, typename ResponsesType>
  double Train(MatType& data,
               const size_t begin,
               const size_t count,
               const data::DatasetInfo& datasetInfo,
               ResponsesType& responses,
               arma::rowvec& weights,
               const size_t minimumLeafSize,
               const double minimumGainSplit,
               const size_t maximumDepth,
               DimensionSelectionType& dimensionSelector,
               FitnessFunction fitnessFunction = FitnessFunction());

  template<bool UseWeights, typename MatType, typename ResponsesType>
  double Train(MatType& data,
               const size_t begin,
               const size_t count,
               ResponsesType& responses,
               arma::rowvec& weights,
               const size_t minimumLeafSize,
               const double minimumGainSplit,
               const size_t maximumDepth,
               DimensionSelectionType& dimensionSelector,
               FitnessFunction fitnessFunction = FitnessFunction());
};


} // namespace tree
} // namespace mlpack

// Include implementation.
#include "decision_tree_regressor_impl.hpp"

#endif