MeLOn
scaler.h
Go to the documentation of this file.
1 /**********************************************************************************
2 * Copyright (c) 2020 Process Systems Engineering (AVT.SVT), RWTH Aachen University
3 *
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License 2.0 which is available at
6 * http://www.eclipse.org/legal/epl-2.0.
7 *
8 * SPDX-License-Identifier: EPL-2.0
9 *
10 * @file scaler.h
11 *
12 * @brief File containing declaration of the scaler classes.
13 *
14 **********************************************************************************/
15 
16 #pragma once
17 
18 #include <vector> // std::vector
19 #include <string> // std::string
20 #include <memory> // std::unique_ptr, std::make_unique
21 #include <unordered_map> // std::unordered_map
22 
23 #include "exceptions.h"
24 
25 namespace melon {
26 
31  enum SCALER_TYPE {
32  IDENTITY = 0,
33  MINMAX,
34  STANDARD,
35  };
36 
41  enum SCALER_PARAMETER {
42  LOWER_BOUNDS = 0,
43  UPPER_BOUNDS,
45  MEAN,
48  };
49 
54  struct ScalerData {
57  std::unordered_map<SCALER_PARAMETER, std::vector<double>> parameters;
58  };
59 
64  template<typename T>
65  class Scaler {
66  public:
74  virtual std::vector<T> scale(const std::vector<T>& input) = 0;
75 
83  virtual std::vector<T> descale(const std::vector<T>& input) = 0;
84 
89  virtual ~Scaler() = default;
90  };
91 
96  template<typename T>
97  class ScalerFactory {
98  public:
99 
107  static std::unique_ptr<Scaler<T>> create_scaler(const std::shared_ptr<const ScalerData> scalerData);
108  };
109 
114  template<typename T>
115  class IdentityScaler : public Scaler<T> {
116  public:
117  IdentityScaler() = default;
118  ~IdentityScaler() = default;
119 
127  std::vector<T> scale(const std::vector<T>& input) override { return input; };
128 
136  std::vector<T> descale(const std::vector<T>& input) override { return input; };
137  };
138 
143  template<typename T>
144  class MinMaxScaler : public Scaler<T> {
145  private:
146  std::vector<double> _lowerBounds;
147  std::vector<double> _upperBounds;
148 
149  std::vector<double> _scaledLowerBounds;
150  std::vector<double> _scaledUpperBounds;
151 
152  public:
153  MinMaxScaler(const std::vector<double>& lowerBounds, const std::vector<double>& upperBounds, const std::vector<double>& scaledLowerBounds, const std::vector<double>& scaledUpperBounds) : _lowerBounds(lowerBounds), _upperBounds(upperBounds), _scaledLowerBounds(scaledLowerBounds), _scaledUpperBounds(scaledUpperBounds) {};
154 
162  std::vector<T> scale(const std::vector<T>& input) override;
163 
171  std::vector<T> descale(const std::vector<T>& input) override;
172  };
173 
178  template<typename T>
179  class StandardScaler : public Scaler<T> {
180  private:
181  std::vector<double> _mean;
182  std::vector<double> _stdDev;
183  public:
184  StandardScaler(const std::vector<double>& mean, const std::vector<double>& stdDev) : _mean(mean), _stdDev(stdDev) {};
185 
193  std::vector<T> scale(const std::vector<T>& input) override;
194 
202  std::vector<T> descale(const std::vector<T>& input) override;
203  };
204 
206  // Factory function for creating a instance of a scaler object.
207  template<typename T>
208  std::unique_ptr<Scaler<T>> ScalerFactory<T>::create_scaler(const std::shared_ptr<const ScalerData> scalerData) {
209  try {
210  switch (scalerData->type) {
212  return std::make_unique<IdentityScaler<T>>();
213  case SCALER_TYPE::MINMAX:
214  return std::make_unique<MinMaxScaler<T>>(scalerData->parameters.at(SCALER_PARAMETER::LOWER_BOUNDS), scalerData->parameters.at(SCALER_PARAMETER::UPPER_BOUNDS), scalerData->parameters.at(SCALER_PARAMETER::SCALED_LOWER_BOUNDS), scalerData->parameters.at(SCALER_PARAMETER::SCALED_UPPER_BOUNDS));
216  return std::make_unique<StandardScaler<T>>(scalerData->parameters.at(SCALER_PARAMETER::MEAN), scalerData->parameters.at(SCALER_PARAMETER::STD_DEV));
217  default:
218  throw MelonException(" Error while creating sclaler: Invalid scaler type.");
219  }
220  }
221  catch (const std::out_of_range& e) {
222  throw MelonException(" Error while creating scaler: Scaler data object is missing a parameter.", e);
223  }
224  }
225 
226 
228  // Scales input values using MinMax-Scaling.
229  template<typename T>
230  std::vector<T> MinMaxScaler<T>::scale(const std::vector<T>& input) {
231  std::vector<T> output(input.size());
232  for (size_t i = 0; i < input.size(); ++i) {
233  output.at(i) = _scaledLowerBounds.at(i) + (input.at(i) - _lowerBounds.at(i)) / (_upperBounds.at(i) - _lowerBounds.at(i)) * (_scaledUpperBounds.at(i) - _scaledLowerBounds.at(i));
234  }
235 
236  return output;
237  }
238 
239 
241  // Decales input values using MinMax-Scaling.
242  template<typename T>
243  std::vector<T> MinMaxScaler<T>::descale(const std::vector<T>& input) {
244  std::vector<T> output(input.size());
245  for (size_t i = 0; i < input.size(); ++i) {
246  output.at(i) = _lowerBounds.at(i) + (input.at(i) - _scaledLowerBounds.at(i)) / (_scaledUpperBounds.at(i) - _scaledLowerBounds.at(i)) * (_upperBounds.at(i) - _lowerBounds.at(i));
247  }
248 
249  return output;
250  }
251 
252 
254  // Scales input values using Standard-Scaling.
255  template<typename T>
256  std::vector<T> StandardScaler<T>::scale(const std::vector<T>& input) {
257  std::vector<T> output(input.size());
258  for (size_t i = 0; i < input.size(); ++i) {
259  output.at(i) = (input.at(i) - _mean.at(i)) / _stdDev.at(i);
260  }
261 
262  return output;
263  }
264 
265 
267  // Descales input values using Standard-Scaling.
268 
269 
270  template<typename T>
271  std::vector<T> StandardScaler<T>::descale(const std::vector<T>& input) {
272  std::vector<T> output(input.size());
273  for (size_t i = 0; i < input.size(); ++i) {
274  output.at(i) = _stdDev.at(i)*input.at(i) + _mean.at(i);
275  }
276 
277  return output;
278  }
279 }
melon::ScalerFactory
This class is a factory class for creating child instances of Scaler.
Definition: scaler.h:110
melon::ScalerData::ScalerData
ScalerData()
Definition: scaler.h:68
melon::IdentityScaler::~IdentityScaler
~IdentityScaler()=default
exceptions.h
melon::IdentityScaler::scale
std::vector< T > scale(const std::vector< T > &input) override
Scales input value using the identity (= no scaling).
Definition: scaler.h:140
melon::MinMaxScaler::scale
std::vector< T > scale(const std::vector< T > &input) override
Scales input values using MinMax-Scaling.
Definition: scaler.h:243
melon::SCALED_UPPER_BOUNDS
@ SCALED_UPPER_BOUNDS
Definition: scaler.h:60
melon::MinMaxScaler::MinMaxScaler
MinMaxScaler(const std::vector< double > &lowerBounds, const std::vector< double > &upperBounds, const std::vector< double > &scaledLowerBounds, const std::vector< double > &scaledUpperBounds)
Definition: scaler.h:166
melon::MINMAX
@ MINMAX
Definition: scaler.h:46
melon::Scaler::~Scaler
virtual ~Scaler()=default
Virtual desctructor to enable inheritance.
melon::UPPER_BOUNDS
@ UPPER_BOUNDS
Definition: scaler.h:56
melon::IdentityScaler::descale
std::vector< T > descale(const std::vector< T > &input) override
Scales input values (= no scaling).
Definition: scaler.h:149
melon::MinMaxScaler::_scaledUpperBounds
std::vector< double > _scaledUpperBounds
Definition: scaler.h:163
melon::StandardScaler::_mean
std::vector< double > _mean
Definition: scaler.h:194
melon::IdentityScaler
Class implementing an identity scaling algorithm.
Definition: scaler.h:128
melon::Scaler::scale
virtual std::vector< T > scale(const std::vector< T > &input)=0
Scales input values.
melon::STD_DEV
@ STD_DEV
Definition: scaler.h:57
melon::Scaler::descale
virtual std::vector< T > descale(const std::vector< T > &input)=0
Descales input values.
melon::SCALED_LOWER_BOUNDS
@ SCALED_LOWER_BOUNDS
Definition: scaler.h:59
melon::Scaler
Abstract class defining scaling algorithm.
Definition: scaler.h:78
melon::StandardScaler::StandardScaler
StandardScaler(const std::vector< double > &mean, const std::vector< double > &stdDev)
Definition: scaler.h:197
melon::MEAN
@ MEAN
Definition: scaler.h:58
melon::IDENTITY
@ IDENTITY
Definition: scaler.h:45
melon::SCALER_TYPE
SCALER_TYPE
Enum for representing the available types of scalers.
Definition: scaler.h:44
melon::MinMaxScaler::_upperBounds
std::vector< double > _upperBounds
Definition: scaler.h:160
melon::StandardScaler::scale
std::vector< T > scale(const std::vector< T > &input) override
Scales input values using Standard-Scaling.
Definition: scaler.h:269
melon::StandardScaler::descale
std::vector< T > descale(const std::vector< T > &input) override
Descales input values using Standard-Scaling.
Definition: scaler.h:284
melon::StandardScaler
Class implementing a Standard-Scaling algorithm.
Definition: scaler.h:192
melon::StandardScaler::_stdDev
std::vector< double > _stdDev
Definition: scaler.h:195
MelonException
This class defines the exceptions thrown by FeedForwardNet.
Definition: exceptions.h:32
melon::ScalerData::parameters
std::unordered_map< SCALER_PARAMETER, std::vector< double > > parameters
Definition: scaler.h:70
melon::MinMaxScaler::descale
std::vector< T > descale(const std::vector< T > &input) override
Descales input values using MinMax-Scaling.
Definition: scaler.h:256
melon::ScalerData::type
SCALER_TYPE type
Definition: scaler.h:68
melon::SCALER_PARAMETER
SCALER_PARAMETER
Definition: scaler.h:54
melon::IdentityScaler::IdentityScaler
IdentityScaler()=default
melon
Definition: kernel.h:21
melon::ScalerFactory::create_scaler
static std::unique_ptr< Scaler< T > > create_scaler(const std::shared_ptr< const ScalerData > scalerData)
Factory function for creating a instance of a scaler object.
Definition: scaler.h:221
melon::ScalerData
Base struct from which data structs of different scalers can be derived.
Definition: scaler.h:67
melon::MinMaxScaler::_scaledLowerBounds
std::vector< double > _scaledLowerBounds
Definition: scaler.h:162
melon::LOWER_BOUNDS
@ LOWER_BOUNDS
Definition: scaler.h:55
melon::STANDARD
@ STANDARD
Definition: scaler.h:47
melon::MinMaxScaler::_lowerBounds
std::vector< double > _lowerBounds
Definition: scaler.h:159