kde_model.hpp

Go to the documentation of this file.

 
#ifndef MLPACK_METHODS_KDE_MODEL_HPP
#define MLPACK_METHODS_KDE_MODEL_HPP
 
// Include trees.
#include <mlpack/core/tree/binary_space_tree.hpp>
#include <mlpack/core/tree/octree.hpp>
#include <mlpack/core/tree/cover_tree.hpp>
#include <mlpack/core/tree/rectangle_tree.hpp>
 
// Include core.
#include <mlpack/core.hpp>
 
// Remaining includes.
#include <boost/variant.hpp>
#include "kde.hpp"
 
namespace mlpack {
namespace kde {
 
template<typename KernelType,
         template<typename TreeMetricType,
                  typename TreeStatType,
                  typename TreeMatType> class TreeType>
using KDEType = KDE<KernelType,
                    metric::EuclideanDistance,
                    arma::mat,
                    TreeType,
                    TreeType<metric::EuclideanDistance,
                             kde::KDEStat,
                             arma::mat>::template DualTreeTraverser,
                    TreeType<metric::EuclideanDistance,
                             kde::KDEStat,
                             arma::mat>::template SingleTreeTraverser>;
 
class KernelNormalizer
{
 private:
  // SFINAE check if Normalizer function is present.
  HAS_MEM_FUNC(Normalizer, HasNormalizer);
 
 public:
  template<typename KernelType>
  static void ApplyNormalizer(
      KernelType& /* kernel */,
      const size_t /* dimension */,
      arma::vec& /* estimations */,
      const typename std::enable_if<
          !HasNormalizer<KernelType, double(KernelType::*)(size_t)>::value>::
          type* = 0)
  { return; }
 
  template<typename KernelType>
  static void ApplyNormalizer(
      KernelType& kernel,
      const size_t dimension,
      arma::vec& estimations,
      const typename std::enable_if<
          HasNormalizer<KernelType, double(KernelType::*)(size_t)>::value>::
          type* = 0)
  {
    estimations /= kernel.Normalizer(dimension);
  }
};
 
class DualMonoKDE : public boost::static_visitor<void>
{
 private:
  arma::vec& estimations;
 
 public:
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  using KDETypeT = KDEType<KernelType, TreeType>;
 
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(KDETypeT<KernelType, TreeType>* kde) const;
 
  // TODO Implement specific cases where a leaf size can be selected.
 
  DualMonoKDE(arma::vec& estimations);
};
 
class DualBiKDE : public boost::static_visitor<void>
{
 private:
  const size_t dimension;
 
  const arma::mat& querySet;
 
  arma::vec& estimations;
 
 public:
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  using KDETypeT = KDEType<KernelType, TreeType>;
 
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(KDETypeT<KernelType, TreeType>* kde) const;
 
  // TODO Implement specific cases where a leaf size can be selected.
 
  DualBiKDE(arma::mat&& querySet, arma::vec& estimations);
};
 
class TrainVisitor : public boost::static_visitor<void>
{
 private:
  arma::mat&& referenceSet;
 
 public:
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(KDEType<KernelType, TreeType>* kde) const;
 
  // TODO Implement specific cases where a leaf size can be selected.
 
  TrainVisitor(arma::mat&& referenceSet);
};
 
class BandwidthVisitor : public boost::static_visitor<void>
{
 private:
  const double bandwidth;
 
 public:
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(KDEType<KernelType, TreeType>* kde) const;
 
  BandwidthVisitor(const double bandwidth);
};
 
class RelErrorVisitor : public boost::static_visitor<void>
{
 private:
  const double relError;
 
 public:
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(KDEType<KernelType, TreeType>* kde) const;
 
  RelErrorVisitor(const double relError);
};
 
class AbsErrorVisitor : public boost::static_visitor<void>
{
 private:
  const double absError;
 
 public:
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(KDEType<KernelType, TreeType>* kde) const;
 
  AbsErrorVisitor(const double absError);
};
 
class MonteCarloVisitor : public boost::static_visitor<void>
{
 private:
  const bool monteCarlo;
 
 public:
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(KDEType<KernelType, TreeType>* kde) const;
 
  MonteCarloVisitor(const bool monteCarlo);
};
 
class MCProbabilityVisitor : public boost::static_visitor<void>
{
 private:
  const double probability;
 
 public:
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(KDEType<KernelType, TreeType>* kde) const;
 
  MCProbabilityVisitor(const double probability);
};
 
class MCSampleSizeVisitor : public boost::static_visitor<void>
{
 private:
  const size_t sampleSize;
 
 public:
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(KDEType<KernelType, TreeType>* kde) const;
 
  MCSampleSizeVisitor(const size_t sampleSize);
};
 
class MCEntryCoefVisitor : public boost::static_visitor<void>
{
 private:
  const double entryCoef;
 
 public:
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(KDEType<KernelType, TreeType>* kde) const;
 
  MCEntryCoefVisitor(const double entryCoef);
};
 
class MCBreakCoefVisitor : public boost::static_visitor<void>
{
 private:
  const double breakCoef;
 
 public:
  template<typename KernelType,
           template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(KDEType<KernelType, TreeType>* kde) const;
 
  MCBreakCoefVisitor(const double breakCoef);
};
 
class ModeVisitor : public boost::static_visitor<KDEMode&>
{
 public:
  template<typename KDEType>
  KDEMode& operator()(KDEType* kde) const;
};
 
class DeleteVisitor : public boost::static_visitor<void>
{
 public:
  template<typename KDEType>
  void operator()(KDEType* kde) const;
};
 
class KDEModel
{
 public:
  enum TreeTypes
  {
    KD_TREE,
    BALL_TREE,
    COVER_TREE,
    OCTREE,
    R_TREE
  };
 
  enum KernelTypes
  {
    GAUSSIAN_KERNEL,
    EPANECHNIKOV_KERNEL,
    LAPLACIAN_KERNEL,
    SPHERICAL_KERNEL,
    TRIANGULAR_KERNEL
  };
 
 private:
  double bandwidth;
 
  double relError;
 
  double absError;
 
  KernelTypes kernelType;
 
  TreeTypes treeType;
 
  bool monteCarlo;
 
  double mcProb;
 
  size_t initialSampleSize;
 
  double mcEntryCoef;
 
  double mcBreakCoef;
 
  boost::variant<KDEType<kernel::GaussianKernel, tree::KDTree>*,
                 KDEType<kernel::GaussianKernel, tree::BallTree>*,
                 KDEType<kernel::GaussianKernel, tree::StandardCoverTree>*,
                 KDEType<kernel::GaussianKernel, tree::Octree>*,
                 KDEType<kernel::GaussianKernel, tree::RTree>*,
                 KDEType<kernel::EpanechnikovKernel, tree::KDTree>*,
                 KDEType<kernel::EpanechnikovKernel, tree::BallTree>*,
                 KDEType<kernel::EpanechnikovKernel, tree::StandardCoverTree>*,
                 KDEType<kernel::EpanechnikovKernel, tree::Octree>*,
                 KDEType<kernel::EpanechnikovKernel, tree::RTree>*,
                 KDEType<kernel::LaplacianKernel, tree::KDTree>*,
                 KDEType<kernel::LaplacianKernel, tree::BallTree>*,
                 KDEType<kernel::LaplacianKernel, tree::StandardCoverTree>*,
                 KDEType<kernel::LaplacianKernel, tree::Octree>*,
                 KDEType<kernel::LaplacianKernel, tree::RTree>*,
                 KDEType<kernel::SphericalKernel, tree::KDTree>*,
                 KDEType<kernel::SphericalKernel, tree::BallTree>*,
                 KDEType<kernel::SphericalKernel, tree::StandardCoverTree>*,
                 KDEType<kernel::SphericalKernel, tree::Octree>*,
                 KDEType<kernel::SphericalKernel, tree::RTree>*,
                 KDEType<kernel::TriangularKernel, tree::KDTree>*,
                 KDEType<kernel::TriangularKernel, tree::BallTree>*,
                 KDEType<kernel::TriangularKernel, tree::StandardCoverTree>*,
                 KDEType<kernel::TriangularKernel, tree::Octree>*,
                 KDEType<kernel::TriangularKernel, tree::RTree>*> kdeModel;
 
 public:
  KDEModel(const double bandwidth = 1.0,
           const double relError = KDEDefaultParams::relError,
           const double absError = KDEDefaultParams::absError,
           const KernelTypes kernelType = KernelTypes::GAUSSIAN_KERNEL,
           const TreeTypes treeType = TreeTypes::KD_TREE,
           const bool monteCarlo = KDEDefaultParams::mode,
           const double mcProb = KDEDefaultParams::mcProb,
           const size_t initialSampleSize = KDEDefaultParams::initialSampleSize,
           const double mcEntryCoef = KDEDefaultParams::mcEntryCoef,
           const double mcBreakCoef = KDEDefaultParams::mcBreakCoef);
 
  KDEModel(const KDEModel& other);
 
  KDEModel(KDEModel&& other);
 
  KDEModel& operator=(KDEModel other);
 
  ~KDEModel();
 
  template<typename Archive>
  void serialize(Archive& ar, const unsigned int version);
 
  double Bandwidth() const { return bandwidth; }
 
  void Bandwidth(const double newBandwidth);
 
  double RelativeError() const { return relError; }
 
  void RelativeError(const double newRelError);
 
  double AbsoluteError() const { return absError; }
 
  void AbsoluteError(const double newAbsError);
 
  TreeTypes TreeType() const { return treeType; }
 
  TreeTypes& TreeType() { return treeType; }
 
  KernelTypes KernelType() const { return kernelType; }
 
  KernelTypes& KernelType() { return kernelType; }
 
  bool MonteCarlo() const { return monteCarlo; }
 
  void MonteCarlo(const bool newMonteCarlo);
 
  double MCProbability() const { return mcProb; }
 
  void MCProbability(const double newMCProb);
 
  size_t MCInitialSampleSize() const { return initialSampleSize; }
 
  void MCInitialSampleSize(const size_t newSampleSize);
 
  double MCEntryCoefficient() const { return mcEntryCoef; }
 
  void MCEntryCoefficient(const double newEntryCoef);
 
  double MCBreakCoefficient() const { return mcBreakCoef; }
 
  void MCBreakCoefficient(const double newBreakCoef);
 
  KDEMode Mode() const;
 
  KDEMode& Mode();
 
  void BuildModel(arma::mat&& referenceSet);
 
  void Evaluate(arma::mat&& querySet, arma::vec& estimations);
 
  void Evaluate(arma::vec& estimations);
 
 
 private:
  void CleanMemory();
};
 
} // namespace kde
} // namespace mlpack
 
BOOST_TEMPLATE_CLASS_VERSION(template<>, mlpack::kde::KDEModel, 1);
 
#include "kde_model_impl.hpp"
 
#endif