hyperray 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/nn/layers/max_pool2d/operations_generic.h

@@ -0,0 +1,216 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_MAX_POOL2D_OPERATIONS_GENERIC_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_MAX_POOL2D_OPERATIONS_GENERIC_H
+#include "layer.h"
+#include "../../../rl_tools.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    // ======================== malloc / free ========================
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, nn::layers::max_pool2d::LayerForward<SPEC>& layer) {}
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, nn::layers::max_pool2d::LayerForward<SPEC>& layer) {}
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, nn::layers::max_pool2d::LayerBackward<SPEC>& layer) {}
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, nn::layers::max_pool2d::LayerBackward<SPEC>& layer) {}
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, nn::layers::max_pool2d::LayerGradient<SPEC>& layer) {
+        malloc(device, layer.output);
+    }
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, nn::layers::max_pool2d::LayerGradient<SPEC>& layer) {
+        free(device, layer.output);
+    }
+    template<typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, nn::layers::max_pool2d::State&) {}
+    template<typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, nn::layers::max_pool2d::State&) {}
+    template<typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, nn::layers::max_pool2d::Buffer&) {}
+    template<typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, nn::layers::max_pool2d::Buffer&) {}
+    template<typename SOURCE_DEVICE, typename TARGET_DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy(SOURCE_DEVICE&, TARGET_DEVICE&, nn::layers::max_pool2d::State&, nn::layers::max_pool2d::State&) {}
+    template<typename SPEC, typename DEVICE, typename RNG, typename MODE>
+    RL_TOOLS_FUNCTION_PLACEMENT void reset(DEVICE&, const nn::layers::max_pool2d::LayerForward<SPEC>&, nn::layers::max_pool2d::State&, RNG&, Mode<MODE>) {}
+
+    // ======================== init_weights (no-op) ========================
+    template<typename DEVICE, typename SPEC, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT void init_weights(DEVICE& device, nn::layers::max_pool2d::LayerForward<SPEC>& layer, RNG& rng) {}
+
+    // ======================== evaluate ========================
+#ifndef RL_TOOLS_NN_DISABLE_GENERIC_FORWARD_BACKWARD
+    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::layers::max_pool2d::LayerForward<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<OUTPUT_SPEC>& output, nn::layers::max_pool2d::Buffer&, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        static_assert(nn::layers::max_pool2d::check_input_output<LAYER_SPEC, INPUT_SPEC, OUTPUT_SPEC>);
+        using TI = typename DEVICE::index_t;
+        using T = typename OUTPUT_SPEC::T;
+        constexpr TI BATCH_SIZE = LAYER_SPEC::INTERNAL_BATCH_SIZE;
+        using INTERNAL_INPUT_SHAPE = tensor::Shape<TI, BATCH_SIZE, LAYER_SPEC::INPUT_HEIGHT, LAYER_SPEC::INPUT_WIDTH, LAYER_SPEC::INPUT_CHANNELS>;
+        using INTERNAL_OUTPUT_SHAPE = tensor::Shape<TI, BATCH_SIZE, LAYER_SPEC::OUTPUT_HEIGHT, LAYER_SPEC::OUTPUT_WIDTH, LAYER_SPEC::OUTPUT_CHANNELS>;
+        auto input_4d = view_memory<INTERNAL_INPUT_SHAPE>(device, input);
+        auto output_4d = view_memory<INTERNAL_OUTPUT_SHAPE>(device, output);
+        for(TI bi = 0; bi < BATCH_SIZE; bi++){
+            for(TI oh = 0; oh < LAYER_SPEC::OUTPUT_HEIGHT; oh++){
+                for(TI ow = 0; ow < LAYER_SPEC::OUTPUT_WIDTH; ow++){
+                    for(TI c = 0; c < LAYER_SPEC::OUTPUT_CHANNELS; c++){
+                        bool first = true;
+                        T max_val = 0;
+                        for(TI kh = 0; kh < LAYER_SPEC::KERNEL_HEIGHT; kh++){
+                            for(TI kw = 0; kw < LAYER_SPEC::KERNEL_WIDTH; kw++){
+                                TI ih_padded = oh * LAYER_SPEC::STRIDE_H + kh;
+                                TI iw_padded = ow * LAYER_SPEC::STRIDE_W + kw;
+                                if(ih_padded >= LAYER_SPEC::PADDING_H && ih_padded < LAYER_SPEC::INPUT_HEIGHT + LAYER_SPEC::PADDING_H &&
+                                   iw_padded >= LAYER_SPEC::PADDING_W && iw_padded < LAYER_SPEC::INPUT_WIDTH + LAYER_SPEC::PADDING_W){
+                                    TI ih = ih_padded - LAYER_SPEC::PADDING_H;
+                                    TI iw = iw_padded - LAYER_SPEC::PADDING_W;
+                                    T val = get(device, input_4d, bi, ih, iw, c);
+                                    if(first || val > max_val){
+                                        max_val = val;
+                                        first = false;
+                                    }
+                                }
+                            }
+                        }
+                        set(device, output_4d, max_val, bi, oh, ow, c);
+                    }
+                }
+            }
+        }
+    }
+
+    template<typename DEVICE, typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC, typename RNG, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT void forward(DEVICE& device, nn::layers::max_pool2d::LayerBackward<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<OUTPUT_SPEC>& output, nn::layers::max_pool2d::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        evaluate(device, static_cast<const nn::layers::max_pool2d::LayerForward<LAYER_SPEC>&>(layer), input, output, buffer, rng, mode);
+    }
+#endif
+    template<typename DEVICE, typename LAYER_SPEC, typename INPUT_SPEC, typename RNG, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT void forward(DEVICE& device, nn::layers::max_pool2d::LayerGradient<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, nn::layers::max_pool2d::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        forward(device, static_cast<nn::layers::max_pool2d::LayerBackward<LAYER_SPEC>&>(layer), input, layer.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 forward(DEVICE& device, nn::layers::max_pool2d::LayerGradient<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<OUTPUT_SPEC>& output, nn::layers::max_pool2d::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        forward(device, layer, input, buffer, rng, mode);
+        copy(device, device, layer.output, output);
+    }
+
+    // ======================== backward ========================
+    template<typename DEVICE, typename LAYER_SPEC, typename D_OUTPUT_SPEC, typename D_INPUT_SPEC, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT void backward_input(DEVICE& device, const nn::layers::max_pool2d::LayerBackward<LAYER_SPEC>& layer, const Tensor<D_OUTPUT_SPEC>& d_output, Tensor<D_INPUT_SPEC>& d_input, nn::layers::max_pool2d::Buffer&, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        // Max pool has no stored pre_activations; we need the input to find which element was max.
+        // This version is unused directly; backward_full provides the input.
+    }
+    template<typename DEVICE, typename LAYER_SPEC, typename INPUT_SPEC, typename D_OUTPUT_SPEC, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT void backward(DEVICE& device, nn::layers::max_pool2d::LayerGradient<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<D_OUTPUT_SPEC>& d_output, nn::layers::max_pool2d::Buffer&, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        // No parameters to accumulate gradients for
+    }
+    template<typename DEVICE, typename LAYER_SPEC, typename INPUT_SPEC, typename D_OUTPUT_SPEC, typename D_INPUT_SPEC, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT void backward_full(DEVICE& device, nn::layers::max_pool2d::LayerGradient<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<D_OUTPUT_SPEC>& d_output, Tensor<D_INPUT_SPEC>& d_input, nn::layers::max_pool2d::Buffer&, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        using TI = typename DEVICE::index_t;
+        using T = typename D_OUTPUT_SPEC::T;
+        constexpr TI BATCH_SIZE = LAYER_SPEC::INTERNAL_BATCH_SIZE;
+        using INTERNAL_INPUT_SHAPE = tensor::Shape<TI, BATCH_SIZE, LAYER_SPEC::INPUT_HEIGHT, LAYER_SPEC::INPUT_WIDTH, LAYER_SPEC::INPUT_CHANNELS>;
+        using INTERNAL_OUTPUT_SHAPE = tensor::Shape<TI, BATCH_SIZE, LAYER_SPEC::OUTPUT_HEIGHT, LAYER_SPEC::OUTPUT_WIDTH, LAYER_SPEC::OUTPUT_CHANNELS>;
+        using INTERNAL_D_INPUT_SHAPE = INTERNAL_INPUT_SHAPE;
+        auto input_4d = view_memory<INTERNAL_INPUT_SHAPE>(device, input);
+        auto d_output_4d = view_memory<INTERNAL_OUTPUT_SHAPE>(device, d_output);
+        auto d_input_4d = view_memory<INTERNAL_D_INPUT_SHAPE>(device, d_input);
+        set_all(device, d_input_4d, (T)0);
+        for(TI bi = 0; bi < BATCH_SIZE; bi++){
+            for(TI oh = 0; oh < LAYER_SPEC::OUTPUT_HEIGHT; oh++){
+                for(TI ow = 0; ow < LAYER_SPEC::OUTPUT_WIDTH; ow++){
+                    for(TI c = 0; c < LAYER_SPEC::OUTPUT_CHANNELS; c++){
+                        // Find the max element position
+                        bool first = true;
+                        T max_val = 0;
+                        TI max_ih = 0, max_iw = 0;
+                        for(TI kh = 0; kh < LAYER_SPEC::KERNEL_HEIGHT; kh++){
+                            for(TI kw = 0; kw < LAYER_SPEC::KERNEL_WIDTH; kw++){
+                                TI ih_padded = oh * LAYER_SPEC::STRIDE_H + kh;
+                                TI iw_padded = ow * LAYER_SPEC::STRIDE_W + kw;
+                                if(ih_padded >= LAYER_SPEC::PADDING_H && ih_padded < LAYER_SPEC::INPUT_HEIGHT + LAYER_SPEC::PADDING_H &&
+                                   iw_padded >= LAYER_SPEC::PADDING_W && iw_padded < LAYER_SPEC::INPUT_WIDTH + LAYER_SPEC::PADDING_W){
+                                    TI ih = ih_padded - LAYER_SPEC::PADDING_H;
+                                    TI iw = iw_padded - LAYER_SPEC::PADDING_W;
+                                    T val = get(device, input_4d, bi, ih, iw, c);
+                                    if(first || val > max_val){
+                                        max_val = val;
+                                        max_ih = ih;
+                                        max_iw = iw;
+                                        first = false;
+                                    }
+                                }
+                            }
+                        }
+                        // Route gradient to the max element
+                        increment(device, d_input_4d, get(device, d_output_4d, bi, oh, ow, c), bi, max_ih, max_iw, c);
+                    }
+                }
+            }
+        }
+    }
+
+    // ======================== zero_gradient / update / _reset_optimizer_state (no-ops) ========================
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void zero_gradient(DEVICE& device, nn::layers::max_pool2d::LayerGradient<SPEC>& layer) {}
+    template<typename DEVICE, typename SOURCE_SPEC, typename TARGET_SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void add_gradient(DEVICE& device, nn::layers::max_pool2d::LayerGradient<SOURCE_SPEC>& source, nn::layers::max_pool2d::LayerGradient<TARGET_SPEC>& target) {}
+    template<typename SOURCE_DEVICE, typename TARGET_DEVICE, typename SOURCE_SPEC, typename TARGET_SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy_gradient(SOURCE_DEVICE& source_device, TARGET_DEVICE& target_device, const nn::layers::max_pool2d::LayerGradient<SOURCE_SPEC>& source, nn::layers::max_pool2d::LayerGradient<TARGET_SPEC>& target) {}
+    template<typename DEVICE, typename SPEC, typename OPTIMIZER>
+    RL_TOOLS_FUNCTION_PLACEMENT void update(DEVICE& device, nn::layers::max_pool2d::LayerGradient<SPEC>& layer, OPTIMIZER& optimizer) {}
+    template<typename DEVICE, typename SPEC, typename OPTIMIZER>
+    RL_TOOLS_FUNCTION_PLACEMENT void _reset_optimizer_state(DEVICE& device, nn::layers::max_pool2d::LayerGradient<SPEC>& layer, OPTIMIZER& optimizer) {}
+
+    // ======================== copy ========================
+    template<typename SOURCE_DEVICE, typename TARGET_DEVICE, typename SOURCE_SPEC, typename TARGET_SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy(SOURCE_DEVICE& source_device, TARGET_DEVICE& target_device, const nn::layers::max_pool2d::LayerForward<SOURCE_SPEC>& source, nn::layers::max_pool2d::LayerForward<TARGET_SPEC>& target) {
+        static_assert(nn::layers::max_pool2d::check_spec_memory<SOURCE_SPEC, TARGET_SPEC>);
+    }
+    template<typename SOURCE_DEVICE, typename TARGET_DEVICE, typename SOURCE_SPEC, typename TARGET_SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy(SOURCE_DEVICE& source_device, TARGET_DEVICE& target_device, const nn::layers::max_pool2d::LayerBackward<SOURCE_SPEC>& source, nn::layers::max_pool2d::LayerBackward<TARGET_SPEC>& target) {
+        static_assert(nn::layers::max_pool2d::check_spec_memory<SOURCE_SPEC, TARGET_SPEC>);
+    }
+    template<typename SOURCE_DEVICE, typename TARGET_DEVICE, typename SOURCE_SPEC, typename TARGET_SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy(SOURCE_DEVICE& source_device, TARGET_DEVICE& target_device, const nn::layers::max_pool2d::LayerGradient<SOURCE_SPEC>& source, nn::layers::max_pool2d::LayerGradient<TARGET_SPEC>& target) {
+        static_assert(nn::layers::max_pool2d::check_spec_memory<SOURCE_SPEC, TARGET_SPEC>);
+        copy(source_device, target_device, source.output, target.output);
+    }
+
+    // ======================== abs_diff ========================
+    template<typename DEVICE, typename S1, typename S2>
+    RL_TOOLS_FUNCTION_PLACEMENT typename S1::TYPE_POLICY::DEFAULT abs_diff(DEVICE& device, const nn::layers::max_pool2d::LayerForward<S1>&, const nn::layers::max_pool2d::LayerForward<S2>&) { return 0; }
+    template<typename DEVICE, typename S1, typename S2>
+    RL_TOOLS_FUNCTION_PLACEMENT typename S1::TYPE_POLICY::DEFAULT abs_diff(DEVICE& device, const nn::layers::max_pool2d::LayerBackward<S1>&, const nn::layers::max_pool2d::LayerBackward<S2>&) { return 0; }
+    template<typename DEVICE, typename S1, typename S2>
+    RL_TOOLS_FUNCTION_PLACEMENT typename S1::TYPE_POLICY::DEFAULT abs_diff(DEVICE& device, const nn::layers::max_pool2d::LayerGradient<S1>& l1, const nn::layers::max_pool2d::LayerGradient<S2>& l2) { return abs_diff(device, l1.output, l2.output); }
+    template<typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT auto abs_diff(DEVICE& device, const nn::layers::max_pool2d::State&, const nn::layers::max_pool2d::State&) { return 0; }
+
+    // ======================== reset_forward_state ========================
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void reset_forward_state(DEVICE& device, nn::layers::max_pool2d::LayerBackward<SPEC>&) {}
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void reset_forward_state(DEVICE& device, nn::layers::max_pool2d::LayerGradient<SPEC>& l) { set_all(device, l.output, 0); }
+
+    // ======================== is_nan ========================
+    template<typename DEVICE, typename SPEC, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT bool is_nan(DEVICE&, const nn::layers::max_pool2d::LayerForward<SPEC>&, const Mode<MODE>& = Mode<mode::Default<>>{}) { return false; }
+    template<typename DEVICE, typename SPEC, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT bool is_nan(DEVICE&, const nn::layers::max_pool2d::LayerBackward<SPEC>&, const Mode<MODE>& = Mode<mode::Default<>>{}) { return false; }
+    template<typename DEVICE, typename SPEC, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT bool is_nan(DEVICE& device, const nn::layers::max_pool2d::LayerGradient<SPEC>& l, const Mode<MODE>& mode = Mode<mode::Default<>>{}) { return is_nan(device, l.output, mode); }
+    template<typename DEVICE, typename MODE = mode::Default<>>
+    RL_TOOLS_FUNCTION_PLACEMENT bool is_nan(DEVICE&, nn::layers::max_pool2d::State&, const Mode<MODE>& = Mode<mode::Default<>>{}) { return false; }
+
+    // ======================== output ========================
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT auto output(DEVICE& device, nn::layers::max_pool2d::LayerGradient<SPEC>& l){
+        return view_memory<typename SPEC::OUTPUT_SHAPE>(device, l.output);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,39 @@
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_MAX_POOL2D_PERSIST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_MAX_POOL2D_PERSIST_H
+#include "../../../version.h"
+#include "layer.h"
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    void save(DEVICE& device, nn::layers::max_pool2d::LayerForward<SPEC>& layer, GROUP& group) {
+        set_attribute(device, group, "type", "max_pool2d");
+        set_attribute(device, group, "kernel_height", std::to_string(SPEC::CONFIG::KERNEL_HEIGHT).c_str());
+        set_attribute(device, group, "kernel_width", std::to_string(SPEC::CONFIG::KERNEL_WIDTH).c_str());
+        set_attribute(device, group, "stride_h", std::to_string(SPEC::CONFIG::STRIDE_H).c_str());
+        set_attribute(device, group, "stride_w", std::to_string(SPEC::CONFIG::STRIDE_W).c_str());
+        set_attribute(device, group, "padding_h", std::to_string(SPEC::CONFIG::PADDING_H).c_str());
+        set_attribute(device, group, "padding_w", std::to_string(SPEC::CONFIG::PADDING_W).c_str());
+        write_attributes(device, group);
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    void save(DEVICE& device, nn::layers::max_pool2d::LayerBackward<SPEC>& layer, GROUP& group) {
+        save(device, (nn::layers::max_pool2d::LayerForward<SPEC>&)layer, group);
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    void save(DEVICE& device, nn::layers::max_pool2d::LayerGradient<SPEC>& layer, GROUP& group) {
+        save(device, (nn::layers::max_pool2d::LayerBackward<SPEC>&)layer, group);
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn::layers::max_pool2d::LayerForward<SPEC>& layer, GROUP& group) { return true; }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn::layers::max_pool2d::LayerBackward<SPEC>& layer, GROUP& group) { return true; }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn::layers::max_pool2d::LayerGradient<SPEC>& layer, GROUP& group) { return true; }
+    template<typename DEVICE, typename GROUP>
+    void save(DEVICE& device, nn::layers::max_pool2d::State& state, GROUP& group) {}
+    template<typename DEVICE, typename GROUP>
+    bool load(DEVICE& device, nn::layers::max_pool2d::State& state, GROUP& group) { return true; }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1 @@
+#include "dense/operations_cpu.h"

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

@@ -0,0 +1 @@
+#include "dense/operations_cpu_accelerate.h"

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

@@ -0,0 +1 @@
+#include "dense/operations_cpu_blas.h"

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

@@ -0,0 +1,3 @@
+#include "dense/operations_cpu_mkl.h"
+#include "conv2d/operations_cpu_mkl.h"
+#include "gru/operations_generic.h"

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

@@ -0,0 +1 @@
+#include "dense/operations_cpu_openblas.h"

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

@@ -0,0 +1,9 @@
+#include "dense/operations_cuda.h"
+#include "upsample2d/operations_cuda.h"
+#include "dynamic_conv2d/operations_cuda.h"
+#ifdef RL_TOOLS_BACKEND_ENABLE_CUDNN
+#include "conv2d/operations_cuda.h"
+#include "max_pool2d/operations_cuda.h"
+#include "avg_pool2d/operations_cuda.h"
+#include "resnet_block/operations_cuda.h"
+#endif

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

@@ -0,0 +1 @@
+#include "dense/operations_dummy.h"

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

@@ -0,0 +1,3 @@
+#include "dense/operations_generic.h"
+#include "gru/operations_generic.h"
+#include "conv2d/operations_generic.h"

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

@@ -0,0 +1,223 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_RESNET_BLOCK_LAYER_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_RESNET_BLOCK_LAYER_H
+#include "../../../utils/generic/typing.h"
+#include "../../../containers/tensor/tensor.h"
+#include "../../../nn/capability/capability.h"
+#include "../../../nn/parameters/parameters.h"
+#include "../conv2d/layer.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::nn::layers::resnet_block {
+
+    template<typename T_TYPE_POLICY, typename T_TI,
+             T_TI T_OUTPUT_CHANNELS,
+             T_TI T_STRIDE = 1,
+             typename T_PARAMETER_GROUP = parameters::groups::Normal>
+    struct Configuration{
+        using TYPE_POLICY = T_TYPE_POLICY;
+        using TI = T_TI;
+        static constexpr TI OUTPUT_CHANNELS = T_OUTPUT_CHANNELS;
+        static constexpr TI STRIDE = T_STRIDE;
+        using PARAMETER_GROUP = T_PARAMETER_GROUP;
+    };
+
+    // Conditional downsample storage (parameterized on the conv layer type, not just the spec)
+    template<bool HAS_DOWNSAMPLE, typename CONV_LAYER>
+    struct DownsampleStorage {};
+
+    template<typename CONV_LAYER>
+    struct DownsampleStorage<true, CONV_LAYER> {
+        CONV_LAYER conv;
+    };
+
+    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, "ResnetBlock input must have >= 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 TI OUTPUT_CHANNELS = CONFIG::OUTPUT_CHANNELS;
+        static constexpr TI STRIDE = CONFIG::STRIDE;
+
+        // Block output spatial dims (determined by first conv: 3x3, stride=STRIDE, pad=1)
+        static constexpr TI OUTPUT_HEIGHT = (INPUT_HEIGHT + 2 - 3) / STRIDE + 1;
+        static constexpr TI OUTPUT_WIDTH = (INPUT_WIDTH + 2 - 3) / STRIDE + 1;
+        static constexpr bool HAS_DOWNSAMPLE = (INPUT_CHANNELS != OUTPUT_CHANNELS) || (STRIDE != 1);
+
+        static constexpr TI INTERNAL_BATCH_SIZE = tensor::shape_math::leading_product(tensor::shape_math::element_to_array<INPUT_SHAPE>(), 3);
+
+        // Conv1: 3x3, stride=STRIDE, pad=1, BN + ReLU
+        using CONV1_CONFIG = conv2d::Configuration<TYPE_POLICY, TI, OUTPUT_CHANNELS, 3, 3, STRIDE, STRIDE, 1, 1,
+            nn::activation_functions::ActivationFunction::RELU,
+            conv2d::Normalization::BATCH_NORM,
+            conv2d::DefaultInitializer<TYPE_POLICY, TI>,
+            typename CONFIG::PARAMETER_GROUP>;
+        using CONV1_SPEC = conv2d::Specification<CONV1_CONFIG, T_CAPABILITY, INPUT_SHAPE>;
+
+        // Conv2: 3x3, stride=1, pad=1, BN + IDENTITY (no activation before skip)
+        using CONV1_OUTPUT_SHAPE = typename CONV1_SPEC::OUTPUT_SHAPE;
+        using CONV2_CONFIG = conv2d::Configuration<TYPE_POLICY, TI, OUTPUT_CHANNELS, 3, 3, 1, 1, 1, 1,
+            nn::activation_functions::ActivationFunction::IDENTITY,
+            conv2d::Normalization::BATCH_NORM,
+            conv2d::DefaultInitializer<TYPE_POLICY, TI>,
+            typename CONFIG::PARAMETER_GROUP>;
+        using CONV2_SPEC = conv2d::Specification<CONV2_CONFIG, T_CAPABILITY, CONV1_OUTPUT_SHAPE>;
+
+        // Downsample: 1x1, stride=STRIDE, pad=0, BN + IDENTITY
+        using DOWNSAMPLE_CONFIG = conv2d::Configuration<TYPE_POLICY, TI, OUTPUT_CHANNELS, 1, 1, STRIDE, STRIDE, 0, 0,
+            nn::activation_functions::ActivationFunction::IDENTITY,
+            conv2d::Normalization::BATCH_NORM,
+            conv2d::DefaultInitializer<TYPE_POLICY, TI>,
+            typename CONFIG::PARAMETER_GROUP>;
+        using DOWNSAMPLE_SPEC = conv2d::Specification<DOWNSAMPLE_CONFIG, T_CAPABILITY, INPUT_SHAPE>;
+
+        // Helper: select conv2d layer type matching the outer capability
+        template <typename CONV_SPEC>
+        using ConvLayerType = typename utils::typing::conditional_t<T_CAPABILITY::TAG == nn::LayerCapability::Forward,
+            conv2d::LayerForward<CONV_SPEC>,
+            typename utils::typing::conditional_t<T_CAPABILITY::TAG == nn::LayerCapability::Backward,
+                conv2d::LayerBackward<CONV_SPEC>,
+                conv2d::LayerGradient<CONV_SPEC>>>;
+
+        using CONV1_LAYER = ConvLayerType<CONV1_SPEC>;
+        using CONV2_LAYER = ConvLayerType<CONV2_SPEC>;
+        using DOWNSAMPLE_LAYER = ConvLayerType<DOWNSAMPLE_SPEC>;
+
+        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 - 3) / STRIDE + 1;
+            static constexpr TI NEW_OW = (NEW_W + 2 - 3) / STRIDE + 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 = tensor::Replace<SHAPE_WIDTH, OUTPUT_CHANNELS, length(NEW_INPUT_SHAPE{}) - 1>;
+        };
+        using OUTPUT_SHAPE = typename OUTPUT_SHAPE_FACTORY<INPUT_SHAPE>::SHAPE;
+
+        static constexpr TI NUM_WEIGHTS = CONV1_SPEC::NUM_WEIGHTS + CONV2_SPEC::NUM_WEIGHTS + (HAS_DOWNSAMPLE ? DOWNSAMPLE_SPEC::NUM_WEIGHTS : 0);
+    };
+
+    template<typename SPEC_1, typename SPEC_2>
+    constexpr bool check_spec_memory =
+        SPEC_1::INPUT_HEIGHT == SPEC_2::INPUT_HEIGHT
+        && SPEC_1::INPUT_WIDTH == SPEC_2::INPUT_WIDTH
+        && SPEC_1::INPUT_CHANNELS == SPEC_2::INPUT_CHANNELS
+        && SPEC_1::OUTPUT_CHANNELS == SPEC_2::OUTPUT_CHANNELS;
+
+    template<typename SPEC_1, typename SPEC_2>
+    constexpr bool check_spec =
+        check_spec_memory<SPEC_1, SPEC_2>
+        && SPEC_1::STRIDE == SPEC_2::STRIDE;
+
+    template <typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC>
+    constexpr bool check_input_output =
+        length(typename INPUT_SPEC::SHAPE{}) >= 4 &&
+        length(typename OUTPUT_SPEC::SHAPE{}) >= 4 &&
+        get<length(typename INPUT_SPEC::SHAPE{})-1>(typename INPUT_SPEC::SHAPE{}) == LAYER_SPEC::INPUT_CHANNELS &&
+        get<length(typename INPUT_SPEC::SHAPE{})-2>(typename INPUT_SPEC::SHAPE{}) == LAYER_SPEC::INPUT_WIDTH &&
+        get<length(typename INPUT_SPEC::SHAPE{})-3>(typename INPUT_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 T = typename SPEC::TYPE_POLICY::template GET<numeric_types::categories::Activation>;
+        using TI = typename SPEC::TI;
+        using INTERMEDIATE_SHAPE = tensor::Shape<TI, SPEC::INTERNAL_BATCH_SIZE, SPEC::OUTPUT_HEIGHT, SPEC::OUTPUT_WIDTH, SPEC::OUTPUT_CHANNELS>;
+        using INTERMEDIATE_SPEC = tensor::Specification<T, TI, INTERMEDIATE_SHAPE, DYNAMIC_ALLOCATION>;
+        Tensor<INTERMEDIATE_SPEC> intermediate;
+        using SHORTCUT_SHAPE = tensor::Shape<TI, SPEC::INTERNAL_BATCH_SIZE, SPEC::OUTPUT_HEIGHT, SPEC::OUTPUT_WIDTH, SPEC::OUTPUT_CHANNELS>;
+        using SHORTCUT_SPEC = tensor::Specification<T, TI, SHORTCUT_SHAPE, DYNAMIC_ALLOCATION>;
+        Tensor<SHORTCUT_SPEC> shortcut;
+        using D_INPUT_SHAPE = tensor::Shape<TI, SPEC::INTERNAL_BATCH_SIZE, SPEC::INPUT_HEIGHT, SPEC::INPUT_WIDTH, SPEC::INPUT_CHANNELS>;
+        using D_INPUT_SPEC = tensor::Specification<T, TI, D_INPUT_SHAPE, DYNAMIC_ALLOCATION>;
+        Tensor<D_INPUT_SPEC> d_input_buffer;
+        conv2d::Buffer<conv2d::BufferSpecification<typename SPEC::CONV1_SPEC, DYNAMIC_ALLOCATION>> conv1_buffer;
+        conv2d::Buffer<conv2d::BufferSpecification<typename SPEC::CONV2_SPEC, DYNAMIC_ALLOCATION>> conv2_buffer;
+        conv2d::Buffer<conv2d::BufferSpecification<typename SPEC::DOWNSAMPLE_SPEC, DYNAMIC_ALLOCATION>> downsample_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_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 NUM_WEIGHTS = SPEC::NUM_WEIGHTS;
+        static constexpr TI INTERNAL_BATCH_SIZE = SPEC::INTERNAL_BATCH_SIZE;
+        static constexpr bool HAS_DOWNSAMPLE = SPEC::HAS_DOWNSAMPLE;
+        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;
+
+        // Internal conv layers (matching the outer capability level)
+        typename SPEC::CONV1_LAYER conv1;
+        typename SPEC::CONV2_LAYER conv2;
+        DownsampleStorage<SPEC::HAS_DOWNSAMPLE, typename SPEC::DOWNSAMPLE_LAYER> downsample;
+
+        template<bool DYNAMIC_ALLOCATION=true>
+        using Buffer = resnet_block::Buffer<resnet_block::BufferSpecification<SPEC, DYNAMIC_ALLOCATION>>;
+        template<bool DYNAMIC_ALLOCATION=true>
+        using State = resnet_block::State;
+    };
+
+    template<typename SPEC>
+    struct LayerBackward: public LayerForward<SPEC>{};
+
+    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::resnet_block::Layer<CONFIG, CAPABILITY, INPUT_SHAPE>;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif