hyperray 0.0.1__py3-none-any.whl

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

@@ -0,0 +1,56 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_MODELS_MLP_PERSIST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_MODELS_MLP_PERSIST_H
+#include "../../nn/parameters/persist.h"
+#include "../../nn/persist.h"
+#include "../../utils/string/operations_generic.h"
+#include "network.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    void save(DEVICE& device, nn_models::mlp::NeuralNetworkForward<SPEC>& network, GROUP& group) {
+        using TI = typename DEVICE::index_t;
+        using NetworkType = typename utils::typing::remove_reference<decltype(network)>::type;
+        set_attribute(device, group, "type", "mlp");
+        set_attribute(device, group, "num_layers", std::to_string(SPEC::NUM_LAYERS).c_str());
+        write_attributes(device, group);
+        auto input_layer_group = create_group(device, group, "input_layer");
+        save(device, network.input_layer, input_layer_group);
+        auto hidden_layers_group = create_group(device, group, "hidden_layers");
+        for(typename DEVICE::index_t layer_i = 0; layer_i < NetworkType::NUM_HIDDEN_LAYERS; layer_i++) {
+            constexpr TI BUFFER_SIZE = 10;
+            char layer_index_str[BUFFER_SIZE];
+            utils::string::int_to_string<long int, TI>(layer_index_str, BUFFER_SIZE, layer_i);
+            auto hidden_layer_group = create_group(device, hidden_layers_group, layer_index_str);
+            save(device, network.hidden_layers[layer_i], hidden_layer_group);
+        }
+        auto output_layer_group = create_group(device, group, "output_layer");
+        save(device, network.output_layer, output_layer_group);
+    }
+    template<typename DEVICE, typename SPEC, typename GROUP>
+    bool load(DEVICE& device, nn_models::mlp::NeuralNetworkForward<SPEC>& network, GROUP& group){
+        using TI = typename DEVICE::index_t;
+        using NetworkType = typename utils::typing::remove_reference<decltype(network)>::type;
+        auto input_layer_group = get_group(device, group, "input_layer");
+        bool success = load(device, network.input_layer, input_layer_group);
+        auto hidden_layers_group = get_group(device, group, "hidden_layers");
+        for(typename DEVICE::index_t layer_i = 0; layer_i < NetworkType::NUM_HIDDEN_LAYERS; layer_i++) {
+            constexpr TI BUFFER_SIZE = 10;
+            char layer_index_str[BUFFER_SIZE];
+            utils::string::int_to_string<long int, TI>(layer_index_str, BUFFER_SIZE, layer_i);
+            auto hidden_layer_group = get_group(device, hidden_layers_group, layer_index_str);
+            success &= load(device, network.hidden_layers[layer_i], hidden_layer_group);
+        }
+        auto output_layer_group = get_group(device, group, "output_layer");
+        success &= load(device, network.output_layer, output_layer_group);
+        return success;
+    }
+    template<typename DEVICE, typename GROUP>
+    void save(DEVICE& device, nn_models::mlp::State& state, GROUP& group) {}
+    template<typename DEVICE, typename GROUP>
+    bool load(DEVICE& device, nn_models::mlp::State& state, GROUP& group) { return true; }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,137 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_MODELS_MLP_PERSIST_CODE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_MODELS_MLP_PERSIST_CODE_H
+
+
+
+#include <string>
+#include <sstream>
+#include "../../persist/code.h"
+#include "network.h"
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEVICE, typename SPEC>
+    persist::Code save_code_split(DEVICE& device, nn_models::mlp::NeuralNetworkForward<SPEC>& network, std::string name, bool const_declaration=true, typename DEVICE::index_t indent = 0){
+        // using T = typename SPEC::T;
+        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_header;
+        std::stringstream ss;
+        ss << ind << "namespace " << name << " {\n";
+        auto input_layer = save_code_split(device, network.input_layer, "input_layer", const_declaration, indent+1);
+        ss_header << input_layer.header;
+        ss_header << "#include <rl_tools/nn_models/mlp/network.h>\n";
+        ss << input_layer.body;
+        for(TI hidden_layer_i = 0; hidden_layer_i < SPEC::NUM_HIDDEN_LAYERS; hidden_layer_i++){
+            auto hidden_layer = save_code_split(device, network.hidden_layers[hidden_layer_i], "hidden_layer_" + std::to_string(hidden_layer_i), const_declaration, indent+1);
+            ss_header << hidden_layer.header;
+            ss << hidden_layer.body;
+        }
+        auto output_layer = save_code_split(device, network.output_layer, "output_layer", const_declaration, indent+1);
+        ss_header << output_layer.header;
+        std::string T_string = containers::persist::get_type_string<typename SPEC::TYPE_POLICY::DEFAULT>();
+        std::string TI_string = containers::persist::get_type_string<TI>();
+        ss << output_layer.body;
+        ss << ind << "    using TYPE_POLICY = " + to_string(typename SPEC::TYPE_POLICY{}) + ";" << "\n";
+        ss << ind << "    using CONFIG = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn_models::mlp::Configuration<";
+        ss << "TYPE_POLICY, ";
+        ss << TI_string << ", ";
+        ss << SPEC::OUTPUT_DIM << ", " << SPEC::NUM_LAYERS << ", " << SPEC::HIDDEN_DIM << ", ";
+        ss << nn::layers::dense::persist::get_activation_function_string<SPEC::HIDDEN_ACTIVATION_FUNCTION>() << ", ";
+        ss << nn::layers::dense::persist::get_activation_function_string<SPEC::OUTPUT_ACTIVATION_FUNCTION>() << ", ";
+        ss << "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::layers::dense::DefaultInitializer<" << "TYPE_POLICY, " << TI_string << ">";
+        ss << ">; \n";
+        ss << ind << "    " << "using TEMPLATE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn_models::mlp::BindConfiguration<CONFIG>;" << "\n";
+        ss << ind << "    " << "using INPUT_SHAPE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::tensor::Shape<" << TI_string << ", " << get<0>(typename SPEC::INPUT_SHAPE{}) << ", " << get<1>(typename SPEC::INPUT_SHAPE{}) << ", " << get<2>(typename SPEC::INPUT_SHAPE{}) << ">;\n";
+        ss << ind << "    " << "using CAPABILITY = " << to_string(typename SPEC::CAPABILITY::template CHANGE_PARAMETERS<true, true>{}) << ";" << "\n";
+        ss << ind << "    " << "using TYPE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn_models::mlp::NeuralNetwork<CONFIG, CAPABILITY, INPUT_SHAPE>;" << "\n";
+        std::stringstream ss_initializer_list;
+        {
+            ss_initializer_list << "{input_layer::factory<TYPE::SPEC::INPUT_LAYER>, ";
+            ss_initializer_list << "{";
+            for(TI hidden_layer_i = 0; hidden_layer_i < SPEC::NUM_HIDDEN_LAYERS; hidden_layer_i++){
+                if(hidden_layer_i > 0){
+                    ss_initializer_list << ", ";
+                }
+                ss_initializer_list << "hidden_layer_" << hidden_layer_i << "::factory<TYPE::SPEC::HIDDEN_LAYER>";
+            }
+            ss_initializer_list << "}, ";
+            ss_initializer_list << "output_layer::factory<TYPE::SPEC::OUTPUT_LAYER>}";
+        }
+        std::stringstream ss_initializer_list_create, ss_initializer_list_create_function;
+        {
+            ss_initializer_list_create << "{input_layer::factory<typename T_TYPE::SPEC::INPUT_LAYER>, ";
+            ss_initializer_list_create_function << "{input_layer::factory_function<typename T_TYPE::SPEC::INPUT_LAYER>(), ";
+            ss_initializer_list_create << "{";
+            ss_initializer_list_create_function << "{";
+            for(TI hidden_layer_i = 0; hidden_layer_i < SPEC::NUM_HIDDEN_LAYERS; hidden_layer_i++){
+                if(hidden_layer_i > 0){
+                    ss_initializer_list_create << ", ";
+                    ss_initializer_list_create_function << ", ";
+                }
+                ss_initializer_list_create << "hidden_layer_" << hidden_layer_i << "::factory<typename T_TYPE::SPEC::HIDDEN_LAYER>";
+                ss_initializer_list_create_function << "hidden_layer_" << hidden_layer_i << "::factory_function<typename T_TYPE::SPEC::HIDDEN_LAYER>()";
+            }
+            ss_initializer_list_create << "}, ";
+            ss_initializer_list_create_function << "}, ";
+            ss_initializer_list_create << "output_layer::factory<typename T_TYPE::SPEC::OUTPUT_LAYER>}";
+            ss_initializer_list_create_function << "output_layer::factory_function<typename T_TYPE::SPEC::OUTPUT_LAYER>()}";
+        }
+
+        // std::string initializer_list;
+//        if constexpr(SPEC::CAPABILITY::TAG == nn::LayerCapability::Forward){
+//            initializer_list = "{" + ss_initializer_list.str() + "}";
+//        }
+//        else{
+//            if constexpr(SPEC::CAPABILITY::TAG == nn::LayerCapability::Backward){
+//                initializer_list = "{{" + ss_initializer_list.str() + "}}";
+//            }
+//            else{
+//                if constexpr(SPEC::CAPABILITY::TAG == nn::LayerCapability::Gradient){
+//                    initializer_list = "{{{" + ss_initializer_list.str() + "}}}";
+//                }
+//                else{
+//                    utils::assert_exit(device, false, "Unknown capability");
+//                }
+//            }
+//        }
+        std::string initializer_list = ss_initializer_list_create.str();
+        ss << ind << "    " << (const_declaration ? "constexpr " : "") << "TYPE module = " << ss_initializer_list.str() << ";\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" << ss_initializer_list_create_function.str() << ";" << "}\n";
+        ss << ind << "}\n";
+        return {ss_header.str(), ss.str()};
+    }
+    template<typename DEVICE, typename SPEC>
+    std::string save_code(DEVICE& device, nn_models::mlp::NeuralNetworkForward<SPEC>& network, std::string name, bool const_declaration = true, typename DEVICE::index_t indent = 0) {
+        auto code = save_code_split(device, network, name, const_declaration, indent);
+        return code.header + code.body;
+    }
+    template <typename DEVICE, typename SPEC>
+    std::string nn_analytics(DEVICE& device, nn_models::mlp::NeuralNetworkGradient<SPEC>& nn) {
+        std::string data;
+        data += "{";
+        data += "   \"type\": \"mlp\",";
+        data += "   \"layers\": [";
+        data += nn_analytics(device, nn.input_layer);
+        for(typename DEVICE::index_t layer_i=0; layer_i < SPEC::NUM_HIDDEN_LAYERS; layer_i++){
+            data += ", ";
+            data += nn_analytics(device, nn.hidden_layers[layer_i]);
+        }
+        data += ", ";
+        data += nn_analytics(device, nn.output_layer);
+        data += "]";
+        data += "}";
+        return data;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/nn_models/mlp_unconditional_stddev/network.h

@@ -0,0 +1,55 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_MODELS_MLP_UNCONDITIONAL_STDDEV_NETWORK_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_MODELS_MLP_UNCONDITIONAL_STDDEV_NETWORK_H
+
+#include "../../nn_models/mlp/network.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::nn_models::mlp_unconditional_stddev {
+
+    template<typename CONFIG, typename CAPABILITY, typename = void>
+    struct LogStdCapability{
+        using TYPE = CAPABILITY;
+    };
+    template<typename CONFIG, typename CAPABILITY>
+    struct LogStdCapability<CONFIG, CAPABILITY, utils::typing::void_t<typename CONFIG::LOG_STD_GROUP>>{
+        using TYPE = nn::group::Capability<CAPABILITY, typename CONFIG::LOG_STD_GROUP>;
+    };
+
+    template <typename T_SPEC, template <typename> typename T_BASE = nn_models::mlp::NeuralNetworkForward>
+    struct NeuralNetworkForward: T_BASE<T_SPEC>{
+        using SPEC = T_SPEC;
+        using TYPE_POLICY = typename SPEC::TYPE_POLICY;
+        using TI = typename SPEC::TI;
+        // using LOG_STD_CONTAINER_SPEC = matrix::Specification<typename TYPE_POLICY::DEFAULT, TI, 1, SPEC::OUTPUT_DIM, SPEC::DYNAMIC_ALLOCATION>;
+        // using LOG_STD_CONTAINER_TYPE = Matrix<LOG_STD_CONTAINER_SPEC>;
+        using LOG_STD_CONTAINER_SHAPE = tensor::Shape<TI, SPEC::OUTPUT_DIM>;
+        using LOG_STD_CAPABILITY = typename LogStdCapability<SPEC, typename SPEC::CAPABILITY>::TYPE;
+        using LOG_STD_PARAMETER_SPEC = typename LOG_STD_CAPABILITY::PARAMETER_TYPE::template Specification<TYPE_POLICY, TI, LOG_STD_CONTAINER_SHAPE, nn::parameters::groups::Output, nn::parameters::categories::Weights, SPEC::DYNAMIC_ALLOCATION, SPEC::CONST>;
+        typename LOG_STD_CAPABILITY::PARAMETER_TYPE::template Instance<LOG_STD_PARAMETER_SPEC> log_std;
+        template <typename TT_SPEC>
+        using BASE = T_BASE<TT_SPEC>;
+    };
+    template <typename SPEC, template <typename> typename BASE = nn_models::mlp::NeuralNetworkBackward>
+    struct NeuralNetworkBackward: NeuralNetworkForward<SPEC, BASE>{};
+    template <typename SPEC, template <typename> typename BASE = nn_models::mlp::NeuralNetworkGradient>
+    struct NeuralNetworkGradient: NeuralNetworkBackward<SPEC, BASE>{};
+
+    template<typename CONFIG, typename CAPABILITY, typename INPUT_SHAPE>
+    using NeuralNetwork =
+    typename utils::typing::conditional_t<CAPABILITY::TAG == nn::LayerCapability::Forward, NeuralNetworkForward<nn_models::mlp::Specification<CONFIG, CAPABILITY, INPUT_SHAPE>>,
+    typename utils::typing::conditional_t<CAPABILITY::TAG == nn::LayerCapability::Backward, NeuralNetworkBackward<nn_models::mlp::Specification<CONFIG, CAPABILITY, INPUT_SHAPE>>,
+    typename utils::typing::conditional_t<CAPABILITY::TAG == nn::LayerCapability::Gradient, NeuralNetworkGradient<nn_models::mlp::Specification<CONFIG, CAPABILITY, INPUT_SHAPE>>, void>>>;
+
+    template <typename CONFIG>
+    struct BindConfiguration{
+        template <typename CAPABILITY, typename INPUT_SHAPE>
+        using Layer = nn_models::mlp_unconditional_stddev::NeuralNetwork<CONFIG, CAPABILITY, INPUT_SHAPE>;
+    };
+
+
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,86 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_MODELS_MLP_UNCONDITIONAL_STDDEV_OPERATIONS_GENERIC_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_MODELS_MLP_UNCONDITIONAL_STDDEV_OPERATIONS_GENERIC_H
+
+#include "network.h"
+#include "../../nn_models/mlp/operations_generic.h"
+
+
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE, typename SPEC, template <typename> typename BASE>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC, BASE>& m){
+        malloc(device, static_cast<nn_models::mlp::NeuralNetworkForward<SPEC>&>(m));
+        malloc(device, m.log_std);
+    }
+    template <typename DEVICE, typename SPEC, template <typename> typename BASE>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC, BASE>& m){
+        free(device, static_cast<nn_models::mlp::NeuralNetworkForward<SPEC>&>(m));
+        free(device, m.log_std);
+    }
+    template <typename DEVICE, typename SPEC, template <typename> typename BASE, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT void init_weights(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC, BASE>& m, RNG& rng){
+        init_weights(device, static_cast<nn_models::mlp::NeuralNetworkForward<SPEC>&>(m), rng);
+        set_all(device, m.log_std.parameters, 0);
+    }
+    template<typename DEVICE, typename SPEC, template <typename> typename BASE, typename OPTIMIZER>
+    RL_TOOLS_FUNCTION_PLACEMENT void update(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkGradient<SPEC, BASE>& network, OPTIMIZER& optimizer) {
+        update(device, network.log_std, optimizer);
+        update(device, static_cast<nn_models::mlp::NeuralNetworkGradient<SPEC>&>(network), optimizer);
+    }
+    template<typename DEVICE, typename SPEC, template <typename> typename BASE>
+    RL_TOOLS_FUNCTION_PLACEMENT void zero_gradient(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkGradient<SPEC, BASE>& network) {
+        zero_gradient(device, static_cast<nn_models::mlp::NeuralNetworkGradient<SPEC>&>(network));
+        zero_gradient(device, network.log_std);
+    }
+    template<typename DEVICE, typename SOURCE_SPEC, template <typename> typename SOURCE_BASE, typename TARGET_SPEC, template <typename> typename TARGET_BASE>
+    RL_TOOLS_FUNCTION_PLACEMENT void add_gradient(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkGradient<SOURCE_SPEC, SOURCE_BASE>& source, nn_models::mlp_unconditional_stddev::NeuralNetworkGradient<TARGET_SPEC, TARGET_BASE>& target) {
+        add_gradient(device, static_cast<nn_models::mlp::NeuralNetworkGradient<SOURCE_SPEC>&>(source), static_cast<nn_models::mlp::NeuralNetworkGradient<TARGET_SPEC>&>(target));
+        add_gradient(device, source.log_std, target.log_std);
+    }
+    template<typename SOURCE_DEVICE, typename TARGET_DEVICE, typename SOURCE_SPEC, template <typename> typename SOURCE_BASE, typename TARGET_SPEC, template <typename> typename TARGET_BASE>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy_gradient(SOURCE_DEVICE& source_device, TARGET_DEVICE& target_device, const nn_models::mlp_unconditional_stddev::NeuralNetworkGradient<SOURCE_SPEC, SOURCE_BASE>& source, nn_models::mlp_unconditional_stddev::NeuralNetworkGradient<TARGET_SPEC, TARGET_BASE>& target) {
+        copy_gradient(source_device, target_device, static_cast<const nn_models::mlp::NeuralNetworkGradient<SOURCE_SPEC>&>(source), static_cast<nn_models::mlp::NeuralNetworkGradient<TARGET_SPEC>&>(target));
+        copy_gradient(source_device, target_device, source.log_std, target.log_std);
+    }
+
+    template<typename DEVICE, typename SPEC, template <typename> typename BASE, typename OPTIMIZER>
+    RL_TOOLS_FUNCTION_PLACEMENT void _reset_optimizer_state(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkGradient<SPEC, BASE>& network, OPTIMIZER& optimizer) {
+        _reset_optimizer_state(device, static_cast<nn_models::mlp::NeuralNetworkGradient<SPEC>&>(network), optimizer);
+        _reset_optimizer_state(device, network.log_std, optimizer);
+    }
+
+    template<typename SOURCE_DEVICE, typename TARGET_DEVICE, typename SOURCE_SPEC, typename TARGET_SPEC, template <typename> typename SOURCE_BASE, template <typename> typename TARGET_BASE>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy(SOURCE_DEVICE& source_device, TARGET_DEVICE& target_device, const  nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SOURCE_SPEC, SOURCE_BASE>& source, nn_models::mlp_unconditional_stddev::NeuralNetworkForward<TARGET_SPEC, TARGET_BASE>& target){
+        static_assert(rl_tools::nn_models::mlp::check_spec_memory<SOURCE_SPEC, TARGET_SPEC>, "The source and target network must have the same structure");
+        copy(source_device, target_device, static_cast<const nn_models::mlp::NeuralNetworkForward<SOURCE_SPEC>&>(source), static_cast<nn_models::mlp::NeuralNetworkForward<TARGET_SPEC>&>(target));
+        copy(source_device, target_device, source.log_std, target.log_std);
+    }
+    template<typename SOURCE_DEVICE, typename TARGET_DEVICE, typename SOURCE_SPEC, typename TARGET_SPEC, typename SOURCE, template <typename> typename TARGET_BASE>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy_from_generic(SOURCE_DEVICE& source_device, TARGET_DEVICE& target_device, const SOURCE& source, nn_models::mlp_unconditional_stddev::NeuralNetworkForward<TARGET_SPEC, TARGET_BASE>& target){
+        static_assert(rl_tools::nn_models::mlp::check_spec_memory<SOURCE_SPEC, TARGET_SPEC>, "The source and target network must have the same structure");
+        copy_from_generic(source_device, target_device, static_cast<const nn_models::mlp::NeuralNetworkForward<SOURCE_SPEC>&>(source), static_cast<nn_models::mlp::NeuralNetworkForward<TARGET_SPEC>&>(target));
+        copy_from_generic(source_device, target_device, source.log_std, target.log_std);
+    }
+    template <typename DEVICE, typename SPEC_1, typename SPEC_2, template <typename> typename BASE_1, template <typename> typename BASE_2>
+    RL_TOOLS_FUNCTION_PLACEMENT typename SPEC_1::TYPE_POLICY::DEFAULT abs_diff(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC_1, BASE_1>& n1, const nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC_2, BASE_2>& n2){
+        using T = typename SPEC_1::TYPE_POLICY::DEFAULT;
+        T acc = 0;
+        acc += abs_diff(device, static_cast<BASE_1<SPEC_1>&>(n1), static_cast<const BASE_2<SPEC_2>&>(n2));
+        acc += abs_diff(device, n1.log_std, n2.log_std);
+        return acc;
+    }
+    template <typename DEVICE, typename SPEC_1, typename SPEC_2, template <typename> typename BASE_1, template <typename> typename BASE_2>
+    RL_TOOLS_FUNCTION_PLACEMENT typename SPEC_1::TYPE_POLICY::DEFAULT abs_diff(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkBackward<SPEC_1, BASE_1>& n1, const nn_models::mlp_unconditional_stddev::NeuralNetworkBackward<SPEC_2, BASE_2>& n2){
+        return abs_diff(device, static_cast<nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC_1, BASE_1>&>(n1), static_cast<const nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC_2, BASE_2>&>(n2));
+    }
+    template <typename DEVICE, typename SPEC_1, typename SPEC_2, template <typename> typename BASE_1, template <typename> typename BASE_2>
+    RL_TOOLS_FUNCTION_PLACEMENT typename SPEC_1::TYPE_POLICY::DEFAULT abs_diff(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkGradient<SPEC_1, BASE_1>& n1, const nn_models::mlp_unconditional_stddev::NeuralNetworkGradient<SPEC_2, BASE_2>& n2){
+        return abs_diff(device, static_cast<nn_models::mlp_unconditional_stddev::NeuralNetworkBackward<SPEC_1, BASE_1>&>(n1), static_cast<const nn_models::mlp_unconditional_stddev::NeuralNetworkBackward<SPEC_2, BASE_2>&>(n2));
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,43 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_MODELS_MLP_UNCONDITIONAL_STDDEV_PERSIST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_MODELS_MLP_UNCONDITIONAL_STDDEV_PERSIST_H
+#include "../../nn/parameters/persist.h"
+#include "../../nn/persist.h"
+#include "network.h"
+#include "../mlp/persist.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEVICE, typename SPEC, template <typename> typename BASE, typename GROUP>
+    void save(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC, BASE>& network, GROUP& group) {
+        save(device, static_cast<nn_models::mlp::NeuralNetworkForward<SPEC>&>(network), group);
+        auto log_std_group = create_group(device, group, "log_std");
+        save(device, network.log_std, log_std_group);
+    }
+    template<typename DEVICE, typename SPEC, template <typename> typename BASE, typename GROUP>
+    void save(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkBackward<SPEC, BASE>& network, GROUP& group){
+        save(device, static_cast<nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC, BASE>&>(network), group);
+    }
+    template<typename DEVICE, typename SPEC, template <typename> typename BASE, typename GROUP>
+    void save(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkGradient<SPEC, BASE>& network, GROUP& group){
+        save(device, static_cast<nn_models::mlp_unconditional_stddev::NeuralNetworkBackward<SPEC, BASE>&>(network), group);
+    }
+    template<typename DEVICE, typename SPEC, template <typename> typename BASE, typename GROUP>
+    bool load(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC, BASE>& network, GROUP& group){
+        bool success = load(device, static_cast<nn_models::mlp::NeuralNetworkForward<SPEC>&>(network), group);
+        auto log_std_group = get_group(device, group, "log_std");
+        success &= load(device, network.log_std, log_std_group);
+        return success;
+    }
+    template<typename DEVICE, typename SPEC, template <typename> typename BASE, typename GROUP>
+    bool load(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkBackward<SPEC, BASE>& network, GROUP& group){
+        return load(device, static_cast<nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC, BASE>&>(network), group);
+    }
+    template<typename DEVICE, typename SPEC, template <typename> typename BASE, typename GROUP>
+    bool load(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkGradient<SPEC, BASE>& network, GROUP& group){
+        return load(device, static_cast<nn_models::mlp_unconditional_stddev::NeuralNetworkBackward<SPEC, BASE>&>(network), group);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

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

@@ -0,0 +1,142 @@
+#include "../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_NN_MODELS_MLP_UNCONDITIONAL_STDDEV_PERSIST_CODE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_NN_MODELS_MLP_UNCONDITIONAL_STDDEV_PERSIST_CODE_H
+
+
+
+#include <string>
+#include <sstream>
+#include "../../persist/code.h"
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template<typename DEVICE, typename SPEC, template <typename> typename BASE>
+    persist::Code save_code_split(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC, BASE>& network, std::string name, bool const_declaration=true, typename DEVICE::index_t indent = 0){
+        // using T = typename SPEC::T;
+        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_header;
+        std::stringstream ss;
+        ss << ind << "namespace " << name << " {\n";
+        auto input_layer = save_code_split(device, network.input_layer, "input_layer", const_declaration, indent+1);
+        ss_header << input_layer.header;
+        ss_header << "#include <rl_tools/nn_models/mlp_unconditional_stddev/network.h>\n";
+        ss << input_layer.body;
+        for(TI hidden_layer_i = 0; hidden_layer_i < SPEC::NUM_HIDDEN_LAYERS; hidden_layer_i++){
+            auto hidden_layer = save_code_split(device, network.hidden_layers[hidden_layer_i], "hidden_layer_" + std::to_string(hidden_layer_i), const_declaration, indent+1);
+            ss_header << hidden_layer.header;
+            ss << hidden_layer.body;
+        }
+        auto output_layer = save_code_split(device, network.output_layer, "output_layer", const_declaration, indent+1);
+        ss_header << output_layer.header;
+        ss << output_layer.body;
+        auto log_std = save_code_split(device, network.log_std, "log_std", const_declaration, indent+1);
+        ss_header << log_std.header;
+        ss << log_std.body;
+        // std::string T_string = containers::persist::get_type_string<T>();
+        std::string TI_string = containers::persist::get_type_string<TI>();
+        ss << ind << "    using TYPE_POLICY = " + to_string(typename SPEC::TYPE_POLICY{}) + ";" << "\n";
+        ss << ind << "    using BASE_CONFIG = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn_models::mlp::Configuration<";
+        ss << "TYPE_POLICY, ";
+        ss << TI_string << ", ";
+        ss << SPEC::OUTPUT_DIM << ", " << SPEC::NUM_LAYERS << ", " << SPEC::HIDDEN_DIM << ", ";
+        ss << nn::layers::dense::persist::get_activation_function_string<SPEC::HIDDEN_ACTIVATION_FUNCTION>() << ", ";
+        ss << nn::layers::dense::persist::get_activation_function_string<SPEC::OUTPUT_ACTIVATION_FUNCTION>() << ", ";
+        ss << "RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn::layers::dense::DefaultInitializer<" << "TYPE_POLICY, " << TI_string << ">";
+        ss << ">; \n";
+        using LOG_STD_GROUPS = typename nn::group::RelativeGroups<typename nn::group::MembershipOf<typename nn_models::mlp_unconditional_stddev::LogStdCapability<SPEC, typename SPEC::CAPABILITY>::TYPE>::TYPE, typename nn::group::MembershipOf<typename SPEC::CAPABILITY>::TYPE>::TYPE;
+        if constexpr(utils::typing::is_same_v<LOG_STD_GROUPS, nn::group::Membership<>>){
+            ss << ind << "    using CONFIG = BASE_CONFIG;\n";
+        }
+        else{
+            ss << ind << "    struct CONFIG: BASE_CONFIG{ using LOG_STD_GROUP = " << nn::group::CodeGroups<LOG_STD_GROUPS>::names() << "; };\n";
+        }
+        ss << ind << "    " << "using TEMPLATE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn_models::mlp_unconditional_stddev::BindConfiguration<CONFIG>;" << "\n";
+        ss << ind << "    " << "using INPUT_SHAPE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::tensor::Shape<" << TI_string << ", " << get<0>(typename SPEC::INPUT_SHAPE{}) << ", " << get<1>(typename SPEC::INPUT_SHAPE{}) << ", " << get<2>(typename SPEC::INPUT_SHAPE{}) << ">;\n";
+        ss << ind << "    " << "using CAPABILITY = " << to_string(typename SPEC::CAPABILITY::template CHANGE_PARAMETERS<true, true>{}) << ";" << "\n";
+        ss << ind << "    " << "using TYPE = RL_TOOLS""_NAMESPACE_WRAPPER ::rl_tools::nn_models::mlp_unconditional_stddev::NeuralNetwork<CONFIG, CAPABILITY, INPUT_SHAPE>;" << "\n";
+        std::stringstream ss_initializer_list;
+        {
+            ss_initializer_list << "{{input_layer::factory<TYPE::SPEC::INPUT_LAYER>, ";
+            ss_initializer_list << "{";
+            for(TI hidden_layer_i = 0; hidden_layer_i < SPEC::NUM_HIDDEN_LAYERS; hidden_layer_i++){
+                if(hidden_layer_i > 0){
+                    ss_initializer_list << ", ";
+                }
+                ss_initializer_list << "hidden_layer_" << hidden_layer_i << "::factory<TYPE::SPEC::HIDDEN_LAYER>";
+            }
+            ss_initializer_list << "}, ";
+            ss_initializer_list << "output_layer::factory<TYPE::SPEC::OUTPUT_LAYER>}";
+            ss_initializer_list << ", log_std::parameters}";
+        }
+        std::stringstream ss_initializer_list_create, ss_initializer_list_create_function;
+        {
+            ss_initializer_list_create << "{{input_layer::factory<typename T_TYPE::SPEC::INPUT_LAYER>, ";
+            ss_initializer_list_create_function << "{{input_layer::factory_function<typename T_TYPE::SPEC::INPUT_LAYER>(), ";
+            ss_initializer_list_create << "{";
+            ss_initializer_list_create_function << "{";
+            for(TI hidden_layer_i = 0; hidden_layer_i < SPEC::NUM_HIDDEN_LAYERS; hidden_layer_i++){
+                if(hidden_layer_i > 0){
+                    ss_initializer_list_create << ", ";
+                    ss_initializer_list_create_function << ", ";
+                }
+                ss_initializer_list_create << "hidden_layer_" << hidden_layer_i << "::factory<typename T_TYPE::SPEC::HIDDEN_LAYER>";
+                ss_initializer_list_create_function << "hidden_layer_" << hidden_layer_i << "::factory_function<typename T_TYPE::SPEC::HIDDEN_LAYER>()";
+            }
+            ss_initializer_list_create << "}, ";
+            ss_initializer_list_create_function << "}, ";
+            ss_initializer_list_create << "output_layer::factory<typename T_TYPE::SPEC::OUTPUT_LAYER>}";
+            ss_initializer_list_create_function << "output_layer::factory_function<typename T_TYPE::SPEC::OUTPUT_LAYER>()";
+            ss_initializer_list_create << ", log_std::parameters}";
+            ss_initializer_list_create_function << ", log_std::parameters}";
+        }
+
+        std::string initializer_list, initializer_list_create;
+        if constexpr(SPEC::CAPABILITY::TAG == nn::LayerCapability::Forward){
+            initializer_list = ss_initializer_list.str();
+            initializer_list_create = ss_initializer_list_create.str();
+        }
+        else{
+            if constexpr(SPEC::CAPABILITY::TAG == nn::LayerCapability::Backward){
+                initializer_list = "{" + ss_initializer_list.str() + "}";
+                initializer_list_create = "{" + ss_initializer_list_create.str() + "}";
+            }
+            else{
+                if constexpr(SPEC::CAPABILITY::TAG == nn::LayerCapability::Gradient){
+                    initializer_list = "{{" + ss_initializer_list.str() + "}}";
+                    initializer_list_create = "{{" + ss_initializer_list_create.str() + "}}";
+                }
+                else{
+                    utils::assert_exit(device, false, "Unknown capability");
+                }
+            }
+        }
+        ss << ind << "    " << (const_declaration ? "constexpr " : "") << "TYPE module = " << initializer_list << ";\n";
+        ss << ind << "    " << "template <typename T_TYPE = TYPE>" << "\n";
+        ss << ind << "    " << (const_declaration ? "constexpr " : "") << "T_TYPE factory = " << initializer_list_create << ";" << "\n";
+        ss << ind << "    " << "template <typename T_TYPE = TYPE>" << "\n";
+        ss << ind << "    " << (const_declaration ? "constexpr " : "") << "T_TYPE factory_function(){return T_TYPE" << initializer_list_create << ";" << "}\n";
+        ss << ind << "}\n";
+        return {ss_header.str(), ss.str()};
+    }
+    template<typename DEVICE, typename SPEC, template <typename> typename BASE>
+    persist::Code save_code_split(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkBackward<SPEC, BASE>& network, std::string name, bool const_declaration=true, typename DEVICE::index_t indent = 0){
+        return save_code_split(device, static_cast<nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC, BASE>&>(network), name, const_declaration, indent);
+    }
+    template<typename DEVICE, typename SPEC, template <typename> typename BASE>
+    persist::Code save_code_split(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkGradient<SPEC, BASE>& network, std::string name, bool const_declaration=true, typename DEVICE::index_t indent = 0){
+        return save_code_split(device, static_cast<nn_models::mlp_unconditional_stddev::NeuralNetworkBackward<SPEC, BASE>&>(network), name, const_declaration, indent);
+    }
+    template<typename DEVICE, typename SPEC>
+    std::string save_code(DEVICE& device, nn_models::mlp_unconditional_stddev::NeuralNetworkForward<SPEC>& network, std::string name, bool const_declaration = true, typename DEVICE::index_t indent = 0) {
+        auto code = save_code_split(device, network, name, const_declaration, indent);
+        return code.header + code.body;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+#endif

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

@@ -0,0 +1,3 @@
+#include "mlp/network.h"
+#include "mlp_unconditional_stddev/network.h"
+#include "sequential/model.h"