NeuralNetwork.cpp

/**
 * DESCRIPTION OF THE FILE
 *
 * @author Michal Kravčenko
 * @date 13.6.18 -
 */

#include <iostream>
#include "../NetConnection/ConnectionFunctionConstant.h"

#include "message.h"
#include "NeuralNetwork.h"
#include "NeuralNetworkSerialization.h"
#include "exceptions.h"

#include "../mpi_wrapper.h"

namespace lib4neuro{
	int network_evaluation_counter = 0;
	int network_backpropagation_counter = 0;
}


namespace lib4neuro {

    NeuralNetwork::NeuralNetwork() {

        this->delete_weights  = true;
        this->delete_biases   = true;
        this->layers_analyzed = false;
    }

    NeuralNetwork::NeuralNetwork(std::string filepath) {
        this->init_from_file( filepath );
    }

    NeuralNetwork::~NeuralNetwork() {}

    NeuralNetwork* NeuralNetwork::get_subnet(::std::vector<size_t>& input_neuron_indices,
                                             ::std::vector<size_t>& output_neuron_indices) {

        THROW_NOT_IMPLEMENTED_ERROR();

        NeuralNetwork* output_net = nullptr;
// TODO rework due to the changed structure of the class
        return output_net;
    }

    size_t NeuralNetwork::add_neuron(std::shared_ptr<Neuron> n,
                                     BIAS_TYPE bt,
                                     size_t bias_idx) {

        if (bt == BIAS_TYPE::NO_BIAS) {
            this->neuron_bias_indices.push_back(-1);
        } else if (bt == BIAS_TYPE::NEXT_BIAS) {
            this->neuron_bias_indices.push_back((int) this->neuron_biases.size());
            this->neuron_biases.resize(this->neuron_biases.size() + 1);
        } else if (bt == BIAS_TYPE::EXISTING_BIAS) {
            if (bias_idx >= this->neuron_biases.size()) {
                THROW_RUNTIME_ERROR("The supplied bias index is too large!");
            }
            this->neuron_bias_indices.push_back((int) bias_idx);
        }

        this->outward_adjacency.push_back(std::make_shared<std::vector<std::pair<size_t, size_t>>>(::std::vector<std::pair<size_t, size_t>>(0)));
        this->inward_adjacency.push_back(std::make_shared<std::vector<std::pair<size_t, size_t>>>(::std::vector<std::pair<size_t, size_t>>(0)));

        this->neurons.push_back(n);

        this->layers_analyzed = false;
        return this->neurons.size() - 1;
    }

    void NeuralNetwork::eval_single_debug(::std::vector<double>& input,
                                          ::std::vector<double>& output,
                                          std::vector<double>* custom_weights_and_biases) {
        if ((this->input_neuron_indices.size() * this->output_neuron_indices.size()) <= 0) {
            THROW_INVALID_ARGUMENT_ERROR("Input and output neurons have not been specified!");
        }

        if (this->input_neuron_indices.size() != input.size()) {
            THROW_INVALID_ARGUMENT_ERROR("Data input size != Network input size");
        }

        if (this->output_neuron_indices.size() != output.size()) {
            THROW_INVALID_ARGUMENT_ERROR("Data output size != Network output size");
        }

		lib4neuro::network_evaluation_counter++;

        double potential, bias;
        int    bias_idx;

        this->copy_parameter_space(custom_weights_and_biases);

        this->analyze_layer_structure();

        /* reset of the output and the neuron potentials */
        ::std::fill(output.begin(),
                    output.end(),
                    0.0);
        ::std::fill(this->neuron_potentials.begin(),
                    this->neuron_potentials.end(),
                    0.0);

        /* set the potentials of the input neurons */
        for (size_t i = 0; i < this->input_neuron_indices.size(); ++i) {
            this->neuron_potentials.at(this->input_neuron_indices.at(i)) = input[i];
            std::cout << this->neuron_potentials.at(this->input_neuron_indices.at(i)) << ", ";
        }
        std::cout << std::endl;



        /* we iterate through all the feed-forward layers and transfer the signals */
        for (auto layer: this->neuron_layers_feedforward) {
            /* we iterate through all neurons in this layer and propagate the signal to the neighboring neurons */

            for (auto si: *layer) {
                bias      = 0.0;
                bias_idx  = this->neuron_bias_indices.at(si);
                if (bias_idx >= 0) {
                    bias = this->neuron_biases.at(bias_idx);
                }
                potential = this->neurons.at(si)->activate(this->neuron_potentials.at(si),
                                                           bias);
                std::cout << "Neuron" << si << " (" << this->neuron_potentials.at(si) << " - " << bias << ") -> (" << potential << ")" << std::endl;
//                std::cout << "  applying bias: " << bias << " to neuron potential: " << this->neuron_potentials.at(si)
//                          << " -> " << potential << std::endl;

                for (auto c: *this->outward_adjacency.at(si)) {
                    size_t ti = c.first;
                    size_t ci = c.second;

                    this->neuron_potentials.at(ti) +=
                        this->connection_list.at(ci)->eval(this->connection_weights) * potential;
                    std::cout << "    EDGE(" << si << ", " << ti << ")" << this->connection_list.at(ci)->eval(this->connection_weights) << std::endl;

//                    std::cout << "  adding input to neuron " << ti << " += "
//                              << this->connection_list.at(ci)->eval(this->connection_weights) << "*" << potential
//                              << std::endl;
                }
            }
        }

        unsigned int i = 0;
        for (auto    oi: this->output_neuron_indices) {
            bias     = 0.0;
            bias_idx = this->neuron_bias_indices.at(oi);
            if (bias_idx >= 0) {
                bias = this->neuron_biases.at(bias_idx);
            }
            output[i] = this->neurons.at(oi)->activate(this->neuron_potentials.at(oi),
                                                       bias);
//            std::cout << "setting the output[" << i << "] = " << output[i] << "(bias = " << bias << ")" << std::endl;
            ++i;
        }
    }


    size_t
    NeuralNetwork::add_connection_simple(size_t n1_idx,
                                         size_t n2_idx,
                                         SIMPLE_CONNECTION_TYPE sct,
                                         size_t weight_idx) {

        std::shared_ptr<ConnectionFunctionIdentity> con_weight_u1u2;
        if (sct == SIMPLE_CONNECTION_TYPE::UNITARY_WEIGHT) {
            con_weight_u1u2 = std::make_shared<ConnectionFunctionIdentity>(ConnectionFunctionIdentity());
        } else {
            if (sct == SIMPLE_CONNECTION_TYPE::NEXT_WEIGHT) {
                weight_idx = this->connection_weights.size();
                this->connection_weights.resize(weight_idx + 1);
            } else if (sct == SIMPLE_CONNECTION_TYPE::EXISTING_WEIGHT) {
                if (weight_idx >= this->connection_weights.size()) {
                    ::std::cerr << "The supplied connection weight index is too large!\n" << ::std::endl;
                }
            }

            con_weight_u1u2 = std::make_shared<ConnectionFunctionIdentity>(ConnectionFunctionIdentity(weight_idx));
        }

        size_t conn_idx = this->add_new_connection_to_list(con_weight_u1u2);

        this->add_outward_connection(n1_idx,
                                     n2_idx,
                                     conn_idx);
        this->add_inward_connection(n2_idx,
                                    n1_idx,
                                    conn_idx);

        this->layers_analyzed = false;

        return this->connection_list.size() - 1;
    }

    size_t
    NeuralNetwork::add_connection_constant(size_t n1_idx,
                                           size_t n2_idx,
                                           double weight) {