adaboost_model.hpp

Go to the documentation of this file.

 
#ifndef MLPACK_METHODS_ADABOOST_ADABOOST_MODEL_HPP
#define MLPACK_METHODS_ADABOOST_ADABOOST_MODEL_HPP
 
#include <mlpack/core.hpp>
 
// Use forward declaration instead of include to accelerate compilation.
class AdaBoost;
 
namespace mlpack {
namespace adaboost {
 
class AdaBoostModel
{
 public:
  enum WeakLearnerTypes
  {
    DECISION_STUMP,
    PERCEPTRON
  };
 
 private:
  arma::Col<size_t> mappings;
  size_t weakLearnerType;
  AdaBoost<tree::ID3DecisionStump>* dsBoost;
  AdaBoost<perceptron::Perceptron<>>* pBoost;
  size_t dimensionality;
 
 public:
  AdaBoostModel();
 
  AdaBoostModel(const arma::Col<size_t>& mappings,
                const size_t weakLearnerType);
 
  AdaBoostModel(const AdaBoostModel& other);
 
  AdaBoostModel(AdaBoostModel&& other);
 
  AdaBoostModel& operator=(const AdaBoostModel& other);
 
  ~AdaBoostModel();
 
  const arma::Col<size_t>& Mappings() const { return mappings; }
  arma::Col<size_t>& Mappings() { return mappings; }
 
  size_t WeakLearnerType() const { return weakLearnerType; }
  size_t& WeakLearnerType() { return weakLearnerType; }
 
  size_t Dimensionality() const { return dimensionality; }
  size_t& Dimensionality() { return dimensionality; }
 
  void Train(const arma::mat& data,
             const arma::Row<size_t>& labels,
             const size_t numClasses,
             const size_t iterations,
             const double tolerance);
 
  void Classify(const arma::mat& testData,
                arma::Row<size_t>& predictions);
 
  void Classify(const arma::mat& testData,
                arma::Row<size_t>& predictions,
                arma::mat& probabilities);
 
  template<typename Archive>
  void serialize(Archive& ar, const unsigned int /* version */)
  {
    if (Archive::is_loading::value)
    {
      if (dsBoost)
        delete dsBoost;
      if (pBoost)
        delete pBoost;
 
      dsBoost = NULL;
      pBoost = NULL;
    }
 
    ar & BOOST_SERIALIZATION_NVP(mappings);
    ar & BOOST_SERIALIZATION_NVP(weakLearnerType);
    if (weakLearnerType == WeakLearnerTypes::DECISION_STUMP)
      ar & BOOST_SERIALIZATION_NVP(dsBoost);
    else if (weakLearnerType == WeakLearnerTypes::PERCEPTRON)
      ar & BOOST_SERIALIZATION_NVP(pBoost);
    ar & BOOST_SERIALIZATION_NVP(dimensionality);
  }
};
 
} // namespace adaboost
} // namespace mlpack
 
#endif