scaling_layer.cpp

//   OpenNN: Open Neural Networks Library
//   www.opennn.net
//
//   S C A L I N G   L A Y E R   C L A S S
//
//   Artificial Intelligence Techniques SL
//   artelnics@artelnics.com
 
#include "scaling_layer.h"
 
namespace OpenNN
{
 
 
ScalingLayer::ScalingLayer() : Layer()
{
    set();
}
 
 
 
ScalingLayer::ScalingLayer(const Index& new_neurons_number) : Layer()
{
    set(new_neurons_number);
}
 
 
ScalingLayer::ScalingLayer(const Tensor<Index, 1>& new_inputs_dimensions) : Layer()
{
    set(new_inputs_dimensions);
}
 
 
 
ScalingLayer::ScalingLayer(const Tensor<Descriptives, 1>& new_descriptives) : Layer()
{
    set(new_descriptives);
}
 
 
 
ScalingLayer::~ScalingLayer()
{
}
 
 
Tensor<Index, 1> ScalingLayer::get_outputs_dimensions() const
{
    return input_variables_dimensions;
}
 
 
Index ScalingLayer::get_inputs_number() const
{
    return descriptives.size();
}
 
 
Index ScalingLayer::get_neurons_number() const
{
    return descriptives.size();
}
 
 
 
Tensor<Descriptives, 1> ScalingLayer::get_descriptives() const
{
    return descriptives;
}
 
 
 
Descriptives ScalingLayer::get_descriptives(const Index& index) const
{
    return descriptives(index);
}
 
 
 
Tensor<type, 1> ScalingLayer::get_minimums() const
{
    const Index neurons_number = get_neurons_number();
 
    Tensor<type, 1> minimums(neurons_number);
 
    for(Index i = 0; i < neurons_number; i++)
    {
        minimums[i] = descriptives[i].minimum;
    }
 
    return minimums;
}
 
 
 
Tensor<type, 1> ScalingLayer::get_maximums() const
{
    const Index neurons_number = get_neurons_number();
 
    Tensor<type, 1> maximums(neurons_number);
 
    for(Index i = 0; i < neurons_number; i++)
    {
        maximums[i] = descriptives[i].maximum;
    }
 
    return maximums;
}
 
 
 
Tensor<type, 1> ScalingLayer::get_means() const
{
    const Index neurons_number = get_neurons_number();
 
    Tensor<type, 1> means(neurons_number);
 
    for(Index i = 0; i < neurons_number; i++)
    {
        means[i] = descriptives[i].mean;
    }
 
    return means;
}
 
 
 
Tensor<type, 1> ScalingLayer::get_standard_deviations() const
{
    const Index neurons_number = get_neurons_number();
 
    Tensor<type, 1> standard_deviations(neurons_number);
 
    for(Index i = 0; i < neurons_number; i++)
    {
        standard_deviations[i] = descriptives[i].standard_deviation;
    }
 
    return standard_deviations;
}
 
 
 
const Tensor<Scaler, 1> ScalingLayer::get_scaling_methods() const
{
    return scalers;
}
 
 
 
Tensor<string, 1> ScalingLayer::write_scalers() const
{
    const Index neurons_number = get_neurons_number();
 
    Tensor<string, 1> scaling_methods_strings(neurons_number);
 
    for(Index i = 0; i < neurons_number; i++)
    {
        if(scalers[i] == Scaler::NoScaling)
        {
            scaling_methods_strings[i] = "NoScaling";
        }
        else if(scalers[i] == Scaler::MinimumMaximum)
        {
            scaling_methods_strings[i] = "MinimumMaximum";
        }
        else if(scalers[i] == Scaler::MeanStandardDeviation)
        {
            scaling_methods_strings[i] = "MeanStandardDeviation";
        }
        else if(scalers[i] == Scaler::StandardDeviation)
        {
            scaling_methods_strings[i] = "StandardDeviation";
        }
        else if(scalers[i] == Scaler::Logarithm)
        {
            scaling_methods_strings[i] = "Logarithm";
        }
        else
        {
            ostringstream buffer;
 
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "Tensor<string, 1> write_scalers() const method.\n"
                   << "Unknown " << i << " scaling method.\n";
 
            throw logic_error(buffer.str());
        }
    }
 
    return scaling_methods_strings;
}
 
 
 
Tensor<string, 1> ScalingLayer::write_scalers_text() const
{
    const Index neurons_number = get_neurons_number();
 
#ifdef OPENNN_DEBUG
 
    if(neurons_number == 0)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: ScalingLayer class.\n"
               << "Tensor<string, 1> write_scalers() const method.\n"
               << "Neurons number must be greater than 0.\n";
 
        throw logic_error(buffer.str());
    }
 
#endif
 
    Tensor<string, 1> scaling_methods_strings(neurons_number);
 
    for(Index i = 0; i < neurons_number; i++)
    {
        if(scalers[i] == Scaler::NoScaling)
        {
            scaling_methods_strings[i] = "no scaling";
        }
        else if(scalers[i] == Scaler::MeanStandardDeviation)
        {
            scaling_methods_strings[i] = "mean and standard deviation";
        }
        else if(scalers[i] == Scaler::StandardDeviation)
        {
            scaling_methods_strings[i] = "standard deviation";
        }
        else if(scalers[i] == Scaler::MinimumMaximum)
        {
            scaling_methods_strings[i] = "minimum and maximum";
        }
        else if(scalers[i] == Scaler::Logarithm)
        {
            scaling_methods_strings[i] = "Logarithm";
        }
        else
        {
            ostringstream buffer;
 
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "Tensor<string, 1> write_scalers_text() const method.\n"
                   << "Unknown " << i << " scaling method.\n";
 
            throw logic_error(buffer.str());
        }
    }
 
    return scaling_methods_strings;
}
 
// const bool& get_display() const method
 
 
const bool& ScalingLayer::get_display() const
{
    return display;
}
 
 
 
void ScalingLayer::set()
{
    descriptives.resize(0);
 
    scalers.resize(0);
 
    set_default();
}
 
 
 
void ScalingLayer::set(const Index& new_inputs_number)
{
    descriptives.resize(new_inputs_number);
 
    scalers.resize(new_inputs_number);
 
    scalers.setConstant(Scaler::MeanStandardDeviation);
 
    set_default();
}
 
 
void ScalingLayer::set(const Tensor<Index, 1>& new_inputs_dimensions)
{
    const Tensor<Index,0> dimension_product = new_inputs_dimensions.prod();
 
    descriptives.resize(dimension_product(0));
 
    scalers.resize(dimension_product(0));
    scalers.setConstant(Scaler::MeanStandardDeviation);
 
    input_variables_dimensions.resize(new_inputs_dimensions.size());
 
    input_variables_dimensions = new_inputs_dimensions;
 
    set_default();
}
 
 
 
void ScalingLayer::set(const Tensor<Descriptives, 1>& new_descriptives)
{
    descriptives = new_descriptives;
 
    scalers.resize(new_descriptives.size());
 
    scalers.setConstant(Scaler::MeanStandardDeviation);
 
    set_default();
}
 
 
void ScalingLayer::set(const Tensor<Descriptives, 1>& new_descriptives, const Tensor<Scaler, 1>& new_scalers)
{
    descriptives = new_descriptives;
 
    scalers = new_scalers;
}
 
 
 
void ScalingLayer::set(const tinyxml2::XMLDocument& new_scaling_layer_document)
{
    set_default();
 
    from_XML(new_scaling_layer_document);
}
 
 
void ScalingLayer::set_inputs_number(const Index& new_inputs_number)
{
    descriptives.resize(new_inputs_number);
 
    scalers.resize(new_inputs_number);
 
    scalers.setConstant(Scaler::MeanStandardDeviation);
}
 
 
void ScalingLayer::set_neurons_number(const Index& new_neurons_number)
{
    descriptives.resize(new_neurons_number);
 
    scalers.resize(new_neurons_number);
 
    scalers.setConstant(Scaler::MeanStandardDeviation);
}
 
 
 
void ScalingLayer::set_default()
{
    layer_name = "scaling_layer";
 
    set_scalers(Scaler::MeanStandardDeviation);
 
    set_min_max_range(type(-1), type(1));
 
    set_display(true);
 
    layer_type = Type::Scaling;
}
 
 
 
void ScalingLayer::set_min_max_range(const type& min, const type& max)
{
    min_range = min;
    max_range = max;
}
 
 
 
void ScalingLayer::set_descriptives(const Tensor<Descriptives, 1>& new_descriptives)
{
#ifdef OPENNN_DEBUG
 
    const Index new_descriptives_size = new_descriptives.size();
 
    const Index neurons_number = get_neurons_number();
 
    if(new_descriptives_size != neurons_number)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: ScalingLayer class.\n"
               << "void set_descriptives(const Tensor<Descriptives, 1>&) method.\n"
               << "Size of descriptives (" << new_descriptives_size << ") is not equal to number of scaling neurons (" << neurons_number << ").\n";
 
        throw logic_error(buffer.str());
    }
 
#endif
 
    descriptives = new_descriptives;
}
 
 
 
void ScalingLayer::set_item_descriptives(const Index& i, const Descriptives& item_descriptives)
{
    descriptives(i) = item_descriptives;
}
 
 
 
void ScalingLayer::set_minimum(const Index& i, const type& new_minimum)
{
    descriptives(i).set_minimum(new_minimum);
}
 
 
 
void ScalingLayer::set_maximum(const Index& i, const type& new_maximum)
{
    descriptives(i).set_maximum(new_maximum);
}
 
 
 
void ScalingLayer::set_mean(const Index& i, const type& new_mean)
{
    descriptives(i).set_mean(new_mean);
}
 
 
 
void ScalingLayer::set_standard_deviation(const Index& i, const type& new_standard_deviation)
{
    descriptives(i).set_standard_deviation(new_standard_deviation);
}
 
 
 
void ScalingLayer::set_scalers(const Tensor<Scaler, 1>& new_scaling_methods)
{
#ifdef OPENNN_DEBUG
 
    const Index neurons_number = get_neurons_number();
 
    if(neurons_number == 0)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: ScalingLayer class.\n"
               << "void set_scalers(const Tensor<Scaler, 1>&) method.\n"
               << "Neurons number (" << neurons_number << ") must be greater than 0.\n";
 
        throw logic_error(buffer.str());
    }
 
#endif
 
    scalers = new_scaling_methods;
}
 
 
 
void ScalingLayer::set_scalers(const Tensor<string, 1>& new_scaling_methods_string)
{
    const Index neurons_number = get_neurons_number();
 
#ifdef OPENNN_DEBUG
 
    if(neurons_number == 0)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: ScalingLayer class.\n"
               << "void set_scalers(const Tensor<string, 1>&) method.\n"
               << "Neurons number (" << neurons_number << ") must be greater than 0.\n";
 
        throw logic_error(buffer.str());
    }
 
#endif
 
    Tensor<Scaler, 1> new_scaling_methods(neurons_number);
 
    for(Index i = 0; i < neurons_number; i++)
    {
        if(new_scaling_methods_string(i) == "NoScaling")
        {
            new_scaling_methods(i) = Scaler::NoScaling;
        }
        else if(new_scaling_methods_string(i) == "MinimumMaximum")
        {
            new_scaling_methods(i) = Scaler::MinimumMaximum;
        }
        else if(new_scaling_methods_string(i) == "MeanStandardDeviation")
        {
            new_scaling_methods(i) = Scaler::MeanStandardDeviation;
        }
        else if(new_scaling_methods_string(i) == "StandardDeviation")
        {
            new_scaling_methods(i) = Scaler::StandardDeviation;
        }
        else if(new_scaling_methods_string(i) == "Logarithm")
        {
            new_scaling_methods(i) = Scaler::Logarithm;
        }
        else
        {
            ostringstream buffer;
 
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "void set_scalers(const Tensor<string, 1>&) method.\n"
                   << "Unknown scaling method: " << new_scaling_methods_string[i] << ".\n";
 
            throw logic_error(buffer.str());
        }
    }
 
    set_scalers(new_scaling_methods);
}
 
 
 
void ScalingLayer::set_scalers(const string& new_scaling_methods_string)
{
    const Index neurons_number = get_neurons_number();
 
#ifdef OPENNN_DEBUG
 
    if(neurons_number == 0)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: ScalingLayer class.\n"
               << "void set_scalers(const Tensor<string, 1>&) method.\n"
               << "Neurons number (" << neurons_number << ")must be greater than 0.\n";
 
        throw logic_error(buffer.str());
    }
 
#endif
 
    Tensor<Scaler, 1> new_scaling_methods(neurons_number);
 
    for(Index i = 0; i < neurons_number; i++)
    {
        if(new_scaling_methods_string == "NoScaling")
        {
            new_scaling_methods(i) = Scaler::NoScaling;
        }
        else if(new_scaling_methods_string == "MeanStandardDeviation")
        {
            new_scaling_methods(i) = Scaler::MeanStandardDeviation;
        }
        else if(new_scaling_methods_string == "MinimumMaximum")
        {
            new_scaling_methods(i) = Scaler::MinimumMaximum;
        }
        else if(new_scaling_methods_string == "StandardDeviation")
        {
            new_scaling_methods(i) = Scaler::StandardDeviation;
        }
        else if(new_scaling_methods_string == "Logarithm")
        {
            new_scaling_methods(i) = Scaler::Logarithm;
        }
        else
        {
            ostringstream buffer;
 
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "void set_scalers(const Tensor<string, 1>&) method.\n"
                   << "Unknown scaling method: " << new_scaling_methods_string[i] << ".\n";
 
            throw logic_error(buffer.str());
        }
    }
 
    set_scalers(new_scaling_methods);
}
 
 
 
void ScalingLayer::set_scalers(const Scaler& new_scaling_method)
{
    const Index neurons_number = get_neurons_number();
 
    for(Index i = 0; i < neurons_number; i++)
    {
        scalers(i) = new_scaling_method;
    }
}
 
 
 
void ScalingLayer::set_display(const bool& new_display)
{
    display = new_display;
}
 
 
 
bool ScalingLayer::is_empty() const
{
    const Index inputs_number = get_neurons_number();
 
    if(inputs_number == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}
 
 
 
void ScalingLayer::check_range(const Tensor<type, 1>& inputs) const
{
    const Index inputs_number = get_neurons_number();
 
#ifdef OPENNN_DEBUG
 
    const Index size = inputs.size();
 
    if(size != inputs_number)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: ScalingLayer class.\n"
               << "void check_range(const Tensor<type, 1>&) const method.\n"
               << "Size of inputs must be equal to number of inputs.\n";
 
        throw logic_error(buffer.str());
    }
 
#endif
 
    // Check inputs
 
    if(display)
    {
        for(Index i = 0; i < inputs_number; i++)
        {
            if(inputs(i) < descriptives(i).minimum)
            {
                cout << "OpenNN Warning: ScalingLayer class.\n"
                     << "void check_range(const Tensor<type, 1>&) const method.\n"
                     << "Input value " << i << " is less than corresponding minimum.\n";
            }
 
            if(inputs(i) > descriptives(i).maximum)
            {
                cout << "OpenNN Warning: ScalingLayer class.\n"
                     << "void check_range(const Tensor<type, 1>&) const method.\n"
                     << "Input value " << i << " is greater than corresponding maximum.\n";
            }
        }
    }
}
 
 
 
Tensor<type, 2> ScalingLayer::calculate_outputs(const Tensor<type, 2>& inputs)
{
    Tensor<type, 2> outputs;
 
    const Index neurons_number = get_neurons_number();
 
#ifdef OPENNN_DEBUG
 
        ostringstream buffer;
 
        const Index columns_number = inputs.dimension(1);
 
        if(columns_number != neurons_number)
        {
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "Tensor<type, 2> calculate_outputs(const Tensor<type, 2>&) const method.\n"
                   << "Size of inputs (" << columns_number << ") must be equal to number of scaling neurons (" << neurons_number << ").\n";
 
            throw logic_error(buffer.str());
        }
 
#endif
 
    const Index points_number = inputs.dimension(0);
 
    outputs.resize(points_number, neurons_number);
 
    for(Index i = 0; i < points_number; i++)
    {
        for(Index j = 0; j < neurons_number; j++)
        {
            if(abs(descriptives(j).minimum - descriptives(j).maximum) < type(NUMERIC_LIMITS_MIN))
            {
                if(display)
                {
                    cout << "OpenNN Warning: ScalingLayer class.\n"
                         << "Tensor<type, 2> calculate_outputs(const Tensor<type, 2>&) const method.\n"
                         << "Standard deviation of variable " << i << " is zero.\n"
                         << "Those variables won't be scaled.\n";
                }
 
                outputs(j) = inputs(j);
            }
            else
            {
                if(scalers(j) == Scaler::NoScaling)
                {
                    outputs(i,j) = inputs(i,j);
                }
                else if(scalers(j) == Scaler::MinimumMaximum)
                {
                    const type slope =
                                (max_range-min_range)/(descriptives(j).maximum-descriptives(j).minimum);
 
                    const type intercept =
                                (min_range*descriptives(j).maximum-max_range*descriptives(j).minimum)/(descriptives(j).maximum-descriptives(j).minimum);
 
                    outputs(i,j) = inputs(i,j)*slope + intercept;
                }
                else if(scalers(j) == Scaler::MeanStandardDeviation)
                {
                    const type slope = static_cast<type>(1)/descriptives(j).standard_deviation;
 
                    const type intercept = -descriptives(j).mean/descriptives(j).standard_deviation;
 
                    outputs(i,j) = inputs(i,j)*slope + intercept;
 
                }
                else if(scalers(j) == Scaler::StandardDeviation)
                {
                    outputs(i,j) = inputs(i,j)/descriptives(j).standard_deviation;
                }
                else if(scalers(j) == Scaler::Logarithm)
                {
                    outputs(i,j) = log(inputs(i,j));
                }
                else
                {
                    ostringstream buffer;
 
                    buffer << "OpenNN Exception: ScalingLayer class\n"
                           << "Tensor<type, 2> calculate_outputs(const Tensor<type, 2>&) const method.\n"
                           << "Unknown scaling method.\n";
 
                    throw logic_error(buffer.str());
                }
            }
        }
    }
 
    return outputs;
}
 
 
Tensor<type, 4> ScalingLayer::calculate_outputs(const Tensor<type, 4>& inputs)
{
    Tensor<type, 4> outputs;
 
        const Index neurons_number = get_neurons_number();
 
#ifdef OPENNN_DEBUG
 
        ostringstream buffer;
 
        const Index columns_number = inputs.dimension(1) * inputs.dimension(2) * inputs.dimension(3);
 
        if(columns_number != neurons_number)
        {
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "Tensor<type, 2> calculate_outputs(const Tensor<type, 2>&) const method.\n"
                   << "Size of inputs (" << columns_number << ") must be equal to number of scaling neurons (" << neurons_number << ").\n";
 
            throw logic_error(buffer.str());
        }
 
#endif
 
    const Index points_number = inputs.dimension(0);
 
    for(Index i = 0; i < points_number; i++)
    {
        for(Index j = 0; j < neurons_number; j++)
        {
            const Index channel_index = j%inputs.dimension(1);
            const Index row_index = (j/(inputs.dimension(1)))%inputs.dimension(2);
            const Index column_index = (j/(inputs.dimension(1) * inputs.dimension(2)))%inputs.dimension(3);
 
            if(abs(descriptives(j).minimum - descriptives(j).maximum) < type(NUMERIC_LIMITS_MIN))
            {
                if(display)
                {
                    cout << "OpenNN Warning: ScalingLayer class.\n"
                         << "Tensor<type, 2> calculate_mean_standard_deviation_outputs(const Tensor<type, 2>&) const method.\n"
                         << "Standard deviation of variable " << i << " is zero.\n"
                         << "Those variables won't be scaled.\n";
                }
 
                outputs(j) = inputs(j);
            }
            else
            {
                if(scalers(j) == Scaler::NoScaling)
                {
                    outputs(i, channel_index, row_index, column_index) = inputs(i, channel_index, row_index, column_index);
                }
                else if(scalers(j) == Scaler::MinimumMaximum)
                {
                    outputs(i, channel_index, row_index, column_index) = static_cast<type>(2)*(inputs(i, channel_index, row_index, column_index) - descriptives(j).minimum)/(descriptives(j).maximum-descriptives(j).minimum) - static_cast<type>(1);
                }
                else if(scalers(j) == Scaler::MeanStandardDeviation)
                {
                    outputs(i, channel_index, row_index, column_index) = (inputs(i, channel_index, row_index, column_index) - descriptives(j).mean)/descriptives(j).standard_deviation;
                }
                else if(scalers(j) == Scaler::StandardDeviation)
                {
                    outputs(i, channel_index, row_index, column_index) = inputs(i, channel_index, row_index, column_index)/descriptives(j).standard_deviation;
                }
                else if(scalers(j) == Scaler::Logarithm)
                {
                    outputs(i, channel_index, row_index, column_index) = log(inputs(i, channel_index, row_index, column_index));
                }
                else
                {
                    ostringstream buffer;
 
                    buffer << "OpenNN Exception: ScalingLayer class\n"
                           << "Tensor<type, 2> calculate_outputs(const Tensor<type, 2>&) const method.\n"
                           << "Unknown scaling method.\n";
 
                    throw logic_error(buffer.str());
                }
            }
        }
    }
 
    return outputs;
}
 
 
 
string ScalingLayer::write_no_scaling_expression(const Tensor<string, 1>& inputs_names, const Tensor<string, 1>& outputs_names) const
{
    const Index inputs_number = get_neurons_number();
 
    ostringstream buffer;
 
    buffer.precision(10);
 
    for(Index i = 0; i < inputs_number; i++)
    {
        buffer << outputs_names(i) << " = " << inputs_names(i) << ";\n";
    }
 
    return buffer.str();
}
 
 
 
string ScalingLayer::write_minimum_maximum_expression(const Tensor<string, 1>& inputs_names, const Tensor<string, 1>& outputs_names) const
{
    const Index inputs_number = get_neurons_number();
 
    ostringstream buffer;
 
    buffer.precision(10);
 
    for(Index i = 0; i < inputs_number; i++)
    {
        buffer << outputs_names(i) << " = 2*(" << inputs_names(i) << "-(" << descriptives(i).minimum << "))/(" << descriptives(i).maximum << "-(" << descriptives(i).minimum << "))-1;\n";
    }
 
    return buffer.str();
}
 
 
 
string ScalingLayer::write_mean_standard_deviation_expression(const Tensor<string, 1>& inputs_names, const Tensor<string, 1>& outputs_names) const
{
    const Index inputs_number = get_neurons_number();
 
    ostringstream buffer;
 
    buffer.precision(10);
 
    for(Index i = 0; i < inputs_number; i++)
    {
        buffer << outputs_names(i) << " = (" << inputs_names(i) << "-(" << descriptives(i).mean << "))/" << descriptives(i).standard_deviation << ";\n";
    }
 
    return buffer.str();
}
 
 
 
string ScalingLayer::write_standard_deviation_expression(const Tensor<string, 1>& inputs_names, const Tensor<string, 1>& outputs_names) const
{
    const Index inputs_number = get_neurons_number();
 
    ostringstream buffer;
 
    buffer.precision(10);
 
    for(Index i = 0; i < inputs_number; i++)
    {
        buffer << outputs_names(i) << " = " << inputs_names(i) << "/(" << descriptives(i).standard_deviation << ");\n";
    }
 
    return buffer.str();
}
 
 
 
string ScalingLayer::write_expression(const Tensor<string, 1>& inputs_names, const Tensor<string, 1>&) const
{
    const Index neurons_number = get_neurons_number();
 
    ostringstream buffer;
 
    buffer.precision(10);
 
    for(Index i = 0; i < neurons_number; i++)
    {
        if(scalers(i) == Scaler::NoScaling)
        {
            buffer << "scaled_" << inputs_names(i) << " = " << inputs_names(i) << ";\n";
        }
        else if(scalers(i) == Scaler::MinimumMaximum)
        {
            buffer << "scaled_" << inputs_names(i) << " = " << inputs_names(i) << "*(" << max_range << "-" << min_range << ")/(" << descriptives(i).maximum << "-(" << descriptives(i).minimum << "))-" << descriptives(i).minimum << "*(" << max_range << "-" << min_range << ")/(" << descriptives(i).maximum << "-" << descriptives(i).minimum << ")+" << min_range << ";\n";
        }
        else if(scalers(i) == Scaler::MeanStandardDeviation)
        {
            buffer << "scaled_" << inputs_names(i) << " = (" << inputs_names(i) << "-" << descriptives(i).mean << ")/" << descriptives(i).standard_deviation << ";\n";
        }
        else if(scalers(i) == Scaler::StandardDeviation)
        {
            buffer << "scaled_" << inputs_names(i) << " = " << inputs_names(i) << "/(" << descriptives(i).standard_deviation << ");\n";
        }
        else
        {
            ostringstream buffer;
 
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "string write_expression() const method.\n"
                   << "Unknown inputs scaling method.\n";
 
            throw logic_error(buffer.str());
        }
    }
 
    string expression = buffer.str();
 
    replace(expression, "+-", "-");
    replace(expression, "--", "+");
 
    return expression;
 
}
 
 
 
string ScalingLayer::write_expression_c() const
{
    const Index neurons_number = get_neurons_number();
 
    ostringstream buffer;
 
    buffer.precision(10);
 
    buffer << "vector<float> " << layer_name << "(const vector<float>& inputs)\n{" << endl;
 
    buffer << "\tvector<float> outputs(" << neurons_number << ");\n" << endl;
 
    for(Index i = 0; i < neurons_number; i++)
    {
        if(scalers(i) == Scaler::NoScaling)
        {
            buffer << "\toutputs[" << i << "] = inputs[" << i << "];" << endl;
        }
        else if(scalers(i) == Scaler::MinimumMaximum)
        {
            const type slope = (max_range-min_range)/(descriptives(i).maximum-descriptives(i).minimum);
 
            const type intercept = -(descriptives(i).minimum*(max_range-min_range))/(descriptives(i).maximum - descriptives(i).minimum) + min_range;
 
            buffer << "\toutputs[" << i << "] = inputs[" << i << "]*"<<slope<<"+"<<intercept<<";\n";
        }
        else if(scalers(i) == Scaler::MeanStandardDeviation)
        {
            const type standard_deviation = descriptives(i).standard_deviation;
 
            const type mean = descriptives(i).mean;
 
            buffer << "\toutputs[" << i << "] = (inputs[" << i << "]-"<<mean<<")/"<<standard_deviation<<";\n";
        }
        else if(scalers(i) == Scaler::StandardDeviation)
        {
            const type standard_deviation = descriptives(i).standard_deviation;
 
            buffer << "\toutputs[" << i << "] = inputs[" << i << "]/" << standard_deviation << " ;" << endl;
        }
        else if(scalers(i) == Scaler::Logarithm)
        {
            buffer << "\toutputs[" << i << "] = log(inputs[" << i << "])"<< " ;" << endl;
        }
        else
        {
            ostringstream buffer;
 
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "string write_expression() const method.\n"
                   << "Unknown inputs scaling method.\n";
 
            throw logic_error(buffer.str());
        }
    }
 
    buffer << "\n\treturn outputs;\n}" << endl;
 
    return buffer.str();
}
 
 
string ScalingLayer::write_expression_python() const
{
    const Index neurons_number = get_neurons_number();
 
    ostringstream buffer;
 
    buffer.precision(10);
 
    buffer << "\tdef " << layer_name << "(self,inputs):\n" << endl;
 
    buffer << "\t\toutputs = [None] * "<<neurons_number<<"\n" << endl;
 
    for(Index i = 0; i < neurons_number; i++)
    {
        if(scalers(i) == Scaler::NoScaling)
        {
            buffer << "\t\toutputs[" << i << "] = inputs[" << i << "]\n" << endl;
        }
        else if(scalers(i) == Scaler::MinimumMaximum)
        {
            const type slope = (max_range-min_range)/(descriptives(i).maximum-descriptives(i).minimum);
 
            const type intercept = -(descriptives(i).minimum*(max_range-min_range))/(descriptives(i).maximum - descriptives(i).minimum) + min_range;
 
            buffer << "\t\toutputs[" << i << "] = inputs[" << i << "]*"<<slope<<"+"<<intercept<<"\n";
        }
        else if(scalers(i) == Scaler::MeanStandardDeviation)
        {
            const type standard_deviation = descriptives(i).standard_deviation;
 
            const type mean = descriptives(i).mean;
 
            buffer << "\t\toutputs[" << i << "] = (inputs[" << i << "]-"<<mean<<")/"<<standard_deviation<<"\n";
        }
        else if(scalers(i) == Scaler::StandardDeviation)
        {
            buffer << "\t\toutputs[" << i << "] = inputs[" << i << "]/" << descriptives(i).standard_deviation << "\n " << endl;
        }
        else if(scalers(i) == Scaler::Logarithm)
        {
            buffer << "\t\toutputs[" << i << "] = np.log(inputs[" << i << "])\n"<< endl;
        }
        else
        {
            ostringstream buffer;
 
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "string write_expression() const method.\n"
                   << "Unknown inputs scaling method.\n";
 
            throw logic_error(buffer.str());
        }
    }
 
    buffer << "\n\t\treturn outputs;\n" << endl;
 
    return buffer.str();
}
 
 
 
void ScalingLayer::write_XML(tinyxml2::XMLPrinter& file_stream) const
{
    ostringstream buffer;
 
    const Index neurons_number = get_neurons_number();
 
    // Scaling layer
 
    file_stream.OpenElement("ScalingLayer");
 
    // Scaling neurons number
 
    file_stream.OpenElement("ScalingNeuronsNumber");
 
    buffer.str("");
    buffer << neurons_number;
 
    file_stream.PushText(buffer.str().c_str());
 
    file_stream.CloseElement();
 
    const Tensor<string, 1> scaling_methods_string = write_scalers();
 
    // Scaling neurons
 
    for(Index i = 0; i < neurons_number; i++)
    {
        // Scaling neuron
 
        file_stream.OpenElement("ScalingNeuron");
 
        file_stream.PushAttribute("Index", int(i+1));
 
        // Minimum
 
        file_stream.OpenElement("Minimum");
 
        buffer.str("");
        buffer << descriptives(i).minimum;
 
        file_stream.PushText(buffer.str().c_str());
 
        file_stream.CloseElement();
 
        // Maximum
 
        file_stream.OpenElement("Maximum");
 
        buffer.str("");
        buffer << descriptives(i).maximum;
 
        file_stream.PushText(buffer.str().c_str());
 
        file_stream.CloseElement();
 
        // Mean
 
        file_stream.OpenElement("Mean");
 
        buffer.str("");
        buffer << descriptives(i).mean;
 
        file_stream.PushText(buffer.str().c_str());
 
        file_stream.CloseElement();
 
        // Standard deviation
 
        file_stream.OpenElement("StandardDeviation");
 
        buffer.str("");
        buffer << descriptives(i).standard_deviation;
 
        file_stream.PushText(buffer.str().c_str());
 
        file_stream.CloseElement();
 
        // Scaler
 
        file_stream.OpenElement("Scaler");
 
        buffer.str("");
        buffer << scaling_methods_string(i);
 
        file_stream.PushText(buffer.str().c_str());
 
        file_stream.CloseElement();
 
        // Scaling neuron (end tag)
 
        file_stream.CloseElement();
    }
 
    // Scaling layer (end tag)
 
    file_stream.CloseElement();
}
 
 
 
void ScalingLayer::from_XML(const tinyxml2::XMLDocument& document)
{
    ostringstream buffer;
 
    const tinyxml2::XMLElement* scaling_layer_element = document.FirstChildElement("ScalingLayer");
 
    if(!scaling_layer_element)
    {
        buffer << "OpenNN Exception: ScalingLayer class.\n"
               << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
               << "Scaling layer element is nullptr.\n";
 
        throw logic_error(buffer.str());
    }
 
    // Scaling neurons number
 
    const tinyxml2::XMLElement* neurons_number_element = scaling_layer_element->FirstChildElement("ScalingNeuronsNumber");
 
    if(!neurons_number_element)
    {
        buffer << "OpenNN Exception: ScalingLayer class.\n"
               << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
               << "Scaling neurons number element is nullptr.\n";
 
        throw logic_error(buffer.str());
    }
 
    const Index neurons_number = static_cast<Index>(atoi(neurons_number_element->GetText()));
 
    set(neurons_number);
 
    unsigned index = 0; // Index does not work
 
    const tinyxml2::XMLElement* start_element = neurons_number_element;
 
    for(Index i = 0; i < neurons_number; i++)
    {
        const tinyxml2::XMLElement* scaling_neuron_element = start_element->NextSiblingElement("ScalingNeuron");
        start_element = scaling_neuron_element;
 
        if(!scaling_neuron_element)
        {
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
                   << "Scaling neuron " << i+1 << " is nullptr.\n";
 
            throw logic_error(buffer.str());
        }
 
        scaling_neuron_element->QueryUnsignedAttribute("Index", &index);
 
        if(index != i+1)
        {
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
                   << "Index " << index << " is not correct.\n";
 
            throw logic_error(buffer.str());
        }
 
        // Minimum
 
        const tinyxml2::XMLElement* minimum_element = scaling_neuron_element->FirstChildElement("Minimum");
 
        if(!minimum_element)
        {
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
                   << "Minimum element " << i+1 << " is nullptr.\n";
 
            throw logic_error(buffer.str());
        }
 
        if(minimum_element->GetText())
        {
            descriptives[i].minimum = static_cast<type>(atof(minimum_element->GetText()));
        }
 
        // Maximum
 
        const tinyxml2::XMLElement* maximum_element = scaling_neuron_element->FirstChildElement("Maximum");
 
        if(!maximum_element)
        {
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
                   << "Maximum element " << i+1 << " is nullptr.\n";
 
            throw logic_error(buffer.str());
        }
 
        if(maximum_element->GetText())
        {
            descriptives[i].maximum = static_cast<type>(atof(maximum_element->GetText()));
        }
 
        // Mean
 
        const tinyxml2::XMLElement* mean_element = scaling_neuron_element->FirstChildElement("Mean");
 
        if(!mean_element)
        {
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
                   << "Mean element " << i+1 << " is nullptr.\n";
 
            throw logic_error(buffer.str());
        }
 
        if(mean_element->GetText())
        {
            descriptives[i].mean = static_cast<type>(atof(mean_element->GetText()));
        }
 
        // Standard deviation
 
        const tinyxml2::XMLElement* standard_deviation_element = scaling_neuron_element->FirstChildElement("StandardDeviation");
 
        if(!standard_deviation_element)
        {
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
                   << "Standard deviation element " << i+1 << " is nullptr.\n";
 
            throw logic_error(buffer.str());
        }
 
        if(standard_deviation_element->GetText())
        {
            descriptives[i].standard_deviation = static_cast<type>(atof(standard_deviation_element->GetText()));
        }
 
        // Scaling method
 
        const tinyxml2::XMLElement* scaling_method_element = scaling_neuron_element->FirstChildElement("Scaler");
 
        if(!scaling_method_element)
        {
            buffer << "OpenNN Exception: ScalingLayer class.\n"
                   << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
                   << "Scaling method element " << i+1 << " is nullptr.\n";
 
            throw logic_error(buffer.str());
        }
 
        string new_method = scaling_method_element->GetText();
 
        if(new_method == "NoScaling" || new_method == "No Scaling")
        {
            scalers[i] = Scaler::NoScaling;
        }
        else if(new_method == "MinimumMaximum" || new_method == "Minimum - Maximum")
        {
            scalers[i] = Scaler::MinimumMaximum;
        }
        else if(new_method == "MeanStandardDeviation" || new_method == "Mean - Standard deviation")
        {
            scalers[i] = Scaler::MeanStandardDeviation;
        }
        else if(new_method == "StandardDeviation")
        {
            scalers[i] = Scaler::StandardDeviation;
        }
        else if(new_method == "Logarithm")
        {
            scalers[i] = Scaler::Logarithm;
        }
        else
        {
            scalers[i] = Scaler::NoScaling;
        }
    }
 
    // Display
    {
        const tinyxml2::XMLElement* display_element = scaling_layer_element->FirstChildElement("Display");
 
        if(display_element)
        {
            string new_display_string = display_element->GetText();
 
            try
            {
                set_display(new_display_string != "0");
            }
            catch(const logic_error& e)
            {
                cerr << e.what() << endl;
            }
        }
    }
}
 
}
 
// OpenNN: Open Neural Networks Library.
// Copyright(C) 2005-2021 Artificial Intelligence Techniques, SL.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA