dcnnelements.hpp

#ifndef dcnnelements_hpp_
#define dcnnelements_hpp_
 
#include "tagged.hpp"
 
#include <cassert>
#include <random>
#include <cmath>

namespace dcnnasgn {
 
    template<typename ... TL>
    void sink(TL&&...)
    {
    }
 
    struct permutation_policy_tag {};
    struct permutation_policy_back_tag {};
 
    template< typename PP>
    concept is_policy = std::derived_from<PP, permutation_policy_tag>
        && (!std::derived_from<PP, permutation_policy_back_tag>);
 
    template< typename BPP>
    concept is_policy_back = std::derived_from<BPP, permutation_policy_back_tag>;
}
 
namespace dcnnsol {
 
    using dcnnasgn::is_policy;
 
    template< typename SP, is_policy PP>
    class image_data;
 
    template< typename CSP, is_policy PP>
    class feature_data;
 
    template< typename KSP, typename CSPI, typename CSPO, is_policy PP>
    class conv_weights;
 
    template< typename CSPI, typename CSPO, is_policy PP>
    class feature_weights;
 
    template< typename CSP, is_policy PP>
    class feature_multiplier;
 
    template< typename CSP, is_policy PP>
    class feature_bias;
 
    template< typename CSPI, typename CSPO, typename KSP, is_policy PP>
    class complete_cnn_model;
 
    template< typename SPI, typename SPO, is_policy PP>
    struct complete_cnn_internal;
 
    template< typename SPI, typename SPO, typename KSP, is_policy PP>
    struct complete_cnn_layer;
 
}
 
namespace dcnnasgn {


    struct input_selector : tagged::tag_base {};
    struct input_tag : tagged::r_tag<input_selector, tagged::rp_dense> {};
    using input_range = tagged::range_class< input_tag>;
    using input_index = tagged::index_class< input_tag>;

    struct batch_selector : tagged::tag_base {};
    struct batch_tag : tagged::r_tag<batch_selector, tagged::rp_odd> {};



    using batch_range = tagged::range_class< batch_tag>;



    struct height_selector : tagged::tag_base {};
    struct width_selector : tagged::tag_base {};

    template< std::size_t H>
    struct height_stag : tagged::srr_tag<height_selector, 0, H, tagged::rp_odd> {};
 
    template< std::size_t W>
    struct width_stag : tagged::srr_tag<width_selector, 0, W, tagged::rp_odd> {};



    template< std::size_t H, std::size_t W>
    struct image_size_policy {
        using height_tag = height_stag<H>;
        using width_tag = width_stag<W>;

        inline static constexpr tagged::range_class< height_tag> hr{ H };
        inline static constexpr tagged::range_class< width_tag> wr{ W };
    };



    struct channel_selector : tagged::tag_base {};

    template< std::size_t C>
    struct channel_stag : tagged::srr_tag<channel_selector, 0, C, tagged::rp_odd> {};

    struct kernel_height_selector : tagged::tag_base {};
    struct kernel_width_selector : tagged::tag_base {};



    using batch_mapping = tagged::tensor_class< input_index, batch_tag>;
 
    template< typename ISP, typename CP>
    struct input_data_policy : ISP, CP {
        using typename ISP::height_tag;
        using typename ISP::width_tag;
        using typename CP::channel_tag;
 
        using ISP::hr;
        using ISP::wr;
        using CP::cr;
 
        using image_carrier = float;
 
        using images_t = tagged::tensor_class< image_carrier, input_tag, tagged::set_roundup<channel_tag, tagged::rp_dense>, tagged::set_roundup<height_tag, tagged::rp_dense>, tagged::set_roundup<width_tag, tagged::rp_dense>>;
        using batch_t = tagged::tensor_class< image_carrier, batch_tag, height_tag, width_tag, channel_tag>;
    };
 
    template< typename ISP, typename CP, typename SPO, is_policy PP>
    struct batch_initializer {
    public:
        using policy = input_data_policy< ISP, CP>;
 
        using height_tag = typename policy::height_tag;
        using width_tag = typename policy::width_tag;
        using channel_tag = typename policy::channel_tag;
 
        using output_data = dcnnsol::image_data<SPO, PP>;
 
        static void init(const typename policy::images_t& ind, const batch_mapping& bmap, output_data& outd)
        {
            static constexpr auto hr = policy::hr;
            static constexpr auto wr = policy::wr;
            auto cr = policy::cr;
 
            auto&& images = outd.values;
 
            assert(ind.range().template get<height_tag>() == hr);
            assert(ind.range().template get<width_tag>() == wr);
            assert(ind.range().template get<channel_tag>() == cr);
 
            assert(images.range().template get<height_tag>() == hr);
            assert(images.range().template get<width_tag>() == wr);
            assert(images.range().template get<channel_tag>() == cr);
 
            assert(images.range().template get<batch_tag>() == bmap.range().get<batch_tag>());
 
            for (auto b : bmap.range())
            {
                auto i = bmap[b];
                for (auto h : hr)
                {
                    for (auto w : wr)
                    {
                        for (auto c : cr)
                        {
                            images[b & h & w & c] = ind[i & h & w & c];
                        }
                    }
                }
            }
        }
    };
 
    struct gold_labels_policy {
        using label_carrier = std::uint32_t;
 
        using labels_t = tagged::tensor_class< label_carrier, input_tag>;
        using batch_t = tagged::tensor_class< label_carrier, batch_tag>;
    };
 
    class gold_labels {
    public:
        using policy = gold_labels_policy;
        gold_labels(const input_range& inr) : labels(inr) {}
        policy::labels_t labels;
    };
 
    class gold_data {
    public:
        using policy = gold_labels_policy;
        gold_data(const batch_range& nr) : labels(nr) {}
        policy::batch_t labels;
        void init(const policy::labels_t& ind, const input_range& inr)
        {
            assert(labels.range().get<batch_tag>().size() == inr.size());
 
            auto inrb = (*inr.begin()).value();
            for (auto i : inr)
            {
                tagged::index_class<batch_tag> b(i.value() - inrb);
                labels[b] = ind[i];
            }
        }
        void init(const policy::labels_t& ind, const batch_mapping& bmap)
        {
            assert(labels.range().get<batch_tag>().size() == bmap.range().size());
 
            for (auto b : bmap.range())
            {
                auto i = bmap[b];
                labels[b] = ind[i];
            }
        }
    };



    template< std::size_t C>
    struct channel_size_policy {
        using channel_tag = channel_stag<C>;

        inline static constexpr tagged::range_class< channel_tag> cr{ C };
    };

    template< typename ISP, typename CSP>
    struct image_data_size_policy : ISP, CSP {
        using image_policy = ISP;
        using channel_policy = CSP;
    };

    template< typename SP, is_policy PP>
    struct image_data_policy : SP {
        using typename SP::height_tag;
        using typename SP::width_tag;
        using typename SP::channel_tag;

        inline static constexpr auto hr = SP::hr;
        inline static constexpr auto wr = SP::wr;
        inline static constexpr auto cr = SP::cr;

        using values_t = tagged::permute_tensor_class< typename PP::data, float, height_tag, width_tag, channel_tag, batch_tag>;
        using co_values_t = tagged::permute_tensor_class< tagged::co_list< typename PP::data>, float, tagged::co<height_tag>, tagged::co<width_tag>, tagged::co<channel_tag>, tagged::co<batch_tag>>;
    };

    template< typename CSP, is_policy PP>
    struct feature_data_policy : CSP {
        using typename CSP::channel_tag;

        inline static constexpr auto cr = CSP::cr;

        using values_t = tagged::permute_tensor_class< typename PP::feature_data, float, channel_tag, batch_tag>;
        using co_values_t = tagged::permute_tensor_class< tagged::co_list<typename PP::feature_data>, float, tagged::co<channel_tag>, tagged::co<batch_tag>>;
    };

    struct loss_data_policy {
        using loss_t = tagged::tensor_class< float, batch_tag>;
    };

 
    struct data_stats {
        data_stats(float e, float v)
            : E(e), var(v)
        {}
 
        template< tagged::tag ... TL>
        data_stats(const tagged::tensor_class< float, TL...>& val)
            : E(0.0f), var(0.0f)
        {
            auto&& rng = val.range();
 
            for (auto ix : rng)
            {
                auto v = val[ix];
                E += v;
                var += v * v;
            }
 
            float c = (float)rng.size();
 
            E /= c;
            var /= c;
            var -= E * E;
        }
 
        float E, var;
    };
 
    template< typename SP, is_policy PP>
    inline data_stats value_stats(const dcnnsol::image_data<SP, PP>& dt)
    {
        return data_stats(dt.values);
    }
 
    template< typename CSP, is_policy PP>
    inline data_stats value_stats(const dcnnsol::feature_data<CSP, PP>& dt)
    {
        return data_stats(dt.values);
    }


    class loss_data {
    public:
        using policy = loss_data_policy;
        loss_data(const batch_range& nr) : loss(nr) {}
        policy::loss_t loss;
    };

 
    inline data_stats loss_stats(const loss_data& dt)
    {
        return data_stats(dt.loss);
    }




    template< tagged::tag T1, tagged::tag T2>
    struct delta_functor {
        delta_functor(std::ptrdiff_t delta)
            : delta_(delta)
        {}
 
        std::ptrdiff_t delta() const
        {
            return delta_;
        }
 
        tagged::index_class<T2> operator()(const tagged::index_class<T1>& ko) const
        {
            auto dox = ko.value();
            return tagged::index_class<T2>(dox + delta_);
        }
    private:
        std::ptrdiff_t delta_;
    };

    template< tagged::tag T1, tagged::tag T2>
    struct neg_delta_functor {
        neg_delta_functor(std::ptrdiff_t delta)
            : delta_(delta)
        {}
 
        std::ptrdiff_t delta() const
        {
            return delta_;
        }
 
        tagged::index_class<T2> operator()(const tagged::index_class<T1>& ko) const
        {
            auto dox = ko.value();
            return tagged::index_class<T2>(delta_ - dox);
        }
    private:
        std::ptrdiff_t delta_;
    };

    template< tagged::tag T1, tagged::tag T2, std::ptrdiff_t MUL>
    struct mul_delta_functor {
        mul_delta_functor(std::ptrdiff_t delta)
            : delta_(delta)
        {}
 
        std::ptrdiff_t delta() const
        {
            return delta_;
        }
 
        inline static constexpr std::ptrdiff_t multiplier = MUL;
 
        tagged::index_class<T2> operator()(const tagged::index_class<T1>& ko) const
        {
            auto dox = ko.value();
            return tagged::index_class<T2>(delta_ + multiplier * dox);
        }
    private:
        std::ptrdiff_t delta_;
    };



    template< std::size_t KH>
    struct kernel_height_stag : tagged::srr_tag<kernel_height_selector, 0, KH, tagged::rp_odd> {};
 
    template< std::size_t KW>
    struct kernel_width_stag : tagged::srr_tag<kernel_width_selector, 0, KW, tagged::rp_odd> {};



    template< std::size_t KH, std::size_t KW>
    struct conv_kernel_size_policy {
 
        using kernel_height_tag = kernel_height_stag<KH>;  
        using kernel_width_tag = kernel_width_stag<KW>; 


 
        inline static constexpr tagged::range_class< kernel_height_tag> khr{ KH };    
        inline static constexpr tagged::range_class< kernel_width_tag> kwr{ KW };  

    };

    template< typename KSP, typename CSPI, typename CSPO>
    struct conv_weight_size_policy : KSP {
 
        using typename KSP::kernel_height_tag;
        using typename KSP::kernel_width_tag;
 
        using channel_in_tag = typename CSPI::channel_tag;    
        using channel_out_tag = typename CSPO::channel_tag;  


 
        using KSP::khr;
        using KSP::kwr;
        inline static constexpr auto cir = CSPI::cr; 
        inline static constexpr auto cor = CSPO::cr; 

    };

    template< typename CSPI, typename CSPO>
    struct feature_weight_size_policy {
 
        using channel_in_tag = typename CSPI::channel_tag;    
        using channel_out_tag = typename CSPO::channel_tag;  


 
        inline static constexpr auto cir = CSPI::cr; 
        inline static constexpr auto cor = CSPO::cr; 

    };

    template< typename KSP, typename CSPI, typename CSPO, is_policy PP>
    struct conv_weight_policy : conv_weight_size_policy< KSP, CSPI, CSPO> {
    private:
        using base_ = conv_weight_size_policy< KSP, CSPI, CSPO>;
    public:
        using typename base_::kernel_height_tag;
        using typename base_::kernel_width_tag;
        using typename base_::channel_in_tag;
        using typename base_::channel_out_tag;


        using weights_t = tagged::permute_tensor_class< typename PP::weights, float, kernel_height_tag, kernel_width_tag, tagged::co<channel_in_tag>, channel_out_tag>;

    };

    template< typename CSPI, typename CSPO, is_policy PP>
    struct feature_weight_policy : feature_weight_size_policy< CSPI, CSPO> {
    private:
        using base_ = feature_weight_size_policy< CSPI, CSPO>;
    public:
        using typename base_::channel_in_tag;
        using typename base_::channel_out_tag;


        using weights_t = tagged::permute_tensor_class< typename PP::feature_weights, float, tagged::co<channel_in_tag>, channel_out_tag>;

    };



    template<std::size_t KD, std::size_t S>
    struct conv_traits {
        static_assert(KD / 2 >= S - 1);
        inline static constexpr std::size_t LPAD = (KD - 1) / 2;
        inline static constexpr std::size_t SHIFT = (KD - 1) / 2;
        inline static constexpr std::size_t RPAD = KD / 2 + 1 - S;
        // KD == LPAD + 1 + RPAD
    };

    template< tagged::tag TK, tagged::tag TO, std::size_t DI, std::size_t KD, std::size_t S>
    struct conv_ok_range_functor {
        using traits = conv_traits<KD, S>;
        static_assert(DI > traits::LPAD);
        static_assert(DI > traits::RPAD);
        tagged::range_class<tagged::selector<TK>> operator()(const tagged::index_class<TO>& o) const
        {
            auto dox = o.value() * S;
            return tagged::range_class< tagged::selector<TK>>(traits::LPAD - std::min(dox, traits::LPAD), (KD + DI - traits::RPAD - 1) - std::max(dox, DI - traits::RPAD - 1));
        }
 
        constexpr std::size_t multiplier() const
        {
            return S;
        }
 
        constexpr std::size_t lpad() const
        {
            return traits::LPAD;
        }
 
        constexpr std::size_t rpad() const
        {
            return traits::RPAD;
        }
    };

    template< tagged::tag TI, tagged::tag TK, tagged::tag TO, std::size_t KD, std::size_t S>
    struct conv_oki_map_functor {
        using traits = conv_traits<KD, S>;
        using df = delta_functor<TK, TI>;
        df operator()(const tagged::index_class<TO>& o) const
        {
            auto dox = o.value() * S;
            return df(dox - traits::SHIFT);
        }
 
        constexpr std::size_t multiplier() const
        {
            return S;
        }
 
        constexpr std::ptrdiff_t delta() const
        {
            return -traits::SHIFT;
        }
    };

    template< tagged::tag TI, tagged::tag TK, std::size_t DI, std::size_t KD, std::size_t S>
    struct conv_ik_range_functor {
        using traits = conv_traits<KD, S>;
        static_assert(DI > traits::LPAD);
        static_assert(DI > traits::RPAD);
        tagged::range_class< tagged::selector<TK>> operator()(const tagged::index_class<TI>& i) const
        {
            static_assert(S == 1, "The kernel range is not contiguous for stride > 1");
            auto dix = i.value();
            return tagged::range_class< tagged::selector<TK>>(std::max(dix, DI - traits::LPAD - 1) - (DI - traits::LPAD - 1), (KD - traits::RPAD) + std::min(dix, traits::RPAD));
        }
    };

    template< tagged::tag TI, tagged::tag TK, tagged::tag TO, std::size_t KD, std::size_t S>
    struct conv_iko_map_functor {
        using traits = conv_traits<KD, S>;
        using df = neg_delta_functor<TK, TO>;
        df operator()(const tagged::index_class<TI>& i) const
        {
            static_assert(S == 1, "The kernel range is not contiguous for stride > 1");
            auto dix = i.value();
            return df(dix + traits::SHIFT);
        }
    };

    template< tagged::tag TK, tagged::tag TO, std::size_t DI, std::size_t KD, std::size_t S>
    struct conv_ko_range_functor {
        using traits = conv_traits<KD, S>;
        static_assert(DI > traits::LPAD);
        static_assert(DI > traits::RPAD);
        tagged::range_class<tagged::selector<TO>> operator()(const tagged::index_class<TK>& k) const
        {
            auto dkx = k.value();
            return tagged::range_class< tagged::selector<TO>>(((traits::LPAD + S - 1) - std::min(dkx, traits::LPAD)) / S, ((DI + KD - traits::RPAD - 1) - std::max(dkx, KD - traits::RPAD - 1)) / S);
        }
    };

    template< tagged::tag TK, tagged::tag TO, tagged::tag TI, std::size_t KD, std::size_t S>
    struct conv_koi_map_functor {
        using traits = conv_traits<KD, S>;
        using df = std::conditional_t< S == 1, delta_functor<TO, TI>, mul_delta_functor<TO, TI, S>>;
        df operator()(const tagged::index_class<TK>& k) const
        {
            auto dkx = k.value();
            return df(dkx - traits::SHIFT);
        }
    };



    template< typename SPI, typename SPO, typename KSP, is_policy PP>
    struct nonstrided_conv_layer_base
    {
    public:
        using CSPI = typename SPI::channel_policy;
        using CSPO = typename SPO::channel_policy;


        using input_data = dcnnsol::image_data<SPI, PP>;
        using weights = dcnnsol::conv_weights<KSP, CSPI, CSPO, PP>;
        using output_data = dcnnsol::image_data<SPO, PP>;

        
        using height_in_tag = typename SPI::height_tag;    
        using width_in_tag = typename SPI::width_tag;   
        using channel_in_tag = typename SPI::channel_tag; 
 
        using kernel_height_tag = typename KSP::kernel_height_tag; 
        using kernel_width_tag = typename KSP::kernel_width_tag;    
 
        using height_out_tag = typename SPO::height_tag;  
        using width_out_tag = typename SPO::width_tag; 
        using channel_out_tag = typename SPO::channel_tag;   

 
        static_assert(tagged::same_tag<height_in_tag, height_out_tag>);
        static_assert(tagged::same_tag<width_in_tag, width_out_tag>);

 
        inline static constexpr auto hir = SPI::hr;  
        inline static constexpr auto wir = SPI::wr;  
        inline static constexpr auto cir = SPI::cr;  
        inline static constexpr auto khr = KSP::khr; 
        inline static constexpr auto kwr = KSP::kwr; 
        inline static constexpr auto hor = SPO::hr;  
        inline static constexpr auto wor = SPO::wr;  
        inline static constexpr auto cor = SPO::cr;  

        
        inline static constexpr std::size_t fanin = khr.size() * kwr.size() * cir.size(); 

        
        inline static constexpr conv_ok_range_functor<tagged::selector<kernel_height_tag>, tagged::selector<height_out_tag>, hir.size(), khr.size(), 1> hokrf{}; 
        inline static constexpr conv_oki_map_functor< tagged::selector<height_in_tag>, tagged::selector<kernel_height_tag>, tagged::selector<height_out_tag>, khr.size(), 1> hokimf{}; 
        inline static constexpr conv_ok_range_functor< tagged::selector<kernel_width_tag>, tagged::selector<width_out_tag>, wir.size(), kwr.size(), 1> wokrf{}; 
        inline static constexpr conv_oki_map_functor< tagged::selector<width_in_tag>, tagged::selector<kernel_width_tag>, tagged::selector<width_out_tag>, kwr.size(), 1> wokimf{}; 
 
        inline static constexpr conv_ik_range_functor< tagged::selector<height_in_tag>, tagged::selector<kernel_height_tag>, hir.size(), khr.size(), 1> hikrf{};    
        inline static constexpr conv_iko_map_functor< tagged::selector<height_in_tag>, tagged::selector<kernel_height_tag>, tagged::selector<height_out_tag>, khr.size(), 1> hikomf{};  
        inline static constexpr conv_ik_range_functor< tagged::selector<width_in_tag>, tagged::selector<kernel_width_tag>, wir.size(), kwr.size(), 1> wikrf{};  
        inline static constexpr conv_iko_map_functor< tagged::selector<width_in_tag>, tagged::selector<kernel_width_tag>, tagged::selector<width_out_tag>, kwr.size(), 1> wikomf{}; 
 
        inline static constexpr conv_ko_range_functor< tagged::selector<kernel_height_tag>, tagged::selector<height_out_tag>, hir.size(), khr.size(), 1> hkorf{};   
        inline static constexpr conv_koi_map_functor< tagged::selector<kernel_height_tag>, tagged::selector<height_out_tag>, tagged::selector<height_in_tag>, khr.size(), 1> hkoimf{}; 
        inline static constexpr conv_ko_range_functor< tagged::selector<kernel_width_tag>, tagged::selector<width_out_tag>, wir.size(), kwr.size(), 1> wkorf{};  
        inline static constexpr conv_koi_map_functor< tagged::selector<kernel_width_tag>, tagged::selector<width_out_tag>, tagged::selector<width_in_tag>, kwr.size(), 1> wkoimf{}; 



        static tagged::range_class<batch_tag> forward_check(const input_data& ind, const weights& wtd, output_data& outd)
        {
            auto&& inv = ind.values;
            auto&& wtv = wtd.weights;
            auto&& outv = outd.values;
 
            auto&& inr = inv.range();
            auto&& wtr = wtv.range();
            auto&& outr = outv.range();
 
            auto&& br = inr.template get<batch_tag>();
 
            static_assert(inr.template get<height_in_tag>() == hir);
            static_assert(inr.template get<width_in_tag>() == wir);
            static_assert(inr.template get<channel_in_tag>() == cir);
 
            static_assert(wtr.template get<kernel_height_tag>() == khr);
            static_assert(wtr.template get<kernel_width_tag>() == kwr);
            static_assert(wtr.template get< tagged::co<channel_in_tag>>() == ~cir);
            static_assert(wtr.template get<channel_out_tag>() == cor);
 
            static_assert(outr.template get<height_out_tag>() == hor);
            static_assert(outr.template get<width_out_tag>() == wor);
            static_assert(outr.template get<channel_out_tag>() == cor);
 
            assert(outr.template get<batch_tag>() == br);
 
            return br;
        }

        static std::size_t forward_complexity( const batch_range & br)
        {
            return (br & khr & kwr & hor & wor & ~cir & cor).size();
        }

    };

    template< typename SPI, typename SPO, typename KSP, is_policy PP>
    struct strided_conv_layer_base
    {
    public:
        using CSPI = typename SPI::channel_policy;
        using CSPO = typename SPO::channel_policy;


        using input_data = dcnnsol::image_data<SPI, PP>;
        using weights = dcnnsol::conv_weights<KSP, CSPI, CSPO, PP>;
        using output_data = dcnnsol::image_data<SPO, PP>;

 
        using height_in_tag = typename SPI::height_tag;    
        using width_in_tag = typename SPI::width_tag;   
        using channel_in_tag = typename SPI::channel_tag; 
 
        using kernel_height_tag = typename KSP::kernel_height_tag; 
        using kernel_width_tag = typename KSP::kernel_width_tag;    
 
        using height_out_tag = typename SPO::height_tag;  
        using width_out_tag = typename SPO::width_tag; 
        using channel_out_tag = typename SPO::channel_tag;   


 
        inline static constexpr auto hir = SPI::hr;  
        inline static constexpr auto wir = SPI::wr;  
        inline static constexpr auto cir = SPI::cr;  
        inline static constexpr auto khr = KSP::khr; 
        inline static constexpr auto kwr = KSP::kwr; 
        inline static constexpr auto hor = SPO::hr;  
        inline static constexpr auto wor = SPO::wr;  
        inline static constexpr auto cor = SPO::cr;  

 
        inline static constexpr std::size_t fanin = khr.size() * kwr.size() * cir.size(); 
 
        static_assert(hir.size() % hor.size() == 0);
        static_assert(wir.size() % wor.size() == 0);

 
        inline static constexpr std::size_t HSTRIDE = hir.size() / hor.size();
        inline static constexpr std::size_t WSTRIDE = wir.size() / wor.size();


 
        inline static constexpr conv_ok_range_functor<tagged::selector<kernel_height_tag>, tagged::selector<height_out_tag>, hir.size(), khr.size(), HSTRIDE> hokrf{}; 
        inline static constexpr conv_oki_map_functor< tagged::selector<height_in_tag>, tagged::selector<kernel_height_tag>, tagged::selector<height_out_tag>, khr.size(), HSTRIDE> hokimf{}; 
        inline static constexpr conv_ok_range_functor< tagged::selector<kernel_width_tag>, tagged::selector<width_out_tag>, wir.size(), kwr.size(), WSTRIDE> wokrf{}; 
        inline static constexpr conv_oki_map_functor< tagged::selector<width_in_tag>, tagged::selector<kernel_width_tag>, tagged::selector<width_out_tag>, kwr.size(), WSTRIDE> wokimf{}; 
 
        inline static constexpr conv_ik_range_functor< tagged::selector<height_in_tag>, tagged::selector<kernel_height_tag>, hir.size(), khr.size(), HSTRIDE> hikrf{};  
        inline static constexpr conv_iko_map_functor< tagged::selector<height_in_tag>, tagged::selector<kernel_height_tag>, tagged::selector<height_out_tag>, khr.size(), HSTRIDE> hikomf{};    
        inline static constexpr conv_ik_range_functor< tagged::selector<width_in_tag>, tagged::selector<kernel_width_tag>, wir.size(), kwr.size(), WSTRIDE> wikrf{};  
        inline static constexpr conv_iko_map_functor< tagged::selector<width_in_tag>, tagged::selector<kernel_width_tag>, tagged::selector<width_out_tag>, kwr.size(), WSTRIDE> wikomf{}; 
 
        inline static constexpr conv_ko_range_functor< tagged::selector<kernel_height_tag>, tagged::selector<height_out_tag>, hir.size(), khr.size(), HSTRIDE> hkorf{};   
        inline static constexpr conv_koi_map_functor< tagged::selector<kernel_height_tag>, tagged::selector<height_out_tag>, tagged::selector<height_in_tag>, khr.size(), HSTRIDE> hkoimf{};   
        inline static constexpr conv_ko_range_functor< tagged::selector<kernel_width_tag>, tagged::selector<width_out_tag>, wir.size(), kwr.size(), WSTRIDE> wkorf{};  
        inline static constexpr conv_koi_map_functor< tagged::selector<kernel_width_tag>, tagged::selector<width_out_tag>, tagged::selector<width_in_tag>, kwr.size(), WSTRIDE> wkoimf{}; 



        static tagged::range_class<batch_tag> forward_check(const input_data& ind, const weights& wtd, output_data& outd)
        {
            auto&& inv = ind.values;
            auto&& wtv = wtd.weights;
            auto&& outv = outd.values;
 
            auto&& inr = inv.range();
            auto&& wtr = wtv.range();
            auto&& outr = outv.range();
 
            auto&& br = inr.template get<batch_tag>();
 
            static_assert(inr.template get<height_in_tag>() == hir);
            static_assert(inr.template get<width_in_tag>() == wir);
            static_assert(inr.template get<channel_in_tag>() == cir);
 
            static_assert(wtr.template get<kernel_height_tag>() == khr);
            static_assert(wtr.template get<kernel_width_tag>() == kwr);
            static_assert(wtr.template get< tagged::co<channel_in_tag>>() == ~cir);
            static_assert(wtr.template get<channel_out_tag>() == cor);
 
            static_assert(outr.template get<height_out_tag>() == hor);
            static_assert(outr.template get<width_out_tag>() == wor);
            static_assert(outr.template get<channel_out_tag>() == cor);
 
            assert(outr.template get<batch_tag>() == br);
 
            return br;
        }

        static std::size_t forward_complexity(const batch_range& br)
        {
            return (br & khr & kwr & hor & wor & ~cir & cor).size();
        }

    };



    template< typename CSP>
    struct image_transformed_relu_internal_policy : CSP {
        using typename CSP::channel_tag;
 
        using CSP::cr;
 
        using stat_t = tagged::tensor_class< float, channel_tag>;
        using multiplier_t = tagged::tensor_class< float, channel_tag>;
        using co_multiplier_t = tagged::tensor_class< float, tagged::co<channel_tag>>;
        using bias_t = tagged::tensor_class< float, channel_tag>;
        using co_bias_t = tagged::tensor_class< float, tagged::co<channel_tag>>;
    };



    template< typename CSP>
    class image_transformed_relu_model {
    public:
        using policy = image_transformed_relu_internal_policy< CSP>;
        image_transformed_relu_model() : scales(policy::cr), betas(policy::cr) {}
        policy::stat_t scales;
        policy::bias_t betas;
    };



    template< typename SP, is_policy PP>
    struct image_transformed_relu_layer_base {
    public:
        using CSP = typename SP::channel_policy;

        using input_data = dcnnsol::image_data<SP, PP>;
        using model_data = image_transformed_relu_model<CSP>;
        using output_data = dcnnsol::image_data<SP, PP>;

        using height_tag = typename SP::height_tag;
        using width_tag = typename SP::width_tag;
        using channel_tag = typename SP::channel_tag;
 
        inline static constexpr auto hr = SP::hr; 
        inline static constexpr auto wr = SP::wr; 
        inline static constexpr auto cr = SP::cr; 
 
        static tagged::range_class<batch_tag> forward_check(const input_data& ind, const model_data& nd, output_data& outd)
        {
            auto&& inv = ind.values;
            auto&& scalev = nd.scales;
            auto&& betav = nd.betas;
            auto&& outv = outd.values;
 
            auto&& inr = inv.range();
            auto&& scaler = scalev.range();
            auto&& betar = betav.range();
            auto&& outr = outv.range();
 
            auto&& br = inr.template get<batch_tag>();
 
            static_assert(inr.template get<height_tag>() == hr);
            static_assert(inr.template get<width_tag>() == wr);
            static_assert(inr.template get<channel_tag>() == cr);
 
            static_assert(scaler.template get<channel_tag>() == cr);
            static_assert(betar.template get<channel_tag>() == cr);
 
            static_assert(outr.template get<height_tag>() == hr);
            static_assert(outr.template get<width_tag>() == wr);
            static_assert(outr.template get<channel_tag>() == cr);
 
            assert(outr.template get<batch_tag>() == br);
 
            return br;
        }
        
        static std::size_t forward_complexity( const batch_range & br)
        {
            return 5 * (br & hr & wr & cr).size();
        }
    };

 
    template< typename CSP, is_policy PP>
    struct feature_bias_policy : CSP {
        using typename CSP::channel_tag;
 
        using CSP::cr;
 
        using bias_t = tagged::tensor_class< float, channel_tag>;
        using co_bias_t = tagged::tensor_class< float, tagged::co<channel_tag>>;
    };

 

 
    struct maxpool_height_selector : tagged::tag_base {};
    struct maxpool_width_selector : tagged::tag_base {};
 
    template< std::size_t KH>
    struct maxpool_height_stag : tagged::srr_tag<maxpool_height_selector, 0, KH, tagged::rp_odd> {};
 
    template< std::size_t KW>
    struct maxpool_width_stag : tagged::srr_tag<maxpool_width_selector, 0, KW, tagged::rp_odd> {};


 
    template< tagged::tag TK, tagged::tag TO, tagged::tag TI, std::size_t KD>
    struct maxpool_koi_map_functor {
        using df = mul_delta_functor<TO, TI, KD>;
        df operator()(const tagged::index_class<TK>& k) const
        {
            auto dkx = k.value();
            return df(dkx);
        }
    };


 
    template< typename SPI, typename SPO, is_policy PP>
    struct image_maxpool_layer_base {
 
        static_assert(SPI::hr.size() % SPO::hr.size() == 0);
        static_assert(SPI::wr.size() % SPO::wr.size() == 0);
        static_assert(SPI::cr == SPO::cr);
 
        static constexpr std::size_t KH = SPI::hr.size() / SPO::hr.size();
        static constexpr std::size_t KW = SPI::wr.size() / SPO::wr.size();
 
        using input_data = dcnnsol::image_data<SPI, PP>;
        using output_data = dcnnsol::image_data<SPO, PP>;
 
        using height_in_tag = typename SPI::height_tag;
        using width_in_tag = typename SPI::width_tag;
        using channel_tag = typename SPI::channel_tag;
 
        using height_out_tag = typename SPO::height_tag;
        using width_out_tag = typename SPO::width_tag;
 
        static_assert(tagged::same_tag<channel_tag, typename SPO::channel_tag>);
 
        inline static constexpr auto hir = SPI::hr;
        inline static constexpr auto wir = SPI::wr;
        inline static constexpr auto cr = SPI::cr;
 
        using maxpool_height_tag = maxpool_height_stag< KH>;
        using maxpool_width_tag = maxpool_width_stag< KW>;
 
        inline static constexpr tagged::range_class< maxpool_height_tag> khr{ KH };
        inline static constexpr tagged::range_class< maxpool_width_tag> kwr{ KW };
 
        inline static constexpr auto hor = SPO::hr;
        inline static constexpr auto wor = SPO::wr;
 
        inline static constexpr maxpool_koi_map_functor<tagged::selector< maxpool_height_tag>, tagged::selector<height_out_tag>, tagged::selector<height_in_tag>, KH> hkoimf{};
        inline static constexpr maxpool_koi_map_functor<tagged::selector< maxpool_width_tag>, tagged::selector<width_out_tag>, tagged::selector<width_in_tag>, KW> wkoimf{};
 
        static tagged::range_class<batch_tag> forward_check(const input_data& ind, output_data& outd)
        {
            auto&& inv = ind.values;
            auto&& outv = outd.values;
 
            auto&& inr = inv.range();
            auto&& outr = outv.range();
 
            auto&& br = inr.template get<batch_tag>();
 
            static_assert(inr.template get<height_in_tag>() == hir);
            static_assert(inr.template get<width_in_tag>() == wir);
            static_assert(inr.template get<channel_tag>() == cr);
 
            static_assert(outr.template get<height_out_tag>() == hor);
            static_assert(outr.template get<width_out_tag>() == wor);
            static_assert(outr.template get<channel_tag>() == cr);
 
            assert(outr.template get<batch_tag>() == br);
 
            return br;
        }

        static std::size_t forward_complexity( const batch_range & br)
        {
            return (br & khr & kwr & hor & wor & cr).size();
        }
    };
 
    template< typename SPI, typename CSPO, is_policy PP>
    struct final_maxpool_layer_base 
    {
    private:
        using CSPI = typename SPI::channel_policy;
 
        static_assert(CSPI::cr == CSPO::cr);
    public:

        using input_data = dcnnsol::image_data<SPI, PP>;
        using output_data = dcnnsol::feature_data<CSPO, PP>;


 
        using height_in_tag = typename SPI::height_tag;    
        using width_in_tag = typename SPI::width_tag;   
        using channel_tag = typename SPI::channel_tag;   


 
        inline static constexpr auto hir = SPI::hr;  
        inline static constexpr auto wir = SPI::wr;  
        inline static constexpr auto cr = SPI::cr;    

 
        inline static constexpr std::size_t fanin = hir.size() * wir.size(); 


        static tagged::range_class<batch_tag> forward_check(const input_data& ind, output_data& outd)
        {
            auto&& inv = ind.values;
            auto&& outv = outd.values;
 
            auto&& inr = inv.range();
            auto&& outr = outv.range();
 
            auto&& br = inr.template get<batch_tag>();
 
            static_assert(inr.template get<height_in_tag>() == hir);
            static_assert(inr.template get<width_in_tag>() == wir);
            static_assert(inr.template get<channel_tag>() == cr);
 
            static_assert(outr.template get<channel_tag>() == cr);
 
            assert(outr.template get<batch_tag>() == br);
 
            return br;
        }

        static std::size_t forward_complexity(const batch_range& br)
        {
            return (br & hir & wir & cr).size();
        }
    };



    template< typename CSP>
    struct as_kernel
    {
        using kernel_height_tag = tagged::retag< dcnnasgn::kernel_height_selector, typename CSP::height_tag>;
        using kernel_width_tag = tagged::retag< dcnnasgn::kernel_width_selector, typename CSP::width_tag>;
 
        inline static constexpr auto khr = CSP::hr.template retag< kernel_height_tag>();
        inline static constexpr auto kwr = CSP::wr.template retag< kernel_width_tag>();
    };



    template< tagged::tag TI, tagged::tag TK>
    struct aggregate_ik_map_functor {
        tagged::index_class<TK> operator()(const tagged::index_class<TI>& i) const
        {
            return i.template retag<TK>();
        }
    };



    template< typename CSPI, typename CSPO, is_policy PP>
    struct feature_conv_layer_base
    {
    public:

        using input_data = dcnnsol::feature_data<CSPI, PP>;
        using weights = dcnnsol::feature_weights< CSPI, CSPO, PP>;
        using output_data = dcnnsol::feature_data<CSPO, PP>;


 
        using channel_in_tag = typename CSPI::channel_tag;    
 
        using channel_out_tag = typename CSPO::channel_tag;  


 
        inline static constexpr auto cir = CSPI::cr; 
        inline static constexpr auto cor = CSPO::cr; 

 
        inline static constexpr std::size_t fanin = cir.size(); 


        static tagged::range_class<batch_tag> forward_check(const input_data& ind, const weights& wtd, output_data& outd)
        {
            auto&& inv = ind.values;
            auto&& wtv = wtd.weights;
            auto&& outv = outd.values;
 
            auto&& inr = inv.range();
            auto&& wtr = wtv.range();
            auto&& outr = outv.range();
 
            auto&& br = inr.template get<batch_tag>();
 
            static_assert(inr.template get<channel_in_tag>() == cir);
 
            static_assert(wtr.template get< tagged::co<channel_in_tag>>() == ~cir);
            static_assert(wtr.template get<channel_out_tag>() == cor);
 
            static_assert(outr.template get<channel_out_tag>() == cor);
 
            assert(outr.template get<batch_tag>() == br);
 
            return br;
        }

        static std::size_t forward_complexity(const batch_range& br)
        {
            return (br & ~cir & cor).size();
        }
    };
 
    template< typename CSP, is_policy PP>
    struct feature_shift_layer_base : CSP {
        using input_data = dcnnsol::feature_data<CSP, PP>;
        using bias_data = dcnnsol::feature_bias<CSP, PP>;
        using output_data = dcnnsol::feature_data<CSP, PP>;
 
        using typename CSP::channel_tag;
 
        using CSP::cr;
 
        static tagged::range_class<batch_tag> forward_check(const input_data& ind, const bias_data& cd, output_data& outd)
        {
            auto&& inv = ind.values;
            auto&& betav = cd.betas;
            auto&& outv = outd.values;
 
            auto&& inr = inv.range();
            auto&& betar = betav.range();
            auto&& outr = outv.range();
 
            auto&& br = inr.template get<batch_tag>();
 
            static_assert(inr.template get<channel_tag>() == cr);
 
            static_assert(betar.template get<channel_tag>() == cr);
 
            static_assert(outr.template get<channel_tag>() == cr);
 
            assert(outr.template get<batch_tag>() == br);
 
            return br;
        }

        static std::size_t forward_complexity( const batch_range & br)
        {
            return (br & cr).size();
        }
    };
 
    template< typename CSP, is_policy PP>
    struct loss_layer_base
    {
        using input_data = dcnnsol::feature_data<CSP, PP>;
        using output_data = loss_data;
 
        using channel_tag = typename CSP::channel_tag;
 
        inline static constexpr auto cr = CSP::cr;
 
        static tagged::range_class<batch_tag> forward_check(const input_data& ind, const gold_data& gd, output_data& outd)
        {
            auto&& inv = ind.values;
            auto&& labelv = gd.labels;
            auto&& outv = outd.loss;
 
            auto&& inr = inv.range();
            auto&& labelr = labelv.range();
            auto&& outr = outv.range();
 
            auto&& br = inr.template get<batch_tag>();
 
            static_assert(inr.template get<channel_tag>() == cr);
 
            assert(labelr.template get<batch_tag>() == br); sink(labelr);
 
            assert(outr.template get<batch_tag>() == br); sink(outr);
 
            return br;
        }

        static std::size_t forward_complexity( const batch_range & br)
        {
            return (br & cr).size();
        }
    };


    template< typename CSP, is_policy PP>
    struct loss_layer
        : loss_layer_base< CSP, PP>
    {
    private:
        using base_ = loss_layer_base< CSP, PP>;
 
        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 maxv = std::numeric_limits<float>::lowest();
                tagged::index_class<channel_selector> maxc;
                for (auto c : cr)
                {
                    auto v = inv[b & c];
                    if (v > maxv)
                    {
                        maxv = v;
                        maxc = c;
                    }
                }
                auto loss = maxc.value() == label ? 1.0f : 0.0f;
 
                outv[b] = loss;
            }
        }
    };
 
    using feature_ftl = tagged::tag_list<channel_selector>;
    using feature_conv_ftl = tagged::tag_list<channel_selector, tagged::co<channel_selector>>;
    using image_conv_ftl = tagged::tag_list<channel_selector, tagged::co<channel_selector>, kernel_height_selector, kernel_width_selector>;
}
 
#endif