bounding_layer.cpp

//   OpenNN: Open Neural Networks Library
//   www.opennn.net
//
//   B O U N D I N G   L A Y E R   C L A S S
//
//   Artificial Intelligence Techniques SL
//   artelnics@artelnics.com
 
#include "bounding_layer.h"
 
namespace OpenNN
{
 
 
BoundingLayer::BoundingLayer() : Layer()
{
    set();
 
    set_default();
}
 
 
 
BoundingLayer::BoundingLayer(const Index& neurons_number) : Layer()
{
    set(neurons_number);
 
    set_default();
}
 
 
 
BoundingLayer::~BoundingLayer()
{
}
 
 
 
bool BoundingLayer::is_empty() const
{
    if(get_neurons_number() == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}
 
 
 
const BoundingLayer::BoundingMethod& BoundingLayer::get_bounding_method() const
{
    return bounding_method;
}
 
 
string BoundingLayer::write_bounding_method() const
{
    if(bounding_method == BoundingMethod::Bounding)
    {
        return "Bounding";
    }
    else if(bounding_method == BoundingMethod::NoBounding)
    {
        return "NoBounding";
    }
    else
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: BoundingLayer class.\n"
               << "string write_bounding_method() const method.\n"
               << "Unknown bounding method.\n";
 
        throw logic_error(buffer.str());
    }
}
 
 
 
Index BoundingLayer::get_inputs_number() const
{
    return lower_bounds.dimension(0);
}
 
 
 
Index BoundingLayer::get_neurons_number() const
{
    return lower_bounds.dimension(0);
}
 
 
 
const Tensor<type, 1>& BoundingLayer::get_lower_bounds() const
{
    return lower_bounds;
}
 
 
 
type BoundingLayer::get_lower_bound(const Index& i) const
{
#ifdef OPENNN_DEBUG
 
    const Index neurons_number = get_neurons_number();
 
    if(i >= neurons_number)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: BoundingLayer class.\n"
               << "type get_lower_bound(const Index&) const method.\n"
               << "Index must be less than number of bounding neurons.\n";
 
        throw logic_error(buffer.str());
    }
 
#endif
 
    return lower_bounds[i];
}
 
 
 
const Tensor<type, 1>& BoundingLayer::get_upper_bounds() const
{
    return upper_bounds;
}
 
 
 
type BoundingLayer::get_upper_bound(const Index& i) const
{
#ifdef OPENNN_DEBUG
 
    const Index neurons_number = get_neurons_number();
 
    if(neurons_number == 0)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: BoundingLayer class.\n"
               << "type get_upper_bound(const Index&) const method.\n"
               << "Number of bounding neurons is zero.\n";
 
        throw logic_error(buffer.str());
    }
    else if(i >= neurons_number)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: BoundingLayer class.\n"
               << "type get_upper_bound(const Index&) const method.\n"
               << "Index must be less than number of bounding neurons.\n";
 
        throw logic_error(buffer.str());
    }
 
#endif
 
    return upper_bounds(i);
}
 
 
 
void BoundingLayer::set()
{
    bounding_method = BoundingMethod::Bounding;
 
    lower_bounds.resize(0);
    upper_bounds.resize(0);
 
    set_default();
}
 
 
 
void BoundingLayer::set(const Index& new_neurons_number)
{
    set_neurons_number(new_neurons_number);
 
    set_default();
}
 
 
 
void BoundingLayer::set_inputs_number(const Index& new_inputs_number)
{
    lower_bounds.resize(new_inputs_number);
    upper_bounds.resize(new_inputs_number);
}
 
 
 
void BoundingLayer::set_neurons_number(const Index& new_neurons_number)
{
    lower_bounds.resize(new_neurons_number);
    upper_bounds.resize(new_neurons_number);
 
    lower_bounds.setConstant(-numeric_limits<type>::max());
    upper_bounds.setConstant(numeric_limits<type>::max());
}
 
 
 
void BoundingLayer::set(const tinyxml2::XMLDocument& bounding_layer_document)
{
    set_default();
 
    from_XML(bounding_layer_document);
}
 
 
 
void BoundingLayer::set(const BoundingLayer& other_bounding_layer)
{
    lower_bounds = other_bounding_layer.lower_bounds;
 
    upper_bounds = other_bounding_layer.upper_bounds;
 
    display = other_bounding_layer.display;
}
 
 
 
void BoundingLayer::set_bounding_method(const BoundingMethod& new_method)
{
    bounding_method = new_method;
}
 
 
 
void BoundingLayer::set_bounding_method(const string& new_method_string)
{
    if(new_method_string == "NoBounding")
    {
        bounding_method = BoundingMethod::NoBounding;
    }
    else if(new_method_string == "Bounding")
    {
        bounding_method = BoundingMethod::Bounding;
    }
    else
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: BoundingLayer class.\n"
               << "void set_bounding_method(const string&) method.\n"
               << "Unknown bounding method: " << new_method_string << ".\n";
 
        throw logic_error(buffer.str());
    }
}
 
 
 
void BoundingLayer::set_lower_bounds(const Tensor<type, 1>& new_lower_bounds)
{
#ifdef OPENNN_DEBUG
 
    const Index neurons_number = get_neurons_number();
 
    if(new_lower_bounds.size() != neurons_number)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: BoundingLayer class.\n"
               << "void set_lower_bounds(const Tensor<type, 1>&) method.\n"
               << "Size must be equal to number of bounding neurons number.\n";
 
        throw logic_error(buffer.str());
    }
 
#endif
 
    // Set lower bound of bounding neurons
 
    lower_bounds = new_lower_bounds;
}
 
 
 
void BoundingLayer::set_lower_bound(const Index& index, const type& new_lower_bound)
{
    const Index neurons_number = get_neurons_number();
 
#ifdef OPENNN_DEBUG
 
    if(index >= neurons_number)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: BoundingLayer class.\n"
               << "void set_lower_bound(const Index&, const type&) method.\n"
               << "Index of bounding neurons must be less than number of bounding neurons.\n";
 
        throw logic_error(buffer.str());
    }
 
#endif
 
    if(lower_bounds.size() != neurons_number)
    {
        lower_bounds.resize(neurons_number);
        lower_bounds.setConstant(-numeric_limits<type>::max());
    }
 
    // Set lower bound of single neuron
 
    lower_bounds[index] = new_lower_bound;
}
 
 
 
void BoundingLayer::set_upper_bounds(const Tensor<type, 1>& new_upper_bounds)
{
#ifdef OPENNN_DEBUG
check_size(new_upper_bounds, get_neurons_number(), LOG);
#endif
 
    // Set upper bound of neurons
 
    upper_bounds = new_upper_bounds;
}
 
 
 
void BoundingLayer::set_upper_bound(const Index& index, const type& new_upper_bound)
{
    const Index neurons_number = get_neurons_number();
 
#ifdef OPENNN_DEBUG
 
    if(index >= neurons_number)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: BoundingLayer class.\n"
               << "void set_upper_bound(const Index&, const type&) method.\n"
               << "Index of bounding neuron must be less than number of bounding neurons.\n";
 
        throw logic_error(buffer.str());
    }
 
#endif
 
    if(upper_bounds.size() != neurons_number)
    {
        upper_bounds.resize(neurons_number);
        upper_bounds.setConstant(numeric_limits<type>::max());
    }
 
    upper_bounds[index] = new_upper_bound;
 
}
 
 
 
void BoundingLayer::set_display(const bool& new_display)
{
    display = new_display;
}
 
 
 
void BoundingLayer::set_default()
{
    layer_name = "bounding_layer";
 
    bounding_method = BoundingMethod::Bounding;
 
    layer_type = Layer::Type::Bounding;
}
 
 
 
Tensor<type, 2> BoundingLayer::calculate_outputs(const Tensor<type, 2>& inputs)
{
#ifdef OPENNN_DEBUG
check_columns_number(inputs, get_inputs_number(), LOG);
#endif
 
    switch(bounding_method)
    {
        case BoundingMethod::NoBounding: return inputs;
 
        case BoundingMethod::Bounding:
        {
            const Index rows_number = inputs.dimension(0);
            const Index columns_number = inputs.dimension(1);
 
            Tensor<type, 2> outputs(rows_number, columns_number);
 
            for(Index i = 0; i < rows_number; i++)
            {
                for(Index j = 0; j < columns_number; j++)
                {
                    if(inputs(i,j) < lower_bounds(j)) outputs(i,j) = lower_bounds(j);
                    else if(inputs(i,j) > upper_bounds(j)) outputs(i,j) = upper_bounds(j);
                    else outputs(i,j) = inputs(i,j);
                }
            }
 
            return outputs;
        }
    }
 
    return Tensor<type, 2>();
}
 
 
 
string BoundingLayer::write_expression(const Tensor<string, 1>& inputs_names, const Tensor<string, 1>& outputs_names) const
{
    ostringstream buffer;
 
    buffer.precision(10);
 
    if(bounding_method == BoundingMethod::Bounding)
    {
        const Index neurons_number = get_neurons_number();
 
        for(Index i = 0; i < neurons_number; i++)
        {
            buffer << outputs_names[i] << " = max(" << lower_bounds[i] << ", " << inputs_names[i] << ")\n";
            buffer << outputs_names[i] << " = min(" << upper_bounds[i] << ", " << inputs_names[i] << ")\n";
        }
    }
    else
    {
        buffer << "";
    }
 
    return buffer.str();
}
 
 
 
string BoundingLayer::write_expression_c() const
{
    const Index neurons_number = get_neurons_number();
 
    ostringstream buffer;
 
    buffer << "vector<float> " << layer_name << "(const vector<float>& inputs)\n{" << endl;
 
    buffer << "\tvector<float> outputs(" << neurons_number << ");\n" << endl;
 
 
    if(bounding_method == BoundingMethod::Bounding)
    {
        for(Index i = 0; i < neurons_number; i++)
        {
            buffer << "\tif(inputs[" << i << "] < " << lower_bounds[i] << ")" << endl;
            buffer << "\t{" << endl;
            buffer << "\t    outputs[" << i << "] = " << lower_bounds[i] << endl;
            buffer << "\t}" << endl;
            buffer << "\telse if(inputs[" << i << "] > " << upper_bounds[i] << ")" << endl;
            buffer << "\t{" << endl;
            buffer << "\t    outputs[" << i << "] = " << upper_bounds[i] << endl;
            buffer << "\t}" << endl;
            buffer << "\telse" << endl;
            buffer << "\t{" << endl;
            buffer << "\t    outputs[" << i << "] = inputs[" << i << "];" << endl;
            buffer << "\t}" << endl;
        }
    }
    else
    {
        for(Index i = 0; i < neurons_number; i++)
        {
            buffer << "\toutputs[" << i << "] = inputs[" << i << "];" << endl;
        }
    }
 
    buffer << "\n\treturn outputs;\n}" << endl;
 
    return buffer.str();
}
 
 
 
string BoundingLayer::write_expression_python() const
{
    const Index neurons_number = get_neurons_number();
 
    ostringstream buffer;
 
    buffer << "\tdef " << layer_name << "(self,inputs):\n" << endl;
 
    buffer << "\t\toutputs = [None] * "<<neurons_number<<"\n" << endl;
 
    if(bounding_method == BoundingMethod::Bounding)
    {
        for(Index i = 0; i < neurons_number; i++)
        {
            buffer << "\t\tif inputs[" << i << "] < " << lower_bounds[i] << ":\n" << endl;
            buffer << "\t\t\toutputs[" << i << "] = " << lower_bounds[i] << "\n" << endl;
            buffer << "\t\telif inputs[" << i << "] >" << upper_bounds[i] << ":\n" << endl;
            buffer << "\t\t\toutputs[" << i << "] = " << upper_bounds[i] << "\n" << endl;
            buffer << "\t\telse:\n" << endl;
            buffer << "\t\t\toutputs[" << i << "] = inputs[" << i << "]\n"<< endl;
        }
    }
    else
    {
        for(Index i = 0; i < neurons_number; i++)
        {
            buffer << "\t\toutputs[" << i << "] = inputs[" << i << "]" << endl;
        }
    }
 
    buffer << "\n\t\treturn outputs\n" << endl;
 
    return buffer.str();
}
 
 
 
void BoundingLayer::write_XML(tinyxml2::XMLPrinter& file_stream) const
{
    ostringstream buffer;
 
    file_stream.OpenElement("BoundingLayer");
 
    // Bounding neurons number
 
    file_stream.OpenElement("BoundingNeuronsNumber");
 
    const Index neurons_number = get_neurons_number();
 
    buffer.str("");
    buffer << neurons_number;
 
    file_stream.PushText(buffer.str().c_str());
 
    file_stream.CloseElement();
 
    for(Index i = 0; i < neurons_number; i++)
    {
        file_stream.OpenElement("Item");
 
        file_stream.PushAttribute("Index", static_cast<unsigned>(i+1));
 
        // Lower bound
 
        file_stream.OpenElement("LowerBound");
 
        buffer.str("");
        buffer << lower_bounds[i];
 
        file_stream.PushText(buffer.str().c_str());
 
        file_stream.CloseElement();
 
        // Upper bound
 
        file_stream.OpenElement("UpperBound");
 
        buffer.str("");
        buffer << upper_bounds[i];
 
        file_stream.PushText(buffer.str().c_str());
 
        file_stream.CloseElement();
 
 
        file_stream.CloseElement();
    }
 
    // Bounding method
 
    file_stream.OpenElement("UseBoundingLayer");
 
    if(bounding_method == BoundingMethod::Bounding)
    {
        buffer.str("");
        buffer << 1;
    }
    else if(bounding_method == BoundingMethod::NoBounding)
    {
        buffer.str("");
        buffer << 0;
    }
    else
    {
        file_stream.CloseElement();
 
        buffer << "OpenNN Exception: BoundingLayer class.\n"
               << "void write_XML(tinyxml2::XMLPrinter&) const method.\n"
               << "Unknown bounding method type.\n";
 
        throw logic_error(buffer.str());
    }
 
    file_stream.PushText(buffer.str().c_str());
 
    file_stream.CloseElement();
 
   // Display
 
//   {
//      file_stream.OpenElement("Display");
 
//      buffer.str("");
//      buffer << display;
 
//      file_stream.PushText(buffer.str().c_str());
 
//      file_stream.CloseElement();
//   }
 
    file_stream.CloseElement();
}
 
 
 
void BoundingLayer::from_XML(const tinyxml2::XMLDocument& document)
{
    ostringstream buffer;
 
    const tinyxml2::XMLElement* bounding_layer_element = document.FirstChildElement("BoundingLayer");
 
    if(!bounding_layer_element)
    {
        buffer << "OpenNN Exception: BoundingLayer class.\n"
               << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
               << "BoundingLayer element is nullptr.\n";
 
        throw logic_error(buffer.str());
    }
 
    // Bounding neurons number
 
    const tinyxml2::XMLElement* neurons_number_element = bounding_layer_element->FirstChildElement("BoundingNeuronsNumber");
 
    if(!neurons_number_element)
    {
        buffer << "OpenNN Exception: BoundingLayer class.\n"
               << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
               << "BoundingNeuronsNumber 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
 
    if(neurons_number > 0)
    {
        const tinyxml2::XMLElement* start_element = neurons_number_element;
 
        for(Index i = 0; i < lower_bounds.size(); i++)
        {
            const tinyxml2::XMLElement* item_element = start_element->NextSiblingElement("Item");
            start_element = item_element;
 
            if(!item_element)
            {
                buffer << "OpenNN Exception: BoundingLayer class.\n"
                       << "void from_XML(const tinyxml2::XMLElement*) method.\n"
                       << "Item " << i+1 << " is nullptr.\n";
 
                throw logic_error(buffer.str());
            }
 
            item_element->QueryUnsignedAttribute("Index", &index);
 
            if(index != i+1)
            {
                buffer << "OpenNN Exception: BoundingLayer class.\n"
                       << "void from_XML(const tinyxml2::XMLElement*) method.\n"
                       << "Index " << index << " is not correct.\n";
 
                throw logic_error(buffer.str());
            }
 
            // Lower bound
 
            const tinyxml2::XMLElement* lower_bound_element = item_element->FirstChildElement("LowerBound");
 
            if(lower_bound_element)
            {
                if(lower_bound_element->GetText())
                {
                    lower_bounds[index-1] = static_cast<type>(atof(lower_bound_element->GetText()));
                }
            }
 
            // Upper bound
 
            const tinyxml2::XMLElement* upper_bound_element = item_element->FirstChildElement("UpperBound");
 
            if(upper_bound_element)
            {
                if(upper_bound_element->GetText())
                {
                    upper_bounds[index-1] = static_cast<type>(atof(upper_bound_element->GetText()));
                }
            }
        }
    }
 
    // Use bounding layer
    {
        const tinyxml2::XMLElement* use_bounding_layer_element = bounding_layer_element->FirstChildElement("UseBoundingLayer");
 
        if(use_bounding_layer_element)
        {
            Index new_method = static_cast<Index>(atoi(use_bounding_layer_element->GetText()));
 
            if(new_method == 1)
            {
                bounding_method = BoundingMethod::Bounding;
            }
            else if(new_method == 0)
            {
                bounding_method = BoundingMethod::NoBounding;
            }
            else
            {
                buffer << "OpenNN Exception: BoundingLayer class.\n"
                       << "void from_XML(const tinyxml2::XMLElement*) method.\n"
                       << "Unknown bounding method.\n";
 
                throw logic_error(buffer.str());
            }
        }
    }
}
 
}
 
// 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