MeLOn
Loading...
Searching...
No Matches
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
25namespace melon {
26
36
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) const = 0;
75
83 virtual std::vector<T> descale(const std::vector<T>& input) const = 0;
84
89 virtual ~Scaler() = default;
90 };
91
96 template<typename T>
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) const override { return input; };
128
136 std::vector<T> descale(const std::vector<T>& input) const 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) const override;
163
171 std::vector<T> descale(const std::vector<T>& input) const 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) const override;
194
202 std::vector<T> descale(const std::vector<T>& input) const 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>>();
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) const {
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) const {
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) const {
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) const {
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}
This class defines the exceptions thrown by FeedForwardNet.
Definition exceptions.h:32
Class implementing an identity scaling algorithm.
Definition scaler.h:115
std::vector< T > descale(const std::vector< T > &input) const override
Scales input values (= no scaling).
Definition scaler.h:136
std::vector< T > scale(const std::vector< T > &input) const override
Scales input value using the identity (= no scaling).
Definition scaler.h:127
Class implementing a MinMax-Scaling algorithm.
Definition scaler.h:144
MinMaxScaler(const std::vector< double > &lowerBounds, const std::vector< double > &upperBounds, const std::vector< double > &scaledLowerBounds, const std::vector< double > &scaledUpperBounds)
Definition scaler.h:153
std::vector< double > _scaledLowerBounds
Definition scaler.h:149
std::vector< double > _lowerBounds
Definition scaler.h:146
std::vector< T > scale(const std::vector< T > &input) const override
Scales input values using MinMax-Scaling.
Definition scaler.h:230
std::vector< double > _scaledUpperBounds
Definition scaler.h:150
std::vector< double > _upperBounds
Definition scaler.h:147
std::vector< T > descale(const std::vector< T > &input) const override
Descales input values using MinMax-Scaling.
Definition scaler.h:243
This class is a factory class for creating child instances of Scaler.
Definition scaler.h:97
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:208
Abstract class defining scaling algorithm.
Definition scaler.h:65
virtual ~Scaler()=default
Virtual desctructor to enable inheritance.
virtual std::vector< T > scale(const std::vector< T > &input) const =0
Scales input values.
virtual std::vector< T > descale(const std::vector< T > &input) const =0
Descales input values.
Class implementing a Standard-Scaling algorithm.
Definition scaler.h:179
std::vector< double > _mean
Definition scaler.h:181
std::vector< T > descale(const std::vector< T > &input) const override
Descales input values using Standard-Scaling.
Definition scaler.h:271
StandardScaler(const std::vector< double > &mean, const std::vector< double > &stdDev)
Definition scaler.h:184
std::vector< double > _stdDev
Definition scaler.h:182
std::vector< T > scale(const std::vector< T > &input) const override
Scales input values using Standard-Scaling.
Definition scaler.h:256
Definition kernel.h:21
SCALER_PARAMETER
Definition scaler.h:41
@ MEAN
Definition scaler.h:45
@ SCALED_LOWER_BOUNDS
Definition scaler.h:46
@ SCALED_UPPER_BOUNDS
Definition scaler.h:47
@ STD_DEV
Definition scaler.h:44
@ UPPER_BOUNDS
Definition scaler.h:43
@ LOWER_BOUNDS
Definition scaler.h:42
SCALER_TYPE
Enum for representing the available types of scalers.
Definition scaler.h:31
@ MINMAX
Definition scaler.h:33
@ STANDARD
Definition scaler.h:34
@ IDENTITY
Definition scaler.h:32
Base struct from which data structs of different scalers can be derived.
Definition scaler.h:54
std::unordered_map< SCALER_PARAMETER, std::vector< double > > parameters
Definition scaler.h:57
ScalerData()
Definition scaler.h:55
SCALER_TYPE type
Definition scaler.h:56