ra_model.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_RANN_RA_MODEL_HPP
#define MLPACK_METHODS_RANN_RA_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/octree.hpp>
#include <boost/variant.hpp>
#include "ra_search.hpp"

namespace mlpack {
namespace neighbor {

template<typename SortPolicy,
         template<typename TreeMetricType,
                  typename TreeStatType,
                  typename TreeMatType> class TreeType>
using RAType = RASearch<SortPolicy,
                        metric::EuclideanDistance,
                        arma::mat,
                        TreeType>;

class MonoSearchVisitor : public boost::static_visitor<void>
{
 private:
  const size_t k;
  arma::Mat<size_t>& neighbors;
  arma::mat& distances;

 public:
  template<typename RAType>
  void operator()(RAType* ra) 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;

  template<typename RAType>
  void SearchLeaf(RAType* ra) const;

 public:
  template<template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  using RATypeT = RAType<SortPolicy, TreeType>;

  template<template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(RATypeT<TreeType>* ra) const;

  void operator()(RATypeT<tree::KDTree>* ra) const;

  void operator()(RATypeT<tree::Octree>* ra) const;

  BiSearchVisitor(const arma::mat& querySet,
                  const size_t k,
                  arma::Mat<size_t>& neighbors,
                  arma::mat& distances,
                  const size_t leafSize);
};

template<typename SortPolicy>
class TrainVisitor : public boost::static_visitor<void>
{
 private:
  arma::mat&& referenceSet;
  size_t leafSize;

  template<typename RAType>
  void TrainLeaf(RAType* ra) const;

 public:
  template<template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  using RATypeT = RAType<SortPolicy, TreeType>;

  template<template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  void operator()(RATypeT<TreeType>* ra) const;

  void operator()(RATypeT<tree::KDTree>* ra) const;

  void operator()(RATypeT<tree::Octree>* ra) const;

  TrainVisitor(arma::mat&& referenceSet,
               const size_t leafSize);
};

class SingleSampleLimitVisitor : public boost::static_visitor<size_t&>
{
 public:
  template<typename RAType>
  size_t& operator()(RAType* ra) const;
};

class FirstLeafExactVisitor : public boost::static_visitor<bool&>
{
 public:
  template<typename RAType>
  bool& operator()(RAType* ra) const;
};

class SampleAtLeavesVisitor : public boost::static_visitor<bool&>
{
 public:
  template<typename RAType>
  bool& operator()(RAType *) const;
};

class AlphaVisitor : public boost::static_visitor<double&>
{
 public:
  template<typename RAType>
  double& operator()(RAType* ra) const;
};

class TauVisitor : public boost::static_visitor<double&>
{
 public:
  template<typename RAType>
  double& operator()(RAType* ra) const;
};

class SingleModeVisitor : public boost::static_visitor<bool&>
{
 public:
  template<typename RAType>
  bool& operator()(RAType* ra) const;
};

class ReferenceSetVisitor : public boost::static_visitor<const arma::mat&>
{
 public:
  template<typename RAType>
  const arma::mat& operator()(RAType* ra) const;
};

class DeleteVisitor : public boost::static_visitor<void>
{
 public:
  template<typename RAType> void operator()(RAType* ra) const;
};

class NaiveVisitor : public boost::static_visitor<bool&>
{
 public:
  template<typename RAType>
  bool& operator()(RAType* ra) const;
};

template<typename SortPolicy>
class RAModel
{
 public:
  enum TreeTypes
  {
    KD_TREE,
    COVER_TREE,
    R_TREE,
    R_STAR_TREE,
    X_TREE,
    HILBERT_R_TREE,
    R_PLUS_TREE,
    R_PLUS_PLUS_TREE,
    UB_TREE,
    OCTREE
  };

 private:
  TreeTypes treeType;
  size_t leafSize;

  bool randomBasis;
  arma::mat q;

  boost::variant<RAType<SortPolicy, tree::KDTree>*,
                 RAType<SortPolicy, tree::StandardCoverTree>*,
                 RAType<SortPolicy, tree::RTree>*,
                 RAType<SortPolicy, tree::RStarTree>*,
                 RAType<SortPolicy, tree::XTree>*,
                 RAType<SortPolicy, tree::HilbertRTree>*,
                 RAType<SortPolicy, tree::RPlusTree>*,
                 RAType<SortPolicy, tree::RPlusPlusTree>*,
                 RAType<SortPolicy, tree::UBTree>*,
                 RAType<SortPolicy, tree::Octree>*> raSearch;

 public:
  RAModel(TreeTypes treeType = TreeTypes::KD_TREE, bool randomBasis = false);

  RAModel(const RAModel& other);

  RAModel(RAModel&& other);

  RAModel& operator=(const RAModel& other);

  RAModel& operator=(RAModel&& other);

  ~RAModel();

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

  const arma::mat& Dataset() const;

  bool SingleMode() const;
  bool& SingleMode();

  bool Naive() const;
  bool& Naive();

  double Tau() const;
  double& Tau();

  double Alpha() const;
  double& Alpha();

  bool SampleAtLeaves() const;
  bool& SampleAtLeaves();

  bool FirstLeafExact() const;
  bool& FirstLeafExact();

  size_t SingleSampleLimit() const;
  size_t& SingleSampleLimit();

  size_t LeafSize() const;
  size_t& LeafSize();

  TreeTypes TreeType() const;
  TreeTypes& TreeType();

  bool RandomBasis() const;
  bool& RandomBasis();

  void BuildModel(arma::mat&& referenceSet,
                  const size_t leafSize,
                  const bool naive,
                  const bool singleMode);

  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

#include "ra_model_impl.hpp"

#endif