probabilistic_layer.cpp

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

// OpenNN includes

#include "probabilistic_layer.h"

namespace OpenNN
{

// DEFAULT CONSTRUCTOR


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


// PROBABILISTIC NEURONS NUMBER CONSTRUCTOR


ProbabilisticLayer::ProbabilisticLayer(const size_t& new_probabilistic_neurons_number)
{
   set(new_probabilistic_neurons_number);
}


// COPY CONSTRUCTOR


ProbabilisticLayer::ProbabilisticLayer(const ProbabilisticLayer& other_probabilistic_layer)
{
   set(other_probabilistic_layer);
}


// DESTRUCTOR


ProbabilisticLayer::~ProbabilisticLayer(void)
{
}


// ASSIGNMENT OPERATOR


ProbabilisticLayer& ProbabilisticLayer::operator = (const ProbabilisticLayer& other_probabilistic_layer)
{
   if(this != &other_probabilistic_layer) 
   {
      probabilistic_neurons_number = other_probabilistic_layer.probabilistic_neurons_number;

      probabilistic_method = other_probabilistic_layer.probabilistic_method;

      display = other_probabilistic_layer.display;
   }

   return(*this);
}


// EQUAL TO OPERATOR

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


bool ProbabilisticLayer::operator == (const ProbabilisticLayer& other_probabilistic_layer) const
{
   if(probabilistic_neurons_number == other_probabilistic_layer.probabilistic_neurons_number
   && probabilistic_method == other_probabilistic_layer.probabilistic_method
   && display == other_probabilistic_layer.display)
   {
      return(true);   
   }   
   else
   {
      return(false);  
   }
}


// METHODS

// const size_t& get_outputs_number(void) const method


const size_t& ProbabilisticLayer::get_probabilistic_neurons_number(void) const
{
   return(probabilistic_neurons_number);
}


// const ProbabilisticMethod& get_probabilistic_method(void) const method


const ProbabilisticLayer::ProbabilisticMethod& ProbabilisticLayer::get_probabilistic_method(void) const
{
   return(probabilistic_method);
}


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


std::string ProbabilisticLayer::write_probabilistic_method(void) const
{
   if(probabilistic_method == Competitive)
   {
      return("Competitive");
   }
   else if(probabilistic_method == Softmax)
   {
      return("Softmax");
   }
   else if(probabilistic_method == NoProbabilistic)
   {
      return("NoProbabilistic");
   }
   else
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: ProbabilisticLayer class.\n"
             << "std::string write_probabilistic_method(void) const method.\n"
             << "Unknown probabilistic method.\n";
 
      throw std::logic_error(buffer.str());
   }
}


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


std::string ProbabilisticLayer::write_probabilistic_method_text(void) const
{
   if(probabilistic_method == Competitive)
   {
      return("competitive");
   }
   else if(probabilistic_method == Softmax)
   {
      return("softmax");
   }
   else if(probabilistic_method == NoProbabilistic)
   {
      return("no probabilistic");
   }
   else
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: ProbabilisticLayer class.\n"
             << "std::string write_probabilistic_method_text(void) const method.\n"
             << "Unknown probabilistic method.\n";

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


// const bool& get_display(void) const method


const bool& ProbabilisticLayer::get_display(void) const
{
   return(display);
}


// void set(void) method


void ProbabilisticLayer::set(void)
{
   probabilistic_neurons_number = 0;

   set_default();
}


// void set(const size_t&) method


void ProbabilisticLayer::set(const size_t& new_probabilistic_neurons_number)
{
   probabilistic_neurons_number = new_probabilistic_neurons_number;

   set_default();
}


// void set(const ProbabilisticLayer&) method


void ProbabilisticLayer::set(const ProbabilisticLayer& other_probabilistic_layer)
{
   probabilistic_neurons_number = other_probabilistic_layer.probabilistic_neurons_number;

   probabilistic_method = other_probabilistic_layer.probabilistic_method;

   display = other_probabilistic_layer.display;
}


// void set_probabilistic_neurons_number(const size_t&) method


void ProbabilisticLayer::set_probabilistic_neurons_number(const size_t& new_probabilistic_neurons_number)
{
   probabilistic_neurons_number = new_probabilistic_neurons_number;
}


// void set_default(void) method


void ProbabilisticLayer::set_default(void)
{
   probabilistic_method = Softmax;
   
   display = true;
}


// void set_probablistic_method(const ProbabilisticMethod&) method


void ProbabilisticLayer::set_probabilistic_method(const ProbabilisticMethod& new_probabilistic_method)
{
   probabilistic_method = new_probabilistic_method;
}


// void set_probabilistic_method(const std::string&) method


void ProbabilisticLayer::set_probabilistic_method(const std::string& new_probabilistic_method)
{
   if(new_probabilistic_method == "Competitive")
   {
      set_probabilistic_method(Competitive);
   }
   else if(new_probabilistic_method == "Softmax")
   {
      set_probabilistic_method(Softmax);
   }
   else if(new_probabilistic_method == "NoProbabilistic")
   {
      set_probabilistic_method(NoProbabilistic);
   }
   else
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: ProbabilisticLayer class.\n"
             << "void set_probabilistic_method(const std::string&) method.\n"
             << "Unknown probabilistic method: " << new_probabilistic_method << ".\n";

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


// void set_display(const bool&) method


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


// void prune_probabilistic_neuron(void) method


void ProbabilisticLayer::prune_probabilistic_neuron(void)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

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

       buffer << "OpenNN Exception: ProbabilisticLayer class.\n"
              << "void prune_probabilistic_neuron(void) method.\n"
              << "Number of probabilistic neurons is zero.\n";

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

    #endif

    probabilistic_neurons_number--;
}


// void initialize_random(void) method


void ProbabilisticLayer::initialize_random(void)
{
    // Probabilistic method

    switch(rand()%3)
    {
      case 0:
      {
         probabilistic_method = Competitive;
      }
      break;

    case 1:
    {
       probabilistic_method = Softmax;
    }
    break;

    case 2:
    {
       probabilistic_method = NoProbabilistic;
    }
    break;

      default:
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception: ProbabilisticLayer class.\n"
                << "void initialize_random(void) method.\n"
                << "Unknown probabilistic method.\n";

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


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


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

   #ifndef NDEBUG 

   const size_t size = inputs.size();

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

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

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

   #endif

   switch(probabilistic_method)
   {
      case Competitive:
      {
         return(calculate_competitive_output(inputs));
      }
      break;

      case Softmax:
      {
         return(calculate_softmax_output(inputs));
      }
      break;       

       case NoProbabilistic:
       {
          return(calculate_no_probabilistic_output(inputs));
       }
       break;

      default:
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception: ProbabilisticLayer class.\n"
                << "Vector<double> calculate_outputs(const Vector<double>&) const method.\n"               
                << "Unknown probabilistic method.\n";
 
         throw std::logic_error(buffer.str());
      }// end default
      break;

   }// end switch
}  


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


Matrix<double> ProbabilisticLayer::calculate_Jacobian(const Vector<double>& inputs) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t size = inputs.size();

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

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

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

   #endif

   switch(probabilistic_method)
   {
      case Competitive:
      {
         return(calculate_competitive_Jacobian(inputs));
      }
      break;

      case Softmax:
      {
          return(calculate_softmax_Jacobian(inputs));
      }
      break;       

       case NoProbabilistic:
       {
           return(calculate_no_probabilistic_Jacobian(inputs));
       }
       break;

      default:
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception: ProbabilisticLayer class.\n"
                << "Matrix<double> calculate_Jacobian(const Vector<double>&) const method.\n"               
                << "Unknown probabilistic method.\n";
 
         throw std::logic_error(buffer.str());
      }// end default
      break;

   }// end switch
}


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


Vector< Matrix<double> > ProbabilisticLayer::calculate_Hessian_form(const Vector<double>& inputs) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t size = inputs.size();

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

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

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

   #endif

   switch(probabilistic_method)
   {
      case Competitive:
      {
         return(calculate_competitive_Hessian_form(inputs));
      }
      break;

      case Softmax:
      {
          return(calculate_softmax_Hessian_form(inputs));
      }
      break;       

       case NoProbabilistic:
       {
           return(calculate_no_probabilistic_Hessian_form(inputs));
       }
       break;

      default:
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception: ProbabilisticLayer class.\n"
                << "Matrix<double> calculate_Hessian_form(const Vector<double>&) const method.\n"               
                << "Unknown probabilistic method.\n";
 
         throw std::logic_error(buffer.str());
      }// end default
      break;

   }// end switch
}


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


Vector<double> ProbabilisticLayer::calculate_competitive_output(const Vector<double>& inputs) const
{
   return(inputs.calculate_competitive());
}


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


Matrix<double> ProbabilisticLayer::calculate_competitive_Jacobian(const Vector<double>&) const
{
   std::ostringstream buffer;

   buffer << "OpenNN Exception: ProbabilisticLayer class.\n"
          << "Matrix<double> calculate_competitive_Jacobian(const Vector<double>&) const method.\n"               
          << "The competitive function is not derivable.\n";
 
   throw std::logic_error(buffer.str());
}


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


Vector< Matrix<double> > ProbabilisticLayer::calculate_competitive_Hessian_form(const Vector<double>&) const
{
   std::ostringstream buffer;

   buffer << "OpenNN Exception: ProbabilisticLayer class.\n"
          << "Vector< Matrix<double> > calculate_competitive_Hessian_form(const Vector<double>&) const method.\n"               
          << "The competitive function is not derivable.\n";
 
   throw std::logic_error(buffer.str());
}


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


Vector<double> ProbabilisticLayer::calculate_softmax_output(const Vector<double>& inputs) const
{
   return(inputs.calculate_softmax());
}


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


Matrix<double> ProbabilisticLayer::calculate_softmax_Jacobian(const Vector<double>& inputs) const
{
   Matrix<double> probabilistic_Jacobian(probabilistic_neurons_number, probabilistic_neurons_number);

   const Vector<double> outputs = inputs.calculate_softmax();

   for(size_t i = 0; i < probabilistic_neurons_number; i++)
   {
      for(size_t j = 0; j < probabilistic_neurons_number; j++)
      {
         if(i == j)
         {
            probabilistic_Jacobian(i,i) = outputs[i]*(1.0 - outputs[i]);
         }
         else
         {
            probabilistic_Jacobian(i,j) = -outputs[i]*outputs[j];
         }
      }         
   }         

   return(probabilistic_Jacobian);
}


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


Vector< Matrix<double> > ProbabilisticLayer::calculate_softmax_Hessian_form(const Vector<double>&) const
{
   Vector< Matrix<double> > Hessian_form;

   return(Hessian_form);
}


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


Vector<double> ProbabilisticLayer::calculate_no_probabilistic_output(const Vector<double>& inputs) const
{
    return(inputs);
}


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


Matrix<double> ProbabilisticLayer::calculate_no_probabilistic_Jacobian(const Vector<double>&) const
{
    Matrix<double> Jacobian(probabilistic_neurons_number, probabilistic_neurons_number);

    Jacobian.initialize_identity();

    return(Jacobian);
}


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


Vector< Matrix<double> > ProbabilisticLayer::calculate_no_probabilistic_Hessian_form(const Vector<double>&) const
{
    Vector< Matrix<double> > Hessian_form;

    return(Hessian_form);
}


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


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

   buffer << "Probabilistic layer\n"
          << "Probabilistic neurons number: " << probabilistic_neurons_number << "\n"
          << "Probabilistic method: " << write_probabilistic_method() << "\n"
          << "Display: "<< display << "\n";

   return(buffer.str());
}


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


tinyxml2::XMLDocument* ProbabilisticLayer::to_XML(void) const
{
   std::ostringstream buffer;

   tinyxml2::XMLDocument* document = new tinyxml2::XMLDocument;   

   tinyxml2::XMLElement* root_element = document->NewElement("ProbabilisticLayer");

   document->InsertFirstChild(root_element);

   tinyxml2::XMLElement* element = NULL;
   tinyxml2::XMLText* text = NULL;

   // Probabilistic neurons number 
   {
      element = document->NewElement("ProbabilisticNeuronsNumber");
      root_element->LinkEndChild(element);

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

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

   // Probabilistic method
   {
      element = document->NewElement("ProbabilisticMethod");
      root_element->LinkEndChild(element);

      text = document->NewText(write_probabilistic_method().c_str());
      element->LinkEndChild(text);
   }

   // Display 
   {
      element = document->NewElement("Display");
      root_element->LinkEndChild(element);

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

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

   return(document);
}


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


void ProbabilisticLayer::from_XML(const tinyxml2::XMLDocument& document)
{
    std::ostringstream buffer;

    const tinyxml2::XMLElement* probabilistic_layer_element = document.FirstChildElement("ProbabilisticLayer");

    if(!probabilistic_layer_element)
    {
        buffer << "OpenNN Exception: ProbabilisticLayer class.\n"
               << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
               << "Probabilistic layer element is NULL.\n";

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

  // Probabilistic neurons number
  {
     const tinyxml2::XMLElement* element = probabilistic_layer_element->FirstChildElement("ProbabilisticNeuronsNumber");

     if(element)
     {
        const char* text = element->GetText();

        if(text)
        {
           try
           {
              set_probabilistic_neurons_number(atoi(text));
           }
           catch(const std::logic_error& e)
           {
              std::cout << e.what() << std::endl;
           }
        }
     }
  }

  // Probabilistic method
  {
     const tinyxml2::XMLElement* element = probabilistic_layer_element->FirstChildElement("ProbabilisticMethod");

     if(element)
     {
        const char* text = element->GetText();

        if(text)
        {
           try
           {
              std::string new_probabilistic_method(text);

              set_probabilistic_method(new_probabilistic_method);
           }
           catch(const std::logic_error& e)
           {
              std::cout << e.what() << std::endl;
           }
        }
     }
  }

  // Display
  {
     const tinyxml2::XMLElement* display_element = probabilistic_layer_element->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;
        }
     }
  }
}


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


std::string ProbabilisticLayer::write_competitive_expression(const Vector<std::string>& inputs_names, const Vector<std::string>& outputs_names) const
{
    std::ostringstream buffer;

    for(size_t i = 0; i < probabilistic_neurons_number; i++)
    {
        buffer << outputs_names[i] << "= Competitive(" << inputs_names.to_string(",") << ");\n";
    }

    return(buffer.str());
}


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


std::string ProbabilisticLayer::write_softmax_expression(const Vector<std::string>& inputs_names, const Vector<std::string>& outputs_names) const
{
    std::ostringstream buffer;

    for(size_t i = 0; i < probabilistic_neurons_number; i++)
    {
        buffer << outputs_names[i] << "= Softmax(" << inputs_names.to_string(",") << ");\n";
    }

    return(buffer.str());
}


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


std::string ProbabilisticLayer::write_no_probabilistic_expression(const Vector<std::string>& inputs_names, const Vector<std::string>& outputs_names) const
{
    std::ostringstream buffer;

    for(size_t i = 0; i < probabilistic_neurons_number; i++)
    {
        buffer << outputs_names[i] << " = " << inputs_names.to_string() << ";\n";
    }

    return(buffer.str());
}


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


std::string ProbabilisticLayer::write_expression(const Vector<std::string>& inputs_names, const Vector<std::string>& outputs_names) const
{   
   switch(probabilistic_method)
   {
      case Competitive:
      {   
          return(write_competitive_expression(inputs_names, outputs_names));
      }
      break;

      case Softmax:
      {
          return(write_softmax_expression(inputs_names, outputs_names));
      }
      break;       

       case NoProbabilistic:
       {
           return(write_no_probabilistic_expression(inputs_names, outputs_names));
       }
       break;

      default:
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception: ProbabilisticLayer class.\n"
                << "std::string write_expression(const Vector<std::string>&, const Vector<std::string>&) const method.\n"               
                << "Unknown probabilistic method.\n";
 
      throw std::logic_error(buffer.str());
      }// end default
      break;
   }// end switch
}

}

// 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