Model.hpp

Go to the documentation of this file.

#pragma once
#include "GenericErrorFunction.hpp"
#include "Layer.hpp"
#include "ErrorFunction.hpp"
#include <Eigen/Core>
#include <cstddef>
#include <filesystem>
#include <memory>
#include <vector>
#include "FullyConnectedLayer.hpp"
#include "exceptions.hpp"
#include <iostream>
#include <filesystem>
 
#ifdef DEBUG
 
#define LOG(X) std::cout<<"[INFO] "<<(X)<<std::endl;
#define WARN(X) std::cout<<"[WARN] "<<(X)<<std::endl;
#define ERR(X) std::cerr<<"[ERROR] "<<(X)<<std::endl;
 
#else
 
#define LOG(X)
#define WARN(X)
#define ERR(X)
 
#endif
 
 
namespace mlask {
class Model {
  private:
    std::size_t in_;
    std::size_t out_;
    std::vector<std::unique_ptr<Layer>> layers_;
    std::size_t epochs_;
    bool log_;
    std::size_t epoch_ = 0;
 
  public:
    Model(std::size_t in, std::size_t out, std::size_t size = 0, std::size_t epochs=0, bool log=false);
 
    void addLayer(std::unique_ptr<Layer> layer);
 
    template<TLayer layer, typename... Args>
    void addLayer(Args&&... args);
 
    template<std::size_t in, std::size_t out>
    void addFullyConnectedLayer();
    void addLambdaActivationFunction( actfunc func, actfunc derv);
 
    template<ErrorFunction err>
    void backprop(vectorIn input, vectorOut expected);
 
    void fit(float_t learning_rate);
    vectorOut forward(vectorIn input) const;
 
    template<ErrorFunction err>
    [[nodiscard]] float_t error(vectorIn input, vectorOut expected)const;
 
 
    template<ErrorFunction err>
    [[nodiscard]] float_t whole_error(Eigen::Matrix<float_t, Eigen::Dynamic, Eigen::Dynamic> input, Eigen::Matrix<float_t, Eigen::Dynamic, Eigen::Dynamic> expected)const;
 
    const Layer* getLayer(std::size_t index)const{ return layers_[index].get(); }
    const Layer* operator[](std::size_t index)const { return getLayer(index); }
 
    [[nodiscard]] std::string str()const;
 
    void exportToONNX(std::filesystem::path path, std::string name = "MLask Model") const;
 
private:
    void convertToONNX(onnx::ModelProto& model, std::string name)const;
    inline std::size_t lastOut()const{
        if(layers_.empty()){
            return in_;
        }
        return layers_.back()->getOut();
    }
};
 
 
template <std::size_t in, std::size_t out>
void Model::addFullyConnectedLayer(){
    std::size_t last_out = lastOut();
    if(in != last_out){
        ERR("Input size of the layer does not match the output size of the previous layer");
        throw ArchitectureError("Input size of the layer does not match the output size of the previous layer", layers_.size());
    }
    else{
        layers_.push_back(std::make_unique<FullyConnectedLayer<in, out>>());
        LOG("Added FullyConnected Layer");
    }
}
 
template<TLayer layer, typename... Args>
void Model::addLayer(Args&&... args){
    layers_.push_back(std::make_unique<layer>(std::forward<Args>(args)...));
}
 
template<ErrorFunction err>
float_t Model::error(vectorIn input, vectorOut expected)const{
    vectorOut result = forward(input);
    return GenericErrorFunction<err>::error_scalar(result, expected);
}
 
template<ErrorFunction err>
float_t Model::whole_error(Eigen::Matrix<float_t, Eigen::Dynamic, Eigen::Dynamic> inputs, Eigen::Matrix<float_t, Eigen::Dynamic, Eigen::Dynamic> expected_values)const{
    float_t error_value = 0;
    std::size_t size = inputs.rows();
    for(std::size_t i=0;i<size;i++){
        error_value += error<err>(inputs.row(i).transpose(), expected_values.row(i).transpose());
    }
    return error_value / size;
}
 
template<ErrorFunction err>
void Model::backprop(vectorIn input, vectorOut expected){
    for (const std::unique_ptr<Layer> &layer : layers_) {
        input = layer->forward(input);
    }
    vectorOut error = GenericErrorFunction<err>::error(input, expected);
    for (auto it = layers_.rbegin(); it!=layers_.rend(); ++it){
        error = (*it).get()->backward(error);
    }
}
 
} // namespace mlask