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