hyperray 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/nn/layers/dense/persist.h

@@ -0,0 +1,62 @@
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_DENSE_PERSIST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_DENSE_PERSIST_H
+#include "../../../version.h"
+#include "layer.h"
+#include "persist_common.h"
+#include "../../parameters/persist.h"
+#include "../../optimizers/adam/instance/persist.h"
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    void save(DEVICE& device, nn::layers::dense::LayerForward<SPEC>& layer, GROUP& group) {
+        // todo: forward implementation to Parameter struct
+        auto weights_group = create_group(device, group, "weights");
+        auto biases_group = create_group(device, group, "biases");
+        save(device, layer.weights, weights_group);
+        save(device, layer.biases, biases_group);
+        set_attribute(device, group, "activation_function", nn::layers::dense::persist::get_activation_function_string_short<SPEC::CONFIG::ACTIVATION_FUNCTION>());
+        set_attribute(device, group, "type", "dense");
+        write_attributes(device, group);
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    void save(DEVICE& device, nn::layers::dense::LayerBackward<SPEC>& layer, GROUP& group) {
+        save(device, (nn::layers::dense::LayerForward<SPEC>&)layer, group);
+        save(device, layer.pre_activations, group, "pre_activations");
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    void save(DEVICE& device, nn::layers::dense::LayerGradient<SPEC>& layer, GROUP& group) {
+        save(device, (nn::layers::dense::LayerBackward<SPEC>&)layer, group);
+        save(device, layer.output, group, "output");
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn::layers::dense::LayerForward<SPEC>& layer, GROUP& group) {
+        auto weights_group = get_group(device, group, "weights");
+        auto biases_group = get_group(device, group, "biases");
+        bool success = load(device, layer.weights, weights_group);
+        success &= load(device, layer.biases, biases_group);
+        return success;
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn::layers::dense::LayerBackward<SPEC>& layer, GROUP& group) {
+        bool success = load(device, (nn::layers::dense::LayerForward<SPEC>&)layer, group);
+        if(group_exists(device, group, "pre_activations")){
+            success &= load(device, layer.pre_activations, group, "pre_activations");
+        }
+        return success;
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn::layers::dense::LayerGradient<SPEC>& layer, GROUP& group) {
+        bool success = load(device, (nn::layers::dense::LayerBackward<SPEC>&)layer, group);
+        if(group_exists(device, group, "output")){
+            success &= load(device, layer.output, group, "output");
+        }
+        return success;
+    }
+    template<typename DEVICE, typename GROUP>
+    void save(DEVICE& device, nn::layers::dense::State& state, GROUP& group) {}
+    template<typename DEVICE, typename GROUP>
+    bool load(DEVICE& device, nn::layers::dense::State& state, GROUP& group) { return true; }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/nn/layers/dense/persist_code.h

@@ -0,0 +1,178 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_DENSE_PERSIST_CODE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_DENSE_PERSIST_CODE_H
+#include "layer.h"
+#include "../../../containers/matrix/persist_code.h"
+#include <sstream>
+#include "../../../persist/code.h"
+#include "../../../containers/matrix/persist_code.h"
+#include "../../../nn/parameters/persist_code.h"
+#include "../../../nn/capability/persist_code.h"
+
+#include "persist_common.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    namespace nn::layers::dense::persist_code{
+        template<typename DEVICE, typename SPEC>
+            rl_tools::persist::Code finish(DEVICE& device, nn::layers::dense::LayerForward<SPEC> &layer, std::string name, rl_tools::persist::Code input, bool const_declaration=true, typename DEVICE::index_t indent=0){
+            using TI = typename DEVICE::index_t;
+            std::stringstream indent_ss;
+            for(TI i=0; i < indent; i++){
+                indent_ss << "    ";
+            }
+            std::string ind = indent_ss.str();
+            using TI = typename DEVICE::index_t;
+            std::stringstream ss, ss_header;
+            ss_header << input.header;
+            ss_header << "#include <rl_tools/nn/layers/dense/layer.h>\n";
+            ss_header << "#include <rl_tools/numeric_types/policy.h>\n";
+            ss << input.body;
+            std::string T_string = containers::persist::get_type_string<typename SPEC::TYPE_POLICY::DEFAULT>();
+            std::string TI_string = containers::persist::get_type_string<typename SPEC::TI>();
+            ss << ind << "namespace " << name << " {\n";
+            ss << ind << "    using TYPE_POLICY = " << to_string(typename SPEC::TYPE_POLICY{}) << ";\n";
+            ss << ind << "    using CONFIG = " << "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::layers::dense::Configuration<"
+                << "TYPE_POLICY, "
+                << TI_string << ", "
+                << SPEC::OUTPUT_DIM << ", "
+                << nn::layers::dense::persist::get_activation_function_string<SPEC::ACTIVATION_FUNCTION>() << ", "
+                << "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::layers::dense::DefaultInitializer<" << "TYPE_POLICY, " << TI_string << ">, "
+                << get_type_string_tag(device, typename SPEC::PARAMETER_GROUP{})
+                << ">; \n";
+            ss << ind << "    " << "using TEMPLATE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::layers::dense::BindConfiguration<CONFIG>;" << "\n";
+            ss << ind << "    " << "using INPUT_SHAPE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::tensor::Shape<" << TI_string << ", " << get<0>(typename SPEC::INPUT_SHAPE{}) << ", " << get<1>(typename SPEC::INPUT_SHAPE{}) << ", " << get<2>(typename SPEC::INPUT_SHAPE{}) << ">;\n";
+            using CONST_CAPABILITY = typename SPEC::CAPABILITY::template CHANGE_PARAMETERS<true, true>;
+            ss << ind << "    " << "using CAPABILITY = " << to_string(CONST_CAPABILITY{}) << ";" << "\n";
+            ss << ind << "    " << "using TYPE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::layers::dense::Layer<CONFIG, CAPABILITY, INPUT_SHAPE>;" << "\n";
+            std::string initializer_list;
+            if constexpr(SPEC::CAPABILITY::TAG == nn::LayerCapability::Forward){
+                initializer_list = "{weights::parameters, biases::parameters}";
+            }
+            else{
+                if constexpr(SPEC::CAPABILITY::TAG == nn::LayerCapability::Backward){
+                    initializer_list = "{{weights::parameters, biases::parameters}, pre_activations::container}";
+                }
+                else{
+                    if constexpr(SPEC::CAPABILITY::TAG == nn::LayerCapability::Gradient){
+                        initializer_list = "{{{weights::parameters, biases::parameters}, pre_activations::container}, output::container}";
+                    }
+                    else{
+                        utils::assert_exit(device, false, "Unknown capability");
+                    }
+                }
+            }
+            ss << ind << "    " << (const_declaration ? "constexpr " : "") << "TYPE module = " << initializer_list << ";\n";
+            ss << ind << "    " << "template <typename T_TYPE = TYPE>" << "\n";
+            ss << ind << "    " << (const_declaration ? "constexpr " : "") << "T_TYPE factory = " << initializer_list << ";" << "\n";
+            ss << ind << "    " << "template <typename T_TYPE = TYPE>" << "\n";
+            ss << ind << "    " << (const_declaration ? "constexpr " : "") << "T_TYPE factory_function(){return T_TYPE" << initializer_list << ";" << "}\n";
+            ss << ind << "}\n";
+
+
+            return {ss_header.str(), ss.str()};
+        }
+    }
+    template<typename DEVICE, typename SPEC>
+    persist::Code save_code_split(DEVICE& device, nn::layers::dense::LayerForward<SPEC> &layer, std::string name, bool const_declaration=true, typename DEVICE::index_t indent=0, bool finish=true){
+        using TI = typename DEVICE::index_t;
+        std::stringstream indent_ss;
+        for(TI i=0; i < indent; i++){
+            indent_ss << "    ";
+        }
+        std::string ind = indent_ss.str();
+        using TI = typename DEVICE::index_t;
+        std::stringstream ss, ss_header;
+        ss << ind << "namespace " << name << " {\n";
+        auto weights = save_code_split(device, layer.weights, "weights", const_declaration, indent+1);
+        ss_header << weights.header;
+        ss << weights.body;
+        auto biases = save_code_split(device, layer.biases, "biases", const_declaration, indent+1);
+        ss_header << biases.header;
+        ss << biases.body;
+        ss << ind << "}\n";
+        if(finish){
+            return nn::layers::dense::persist_code::finish(device, layer, name, {ss_header.str(), ss.str()}, const_declaration, indent);
+        }
+        else{
+            return {ss_header.str(), ss.str()};
+        }
+    }
+    template<typename DEVICE, typename SPEC>
+    persist::Code save_code_split(DEVICE& device, nn::layers::dense::LayerBackward<SPEC> &layer, std::string name, bool const_declaration=true, typename DEVICE::index_t indent=0, bool finish=true){
+        using TI = typename DEVICE::index_t;
+        std::stringstream indent_ss;
+        for(TI i=0; i < indent; i++){
+            indent_ss << "    ";
+        }
+        std::string ind = indent_ss.str();
+        using TI = typename DEVICE::index_t;
+        std::stringstream ss, ss_header;
+        auto previous = save_code_split(device, static_cast<nn::layers::dense::LayerForward<SPEC>&>(layer), name, const_declaration, indent, false);
+        ss_header << previous.header;
+        ss << previous.body;
+        ss << ind << "namespace " << name << " {\n";
+        auto pre_activations = save_code_split(device, layer.pre_activations, "pre_activations", const_declaration, indent+1);
+        ss_header << pre_activations.header;
+        ss << pre_activations.body;
+        ss << ind << "}\n";
+        if(finish){
+            return nn::layers::dense::persist_code::finish(device, layer, name, {ss_header.str(), ss.str()}, const_declaration, indent);
+        }
+        else{
+            return {ss_header.str(), ss.str()};
+        }
+    }
+
+    template<typename DEVICE, typename SPEC>
+    persist::Code save_code_split(DEVICE& device, nn::layers::dense::LayerGradient<SPEC> &layer, std::string name, bool const_declaration=true, typename DEVICE::index_t indent=0){
+        using TI = typename DEVICE::index_t;
+        std::stringstream indent_ss;
+        for(TI i=0; i < indent; i++){
+            indent_ss << "    ";
+        }
+        std::string ind = indent_ss.str();
+        using TI = typename DEVICE::index_t;
+        std::stringstream ss, ss_header;
+        auto previous = save_code_split(device, static_cast<nn::layers::dense::LayerBackward<SPEC>&>(layer), name, const_declaration, indent, false);
+        ss_header << previous.header;
+        ss << previous.body;
+        ss << ind << "namespace " << name << " {\n";
+        auto output = save_code_split(device, layer.output, "output", const_declaration, indent+1);
+        ss_header << output.header;
+        ss << output.body;
+        ss << ind << "}\n";
+        return nn::layers::dense::persist_code::finish(device, layer, name, {ss_header.str(), ss.str()}, const_declaration, indent);
+    }
+
+    template<typename DEVICE, typename SPEC>
+    std::string save_code(DEVICE& device, nn::layers::dense::LayerForward<SPEC> &layer, std::string name, bool const_declaration=true, typename DEVICE::index_t indent=0){
+        auto code = save_code_split(device, layer, name, const_declaration, indent);
+        return code.header + code.body;
+    }
+    template<typename DEVICE, typename SPEC>
+    std::string save_code(DEVICE& device, nn::layers::dense::LayerBackward<SPEC> &layer, std::string name, bool const_declaration=true, typename DEVICE::index_t indent=0){
+        auto code = save_code_split(device, layer, name, const_declaration, indent);
+        return code.header + code.body;
+    }
+    template<typename DEVICE, typename SPEC>
+    std::string save_code(DEVICE& device, nn::layers::dense::LayerGradient<SPEC> &layer, std::string name, bool const_declaration=true, typename DEVICE::index_t indent=0){
+        auto code = save_code_split(device, layer, name, const_declaration, indent);
+        return code.header + code.body;
+    }
+    template <typename DEVICE, typename SPEC>
+    std::string nn_analytics(DEVICE& device, nn::layers::dense::LayerGradient<SPEC>& layer) {
+        std::string data;
+        data += "{";
+        data += "\"weights\": " + nn_analytics(device, layer.weights) + ", ";
+        data += "\"biases\": " + nn_analytics(device, layer.weights) + ", ";
+        data += "\"pre_activations\": " + json(device, layer.pre_activations) + ", ";
+        data += "\"output\": " + json(device, layer.output);
+        data += "}";
+        return data;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/nn/layers/dense/persist_common.h

@@ -0,0 +1,59 @@
+
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_DENSE_PERSIST_COMMON_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_DENSE_PERSIST_COMMON_H
+#include "layer.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace nn::layers::dense::persist{
+        template<nn::activation_functions::ActivationFunction ACTIVATION_FUNCTION>
+        auto get_activation_function_string_short(){
+            static_assert(ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::IDENTITY ||
+                          ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::RELU ||
+                          ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::GELU ||
+                          ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::TANH ||
+                          ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::FAST_TANH ||
+                          ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::SIGMOID);
+
+            if constexpr (ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::IDENTITY){
+                return "IDENTITY";
+            } else if constexpr (ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::RELU){
+                return "RELU";
+            } else if constexpr (ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::GELU){
+                return "GELU";
+            } else if constexpr (ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::TANH){
+                return "TANH";
+            } else if constexpr (ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::FAST_TANH){
+                return "FAST_TANH";
+            } else if constexpr (ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::SIGMOID){
+                return "SIGMOID";
+            }
+        }
+        template<nn::activation_functions::ActivationFunction ACTIVATION_FUNCTION>
+        constexpr auto get_activation_function_string(){
+            static_assert(ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::IDENTITY ||
+                          ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::RELU ||
+                          ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::GELU ||
+                          ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::TANH ||
+                          ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::FAST_TANH ||
+                          ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::SIGMOID);
+
+            if constexpr (ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::IDENTITY){
+                return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::IDENTITY";
+            } else if constexpr (ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::RELU){
+                return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::RELU";
+            } else if constexpr (ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::GELU){
+                return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::GELU";
+            } else if constexpr (ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::TANH){
+                return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::TANH";
+            } else if constexpr (ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::FAST_TANH){
+                return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::FAST_TANH";
+            } else if constexpr (ACTIVATION_FUNCTION == nn::activation_functions::ActivationFunction::SIGMOID){
+                return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::SIGMOID";
+            }
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/nn/layers/dynamic_conv2d/layer.h

@@ -0,0 +1,188 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_DYNAMIC_CONV2D_LAYER_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_DYNAMIC_CONV2D_LAYER_H
+#include "../../../nn/activation_functions.h"
+#include "../../../utils/generic/typing.h"
+#include "../../../containers/tensor/tensor.h"
+#include "../../../nn/capability/capability.h"
+#include "../../../nn/parameters/parameters.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::nn::layers::dynamic_conv2d {
+
+    template<typename T_TYPE_POLICY, typename T_TI,
+             T_TI T_KERNEL_HEIGHT, T_TI T_KERNEL_WIDTH = T_KERNEL_HEIGHT,
+             T_TI T_STRIDE_H = 1, T_TI T_STRIDE_W = T_STRIDE_H,
+             T_TI T_PADDING_H = 0, T_TI T_PADDING_W = T_PADDING_H,
+             nn::activation_functions::ActivationFunction T_ACTIVATION_FUNCTION = nn::activation_functions::ActivationFunction::IDENTITY,
+             T_TI T_OUTPUT_CHANNELS = 0>
+    struct Configuration{
+        using TYPE_POLICY = T_TYPE_POLICY;
+        using TI = T_TI;
+        static constexpr TI KERNEL_HEIGHT = T_KERNEL_HEIGHT;
+        static constexpr TI KERNEL_WIDTH = T_KERNEL_WIDTH;
+        static constexpr TI STRIDE_H = T_STRIDE_H;
+        static constexpr TI STRIDE_W = T_STRIDE_W;
+        static constexpr TI PADDING_H = T_PADDING_H;
+        static constexpr TI PADDING_W = T_PADDING_W;
+        static constexpr nn::activation_functions::ActivationFunction ACTIVATION_FUNCTION = T_ACTIVATION_FUNCTION;
+        static constexpr TI OUTPUT_CHANNELS = T_OUTPUT_CHANNELS;
+    };
+
+    template <typename T_CONFIG, typename T_CAPABILITY, typename T_INPUT_SHAPE>
+    struct Specification: T_CAPABILITY, T_CONFIG{
+        using CONFIG = T_CONFIG;
+        using TYPE_POLICY = typename CONFIG::TYPE_POLICY;
+        using TI = typename CONFIG::TI;
+        using CAPABILITY = T_CAPABILITY;
+        using INPUT_SHAPE = T_INPUT_SHAPE;
+        static_assert(length(INPUT_SHAPE{}) >= 4, "DynamicConv2d input shape must have at least 4 dimensions (...BATCH x H x W x C)");
+        static constexpr TI INPUT_HEIGHT = get<length(INPUT_SHAPE{})-3>(INPUT_SHAPE{});
+        static constexpr TI INPUT_WIDTH = get<length(INPUT_SHAPE{})-2>(INPUT_SHAPE{});
+        static constexpr TI INPUT_CHANNELS = get_last(INPUT_SHAPE{});
+        static constexpr bool IS_FULL_CONV = CONFIG::OUTPUT_CHANNELS != 0;
+        static constexpr TI OUTPUT_CHANNELS = IS_FULL_CONV ? CONFIG::OUTPUT_CHANNELS : INPUT_CHANNELS;
+        static constexpr TI OUTPUT_HEIGHT = (INPUT_HEIGHT + 2 * CONFIG::PADDING_H - CONFIG::KERNEL_HEIGHT) / CONFIG::STRIDE_H + 1;
+        static constexpr TI OUTPUT_WIDTH = (INPUT_WIDTH + 2 * CONFIG::PADDING_W - CONFIG::KERNEL_WIDTH) / CONFIG::STRIDE_W + 1;
+
+        template <typename NEW_INPUT_SHAPE>
+        struct OUTPUT_SHAPE_FACTORY{
+            static_assert(length(NEW_INPUT_SHAPE{}) >= 4);
+            static constexpr TI NEW_H = get<length(NEW_INPUT_SHAPE{})-3>(NEW_INPUT_SHAPE{});
+            static constexpr TI NEW_W = get<length(NEW_INPUT_SHAPE{})-2>(NEW_INPUT_SHAPE{});
+            static constexpr TI NEW_C = get_last(NEW_INPUT_SHAPE{});
+            static_assert(NEW_H == INPUT_HEIGHT);
+            static_assert(NEW_W == INPUT_WIDTH);
+            static_assert(NEW_C == INPUT_CHANNELS);
+            static constexpr TI NEW_OH = (NEW_H + 2 * CONFIG::PADDING_H - CONFIG::KERNEL_HEIGHT) / CONFIG::STRIDE_H + 1;
+            static constexpr TI NEW_OW = (NEW_W + 2 * CONFIG::PADDING_W - CONFIG::KERNEL_WIDTH) / CONFIG::STRIDE_W + 1;
+            using SHAPE_HEIGHT = tensor::Replace<NEW_INPUT_SHAPE, NEW_OH, length(NEW_INPUT_SHAPE{}) - 3>;
+            using SHAPE_WIDTH = tensor::Replace<SHAPE_HEIGHT, NEW_OW, length(NEW_INPUT_SHAPE{}) - 2>;
+            using SHAPE_CHANNELS = tensor::Replace<SHAPE_WIDTH, OUTPUT_CHANNELS, length(NEW_INPUT_SHAPE{}) - 1>;
+            using SHAPE = SHAPE_CHANNELS;
+        };
+        using OUTPUT_SHAPE = typename OUTPUT_SHAPE_FACTORY<INPUT_SHAPE>::SHAPE;
+        static constexpr TI INTERNAL_BATCH_SIZE = tensor::shape_math::leading_product(tensor::shape_math::element_to_array<INPUT_SHAPE>(), 3);
+        static constexpr TI NUM_WEIGHTS = 0;
+    };
+
+    template<typename SPEC_1, typename SPEC_2>
+    constexpr bool check_spec_memory =
+            SPEC_1::INPUT_CHANNELS == SPEC_2::INPUT_CHANNELS
+            && SPEC_1::OUTPUT_CHANNELS == SPEC_2::OUTPUT_CHANNELS
+            && SPEC_1::KERNEL_HEIGHT == SPEC_2::KERNEL_HEIGHT
+            && SPEC_1::KERNEL_WIDTH == SPEC_2::KERNEL_WIDTH
+            && SPEC_1::INPUT_HEIGHT == SPEC_2::INPUT_HEIGHT
+            && SPEC_1::INPUT_WIDTH == SPEC_2::INPUT_WIDTH;
+
+    template<typename SPEC_1, typename SPEC_2>
+    constexpr bool check_spec =
+        check_spec_memory<SPEC_1, SPEC_2>
+        && SPEC_1::ACTIVATION_FUNCTION == SPEC_2::ACTIVATION_FUNCTION
+        && SPEC_1::STRIDE_H == SPEC_2::STRIDE_H
+        && SPEC_1::STRIDE_W == SPEC_2::STRIDE_W
+        && SPEC_1::PADDING_H == SPEC_2::PADDING_H
+        && SPEC_1::PADDING_W == SPEC_2::PADDING_W;
+
+    template <typename LAYER_SPEC, typename DATA_SPEC, typename OUTPUT_SPEC>
+    constexpr bool check_data_output =
+        length(typename DATA_SPEC::SHAPE{}) >= 4 &&
+        length(typename OUTPUT_SPEC::SHAPE{}) >= 4 &&
+        get<length(typename DATA_SPEC::SHAPE{})-1>(typename DATA_SPEC::SHAPE{}) == LAYER_SPEC::INPUT_CHANNELS &&
+        get<length(typename DATA_SPEC::SHAPE{})-2>(typename DATA_SPEC::SHAPE{}) == LAYER_SPEC::INPUT_WIDTH &&
+        get<length(typename DATA_SPEC::SHAPE{})-3>(typename DATA_SPEC::SHAPE{}) == LAYER_SPEC::INPUT_HEIGHT &&
+        get<length(typename OUTPUT_SPEC::SHAPE{})-1>(typename OUTPUT_SPEC::SHAPE{}) == LAYER_SPEC::OUTPUT_CHANNELS &&
+        get<length(typename OUTPUT_SPEC::SHAPE{})-2>(typename OUTPUT_SPEC::SHAPE{}) == LAYER_SPEC::OUTPUT_WIDTH &&
+        get<length(typename OUTPUT_SPEC::SHAPE{})-3>(typename OUTPUT_SPEC::SHAPE{}) == LAYER_SPEC::OUTPUT_HEIGHT;
+
+    struct State{};
+
+    template <typename T_SPEC, bool T_DYNAMIC_ALLOCATION>
+    struct BufferSpecification {
+        using SPEC = T_SPEC;
+        static constexpr bool DYNAMIC_ALLOCATION = T_DYNAMIC_ALLOCATION;
+    };
+    template<typename T_BUFFER_SPEC>
+    struct Buffer{
+        using SPEC = typename T_BUFFER_SPEC::SPEC;
+        static constexpr bool DYNAMIC_ALLOCATION = T_BUFFER_SPEC::DYNAMIC_ALLOCATION;
+        using ACCUMULATOR_TYPE = typename SPEC::TYPE_POLICY::template GET<numeric_types::categories::Accumulator>;
+        using TI = typename SPEC::TI;
+        using D_DATA_SHAPE = tensor::Shape<TI, SPEC::INTERNAL_BATCH_SIZE, SPEC::INPUT_HEIGHT, SPEC::INPUT_WIDTH, SPEC::INPUT_CHANNELS>;
+        using D_DATA_SPEC = tensor::Specification<ACCUMULATOR_TYPE, TI, D_DATA_SHAPE, DYNAMIC_ALLOCATION>;
+        Tensor<D_DATA_SPEC> d_data_acc;
+        using D_KERNEL_WEIGHTS_SHAPE = utils::typing::conditional_t<SPEC::IS_FULL_CONV,
+            tensor::Shape<TI, SPEC::INTERNAL_BATCH_SIZE, SPEC::OUTPUT_CHANNELS, SPEC::INPUT_CHANNELS, SPEC::KERNEL_HEIGHT, SPEC::KERNEL_WIDTH>,
+            tensor::Shape<TI, SPEC::INTERNAL_BATCH_SIZE, SPEC::INPUT_CHANNELS, SPEC::KERNEL_HEIGHT, SPEC::KERNEL_WIDTH>>;
+        using D_KERNEL_WEIGHTS_SPEC = tensor::Specification<ACCUMULATOR_TYPE, TI, D_KERNEL_WEIGHTS_SHAPE, DYNAMIC_ALLOCATION>;
+        Tensor<D_KERNEL_WEIGHTS_SPEC> d_kernel_weights_acc;
+    };
+
+    template<typename T_SPEC>
+    struct LayerForward {
+        using SPEC = T_SPEC;
+        using TYPE_POLICY = typename SPEC::TYPE_POLICY;
+        using TI = typename SPEC::TI;
+        static constexpr TI INPUT_HEIGHT = SPEC::INPUT_HEIGHT;
+        static constexpr TI INPUT_WIDTH = SPEC::INPUT_WIDTH;
+        static constexpr TI INPUT_CHANNELS = SPEC::INPUT_CHANNELS;
+        static constexpr TI OUTPUT_HEIGHT = SPEC::OUTPUT_HEIGHT;
+        static constexpr TI OUTPUT_WIDTH = SPEC::OUTPUT_WIDTH;
+        static constexpr TI OUTPUT_CHANNELS = SPEC::OUTPUT_CHANNELS;
+        static constexpr TI KERNEL_HEIGHT = SPEC::KERNEL_HEIGHT;
+        static constexpr TI KERNEL_WIDTH = SPEC::KERNEL_WIDTH;
+        static constexpr TI STRIDE_H = SPEC::STRIDE_H;
+        static constexpr TI STRIDE_W = SPEC::STRIDE_W;
+        static constexpr TI PADDING_H = SPEC::PADDING_H;
+        static constexpr TI PADDING_W = SPEC::PADDING_W;
+        static constexpr TI NUM_WEIGHTS = SPEC::NUM_WEIGHTS;
+        static constexpr TI INTERNAL_BATCH_SIZE = SPEC::INTERNAL_BATCH_SIZE;
+        using INPUT_SHAPE = typename SPEC::INPUT_SHAPE;
+        template <typename NEW_INPUT_SHAPE>
+        using OUTPUT_SHAPE_FACTORY = typename SPEC::template OUTPUT_SHAPE_FACTORY<NEW_INPUT_SHAPE>::SHAPE;
+        using OUTPUT_SHAPE = typename SPEC::OUTPUT_SHAPE;
+
+        template<bool DYNAMIC_ALLOCATION=true>
+        using Buffer = dynamic_conv2d::Buffer<dynamic_conv2d::BufferSpecification<SPEC, DYNAMIC_ALLOCATION>>;
+        template<bool DYNAMIC_ALLOCATION=true>
+        using State = dynamic_conv2d::State;
+    };
+
+    template<typename SPEC>
+    struct LayerBackward: public LayerForward<SPEC>{
+        using T = typename SPEC::TYPE_POLICY::template GET<numeric_types::categories::Activation>;
+        using TI = typename SPEC::TI;
+        using PRE_ACTIVATIONS_SHAPE = tensor::Shape<TI, SPEC::INTERNAL_BATCH_SIZE, SPEC::OUTPUT_HEIGHT, SPEC::OUTPUT_WIDTH, SPEC::OUTPUT_CHANNELS>;
+        using PRE_ACTIVATIONS_SPEC = tensor::Specification<T, TI, PRE_ACTIVATIONS_SHAPE, SPEC::DYNAMIC_ALLOCATION, tensor::RowMajorStride<PRE_ACTIVATIONS_SHAPE>, SPEC::CONST>;
+        using PRE_ACTIVATIONS_TYPE = Tensor<PRE_ACTIVATIONS_SPEC>;
+        PRE_ACTIVATIONS_TYPE pre_activations;
+    };
+
+    template<typename SPEC>
+    struct LayerGradient: public LayerBackward<SPEC>{
+        using T = typename SPEC::TYPE_POLICY::template GET<numeric_types::categories::Activation>;
+        using TI = typename SPEC::TI;
+        using OUTPUT_CONTAINER_SHAPE = tensor::Shape<TI, SPEC::INTERNAL_BATCH_SIZE, SPEC::OUTPUT_HEIGHT, SPEC::OUTPUT_WIDTH, SPEC::OUTPUT_CHANNELS>;
+        using OUTPUT_CONTAINER_SPEC = tensor::Specification<T, TI, OUTPUT_CONTAINER_SHAPE, SPEC::DYNAMIC_ALLOCATION, tensor::RowMajorStride<OUTPUT_CONTAINER_SHAPE>, SPEC::CONST>;
+        using OUTPUT_CONTAINER_TYPE = Tensor<OUTPUT_CONTAINER_SPEC>;
+        OUTPUT_CONTAINER_TYPE output;
+    };
+
+    template<typename CONFIG, typename CAPABILITY, typename INPUT_SHAPE>
+    using Layer =
+        typename utils::typing::conditional_t<CAPABILITY::TAG == nn::LayerCapability::Forward,
+            LayerForward<Specification<CONFIG, CAPABILITY, INPUT_SHAPE>>,
+        typename utils::typing::conditional_t<CAPABILITY::TAG == nn::LayerCapability::Backward,
+            LayerBackward<Specification<CONFIG, CAPABILITY, INPUT_SHAPE>>,
+        typename utils::typing::conditional_t<CAPABILITY::TAG == nn::LayerCapability::Gradient,
+            LayerGradient<Specification<CONFIG, CAPABILITY, INPUT_SHAPE>>, void>>>;
+
+    template <typename CONFIG>
+    struct BindConfiguration{
+        template <typename CAPABILITY, typename INPUT_SHAPE>
+        using Layer = nn::layers::dynamic_conv2d::Layer<CONFIG, CAPABILITY, INPUT_SHAPE>;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif