ns_model.hpp

Go to the documentation of this file.

 
#ifndef MLPACK_METHODS_NEIGHBOR_SEARCH_NS_MODEL_HPP
#define MLPACK_METHODS_NEIGHBOR_SEARCH_NS_MODEL_HPP
 
#include <mlpack/core/tree/binary_space_tree.hpp>
#include <mlpack/core/tree/cover_tree.hpp>
#include <mlpack/core/tree/rectangle_tree.hpp>
#include <mlpack/core/tree/spill_tree.hpp>
#include <mlpack/core/tree/octree.hpp>
#include <boost/variant.hpp>
#include "neighbor_search.hpp"
 
namespace mlpack {
namespace neighbor {
 
template<typename SortPolicy,
         template<typename TreeMetricType,
                  typename TreeStatType,
                  typename TreeMatType> class TreeType>
using NSType = NeighborSearch<SortPolicy,
                              metric::EuclideanDistance,
                              arma::mat,
                              TreeType,
                              TreeType<metric::EuclideanDistance,
                                  NeighborSearchStat<SortPolicy>,
                                  arma::mat>::template DualTreeTraverser>;
 
class MonoSearchVisitor : public boost::static_visitor<void>
{
 private:
  const size_t k;
  arma::Mat<size_t>& neighbors;
  arma::mat& distances;
 
 public:
  template<typename NSType>
  void operator()(NSType* ns) const;
 
  MonoSearchVisitor(const size_t k,
                    arma::Mat<size_t>& neighbors,
                    arma::mat& distances) :
      k(k),
      neighbors(neighbors),
      distances(distances)
  {};
};
 
template<typename SortPolicy>
class BiSearchVisitor : public boost::static_visitor<void>
{
 private:
  const arma::mat& querySet;
  const size_t k;
  arma::Mat<size_t>& neighbors;
  arma::mat& distances;
  const size_t leafSize;
  const double tau;
  const double rho;
 
  template<typename NSType>
  void SearchLeaf(NSType* ns) const;
 
 public:
  template<template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  using NSTypeT = NSType<SortPolicy, TreeType>;
 
  template<template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(NSTypeT<TreeType>* ns) const;
 
  void operator()(NSTypeT<tree::KDTree>* ns) const;
 
  void operator()(NSTypeT<tree::BallTree>* ns) const;
 
  void operator()(SpillKNN* ns) const;
 
  void operator()(NSTypeT<tree::Octree>* ns) const;
 
  BiSearchVisitor(const arma::mat& querySet,
                  const size_t k,
                  arma::Mat<size_t>& neighbors,
                  arma::mat& distances,
                  const size_t leafSize,
                  const double tau,
                  const double rho);
};
 
template<typename SortPolicy>
class TrainVisitor : public boost::static_visitor<void>
{
 private:
  arma::mat&& referenceSet;
  size_t leafSize;
  const double tau;
  const double rho;
 
  template<typename NSType>
  void TrainLeaf(NSType* ns) const;
 
 public:
  template<template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  using NSTypeT = NSType<SortPolicy, TreeType>;
 
  template<template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(NSTypeT<TreeType>* ns) const;
 
  void operator()(NSTypeT<tree::KDTree>* ns) const;
 
  void operator()(NSTypeT<tree::BallTree>* ns) const;
 
  void operator()(SpillKNN* ns) const;
 
  void operator()(NSTypeT<tree::Octree>* ns) const;
 
  TrainVisitor(arma::mat&& referenceSet,
               const size_t leafSize,
               const double tau,
               const double rho);
};
 
class SearchModeVisitor : public boost::static_visitor<NeighborSearchMode&>
{
 public:
  template<typename NSType>
  NeighborSearchMode& operator()(NSType* ns) const;
};
 
class EpsilonVisitor : public boost::static_visitor<double&>
{
 public:
  template<typename NSType>
  double& operator()(NSType *ns) const;
};
 
class ReferenceSetVisitor : public boost::static_visitor<const arma::mat&>
{
 public:
  template<typename NSType>
  const arma::mat& operator()(NSType *ns) const;
};
 
class DeleteVisitor : public boost::static_visitor<void>
{
 public:
  template<typename NSType>
  void operator()(NSType *ns) const;
};
 
template<typename SortPolicy>
class NSModel
{
 public:
  enum TreeTypes
  {
    KD_TREE,
    COVER_TREE,
    R_TREE,
    R_STAR_TREE,
    BALL_TREE,
    X_TREE,
    HILBERT_R_TREE,
    R_PLUS_TREE,
    R_PLUS_PLUS_TREE,
    VP_TREE,
    RP_TREE,
    MAX_RP_TREE,
    SPILL_TREE,
    UB_TREE,
    OCTREE
  };
 
 private:
  TreeTypes treeType;
 
  size_t leafSize;
 
  double tau;
  double rho;
 
  bool randomBasis;
  arma::mat q;
 
  boost::variant<NSType<SortPolicy, tree::KDTree>*,
                 NSType<SortPolicy, tree::StandardCoverTree>*,
                 NSType<SortPolicy, tree::RTree>*,
                 NSType<SortPolicy, tree::RStarTree>*,
                 NSType<SortPolicy, tree::BallTree>*,
                 NSType<SortPolicy, tree::XTree>*,
                 NSType<SortPolicy, tree::HilbertRTree>*,
                 NSType<SortPolicy, tree::RPlusTree>*,
                 NSType<SortPolicy, tree::RPlusPlusTree>*,
                 NSType<SortPolicy, tree::VPTree>*,
                 NSType<SortPolicy, tree::RPTree>*,
                 NSType<SortPolicy, tree::MaxRPTree>*,
                 SpillKNN*,
                 NSType<SortPolicy, tree::UBTree>*,
                 NSType<SortPolicy, tree::Octree>*> nSearch;
 
 public:
  NSModel(TreeTypes treeType = TreeTypes::KD_TREE, bool randomBasis = false);
 
  NSModel(const NSModel& other);
 
  NSModel(NSModel&& other);
 
  NSModel& operator=(const NSModel& other);
 
  NSModel& operator=(NSModel&& other);
 
  ~NSModel();
 
  template<typename Archive>
  void serialize(Archive& ar, const unsigned int /* version */);
 
  const arma::mat& Dataset() const;
 
  NeighborSearchMode SearchMode() const;
  NeighborSearchMode& SearchMode();
 
  double Epsilon() const;
  double& Epsilon();
 
  size_t LeafSize() const { return leafSize; }
  size_t& LeafSize() { return leafSize; }
 
  double Tau() const { return tau; }
  double& Tau() { return tau; }
 
  double Rho() const { return rho; }
  double& Rho() { return rho; }
 
  TreeTypes TreeType() const { return treeType; }
  TreeTypes& TreeType() { return treeType; }
 
  bool RandomBasis() const { return randomBasis; }
  bool& RandomBasis() { return randomBasis; }
 
  void BuildModel(arma::mat&& referenceSet,
                  const size_t leafSize,
                  const NeighborSearchMode searchMode,
                  const double epsilon = 0);
 
  void Search(arma::mat&& querySet,
              const size_t k,
              arma::Mat<size_t>& neighbors,
              arma::mat& distances);
 
  void Search(const size_t k,
              arma::Mat<size_t>& neighbors,
              arma::mat& distances);
 
  std::string TreeName() const;
};
 
} // namespace neighbor
} // namespace mlpack
 
BOOST_TEMPLATE_CLASS_VERSION(template<typename SortPolicy>,
    mlpack::neighbor::NSModel<SortPolicy>, 1);
 
// Include implementation.
#include "ns_model_impl.hpp"
 
#endif