rs_model.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_RANGE_SEARCH_RS_MODEL_HPP
#define MLPACK_METHODS_RANGE_SEARCH_RS_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 "range_search.hpp"

namespace mlpack {
namespace range {

template<template<typename TreeMetricType,
                  typename TreeStatType,
                  typename TreeMatType> class TreeType>
using RSType = RangeSearch<metric::EuclideanDistance, arma::mat, TreeType>;

struct RSModelName
{
  static const std::string Name() { return "range_search_model"; }
};

class MonoSearchVisitor : public  boost::static_visitor<void>
{
 private:
  const math::Range& range;
  std::vector<std::vector<size_t>>& neighbors;
  std::vector<std::vector<double>>& distances;

 public:
  template<typename RSType>
  void operator()(RSType* rs) const;

  MonoSearchVisitor(const math::Range& range,
                    std::vector<std::vector<size_t>>& neighbors,
                    std::vector<std::vector<double>>& distances):
      range(range),
      neighbors(neighbors),
      distances(distances)
  {};
};

class BiSearchVisitor : public boost::static_visitor<void>
{
 private:
  const arma::mat& querySet;
  const math::Range& range;
  std::vector<std::vector<size_t>>& neighbors;
  std::vector<std::vector<double>>& distances;
  const size_t leafSize;

  template<typename RSType>
  void SearchLeaf(RSType* rs) const;

 public:
  template<template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  using RSTypeT = RSType<TreeType>;

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

  void operator()(RSTypeT<tree::KDTree>* rs) const;

  void operator()(RSTypeT<tree::BallTree>* rs) const;

  void operator()(RSTypeT<tree::Octree>* rs) const;

  BiSearchVisitor(const arma::mat& querySet,
                  const math::Range& range,
                  std::vector<std::vector<size_t>>& neighbors,
                  std::vector<std::vector<double>>& distances,
                  const size_t leafSize);
};

class TrainVisitor : public boost::static_visitor<void>
{
 private:
  arma::mat&& referenceSet;
  size_t leafSize;
  template<typename RSType>
  void TrainLeaf(RSType* rs) const;

 public:
  template<template<typename TreeMetricType,
                    typename TreeStatType,
                    typename TreeMatType> class TreeType>
  using RSTypeT = RSType<TreeType>;

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

  void operator()(RSTypeT<tree::KDTree>* rs) const;

  void operator()(RSTypeT<tree::BallTree>* rs) const;

  void operator()(RSTypeT<tree::Octree>* rs) const;

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

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

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

template<typename Archive>
class SerializeVisitor : public boost::static_visitor<void>
{
 private:
  Archive& ar;
  const std::string& name;

 public:
  template<typename RSType>
  void operator()(RSType* rs) const;

  SerializeVisitor(Archive& ar, const std::string& name);
};

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

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

class RSModel
{
 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,
    UB_TREE,
    OCTREE
  };

 private:
  TreeTypes treeType;
  size_t leafSize;

  bool randomBasis;
  arma::mat q;

  boost::variant<RSType<tree::KDTree>*,
                 RSType<tree::StandardCoverTree>*,
                 RSType<tree::RTree>*,
                 RSType<tree::RStarTree>*,
                 RSType<tree::BallTree>*,
                 RSType<tree::XTree>*,
                 RSType<tree::HilbertRTree>*,
                 RSType<tree::RPlusTree>*,
                 RSType<tree::RPlusPlusTree>*,
                 RSType<tree::VPTree>*,
                 RSType<tree::RPTree>*,
                 RSType<tree::MaxRPTree>*,
                 RSType<tree::UBTree>*,
                 RSType<tree::Octree>*> rSearch;

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

  RSModel(const RSModel& other);

  RSModel(RSModel&& other);

  RSModel& operator=(const RSModel& other);

  RSModel& operator=(RSModel&& other);

  ~RSModel();

  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();

  size_t LeafSize() const { return leafSize; }
  size_t& LeafSize() { return leafSize; }

  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 bool naive,
                  const bool singleMode);

  void Search(arma::mat&& querySet,
              const math::Range& range,
              std::vector<std::vector<size_t>>& neighbors,
              std::vector<std::vector<double>>& distances);

  void Search(const math::Range& range,
              std::vector<std::vector<size_t>>& neighbors,
              std::vector<std::vector<double>>& distances);

 private:
  std::string TreeName() const;

  void CleanMemory();
};

} // namespace range
} // namespace mlpack

// Include implementation (of Serialize() and inline functions).
#include "rs_model_impl.hpp"

#endif