mlpack
hpt_impl.hpp
Go to the documentation of this file.
1 
12 #ifndef MLPACK_CORE_HPT_HPT_IMPL_HPP
13 #define MLPACK_CORE_HPT_HPT_IMPL_HPP
14 
15 #include <mlpack/core.hpp>
16 
17 namespace mlpack {
18 namespace hpt {
19 
20 template<typename MLAlgorithm,
21  typename Metric,
22  template<typename, typename, typename, typename, typename> class CV,
23  typename Optimizer,
24  typename MatType,
25  typename PredictionsType,
26  typename WeightsType>
27 template<typename... CVArgs>
28 HyperParameterTuner<MLAlgorithm,
29  Metric,
30  CV,
31  Optimizer,
32  MatType,
33  PredictionsType,
34  WeightsType>::HyperParameterTuner(const CVArgs&... args) :
35  cv(args...), relativeDelta(0.01), minDelta(1e-10) {}
36 
37 template<typename MLAlgorithm,
38  typename Metric,
39  template<typename, typename, typename, typename, typename> class CV,
40  typename Optimizer,
41  typename MatType,
42  typename PredictionsType,
43  typename WeightsType>
44 template<typename... Args>
45 TupleOfHyperParameters<Args...> HyperParameterTuner<MLAlgorithm,
46  Metric,
47  CV,
48  Optimizer,
49  MatType,
50  PredictionsType,
51  WeightsType>::Optimize(
52  const Args&... args)
53 {
54  static const size_t numberOfParametersToOptimize =
55  std::tuple_size<TupleOfHyperParameters<Args...>>::value;
56  data::IncrementPolicy policy(true);
57  data::DatasetMapper<data::IncrementPolicy, double> datasetInfo(policy,
58  numberOfParametersToOptimize);
59 
60  arma::mat bestParameters(numberOfParametersToOptimize, 1);
61  const auto argsTuple = std::tie(args...);
62 
63  InitAndOptimize<0>(argsTuple, bestParameters, datasetInfo);
64 
65  for (size_t i = 0; i < datasetInfo.Dimensionality(); ++i)
66  {
67  if (datasetInfo.Type(i) == data::Datatype::categorical)
68  bestParameters[i] = datasetInfo.UnmapString(bestParameters[i], i);
69  }
70 
71  return VectorToTuple<TupleOfHyperParameters<Args...>, 0>(bestParameters);
72 }
73 
74 template<typename MLAlgorithm,
75  typename Metric,
76  template<typename, typename, typename, typename, typename> class CV,
77  typename Optimizer,
78  typename MatType,
79  typename PredictionsType,
80  typename WeightsType>
81 template<size_t I, typename ArgsTuple, typename... FixedArgs, typename>
82 void HyperParameterTuner<MLAlgorithm,
83  Metric,
84  CV,
85  Optimizer,
86  MatType,
87  PredictionsType,
88  WeightsType>::InitAndOptimize(
89  const ArgsTuple& /* args */,
90  arma::mat& bestParams,
91  data::DatasetMapper<data::IncrementPolicy, double>& datasetInfo,
92  FixedArgs... fixedArgs)
93 {
94  static const size_t totalArgs = std::tuple_size<ArgsTuple>::value;
95 
96  std::vector<bool> categoricalDimensions(datasetInfo.Dimensionality());
97  arma::Row<size_t> numCategories(datasetInfo.Dimensionality());
98  for (size_t d = 0; d < datasetInfo.Dimensionality(); d++)
99  {
100  numCategories[d] = datasetInfo.NumMappings(d);
101  categoricalDimensions[d] = datasetInfo.Type(d) ==
102  mlpack::data::Datatype::categorical;
103  }
104 
105  CVFunction<CVType, MLAlgorithm, totalArgs, FixedArgs...>
106  cvFunction(cv, datasetInfo, relativeDelta, minDelta, fixedArgs...);
107  bestObjective = Metric::NeedsMinimization ? optimizer.Optimize(cvFunction,
108  bestParams, categoricalDimensions, numCategories) :
109  -optimizer.Optimize(cvFunction, bestParams, categoricalDimensions,
110  numCategories);
111  bestModel = std::move(cvFunction.BestModel());
112 }
113 
114 template<typename MLAlgorithm,
115  typename Metric,
116  template<typename, typename, typename, typename, typename> class CV,
117  typename Optimizer,
118  typename MatType,
119  typename PredictionsType,
120  typename WeightsType>
121 template<size_t I, class ArgsTuple, class... FixedArgs, class, class>
122 void HyperParameterTuner<MLAlgorithm,
123  Metric,
124  CV,
125  Optimizer,
126  MatType,
127  PredictionsType,
128  WeightsType>::InitAndOptimize(
129  const ArgsTuple& args,
130  arma::mat& bestParams,
131  data::DatasetMapper<data::IncrementPolicy, double>& datasetInfo,
132  FixedArgs... fixedArgs)
133 {
134  using PreFixedArgT = typename std::remove_reference<
135  typename std::tuple_element<I, ArgsTuple>::type>::type;
136  using FixedArgT = FixedArg<typename PreFixedArgT::Type, I>;
137 
138  InitAndOptimize<I + 1>(args, bestParams, datasetInfo, fixedArgs...,
139  FixedArgT{std::get<I>(args).value});
140 }
141 
142 template<typename MLAlgorithm,
143  typename Metric,
144  template<typename, typename, typename, typename, typename> class CV,
145  typename Optimizer,
146  typename MatType,
147  typename PredictionsType,
148  typename WeightsType>
149 template<size_t I, class ArgsTuple, class... FixedArgs, class, class, class>
150 void HyperParameterTuner<MLAlgorithm,
151  Metric,
152  CV,
153  Optimizer,
154  MatType,
155  PredictionsType,
156  WeightsType>::InitAndOptimize(
157  const ArgsTuple& args,
158  arma::mat& bestParams,
159  data::DatasetMapper<data::IncrementPolicy, double>& datasetInfo,
160  FixedArgs... fixedArgs)
161 {
162  static const size_t dimension =
163  I - std::tuple_size<std::tuple<FixedArgs...>>::value;
164  datasetInfo.Type(dimension) = data::Datatype::numeric;
165  bestParams(dimension) = std::get<I>(args);
166 
167  InitAndOptimize<I + 1>(args, bestParams, datasetInfo, fixedArgs...);
168 }
169 
170 template<typename MLAlgorithm,
171  typename Metric,
172  template<typename, typename, typename, typename, typename> class CV,
173  typename Optimizer,
174  typename MatType,
175  typename PredictionsType,
176  typename WeightsType>
177 template<size_t I, class ArgsTuple, class... FixedArgs, class, class, class,
178  class>
179 void HyperParameterTuner<MLAlgorithm,
180  Metric,
181  CV,
182  Optimizer,
183  MatType,
184  PredictionsType,
185  WeightsType>::InitAndOptimize(
186  const ArgsTuple& args,
187  arma::mat& bestParams,
188  data::DatasetMapper<data::IncrementPolicy, double>& datasetInfo,
189  FixedArgs... fixedArgs)
190 {
191  static const size_t dimension =
192  I - std::tuple_size<std::tuple<FixedArgs...>>::value;
193  for (auto value : std::get<I>(args))
194  datasetInfo.MapString<size_t>(value, dimension);
195 
196  if (datasetInfo.NumMappings(dimension) == 0)
197  {
198  std::ostringstream oss;
199  oss << "HyperParameterTuner::Optimize(): the collection passed as the "
200  << "argument " << I + 1 << " is empty" << std::endl;
201  throw std::invalid_argument(oss.str());
202  }
203 
204  InitAndOptimize<I + 1>(args, bestParams, datasetInfo, fixedArgs...);
205 }
206 
207 template<typename MLAlgorithm,
208  typename Metric,
209  template<typename, typename, typename, typename, typename> class CV,
210  typename Optimizer,
211  typename MatType,
212  typename PredictionsType,
213  typename WeightsType>
214 template<typename TupleType, size_t I, typename... Args, typename>
215 TupleType HyperParameterTuner<MLAlgorithm,
216  Metric,
217  CV,
218  Optimizer,
219  MatType,
220  PredictionsType,
221  WeightsType>::VectorToTuple(
222  const arma::vec& vector, const Args&... args)
223 {
224  return VectorToTuple<TupleType, I + 1>(vector, args..., vector(I));
225 }
226 
227 template<typename MLAlgorithm,
228  typename Metric,
229  template<typename, typename, typename, typename, typename> class CV,
230  typename Optimizer,
231  typename MatType,
232  typename PredictionsType,
233  typename WeightsType>
234 template<typename TupleType, size_t I, typename... Args, typename, typename>
235 TupleType HyperParameterTuner<MLAlgorithm,
236  Metric,
237  CV,
238  Optimizer,
239  MatType,
240  PredictionsType,
241  WeightsType>::VectorToTuple(
242  const arma::vec& /* vector */, const Args&... args)
243 {
244  return TupleType(args...);
245 }
246 
247 } // namespace hpt
248 } // namespace mlpack
249 
250 #endif
mlpack::data::DatasetMapper
Auxiliary information for a dataset, including mappings to/from strings (or other types) and the data...
Definition: dataset_mapper.hpp:41
mlpack::data::IncrementPolicy
IncrementPolicy is used as a helper class for DatasetMapper.
Definition: increment_policy.hpp:33
mlpack
Linear algebra utility functions, generally performed on matrices or vectors.
Definition: cv.hpp:1
mlpack::hpt::HyperParameterTuner
The class HyperParameterTuner for the given MLAlgorithm utilizes the provided Optimizer to find the v...
Definition: hpt.hpp:96
mlpack::data::DatasetMapper::Dimensionality
size_t Dimensionality() const
Get the dimensionality of the DatasetMapper object (that is, how many dimensions it has information f...
Definition: dataset_mapper_impl.hpp:228
mlpack::data::DatasetMapper::UnmapString
const InputType & UnmapString(const T value, const size_t dimension, const size_t unmappingIndex=0) const
Return the input that corresponds to a given value in a given dimension.
Definition: dataset_mapper_impl.hpp:125
mlpack::data::DatasetMapper::MapString
T MapString(const InputType &input, const size_t dimension)
Given the input and the dimension to which it belongs, return its numeric mapping.
Definition: dataset_mapper_impl.hpp:85
mlpack::data::DatasetMapper::Type
Datatype Type(const size_t dimension) const
Return the type of a given dimension (numeric or categorical).
Definition: dataset_mapper_impl.hpp:196
core.hpp
Include all of the base components required to write mlpack methods, and the main mlpack Doxygen docu...
mlpack::hpt::HyperParameterTuner::Optimizer
OptimizerType & Optimizer()
Access and modify the optimizer.
Definition: hpt.hpp:110
mlpack::data::DatasetMapper::NumMappings
size_t NumMappings(const size_t dimension) const
Get the number of mappings for a particular dimension.
Definition: dataset_mapper_impl.hpp:222
mlpack::hpt::FixedArg
A struct for storing information about a fixed argument.
Definition: fixed.hpp:52
mlpack::hpt::CVFunction
This wrapper serves for adapting the interface of the cross-validation classes to the one that can be...
Definition: cv_function.hpp:39
mlpack::hpt::TupleOfHyperParameters
typename DeduceHyperParameterTypes< Args... >::TupleType TupleOfHyperParameters
A short alias for deducing types of hyper-parameters from types of arguments in the Optimize method i...
Definition: deduce_hp_types.hpp:127
mlpack::hpt::HyperParameterTuner::Optimize
TupleOfHyperParameters< Args... > Optimize(const Args &... args)
Find the best hyper-parameters by using the given Optimizer.
Definition: hpt_impl.hpp:51
Generated by   doxygen 1.8.13