hyperverse 0.0.1__py3-none-any.whl

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

@@ -0,0 +1,99 @@
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_CONV2D_PERSIST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_CONV2D_PERSIST_H
+#include "../../../version.h"
+#include "layer.h"
+#include "../../parameters/persist.h"
+#include "../dense/persist_common.h"
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    void save(DEVICE& device, nn::layers::conv2d::LayerForward<SPEC>& layer, GROUP& group) {
+        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, "type", "conv2d");
+        set_attribute(device, group, "output_channels", std::to_string(SPEC::OUTPUT_CHANNELS).c_str());
+        set_attribute(device, group, "input_channels", std::to_string(SPEC::INPUT_CHANNELS).c_str());
+        set_attribute(device, group, "kernel_height", std::to_string(SPEC::KERNEL_HEIGHT).c_str());
+        set_attribute(device, group, "kernel_width", std::to_string(SPEC::KERNEL_WIDTH).c_str());
+        set_attribute(device, group, "stride_h", std::to_string(SPEC::STRIDE_H).c_str());
+        set_attribute(device, group, "stride_w", std::to_string(SPEC::STRIDE_W).c_str());
+        set_attribute(device, group, "padding_h", std::to_string(SPEC::PADDING_H).c_str());
+        set_attribute(device, group, "padding_w", std::to_string(SPEC::PADDING_W).c_str());
+        set_attribute(device, group, "activation_function", nn::layers::dense::persist::get_activation_function_string_short<SPEC::ACTIVATION_FUNCTION>());
+        if constexpr(SPEC::NORMALIZATION == nn::layers::conv2d::Normalization::NONE){
+            set_attribute(device, group, "normalization", "NONE");
+        } else if constexpr(SPEC::NORMALIZATION == nn::layers::conv2d::Normalization::BATCH_NORM){
+            set_attribute(device, group, "normalization", "BATCH_NORM");
+        } else if constexpr(SPEC::NORMALIZATION == nn::layers::conv2d::Normalization::LAYER_NORM){
+            set_attribute(device, group, "normalization", "LAYER_NORM");
+        }
+        if constexpr(SPEC::NORMALIZATION != nn::layers::conv2d::Normalization::NONE) {
+            auto gamma_group = create_group(device, group, "gamma");
+            auto beta_group = create_group(device, group, "beta");
+            save(device, layer.norm.gamma, gamma_group);
+            save(device, layer.norm.beta, beta_group);
+            if constexpr(SPEC::NORMALIZATION == nn::layers::conv2d::Normalization::BATCH_NORM) {
+                save(device, layer.norm.running_mean, group, "running_mean");
+                save(device, layer.norm.running_var, group, "running_var");
+            }
+        }
+        write_attributes(device, group);
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    void save(DEVICE& device, nn::layers::conv2d::LayerBackward<SPEC>& layer, GROUP& group) {
+        save(device, (nn::layers::conv2d::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::conv2d::LayerGradient<SPEC>& layer, GROUP& group) {
+        save(device, (nn::layers::conv2d::LayerBackward<SPEC>&)layer, group);
+        save(device, layer.output, group, "output");
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn::layers::conv2d::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);
+        if constexpr(SPEC::NORMALIZATION != nn::layers::conv2d::Normalization::NONE) {
+            if(group_exists(device, group, "gamma") && group_exists(device, group, "beta")) {
+                auto gamma_group = get_group(device, group, "gamma");
+                auto beta_group = get_group(device, group, "beta");
+                success &= load(device, layer.norm.gamma, gamma_group);
+                success &= load(device, layer.norm.beta, beta_group);
+            }
+            if constexpr(SPEC::NORMALIZATION == nn::layers::conv2d::Normalization::BATCH_NORM) {
+                if(group_exists(device, group, "running_mean")) {
+                    success &= load(device, layer.norm.running_mean, group, "running_mean");
+                    success &= load(device, layer.norm.running_var, group, "running_var");
+                }
+            }
+        }
+        return success;
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn::layers::conv2d::LayerBackward<SPEC>& layer, GROUP& group) {
+        bool success = load(device, (nn::layers::conv2d::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::conv2d::LayerGradient<SPEC>& layer, GROUP& group) {
+        bool success = load(device, (nn::layers::conv2d::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::conv2d::State& state, GROUP& group) {}
+    template<typename DEVICE, typename GROUP>
+    bool load(DEVICE& device, nn::layers::conv2d::State& state, GROUP& group) { return true; }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,170 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_CONV2D_PERSIST_CODE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_CONV2D_PERSIST_CODE_H
+#include "layer.h"
+#include "../../../containers/tensor/persist_code.h"
+#include <sstream>
+#include "../../../persist/code.h"
+#include "../../../nn/parameters/persist_code.h"
+#include "../../../nn/capability/persist_code.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    namespace nn::layers::conv2d::persist_code{
+        template <nn::activation_functions::ActivationFunction F>
+        std::string get_activation_function_string(){
+            if constexpr(F == nn::activation_functions::ActivationFunction::IDENTITY) return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::IDENTITY";
+            else if constexpr(F == nn::activation_functions::ActivationFunction::RELU) return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::RELU";
+            else if constexpr(F == nn::activation_functions::ActivationFunction::GELU) return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::GELU";
+            else if constexpr(F == nn::activation_functions::ActivationFunction::TANH) return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::TANH";
+            else if constexpr(F == nn::activation_functions::ActivationFunction::FAST_TANH) return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::FAST_TANH";
+            else if constexpr(F == nn::activation_functions::ActivationFunction::SIGMOID) return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::SIGMOID";
+            else return "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::activation_functions::ActivationFunction::IDENTITY";
+        }
+        template<typename DEVICE, typename SPEC>
+        rl_tools::persist::Code finish(DEVICE& device, nn::layers::conv2d::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();
+            std::string TI_string = containers::persist::get_type_string<typename SPEC::TI>();
+            std::stringstream ss, ss_header;
+            ss_header << input.header;
+            ss_header << "#include <rl_tools/nn/layers/conv2d/layer.h>\n";
+            ss << input.body;
+            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::conv2d::Configuration<"
+               << "TYPE_POLICY, " << TI_string << ", "
+               << SPEC::OUTPUT_CHANNELS << ", "
+               << SPEC::KERNEL_HEIGHT << ", " << SPEC::KERNEL_WIDTH << ", "
+               << SPEC::STRIDE_H << ", " << SPEC::STRIDE_W << ", "
+               << SPEC::PADDING_H << ", " << SPEC::PADDING_W << ", "
+               << get_activation_function_string<SPEC::ACTIVATION_FUNCTION>()
+               << ">;\n";
+            ss << ind << "    using TEMPLATE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::layers::conv2d::BindConfiguration<CONFIG>;\n";
+            ss << ind << "    using INPUT_SHAPE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::tensor::Shape<" << TI_string;
+            tensor::persist_code::emit_values<typename SPEC::INPUT_SHAPE>(ss);
+            ss << ">;\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::conv2d::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{
+                initializer_list = "{{{weights::parameters, biases::parameters, {}}, pre_activations::container, {}}, output::container}";
+            }
+            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::conv2d::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();
+        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::conv2d::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::conv2d::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();
+        std::stringstream ss, ss_header;
+        auto previous = save_code_split(device, static_cast<nn::layers::conv2d::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::conv2d::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::conv2d::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();
+        std::stringstream ss, ss_header;
+        auto previous = save_code_split(device, static_cast<nn::layers::conv2d::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::conv2d::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::conv2d::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::conv2d::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::conv2d::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::conv2d::LayerGradient<SPEC>& layer) {
+        std::string data;
+        data += "{";
+        data += "\"weights\": " + nn_analytics(device, layer.weights) + ", ";
+        data += "\"biases\": " + nn_analytics(device, layer.biases) + ", ";
+        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/layer.h

@@ -0,0 +1,145 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_DENSE_LAYER_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_DENSE_LAYER_H
+#include "../../../nn/activation_functions.h"
+#include "../../../utils/generic/typing.h"
+#include "../../../containers/matrix/matrix.h"
+
+//#include "../../../nn/nn.h"
+#include "../../../nn/capability/capability.h"
+#include "../../../nn/parameters/parameters.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::nn::layers::dense {
+    template <typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC>
+    constexpr bool check_input_output_f(){
+        static_assert(INPUT_SPEC::COLS == LAYER_SPEC::INPUT_DIM);
+        static_assert(INPUT_SPEC::ROWS == OUTPUT_SPEC::ROWS);
+        //                INPUT_SPEC::ROWS <= OUTPUT_SPEC::ROWS && // todo: could be relaxed to not fill the full output
+        static_assert(OUTPUT_SPEC::COLS == LAYER_SPEC::OUTPUT_DIM);
+        // static_assert(utils::typing::is_same_v<typename LAYER_SPEC::T, typename INPUT_SPEC::T>);
+        // static_assert(utils::typing::is_same_v<typename INPUT_SPEC::T, typename OUTPUT_SPEC::T>);
+        return true;
+    }
+    template <typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC>
+    constexpr bool check_input_output = check_input_output_f<LAYER_SPEC, INPUT_SPEC, OUTPUT_SPEC>();
+
+    template <typename T_TYPE_POLICY, typename T_TI>
+    struct KaimingUniformSpecification{
+        using T = typename T_TYPE_POLICY::DEFAULT;
+        using TI = T_TI;
+        static constexpr bool INIT_LEGACY = true;
+        static constexpr T SCALE = 1;
+    };
+    template<typename SPEC>
+    struct KaimingUniform {
+    };
+    template<typename T_TYPE_POLICY, typename T_TI>
+    using DefaultInitializer = KaimingUniform<KaimingUniformSpecification<T_TYPE_POLICY, T_TI>>;
+
+
+    template<typename T_TYPE_POLICY, typename T_TI, T_TI T_OUTPUT_DIM, nn::activation_functions::ActivationFunction T_ACTIVATION_FUNCTION, typename T_INITIALIZER = DefaultInitializer<T_TYPE_POLICY, T_TI>, typename T_PARAMETER_GROUP=parameters::groups::Normal>
+    struct Configuration{
+        using TYPE_POLICY = T_TYPE_POLICY;
+        using TI = T_TI;
+        static constexpr TI OUTPUT_DIM = T_OUTPUT_DIM;
+        static constexpr nn::activation_functions::ActivationFunction ACTIVATION_FUNCTION = T_ACTIVATION_FUNCTION;
+        using INITIALIZER = T_INITIALIZER;
+        using PARAMETER_GROUP = T_PARAMETER_GROUP;
+    };
+    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 constexpr TI INPUT_DIM = get_last(INPUT_SHAPE{});
+        template <typename NEW_INPUT_SHAPE>
+        struct OUTPUT_SHAPE_FACTORY{
+            static constexpr TI NEW_INPUT_DIM = get_last(NEW_INPUT_SHAPE{});
+            static_assert(NEW_INPUT_DIM == INPUT_DIM);
+            using SHAPE = tensor::Replace<NEW_INPUT_SHAPE, CONFIG::OUTPUT_DIM, length(NEW_INPUT_SHAPE{})-1>;
+        };
+        using OUTPUT_SHAPE = typename OUTPUT_SHAPE_FACTORY<INPUT_SHAPE>::SHAPE;
+        static constexpr TI INTERNAL_BATCH_SIZE = get<0>(tensor::CumulativeProduct<tensor::PopBack<INPUT_SHAPE>>{}); // Since the Dense layer is based on Matrices (2D Tensors) the dense layer operation is broadcasted over the leading dimensions. Hence, the actual batch size is the product of all leading dimensions, excluding the last one (containing the features). Since rl_tools::matrix_view is used for zero-cost conversion the INTERNAL_BATCH_SIZE accounts for all leading dimensions.
+        static constexpr TI NUM_WEIGHTS = CONFIG::OUTPUT_DIM * INPUT_DIM + CONFIG::OUTPUT_DIM;
+    };
+    template<typename SPEC_1, typename SPEC_2>
+    constexpr bool check_spec_memory =
+            // utils::typing::is_same_v<typename SPEC_1::T, typename SPEC_2::T>
+            SPEC_1::INPUT_DIM == SPEC_2::INPUT_DIM
+            && SPEC_1::OUTPUT_DIM == SPEC_2::OUTPUT_DIM;
+    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;
+
+    struct State{};
+    struct Buffer{};
+
+    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_DIM = SPEC::INPUT_DIM;
+        static constexpr TI OUTPUT_DIM = SPEC::OUTPUT_DIM;
+        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;
+        using WEIGHTS_SHAPE = tensor::Shape<TI, OUTPUT_DIM, INPUT_DIM>;
+        using WEIGHTS_PARAMETER_SPEC = typename SPEC::PARAMETER_TYPE::template Specification<TYPE_POLICY, TI, WEIGHTS_SHAPE, typename SPEC::PARAMETER_GROUP, nn::parameters::categories::Weights, SPEC::DYNAMIC_ALLOCATION, SPEC::CONST>;
+        typename SPEC::PARAMETER_TYPE::template Instance<WEIGHTS_PARAMETER_SPEC> weights;
+
+
+        using BIASES_SHAPE = tensor::Shape<TI, OUTPUT_DIM>;
+        using BIASES_PARAMETER_SPEC = typename SPEC::PARAMETER_TYPE::template Specification<TYPE_POLICY, TI, BIASES_SHAPE, typename SPEC::PARAMETER_GROUP, nn::parameters::categories::Biases, SPEC::DYNAMIC_ALLOCATION, SPEC::CONST>;
+        typename SPEC::PARAMETER_TYPE::template Instance<BIASES_PARAMETER_SPEC> biases;
+        template<bool DYNAMIC_ALLOCATION=true>
+        using Buffer = dense::Buffer;
+        template<bool DYNAMIC_ALLOCATION=true>
+        using State = dense::State;
+    };
+    template<typename SPEC>
+    struct LayerBackward: public LayerForward<SPEC>{
+        // This layer supports backpropagation wrt its input but not its weights (for this it stores the intermediate pre_activations)
+
+        using PARENT = LayerForward<SPEC>;
+        using T = typename SPEC::TYPE_POLICY::template GET<numeric_types::categories::Activation>;
+        using PRE_ACTIVATIONS_CONTAINER_SPEC = matrix::Specification<T, typename SPEC::TI, SPEC::INTERNAL_BATCH_SIZE, SPEC::OUTPUT_DIM, SPEC::DYNAMIC_ALLOCATION, matrix::layouts::DEFAULT<typename SPEC::TI>, SPEC::CONST>;
+        using PRE_ACTIVATIONS_CONTAINER_TYPE = Matrix<PRE_ACTIVATIONS_CONTAINER_SPEC>;
+        PRE_ACTIVATIONS_CONTAINER_TYPE pre_activations;
+    };
+    template<typename SPEC>
+    struct LayerGradient: public LayerBackward<SPEC>{
+        // This layer supports backpropagation wrt its input but including its weights (for this it stores the intermediate outputs in addition to the pre_activations because they determine the gradient wrt the weights of the following layer)
+
+        using PARENT = LayerBackward<SPEC>;
+        using T = typename SPEC::TYPE_POLICY::template GET<numeric_types::categories::Activation>;
+        using OUTPUT_CONTAINER_SPEC = matrix::Specification<T, typename SPEC::TI, SPEC::INTERNAL_BATCH_SIZE, SPEC::OUTPUT_DIM, SPEC::DYNAMIC_ALLOCATION, matrix::layouts::DEFAULT<typename SPEC::TI>, SPEC::CONST>;
+        using OUTPUT_CONTAINER_TYPE = Matrix<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::dense::Layer<CONFIG, CAPABILITY, INPUT_SHAPE>;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,63 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_DENSE_OPERATIONS_ARM_DSP_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_DENSE_OPERATIONS_ARM_DSP_H
+
+#include "../../../../nn/layers/dense/operations_generic.h"
+//#include "../../../../utils/generic/memcpy.h"
+#include "../../../../devices/arm.h"
+#include "arm_math.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEV_SPEC, typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC, typename RNG, typename MODE = mode::Default<>>
+    void evaluate(devices::arm::DSP<DEV_SPEC>& device, const nn::layers::dense::LayerForward<LAYER_SPEC>& layer, const Matrix<INPUT_SPEC>& input, Matrix<OUTPUT_SPEC>& output, nn::layers::dense::Buffer&, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        static_assert(nn::layers::dense::check_input_output<LAYER_SPEC, INPUT_SPEC, OUTPUT_SPEC>);
+        static_assert(INPUT_SPEC::ROW_PITCH == INPUT_SPEC::COLS);
+        static_assert(INPUT_SPEC::COL_PITCH == 1);
+        static_assert(OUTPUT_SPEC::ROW_PITCH == OUTPUT_SPEC::COLS);
+        static_assert(OUTPUT_SPEC::COL_PITCH == 1);
+        static_assert(decltype(layer.weights.parameters)::ROW_PITCH == INPUT_SPEC::COLS);
+        static_assert(decltype(layer.weights.parameters)::COL_PITCH == 1);
+        static_assert(decltype(layer.biases.parameters)::COL_PITCH == 1);
+        static_assert(decltype(layer.biases.parameters)::ROW_PITCH == decltype(layer.biases.parameters)::COLS);
+        static_assert(utils::typing::is_same_v<typename LAYER_SPEC::T, float>);
+
+        // Warning do not use the same buffer for input and output!
+        constexpr auto BATCH_SIZE = INPUT_SPEC::ROWS;
+        static_assert(BATCH_SIZE == 1);
+        using DEVICE = devices::ARM<DEV_SPEC>;
+        using T = typename LAYER_SPEC::T;
+        using TI = typename DEVICE::index_t;
+
+        arm_matrix_instance_f32 arm_weights = {
+                .numRows = LAYER_SPEC::OUTPUT_DIM,
+                .numCols = LAYER_SPEC::INPUT_DIM,
+                .pData = layer.weights.parameters._data
+        };
+
+        arm_matrix_instance_f32 arm_input = {
+                .numRows = LAYER_SPEC::INPUT_DIM,
+                .numCols = BATCH_SIZE,
+                .pData = input._data
+        };
+        arm_matrix_instance_f32 arm_output = {
+                .numRows = LAYER_SPEC::OUTPUT_DIM,
+                .numCols = BATCH_SIZE,
+                .pData = output._data
+        } ;
+        arm_mat_mult_f32(&arm_weights, &arm_input, &arm_output);
+        // beware this only works for batch size = 1
+        arm_add_f32(output._data, layer.biases.parameters._data, output._data, LAYER_SPEC::OUTPUT_DIM);
+
+
+        for(TI i = 0; i < BATCH_SIZE; i++){
+            for(TI j = 0; j < LAYER_SPEC::OUTPUT_DIM; j++){
+                set(output, i, j, activation<typename DEVICE::SPEC::MATH, T, LAYER_SPEC::ACTIVATION_FUNCTION>(get(output, i, j)));
+            }
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,173 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_DENSE_OPERATIONS_ARM_OPT_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_DENSE_OPERATIONS_ARM_OPT_H
+
+#include "../../../../nn/layers/dense/operations_generic.h"
+//#include "../../../../utils/generic/memcpy.h"
+#include "../../../../devices/arm.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEV_SPEC, typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC, typename RNG, typename MODE = mode::Default<>>
+    void evaluate(devices::arm::OPT<DEV_SPEC>& device, const nn::layers::dense::LayerForward<LAYER_SPEC>& layer, const Matrix<INPUT_SPEC>& input, Matrix<OUTPUT_SPEC>& output, nn::layers::dense::Buffer&, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        // For performance reasons: restricted to dense row-major matrices (row-pitch is allowed)
+        static_assert(nn::layers::dense::check_input_output<LAYER_SPEC, INPUT_SPEC, OUTPUT_SPEC>);
+        static_assert(INPUT_SPEC::COL_PITCH == 1);
+        static_assert(OUTPUT_SPEC::COL_PITCH == 1);
+        static_assert(decltype(layer.weights.parameters)::SPEC::STRIDE::template GET<1> == 1);
+        static_assert(decltype(layer.biases.parameters)::SPEC::STRIDE::template GET<0> == 1);
+        using WEIGHT_TYPE = typename decltype(layer.weights.parameters)::T;
+        static_assert(utils::typing::is_same_v<WEIGHT_TYPE, typename decltype(layer.biases.parameters)::T>);
+        static_assert(utils::typing::is_same_v<WEIGHT_TYPE, typename INPUT_SPEC::T>);
+        static_assert(utils::typing::is_same_v<WEIGHT_TYPE, typename OUTPUT_SPEC::T>);
+//        static_assert(utils::typing::is_same_v<typename LAYER_SPEC::T, float>);
+
+        // Warning do not use the same buffer for input and output!
+        constexpr auto BATCH_SIZE = INPUT_SPEC::ROWS;
+        // static_assert(BATCH_SIZE == 1);
+        using DEVICE = devices::ARM<DEV_SPEC>;
+        using T = WEIGHT_TYPE;
+        using TI = typename LAYER_SPEC::TI;
+        {
+
+            const T *weights_row;
+            const T *input_row = input._data;
+            T *output_row = output._data;
+
+            const T *weights_element, *biases_element, *input_element;
+            T *output_element;
+
+            T acc;
+            TI weights_row_i, batch_i = BATCH_SIZE, input_i;
+
+            {
+                do{
+                    output_element = output_row;
+                    biases_element = layer.biases.parameters._data;
+
+                    weights_row_i = LAYER_SPEC::OUTPUT_DIM;
+                    weights_row = layer.weights.parameters._data;
+
+                    do{
+                        acc = 0.0f;
+                        input_element = input_row;
+                        weights_element = weights_row;
+
+                        // reduction
+                        input_i = ((TI)LAYER_SPEC::INPUT_DIM) >> 2U;
+                        while (input_i > 0U){
+                            acc += *weights_element++ * *input_element++;
+                            acc += *weights_element++ * *input_element++;
+                            acc += *weights_element++ * *input_element++;
+                            acc += *weights_element++ * *input_element++;
+
+                            input_i--;
+                        }
+                        input_i = ((TI)LAYER_SPEC::INPUT_DIM) % 0x4U;
+                        while (input_i > 0U){
+                            acc += *weights_element++ * *input_element++;
+                            input_i--;
+                        }
+
+                        acc += *biases_element++;
+                        acc = activation<typename DEVICE::SPEC::MATH, T, LAYER_SPEC::ACTIVATION_FUNCTION>(acc);
+
+                        *output_element++ = acc;
+
+                        weights_row_i--;
+
+                        weights_row += decltype(layer.weights.parameters)::SPEC::STRIDE::template GET<0>;
+
+                    }while (weights_row_i > 0U);
+
+                    output_row += OUTPUT_SPEC::ROW_PITCH;
+                    input_row += INPUT_SPEC::ROW_PITCH;
+                    batch_i--;
+                }while (batch_i > 0U);
+            }
+        }
+    }
+
+    template<typename DEV_SPEC, typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC, typename RNG, typename MODE = mode::Default<>>
+    void forward(devices::ARM<DEV_SPEC>& device, nn::layers::dense::LayerBackward<LAYER_SPEC>& layer, const Matrix<INPUT_SPEC>& input, Matrix<OUTPUT_SPEC>& output, nn::layers::dense::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        // For performance reasons: restricted to dense row-major matrices (row-pitch is allowed)
+        static_assert(nn::layers::dense::check_input_output<LAYER_SPEC, INPUT_SPEC, OUTPUT_SPEC>);
+        static_assert(INPUT_SPEC::COL_PITCH == 1);
+        static_assert(OUTPUT_SPEC::COL_PITCH == 1);
+        static_assert(decltype(layer.weights.parameters)::COL_PITCH == 1);
+        static_assert(decltype(layer.biases.parameters)::COL_PITCH == 1);
+//        static_assert(utils::typing::is_same_v<typename LAYER_SPEC::T, float>);
+
+        // Warning do not use the same buffer for input and output!
+        constexpr auto BATCH_SIZE = INPUT_SPEC::ROWS;
+        // static_assert(BATCH_SIZE == 1);
+        using DEVICE = devices::ARM<DEV_SPEC>;
+        using T = typename LAYER_SPEC::T;
+        using TI = typename DEVICE::index_t;
+        {
+
+            T *weights_row;
+            const T *input_row = input._data;
+            T *pre_activations_row = layer.pre_activations._data;
+            T *output_row = output._data;
+
+            T *weights_element, *biases_element, *input_element, *pre_activations_element, *output_element;
+
+            T acc;
+            TI weights_row_i, batch_i = BATCH_SIZE, input_i;
+
+            {
+                do{
+                    pre_activations_element = pre_activations_row;
+                    output_element = output_row;
+                    biases_element = layer.biases.parameters._data;
+
+                    weights_row_i = LAYER_SPEC::OUTPUT_DIM;
+                    weights_row = layer.weights.parameters._data;
+
+                    do{
+                        acc = 0.0f;
+                        input_element = input_row;
+                        weights_element = weights_row;
+
+                        // reduction
+                        input_i = ((TI)LAYER_SPEC::INPUT_DIM) >> 2U;
+                        while (input_i > 0U){
+                            acc += *weights_element++ * *input_element++;
+                            acc += *weights_element++ * *input_element++;
+                            acc += *weights_element++ * *input_element++;
+                            acc += *weights_element++ * *input_element++;
+
+                            input_i--;
+                        }
+                        input_i = ((TI)LAYER_SPEC::INPUT_DIM) % 0x4U;
+                        while (input_i > 0U){
+                            acc += *weights_element++ * *input_element++;
+                            input_i--;
+                        }
+
+                        acc += *biases_element++;
+                        *pre_activations_element++ = acc;
+                        acc = activation<typename DEVICE::SPEC::MATH, T, LAYER_SPEC::ACTIVATION_FUNCTION>(acc);
+
+                        *output_element++ = acc;
+
+                        weights_row_i--;
+
+                        weights_row += decltype(layer.weights.parameters)::ROW_PITCH;
+
+                    }while (weights_row_i > 0U);
+
+                    pre_activations_row += OUTPUT_SPEC::ROW_PITCH;
+                    output_row += OUTPUT_SPEC::ROW_PITCH;
+                    input_row += INPUT_SPEC::ROW_PITCH;
+                    batch_i--;
+                }while (batch_i > 0U);
+            }
+        }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif