NeuralNetwork.cpp

    void NeuralNetwork::set_normalization_strategy_instance(NormalizationStrategy *ns) {
        if(!ns) {
            THROW_RUNTIME_ERROR("Argument 'ns' is not initialized!");
        }
        this->normalization_strategy = ns;
    }

    FullyConnectedFFN::FullyConnectedFFN(std::vector<unsigned int>* neuron_numbers, NEURON_TYPE hidden_layer_neuron_type) : NeuralNetwork() {
        if(neuron_numbers->size() < 2) {
            THROW_INVALID_ARGUMENT_ERROR("Parameter 'neuron_numbers' specifying numbers of neurons in network's layers "
                                         "doesn't specify input and output layers, which are compulsory!");
        }

        this->neurons = new ::std::vector<Neuron *>(0);
        this->neuron_biases = new ::std::vector<double>(0);
        this->neuron_potentials = 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 = new ::std::vector<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;

        unsigned int inp_dim = neuron_numbers->at(0);  //!< Network input dimension
        unsigned int out_dim = neuron_numbers->back(); //!< Network output dimension

        COUT_DEBUG("Fully connected feed-forward network being constructed:" << std::endl);
        COUT_DEBUG("# of inputs: " << inp_dim << std::endl);
        COUT_DEBUG("# of outputs: " << out_dim << std::endl);

        std::vector<size_t> input_layer_neuron_indices;
        std::vector<size_t> previous_layer_neuron_indices;
        std::vector<size_t> current_layer_neuron_indices;

        /* Creation of INPUT layer neurons */
        current_layer_neuron_indices.reserve(inp_dim);
        input_layer_neuron_indices.reserve(inp_dim);
        for(unsigned int i = 0; i < inp_dim; i++) {
            size_t neuron_id = this->add_neuron(new NeuronLinear, BIAS_TYPE::NO_BIAS);
            current_layer_neuron_indices.emplace_back(neuron_id);
        }
        input_layer_neuron_indices = current_layer_neuron_indices;

        /* Creation of HIDDEN layers */
        for(unsigned int i = 1; i <= neuron_numbers->size()-2; i++) {
            COUT_DEBUG("Hidden layer #" << i << ": " << neuron_numbers->at(i) << " neurons" << std::endl);
            previous_layer_neuron_indices.reserve(neuron_numbers->at(i-1));
            previous_layer_neuron_indices = current_layer_neuron_indices;
            current_layer_neuron_indices.clear();
            current_layer_neuron_indices.reserve(neuron_numbers->at(i));

            /* Creation of one single hidden layer */
            for(unsigned int j = 0; j < neuron_numbers->at(i); j++) {
                size_t neuron_id;

                /* Create new hidden neuron */
                switch (hidden_layer_neuron_type) {
                    case NEURON_TYPE::BINARY: {
                        neuron_id = this->add_neuron(new NeuronBinary, BIAS_TYPE::NEXT_BIAS);
                        break;
                    }

                    case NEURON_TYPE::CONSTANT: {
                        THROW_INVALID_ARGUMENT_ERROR("Constant neurons can't be used in fully connected feed-forward networks!");
                        break;
                    }

                    case NEURON_TYPE::LINEAR: {
                        neuron_id = this->add_neuron(new NeuronLinear, BIAS_TYPE::NEXT_BIAS);
                        break;
                    }

                    case NEURON_TYPE::LOGISTIC: {
                        neuron_id = this->add_neuron(new NeuronLogistic, BIAS_TYPE::NEXT_BIAS);
                        break;
                    }
                }

                current_layer_neuron_indices.emplace_back(neuron_id);

                /* Connect new neuron with all neurons from the previous layer */
                for(auto ind : previous_layer_neuron_indices) {
                    this->add_connection_simple(ind, neuron_id, l4n::SIMPLE_CONNECTION_TYPE::NEXT_WEIGHT);
                }
            }
        }

        previous_layer_neuron_indices.reserve(neuron_numbers->back()-1);
        previous_layer_neuron_indices = current_layer_neuron_indices;
        current_layer_neuron_indices.clear();
        current_layer_neuron_indices.reserve(out_dim);

        /* Creation of OUTPUT layer neurons */
        for(unsigned int i = 0; i < out_dim; i++) {
            size_t neuron_id = this->add_neuron(new NeuronLinear, BIAS_TYPE::NO_BIAS);
            current_layer_neuron_indices.emplace_back(neuron_id);

            /* Connect new neuron with all neuron from the previous layer */
            for(auto ind : previous_layer_neuron_indices) {
                this->add_connection_simple(ind, neuron_id, l4n::SIMPLE_CONNECTION_TYPE::NEXT_WEIGHT);
            }
        }

        /* Init variables containing indices of INPUT nad OUTPUT neurons */
        this->input_neuron_indices = new ::std::vector<size_t>(inp_dim);
        this->output_neuron_indices = new ::std::vector<size_t>(out_dim);

        *this->input_neuron_indices = input_layer_neuron_indices;
        *this->output_neuron_indices = current_layer_neuron_indices;

        this->analyze_layer_structure();
    }

}