dcnnsol.hpp

#ifndef dcnnsol_hpp_
#define dcnnsol_hpp_
 
#include "dcnncombined.hpp"
 
namespace dcnnsol {
 
    using dcnnasgn::permutation_policy_tag;
 
    using dcnnasgn::kernel_height_selector;
    using dcnnasgn::kernel_width_selector;
    using dcnnasgn::channel_selector;
    using dcnnasgn::batch_tag;
    using dcnnasgn::height_selector;
    using dcnnasgn::width_selector;
    using dcnnasgn::conv_weight_policy;
    using dcnnasgn::feature_weight_policy;
    using dcnnasgn::batch_range;
    using dcnnasgn::nonstrided_conv_layer_base;
    using dcnnasgn::strided_conv_layer_base;
    using dcnnasgn::image_transformed_relu_layer_base;
    using dcnnasgn::image_maxpool_layer_base;
    using dcnnasgn::final_maxpool_layer_base;
    using dcnnasgn::feature_conv_layer_base;
    using dcnnasgn::feature_shift_layer_base;
    using dcnnasgn::image_data_policy;
    using dcnnasgn::feature_data_policy;
    using dcnnasgn::feature_bias_policy;
 
    using tagged::tag_list;
    using tagged::co;
    using tagged::tensor_class;


    struct permutation_policy : permutation_policy_tag {
        using weights = tagged::tag_list< kernel_height_selector, kernel_width_selector, tagged::co<channel_selector>, channel_selector>;
        using feature_weights = tagged::tag_list< tagged::co<channel_selector>, channel_selector>;
        using data = tagged::tag_list< batch_tag, height_selector, width_selector, channel_selector>;
        using feature_data = tagged::tag_list< batch_tag, channel_selector>;
    };


    
    template< typename SP>
    class image_data<SP, permutation_policy> {
    public:
        using policy = image_data_policy< SP, permutation_policy>;
        image_data(const batch_range& nr)
            : values(policy::hr& policy::wr& policy::cr& nr)
        {}
        typename policy::values_t values;
    };

    template< typename CSP>
    class feature_data< CSP, permutation_policy> {
    public:
        using policy = feature_data_policy< CSP, permutation_policy>;
        feature_data(const batch_range& nr) : values(policy::cr& nr) {}
        policy::values_t values;
    };

    template< typename KSP, typename CSPI, typename CSPO>
    class conv_weights< KSP, CSPI, CSPO, permutation_policy> {
    public:
        using policy = conv_weight_policy< KSP, CSPI, CSPO, permutation_policy>;
        typename policy::weights_t weights;
 
        conv_weights() 
            : weights(policy::khr& policy::kwr & ~policy::cir& policy::cor) 
        {}
    };

    template< typename CSPI, typename CSPO>
    class feature_weights< CSPI, CSPO, permutation_policy> {
    public:
        using policy = feature_weight_policy< CSPI, CSPO, permutation_policy>;
        typename policy::weights_t weights;
 
        feature_weights()
            : weights(~policy::cir& policy::cor)
        {
        }
    };

    template< typename CSP>
    class feature_bias< CSP, permutation_policy> {
    public:
        using policy = feature_bias_policy< CSP, permutation_policy>;
        feature_bias() : betas(policy::cr) {}
        policy::bias_t betas;
    };


    template< typename SPI, typename SPO, typename KSP>
    struct nonstrided_conv_layer<SPI, SPO, KSP, permutation_policy>
        : nonstrided_conv_layer_base< SPI, SPO, KSP, permutation_policy>
    {
    private:
        using base_ = nonstrided_conv_layer_base< SPI, SPO, KSP, permutation_policy>;
 
        using typename base_::input_data;
        using typename base_::weights;
        using typename base_::output_data;
 
        using base_::hokrf;
        using base_::hokimf;
        using base_::wokrf;
        using base_::wokimf;
 
        using base_::hikrf;
        using base_::hikomf;
        using base_::wikrf;
        using base_::wikomf;
 
        using base_::hkorf;
        using base_::hkoimf;
        using base_::wkorf;
        using base_::wkoimf;
 
        using base_::hir;
        using base_::wir;
        using base_::cir;
        using base_::khr;
        using base_::kwr;
        using base_::hor;
        using base_::wor;
        using base_::cor;
 
        using base_::fanin;
 
        using base_::forward_check;
 
    public:
        static void load_model(weights& wtd, const std::filesystem::path& data_folder, const std::string& fname)
        {
            auto&& weights = wtd.weights;
 
            load_data_raw<dcnnasgn::image_conv_ftl>(weights, data_folder / (fname + ".bin"));
        }

        static void forward(const input_data& ind, const weights& wtd, output_data& outd)
        {
            auto br = forward_check(ind, wtd, outd);
 
            auto&& inv = ind.values;
            auto&& wtv = wtd.weights;
            auto&& outv = outd.values;
 
            for (auto x : outv.range())
            {
                outv[x] = 0.0f;
            }
 
            for (auto b : br)
            {
                auto&& outvb = outv[b];
                auto&& invb = inv[b];
 
                for (auto kh : khr)
                {
                    auto hor2 = hkorf(kh);
                    auto hoid = hkoimf(kh);
 
                    for (auto kw : kwr)
                    {
                        auto wor2 = wkorf(kw);
                        auto woid = wkoimf(kw);
 
                        auto&& wtvk = wtv[kh & kw];
 
                        for (auto ho : hor2)
                        {
                            auto hi = hoid(ho);
 
                            auto&& outvbh = outvb[ho];
                            auto&& invbh = invb[hi];
 
                            for (auto wo : wor2)
                            {
                                auto wi = woid(wo);
 
                                auto&& outvbhw = outvbh[wo];
                                auto&& invbhw = invbh[wi];
 
                                for (auto ci : cir)
                                {
                                    auto&& wtwki = wtvk[~ci];
 
                                    float val_inv = invbhw[ci];
                                    for (auto co : cor)
                                    {
                                        outvbhw[co] += wtwki[co] * val_inv;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    };

    template< typename SPI, typename SPO, typename KSP>
    struct strided_conv_layer<SPI, SPO, KSP, permutation_policy>
        : strided_conv_layer_base< SPI, SPO, KSP, permutation_policy>
    {
    private:
        using base_ = strided_conv_layer_base< SPI, SPO, KSP, permutation_policy>;
 
        using typename base_::input_data;
        using typename base_::weights;
        using typename base_::output_data;
 
        using base_::hokrf;
        using base_::hokimf;
        using base_::wokrf;
        using base_::wokimf;
 
        using base_::hikrf;
        using base_::hikomf;
        using base_::wikrf;
        using base_::wikomf;
 
        using base_::hkorf;
        using base_::hkoimf;
        using base_::wkorf;
        using base_::wkoimf;
 
        using base_::hir;
        using base_::wir;
        using base_::cir;
        using base_::khr;
        using base_::kwr;
        using base_::hor;
        using base_::wor;
        using base_::cor;
 
        using base_::fanin;
 
        using base_::forward_check;
 
    public:
        static void load_model(weights& wtd, const std::filesystem::path& data_folder, const std::string& fname)
        {
            auto&& weights = wtd.weights;
 
            load_data_raw<dcnnasgn::image_conv_ftl>(weights, data_folder / (fname + ".bin"));
        }

        static void forward(const input_data& ind, const weights& wtd, output_data& outd)
        {
            auto br = forward_check(ind, wtd, outd);
 
            auto&& inv = ind.values;
            auto&& wtv = wtd.weights;
            auto&& outv = outd.values;
 
            for (auto x : outv.range())
            {
                outv[x] = 0.0f;
            }
 
            for (auto b : br)
            {
                auto&& outvb = outv[b];
                auto&& invb = inv[b];
 
                for (auto kh : khr)
                {
                    auto hor2 = hkorf(kh);
                    auto hoid = hkoimf(kh);
 
                    for (auto kw : kwr)
                    {
                        auto wor2 = wkorf(kw);
                        auto woid = wkoimf(kw);
 
                        auto&& wtvk = wtv[kh & kw];
 
                        for (auto ho : hor2)
                        {
                            auto hi = hoid(ho);
 
                            auto&& outvbh = outvb[ho];
                            auto&& invbh = invb[hi];
 
                            for (auto wo : wor2)
                            {
                                auto wi = woid(wo);
 
                                auto&& outvbhw = outvbh[wo];
                                auto&& invbhw = invbh[wi];
 
                                for (auto ci : cir)
                                {
                                    auto&& wtwki = wtvk[~ci];
 
                                    float val_inv = invbhw[ci];
                                    for (auto co : cor)
                                    {
                                        outvbhw[co] += wtwki[co] * val_inv;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    };

    template< typename SP>
    struct image_transformed_relu_layer< SP, permutation_policy>
        : image_transformed_relu_layer_base<SP, permutation_policy>
    {
    private:
        using self_ = image_transformed_relu_layer_base<SP, permutation_policy>;
 
        using typename self_::input_data;
        using typename self_::model_data;
        using typename self_::output_data;
 
        using typename self_::channel_tag;
 
        using self_::hr;
        using self_::wr;
        using self_::cr;
 
        using self_::forward_check;
 
    public:
 
        static void load_model(model_data& md, const std::filesystem::path& data_folder, const std::string& fname_bias1, const std::string& fname_mean, const std::string& fname_var, const std::string& fname_weight, const std::string& fname_bias2)
        {
            tensor_class<float, channel_tag> betas1(cr);
            tensor_class<float, channel_tag> Es(cr);
            tensor_class<float, channel_tag> vars(cr);
            tensor_class<float, channel_tag> multipliers(cr);
            tensor_class<float, channel_tag> betas2(cr);
 
            load_data_raw<dcnnasgn::feature_ftl>(betas1, data_folder / (fname_bias1 + ".bin"));
            load_data_raw<dcnnasgn::feature_ftl>(Es, data_folder / (fname_mean + ".bin"));
            load_data_raw<dcnnasgn::feature_ftl>(vars, data_folder / (fname_var + ".bin"));
            load_data_raw<dcnnasgn::feature_ftl>(multipliers, data_folder / (fname_weight + ".bin"));
            load_data_raw<dcnnasgn::feature_ftl>(betas2, data_folder / (fname_bias2 + ".bin"));
 
            auto&& scalev = md.scales;
            auto&& betav = md.betas;
            for (auto c : cr)
            {
                auto beta1 = betas1[c];
                auto E = Es[c];
                auto var = vars[c];
                auto multiplier = multipliers[c];
                auto beta2 = betas2[c];
                auto scale = multiplier / std::sqrt(var);
                scalev[c] = scale;
                betav[c] = scale * (beta1 - E) + beta2;
            }
        }

        static void forward(const input_data& ind, const model_data& md, output_data& outd)
        {
            auto br = forward_check(ind, md, outd);
 
            auto&& inv = ind.values;
            auto&& scalev = md.scales;
            auto&& betav = md.betas;
            auto&& outv = outd.values;
 
            forward_core(br, inv, scalev, betav, outv);
        }
 
        static void forward_core(auto br, auto&& inv, auto&& scalev, auto&& betav, auto&& outv)
        {
            for (auto b : br)
            {
                auto&& invb = inv[b];
                auto&& outvb = outv[b];
                for (auto h : hr)
                {
                    auto&& invbh = invb[h];
                    auto&& outvbh = outvb[h];
                    for (auto w : wr)
                    {
                        auto&& invbhw = invbh[w];
                        auto&& outvbhw = outvbh[w];
                        for (auto c : cr)
                        {
                            auto val1 = invbhw[c] * scalev[c];
                            auto val2 = val1 + betav[c];
                            outvbhw[c] = std::max(0.0f, val2);
                        }
                    }
                }
            }
        }
    };
    
    template< typename SPI, typename SPO>
    struct image_maxpool_layer< SPI, SPO, permutation_policy>
        : image_maxpool_layer_base<SPI, SPO, permutation_policy>
    {
    private:
        using base_ = image_maxpool_layer_base<SPI, SPO, permutation_policy>;
 
        using typename base_::input_data;
        using typename base_::output_data;
 
        using typename base_::height_out_tag;
        using typename base_::width_out_tag;
        using typename base_::channel_tag;
 
        using base_::hir;
        using base_::wir;
        using base_::cr;
 
        using base_::khr;
        using base_::kwr;
 
        using base_::hor;
        using base_::wor;
 
        using base_::hkoimf;
        using base_::wkoimf;
 
        using base_::forward_check;
    public:
        static void forward(const input_data& ind, output_data& outd)
        {
            auto br = forward_check(ind, outd);
 
            auto&& inv = ind.values;
            auto&& outv = outd.values;
 
            for (auto b : br)
            {
                auto&& outvb = outv[b];
                for (auto ho : hor)
                {
                    auto&& outvbh = outvb[ho];
                    for (auto wo : wor)
                    {
                        auto&& outvbhw = outvbh[wo];
                        for (auto c : cr)
                        {
                            outvbhw[c] = -std::numeric_limits<float>::infinity();
                        }
                    }
                }
            }
 
            for (auto b : br)
            {
                auto&& invb = inv[b];
                auto&& outvb = outv[b];
                for (auto kh : khr)
                {
                    auto hoid = hkoimf(kh);
                    for (auto kw : kwr)
                    {
                        auto woid = wkoimf(kw);
                        for (auto ho : hor)
                        {
                            auto&& outvbh = outvb[ho];
                            auto hi = hoid(ho);
                            auto&& invbh = invb[hi];
                            for (auto wo : wor)
                            {
                                auto&& outvbhw = outvbh[wo];
                                auto wi = woid(wo);
                                auto&& invbhw = invbh[wi];
                                for (auto c : cr)
                                {
                                    outvbhw[c] = std::max(outvbhw[c], invbhw[c]);
                                }
                            }
                        }
                    }
                }
            }
        }
    };

    template< typename SPI, typename CSPO>
    struct final_maxpool_layer< SPI, CSPO, permutation_policy>
        : final_maxpool_layer_base<SPI, CSPO, permutation_policy>
    {
    private:
        using base_ = final_maxpool_layer_base<SPI, CSPO, permutation_policy>;
 
        using typename base_::input_data;
        using typename base_::output_data;
 
        using typename base_::height_in_tag;
        using typename base_::width_in_tag;
        using typename base_::channel_tag;
 
        using base_::hir;
        using base_::wir;
        using base_::cr;
 
        using base_::forward_check;
    public:
        static void forward(const input_data& ind, output_data& outd)
        {
            auto br = forward_check(ind, outd);
 
            auto&& inv = ind.values;
            auto&& outv = outd.values;
 
            for (auto b : br)
            {
                auto&& outvb = outv[b];
                for (auto c : cr)
                {
                    outvb[c] = -std::numeric_limits<float>::infinity();
                }
            }
 
            for (auto b : br)
            {
                auto&& invb = inv[b];
                auto&& outvb = outv[b];
                for (auto hi : hir)
                {
                    auto&& invbh = invb[hi];
                    for (auto wi : wir)
                    {
                        auto&& invbhw = invbh[wi];
                        for (auto c : cr)
                        {
                            outvb[c] = std::max(outvb[c], invbhw[c]);
                        }
                    }
                }
            }
        }
    };

    template< typename CSPI, typename CSPO>
    struct feature_conv_layer< CSPI, CSPO, permutation_policy>
        : feature_conv_layer_base< CSPI, CSPO, permutation_policy>
    {
    private:
        using base_ = feature_conv_layer_base< CSPI, CSPO, permutation_policy>;
 
        using typename base_::input_data;
        using typename base_::weights;
        using typename base_::output_data;
 
        using base_::cir;
        using base_::cor;
 
        using base_::forward_check;
 
        using base_::fanin;
    public:
 
        static void load_model(weights& wtd, const std::filesystem::path& data_folder, const std::string& fname)
        {
            auto&& weights = wtd.weights;
 
            load_data_raw<dcnnasgn::feature_conv_ftl>(weights, data_folder / (fname + ".bin"));
        }

        static void forward(const input_data& ind, const weights& wtd, output_data& outd)
        {
            auto br = forward_check(ind, wtd, outd);
 
            auto&& inv = ind.values;
            auto&& wtv = wtd.weights;
            auto&& outv = outd.values;
 
            for (auto co : cor)
            {
                for (auto b : br)
                {
                    outv[co & b] = 0.0f;
                }
            }
 
            for (auto ci : cir)
            {
                for (auto co : cor)
                {
                    auto wt = wtv[~ci & co];
                    for (auto b : br)
                    {
                        outv[co & b] += wt * inv[ci & b];
                    }
                }
            }
        }
    };

    template< typename CSP>
    struct feature_shift_layer< CSP, permutation_policy>
        : feature_shift_layer_base< CSP, permutation_policy>
    {
    private:
        using base_ = feature_shift_layer_base< CSP, permutation_policy>;
 
        using typename base_::input_data;
        using typename base_::bias_data;
        using typename base_::output_data;
 
        using base_::cr;
 
        using base_::forward_check;
    public:
 
        static void load_model(bias_data& cd, const std::filesystem::path& data_folder, const std::string& fname)
        {
            load_data_raw<dcnnasgn::feature_ftl>(cd.betas, data_folder / (fname + ".bin"));
        }

        static void forward(const input_data& ind, const bias_data& cd, output_data& outd)
        {
            auto br = forward_check(ind, cd, outd);
 
            auto&& inv = ind.values;
            auto&& betav = cd.betas;
            auto&& outv = outd.values;
 
            for (auto c : cr)
            {
                auto beta = betav[c];
                for (auto b : br)
                {
                    outv[c & b] = inv[c & b] + beta;
                }
            }
        }
    };



    template< typename CSPI, typename CSPO, typename KSP>
    class complete_cnn_model< CSPI, CSPO, KSP, permutation_policy> {
    public:
        using model_c = dcnnsol::conv_weights< KSP, CSPI, CSPO, permutation_policy>;
        using model_r = dcnnasgn::image_transformed_relu_model< CSPO>;
 
        model_c c;
        model_r r;
    };

    template< typename SPI, typename SPO>
    struct complete_cnn_internal< SPI, SPO, permutation_policy> {
    private:
        using CSPI = typename SPI::channel_policy;
        using CSPO = typename SPO::channel_policy;
    public:
        using data_c = dcnnsol::image_data< SPO, permutation_policy>;
 
        data_c c;
 
        complete_cnn_internal(const batch_range& nr)
            : c(nr)
        {
        }
    };

    template< typename SPI, typename SPO, typename KSP>
    struct complete_cnn_layer< SPI, SPO, KSP, permutation_policy> {
    public:
        using CSPI = typename SPI::channel_policy;
        using CSPO = typename SPO::channel_policy;
 
        static constexpr bool nonstrided = tagged::same_tag< typename SPI::height_tag, typename SPO::height_tag>
            && tagged::same_tag< typename SPI::width_tag, typename SPO::width_tag>;
 
        using layer_c = std::conditional_t< nonstrided, 
            dcnnsol::nonstrided_conv_layer< SPI, SPO, KSP, permutation_policy>, 
            dcnnsol::strided_conv_layer< SPI, SPO, KSP, permutation_policy>>;
        using layer_r = dcnnsol::image_transformed_relu_layer< SPO, permutation_policy>;
 
        using internal_data = complete_cnn_internal< SPI, SPO, permutation_policy>;
 
        using input_data = dcnnsol::image_data< SPI, permutation_policy>;
        using model = complete_cnn_model< CSPI, CSPO, KSP, permutation_policy>;
        using output_data = dcnnsol::image_data< SPO, permutation_policy>;
 
        static void load_model(model& md, const std::filesystem::path& data_folder, int feature_number)
        {
            auto conv_name = "features." + std::to_string(feature_number);
            auto norm_name = "features." + std::to_string(feature_number + 1);
 
            layer_c::load_model(md.c, data_folder, conv_name + ".weight");
            layer_r::load_model(md.r, data_folder, conv_name + ".bias", norm_name + ".running_mean", norm_name + ".running_var", norm_name + ".weight", norm_name + ".bias");
        }
 
        static void forward(const input_data& ind, const model& md, internal_data& td, output_data& outd)
        {
            layer_c::forward(ind, md.c, td.c);
            layer_r::forward(td.c, md.r, outd);
        }

        static std::size_t forward_complexity(const batch_range& br)
        {
            std::size_t s = 0;
            s += layer_c::forward_complexity(br);
            s += layer_r::forward_complexity(br);
            return s;
        }
    };

 
}
 
#endif