NeuralNetwork.cpp

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

#include <iostream>
#include <4neuro.h>
#include <NetConnection/ConnectionFunctionConstant.h>

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


namespace lib4neuro {
    NeuralNetwork::NeuralNetwork() {
//        this->neurons = new ::std::vector<Neuron *>(0);
//        this->neuron_biases = new ::std::vector<double>(0);
//        this->neuron_bias_indices = new ::std::vector<int>(0);

//        this->connection_weights = new ::std::vector<double>(0);
//        this->connection_list = ::std::vector<std::shared_ptr<ConnectionFunctionGeneral>>(0);
//        this->inward_adjacency = new ::std::vector<std::vector<std::pair<size_t, size_t>> *>(0);
//        this->outward_adjacency = new ::std::vector<std::vector<std::pair<size_t, size_t>> *>(0);
//
//        this->neuron_layers_feedforward = new ::std::vector<std::vector<size_t> *>(0);
//        this->neuron_layers_feedbackward = new ::std::vector<std::vector<size_t> *>(0);

//        this->input_neuron_indices = new ::std::vector<size_t>(0);
//        this->output_neuron_indices = new ::std::vector<size_t>(0);

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

    NeuralNetwork::NeuralNetwork(std::string filepath) {
        ::std::ifstream ifs(filepath);
        if(ifs.is_open()) {
            try {
                boost::archive::text_iarchive ia(ifs);
                ia >> *this;
            }catch(boost::archive::archive_exception& e) {
                THROW_RUNTIME_ERROR("Serialized archive error: '" + e.what() + "'! Please, check if your file is really "
                                                                               "the serialized DataSet.");
            }
            ifs.close();
        } else {
            THROW_RUNTIME_ERROR("File '" + filepath + "' couldn't be open!");
        }

    }

    NeuralNetwork::~NeuralNetwork() {

//        if (this->neurons) {
//            for (auto n: *(this->neurons)) {
//                delete n;
//                n = nullptr;
//            }
//            delete this->neurons;
//            this->neurons = nullptr;
//        }

//        if (this->neuron_potentials) {
//            delete this->neuron_potentials;
//            this->neuron_potentials = nullptr;
//        }
//
//        if (this->neuron_bias_indices) {
//            delete this->neuron_bias_indices;
//            this->neuron_bias_indices = nullptr;
//        }
//
//        if (this->output_neuron_indices) {
//            delete this->output_neuron_indices;
//            this->output_neuron_indices = nullptr;
//        }
//
//        if (this->input_neuron_indices) {
//            delete this->input_neuron_indices;
//            this->input_neuron_indices = nullptr;
//        }

//        if (this->connection_weights && this->delete_weights) {
//            delete this->connection_weights;
//            this->connection_weights = nullptr;
//        }

//        if (this->neuron_biases && this->delete_biases) {
//            delete this->neuron_biases;
//            this->neuron_biases = nullptr;
//        }

//        if (this->connection_list) {
//
//            if (this->delete_weights) {
//                for (auto& c: *this->connection_list) {
//                    printf("%p\n", c);
//                    if(c) {
//                        printf("Deleting %p\n", c);
//                        puts("c");
////                        delete c;
//                        puts("a");
////                        c = nullptr;
//                        puts("b");
//                    }
//                }
//            }
//        }
//        this->connection_list.clear();
//        delete this->connection_list;
//        this->connection_list = nullptr;

//        puts("*********** 1");

//        if (this->inward_adjacency) {
//            for (auto e: *this->inward_adjacency) {
//                if (e) {
//                    delete e;
//                    e = nullptr;
//                }
//            }
//            delete this->inward_adjacency;
//            this->inward_adjacency = nullptr;
//        }
//
//        if (this->outward_adjacency) {
//            for (
//                auto e: *this->outward_adjacency) {
//                if (e) {
//                    delete e;
//                    e = nullptr;
//                }
//            }
//            delete this-> outward_adjacency;
//            this->outward_adjacency = nullptr;
//        }
//
//        if (this->neuron_layers_feedforward) {
//            for (
//                auto e: this->neuron_layers_feedforward) {
//                delete e;
//                e = nullptr;
//            }
//            delete this->neuron_layers_feedforward;
//            this->neuron_layers_feedforward = nullptr;
//        }
//
//        if (this->neuron_layers_feedbackward) {
//            for (
//                auto e: *this->neuron_layers_feedbackward) {
//                delete e;
//                e = nullptr;
//            }
//            delete this->neuron_layers_feedbackward;
//            this->neuron_layers_feedbackward = nullptr;
//        }

    }

    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
//    Neuron * active_neuron, * target_neuron;
//
//    size_t n = this->neurons.size();
//    bool *part_of_subnetwork = new bool[n];
//    ::std::fill(part_of_subnetwork, part_of_subnetwork + n, false);
//
//    bool *is_reachable_from_source = new bool[n];
//    bool *is_reachable_from_destination = new bool[n];
//    ::std::fill(is_reachable_from_source, is_reachable_from_source + n, false);
//    ::std::fill(is_reachable_from_destination, is_reachable_from_destination + n, false);
//
//    bool *visited_neurons = new bool[n];
//    ::std::fill(visited_neurons, visited_neurons + n, false);
//
//    size_t active_set_size[2];
//    active_set_size[0] = 0;
//    active_set_size[1] = 0;
//    size_t * active_neuron_set = new size_t[2 * n];
//    size_t idx1 = 0, idx2 = 1;
//
//    /* MAPPING BETWEEN NEURONS AND THEIR INDICES */
//    size_t idx = 0, idx_target;
//    for(Neuron *v: *this->neurons){
//        v->set_idx( idx );
//        idx++;
//    }
//
//    /* INITIAL STATE FOR THE FORWARD PASS */
//    for(size_t i: input_neuron_indices ){