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::first_normalize_layer_base;
    using dcnnasgn::nonstrided_conv_layer_base;
    using dcnnasgn::strided_conv_layer_base;
    using dcnnasgn::image_normalize_layer_base;
    using dcnnasgn::image_multiply_layer_base;
    using dcnnasgn::image_shift_layer_base;
    using dcnnasgn::image_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::loss_layer_base;
    using dcnnasgn::gold_data;
    using dcnnasgn::image_data_policy;
    using dcnnasgn::feature_data_policy;
    using dcnnasgn::feature_multiplier_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_multiplier< CSP, permutation_policy> {
    public:
        using policy = feature_multiplier_policy< CSP, permutation_policy>;
        feature_multiplier() : multipliers(policy::cr) {}
        policy::multiplier_t multipliers;
    };

    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 SP>
    struct first_normalize_layer< SP, permutation_policy>
        : first_normalize_layer_base< SP, permutation_policy>
    {
    private:
        using base_ = first_normalize_layer_base< SP, permutation_policy>;
 
        using typename base_::input_data;
        using typename base_::stat_data;
        using typename base_::output_data;
 
        using base_::hr;   
        using base_::wr;   
        using base_::cr;   
 
        using base_::forward_check; 
    public:
        static void forward(const input_data& ind, stat_data& cd, output_data& outd)
        {
            auto br = forward_check(ind, cd, outd);
 
            auto&& inv = ind.images;
            auto&& sumx = cd.sumx;
            auto&& sumx2 = cd.sumx2;
            auto&& E = cd.E;
            auto&& var = cd.var;
            auto&& scale = cd.scale;
            auto&& outv = outd.values;
 
            sumx = 0;
            sumx2 = 0;
 
            for (auto h : hr)
            {
                for (auto w : wr)
                {
                    for (auto b : br)
                    {
                        for (auto c : cr)
                        {
                            float value = inv[b & h & w & c];
                            sumx += value;
                            sumx2 += value * value;
                        }
                    }
                }
            }
 
            std::uint64_t n = hr.size() * wr.size() * br.size() * cr.size();
            E = (float)((double)sumx / n);
            var = (float)(((double)sumx2 - (double)sumx * E) / n);
            scale = 1.0f / std::sqrt(var);
 
            for (auto h : hr)
            {
                for (auto w : wr)
                {
                    for (auto b : br)
                    {
                        for (auto c : cr)
                        {
                            outv[h & w & c & b] = scale * (inv[b & h & w & c] - E);
                        }
                    }
                }
            }
        }
    };

    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_normalize_layer< SP, permutation_policy>
        : image_normalize_layer_base<SP, permutation_policy>
    {
    private:
        using self_ = image_normalize_layer_base<SP, permutation_policy>;
 
        using typename self_::input_data;
        using typename self_::norm_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(norm_data& nd, const std::filesystem::path& data_folder, const std::string& fname_mean, const std::string& fname_var)
        {
            load_data_raw<dcnnasgn::feature_ftl>(nd.Es, data_folder / (fname_mean + ".bin"));
 
            auto&& scalev = nd.scales;
            tensor_class<float, channel_tag> vars(cr);
            load_data_raw<dcnnasgn::feature_ftl>(vars, data_folder / (fname_var + ".bin"));
            for (auto c : cr)
            {
                auto var = vars[c];
                scalev[c] = 1.0f / std::sqrt(var);
            }
        }

        static void forward(const input_data& ind, const norm_data& nd, output_data& outd)
        {
            auto br = forward_check(ind, nd, outd);
 
            auto&& inv = ind.values;
            auto&& Ev = nd.Es;
            auto&& scalev = nd.scales;
            auto&& outv = outd.values;
 
            forward_core(br, inv, Ev, scalev, outv);
        }
 
        static void forward_core(auto br, auto&& inv, auto&& Ev, auto&& scalev, 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)
                        {
                            outvbhw[c] = scalev[c] * (invbhw[c] - Ev[c]);
                        }
                    }
                }
            }
        }
 
 
    };

    template< typename SP>
    struct image_multiply_layer< SP, permutation_policy>
        : image_multiply_layer_base< SP, permutation_policy>
    {
    private:
        using base_ = image_multiply_layer_base< SP, permutation_policy>;
 
        using typename base_::input_data;
        using typename base_::multiplier_data;
        using typename base_::output_data;
 
        using base_::hr;
        using base_::wr;
        using base_::cr;
 
        using base_::forward_check;
 
    public:
        static void load_model(multiplier_data& cd, const std::filesystem::path& data_folder, const std::string& fname)
        {
            load_data_raw<dcnnasgn::feature_ftl>(cd.multipliers, data_folder / (fname + ".bin"));
        }

        static void forward(const input_data& ind, const multiplier_data& cd, output_data& outd)
        {
            auto br = forward_check(ind, cd, outd);
 
            auto&& inv = ind.values;
            auto&& multiplierv = cd.multipliers;
            auto&& outv = outd.values;
 
            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)
                        {
                            outvbhw[c] = invbhw[c] * multiplierv[c];
                        }
                    }
                }
            }
        }
    };

    template< typename SP>
    struct image_shift_layer< SP, permutation_policy>
        : image_shift_layer_base< SP, permutation_policy>
    {
    private:
        using base_ = image_shift_layer_base< SP, permutation_policy>;
 
        using typename base_::input_data;
        using typename base_::bias_data;
        using typename base_::output_data;
 
        using base_::hr;
        using base_::wr;
        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 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)
                        {
                            outvbhw[c] = invbhw[c] + betav[c];
                        }
                    }
                }
            }
        }
    };

    template< typename SP>
    struct image_relu_layer< SP, permutation_policy>
        : image_relu_layer_base< SP, permutation_policy>
    {
    private:
        using base_ = image_relu_layer_base< SP, permutation_policy>;
 
        using typename base_::input_data;
        using typename base_::output_data;
 
        using base_::hr;
        using base_::wr;
        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&& 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)
                        {
                            outvbhw[c] = std::max(0.0f, invbhw[c]);
                        }
                    }
                }
            }
        }
    };

    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 CSP>
    struct loss_layer< CSP, permutation_policy>
        : loss_layer_base< CSP, permutation_policy>
    {
    private:
        using base_ = loss_layer_base< CSP, permutation_policy>;
 
        using typename base_::input_data;
        using typename base_::output_data;
 
        using base_::cr;
 
        using base_::forward_check;
    public:
        static void forward(const input_data& ind, const gold_data& gd, output_data& outd)
        {
            auto br = forward_check(ind, gd, outd);
 
            auto&& inv = ind.values;
            auto&& labelv = gd.labels;
            auto&& outv = outd.loss;
 
            for (auto b : br)
            {
                auto label = labelv[b];
                float loss = 0.0f;
                for (auto c : cr)
                {
                    auto value = inv[c & b];
                    auto expected = c.value() == label ? 1.0f : 0.0f;
                    auto diff = value - expected;
                    loss += diff * diff;
                }
                outv[b] = loss;
            }
        }
    };



    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_b = dcnnsol::feature_bias< CSPO, permutation_policy>;
        using model_n = dcnnasgn::image_normalize_model< CSPO>;
        using model_m = dcnnsol::feature_multiplier< CSPO, permutation_policy>;
        using model_s = dcnnsol::feature_bias< CSPO, permutation_policy>;
 
        model_c c;
        model_b b;
        model_n n;
        model_m m;
        model_s s;
    };

    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>;
        using data_b = dcnnsol::image_data< SPO, permutation_policy>;
        using data_n = dcnnsol::image_data< SPO, permutation_policy>;
        using data_m = dcnnsol::image_data< SPO, permutation_policy>;
        using data_s = dcnnsol::image_data< SPO, permutation_policy>;
 
        data_c c;
        data_b b;
        data_n n;
        data_m m;
        data_s s;
 
        complete_cnn_internal(const batch_range& nr)
            : c(nr), b(nr), n(nr), m(nr), s(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_b = dcnnsol::image_shift_layer< SPO, permutation_policy>;
        using layer_n = dcnnsol::image_normalize_layer< SPO, permutation_policy>;
        using layer_m = dcnnsol::image_multiply_layer< SPO, permutation_policy>;
        using layer_s = dcnnsol::image_shift_layer< SPO, permutation_policy>;
        using layer_r = dcnnsol::image_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_b::load_model(md.b, data_folder, conv_name + ".bias");
            layer_n::load_model(md.n, data_folder, norm_name + ".running_mean", norm_name + ".running_var");
            layer_m::load_model(md.m, data_folder, norm_name + ".weight");
            layer_s::load_model(md.s, data_folder, 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_b::forward(td.c, md.b, td.b);
            layer_n::forward(td.b, md.n, td.n);
            layer_m::forward(td.n, md.m, td.m);
            layer_s::forward(td.m, md.s, td.s);
            layer_r::forward(td.s, outd);
        }

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

 
}
 
#endif