network.h

Go to the documentation of this file.

/*
 * NeuralNetwork.h
 *
 *  Created on: Mar 5, 2018
 *    Author: joseph
 */

#ifndef BLACKCAT_NEURALNETWORK_NEURALNETWORK_H_
#define BLACKCAT_NEURALNETWORK_NEURALNETWORK_H_

#include "layers/layer_traits.h"

#include "layer_chain.h"
#include "layer_loader.h"
#include <sys/types.h>
#include <sys/stat.h>

namespace bc {
namespace nn {
namespace detail {

template<class T>
using is_recurrent_layer = bc::traits::conditional_detected_t<
        detail::query_forward_requires_outputs, T, std::false_type>;
}

template<class ... Layers>
struct NeuralNetwork {

    using self = NeuralNetwork<Layers...>;
    using is_recurrent = bc::traits::any<detail::is_recurrent_layer, Layers...>;
    using layer_chain = LayerChain<
            bc::traits::Integer<0>,
            void,
            Layers...>;

    layer_chain m_layer_chain;
    double m_learning_rate = m_layer_chain.head().layer().get_learning_rate();
    bc::size_t m_batch_size = 1;

    NeuralNetwork(Layers... layers): m_layer_chain(layers...)
    {
        if (is_recurrent::value) {
            m_layer_chain.for_each([&](auto& layer) {
                layer.get_cache().enable_recurrent_caching();
            });
        }
    }

    template<class T>
    auto forward_propagation(const T& tensor) {
        auto fp_caller = [](auto& layer, const auto& X) {
            return layer.forward_propagation(X);
        };

        zero_time_index();
        return m_layer_chain.for_each_propagate(fp_caller, tensor);
    }

    template<class T>
    auto back_propagation(const T& tensor) {
        auto bp_caller = [](auto& layer, const auto& Dy) {
            return layer.back_propagation(Dy);
        };

        auto& last_layer = m_layer_chain.tail();
        auto dx = last_layer.reverse_for_each_propagate(bp_caller, tensor);

        m_layer_chain.for_each([&](auto& layer) {
            layer.increment_time_index();
        });

        return dx;
    }

    template<class T>
    auto predict(const T& tensor) {
        auto fp_caller = [](auto& layer, const auto& X) {
            return layer.predict(X);
        };

        zero_time_index();
        return m_layer_chain.for_each_propagate(fp_caller, tensor);
    }

    template<class T>
    auto single_predict(const T& tensor) {
        auto fp_caller = [](auto& layer, const auto& X) {
            return layer.single_predict(X);
        };

        zero_time_index();
        return m_layer_chain.for_each_propagate(fp_caller, tensor);
    }

    template<int X> auto& get_layer() const {
        return m_layer_chain.get(bc::traits::Integer<X>());
    }

    template<int X> auto& get_layer() {
        return m_layer_chain.get(bc::traits::Integer<X>());
    }

    void set_learning_rate(double lr) {
        m_learning_rate = lr;
        m_layer_chain.for_each([&](auto& layer) {
            layer.set_learning_rate(lr);
        });
    }

    double get_learning_rate() const {
        return m_learning_rate;
    }

    void set_batch_size(int batch_sz) {
        m_batch_size = batch_sz;
        m_layer_chain.for_each([&](auto& layer) {
            layer.set_batch_size(batch_sz);
        });
    }

    void copy_training_data_to_single_predict(int batch_index) {
        BC_ASSERT(batch_index<batch_size(), "Require: batch_index < batch_size");

        m_layer_chain.for_each([&](auto& layer) {
            layer.zero_time_index();
            layer.copy_training_data_to_single_predict(batch_index);
        });
    }

    void zero_time_index() {
        m_layer_chain.for_each([&](auto& layer) {
            layer.zero_time_index();
        });
    }

    void update_weights() {
        m_layer_chain.for_each([ ](auto& layer) {layer.update_weights();});
    }

    bc::size_t input_size() const {
        return m_layer_chain.head().layer().input_size();
    }


    bc::size_t output_size() const {
        return m_layer_chain.tail().layer().output_size();
    }

    bc::size_t batch_size() const {
        return m_layer_chain.head().layer().batch_size();
    }

    std::string get_string_architecture() const {
        std::string architecture = "";
        m_layer_chain.for_each([&](auto& layer) {
            architecture += layer.get_string_architecture() + "\n";
        });
        return architecture;
    }

    void save(std::string directory_name) {
        zero_time_index();
        //Attempt to create a directory to save our model in
        if (directory_name == ".")
            directory_name = "";

        if (directory_name != "" &&
                !bc::filesystem::directory_exists(directory_name))
        {
            bc::filesystem::mkdir(directory_name);
        }

        auto get_filepath = [&](std::string filename) {
            return bc::filesystem::make_path(directory_name, filename);
        };

        {
            //Create a yaml file with network description/architecture
            std::ofstream os(get_filepath("architecture.yaml"));
            os << get_string_architecture();
        }

        {
            //Store meta-data about the current state
            std::ofstream os(get_filepath("meta"));
            os << this->get_learning_rate() << '\n';
            os << this->batch_size() << '\n';
        }

        //Initialize a layer loader object to load each layer
        Layer_Loader loader(directory_name);

        int index = 0;
        m_layer_chain.for_each([&](auto& layer) {
            loader.set_current_layer_index(index);
            loader.set_current_layer_name(layer.classname());
            loader.make_current_directory();
            layer.save(loader);
            layer.save_from_cache(loader, layer.get_cache());
            index++;
        });
    }

    void load(std::string directory_name) {
        zero_time_index();

        auto get_filepath = [&](std::string filename) {
            return bc::filesystem::make_path(directory_name, filename);
        };

        Layer_Loader loader(directory_name);
        int index = 0;

        m_layer_chain.for_each([&](auto& layer) {
            loader.set_current_layer_index(index);
            loader.set_current_layer_name(layer.classname());
            layer.load(loader);
            layer.load_to_cache(loader, layer.get_cache());
            index++;
        });

        std::ifstream is(get_filepath("meta"));
        std::string tmp;

        std::getline(is, tmp);
        set_learning_rate(std::stod(tmp));
        std::getline(is, tmp);
        set_batch_size(std::stoi(tmp));
    }
};


template<class ... Layers>
auto neuralnetwork(Layers ... layers) {
    return NeuralNetwork<Layers...>(layers...);
}

}
}

#endif /* NEURALNETWORK_H_ */