bounding_layer.cpp

/****************************************************************************************************************/
/*                                                                                                              */
/*   OpenNN: Open Neural Networks Library                                                                       */
/*   www.artelnics.com/opennn                                                                                   */
/*                                                                                                              */
/*   B O U N D I N G   L A Y E R   C L A S S                                                                    */
/*                                                                                                              */
/*   Roberto Lopez                                                                                              */
/*   Artelnics - Making intelligent use of data                                                                 */
/*   [email protected]                                                                                 */
/*                                                                                                              */
/****************************************************************************************************************/

// OpenNN includes

#include "bounding_layer.h"

namespace OpenNN
{

// DEFAULT CONSTRUCTOR


BoundingLayer::BoundingLayer(void)
{
   set();
}


// BOUNDING NEURONS NUMBER CONSTRUCTOR


BoundingLayer::BoundingLayer(const size_t& bounding_neurons_number)
{
   set(bounding_neurons_number);

   set_default();
}


// XML CONSTRUCTOR


BoundingLayer::BoundingLayer(const tinyxml2::XMLDocument& bounding_layer_document)
{
   set(bounding_layer_document);
}


// COPY CONSTRUCTOR


BoundingLayer::BoundingLayer(const BoundingLayer& other_bounding_layer)
{
   set(other_bounding_layer);
}


// DESTRUCTOR


BoundingLayer::~BoundingLayer(void)
{
}


// ASSIGNMENT OPERATOR


BoundingLayer& BoundingLayer::operator = (const BoundingLayer& other_bounding_layer)
{
   if(this != &other_bounding_layer) 
   {
      lower_bounds = other_bounding_layer.lower_bounds;
      upper_bounds = other_bounding_layer.upper_bounds;
      display = other_bounding_layer.display;
   }

   return(*this);
}


// EQUAL TO OPERATOR

// bool operator == (const BoundingLayer&) const method


bool BoundingLayer::operator == (const BoundingLayer& other_bounding_layer) const
{
    if(lower_bounds == other_bounding_layer.lower_bounds
    && upper_bounds == other_bounding_layer.upper_bounds
    && display == other_bounding_layer.display)
    {
       return(true);
    }
    else
    {
       return(false);
    }
}


// bool is_empty(void) const method


bool BoundingLayer::is_empty(void) const
{
   if(get_bounding_neurons_number() == 0)
   {
      return(true);
   }
   else
   {
      return(false);
   }
}


// size_t get_bounding_neurons_number(void) const method


size_t BoundingLayer::get_bounding_neurons_number(void) const
{
   return(lower_bounds.size());
}


// const Vector<double>& get_lower_bounds(void) const method


const Vector<double>& BoundingLayer::get_lower_bounds(void) const
{
   return(lower_bounds);               
}


// double get_lower_bound(const size_t&) const const method


double BoundingLayer::get_lower_bound(const size_t& i) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG

   const size_t bounding_neurons_number = get_bounding_neurons_number();

   if(i >= bounding_neurons_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: BoundingLayer class.\n" 
             << "double get_lower_bound(const size_t&) const method.\n"
             << "Index must be less than number of bounding neurons.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   return(lower_bounds[i]);
}


// const Vector<double>& get_upper_bound(void) const method


const Vector<double>& BoundingLayer::get_upper_bounds(void) const
{
   return(upper_bounds);               
}


// double get_upper_bound(const size_t&) const method


double BoundingLayer::get_upper_bound(const size_t& i) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG

   const size_t bounding_neurons_number = get_bounding_neurons_number();

   if(bounding_neurons_number == 0)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: BoundingLayer class.\n" 
             << "double get_upper_bound(const size_t&) const method.\n"
             << "Number of bounding neurons is zero.\n";

      throw std::logic_error(buffer.str());
   }
   else if(i >= bounding_neurons_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: BoundingLayer class.\n" 
             << "double get_upper_bound(const size_t&) const method.\n"
             << "Index must be less than number of bounding neurons.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   return(upper_bounds[i]);
}


// Vector< Vector<double>* > get_bounds(void) method


Vector< Vector<double>* > BoundingLayer::get_bounds(void)
{
   Vector< Vector<double>* > bounds(2);

   bounds[0] = &lower_bounds;
   bounds[1] = &upper_bounds;

   return(bounds);
}


// void set(void)


void BoundingLayer::set(void)
{
   lower_bounds.set();
   upper_bounds.set();

   set_default();
}


// void set(const size_t&)


void BoundingLayer::set(const size_t& new_bounding_neurons_number)
{
   lower_bounds.set(new_bounding_neurons_number);
   upper_bounds.set(new_bounding_neurons_number);

   set_default();
}


// void set(const tinyxml2::XMLDocument&) method


void BoundingLayer::set(const tinyxml2::XMLDocument& bounding_layer_document)
{
    set_default();

   from_XML(bounding_layer_document);
}


// void set(const BoundingLayer&)


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 set_lower_bound(const Vector<double>&) method


void BoundingLayer::set_lower_bounds(const Vector<double>& new_lower_bounds)
{
   // Control sentence (if debug)

   #ifndef NDEBUG

   const size_t bounding_neurons_number = get_bounding_neurons_number();

   if(new_lower_bounds.size() != bounding_neurons_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: BoundingLayer class.\n"
             << "void set_lower_bounds(const Vector<double>&) method.\n"
             << "Size must be equal to number of bounding neurons number.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   // Set lower bound of bounding neurons

   lower_bounds = new_lower_bounds;
}


// void set_lower_bound(const size_t&, const double&) method


void BoundingLayer::set_lower_bound(const size_t& index, const double& new_lower_bound)
{
   const size_t bounding_neurons_number = get_bounding_neurons_number();

   // Control sentence (if debug)

   #ifndef NDEBUG

   if(index >= bounding_neurons_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: BoundingLayer class.\n"
             << "void set_lower_bound(const size_t&, const double&) method.\n"
             << "Index of bounding neurons must be less than number of bounding neurons.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   if(lower_bounds.size() != bounding_neurons_number)
   {
      lower_bounds.set(bounding_neurons_number, -1.0e99);
   }

   // Set lower bound of single neuron

   lower_bounds[index] = new_lower_bound;
}


// void set_upper_bounds(const Vector<double>&) method


void BoundingLayer::set_upper_bounds(const Vector<double>& new_upper_bounds)
{
   // Control sentence (if debug)

   #ifndef NDEBUG

   const size_t bounding_neurons_number = get_bounding_neurons_number();

   if(new_upper_bounds.size() != bounding_neurons_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: BoundingLayer class.\n"
             << "void set_upper_bound(const Vector<double>&) method.\n"
             << "Size must be equal to number of bounding neurons.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   // Set upper bound of neurons

   upper_bounds = new_upper_bounds;
}


// void set_upper_bound(const size_t&, const double&) method


void BoundingLayer::set_upper_bound(const size_t& index, const double& new_upper_bound)
{
   const size_t bounding_neurons_number = get_bounding_neurons_number();

   // Control sentence (if debug)

   #ifndef NDEBUG

   if(index >= bounding_neurons_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: BoundingLayer class.\n"
             << "void set_upper_bound(const size_t&, const double&) method.\n"
             << "Index of bounding neuron must be less than number of bounding neurons.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   if(upper_bounds.size() != bounding_neurons_number)
   {
      upper_bounds.set(bounding_neurons_number, 1.0e99);
   }

   // Set upper bound of single bounding neuron

   upper_bounds[index] = new_upper_bound;
}


// void set_bounds(const Vector< Vector<double> >&) method


void BoundingLayer::set_bounds(const Vector< Vector<double> >& new_bounds)
{
   // Control sentence (if debug)

   #ifndef NDEBUG

   const size_t size = new_bounds.size();

   const size_t bounding_neurons_number = get_bounding_neurons_number();

   if(size != 2)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: BoundingLayer class.\n"
             << "void set_bounds(const Vector< Vector<double> >&) method.\n"
             << "Number of rows must be 2.\n";

      throw std::logic_error(buffer.str());
   }
   else if(new_bounds[0].size() != bounding_neurons_number
        && new_bounds[1].size() != bounding_neurons_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: BoundingLayer class.\n"
             << "void set_bounds(const Vector< Vector<double> >&) method.\n"
             << "Number of columns must be equal to number of bounding neurons.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   // Set lower and upper bounds of bounding neurons

   set_lower_bounds(new_bounds[0]);
   set_upper_bounds(new_bounds[1]);
}


// void set_display(const bool&) method


void BoundingLayer::set_display(const bool& new_display)
{
   display = new_display;
}


// void set_default(void) method


void BoundingLayer::set_default(void)
{
   display = true;        
}


// void prune_bounding_neuron(const size_t&) method


void BoundingLayer::prune_bounding_neuron(const size_t& index)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    const size_t bounding_neurons_number = get_bounding_neurons_number();

    if(index >= bounding_neurons_number)
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: BoundingLayer class.\n"
              << "void prune_bounding_neuron(const size_t&) method.\n"
              << "Index of bounding neuron is equal or greater than number of bounding neurons.\n";

       throw std::logic_error(buffer.str());
    }

    #endif

    lower_bounds.erase(lower_bounds.begin() + index);
    upper_bounds.erase(upper_bounds.begin() + index);
}


// void initialize_random(void) method


void BoundingLayer::initialize_random(void)
{
   Vector<double> random_vector(4);
   random_vector.randomize_normal();

   std::sort(random_vector.begin(), random_vector.end());

   lower_bounds.randomize_uniform(random_vector[0], random_vector[1]);
   upper_bounds.randomize_uniform(random_vector[2], random_vector[3]);
}


// Vector<double> calculate_outputs(const Vector<double>&) const method


Vector<double> BoundingLayer::calculate_outputs(const Vector<double>& inputs) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG

   const size_t inputs_size = inputs.size();

   const size_t bounding_neurons_number = get_bounding_neurons_number();

   if(inputs_size != bounding_neurons_number) 
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: BoundingLayer class.\n"
             << "Vector<double> calculate_outputs(const Vector<double>&) const method.\n"
             << "Size of inputs must be equal to number of bounding neurons.\n";

      throw std::logic_error(buffer.str());
   }   

   #endif

   return(inputs.calculate_lower_upper_bounded(lower_bounds, upper_bounds));
}  


// Vector<double> calculate_derivative(const Vector<double>&) const method


Vector<double> BoundingLayer::calculate_derivative(const Vector<double>& inputs) const
{
   const size_t bounding_neurons_number = get_bounding_neurons_number();

   const Vector<double> outputs = calculate_outputs(inputs);

   Vector<double> derivatives(bounding_neurons_number);

   for(size_t i = 0; i < bounding_neurons_number; i++)
   {
      if(outputs[i] <= lower_bounds[i] || outputs[i] >= upper_bounds[i])
      {           
         derivatives[i] = 0.0;
      }
      else
      {
         derivatives[i] = 1.0;
      }
   }

   return(derivatives);
}


// Vector<double> calculate_second_derivative(const Vector<double>&) const method


Vector<double> BoundingLayer::calculate_second_derivative(const Vector<double>& inputs) const
{
   std::ostringstream buffer;

   const size_t bounding_neurons_number = get_bounding_neurons_number();

   const Vector<double> outputs = calculate_outputs(inputs);

   for(size_t i = 0; i < bounding_neurons_number; i++)
   {
      if(outputs[i] == lower_bounds[i])
      {
         buffer << "OpenNN Exception: BoundingLayer class.\n"
                << "Vector<double> calculate_outputs(const Vector<double>&) const method.\n"
                << "Output is equal to lower bound. The bounding function is not differentiable at this point.\n";

         throw std::logic_error(buffer.str());
      }
      else if(outputs[i] == upper_bounds[i])
      {
         buffer << "OpenNN Exception: BoundingLayer class.\n"
                << "Vector<double> calculate_outputs(const Vector<double>&) const method.\n"
                << "Output is equal to upper bound. The bounding function is not differentiable at this point.\n";

         throw std::logic_error(buffer.str());
      }
   }

   Vector<double> second_derivative(bounding_neurons_number, 0.0);

   return(second_derivative);
}


// Matrix<double> arrange_Jacobian(const Vector<double>&) const method


Matrix<double> BoundingLayer::arrange_Jacobian(const Vector<double>& derivatives) const
{   
   const size_t bounding_neurons_number = get_bounding_neurons_number();

   // Control sentence (if debug)

   #ifndef NDEBUG

   const size_t derivatives_size = derivatives.size();

   if(derivatives_size != bounding_neurons_number) 
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: BoundingLayer class.\n"
             << "Matrix<double> arrange_Jacobian(const Vector<double>&) method.\n"
             << "Size of derivatives must be equal to number of bounding neurons.\n";

      throw std::logic_error(buffer.str());
   }   

   #endif

   Matrix<double> Jacobian(bounding_neurons_number, bounding_neurons_number, 0.0);
   Jacobian.set_diagonal(derivatives);

   return(Jacobian);
}  


// Vector< Matrix<double> > arrange_Hessian_form(const Vector<double>&) const method


Vector< Matrix<double> > BoundingLayer::arrange_Hessian_form(const Vector<double>&) const
{
   const size_t bounding_neurons_number = get_bounding_neurons_number();

   Vector< Matrix<double> > bounded_Hessian_form(bounding_neurons_number);

   for(size_t i = 0; i < bounding_neurons_number; i++)
   {
      bounded_Hessian_form[i].set(bounding_neurons_number, bounding_neurons_number, 0.0);
   }

   return(bounded_Hessian_form);
}


// std::string write_expression(const Vector<std::string>&, const Vector<std::string>&) const method


std::string BoundingLayer::write_expression(const Vector<std::string>& inputs_name, const Vector<std::string>& outputs_name) const
{
   std::stringstream expression;
   
   const size_t bounding_neurons_number = get_bounding_neurons_number();

   for(size_t i = 0; i < bounding_neurons_number; i++)
   {
      expression << outputs_name[i] << " < " << lower_bounds[i] << " ? " << lower_bounds[i] << " : " << inputs_name[i] << "\n";      
      expression << outputs_name[i] << " > " << upper_bounds[i] << " ? " << upper_bounds[i] << " : " << inputs_name[i] << "\n";      
   }

   return(expression.str());
}


// std::string to_string(void) const method


std::string BoundingLayer::to_string(void) const
{
   std::ostringstream buffer;

   buffer << "Bounding layer\n"  
          << "Lower bounds: " << lower_bounds << "\n"
          << "Upper bounds: " << upper_bounds << "\n"
          << "Display: " << display << "\n";

   return(buffer.str());
}


// tinyxml2::XMLDocument* to_XML(void) const method


tinyxml2::XMLDocument* BoundingLayer::to_XML(void) const
{
   tinyxml2::XMLDocument* document = new tinyxml2::XMLDocument;

   std::ostringstream buffer;

   tinyxml2::XMLElement* bounding_layer_element = document->NewElement("BoundingLayer");

   document->InsertFirstChild(bounding_layer_element);

   // Lower bounds

   {
      tinyxml2::XMLElement* element = document->NewElement("LowerBounds");
      bounding_layer_element->LinkEndChild(element);

      buffer.str("");
      buffer << lower_bounds;

      tinyxml2::XMLText* text = document->NewText(buffer.str().c_str());
      element->LinkEndChild(text);
   }

   // Upper bounds

   {
      tinyxml2::XMLElement* element = document->NewElement("UpperBounds");
      bounding_layer_element->LinkEndChild(element);

      buffer.str("");
      buffer << upper_bounds;

      tinyxml2::XMLText* text = document->NewText(buffer.str().c_str());
      element->LinkEndChild(text);
   }

   // Display
   {
      tinyxml2::XMLElement* display_element = document->NewElement("Display");
      bounding_layer_element->LinkEndChild(display_element);

      buffer.str("");
      buffer << display;

      tinyxml2::XMLText* display_text = document->NewText(buffer.str().c_str());
      display_element->LinkEndChild(display_text);
   }

   return(document);
}


// void from_XML(const tinyxml2::XMLDocument&) method


void BoundingLayer::from_XML(const tinyxml2::XMLDocument& document)
{
      // Control sentence 
//      {
//         const char* text = bounding_layer_element->GetText();     

//         const std::string string(text);

//         if(string != "BoundingLayer")
//         {
//            std::ostringstream buffer;

//            buffer << "OpenNN Exception: BoundingLayer class.\n" 
//                   << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
//                   << "Unkown root element: " << text << ".\n";

//              throw std::logic_error(buffer.str());
//         }
//      }

  // Lower bounds
  {
     const tinyxml2::XMLElement* lower_bounds_element = document.FirstChildElement("LowerBounds");

     if(lower_bounds_element)
     {
        const char* lower_bounds_text = lower_bounds_element->GetText();

        if(lower_bounds_text)
        {
           Vector<double> new_lower_bounds;
           new_lower_bounds.parse(lower_bounds_text);

           try
           {
              set_lower_bounds(new_lower_bounds);
           }
           catch(const std::logic_error& e)
           {
              std::cout << e.what() << std::endl;
           }
        }
     }
  }

  // Upper bounds
  {
     const tinyxml2::XMLElement* upper_bounds_element = document.FirstChildElement("UpperBounds");

     if(upper_bounds_element)
     {
        const char* upper_bounds_text = upper_bounds_element->GetText();

        if(upper_bounds_text)
        {
           Vector<double> new_upper_bounds;
           new_upper_bounds.parse(upper_bounds_text);

           try
           {
              set_upper_bounds(new_upper_bounds);
           }
           catch(const std::logic_error& e)
           {
              std::cout << e.what() << std::endl;
           }
        }
     }
  }

  // Display
  {
     const tinyxml2::XMLElement* display_element = document.FirstChildElement("Display");

     if(display_element)
     {
        std::string new_display_string = display_element->GetText();

        try
        {
           set_display(new_display_string != "0");
        }
        catch(const std::logic_error& e)
        {
           std::cout << e.what() << std::endl;
        }
     }
  }
}

}

// OpenNN: Open Neural Networks Library.
// Copyright (c) 2005-2015 Roberto Lopez.
//
// 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