hyperverse 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/nn_models/parallel/persist.h

@@ -0,0 +1,80 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_MODELS_PARALLEL_PERSIST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_MODELS_PARALLEL_PERSIST_H
+
+#include "model.h"
+#include "../sequential/persist.h"
+
+#include <sstream>
+#include <string>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace nn_models::parallel{
+        template <typename SHAPE, auto INDEX = 0>
+        void _shape_to_csv(std::stringstream& ss){
+            if constexpr(INDEX == 0){
+                ss << get<0>(SHAPE{});
+            }
+            else{
+                ss << "," << get<INDEX>(SHAPE{});
+            }
+            if constexpr(INDEX + 1 < length(SHAPE{})){
+                _shape_to_csv<SHAPE, INDEX + 1>(ss);
+            }
+        }
+
+        template <auto I = 0, typename DEVICE, typename SPEC, typename GROUP>
+        void _save_branches(DEVICE& device, ModuleForward<SPEC>& model, GROUP& group){
+            if constexpr(I < SPEC::NUM_BRANCHES){
+                std::string name = "branch_" + std::to_string(I);
+                auto branch_group = create_group(device, group, name.c_str());
+                using BRANCH = typename utils::tuple_element<I, typename SPEC::BRANCH_TUPLE>::type;
+                using INPUT_SHAPE = typename BRANCH::INPUT_SHAPE;
+                std::stringstream shape_ss;
+                _shape_to_csv<INPUT_SHAPE>(shape_ss);
+                set_attribute(device, branch_group, "input_shape", shape_ss.str().c_str());
+                save(device, get<I>(model.pipelines), branch_group);
+                _save_branches<I + 1>(device, model, group);
+            }
+        }
+        template <auto I = 0, typename DEVICE, typename SPEC, typename GROUP>
+        bool _load_branches(DEVICE& device, ModuleForward<SPEC>& model, GROUP& group){
+            if constexpr(I < SPEC::NUM_BRANCHES){
+                std::string name = "branch_" + std::to_string(I);
+                auto branch_group = get_group(device, group, name.c_str());
+                bool success = load(device, get<I>(model.pipelines), branch_group);
+                return success && _load_branches<I + 1>(device, model, group);
+            }
+            else{
+                return true;
+            }
+        }
+    }
+
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    void save(DEVICE& device, nn_models::parallel::ModuleForward<SPEC>& model, GROUP& group){
+        set_attribute(device, group, "type", "parallel");
+        set_attribute(device, group, "num_branches", std::to_string(SPEC::NUM_BRANCHES).c_str());
+        set_attribute(device, group, "has_head", SPEC::HAS_HEAD ? "1" : "0");
+        write_attributes(device, group);
+        nn_models::parallel::_save_branches(device, model, group);
+        if constexpr(SPEC::HAS_HEAD){
+            auto group_head = create_group(device, group, "head");
+            save(device, model.head, group_head);
+        }
+    }
+
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn_models::parallel::ModuleForward<SPEC>& model, GROUP& group){
+        bool success = nn_models::parallel::_load_branches(device, model, group);
+        if constexpr(SPEC::HAS_HEAD){
+            auto group_head = get_group(device, group, "head");
+            success &= load(device, model.head, group_head);
+        }
+        return success;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/nn_models/parallel/persist_code.h

@@ -0,0 +1,200 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_MODELS_PARALLEL_PERSIST_CODE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_MODELS_PARALLEL_PERSIST_CODE_H
+#include "../../persist/code.h"
+#include "../sequential/persist_code.h"
+#include "model.h"
+
+#include <string>
+#include <sstream>
+#include <vector>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace nn_models::parallel::persist_code{
+        template <typename SHAPE, auto INDEX = 0>
+        void shape_to_string(std::stringstream& ss, const std::string& ti_string){
+            if constexpr(INDEX == 0){
+                ss << "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::tensor::Shape<" << ti_string;
+            }
+            ss << ", " << get<INDEX>(SHAPE{});
+            if constexpr(INDEX + 1 < length(SHAPE{})){
+                shape_to_string<SHAPE, INDEX + 1>(ss, ti_string);
+            }
+            else{
+                ss << ">";
+            }
+        }
+
+        template <auto I = 0, typename DEVICE, typename SPEC>
+        void _save_code_branches(DEVICE& device, nn_models::parallel::ModuleForward<SPEC>& model,
+                                  std::vector<persist::Code>& branch_codes,
+                                  bool const_declaration, typename DEVICE::index_t indent){
+            if constexpr(I < SPEC::NUM_BRANCHES){
+                std::string name = "branch_" + std::to_string(I);
+                auto code = save_code_split(device, get<I>(model.pipelines), name, const_declaration, indent + 1);
+                branch_codes.push_back(code);
+                _save_code_branches<I + 1>(device, model, branch_codes, const_declaration, indent);
+            }
+        }
+
+        template <auto I = 0, typename SPEC>
+        void _emit_branch_input_shapes(std::stringstream& ss, const std::string& ind, const std::string& ti_string){
+            if constexpr(I < SPEC::NUM_BRANCHES){
+                using BRANCH_TUPLE = typename SPEC::BRANCH_TUPLE;
+                using BRANCH = typename utils::tuple_element<I, BRANCH_TUPLE>::type;
+                std::stringstream shape_ss;
+                shape_to_string<typename BRANCH::INPUT_SHAPE>(shape_ss, ti_string);
+                ss << ind << "    " << "    " << "using INPUT_SHAPE_" << I << " = " << shape_ss.str() << ";\n";
+                _emit_branch_input_shapes<I + 1, SPEC>(ss, ind, ti_string);
+            }
+        }
+
+        template <auto I = 0, typename SPEC>
+        void _emit_branch_types(std::stringstream& ss, const std::string& ind){
+            if constexpr(I < SPEC::NUM_BRANCHES){
+                using BRANCH = typename utils::tuple_element<I, typename SPEC::BRANCH_TUPLE>::type;
+                using PIPELINE = typename BRANCH::MODULE::template Layer<typename SPEC::CAPABILITY, typename BRANCH::INPUT_SHAPE>;
+                using GROUPS = typename nn::group::RelativeGroups<typename nn::group::MembershipOf<typename PIPELINE::SPEC::CAPABILITY>::TYPE, typename nn::group::MembershipOf<typename SPEC::CAPABILITY>::TYPE>::TYPE;
+                ss << ind << "    " << "    " << "using BRANCH_" << I << " = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn_models::parallel::Branch<" << nn::group::CodeGroups<GROUPS>::wrap("branch_" + std::to_string(I) + "::TEMPLATE") << ", INPUT_SHAPE_" << I << ">;\n";
+                _emit_branch_types<I + 1, SPEC>(ss, ind);
+            }
+        }
+
+        template <auto I = 0, typename SPEC>
+        void _emit_branch_list(std::stringstream& ss){
+            if constexpr(I < SPEC::NUM_BRANCHES){
+                ss << ", BRANCH_" << I;
+                _emit_branch_list<I + 1, SPEC>(ss);
+            }
+        }
+
+        template <auto I = 0, typename SPEC>
+        void _emit_factory_assignments(std::stringstream& ss, const std::string& ind, const std::string& accessor){
+            if constexpr(I < SPEC::NUM_BRANCHES){
+                if constexpr(I == 0){
+                    ss << ind << "    " << "    " << accessor << ".pipelines.content = branch_0::factory<decltype(" << accessor << ".pipelines.content)>;\n";
+                }
+                else{
+                    // Navigate the MapTuple hierarchy: for I-th element, we need I levels of static_cast
+                    // Use rl_tools::get<I>() instead
+                    ss << ind << "    " << "    " << "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::get<" << I << ">(" << accessor << ".pipelines) = branch_" << I << "::factory<RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::utils::typing::remove_reference_t<decltype(RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::get<" << I << ">(" << accessor << ".pipelines))>>;\n";
+                }
+                _emit_factory_assignments<I + 1, SPEC>(ss, ind, accessor);
+            }
+        }
+
+        template <auto I = 0, typename SPEC>
+        void _emit_factory_function_assignments(std::stringstream& ss, const std::string& ind, const std::string& accessor){
+            if constexpr(I < SPEC::NUM_BRANCHES){
+                if constexpr(I == 0){
+                    ss << ind << "    " << "    " << accessor << ".pipelines.content = branch_0::factory_function<decltype(" << accessor << ".pipelines.content)>();\n";
+                }
+                else{
+                    ss << ind << "    " << "    " << "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::get<" << I << ">(" << accessor << ".pipelines) = branch_" << I << "::factory_function<RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::utils::typing::remove_reference_t<decltype(RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::get<" << I << ">(" << accessor << ".pipelines))>>();\n";
+                }
+                _emit_factory_function_assignments<I + 1, SPEC>(ss, ind, accessor);
+            }
+        }
+    }
+
+    template<typename DEVICE, typename SPEC>
+    persist::Code save_code_split(DEVICE& device, nn_models::parallel::ModuleForward<SPEC>& model, 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;
+
+        std::vector<persist::Code> branch_codes;
+        nn_models::parallel::persist_code::_save_code_branches(device, model, branch_codes, const_declaration, indent);
+        for(auto& code : branch_codes){
+            ss_header << code.header;
+        }
+
+        persist::Code head_code;
+        if constexpr(SPEC::HAS_HEAD){
+            head_code = save_code_split(device, model.head, "head", const_declaration, indent+1);
+            ss_header << head_code.header;
+        }
+
+        ss_header << "#include <rl_tools/nn_models/parallel/model.h>\n";
+
+        std::string TI_string = containers::persist::get_type_string<TI>();
+
+        ss << ind << "namespace " << name << " {\n";
+        for(auto& code : branch_codes){
+            ss << code.body;
+        }
+        if constexpr(SPEC::HAS_HEAD){
+            ss << head_code.body;
+        }
+
+        ss << ind << "    " << "namespace model_definition {\n";
+        ss << ind << "    " << "    " << "using CAPABILITY = " << to_string(typename SPEC::CAPABILITY::template CHANGE_PARAMETERS<true, true>{}) << "; \n";
+
+        nn_models::parallel::persist_code::_emit_branch_input_shapes<0, SPEC>(ss, ind, TI_string);
+        nn_models::parallel::persist_code::_emit_branch_types<0, SPEC>(ss, ind);
+
+        if constexpr(SPEC::HAS_HEAD){
+            using GROUPS = typename nn::group::RelativeGroups<typename nn::group::MembershipOf<typename SPEC::HEAD_TYPE::SPEC::CAPABILITY>::TYPE, typename nn::group::MembershipOf<typename SPEC::CAPABILITY>::TYPE>::TYPE;
+            ss << ind << "    " << "    " << "using HEAD = " << nn::group::CodeGroups<GROUPS>::wrap("head::TEMPLATE") << ";\n";
+            ss << ind << "    " << "    " << "using MODEL = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn_models::parallel::Build<CAPABILITY, HEAD";
+        }
+        else{
+            ss << ind << "    " << "    " << "using MODEL = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn_models::parallel::Build<CAPABILITY, void";
+        }
+        nn_models::parallel::persist_code::_emit_branch_list<0, SPEC>(ss);
+        ss << ">;\n";
+
+        ss << ind << "    " << "}\n";
+
+        ss << ind << "    " << "using TYPE = model_definition::MODEL;\n";
+
+        // constexpr module
+        ss << ind << "    " << (const_declaration ? "constexpr " : "") << "TYPE module = [](){\n";
+        ss << ind << "    " << "    TYPE m{};\n";
+        nn_models::parallel::persist_code::_emit_factory_assignments<0, SPEC>(ss, ind, "m");
+        if constexpr(SPEC::HAS_HEAD){
+            ss << ind << "    " << "    m.head = head::factory<decltype(m.head)>;\n";
+        }
+        ss << ind << "    " << "    return m;\n";
+        ss << ind << "    " << "}();\n";
+
+        // factory variable template
+        ss << ind << "    " << "template <typename T_TYPE = TYPE>" << "\n";
+        ss << ind << "    " << (const_declaration ? "constexpr " : "") << "T_TYPE factory = [](){\n";
+        ss << ind << "    " << "    T_TYPE m{};\n";
+        nn_models::parallel::persist_code::_emit_factory_assignments<0, SPEC>(ss, ind, "m");
+        if constexpr(SPEC::HAS_HEAD){
+            ss << ind << "    " << "    m.head = head::factory<decltype(m.head)>;\n";
+        }
+        ss << ind << "    " << "    return m;\n";
+        ss << ind << "    " << "}();\n";
+
+        // factory function
+        ss << ind << "    " << "template <typename T_TYPE = TYPE>" << "\n";
+        ss << ind << "    " << (const_declaration ? "constexpr " : "") << "T_TYPE factory_function(){\n";
+        ss << ind << "    " << "    T_TYPE m{};\n";
+        nn_models::parallel::persist_code::_emit_factory_function_assignments<0, SPEC>(ss, ind, "m");
+        if constexpr(SPEC::HAS_HEAD){
+            ss << ind << "    " << "    m.head = head::factory_function<decltype(m.head)>();\n";
+        }
+        ss << ind << "    " << "    return m;\n";
+        ss << ind << "    " << "}\n";
+
+        ss << ind << "}";
+
+        return {ss_header.str(), ss.str()};
+    }
+    template<typename DEVICE, typename SPEC>
+    std::string save_code(DEVICE& device, nn_models::parallel::ModuleForward<SPEC>& model, std::string name, bool const_declaration = true, typename DEVICE::index_t indent = 0){
+        auto code = save_code_split(device, model, name, const_declaration, indent);
+        return code.header + code.body;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/nn_models/persist.h

@@ -0,0 +1 @@
+#include "mlp/persist.h"

hyperdrone/_vendor/rl-tools/include/rl_tools/nn_models/persist_code.h

@@ -0,0 +1 @@
+#include "mlp/persist_code.h"

hyperdrone/_vendor/rl-tools/include/rl_tools/nn_models/random_uniform/model.h

@@ -0,0 +1,43 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_MODELS_RANDOM_UNIFORM_MODEL_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_MODELS_RANDOM_UNIFORM_MODEL_H
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::nn_models::random_uniform{
+    enum class Range{
+        MINUS_ONE_TO_ONE,
+        ZERO_TO_ONE
+    };
+    template <typename T_TYPE_POLICY, typename T_TI, T_TI T_INPUT_DIM, T_TI T_OUTPUT_DIM, Range T_RANGE>
+    struct Specification{
+        using TYPE_POLICY = T_TYPE_POLICY;
+        using TI = T_TI;
+        static constexpr T_TI INPUT_DIM = T_INPUT_DIM;
+        static constexpr T_TI OUTPUT_DIM = T_OUTPUT_DIM;
+        static constexpr Range RANGE = T_RANGE;
+    };
+    struct State{};
+    struct Buffer{};
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::nn_models{
+    template <typename T_SPEC>
+    struct RandomUniform{
+        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;
+        using INPUT_SHAPE = tensor::Shape<TI, 0, 0, INPUT_DIM>;
+        using OUTPUT_SHAPE = tensor::Shape<TI, 0, 0, OUTPUT_DIM>;
+
+        template <bool DYNAMIC_ALLOCATION=true>
+        using State = random_uniform::State;
+        template <TI BATCH_SIZE=1>
+        using Buffer = typename random_uniform::Buffer;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/nn_models/random_uniform/operations_generic.h

@@ -0,0 +1,73 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_MODELS_RANDOM_UNIFORM_OPERATIONS_GENERIC_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_MODELS_RANDOM_UNIFORM_OPERATIONS_GENERIC_H
+#include "model.h"
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+
+    template <typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(const DEVICE& device, nn_models::RandomUniform<SPEC>){ }
+    template <typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(const DEVICE& device, nn_models::RandomUniform<SPEC>){ }
+    template <typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(const DEVICE& device, nn_models::random_uniform::State){ }
+    template <typename SOURCE_DEVICE, typename TARGET_DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy(SOURCE_DEVICE& source_device, TARGET_DEVICE& target_device, nn_models::random_uniform::State& source, nn_models::random_uniform::State& target){}
+    template <typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(const DEVICE& device, nn_models::random_uniform::State){ }
+    template <typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(const DEVICE& device, nn_models::random_uniform::Buffer){ }
+    template <typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(const DEVICE& device, nn_models::random_uniform::Buffer){ }
+
+    template <typename DEVICE, typename SPEC, typename RNG, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT void reset(DEVICE& device, const nn_models::RandomUniform<SPEC>& model, nn_models::random_uniform::State& state, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}){ }
+
+    template <typename DEVICE, typename SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC, typename RNG, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT void evaluate(const DEVICE& device, nn_models::RandomUniform<SPEC>, Matrix<INPUT_SPEC>& input, Matrix<OUTPUT_SPEC>& output, nn_models::random_uniform::Buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        static_assert(SPEC::OUTPUT_DIM == OUTPUT_SPEC::COLS, "Output dimension mismatch");
+        static_assert(SPEC::INPUT_DIM == INPUT_SPEC::COLS, "Input dimension mismatch");
+        using T = typename SPEC::TYPE_POLICY::DEFAULT;
+        using TI = typename SPEC::TI;
+        for(TI row_i = 0; row_i < OUTPUT_SPEC::ROWS; row_i++){
+            for(TI col_i = 0; col_i < OUTPUT_SPEC::COLS; col_i++){
+                T value = 0;
+                if(SPEC::RANGE == nn_models::random_uniform::Range::MINUS_ONE_TO_ONE){
+                    value = random::uniform_real_distribution(device.random, (T)-1, (T)1, rng);
+                }else if(SPEC::RANGE == nn_models::random_uniform::Range::ZERO_TO_ONE){
+                    value = random::uniform_real_distribution(device.random, (T)0, (T)1, rng);
+                }
+                set(output, row_i, col_i, value);
+            }
+        }
+    }
+    template<typename DEVICE, typename MODULE_SPEC, typename MODE>
+    RL_TOOLS_FUNCTION_PLACEMENT bool is_nan(DEVICE& device, nn_models::RandomUniform<MODULE_SPEC>& model, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        return false;
+    }
+    template<typename DEVICE, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT bool is_nan(DEVICE& device, nn_models::random_uniform::State& state, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        return false;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+// Tensor proxies
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEVICE, typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC, typename RNG, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT void evaluate(DEVICE& device, const nn_models::RandomUniform<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<OUTPUT_SPEC>& output, nn_models::random_uniform::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        auto matrix_view_input = matrix_view(device, input);
+        auto matrix_view_output = matrix_view(device, output);
+        evaluate(device, layer, matrix_view_input, matrix_view_output, buffer, rng, mode);
+    }
+    template<typename DEVICE, typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC, typename RNG, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT void evaluate_step(DEVICE& device, const nn_models::RandomUniform<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, nn_models::random_uniform::State&, Tensor<OUTPUT_SPEC>& output, nn_models::random_uniform::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        auto matrix_view_input = matrix_view(device, input);
+        auto matrix_view_output = matrix_view(device, output);
+        evaluate(device, layer, matrix_view_input, matrix_view_output, buffer, rng, mode);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/nn_models/resnet/resnet.h

@@ -0,0 +1,97 @@
+#pragma once
+// ======================== ResNet-18 Model Definition ========================
+// Shared between the inference executable and the test suite.
+// Uses timm/resnet18.a1_in1k architecture: stem → maxpool → 4 layer groups → avgpool → fc
+
+#include <rl_tools/nn/layers/conv2d/layer.h>
+#include <rl_tools/nn/layers/max_pool2d/layer.h>
+#include <rl_tools/nn/layers/avg_pool2d/layer.h>
+#include <rl_tools/nn/layers/resnet_block/layer.h>
+#include <rl_tools/nn/layers/dense/layer.h>
+#include <rl_tools/nn_models/sequential/model.h>
+
+namespace rl_tools::nn_models::sequential {
+    namespace detail {
+        template <int N, typename REMAINING, typename ACC>
+        struct TakeFirstImpl;
+        template <typename HEAD, typename... TAIL, typename... ACC>
+        struct TakeFirstImpl<0, Module<HEAD, TAIL...>, Module<ACC...>> {
+            using type = Module<ACC...>;
+        };
+        template <typename... ACC>
+        struct TakeFirstImpl<0, Module<>, Module<ACC...>> {
+            using type = Module<ACC...>;
+        };
+        template <int N, typename HEAD, typename... TAIL, typename... ACC>
+        struct TakeFirstImpl<N, Module<HEAD, TAIL...>, Module<ACC...>> {
+            static_assert(N > 0);
+            using type = typename TakeFirstImpl<N-1, Module<TAIL...>, Module<ACC..., HEAD>>::type;
+        };
+    }
+    template <int N, typename MODULE>
+    using TakeFirst = typename detail::TakeFirstImpl<N, MODULE, Module<>>::type;
+}
+
+namespace rl_tools::nn_models::resnet18 {
+    // Stem: 7x7 conv, stride=2, pad=3, 64 channels, BN+ReLU
+    template<typename TYPE_POLICY, typename TI>
+    using STEM_CONV_CONFIG = nn::layers::conv2d::Configuration<
+        TYPE_POLICY, TI, 64, 7, 7, 2, 2, 3, 3,
+        nn::activation_functions::ActivationFunction::RELU,
+        nn::layers::conv2d::Normalization::BATCH_NORM>;
+
+    // MaxPool: 3x3, stride=2, pad=1
+    template<typename TYPE_POLICY, typename TI>
+    using MAXPOOL_CONFIG = nn::layers::max_pool2d::Configuration<TYPE_POLICY, TI, 3, 3, 2, 2, 1, 1>;
+
+    // ResNet blocks
+    template<typename TYPE_POLICY, typename TI>
+    using BLOCK_64_S1_CONFIG  = nn::layers::resnet_block::Configuration<TYPE_POLICY, TI,  64, 1>;
+    template<typename TYPE_POLICY, typename TI>
+    using BLOCK_128_S2_CONFIG = nn::layers::resnet_block::Configuration<TYPE_POLICY, TI, 128, 2>;
+    template<typename TYPE_POLICY, typename TI>
+    using BLOCK_128_S1_CONFIG = nn::layers::resnet_block::Configuration<TYPE_POLICY, TI, 128, 1>;
+    template<typename TYPE_POLICY, typename TI>
+    using BLOCK_256_S2_CONFIG = nn::layers::resnet_block::Configuration<TYPE_POLICY, TI, 256, 2>;
+    template<typename TYPE_POLICY, typename TI>
+    using BLOCK_256_S1_CONFIG = nn::layers::resnet_block::Configuration<TYPE_POLICY, TI, 256, 1>;
+    template<typename TYPE_POLICY, typename TI>
+    using BLOCK_512_S2_CONFIG = nn::layers::resnet_block::Configuration<TYPE_POLICY, TI, 512, 2>;
+    template<typename TYPE_POLICY, typename TI>
+    using BLOCK_512_S1_CONFIG = nn::layers::resnet_block::Configuration<TYPE_POLICY, TI, 512, 1>;
+
+    // Global average pool
+    template<typename TYPE_POLICY, typename TI>
+    using AVGPOOL_CONFIG = nn::layers::avg_pool2d::Configuration<TYPE_POLICY, TI>;
+
+    // FC: 512 -> 1000, identity activation
+    template<typename TYPE_POLICY, typename TI>
+    using FC_CONFIG = nn::layers::dense::Configuration<TYPE_POLICY, TI, 1000,
+        nn::activation_functions::ActivationFunction::IDENTITY>;
+
+    template<typename TYPE_POLICY, typename TI>
+    using MODULE_CHAIN = nn_models::sequential::Module<
+        nn::layers::conv2d::BindConfiguration<STEM_CONV_CONFIG<TYPE_POLICY, TI>>,           // 0: stem
+        nn::layers::max_pool2d::BindConfiguration<MAXPOOL_CONFIG<TYPE_POLICY, TI>>,         // 1: maxpool
+        nn::layers::resnet_block::BindConfiguration<BLOCK_64_S1_CONFIG<TYPE_POLICY, TI>>,   // 2: layer1.0
+        nn::layers::resnet_block::BindConfiguration<BLOCK_64_S1_CONFIG<TYPE_POLICY, TI>>,   // 3: layer1.1
+        nn::layers::resnet_block::BindConfiguration<BLOCK_128_S2_CONFIG<TYPE_POLICY, TI>>,  // 4: layer2.0
+        nn::layers::resnet_block::BindConfiguration<BLOCK_128_S1_CONFIG<TYPE_POLICY, TI>>,  // 5: layer2.1
+        nn::layers::resnet_block::BindConfiguration<BLOCK_256_S2_CONFIG<TYPE_POLICY, TI>>,  // 6: layer3.0
+        nn::layers::resnet_block::BindConfiguration<BLOCK_256_S1_CONFIG<TYPE_POLICY, TI>>,  // 7: layer3.1
+        nn::layers::resnet_block::BindConfiguration<BLOCK_512_S2_CONFIG<TYPE_POLICY, TI>>,  // 8: layer4.0
+        nn::layers::resnet_block::BindConfiguration<BLOCK_512_S1_CONFIG<TYPE_POLICY, TI>>,  // 9: layer4.1
+        nn::layers::avg_pool2d::BindConfiguration<AVGPOOL_CONFIG<TYPE_POLICY, TI>>,         // 10: avgpool
+        nn::layers::dense::BindConfiguration<FC_CONFIG<TYPE_POLICY, TI>>                    // 11: fc
+    >;
+
+    template<typename TYPE_POLICY, typename TI>
+    using INPUT_SHAPE = tensor::Shape<TI, 1, 224, 224, 3>;
+
+    template<typename TYPE_POLICY, typename TI, typename CAPABILITY>
+    using MODEL = nn_models::sequential::Build<CAPABILITY, MODULE_CHAIN<TYPE_POLICY, TI>, INPUT_SHAPE<TYPE_POLICY, TI>>;
+
+    // ImageNet normalization constants
+    static constexpr double IMAGENET_MEAN[3] = {0.485, 0.456, 0.406};
+    static constexpr double IMAGENET_STD[3]  = {0.229, 0.224, 0.225};
+}