fastmks.hpp

Go to the documentation of this file.

 
#ifndef MLPACK_METHODS_FASTMKS_FASTMKS_HPP
#define MLPACK_METHODS_FASTMKS_FASTMKS_HPP
 
#include <mlpack/prereqs.hpp>
#include <mlpack/core/metrics/ip_metric.hpp>
#include "fastmks_stat.hpp"
#include <mlpack/core/tree/cover_tree.hpp>
#include <queue>
 
namespace mlpack {
namespace fastmks  {
 
template<
    typename KernelType,
    typename MatType = arma::mat,
    template<typename TreeMetricType,
             typename TreeStatType,
             typename TreeMatType> class TreeType = tree::StandardCoverTree
>
class FastMKS
{
 public:
  typedef TreeType<metric::IPMetric<KernelType>, FastMKSStat, MatType> Tree;
 
  FastMKS(const bool singleMode = false, const bool naive = false);
 
  FastMKS(const MatType& referenceSet,
          const bool singleMode = false,
          const bool naive = false);
 
  FastMKS(const MatType& referenceSet,
          KernelType& kernel,
          const bool singleMode = false,
          const bool naive = false);
 
  FastMKS(MatType&& referenceSet,
          const bool singleMode = false,
          const bool naive = false);
 
  FastMKS(MatType&& referenceSet,
          KernelType& kernel,
          const bool singleMode = false,
          const bool naive = false);
 
  FastMKS(Tree* referenceTree,
          const bool singleMode = false);
 
  FastMKS(const FastMKS& other);
 
  FastMKS(FastMKS&& other);
 
  FastMKS& operator=(const FastMKS& other);
 
  ~FastMKS();
 
  void Train(const MatType& referenceSet);
 
  void Train(const MatType& referenceSet, KernelType& kernel);
 
  void Train(MatType&& referenceSet);
 
  void Train(MatType&& referenceSet, KernelType& kernel);
 
  void Train(Tree* referenceTree);
 
  void Search(const MatType& querySet,
              const size_t k,
              arma::Mat<size_t>& indices,
              arma::mat& kernels);
 
  void Search(Tree* querySet,
              const size_t k,
              arma::Mat<size_t>& indices,
              arma::mat& kernels);
 
  void Search(const size_t k,
              arma::Mat<size_t>& indices,
              arma::mat& products);
 
  const metric::IPMetric<KernelType>& Metric() const { return metric; }
  metric::IPMetric<KernelType>& Metric() { return metric; }
 
  bool SingleMode() const { return singleMode; }
  bool& SingleMode() { return singleMode; }
 
  bool Naive() const { return naive; }
  bool& Naive() { return naive; }
 
  template<typename Archive>
  void serialize(Archive& ar, const unsigned int /* version */);
 
 private:
  const MatType* referenceSet;
  Tree* referenceTree;
  bool treeOwner;
  bool setOwner;
 
  bool singleMode;
  bool naive;
 
  metric::IPMetric<KernelType> metric;
 
  typedef std::pair<double, size_t> Candidate;
 
  struct CandidateCmp {
    bool operator()(const Candidate& c1, const Candidate& c2)
    {
      return c1.first > c2.first;
    };
  };
 
  typedef std::priority_queue<Candidate, std::vector<Candidate>,
      CandidateCmp> CandidateList;
};
 
} // namespace fastmks
} // namespace mlpack
 
// Include implementation.
#include "fastmks_impl.hpp"
 
#endif