kde.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_KDE_KDE_HPP
#define MLPACK_METHODS_KDE_KDE_HPP

#include <mlpack/prereqs.hpp>
#include <mlpack/core/tree/binary_space_tree.hpp>

#include "kde_stat.hpp"

namespace mlpack {
namespace kde  {

enum KDEMode
{
  DUAL_TREE_MODE,
  SINGLE_TREE_MODE
};

template<typename KernelType = kernel::GaussianKernel,
         typename MetricType = mlpack::metric::EuclideanDistance,
         typename MatType = arma::mat,
         template<typename TreeMetricType,
                  typename TreeStatType,
                  typename TreeMatType> class TreeType = tree::KDTree,
         template<typename RuleType> class DualTreeTraversalType =
             TreeType<MetricType,
                      kde::KDEStat,
                      MatType>::template DualTreeTraverser,
         template<typename RuleType> class SingleTreeTraversalType =
             TreeType<MetricType,
                      kde::KDEStat,
                      MatType>::template SingleTreeTraverser>
class KDE
{
 public:
  typedef TreeType<MetricType, kde::KDEStat, MatType> Tree;

  KDE(const double relError = 0.05,
      const double absError = 0,
      KernelType kernel = KernelType(),
      const KDEMode mode = DUAL_TREE_MODE,
      MetricType metric = MetricType());

  KDE(const KDE& other);

  KDE(KDE&& other);

  KDE& operator=(KDE other);

  ~KDE();

  void Train(MatType referenceSet);

  void Train(Tree* referenceTree, std::vector<size_t>* oldFromNewReferences);

  void Evaluate(MatType querySet, arma::vec& estimations);

  void Evaluate(Tree* queryTree,
                const std::vector<size_t>& oldFromNewQueries,
                arma::vec& estimations);

  void Evaluate(arma::vec& estimations);

  const KernelType& Kernel() const { return kernel; }

  KernelType& Kernel() { return kernel; }

  const MetricType& Metric() const { return metric; }

  MetricType& Metric() { return metric; }

  Tree* ReferenceTree() { return referenceTree; }

  double RelativeError() const { return relError; }

  void RelativeError(const double newError);

  double AbsoluteError() const { return absError; }

  void AbsoluteError(const double newError);

  bool OwnsReferenceTree() const { return ownsReferenceTree; }

  bool IsTrained() const { return trained; }

  KDEMode Mode() const { return mode; }

  KDEMode& Mode() { return mode; }

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

 private:
  KernelType kernel;

  MetricType metric;

  Tree* referenceTree;

  std::vector<size_t>* oldFromNewReferences;

  double relError;

  double absError;

  bool ownsReferenceTree;

  bool trained;

  KDEMode mode;

  static void CheckErrorValues(const double relError, const double absError);

  static void RearrangeEstimations(const std::vector<size_t>& oldFromNew,
                                   arma::vec& estimations);
};

} // namespace kde
} // namespace mlpack

// Include implementation.
#include "kde_impl.hpp"

#endif // MLPACK_METHODS_KDE_KDE_HPP