hpt.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_HPT_HPT_HPP
#define MLPACK_CORE_HPT_HPT_HPP

#include <mlpack/core/cv/meta_info_extractor.hpp>
#include <mlpack/core/hpt/deduce_hp_types.hpp>
#include 

namespace mlpack {
namespace hpt {

template<typename MLAlgorithm,
         typename Metric,
         template<typename, typename, typename, typename, typename> class CV,
         typename OptimizerType = ens::GridSearch,
         typename MatType = arma::mat,
         typename PredictionsType =
             typename cv::MetaInfoExtractor                  MatType>::PredictionsType,          typename WeightsType =              typename cv::MetaInfoExtractor                  PredictionsType>::WeightsType> class HyperParameterTuner {  public:   template<typename... CVArgs>   HyperParameterTuner(const CVArgs& ...args);    OptimizerType& Optimizer() { return optimizer; }    double RelativeDelta() const { return relativeDelta; }    double& RelativeDelta() { return relativeDelta; }    double MinDelta() const { return minDelta; }    double& MinDelta() { return minDelta; }    template<typename... Args>   TupleOfHyperParameters Optimize(const Args&... args);    double BestObjective() const { return bestObjective; }    const MLAlgorithm& BestModel() const { return bestModel; }    MLAlgorithm& BestModel() { return bestModel; }   private:   template<typename OriginalMetric>   struct Negated   {     static double Evaluate(MLAlgorithm& model,                            const MatType& xs,                            const PredictionsType& ys)     { return -OriginalMetric::Evaluate(model, xs, ys); }   };    using CVType = typename std::conditional       CV,       CV, MatType, PredictionsType,           WeightsType>>::type;     CVType cv;    OptimizerType optimizer;    double bestObjective;    MLAlgorithm bestModel;    double relativeDelta;    double minDelta;    template<typename Tuple, size_t I>   using IsPreFixed = IsPreFixedArg::type>;    template<typename Tuple, size_t I>   using IsArithmetic = std::is_arithmetic<typename std::remove_reference<       typename std::tuple_element::type>::type>;    template<size_t I /* Index of the next argument to handle. */,            typename ArgsTuple,            typename... FixedArgs,            typename = std::enable_if_t::value>>   inline void InitAndOptimize(       const ArgsTuple& args,       arma::mat& bestParams,       data::DatasetMapper& datasetInfo,       FixedArgs... fixedArgs);    template<size_t I /* Index of the next argument to handle. */,            typename ArgsTuple,            typename... FixedArgs,            typename = std::enable_if_t<(I < std::tuple_size::value)>,            typename = std::enable_if_t<IsPreFixed::value>>   inline void InitAndOptimize(       const ArgsTuple& args,       arma::mat& bestParams,       data::DatasetMapper& datasetInfo,       FixedArgs... fixedArgs);    template<size_t I /* Index of the next argument to handle. */,            typename ArgsTuple,            typename... FixedArgs,            typename = std::enable_if_t<(I < std::tuple_size::value)>,            typename = std::enable_if_tIsPreFixed::value &&                    IsArithmetic::value>,            typename = void>   inline void InitAndOptimize(       const ArgsTuple& args,       arma::mat& bestParams,       data::DatasetMapper& datasetInfo,       FixedArgs... fixedArgs);    template<size_t I /* Index of the next argument to handle. */,            typename ArgsTuple,            typename... FixedArgs,            typename = std::enable_if_t<(I < std::tuple_size::value)>,            typename = std::enable_if_tIsPreFixed::value &&                    !IsArithmetic::value>,            typename = void,            typename = void>   inline void InitAndOptimize(       const ArgsTuple& args,       arma::mat& bestParams,       data::DatasetMapper& datasetInfo,       FixedArgs... fixedArgs);    template<typename TupleType,            size_t I /* Index of the element in vector to handle. */,            typename... Args,            typename = typename                std::enable_if_t<(I < std::tuple_size::value)>>   inline TupleType VectorToTuple(const arma::vec& vector, const Args&... args);    template<typename TupleType,            size_t I /* Index of the element in vector to handle. */,            typename... Args,            typename = typename                std::enable_if_t::value>,            typename = void>   inline TupleType VectorToTuple(const arma::vec& vector, const Args&... args); };  } // namespace hpt } // namespace mlpack  // Include implementation #include "hpt_impl.hpp"  #endif



















                 MatType>::PredictionsType,
         typename WeightsType =
             typename cv::MetaInfoExtractor                  PredictionsType>::WeightsType> class HyperParameterTuner {  public:   template<typename... CVArgs>   HyperParameterTuner(const CVArgs& ...args);    OptimizerType& Optimizer() { return optimizer; }    double RelativeDelta() const { return relativeDelta; }    double& RelativeDelta() { return relativeDelta; }    double MinDelta() const { return minDelta; }    double& MinDelta() { return minDelta; }    template<typename... Args>   TupleOfHyperParameters Optimize(const Args&... args);    double BestObjective() const { return bestObjective; }    const MLAlgorithm& BestModel() const { return bestModel; }    MLAlgorithm& BestModel() { return bestModel; }   private:   template<typename OriginalMetric>   struct Negated   {     static double Evaluate(MLAlgorithm& model,                            const MatType& xs,                            const PredictionsType& ys)     { return -OriginalMetric::Evaluate(model, xs, ys); }   };    using CVType = typename std::conditional       CV,       CV, MatType, PredictionsType,           WeightsType>>::type;     CVType cv;    OptimizerType optimizer;    double bestObjective;    MLAlgorithm bestModel;    double relativeDelta;    double minDelta;    template<typename Tuple, size_t I>   using IsPreFixed = IsPreFixedArg::type>;    template<typename Tuple, size_t I>   using IsArithmetic = std::is_arithmetic<typename std::remove_reference<       typename std::tuple_element::type>::type>;    template<size_t I /* Index of the next argument to handle. */,            typename ArgsTuple,            typename... FixedArgs,            typename = std::enable_if_t::value>>   inline void InitAndOptimize(       const ArgsTuple& args,       arma::mat& bestParams,       data::DatasetMapper& datasetInfo,       FixedArgs... fixedArgs);    template<size_t I /* Index of the next argument to handle. */,            typename ArgsTuple,            typename... FixedArgs,            typename = std::enable_if_t<(I < std::tuple_size::value)>,            typename = std::enable_if_t<IsPreFixed::value>>   inline void InitAndOptimize(       const ArgsTuple& args,       arma::mat& bestParams,       data::DatasetMapper& datasetInfo,       FixedArgs... fixedArgs);    template<size_t I /* Index of the next argument to handle. */,            typename ArgsTuple,            typename... FixedArgs,            typename = std::enable_if_t<(I < std::tuple_size::value)>,            typename = std::enable_if_tIsPreFixed::value &&                    IsArithmetic::value>,            typename = void>   inline void InitAndOptimize(       const ArgsTuple& args,       arma::mat& bestParams,       data::DatasetMapper& datasetInfo,       FixedArgs... fixedArgs);    template<size_t I /* Index of the next argument to handle. */,            typename ArgsTuple,            typename... FixedArgs,            typename = std::enable_if_t<(I < std::tuple_size::value)>,            typename = std::enable_if_tIsPreFixed::value &&                    !IsArithmetic::value>,            typename = void,            typename = void>   inline void InitAndOptimize(       const ArgsTuple& args,       arma::mat& bestParams,       data::DatasetMapper& datasetInfo,       FixedArgs... fixedArgs);    template<typename TupleType,            size_t I /* Index of the element in vector to handle. */,            typename... Args,            typename = typename                std::enable_if_t<(I < std::tuple_size::value)>>   inline TupleType VectorToTuple(const arma::vec& vector, const Args&... args);    template<typename TupleType,            size_t I /* Index of the element in vector to handle. */,            typename... Args,            typename = typename                std::enable_if_t::value>,            typename = void>   inline TupleType VectorToTuple(const arma::vec& vector, const Args&... args); };  } // namespace hpt } // namespace mlpack  // Include implementation #include "hpt_impl.hpp"  #endif


















                 PredictionsType>::WeightsType>
class HyperParameterTuner
{
 public:
  template<typename... CVArgs>
  HyperParameterTuner(const CVArgs& ...args);

  OptimizerType& Optimizer() { return optimizer; }

  double RelativeDelta() const { return relativeDelta; }

  double& RelativeDelta() { return relativeDelta; }

  double MinDelta() const { return minDelta; }

  double& MinDelta() { return minDelta; }

  template<typename... Args>
  TupleOfHyperParameters Optimize(const Args&... args);

  double BestObjective() const { return bestObjective; }

  const MLAlgorithm& BestModel() const { return bestModel; }

  MLAlgorithm& BestModel() { return bestModel; }

 private:
  template<typename OriginalMetric>
  struct Negated
  {
    static double Evaluate(MLAlgorithm& model,
                           const MatType& xs,
                           const PredictionsType& ys)
    { return -OriginalMetric::Evaluate(model, xs, ys); }
  };

  using CVType = typename std::conditional       CV,       CV, MatType, PredictionsType,           WeightsType>>::type;     CVType cv;    OptimizerType optimizer;    double bestObjective;    MLAlgorithm bestModel;    double relativeDelta;    double minDelta;    template<typename Tuple, size_t I>   using IsPreFixed = IsPreFixedArg::type>;    template<typename Tuple, size_t I>   using IsArithmetic = std::is_arithmetic<typename std::remove_reference<       typename std::tuple_element::type>::type>;    template<size_t I /* Index of the next argument to handle. */,            typename ArgsTuple,            typename... FixedArgs,            typename = std::enable_if_t::value>>   inline void InitAndOptimize(       const ArgsTuple& args,       arma::mat& bestParams,       data::DatasetMapper& datasetInfo,       FixedArgs... fixedArgs);    template<size_t I /* Index of the next argument to handle. */,            typename ArgsTuple,            typename... FixedArgs,            typename = std::enable_if_t<(I < std::tuple_size::value)>,            typename = std::enable_if_t<IsPreFixed::value>>   inline void InitAndOptimize(       const ArgsTuple& args,       arma::mat& bestParams,       data::DatasetMapper& datasetInfo,       FixedArgs... fixedArgs);    template<size_t I /* Index of the next argument to handle. */,            typename ArgsTuple,            typename... FixedArgs,            typename = std::enable_if_t<(I < std::tuple_size::value)>,            typename = std::enable_if_tIsPreFixed::value &&                    IsArithmetic::value>,            typename = void>   inline void InitAndOptimize(       const ArgsTuple& args,       arma::mat& bestParams,       data::DatasetMapper& datasetInfo,       FixedArgs... fixedArgs);    template<size_t I /* Index of the next argument to handle. */,            typename ArgsTuple,            typename... FixedArgs,            typename = std::enable_if_t<(I < std::tuple_size::value)>,            typename = std::enable_if_tIsPreFixed::value &&                    !IsArithmetic::value>,            typename = void,            typename = void>   inline void InitAndOptimize(       const ArgsTuple& args,       arma::mat& bestParams,       data::DatasetMapper& datasetInfo,       FixedArgs... fixedArgs);    template<typename TupleType,            size_t I /* Index of the element in vector to handle. */,            typename... Args,            typename = typename                std::enable_if_t<(I < std::tuple_size::value)>>   inline TupleType VectorToTuple(const arma::vec& vector, const Args&... args);    template<typename TupleType,            size_t I /* Index of the element in vector to handle. */,            typename... Args,            typename = typename                std::enable_if_t::value>,            typename = void>   inline TupleType VectorToTuple(const arma::vec& vector, const Args&... args); };  } // namespace hpt } // namespace mlpack  // Include implementation #include "hpt_impl.hpp"  #endif


















      CV,
      CV, MatType, PredictionsType,
          WeightsType>>::type;


  CVType cv;

  OptimizerType optimizer;

  double bestObjective;

  MLAlgorithm bestModel;

  double relativeDelta;

  double minDelta;

  template<typename Tuple, size_t I>
  using IsPreFixed = IsPreFixedArg::type>;

  template<typename Tuple, size_t I>
  using IsArithmetic = std::is_arithmetic<typename std::remove_reference<
      typename std::tuple_element::type>::type>;

  template<size_t I /* Index of the next argument to handle. */,
           typename ArgsTuple,
           typename... FixedArgs,
           typename = std::enable_if_t::value>>
  inline void InitAndOptimize(
      const ArgsTuple& args,
      arma::mat& bestParams,
      data::DatasetMapper& datasetInfo,
      FixedArgs... fixedArgs);

  template<size_t I /* Index of the next argument to handle. */,
           typename ArgsTuple,
           typename... FixedArgs,
           typename = std::enable_if_t<(I < std::tuple_size::value)>,
           typename = std::enable_if_t<IsPreFixed::value>>
  inline void InitAndOptimize(
      const ArgsTuple& args,
      arma::mat& bestParams,
      data::DatasetMapper& datasetInfo,
      FixedArgs... fixedArgs);

  template<size_t I /* Index of the next argument to handle. */,
           typename ArgsTuple,
           typename... FixedArgs,
           typename = std::enable_if_t<(I < std::tuple_size::value)>,
           typename = std::enable_if_tIsPreFixed::value &&
                   IsArithmetic::value>,
           typename = void>
  inline void InitAndOptimize(
      const ArgsTuple& args,
      arma::mat& bestParams,
      data::DatasetMapper& datasetInfo,
      FixedArgs... fixedArgs);

  template<size_t I /* Index of the next argument to handle. */,
           typename ArgsTuple,
           typename... FixedArgs,
           typename = std::enable_if_t<(I < std::tuple_size::value)>,
           typename = std::enable_if_tIsPreFixed::value &&
                   !IsArithmetic::value>,
           typename = void,
           typename = void>
  inline void InitAndOptimize(
      const ArgsTuple& args,
      arma::mat& bestParams,
      data::DatasetMapper& datasetInfo,
      FixedArgs... fixedArgs);

  template<typename TupleType,
           size_t I /* Index of the element in vector to handle. */,
           typename... Args,
           typename = typename
               std::enable_if_t<(I < std::tuple_size::value)>>
  inline TupleType VectorToTuple(const arma::vec& vector, const Args&... args);

  template<typename TupleType,
           size_t I /* Index of the element in vector to handle. */,
           typename... Args,
           typename = typename
               std::enable_if_t::value>,
           typename = void>
  inline TupleType VectorToTuple(const arma::vec& vector, const Args&... args);
};

} // namespace hpt
} // namespace mlpack

// Include implementation
#include "hpt_impl.hpp"

#endif