hyperverse 0.0.1__py3-none-any.whl

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

@@ -0,0 +1,122 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_UNFLATTEN_LAYER_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_UNFLATTEN_LAYER_H
+#include "../../../utils/generic/typing.h"
+#include "../../../containers/tensor/tensor.h"
+#include "../../../nn/capability/capability.h"
+#include "../../../nn/parameters/parameters.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::nn::layers::unflatten {
+
+    template<typename T_TYPE_POLICY, typename T_TI, T_TI T_HEIGHT, T_TI T_WIDTH, T_TI T_CHANNELS>
+    struct Configuration{
+        using TYPE_POLICY = T_TYPE_POLICY;
+        using TI = T_TI;
+        static constexpr TI HEIGHT = T_HEIGHT;
+        static constexpr TI WIDTH = T_WIDTH;
+        static constexpr TI CHANNELS = T_CHANNELS;
+    };
+
+    template <typename T_CONFIG, typename T_CAPABILITY, typename T_INPUT_SHAPE>
+    struct Specification: T_CAPABILITY, T_CONFIG{
+        using CONFIG = T_CONFIG;
+        using TYPE_POLICY = typename CONFIG::TYPE_POLICY;
+        using TI = typename CONFIG::TI;
+        using CAPABILITY = T_CAPABILITY;
+        using INPUT_SHAPE = T_INPUT_SHAPE;
+        static constexpr TI HEIGHT = CONFIG::HEIGHT;
+        static constexpr TI WIDTH = CONFIG::WIDTH;
+        static constexpr TI CHANNELS = CONFIG::CHANNELS;
+        static constexpr TI INPUT_DIM = HEIGHT * WIDTH * CHANNELS;
+        static_assert(length(INPUT_SHAPE{}) >= 2, "Unflatten input shape must have at least 2 dimensions (...BATCH x H*W*C)");
+        static_assert(get_last(INPUT_SHAPE{}) == INPUT_DIM, "Unflatten: last input dimension must equal H*W*C");
+
+        using BATCH_SHAPE = tensor::PopBack<INPUT_SHAPE>;
+        static constexpr TI INTERNAL_BATCH_SIZE = get<0>(tensor::CumulativeProduct<BATCH_SHAPE>{});
+
+        // Output shape: (...BATCH, H, W, C)
+        template <typename NEW_INPUT_SHAPE>
+        struct OUTPUT_SHAPE_FACTORY{
+            static_assert(length(NEW_INPUT_SHAPE{}) >= 2);
+            static_assert(get_last(NEW_INPUT_SHAPE{}) == INPUT_DIM);
+            using NEW_BATCH_SHAPE = tensor::PopBack<NEW_INPUT_SHAPE>;
+            using SHAPE = tensor::Append<tensor::Append<tensor::Append<NEW_BATCH_SHAPE, HEIGHT>, WIDTH>, CHANNELS>;
+        };
+        using OUTPUT_SHAPE = typename OUTPUT_SHAPE_FACTORY<INPUT_SHAPE>::SHAPE;
+        static constexpr TI NUM_WEIGHTS = 0;
+    };
+
+    template<typename SPEC_1, typename SPEC_2>
+    constexpr bool check_spec_memory =
+        SPEC_1::HEIGHT == SPEC_2::HEIGHT
+        && SPEC_1::WIDTH == SPEC_2::WIDTH
+        && SPEC_1::CHANNELS == SPEC_2::CHANNELS;
+
+    template<typename SPEC_1, typename SPEC_2>
+    constexpr bool check_spec = check_spec_memory<SPEC_1, SPEC_2>;
+
+    template <typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC>
+    constexpr bool check_input_output =
+        length(typename INPUT_SPEC::SHAPE{}) >= 2 &&
+        length(typename OUTPUT_SPEC::SHAPE{}) >= 4 &&
+        get_last(typename INPUT_SPEC::SHAPE{}) == LAYER_SPEC::INPUT_DIM &&
+        get<length(typename OUTPUT_SPEC::SHAPE{})-3>(typename OUTPUT_SPEC::SHAPE{}) == LAYER_SPEC::HEIGHT &&
+        get<length(typename OUTPUT_SPEC::SHAPE{})-2>(typename OUTPUT_SPEC::SHAPE{}) == LAYER_SPEC::WIDTH &&
+        get_last(typename OUTPUT_SPEC::SHAPE{}) == LAYER_SPEC::CHANNELS;
+
+    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 HEIGHT = SPEC::HEIGHT;
+        static constexpr TI WIDTH = SPEC::WIDTH;
+        static constexpr TI CHANNELS = SPEC::CHANNELS;
+        static constexpr TI INPUT_DIM = SPEC::INPUT_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;
+        template<bool DYNAMIC_ALLOCATION=true>
+        using Buffer = unflatten::Buffer;
+        template<bool DYNAMIC_ALLOCATION=true>
+        using State = unflatten::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::HEIGHT, SPEC::WIDTH, SPEC::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::unflatten::Layer<CONFIG, CAPABILITY, INPUT_SHAPE>;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,55 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_UNFLATTEN_OPERATIONS_CUDA_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_UNFLATTEN_OPERATIONS_CUDA_H
+#include "layer.h"
+#include <cuda_runtime.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::CUDA<DEV_SPEC>& device, const nn::layers::unflatten::LayerForward<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<OUTPUT_SPEC>& output, nn::layers::unflatten::Buffer&, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        static_assert(nn::layers::unflatten::check_input_output<LAYER_SPEC, INPUT_SPEC, OUTPUT_SPEC>);
+        static_assert(tensor::dense_row_major_layout<INPUT_SPEC>(), "Unflatten requires contiguous row-major input");
+        static_assert(tensor::dense_row_major_layout<OUTPUT_SPEC>(), "Unflatten requires contiguous row-major output");
+        using T = typename INPUT_SPEC::T;
+        constexpr auto TOTAL = product(typename INPUT_SPEC::SHAPE{});
+        cudaMemcpyAsync(data(output), data(input), TOTAL * sizeof(T), cudaMemcpyDeviceToDevice, device.stream);
+    }
+    template<typename DEV_SPEC, typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC, typename RNG, typename MODE = mode::Default<>>
+    void evaluate_step(devices::CUDA<DEV_SPEC>& device, const nn::layers::unflatten::LayerForward<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, nn::layers::unflatten::State& state, Tensor<OUTPUT_SPEC>& output, nn::layers::unflatten::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        evaluate(device, layer, input, output, buffer, rng, mode);
+    }
+    template<typename DEV_SPEC, typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC, typename RNG, typename MODE = mode::Default<>>
+    void forward(devices::CUDA<DEV_SPEC>& device, nn::layers::unflatten::LayerBackward<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<OUTPUT_SPEC>& output, nn::layers::unflatten::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        evaluate(device, static_cast<const nn::layers::unflatten::LayerForward<LAYER_SPEC>&>(layer), input, output, buffer, rng, mode);
+    }
+    template<typename DEV_SPEC, typename LAYER_SPEC, typename INPUT_SPEC, typename RNG, typename MODE = mode::Default<>>
+    void forward(devices::CUDA<DEV_SPEC>& device, nn::layers::unflatten::LayerGradient<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, nn::layers::unflatten::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        nn::layers::unflatten::Buffer buf;
+        forward(device, static_cast<nn::layers::unflatten::LayerBackward<LAYER_SPEC>&>(layer), input, layer.output, buf, rng, mode);
+    }
+    template<typename DEV_SPEC, typename LAYER_SPEC, typename INPUT_SPEC, typename OUTPUT_SPEC, typename RNG, typename MODE = mode::Default<>>
+    void forward(devices::CUDA<DEV_SPEC>& device, nn::layers::unflatten::LayerGradient<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<OUTPUT_SPEC>& output, nn::layers::unflatten::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        forward(device, layer, input, buffer, rng, mode);
+        copy(device, device, layer.output, output);
+    }
+    template<typename DEV_SPEC, typename LAYER_SPEC, typename D_OUTPUT_SPEC, typename D_INPUT_SPEC, typename MODE = mode::Default<>>
+    void backward_input(devices::CUDA<DEV_SPEC>& device, const nn::layers::unflatten::LayerBackward<LAYER_SPEC>& layer, const Tensor<D_OUTPUT_SPEC>& d_output, Tensor<D_INPUT_SPEC>& d_input, nn::layers::unflatten::Buffer&, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        static_assert(nn::layers::unflatten::check_input_output<LAYER_SPEC, D_INPUT_SPEC, D_OUTPUT_SPEC>);
+        static_assert(tensor::dense_row_major_layout<D_OUTPUT_SPEC>(), "Unflatten requires contiguous row-major d_output");
+        static_assert(tensor::dense_row_major_layout<D_INPUT_SPEC>(), "Unflatten requires contiguous row-major d_input");
+        using T = typename D_INPUT_SPEC::T;
+        constexpr auto TOTAL = product(typename D_INPUT_SPEC::SHAPE{});
+        cudaMemcpyAsync(data(d_input), data(d_output), TOTAL * sizeof(T), cudaMemcpyDeviceToDevice, device.stream);
+    }
+    template<typename DEV_SPEC, typename LAYER_SPEC, typename INPUT_SPEC, typename D_OUTPUT_SPEC, typename MODE = mode::Default<>>
+    void backward(devices::CUDA<DEV_SPEC>& device, nn::layers::unflatten::LayerGradient<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<D_OUTPUT_SPEC>& d_output, nn::layers::unflatten::Buffer&, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+    }
+    template<typename DEV_SPEC, typename LAYER_SPEC, typename INPUT_SPEC, typename D_OUTPUT_SPEC, typename D_INPUT_SPEC, typename MODE = mode::Default<>>
+    void backward_full(devices::CUDA<DEV_SPEC>& device, nn::layers::unflatten::LayerGradient<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<D_OUTPUT_SPEC>& d_output, Tensor<D_INPUT_SPEC>& d_input, nn::layers::unflatten::Buffer& buffer, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        backward_input(device, static_cast<const nn::layers::unflatten::LayerBackward<LAYER_SPEC>&>(layer), d_output, d_input, buffer, mode);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,160 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_UNFLATTEN_OPERATIONS_GENERIC_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_UNFLATTEN_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::unflatten::LayerForward<SPEC>& layer) {}
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, nn::layers::unflatten::LayerForward<SPEC>& layer) {}
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, nn::layers::unflatten::LayerBackward<SPEC>& layer) {}
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, nn::layers::unflatten::LayerBackward<SPEC>& layer) {}
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, nn::layers::unflatten::LayerGradient<SPEC>& layer) {
+        malloc(device, layer.output);
+    }
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, nn::layers::unflatten::LayerGradient<SPEC>& layer) {
+        free(device, layer.output);
+    }
+    template<typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, nn::layers::unflatten::State&) {}
+    template<typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, nn::layers::unflatten::State&) {}
+    template<typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, nn::layers::unflatten::Buffer&) {}
+    template<typename DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, nn::layers::unflatten::Buffer&) {}
+    template<typename SOURCE_DEVICE, typename TARGET_DEVICE>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy(SOURCE_DEVICE&, TARGET_DEVICE&, nn::layers::unflatten::State&, nn::layers::unflatten::State&) {}
+    template<typename SPEC, typename DEVICE, typename RNG, typename MODE>
+    RL_TOOLS_FUNCTION_PLACEMENT void reset(DEVICE&, const nn::layers::unflatten::LayerForward<SPEC>&, nn::layers::unflatten::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::unflatten::LayerForward<SPEC>& layer, RNG& rng) {}
+
+    // ======================== evaluate ========================
+    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::unflatten::LayerForward<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<OUTPUT_SPEC>& output, nn::layers::unflatten::Buffer&, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        static_assert(nn::layers::unflatten::check_input_output<LAYER_SPEC, INPUT_SPEC, OUTPUT_SPEC>);
+        static_assert(tensor::dense_row_major_layout<INPUT_SPEC>(), "Unflatten requires contiguous row-major input");
+        static_assert(tensor::dense_row_major_layout<OUTPUT_SPEC>(), "Unflatten requires contiguous row-major output");
+        using TI = typename DEVICE::index_t;
+        constexpr TI TOTAL = product(typename INPUT_SPEC::SHAPE{});
+        auto* src = data(input);
+        auto* dst = data(output);
+        for(TI i = 0; i < TOTAL; i++){
+            dst[i] = src[i];
+        }
+    }
+
+    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::layers::unflatten::LayerForward<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, nn::layers::unflatten::State& state, Tensor<OUTPUT_SPEC>& output, nn::layers::unflatten::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        evaluate(device, layer, input, 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::unflatten::LayerBackward<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<OUTPUT_SPEC>& output, nn::layers::unflatten::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        evaluate(device, static_cast<const nn::layers::unflatten::LayerForward<LAYER_SPEC>&>(layer), input, output, buffer, rng, mode);
+    }
+    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::unflatten::LayerGradient<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, nn::layers::unflatten::Buffer& buffer, RNG& rng, const Mode<MODE>& mode = Mode<mode::Default<>>{}) {
+        forward(device, static_cast<nn::layers::unflatten::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::unflatten::LayerGradient<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<OUTPUT_SPEC>& output, nn::layers::unflatten::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::unflatten::LayerBackward<LAYER_SPEC>& layer, const Tensor<D_OUTPUT_SPEC>& d_output, Tensor<D_INPUT_SPEC>& d_input, nn::layers::unflatten::Buffer&, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        static_assert(nn::layers::unflatten::check_input_output<LAYER_SPEC, D_INPUT_SPEC, D_OUTPUT_SPEC>);
+        static_assert(tensor::dense_row_major_layout<D_OUTPUT_SPEC>(), "Unflatten requires contiguous row-major d_output");
+        static_assert(tensor::dense_row_major_layout<D_INPUT_SPEC>(), "Unflatten requires contiguous row-major d_input");
+        using TI = typename DEVICE::index_t;
+        constexpr TI TOTAL = product(typename D_INPUT_SPEC::SHAPE{});
+        auto* src = data(d_output);
+        auto* dst = data(d_input);
+        for(TI i = 0; i < TOTAL; i++){
+            dst[i] = src[i];
+        }
+    }
+    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::unflatten::LayerGradient<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<D_OUTPUT_SPEC>& d_output, nn::layers::unflatten::Buffer&, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+    }
+    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::unflatten::LayerGradient<LAYER_SPEC>& layer, const Tensor<INPUT_SPEC>& input, Tensor<D_OUTPUT_SPEC>& d_output, Tensor<D_INPUT_SPEC>& d_input, nn::layers::unflatten::Buffer& buffer, const Mode<MODE>& mode = Mode<mode::Default<>>{}){
+        backward_input(device, static_cast<const nn::layers::unflatten::LayerBackward<LAYER_SPEC>&>(layer), d_output, d_input, buffer, mode);
+    }
+
+    // ======================== zero_gradient / update / _reset_optimizer_state (no-ops) ========================
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void zero_gradient(DEVICE& device, nn::layers::unflatten::LayerGradient<SPEC>& layer) {}
+    template<typename DEVICE, typename SOURCE_SPEC, typename TARGET_SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void add_gradient(DEVICE& device, nn::layers::unflatten::LayerGradient<SOURCE_SPEC>& source, nn::layers::unflatten::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::unflatten::LayerGradient<SOURCE_SPEC>& source, nn::layers::unflatten::LayerGradient<TARGET_SPEC>& target) {}
+    template<typename DEVICE, typename SPEC, typename OPTIMIZER>
+    RL_TOOLS_FUNCTION_PLACEMENT void update(DEVICE& device, nn::layers::unflatten::LayerGradient<SPEC>& layer, OPTIMIZER& optimizer) {}
+    template<typename DEVICE, typename SPEC, typename OPTIMIZER>
+    RL_TOOLS_FUNCTION_PLACEMENT void _reset_optimizer_state(DEVICE& device, nn::layers::unflatten::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::unflatten::LayerForward<SOURCE_SPEC>& source, nn::layers::unflatten::LayerForward<TARGET_SPEC>& target) {
+        static_assert(nn::layers::unflatten::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::unflatten::LayerBackward<SOURCE_SPEC>& source, nn::layers::unflatten::LayerBackward<TARGET_SPEC>& target) {
+        static_assert(nn::layers::unflatten::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::unflatten::LayerGradient<SOURCE_SPEC>& source, nn::layers::unflatten::LayerGradient<TARGET_SPEC>& target) {
+        static_assert(nn::layers::unflatten::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::unflatten::LayerForward<S1>&, const nn::layers::unflatten::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::unflatten::LayerBackward<S1>&, const nn::layers::unflatten::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::unflatten::LayerGradient<S1>& l1, const nn::layers::unflatten::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::unflatten::State&, const nn::layers::unflatten::State&) { return 0; }
+
+    // ======================== reset_forward_state ========================
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void reset_forward_state(DEVICE& device, nn::layers::unflatten::LayerBackward<SPEC>&) {}
+    template<typename DEVICE, typename SPEC>
+    RL_TOOLS_FUNCTION_PLACEMENT void reset_forward_state(DEVICE& device, nn::layers::unflatten::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::unflatten::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::unflatten::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::unflatten::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::unflatten::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::unflatten::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/unflatten/persist.h

@@ -0,0 +1,47 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_UNFLATTEN_PERSIST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_UNFLATTEN_PERSIST_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::unflatten::LayerForward<SPEC>& layer, GROUP& group) {
+        set_attribute(device, group, "type", "unflatten");
+        set_attribute(device, group, "height", std::to_string(SPEC::HEIGHT).c_str());
+        set_attribute(device, group, "width", std::to_string(SPEC::WIDTH).c_str());
+        set_attribute(device, group, "channels", std::to_string(SPEC::CHANNELS).c_str());
+        write_attributes(device, group);
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    void save(DEVICE& device, nn::layers::unflatten::LayerBackward<SPEC>& layer, GROUP& group) {
+        save(device, (nn::layers::unflatten::LayerForward<SPEC>&)layer, group);
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    void save(DEVICE& device, nn::layers::unflatten::LayerGradient<SPEC>& layer, GROUP& group) {
+        save(device, (nn::layers::unflatten::LayerBackward<SPEC>&)layer, group);
+        save(device, layer.output, group, "output");
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn::layers::unflatten::LayerForward<SPEC>& layer, GROUP& group) {
+        return true;
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn::layers::unflatten::LayerBackward<SPEC>& layer, GROUP& group) {
+        return load(device, (nn::layers::unflatten::LayerForward<SPEC>&)layer, group);
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn::layers::unflatten::LayerGradient<SPEC>& layer, GROUP& group) {
+        bool success = load(device, (nn::layers::unflatten::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::unflatten::State& state, GROUP& group) {}
+    template<typename DEVICE, typename GROUP>
+    bool load(DEVICE& device, nn::layers::unflatten::State& state, GROUP& group) { return true; }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,106 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_UNFLATTEN_PERSIST_CODE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_UNFLATTEN_PERSIST_CODE_H
+#include "layer.h"
+#include <sstream>
+#include "../../../containers/tensor/persist_code.h"
+#include "../../../persist/code.h"
+#include "../../../nn/capability/persist_code.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools {
+    namespace nn::layers::unflatten::persist_code{
+        template<typename DEVICE, typename SPEC>
+        rl_tools::persist::Code finish(DEVICE& device, nn::layers::unflatten::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/unflatten/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::unflatten::Configuration<TYPE_POLICY, " << TI_string << ", " << SPEC::HEIGHT << ", " << SPEC::WIDTH << ", " << SPEC::CHANNELS << ">;\n";
+            ss << ind << "    using TEMPLATE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::layers::unflatten::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::unflatten::Layer<CONFIG, CAPABILITY, INPUT_SHAPE>;\n";
+            std::string initializer_list;
+            if constexpr(SPEC::CAPABILITY::TAG == nn::LayerCapability::Forward){
+                initializer_list = "{}";
+            }
+            else if constexpr(SPEC::CAPABILITY::TAG == nn::LayerCapability::Backward){
+                initializer_list = "{{}}";
+            }
+            else{
+                initializer_list = "{{}, 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::unflatten::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::stringstream ss, ss_header;
+        if(finish){
+            return nn::layers::unflatten::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::unflatten::LayerBackward<SPEC>& layer, std::string name, bool const_declaration=true, typename DEVICE::index_t indent=0, bool finish=true){
+        return save_code_split(device, static_cast<nn::layers::unflatten::LayerForward<SPEC>&>(layer), name, const_declaration, indent, finish);
+    }
+    template<typename DEVICE, typename SPEC>
+    persist::Code save_code_split(DEVICE& device, nn::layers::unflatten::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::unflatten::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::unflatten::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::unflatten::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 nn_analytics(DEVICE& device, nn::layers::unflatten::LayerGradient<SPEC>& layer) {
+        return "{\"output\": " + json(device, layer.output) + "}";
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,132 @@
+#include "../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_LAYERS_UPSAMPLE2D_LAYER_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_LAYERS_UPSAMPLE2D_LAYER_H
+#include "../../../utils/generic/typing.h"
+#include "../../../containers/tensor/tensor.h"
+#include "../../../nn/capability/capability.h"
+#include "../../../nn/parameters/parameters.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::nn::layers::upsample2d {
+
+    template<typename T_TYPE_POLICY, typename T_TI,
+             T_TI T_SCALE_H = 2, T_TI T_SCALE_W = T_SCALE_H>
+    struct Configuration{
+        using TYPE_POLICY = T_TYPE_POLICY;
+        using TI = T_TI;
+        static constexpr TI SCALE_H = T_SCALE_H;
+        static constexpr TI SCALE_W = T_SCALE_W;
+    };
+
+    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, "Upsample2d input shape must have at least 4 dimensions (...BATCH x H x W x C)");
+        static constexpr TI INPUT_HEIGHT = get<length(INPUT_SHAPE{})-3>(INPUT_SHAPE{});
+        static constexpr TI INPUT_WIDTH = get<length(INPUT_SHAPE{})-2>(INPUT_SHAPE{});
+        static constexpr TI INPUT_CHANNELS = get_last(INPUT_SHAPE{});
+        static constexpr TI OUTPUT_HEIGHT = INPUT_HEIGHT * CONFIG::SCALE_H;
+        static constexpr TI OUTPUT_WIDTH = INPUT_WIDTH * CONFIG::SCALE_W;
+        static constexpr TI OUTPUT_CHANNELS = INPUT_CHANNELS;
+        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 * CONFIG::SCALE_H;
+            static constexpr TI NEW_OW = NEW_W * CONFIG::SCALE_W;
+            using SHAPE_HEIGHT = tensor::Replace<NEW_INPUT_SHAPE, NEW_OH, length(NEW_INPUT_SHAPE{}) - 3>;
+            using SHAPE = tensor::Replace<SHAPE_HEIGHT, NEW_OW, length(NEW_INPUT_SHAPE{}) - 2>;
+        };
+        using OUTPUT_SHAPE = typename OUTPUT_SHAPE_FACTORY<INPUT_SHAPE>::SHAPE;
+        static constexpr TI INTERNAL_BATCH_SIZE = tensor::shape_math::leading_product(tensor::shape_math::element_to_array<INPUT_SHAPE>(), 3);
+        static constexpr TI NUM_WEIGHTS = 0;
+    };
+
+    template<typename SPEC_1, typename SPEC_2>
+    constexpr bool check_spec_memory =
+        SPEC_1::INPUT_HEIGHT == SPEC_2::INPUT_HEIGHT
+        && SPEC_1::INPUT_WIDTH == SPEC_2::INPUT_WIDTH
+        && SPEC_1::INPUT_CHANNELS == SPEC_2::INPUT_CHANNELS
+        && SPEC_1::SCALE_H == SPEC_2::SCALE_H
+        && SPEC_1::SCALE_W == SPEC_2::SCALE_W;
+
+    template<typename SPEC_1, typename SPEC_2>
+    constexpr bool check_spec = check_spec_memory<SPEC_1, SPEC_2>;
+
+    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{};
+    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_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;
+        using INPUT_SHAPE = typename SPEC::INPUT_SHAPE;
+        template <typename NEW_INPUT_SHAPE>
+        using OUTPUT_SHAPE_FACTORY = typename SPEC::template OUTPUT_SHAPE_FACTORY<NEW_INPUT_SHAPE>::SHAPE;
+        using OUTPUT_SHAPE = typename SPEC::OUTPUT_SHAPE;
+        template<bool DYNAMIC_ALLOCATION=true>
+        using Buffer = upsample2d::Buffer;
+        template<bool DYNAMIC_ALLOCATION=true>
+        using State = upsample2d::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::upsample2d::Layer<CONFIG, CAPABILITY, INPUT_SHAPE>;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif