62 inline static T
_tanh(T x) {
using std::tanh;
return tanh(x); }
68 inline static T
_relu(T x) {
using std::max;
return max((T)0, x); }
69 inline static T
_relu6(T x) {
using std::max;
using std::min;
return min((T)6, max((T)0, x)); }
96 std::vector<T>
_calculate_prediction(
const std::vector<T> input,
const std::vector<T> internalVariables,
const bool fullSpace, std::vector<T>& constraints);
189 void get_full_space_variables(
unsigned int& variableNumber, std::vector<std::string>& variableNames, std::vector<std::pair<double, double>>& variableBounds);
199 _annData = std::dynamic_pointer_cast<const AnnData>(modelData);
200 if (_annData ==
nullptr) {
201 throw(
MelonException(
" Error while loading feed forward network: Incorrect type of passed data object. The data object must be of type AnnData."));
210 template <
typename T>
212 std::vector<T> dummyConstraints;
213 std::vector<T> dummyInternalVariables;
215 return _calculate_prediction(input, dummyInternalVariables,
false, dummyConstraints);
217 catch (
const std::exception& e) {
218 throw(
MelonException(
" Encountered a fatal error while evaluating feed forward network. Terminating.", e));
221 throw(
MelonException(
" Encountered a fatal error while evaluating feed forward network. Terminating."));
228 template <
typename T>
231 return _calculate_prediction(input, internalVariables,
true, constraints);
233 catch (
const std::exception& e) {
234 throw(
MelonException(
" Encountered a fatal error while evaluating feed forward network. Terminating.", e));
237 throw(
MelonException(
" Encountered a fatal error while evaluating feed forward network. Terminating."));
244 template <
typename T>
246 switch (reformulation) {
248 this->_tanh_formulation = &_tanh;
251 this->_tanh_formulation = &_tanh_reformulation_1;
254 this->_tanh_formulation = &_tanh_reformulation_2;
257 this->_tanh_formulation = &_tanh_reformulation_3;
260 this->_tanh_formulation = &_tanh_reformulation_4;
263 throw MelonException(
" Error while setting tanh formulation: Unknown tanh formulation.");
270 template <
typename T>
276 unsigned int variableNumber;
277 std::vector<std::string> dummyVariableNames;
278 std::vector<std::pair<double, double>> dummyVariableBounds;
280 get_full_space_variables(variableNumber, dummyVariableNames, dummyVariableBounds);
282 return variableNumber;
288 template <
typename T>
295 auto& structure = _annData->structure;
296 auto& weights = _annData->weights;
298 const double MAX_BOUND = 10e6;
300 variableNames.clear();
301 variableBounds.clear();
304 if (structure.scaledInput) {
305 variableNumber += structure.inputSize;
306 for (
int i = 0; i < structure.inputSize; i++) {
307 variableNames.push_back(
"input_normalized_" + std::to_string(i));
308 variableBounds.push_back(std::make_pair(-1., 1.));
312 for (
int iLayer = 0; iLayer < structure.numLayers; iLayer++) {
315 variableNumber += structure.layerSize.at(iLayer);
316 for (
int iNeuron = 0; iNeuron < structure.layerSize.at(iLayer); iNeuron++) {
317 variableNames.push_back(
"layer_" + std::to_string(iLayer) +
"_neuron_" + std::to_string(iNeuron) +
"_acummulated_input");
318 variableBounds.push_back(std::make_pair(-MAX_BOUND, MAX_BOUND));
322 variableNumber += structure.layerSize.at(iLayer);
323 for (
int iNeuron = 0; iNeuron < structure.layerSize.at(iLayer); iNeuron++) {
324 variableNames.push_back(
"layer_" + std::to_string(iLayer) +
"_neuron_" + std::to_string(iNeuron) +
"_output");
325 variableBounds.push_back(std::make_pair(-MAX_BOUND, MAX_BOUND));
330 if (structure.normalizedOutput) {
331 variableNumber += structure.layerSize.back();
332 for (
int i = 0; i < structure.layerSize.back(); i++) {
333 variableNames.push_back(
"output_" + std::to_string(i));
334 variableBounds.push_back(std::make_pair(-MAX_BOUND, MAX_BOUND));
342 template <
typename T>
350 auto& structure = _annData->structure;
351 auto& weights = _annData->weights;
354 if (input.size() != structure.inputSize) {
355 throw MelonException(
" Error while evaluating network: Incorrect number of variables. In reduced space mode evaluation the number of variables must be equal to the number of network inputs.");
358 unsigned int variablesSize = get_number_of_full_space_variables();
359 if (internalVariables.size() != variablesSize) {
360 throw MelonException(
" Error while evaluating network: Incorrect number of variables. In full space mode evaluation the number of variables must be equal to the number of internal network variables.");
364 std::vector<std::vector<T>> networkValues(structure.numLayers);
366 auto variableIterator = internalVariables.begin();
371 std::vector<T> normalizedInput = input;
372 if (structure.scaledInput) {
373 normalizedInput = _inputScaler->scale(input);
375 this->_set_constraints(constraints, normalizedInput, variableIterator);
383 for (
size_t iLayer = 0; iLayer < networkValues.size(); iLayer++) {
386 auto& layerInputWeights = weights.inputWeight.at(iLayer);
387 auto& layerBiasWeights = weights.biasWeight.at(iLayer);
388 auto& layerIncidentLayerWeights = weights.layerWeight.at(iLayer);
389 auto& layerConnections = structure.layerConnect.at(iLayer);
390 auto& layerSize = structure.layerSize.at(iLayer);
393 std::vector<T> accumulatedLayerInputs(structure.layerSize.at(iLayer), 0);
396 if (structure.inputConnect.at(iLayer) == 1) {
397 accumulatedLayerInputs = accumulatedLayerInputs + layerInputWeights * normalizedInput;
401 if (structure.biasConnect.at(iLayer) == 1) {
402 accumulatedLayerInputs = accumulatedLayerInputs + layerBiasWeights;
406 for (
size_t iIncidentLayer = 0; iIncidentLayer < layerConnections.size(); iIncidentLayer++) {
407 if (layerConnections.at(iIncidentLayer) == 1) {
408 accumulatedLayerInputs = accumulatedLayerInputs + layerIncidentLayerWeights.at(iIncidentLayer)*networkValues.at(iIncidentLayer);
413 this->_set_constraints(constraints, accumulatedLayerInputs, variableIterator);
417 std::vector<T> layerOutput = _calculate_layer_activation(accumulatedLayerInputs, structure.activationFunction.at(iLayer));
420 this->_set_constraints(constraints, layerOutput, variableIterator);
423 networkValues.at(iLayer) = layerOutput;
429 std::vector<T> output = networkValues.back();
430 if (structure.normalizedOutput) {
431 output = _outputScaler->descale(networkValues.back());
433 this->_set_constraints(constraints, output, variableIterator);
440 throw MelonException(
" Error while evaluating network: No network loaded.");
447 template <
typename T>
450 std::vector<T> layerActivation(v);
453 T(*activation_function) (T);
454 switch (activationFunction) {
456 return layerActivation;
458 activation_function = this->_tanh_formulation;
461 activation_function = &_relu;
464 activation_function = &_relu6;
469 std::transform(v.begin(), v.end(), layerActivation.begin(), activation_function);
471 return layerActivation;
This class defines the exceptions thrown by FeedForwardNet.
Definition exceptions.h:32
This class is a factory class for creating child instances of AnnParser.
Definition AnnParser.h:215
This class represents a feed foward artificial network to be used in the MAiNGO solver.
Definition ffNet.h:52
std::vector< T > calculate_prediction_full_space(const std::vector< T > input, const std::vector< T > internalVariables, std::vector< T > &constraints)
Calculates the prediction of the feed forward net for a given point in full space mode (values for al...
Definition ffNet.h:229
std::unique_ptr< Scaler< T > > _outputScaler
Definition ffNet.h:58
~FeedForwardNet()=default
Default Destructor.
std::shared_ptr< const AnnData > _annData
Definition ffNet.h:55
FeedForwardNet()
Constructor for creating object with no model loaded.
Definition ffNet.h:110
unsigned int get_number_of_full_space_variables()
Get the number of internal network variables.
Definition ffNet.h:271
std::vector< T > _calculate_layer_activation(const std::vector< T > &v, const ACTIVATION_FUNCTION activationFunction)
Calculates the activations for a layer given its inputs.
Definition ffNet.h:448
void set_tanh_formulation(const TANH_REFORMULATION &reformulation)
Changes the reformulation to be used for tanh evaluations. The reformulations are intended to be used...
Definition ffNet.h:245
FeedForwardNet(std::shared_ptr< AnnData > modelData)
Constructor for creating object from existing AnnData object.
Definition ffNet.h:137
static T _relu(T x)
Definition ffNet.h:68
std::vector< T > _calculate_prediction(const std::vector< T > input, const std::vector< T > internalVariables, const bool fullSpace, std::vector< T > &constraints)
Calculates the prediction of the feed forward net for a given point.
Definition ffNet.h:343
std::unique_ptr< Scaler< T > > _inputScaler
Definition ffNet.h:57
void get_full_space_variables(unsigned int &variableNumber, std::vector< std::string > &variableNames, std::vector< std::pair< double, double > > &variableBounds)
Returns the number and the names of the internal variables of the network.
Definition ffNet.h:289
static T _tanh_reformulation_3(T x)
Definition ffNet.h:65
T(* _tanh_formulation)(T)
Definition ffNet.h:61
FeedForwardNet(std::string modelPath, std::string modelName, MODEL_FILE_TYPE fileType)
Constructor for creating object from file with the modelName being relative to modelPath.
Definition ffNet.h:130
static T _tanh_reformulation_1(T x)
Definition ffNet.h:63
static T _relu6(T x)
Definition ffNet.h:69
FeedForwardNet(std::string modelName, MODEL_FILE_TYPE fileType)
Constructor for creating object from file with the modelName relative to the current working director...
Definition ffNet.h:119
static T _tanh_reformulation_4(T x)
Definition ffNet.h:66
static T _tanh(T x)
Definition ffNet.h:62
void _set_data_object(std::shared_ptr< const ModelData > modelData) override
Sets data object containing model parameters.
Definition ffNet.h:196
std::vector< T > calculate_prediction_reduced_space(const std::vector< T > input)
Calculates the prediction of the feed forward net for a given point in reduced space mode (only value...
Definition ffNet.h:211
static T _tanh_reformulation_2(T x)
Definition ffNet.h:64
void load_model(std::string modelName, MODEL_FILE_TYPE fileType)
Loads new model from file.
Definition MeLOn.h:114
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
MODEL_FILE_TYPE
Enum for representing the parsable filetypes.
Definition modelParser.h:30
ACTIVATION_FUNCTION
Enum for representing the available types of scaler parameters.
Definition AnnProperties.h:30
@ PURE_LIN
Definition AnnProperties.h:31
@ RELU6
Definition AnnProperties.h:34
@ RELU
Definition AnnProperties.h:33
@ TANH
Definition AnnProperties.h:32
TANH_REFORMULATION
Enum for representing the different reformulations for the tanh activation function.
Definition ffNet.h:37
@ TANH_REF_0
Definition ffNet.h:38
@ TANH_REF4
Definition ffNet.h:42
@ TANH_REF1
Definition ffNet.h:39
@ TANH_REF3
Definition ffNet.h:41
@ TANH_REF2
Definition ffNet.h:40