decision_tree.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_DECISION_TREE_DECISION_TREE_HPP
#define MLPACK_METHODS_DECISION_TREE_DECISION_TREE_HPP

#include <mlpack/prereqs.hpp>
#include "gini_gain.hpp"
#include "best_binary_numeric_split.hpp"
#include "all_categorical_split.hpp"
#include "all_dimension_select.hpp"
#include <type_traits>

namespace mlpack {
namespace tree {

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

  template<typename MatType, typename LabelsType>
  DecisionTree(MatType&& data,
               const data::DatasetInfo& datasetInfo,
               LabelsType&& labels,
               const size_t numClasses,
               const size_t minimumLeafSize = 10,
               const double minimumGainSplit = 1e-7);

  template<typename MatType, typename LabelsType>
  DecisionTree(MatType&& data,
               LabelsType&& labels,
               const size_t numClasses,
               const size_t minimumLeafSize = 10,
               const double minimumGainSplit = 1e-7);

  template<typename MatType, typename LabelsType, typename WeightsType>
  DecisionTree(MatType&& data,
               const data::DatasetInfo& datasetInfo,
               LabelsType&& labels,
               const size_t numClasses,
               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 LabelsType, typename WeightsType>
  DecisionTree(MatType&& data,
               LabelsType&& labels,
               const size_t numClasses,
               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);


  DecisionTree(const size_t numClasses = 1);

  DecisionTree(const DecisionTree& other);

  DecisionTree(DecisionTree&& other);

  DecisionTree& operator=(const DecisionTree& other);

  DecisionTree& operator=(DecisionTree&& other);

  ~DecisionTree();

  template<typename MatType, typename LabelsType>
  void Train(MatType&& data,
             const data::DatasetInfo& datasetInfo,
             LabelsType&& labels,
             const size_t numClasses,
             const size_t minimumLeafSize = 10,
             const double minimumGainSplit = 1e-7);

  template<typename MatType, typename LabelsType>
  void Train(MatType&& data,
             LabelsType&& labels,
             const size_t numClasses,
             const size_t minimumLeafSize = 10,
             const double minimumGainSplit = 1e-7);

  template<typename MatType, typename LabelsType, typename WeightsType>
  void Train(MatType&& data,
             const data::DatasetInfo& datasetInfo,
             LabelsType&& labels,
             const size_t numClasses,
             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 LabelsType, typename WeightsType>
  void Train(MatType&& data,
             LabelsType&& labels,
             const size_t numClasses,
             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 VecType>
  size_t Classify(const VecType& point) const;

  template<typename VecType>
  void Classify(const VecType& point,
                size_t& prediction,
                arma::vec& probabilities) const;

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

  template<typename MatType>
  void Classify(const MatType& data,
                arma::Row<size_t>& predictions,
                arma::mat& probabilities) const;

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

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

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

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

  size_t NumClasses() const;

 private:
  std::vector<DecisionTree*> children;
  size_t splitDimension;
  size_t dimensionTypeOrMajorityClass;
  arma::vec classProbabilities;

  typedef typename NumericSplit::template AuxiliarySplitInfo<ElemType>
      NumericAuxiliarySplitInfo;
  typedef typename CategoricalSplit::template AuxiliarySplitInfo<ElemType>
      CategoricalAuxiliarySplitInfo;

  template<bool UseWeights, typename RowType, typename WeightsRowType>
  void CalculateClassProbabilities(const RowType& labels,
                                   const size_t numClasses,
                                   const WeightsRowType& weights);

  template<bool UseWeights, typename MatType>
  void Train(MatType& data,
             const size_t begin,
             const size_t count,
             const data::DatasetInfo& datasetInfo,
             arma::Row<size_t>& labels,
             const size_t numClasses,
             arma::rowvec& weights,
             const size_t minimumLeafSize = 10,
             const double minimumGainSplit = 1e-7);

  template<bool UseWeights, typename MatType>
  void Train(MatType& data,
             const size_t begin,
             const size_t count,
             arma::Row<size_t>& labels,
             const size_t numClasses,
             arma::rowvec& weights,
             const size_t minimumLeafSize = 10,
             const double minimumGainSplit = 1e-7);
};

template<typename FitnessFunction = GiniGain,
         template<typename> class NumericSplitType = BestBinaryNumericSplit,
         template<typename> class CategoricalSplitType = AllCategoricalSplit,
         typename DimensionSelectType = AllDimensionSelect,
         typename ElemType = double>
using DecisionStump = DecisionTree<FitnessFunction,
                                   NumericSplitType,
                                   CategoricalSplitType,
                                   DimensionSelectType,
                                   ElemType,
                                   false>;

} // namespace tree
} // namespace mlpack

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

#endif