MultiLayerNeuralNetwork.hpp

Go to the documentation of this file.

#ifndef SRC_MLNN_MULTILAYERNEURALNETWORK_HPP_
#define SRC_MLNN_MULTILAYERNEURALNETWORK_HPP_

#include <types/MatrixTypes.hpp>
#include <mlnn/layer/LayerTypes.hpp>
#include <loss/LossTypes.hpp>

#include <fstream>
// Include headers that implement a archive in simple text format
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>

// Forward declaration of class boost::serialization::access
namespace boost {
namespace serialization {
class access;
}//: serialization
}//: access


namespace mic {
namespace mlnn {

using namespace activation_function;
using namespace cost_function;
using namespace fully_connected;
using namespace convolution;
using namespace regularisation;

template <typename eT>
class MultiLayerNeuralNetwork {
public:

    MultiLayerNeuralNetwork(std::string name_ = "mlnn") :
        name(name_),
        connected(false) // Initially the network is not connected.
    {

    }

    virtual ~MultiLayerNeuralNetwork() { }

    template <typename LayerType>
    void pushLayer( LayerType* layer_ptr_){
        layers.push_back(std::shared_ptr <LayerType> (layer_ptr_));
        connected = false;
    }

    template <typename LayerType>
    std::shared_ptr<LayerType> getLayer(size_t index_){
        assert(index_ < layers.size());
        // Cast the pointer to LayerType.
        return std::dynamic_pointer_cast< LayerType >( layers[index_] );
    }

    std::shared_ptr<Layer<eT> > getLayer(size_t index_){
        assert(index_ < layers.size());
        // Cast the pointer to LayerType.
        return layers[index_];
    }

    void popLayer(size_t number_of_layers_ = 1){
        assert(number_of_layers_ <= layers.size());
        //layers.erase(layers.back() - number_of_layers_, layers.back());
        for (size_t i=0; i <number_of_layers_; i++)
            layers.pop_back();
        connected = false;
    }


    size_t layerInputsSize(size_t layer_number_ = -1) {
        assert (layer_number_ < layers.size());
        // Last layer.
        if (layer_number_ < 0)
            layer_number_ = layers.size() -1;
        // Return input size.
        return layers[layer_number_]->inputsSize();
    }

    size_t lastLayerOutputsSize(size_t layer_number_ = -1) {
        assert (layer_number_ < layers.size());
        // Last layer.
        if (layer_number_ < 0)
            layer_number_ = layers.size() -1;
        // Return input size.
        return layers[layer_number_]->outputsSize();
    }

    size_t lastLayerBatchSize(size_t layer_number_ = -1) {
        assert (layer_number_ < layers.size());
        // Last layer.
        if (layer_number_ < 0)
            layer_number_ = layers.size() -1;
        // Return input size.
        return layers[layer_number_]->batchSize();
    }


    template<typename omT>
    void setOptimization () {
        // Iterate through layers and set optimization function for each one.
        for (size_t i = 0; i < layers.size(); i++)
            layers[i]->template setOptimization<omT> ();
    }


    void update(eT alpha_, eT decay_ = 0.0f) {
        // The updates are cumulated for a batch, reduce the alpha rate.
        eT alpha_batch = alpha_/layers[0]->batch_size;

        for (size_t i = 0; i < layers.size(); i++) {
            layers[i]->update(alpha_batch, decay_);
        }//: for
    }


    void resetGrads() {
        for (size_t i = 0; i < layers.size(); i++)
            layers[i]->resetGrads();
    }

    void resizeBatch(size_t batch_size_) {
        // If current batch size is ok.
        if ((size_t)(layers[0]->s['x'])->cols() == batch_size_)
            return;

        // Else - resize.
        for (size_t i = 0; i < layers.size(); i++) {
            layers[i]->resizeBatch(batch_size_);
        }//: for
    }

    mic::types::MatrixPtr<eT> getPredictions() {
        return layers.back()->s['y'];
    }

    mic::types::MatrixPtr<eT> getPredictions(size_t layer_nr_) {
        assert(layer_nr_ < layers.size());
        return layers[layer_nr_]->s['y'];
    }

    size_t countCorrectPredictions(mic::types::MatrixPtr<eT> targets_, mic::types::MatrixPtr<eT> predictions_)  {

        // Get vectors of indices denoting classes (type of 1-ouf-of-k dencoding).
        mic::types::Matrix<eT> predicted_classes = predictions_->colwiseReturnMaxIndices();
        mic::types::Matrix<eT> target_classes = targets_->colwiseReturnMaxIndices();

        // Get direct pointers to data.
        eT *p = predicted_classes.data();
        eT *t = target_classes.data();

        size_t correct=0;
        size_t i;
        for(i=0; i< (size_t) predicted_classes.size(); i++) {
            if (p[i] == t[i])
                correct++;
        }//: for

        return correct;
    }


    friend std::ostream& operator<<(std::ostream& os_, const MultiLayerNeuralNetwork& obj_) {
        // Display dimensions.
        os_ << "[" << obj_.name << "]:\n";
        // Display layers one by one.
        for (size_t i = 0; i < obj_.layers.size(); i++)
            os_ << (*obj_.layers[i]) << std::endl;

        return os_;
    }


    bool save(std::string filename_)
    {
        try {
            // Create an output archive
            std::ofstream ofs(filename_);
            boost::archive::text_oarchive ar(ofs);

            // Change batch size to 1 - fastening the save/load procedures.
            //setBatchSize(1);

            // Write data
            ar & (*this);
            LOG(LINFO) << "Network " << name << " properly saved to file " << filename_;
            LOG(LDEBUG) << "Saved network: \n" << (*this);
        } catch(...) {
            LOG(LERROR) << "Could not write neural network " << name << " to file " << filename_ << "!";
            // Clear layers - just in case.
            layers.clear();
            return false;
        }
        return true;
    }

    bool load(std::string filename_)
    {
        try {
            // Create and input archive
            std::ifstream ifs(filename_);
            boost::archive::text_iarchive ar(ifs);
            // Load data
            ar & (*this);
            LOG(LINFO) << "Network " << name << " properly loaded from file " << filename_;
            LOG(LDEBUG) << "Loaded network: \n" << (*this);
        } catch(...) {
            LOG(LERROR) << "Could not load neural network from file " << filename_ << "!";
            // Clear layers - just in case.
            layers.clear();
            return false;
        }
        return true;
    }



protected:
    std::vector<std::shared_ptr <mic::mlnn::Layer<eT> > > layers;

    std::string name;

    bool connected;


private:
    // Friend class - required for using boost serialization.
    friend class boost::serialization::access;

    template<class Archive>
    void save(Archive & ar, const unsigned int version) const {
        // Serialize name.
        ar & name;

        // Serialize number of layers.
        size_t size = layers.size();
        ar & size;

        // Serialize layers one by one.
        for (size_t i = 0; i < layers.size(); i++) {
            // Serialize type first - so we can use it in load.
            ar & layers[i]->layer_type;

            // Serialize the layer.
            ar & (*layers[i]);
        }//: for

    }

    template<class Archive>
    void load(Archive & ar, const unsigned int version) {
        // Clear the layers vector - just in case.
        layers.clear();
        connected = false;

        // Deserialize name.
        ar & name;

        // Deserialize the number of layers.
        size_t size;
        ar & size;

        // Serialize layers one by one.
        for (size_t i = 0; i < size; i++) {
            LayerTypes lt;
            // Get layer type
            ar & lt;

            std::shared_ptr<Layer<eT> > layer_ptr;
            switch(lt) {
            // activation_function
            case(LayerTypes::ELU):
                layer_ptr = std::make_shared<ELU<eT> >(ELU<eT>());
                LOG(LDEBUG) <<  "ELU";
                break;
            case(LayerTypes::ReLU):
                layer_ptr = std::make_shared<ReLU<eT> >(ReLU<eT>());
                LOG(LDEBUG) <<  "ReLU";
                break;
            case(LayerTypes::Sigmoid):
                layer_ptr = std::make_shared<Sigmoid<eT> >(Sigmoid<eT>());
                LOG(LDEBUG) <<  "Sigmoid";
                break;

            // convolution
            case(LayerTypes::Convolution):
                layer_ptr = std::make_shared<Convolution<eT> >(Convolution<eT>());
                LOG(LERROR) <<  "Convolution Layer serialization not implemented (some params are not serialized)!";
                break;
            case(LayerTypes::Cropping):
                layer_ptr = std::make_shared<Cropping<eT> >(Cropping<eT>());
                LOG(LERROR) <<  "Cropping Layer serialization not implemented (some params are not serialized)!";
                break;
            case(LayerTypes::MaxPooling):
                layer_ptr = std::make_shared<MaxPooling<eT> >(MaxPooling<eT>());
                LOG(LERROR) <<  "MaxPooling Layer serialization not implemented (some params are not serialized)!";
                break;
            case(LayerTypes::Padding):
                layer_ptr = std::make_shared<Padding<eT> >(Padding<eT>());
                LOG(LERROR) <<  "Padding Layer serialization not implemented (some params are not serialized)!";
                break;

            // cost_function
            case(LayerTypes::Softmax):
                layer_ptr = std::make_shared<Softmax<eT> >(Softmax<eT>());
                LOG(LDEBUG) <<  "Softmax";
                break;

            // fully_connected
            case(LayerTypes::Linear):
                //ar.template register_type<mic::mlnn::Linear>();
                layer_ptr = std::make_shared<Linear<eT> >(Linear<eT>());
                LOG(LDEBUG) <<  "Linear";
                break;
            case(LayerTypes::SparseLinear):
                layer_ptr = std::make_shared<SparseLinear<eT> >(SparseLinear<eT>());
                LOG(LDEBUG) <<  "SparseLinear";
                break;
            case(LayerTypes::HebbianLinear):
                layer_ptr = std::make_shared<HebbianLinear<eT> >(HebbianLinear<eT>());
                LOG(LDEBUG) <<  "HebbianLinear";
                break;

            case(LayerTypes::BinaryCorrelator):
                layer_ptr = std::make_shared<BinaryCorrelator<eT> >(BinaryCorrelator<eT>());
                LOG(LDEBUG) <<  "BinaryCorrelator";
                break;

            // regularisation
            case(LayerTypes::Dropout):
                layer_ptr = std::make_shared<Dropout<eT> >(Dropout<eT>());
                LOG(LERROR) <<  "Dropout Layer serialization not implemented (some params are not serialized)!";
                break;

            default:
                LOG(LERROR) <<  "Undefined Layer type detected during deserialization!";
            }//: switch

            ar & (*layer_ptr);
            layers.push_back(layer_ptr);
        }//: for

    }

     // The serialization must be splited as load requires to allocate the memory.
     BOOST_SERIALIZATION_SPLIT_MEMBER()

};


} /* namespace mlnn */
} /* namespace mic */

// Just in the case that something important will change in the MLNN class - set version.
BOOST_CLASS_VERSION(mic::mlnn::MultiLayerNeuralNetwork<float>, 2)
BOOST_CLASS_VERSION(mic::mlnn::MultiLayerNeuralNetwork<double>, 2)


#endif /* SRC_MLNN_MULTILAYERNEURALNETWORK_HPP_ */