minkowski_error.cpp

//   OpenNN: Open Neural Networks Library
//   www.opennn.net
//
//   M I N K O W S K I   E R R O R   C L A S S
//
//   Artificial Intelligence Techniques SL
//   artelnics@artelnics.com
 
#include "minkowski_error.h"
 
namespace OpenNN
{
 
 
MinkowskiError::MinkowskiError() : LossIndex()
{
    set_default();
}
 
 
 
MinkowskiError::MinkowskiError(NeuralNetwork* new_neural_network_pointer, DataSet* new_data_set_pointer)
    : LossIndex(new_neural_network_pointer, new_data_set_pointer)
{
    set_default();
}
 
 
 
MinkowskiError::~MinkowskiError()
{
}
 
 
 
type MinkowskiError::get_Minkowski_parameter() const
{
    return minkowski_parameter;
}
 
 
 
void MinkowskiError::set_default()
{
    minkowski_parameter = type(1.5);
 
    display = true;
}
 
 
 
void MinkowskiError::set_Minkowski_parameter(const type& new_Minkowski_parameter)
{
    // Control sentence
 
    if(new_Minkowski_parameter < type(1) || new_Minkowski_parameter > type(2.0))
    {
        ostringstream buffer;
 
        buffer << "OpenNN Error. MinkowskiError class.\n"
               << "void set_Minkowski_parameter(const type&) method.\n"
               << "The Minkowski parameter must be comprised between 1 and 2.\n";
 
        throw logic_error(buffer.str());
    }
 
    // Set Minkowski parameter
 
    minkowski_parameter = new_Minkowski_parameter;
}
 
 
 
void MinkowskiError::calculate_error(const DataSetBatch& batch,
                                     const NeuralNetworkForwardPropagation&,
                                     LossIndexBackPropagation& back_propagation) const
{
    Tensor<type, 0> minkowski_error;
 
    minkowski_error.device(*thread_pool_device)
            = (back_propagation.errors.abs().pow(minkowski_parameter).sum()).pow(static_cast<type>(1.0)/minkowski_parameter);
 
    const Index batch_samples_number = batch.get_samples_number();
 
    back_propagation.error = minkowski_error(0)/batch_samples_number;
}
 
 
void MinkowskiError::calculate_output_delta(const DataSetBatch& batch,
                                            NeuralNetworkForwardPropagation&,
                                            LossIndexBackPropagation& back_propagation) const
{
    const Index trainable_layers_number = neural_network_pointer->get_trainable_layers_number();
 
    LayerBackPropagation* output_layer_back_propagation = back_propagation.neural_network.layers(trainable_layers_number-1);
 
    const Tensor<type, 0> p_norm_derivative =
            (back_propagation.errors.abs().pow(minkowski_parameter).sum().pow(static_cast<type>(1.0)/minkowski_parameter)).pow(minkowski_parameter - type(1));
 
    const Index batch_samples_number = batch.get_samples_number();
 
    switch(output_layer_back_propagation->layer_pointer->get_type())
    {
    case Layer::Type::Perceptron:
    {
        PerceptronLayerBackPropagation* perceptron_layer_back_propagation
                = static_cast<PerceptronLayerBackPropagation*>(output_layer_back_propagation);
 
        if(abs(p_norm_derivative()) < type(NUMERIC_LIMITS_MIN))
        {
            perceptron_layer_back_propagation->delta.setZero();
        }
        else
        {
            perceptron_layer_back_propagation->delta.device(*thread_pool_device)
                    = back_propagation.errors*(back_propagation.errors.abs().pow(minkowski_parameter - type(2)));
 
            perceptron_layer_back_propagation->delta.device(*thread_pool_device) =
                    (type(1.0/batch_samples_number))*perceptron_layer_back_propagation->delta/p_norm_derivative();
        }
    }
        break;
 
    case Layer::Type::Probabilistic:
    {
        ProbabilisticLayerBackPropagation* probabilistic_layer_back_propagation
                = static_cast<ProbabilisticLayerBackPropagation*>(output_layer_back_propagation);
 
        if(abs(p_norm_derivative()) < type(NUMERIC_LIMITS_MIN))
        {
            probabilistic_layer_back_propagation->delta.setZero();
 
        }
        else
        {
            probabilistic_layer_back_propagation->delta.device(*thread_pool_device)
                    = back_propagation.errors*(back_propagation.errors.abs().pow(minkowski_parameter - type(2)));
 
            probabilistic_layer_back_propagation->delta.device(*thread_pool_device) =
                    (type(1.0/batch_samples_number))*probabilistic_layer_back_propagation->delta/p_norm_derivative();
        }
    }
        break;
 
    case Layer::Type::Recurrent:
    {
        RecurrentLayerBackPropagation* recurrent_layer_back_propagation
                = static_cast<RecurrentLayerBackPropagation*>(output_layer_back_propagation);
 
        if(abs(p_norm_derivative()) < type(NUMERIC_LIMITS_MIN))
        {
            recurrent_layer_back_propagation->delta.setZero();
        }
        else
        {
            recurrent_layer_back_propagation->delta.device(*thread_pool_device)
                    = back_propagation.errors*(back_propagation.errors.abs().pow(minkowski_parameter - type(2)));
 
            recurrent_layer_back_propagation->delta.device(*thread_pool_device) =
                    (type(1.0/batch_samples_number))*recurrent_layer_back_propagation->delta/p_norm_derivative();
        }
    }
        break;
 
    case Layer::Type::LongShortTermMemory:
    {
        LongShortTermMemoryLayerBackPropagation* long_short_term_memory_layer_back_propagation
                = static_cast<LongShortTermMemoryLayerBackPropagation*>(output_layer_back_propagation);
 
        if(abs(p_norm_derivative()) < type(NUMERIC_LIMITS_MIN))
        {
            long_short_term_memory_layer_back_propagation->delta.setZero();
        }
        else
        {
            long_short_term_memory_layer_back_propagation->delta.device(*thread_pool_device)
                    = back_propagation.errors*(back_propagation.errors.abs().pow(minkowski_parameter - type(2)));
 
            long_short_term_memory_layer_back_propagation->delta.device(*thread_pool_device) =
                    (type(1.0/batch_samples_number))*long_short_term_memory_layer_back_propagation->delta/p_norm_derivative();
        }
    }
        break;
 
    default: break;
    }
}
 
 
 
string MinkowskiError::get_error_type() const
{
    return "MINKOWSKI_ERROR";
}
 
 
 
string MinkowskiError::get_error_type_text() const
{
    return "Minkowski error";
}
 
 
 
void MinkowskiError::write_XML(tinyxml2::XMLPrinter& file_stream) const
{
    ostringstream buffer;
 
    // Error type
 
    file_stream.OpenElement("MinkowskiError");
 
    // Minkowski parameter
 
    file_stream.OpenElement("MinkowskiParameter");
 
    buffer.str("");
    buffer << minkowski_parameter;
 
    file_stream.PushText(buffer.str().c_str());
 
    file_stream.CloseElement();
 
    // Close error
 
    file_stream.CloseElement();
}
 
 
 
void MinkowskiError::from_XML(const tinyxml2::XMLDocument& document)
{
    const tinyxml2::XMLElement* root_element = document.FirstChildElement("MinkowskiError");
 
    if(!root_element)
    {
        ostringstream buffer;
 
        buffer << "OpenNN Exception: MinkowskiError class.\n"
               << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
               << "Minkowski error element is nullptr.\n";
 
        throw logic_error(buffer.str());
    }
 
    // Minkowski parameter
 
    if(root_element)
    {
        const tinyxml2::XMLElement* parameter_element = root_element->FirstChildElement("MinkowskiParameter");
 
        type new_Minkowski_parameter = type(1.5);
 
        if(parameter_element)
        {
            new_Minkowski_parameter = static_cast<type>(atof(parameter_element->GetText()));
        }
 
        try
        {
            set_Minkowski_parameter(new_Minkowski_parameter);
        }
        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