hyperray 0.0.1__py3-none-any.whl

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

@@ -0,0 +1,278 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DYN_PERSIST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DYN_PERSIST_H
+
+#include "model.h"
+#include "operations_generic.h"
+#include "../utils/string/operations_generic.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace dyn::persist_helpers{
+        template <typename DEVICE, typename TI>
+        ActivationFunction parse_activation_function(DEVICE& device, const char* name, TI len){
+            if(utils::string::compare(name, "IDENTITY", 8)) return ActivationFunction::IDENTITY;
+            if(utils::string::compare(name, "RELU", 4)) return ActivationFunction::RELU;
+            if(utils::string::compare(name, "relu", 4)) return ActivationFunction::RELU;
+            if(utils::string::compare(name, "GELU", 4)) return ActivationFunction::GELU;
+            if(utils::string::compare(name, "gelu", 4)) return ActivationFunction::GELU;
+            if(utils::string::compare(name, "TANH", 4)) return ActivationFunction::TANH;
+            if(utils::string::compare(name, "tanh", 4)) return ActivationFunction::TANH;
+            if(utils::string::compare(name, "FAST_TANH", 9)) return ActivationFunction::FAST_TANH;
+            if(utils::string::compare(name, "fast_tanh", 9)) return ActivationFunction::FAST_TANH;
+            if(utils::string::compare(name, "SIGMOID", 7)) return ActivationFunction::SIGMOID;
+            if(utils::string::compare(name, "sigmoid", 7)) return ActivationFunction::SIGMOID;
+            return ActivationFunction::IDENTITY;
+        }
+        template <typename TI>
+        dyn::Type parse_dtype(const char* name, TI len){
+            if(utils::string::compare(name, "float32", 7)) return dyn::Type::FLOAT32;
+            if(utils::string::compare(name, "float64", 7)) return dyn::Type::FLOAT64;
+            if(utils::string::compare(name, "bf16", 4)) return dyn::Type::BF16;
+            if(utils::string::compare(name, "int8", 4)) return dyn::Type::INT8;
+            return dyn::Type::FLOAT32;
+        }
+    }
+
+    // --- TAR backend: Load dyn::Tensor ---
+#ifdef RL_TOOLS_PERSIST_BACKENDS_TAR_OPERATIONS_GENERIC
+    template <typename DEVICE, typename TI, typename GROUP_SPEC>
+    bool load(DEVICE& device, dyn::Tensor<dyn::TensorSpecification<TI>>& tensor, persist::backends::tar::ReaderGroup<GROUP_SPEC>& group, const char* name){
+        auto tensor_group = get_group(device, group, name);
+        constexpr TI MAX_PATH = GROUP_SPEC::MAX_PATH_LENGTH;
+        char current_path[MAX_PATH];
+        utils::string::copy<TI>(current_path, tensor_group.path, MAX_PATH);
+        TI path_len = utils::string::length(current_path, MAX_PATH);
+        TI sep_pos = path_len;
+        if(path_len > 0 && path_len + 1 < MAX_PATH){ current_path[path_len] = '/'; current_path[path_len+1] = '\0'; sep_pos = path_len+1; }
+        utils::string::copy(current_path + sep_pos, "meta", MAX_PATH - sep_pos);
+        constexpr TI METADATA_SIZE = 200;
+        char metadata[METADATA_SIZE];
+        TI read_size = 0;
+        if(!persist::backends::tar::get(device, tensor_group.data, current_path, metadata, METADATA_SIZE, read_size)) return false;
+        if(read_size < METADATA_SIZE) metadata[read_size] = '\0';
+        TI pos, len;
+        if(persist::backends::tar::seek_in_metadata(device, metadata, read_size, "dtype", pos, len)) tensor.type = dyn::persist_helpers::parse_dtype(metadata+pos, len);
+        if(!persist::backends::tar::seek_in_metadata(device, metadata, read_size, "num_dims", pos, len)) return false;
+        tensor.rank = utils::string::string_to_int<TI>(metadata+pos, len);
+        for(TI d = 0; d < tensor.rank; d++){
+            char key[16] = "dim_"; char digit[2] = {static_cast<char>('0'+d), '\0'}; utils::string::copy(key+4, digit, 12);
+            if(!persist::backends::tar::seek_in_metadata(device, metadata, read_size, key, pos, len)) return false;
+            tensor.shape[d] = utils::string::string_to_int<TI>(metadata+pos, len);
+        }
+        rl_tools::malloc(device, tensor);
+        utils::string::copy(current_path+sep_pos, "data", MAX_PATH-sep_pos);
+        TI data_read_size = 0;
+        return persist::backends::tar::get(device, tensor_group.data, current_path, reinterpret_cast<char*>(tensor.data), tensor.size() * dyn::size_of<TI>(tensor.type), data_read_size);
+    }
+#endif
+
+    // --- HDF5 C API backend: Load dyn::Tensor (raw bytes, no float bottleneck) ---
+#ifdef RL_TOOLS_PERSIST_BACKENDS_HDF5_HDF5
+    template <typename DEVICE, typename TI, typename GROUP_SPEC>
+    bool load(DEVICE& device, dyn::Tensor<dyn::TensorSpecification<TI>>& tensor, persist::backends::hdf5::Group<GROUP_SPEC>& group, const char* name){
+        hid_t ds = H5Dopen2(group.id, name, H5P_DEFAULT);
+        if(ds < 0) return false;
+        hid_t space = H5Dget_space(ds);
+        int rank = H5Sget_simple_extent_ndims(space);
+        hsize_t dims[dyn::TensorSpecification<TI>::MAX_RANK];
+        H5Sget_simple_extent_dims(space, dims, nullptr);
+        tensor.rank = rank;
+        for(TI d = 0; d < (TI)rank; d++) tensor.shape[d] = dims[d];
+        hid_t dtype = H5Dget_type(ds);
+        H5T_class_t cls = H5Tget_class(dtype);
+        size_t dts = H5Tget_size(dtype);
+        H5Tclose(dtype);
+        hid_t memtype;
+        if(cls == H5T_FLOAT && dts == 8){
+            tensor.type = dyn::Type::FLOAT64;
+            memtype = H5T_NATIVE_DOUBLE;
+        }
+        else if(cls == H5T_FLOAT){
+            tensor.type = dyn::Type::FLOAT32;
+            memtype = H5T_NATIVE_FLOAT;
+        }
+        else if(cls == H5T_INTEGER && dts == 1){
+            tensor.type = dyn::Type::INT8;
+            memtype = H5T_NATIVE_INT8;
+        }
+        else{
+            H5Sclose(space); H5Dclose(ds); return false;
+        }
+        rl_tools::malloc(device, tensor);
+        herr_t err = H5Dread(ds, memtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, tensor.data);
+        H5Sclose(space);
+        H5Dclose(ds);
+        return err >= 0;
+    }
+#endif
+
+    // --- Load a dyn::Layer (backend-agnostic) ---
+    template <typename DEVICE, typename TI, typename GROUP>
+    bool load(DEVICE& device, dyn::Layer<TI>& layer, GROUP& group){
+        using namespace dyn;
+        constexpr TI ATTR_SIZE = 64;
+        char type_str[ATTR_SIZE];
+        get_attribute<char*>(device, group, "type", type_str, ATTR_SIZE);
+        bool ok = true;
+
+        if(utils::string::compare(type_str, "dense", 5)){
+            layer.type = LayerType::DENSE;
+            auto* d = new layers::Dense<TI>();
+            auto wg = get_group(device, group, "weights"); ok &= load(device, d->weights, wg, "parameters");
+            auto bg = get_group(device, group, "biases"); ok &= load(device, d->biases, bg, "parameters");
+            d->output_dim = d->weights.shape[0]; d->input_dim = d->weights.shape[1];
+            char af[ATTR_SIZE]; get_attribute<char*>(device, group, "activation_function", af, ATTR_SIZE);
+            d->activation_function = persist_helpers::parse_activation_function(device, af, ATTR_SIZE);
+            layer.data = d;
+        }
+        else if(utils::string::compare(type_str, "gru", 3)){
+            layer.type = LayerType::GRU;
+            auto* g = new layers::GRU<TI>();
+            auto wig = get_group(device, group, "weights_input"); ok &= load(device, g->weights_input, wig, "parameters");
+            auto big = get_group(device, group, "biases_input"); ok &= load(device, g->biases_input, big, "parameters");
+            auto whg = get_group(device, group, "weights_hidden"); ok &= load(device, g->weights_hidden, whg, "parameters");
+            auto bhg = get_group(device, group, "biases_hidden"); ok &= load(device, g->biases_hidden, bhg, "parameters");
+            auto ihg = get_group(device, group, "initial_hidden_state"); ok &= load(device, g->initial_hidden_state, ihg, "parameters");
+            g->hidden_dim = g->weights_input.shape[0] / 3; g->input_dim = g->weights_input.shape[1];
+            layer.data = g;
+        }
+        else if(utils::string::compare(type_str, "conv2d", 6)){
+            layer.type = LayerType::CONV2D;
+            auto* c = new layers::Conv2d<TI>();
+            auto wg = get_group(device, group, "weights"); ok &= load(device, c->weights, wg, "parameters");
+            auto bg = get_group(device, group, "biases"); ok &= load(device, c->biases, bg, "parameters");
+            c->output_channels = get_attribute_int<TI>(device, group, "output_channels");
+            c->input_channels = get_attribute_int<TI>(device, group, "input_channels");
+            c->kernel_height = get_attribute_int<TI>(device, group, "kernel_height");
+            c->kernel_width = get_attribute_int<TI>(device, group, "kernel_width");
+            c->stride_h = get_attribute_int<TI>(device, group, "stride_h");
+            c->stride_w = get_attribute_int<TI>(device, group, "stride_w");
+            c->padding_h = get_attribute_int<TI>(device, group, "padding_h");
+            c->padding_w = get_attribute_int<TI>(device, group, "padding_w");
+            char af[ATTR_SIZE]; get_attribute<char*>(device, group, "activation_function", af, ATTR_SIZE);
+            c->activation_function = persist_helpers::parse_activation_function(device, af, ATTR_SIZE);
+            char norm[ATTR_SIZE]; get_attribute<char*>(device, group, "normalization", norm, ATTR_SIZE);
+            if(utils::string::compare(norm, "BATCH_NORM", 10)) c->normalization = layers::Conv2d<TI>::Normalization::BATCH_NORM;
+            else if(utils::string::compare(norm, "LAYER_NORM", 10)) c->normalization = layers::Conv2d<TI>::Normalization::LAYER_NORM;
+            else c->normalization = layers::Conv2d<TI>::Normalization::NONE;
+            if(c->normalization != layers::Conv2d<TI>::Normalization::NONE){
+                auto gg = get_group(device, group, "gamma"); ok &= load(device, c->gamma, gg, "parameters");
+                auto btg = get_group(device, group, "beta"); ok &= load(device, c->beta, btg, "parameters");
+                if(c->normalization == layers::Conv2d<TI>::Normalization::BATCH_NORM){
+                    ok &= load(device, c->running_mean, group, "running_mean");
+                    ok &= load(device, c->running_var, group, "running_var");
+                }
+            }
+            layer.data = c;
+        }
+        else if(utils::string::compare(type_str, "max_pool2d", 10)){
+            layer.type = LayerType::MAX_POOL2D;
+            auto* mp = new layers::MaxPool2d<TI>();
+            mp->kernel_height = get_attribute_int<TI>(device, group, "kernel_height");
+            mp->kernel_width = get_attribute_int<TI>(device, group, "kernel_width");
+            mp->stride_h = get_attribute_int<TI>(device, group, "stride_h");
+            mp->stride_w = get_attribute_int<TI>(device, group, "stride_w");
+            mp->padding_h = get_attribute_int<TI>(device, group, "padding_h");
+            mp->padding_w = get_attribute_int<TI>(device, group, "padding_w");
+            layer.data = mp;
+        }
+        else if(utils::string::compare(type_str, "standardize", 11)){
+            layer.type = LayerType::STANDARDIZE;
+            auto* s = new layers::Standardize<TI>();
+            auto mg = get_group(device, group, "mean"); ok &= load(device, s->mean, mg, "parameters");
+            auto pg = get_group(device, group, "precision"); ok &= load(device, s->precision, pg, "parameters");
+            s->dim = s->mean.size(); layer.data = s;
+        }
+        else if(utils::string::compare(type_str, "embedding", 9)){
+            layer.type = LayerType::EMBEDDING;
+            auto* e = new layers::Embedding<TI>();
+            auto wg = get_group(device, group, "weights"); ok &= load(device, e->weights, wg, "parameters");
+            e->num_classes = e->weights.shape[0]; e->embedding_dim = e->weights.shape[1]; layer.data = e;
+        }
+        else if(utils::string::compare(type_str, "sample_and_squash", 17)){ layer.type = LayerType::SAMPLE_AND_SQUASH; }
+        else if(utils::string::compare(type_str, "flatten", 7)){ layer.type = LayerType::FLATTEN; }
+        else if(utils::string::compare(type_str, "unflatten", 9)){
+            layer.type = LayerType::UNFLATTEN;
+            auto* u = new layers::Unflatten<TI>();
+            u->height = 0; u->width = 0; u->channels = 0;
+            if(!attribute_exists(device, group, "height") || !attribute_exists(device, group, "width") || !attribute_exists(device, group, "channels")){
+                return false;
+            }
+            u->height = get_attribute_int<TI>(device, group, "height");
+            u->width = get_attribute_int<TI>(device, group, "width");
+            u->channels = get_attribute_int<TI>(device, group, "channels");
+            layer.data = u;
+        }
+        else if(utils::string::compare(type_str, "avg_pool2d", 10)){ layer.type = LayerType::AVG_POOL2D; }
+        else if(utils::string::compare(type_str, "sequential", 10)){
+            layer.type = LayerType::SEQUENTIAL;
+            auto layers_group = get_group(device, group, "layers");
+            TI count = 0;
+            for(TI i = 0; i < 100; i++){ char idx[10]; utils::string::int_to_string<long int, TI>(idx, 10, i); if(!group_exists(device, layers_group, idx)) break; count++; }
+            layer.num_children = count; layer.children = new Layer<TI>[count];
+            for(TI i = 0; i < count; i++){ char idx[10]; utils::string::int_to_string<long int, TI>(idx, 10, i); auto lg = get_group(device, layers_group, idx); ok &= load(device, layer.children[i], lg); }
+        }
+        else if(utils::string::compare(type_str, "mlp", 3)){
+            layer.type = LayerType::MLP;
+            TI num_layers = get_attribute_int<TI>(device, group, "num_layers");
+            layer.num_children = num_layers; layer.children = new Layer<TI>[num_layers];
+            auto ig = get_group(device, group, "input_layer"); ok &= load(device, layer.children[0], ig);
+            auto hg = get_group(device, group, "hidden_layers");
+            for(TI i = 0; i < num_layers - 2; i++){ char idx[10]; utils::string::int_to_string<long int, TI>(idx, 10, i); auto hlg = get_group(device, hg, idx); ok &= load(device, layer.children[1+i], hlg); }
+            auto og = get_group(device, group, "output_layer"); ok &= load(device, layer.children[num_layers-1], og);
+        }
+        else if(utils::string::compare(type_str, "resnet_block", 12)){
+            layer.type = LayerType::RESNET_BLOCK;
+            bool has_ds = group_exists(device, group, "downsample");
+            layer.num_children = has_ds ? 3 : 2; layer.children = new Layer<TI>[layer.num_children];
+            auto c1g = get_group(device, group, "conv1"); ok &= load(device, layer.children[0], c1g);
+            auto c2g = get_group(device, group, "conv2"); ok &= load(device, layer.children[1], c2g);
+            if(has_ds){ auto dsg = get_group(device, group, "downsample"); ok &= load(device, layer.children[2], dsg); }
+        }
+        else if(utils::string::compare(type_str, "parallel", 8)){
+            layer.type = LayerType::PARALLEL;
+            auto* p = new layers::Parallel<TI>();
+            layer.data = p;
+            p->num_branches = get_attribute_int<TI>(device, group, "num_branches");
+            p->has_head = (get_attribute_int<TI>(device, group, "has_head") != 0);
+            if(p->num_branches > layers::Parallel<TI>::MAX_BRANCHES) return false;
+            layer.num_children = p->num_branches + (p->has_head ? 1 : 0);
+            layer.children = new Layer<TI>[layer.num_children];
+            for(TI i = 0; i < p->num_branches; i++){
+                char idx[10]; utils::string::int_to_string<long int, TI>(idx, 10, i);
+                char name[16] = "branch_"; TI nlen = 7;
+                for(TI j = 0; idx[j] != '\0' && nlen + 1 < 16; j++) name[nlen++] = idx[j];
+                name[nlen] = '\0';
+                auto bg = get_group(device, group, name);
+                constexpr TI BUF_SIZE = 128;
+                char shape_buf[BUF_SIZE];
+                get_attribute<char*>(device, bg, "input_shape", shape_buf, BUF_SIZE);
+                TI rank = 0, cur = 0;
+                bool have_digit = false;
+                for(TI j = 0; j < BUF_SIZE && shape_buf[j] != '\0'; j++){
+                    if(shape_buf[j] == ','){
+                        if(rank < layers::Parallel<TI>::MAX_RANK) p->input_shapes[i][rank] = cur;
+                        rank++; cur = 0; have_digit = false;
+                    }
+                    else if(shape_buf[j] >= '0' && shape_buf[j] <= '9'){
+                        cur = cur * 10 + (shape_buf[j] - '0'); have_digit = true;
+                    }
+                }
+                if(have_digit && rank < layers::Parallel<TI>::MAX_RANK) p->input_shapes[i][rank++] = cur;
+                p->input_ranks[i] = rank;
+                ok &= load(device, layer.children[i], bg);
+            }
+            if(p->has_head){
+                auto hg = get_group(device, group, "head");
+                ok &= load(device, layer.children[p->num_branches], hg);
+            }
+        }
+        else{ return false; }
+        return ok;
+    }
+
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/dyn/policy_adapter.h

@@ -0,0 +1,100 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DYN_POLICY_ADAPTER_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DYN_POLICY_ADAPTER_H
+
+#include "model.h"
+#include "operations_generic.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::dyn{
+    template <typename T_TI>
+    struct PolicyState{
+        using TI = T_TI;
+        State<TI> inner{};
+    };
+    template <typename T_TI>
+    struct PolicyBuffer{
+        using TI = T_TI;
+        Buffer<TI> inner{};
+        Tensor<TensorSpecification<TI>> dyn_input{};
+        Tensor<TensorSpecification<TI>> dyn_output{};
+    };
+    template <typename T_TI, T_TI T_INPUT_DIM, T_TI T_OUTPUT_DIM>
+    struct Policy{
+        using TI = T_TI;
+        static constexpr TI INPUT_DIM = T_INPUT_DIM;
+        static constexpr TI OUTPUT_DIM = T_OUTPUT_DIM;
+        Layer<TI> layer{};
+        using INPUT_SHAPE = tensor::Shape<TI, 1, INPUT_DIM>;
+        using OUTPUT_SHAPE = tensor::Shape<TI, 1, OUTPUT_DIM>;
+        template <bool DA = true> using State = PolicyState<TI>;
+        template <bool DA = true> using Buffer = PolicyBuffer<TI>;
+    };
+}
+namespace rl_tools{ namespace inference{ namespace executor{
+    template <typename TI, TI T_INPUT_DIM, TI T_OUTPUT_DIM, typename T_T, TI T_SPEC_INPUT_DIM, bool T_DA>
+    struct ObservationTensorType<dyn::Policy<TI, T_INPUT_DIM, T_OUTPUT_DIM>, T_T, TI, T_SPEC_INPUT_DIM, T_DA>{
+        using type = dyn::Tensor<dyn::TensorSpecification<TI>>;
+    };
+}}}
+namespace rl_tools{ namespace inference{ namespace applications{ namespace l2f{
+    template <typename TI, TI T_INPUT_DIM, TI T_OUTPUT_DIM, typename T_T, TI T_L2F_INPUT_DIM, TI T_L2F_OUTPUT_DIM, bool T_DA>
+    struct InputTensorType<dyn::Policy<TI, T_INPUT_DIM, T_OUTPUT_DIM>, T_T, TI, T_L2F_INPUT_DIM, T_L2F_OUTPUT_DIM, T_DA>{
+        using type = dyn::Tensor<dyn::TensorSpecification<TI>>;
+    };
+    template <typename TI, TI T_INPUT_DIM, TI T_OUTPUT_DIM, typename T_T, TI T_L2F_INPUT_DIM, TI T_L2F_OUTPUT_DIM, bool T_DA>
+    struct OutputTensorType<dyn::Policy<TI, T_INPUT_DIM, T_OUTPUT_DIM>, T_T, TI, T_L2F_INPUT_DIM, T_L2F_OUTPUT_DIM, T_DA>{
+        using type = dyn::Tensor<dyn::TensorSpecification<TI>>;
+    };
+}}}}
+namespace rl_tools{
+    template <typename DEVICE, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, dyn::PolicyState<TI>& state){
+        rl_tools::malloc(device, state.inner);
+    }
+    template <typename DEVICE, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, dyn::PolicyState<TI>& state){
+        rl_tools::free(device, state.inner);
+    }
+    template <typename DEVICE, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy(DEVICE& d1, DEVICE& d2, const dyn::PolicyState<TI>& src, dyn::PolicyState<TI>& dst){
+        rl_tools::copy(d1, d2, src.inner, dst.inner);
+    }
+    template <typename DEVICE, typename TI, TI INPUT_DIM, TI OUTPUT_DIM, typename RNG>
+    RL_TOOLS_FUNCTION_PLACEMENT void reset(DEVICE& device, dyn::Policy<TI, INPUT_DIM, OUTPUT_DIM>& policy, dyn::PolicyState<TI>& state, RNG& rng){
+        rl_tools::reset(device, policy.layer, state.inner);
+    }
+    template <typename DEVICE, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, dyn::PolicyBuffer<TI>& buffer){
+        rl_tools::malloc(device, buffer.inner);
+        rl_tools::malloc(device, buffer.dyn_input);
+        rl_tools::malloc(device, buffer.dyn_output);
+    }
+    template <typename DEVICE, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, dyn::PolicyBuffer<TI>& buffer){
+        rl_tools::free(device, buffer.inner);
+        rl_tools::free(device, buffer.dyn_input);
+        rl_tools::free(device, buffer.dyn_output);
+    }
+    template <typename DEVICE, typename TI, TI INPUT_DIM, TI OUTPUT_DIM>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, dyn::Policy<TI, INPUT_DIM, OUTPUT_DIM>& policy){
+        rl_tools::free(device, policy.layer);
+    }
+    template <typename DEVICE, typename TI, TI INPUT_DIM, TI OUTPUT_DIM, typename OBS_SPEC, typename OUTPUT_SPEC, typename RNG, typename MODE>
+    RL_TOOLS_FUNCTION_PLACEMENT void evaluate_step(DEVICE& device, dyn::Policy<TI, INPUT_DIM, OUTPUT_DIM>& policy, Tensor<OBS_SPEC>& observation, dyn::PolicyState<TI>& state, Tensor<OUTPUT_SPEC>& output, dyn::PolicyBuffer<TI>& buffer, RNG& rng, MODE mode){
+        for(TI i = 0; i < OBS_SPEC::SHAPE::LAST; i++){
+            set(device, buffer.dyn_input, get(device, observation, 0, i), i);
+        }
+        rl_tools::evaluate_step(device, policy.layer, buffer.dyn_input, state.inner, buffer.dyn_output, buffer.inner);
+        for(TI i = 0; i < OUTPUT_SPEC::SHAPE::LAST; i++){
+            set(device, output, get(device, buffer.dyn_output, i), 0, i);
+        }
+    }
+    template <typename DEVICE, typename TI, TI INPUT_DIM, TI OUTPUT_DIM, typename RNG, typename MODE>
+    RL_TOOLS_FUNCTION_PLACEMENT void evaluate_step(DEVICE& device, dyn::Policy<TI, INPUT_DIM, OUTPUT_DIM>& policy, dyn::Tensor<dyn::TensorSpecification<TI>>& observation, dyn::PolicyState<TI>& state, dyn::Tensor<dyn::TensorSpecification<TI>>& action, dyn::PolicyBuffer<TI>& buffer, RNG& rng, MODE mode){
+        rl_tools::evaluate_step(device, policy.layer, observation, state.inner, action, buffer.inner);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/dyn/policy_adapter_persist.h

@@ -0,0 +1,52 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DYN_POLICY_ADAPTER_PERSIST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DYN_POLICY_ADAPTER_PERSIST_H
+
+#include "policy_adapter.h"
+#include "persist.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE, typename SPEC, typename TI, TI INPUT_DIM, TI OUTPUT_DIM, typename GROUP>
+    bool load(DEVICE& device, inference::applications::L2F<SPEC>& l2f, dyn::Policy<TI, INPUT_DIM, OUTPUT_DIM>& policy, GROUP& actor_group){
+        if(!rl_tools::load(device, policy.layer, actor_group)){
+            return false;
+        }
+        TI input_dim = dyn::infer_flat_input_dim(policy.layer);
+        if(input_dim == 0){
+            return false;
+        }
+        TI input_shape[] = {1, input_dim};
+        dyn::propagate_shapes(policy.layer, input_shape, (TI)2);
+        if(policy.layer.output_size == 0){
+            return false;
+        }
+        TI output_dim = policy.layer.output_shape[policy.layer.output_rank - 1];
+        if(output_dim != OUTPUT_DIM){
+            return false;
+        }
+        auto& executor = l2f.executor;
+        executor.policy_state.inner.batch_size = 1;
+        executor.policy_state.inner.layer = &policy.layer;
+        executor.policy_state_temp.inner.batch_size = 1;
+        executor.policy_state_temp.inner.layer = &policy.layer;
+        executor.policy_buffer.inner.layer = &policy.layer;
+        dyn::set_shape(executor.policy_buffer.dyn_input, (TI)2, input_shape);
+        executor.policy_buffer.dyn_input.type = dyn::Type::FLOAT32;
+        TI output_shape[] = {1, output_dim};
+        dyn::set_shape(executor.policy_buffer.dyn_output, (TI)2, output_shape);
+        executor.policy_buffer.dyn_output.type = dyn::Type::FLOAT32;
+        executor.policy_buffer.dyn_output.capacity = policy.layer.output_size;
+        dyn::set_shape(executor.observation, (TI)2, input_shape);
+        executor.observation.type = dyn::Type::FLOAT32;
+        dyn::set_shape(l2f.input, (TI)2, input_shape);
+        l2f.input.type = dyn::Type::FLOAT32;
+        dyn::set_shape(l2f.output, (TI)2, output_shape);
+        l2f.output.type = dyn::Type::FLOAT32;
+        rl_tools::malloc(device, l2f);
+        return true;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/dyn/tensor_operations_generic.h

@@ -0,0 +1,55 @@
+#include "../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_DYN_TENSOR_OPERATIONS_GENERIC_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_DYN_TENSOR_OPERATIONS_GENERIC_H
+
+#include "model.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    namespace dyn{
+        template <typename TI>
+        RL_TOOLS_FUNCTION_PLACEMENT void set_shape(Tensor<TensorSpecification<TI>>& tensor, TI rank, const TI* shape){
+            tensor.rank = rank;
+            for(TI i = 0; i < rank; i++) tensor.shape[i] = shape[i];
+        }
+    }
+    template <typename DEVICE, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT float get(DEVICE& device, const dyn::Tensor<dyn::TensorSpecification<TI>>& tensor, TI flat_index){
+        return dyn::to_float(reinterpret_cast<const char*>(tensor.data) + flat_index * dyn::size_of<TI>(tensor.type), tensor.type);
+    }
+    template <typename DEVICE, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void set(DEVICE& device, dyn::Tensor<dyn::TensorSpecification<TI>>& tensor, float value, TI flat_index){
+        dyn::from_float(reinterpret_cast<char*>(tensor.data) + flat_index * dyn::size_of<TI>(tensor.type), value, tensor.type);
+    }
+    template <typename DEVICE, typename TI, typename TI2, typename TI3>
+    RL_TOOLS_FUNCTION_PLACEMENT float get(DEVICE& device, const dyn::Tensor<dyn::TensorSpecification<TI>>& tensor, TI2 dim0, TI3 dim1){
+        return get(device, tensor, (TI)(dim0 * tensor.shape[1] + dim1));
+    }
+    template <typename DEVICE, typename TI, typename TI2, typename TI3>
+    RL_TOOLS_FUNCTION_PLACEMENT void set(DEVICE& device, dyn::Tensor<dyn::TensorSpecification<TI>>& tensor, float value, TI2 dim0, TI3 dim1){
+        set(device, tensor, value, (TI)(dim0 * tensor.shape[1] + dim1));
+    }
+    template <typename DEVICE, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void copy(DEVICE& d1, DEVICE& d2, const dyn::Tensor<dyn::TensorSpecification<TI>>& src, dyn::Tensor<dyn::TensorSpecification<TI>>& dst){
+        for(TI i = 0; i < src.size(); i++) set(d1, dst, get(d1, src, i), i);
+    }
+    template <typename DEVICE, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void scale(DEVICE& device, dyn::Tensor<dyn::TensorSpecification<TI>>& tensor, float factor){
+        for(TI i = 0; i < tensor.size(); i++) set(device, tensor, get(device, tensor, i) * factor, i);
+    }
+    template <typename DEVICE, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void malloc(DEVICE& device, dyn::Tensor<dyn::TensorSpecification<TI>>& tensor){
+        TI s = tensor.size();
+        if(s > 0){
+            tensor.data = new char[s * dyn::size_of<TI>(tensor.type)];
+            if(tensor.capacity == 0) tensor.capacity = s;
+        }
+    }
+    template <typename DEVICE, typename TI>
+    RL_TOOLS_FUNCTION_PLACEMENT void free(DEVICE& device, dyn::Tensor<dyn::TensorSpecification<TI>>& tensor){
+        if(tensor.data){ delete[] reinterpret_cast<char*>(tensor.data); tensor.data = nullptr; }
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/inference/applications/l2f/c_backend.h

@@ -0,0 +1,117 @@
+#include "../../executor/operations_generic.h"
+#include "c_interface.h"
+#include "../../executor/c_backend.h"
+#include "operations_generic.h"
+
+namespace rl_tools::inference::applications::l2f{
+    using CONFIG = RL_TOOLS_INFERENCE_APPLICATIONS_L2F_CONFIG;
+    using TYPE_POLICY = typename CONFIG::TYPE_POLICY;
+    using TI = typename CONFIG::TI;
+
+    static constexpr TI TEST_SEQUENCE_LENGTH = rlt::checkpoint::example::inputs::_0::SHAPE::template GET<0>;
+    static constexpr TI TEST_BATCH_SIZE = rlt::checkpoint::example::inputs::_0::SHAPE::template GET<1>;
+    static_assert(CONFIG::TEST_BATCH_SIZE_ACTUAL <= TEST_BATCH_SIZE);
+    static_assert(CONFIG::TEST_SEQUENCE_LENGTH_ACTUAL <= TEST_SEQUENCE_LENGTH);
+
+    static constexpr TI INPUT_DIM = CONFIG::POLICY::INPUT_SHAPE::LAST;
+    static constexpr TI OUTPUT_DIM = CONFIG::POLICY::OUTPUT_SHAPE::LAST;
+    static_assert(OUTPUT_DIM == 4);
+    static_assert(INPUT_DIM == (18 + CONFIG::ACTION_HISTORY_LENGTH * OUTPUT_DIM));
+
+
+    // state
+    using SPEC = rl_tools::inference::applications::l2f::Specification<TYPE_POLICY, TI, RLtoolsInferenceTimestamp, CONFIG::ACTION_HISTORY_LENGTH, OUTPUT_DIM, typename CONFIG::POLICY, CONFIG::CONTROL_INTERVAL_INTERMEDIATE_NS, CONFIG::CONTROL_INTERVAL_NATIVE_NS, CONFIG::FORCE_SYNC_INTERMEDIATE, CONFIG::FORCE_SYNC_NATIVE, CONFIG::FORCE_SYNC_NATIVE_RUNTIME, CONFIG::WARNING_LEVELS, CONFIG::DYNAMIC_ALLOCATION>;
+    typename CONFIG::DEVICE device;
+    typename CONFIG::RNG rng;
+    static rl_tools::inference::applications::L2F<SPEC> executor;
+    // Test Buffers
+    #ifndef RL_TOOLS_DISABLE_TEST
+    static CONFIG::POLICY_TEST::template Buffer<false> buffers_test;
+    static CONFIG::POLICY_TEST::State<false> policy_state_test;
+    static rl_tools::Tensor<rl_tools::tensor::Specification<TYPE_POLICY::DEFAULT, TI, rl_tools::tensor::Shape<TI, 1, OUTPUT_DIM>, false>> output;
+    #endif
+}
+
+
+
+// Main functions (possibly with side effects)
+void rl_tools_inference_applications_l2f_reset(){
+    using namespace rl_tools::inference::applications::l2f;
+    rl_tools::reset(device, executor, CONFIG::policy(), rng);
+}
+void rl_tools_inference_applications_l2f_init(){
+    using namespace rl_tools::inference::applications::l2f;
+    TI seed = 0;
+    rl_tools::malloc(device, executor);
+    rl_tools::init(device, rng, seed);
+    rl_tools_inference_applications_l2f_reset();
+}
+
+const char* rl_tools_inference_applications_l2f_checkpoint_name(){
+    return rl_tools::checkpoint::meta::name;
+}
+
+float rl_tools_inference_applications_l2f_test(RLtoolsInferenceApplicationsL2FAction* p_output){
+    using namespace rl_tools::inference::applications::l2f;
+#ifndef RL_TOOLS_DISABLE_TEST
+    rl_tools::Mode<rl_tools::mode::Evaluation<>> mode;
+    float acc = 0;
+    uint64_t num_values = 0;
+    for(TI batch_i = 0; batch_i < CONFIG::TEST_BATCH_SIZE_ACTUAL; batch_i++){
+        rl_tools::reset(device, CONFIG::policy(), policy_state_test, rng);
+        for(TI step_i = 0; step_i < CONFIG::TEST_SEQUENCE_LENGTH_ACTUAL; step_i++){
+            const auto step_input = rl_tools::view(device, rl_tools::checkpoint::example::inputs::_0::container, step_i);
+            const auto batch_input = rl_tools::view_range(device, step_input, batch_i, rl_tools::tensor::ViewSpec<0, 1>{});
+            rl_tools::utils::assert_exit(device, !rl_tools::is_nan(device, batch_input), "input is nan");
+            // rl_tools::utils::assert_exit(device, !rl_tools::is_nan(device, policy_state_test.content_state.next_content_state.state.state), "state is nan");
+            rl_tools::evaluate_step(device, CONFIG::policy(), batch_input, policy_state_test, output, buffers_test, rng, mode);
+            rl_tools::utils::assert_exit(device, !rl_tools::is_nan(device, output), "output is nan");
+            for(TI action_i = 0; action_i < OUTPUT_DIM; action_i++){
+                acc += rl_tools::math::abs(device.math, rl_tools::get(device, output, 0, action_i) - rl_tools::get(device, rl_tools::checkpoint::example::outputs::_0::container, step_i, batch_i, action_i));
+                num_values += 1;
+                rl_tools::utils::assert_exit(device, !rl_tools::math::is_nan(device.math, acc), "output is nan");
+                if(batch_i == 0 && step_i == CONFIG::TEST_SEQUENCE_LENGTH_ACTUAL-1){
+                    p_output->action[action_i] = rl_tools::get(device, output, 0, action_i);
+                }
+            }
+        }
+    }
+    return acc / num_values;
+#else
+    return 0;
+#endif
+}
+
+void rl_tools_inference_applications_l2f_set_force_sync_native(uint32_t force_sync_native){
+    using namespace rl_tools::inference::applications::l2f;
+    executor.executor.force_sync_native = force_sync_native;
+    executor.executor.force_sync_native_initialized = true;
+}
+
+
+RLtoolsInferenceExecutorStatus rl_tools_inference_applications_l2f_control(RLtoolsInferenceTimestamp nanoseconds, RLtoolsInferenceApplicationsL2FObservation* c_observation, RLtoolsInferenceApplicationsL2FAction* c_action){
+    using namespace rl_tools::inference::applications::l2f;
+    static_assert(RL_TOOLS_INTERFACE_APPLICATIONS_L2F_ACTION_DIM == OUTPUT_DIM);
+    rl_tools::inference::applications::l2f::Observation<SPEC> observation;
+    for (TI dim_i = 0; dim_i < 3; dim_i++){
+        observation.position[dim_i] = c_observation->position[dim_i];
+        observation.orientation[dim_i] = c_observation->orientation[dim_i];
+        observation.linear_velocity[dim_i] = c_observation->linear_velocity[dim_i];
+        observation.angular_velocity[dim_i] = c_observation->angular_velocity[dim_i];
+    }
+    observation.orientation[3] = c_observation->orientation[3];
+    for (TI action_i=0; action_i < OUTPUT_DIM; action_i++){
+        observation.previous_action[action_i] = c_observation->previous_action[action_i];
+    }
+    observation.position_set = true;
+    observation.orientation_set = true;
+    observation.linear_velocity_set = true;
+    observation.angular_velocity_set = true;
+    observation.previous_action_set = true;
+    rl_tools::inference::applications::l2f::Action<SPEC> action;
+    auto status = rl_tools::control(device, executor, nanoseconds, CONFIG::policy(), observation, action, rng);
+    for (TI action_i=0; action_i < OUTPUT_DIM; action_i++){
+        c_action->action[action_i] = action.action[action_i];
+    }
+    return rl_tools::convert(status);
+}

hyperdrone/_vendor/rl-tools/include/rl_tools/inference/applications/l2f/c_interface.h

@@ -0,0 +1,36 @@
+#ifndef RL_TOOLS_INFERENCE_APPLICATIONS_L2F_C_INTERFACE_H
+#define RL_TOOLS_INFERENCE_APPLICATIONS_L2F_C_INTERFACE_H
+
+#include <stdint.h>
+
+#include "../../executor/c_interface.h"
+#define RL_TOOLS_INTERFACE_APPLICATIONS_L2F_ACTION_DIM 4
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    typedef struct {
+        float position[3];
+        float orientation[4]; // Quaternion: w, x, y, z
+        float linear_velocity[3];
+        float angular_velocity[3];
+        float previous_action[RL_TOOLS_INTERFACE_APPLICATIONS_L2F_ACTION_DIM];
+    } RLtoolsInferenceApplicationsL2FObservation;
+    typedef struct {
+        float action[RL_TOOLS_INTERFACE_APPLICATIONS_L2F_ACTION_DIM];
+    } RLtoolsInferenceApplicationsL2FAction;
+
+    void rl_tools_inference_applications_l2f_init();
+    void rl_tools_inference_applications_l2f_reset();
+    float rl_tools_inference_applications_l2f_test(RLtoolsInferenceApplicationsL2FAction* action);
+    // note: DON'T pass an uint32 timestamp here, which might wrap around after ~1h
+    void rl_tools_inference_applications_l2f_set_force_sync_native(uint32_t force_sync_native);
+    RLtoolsInferenceExecutorStatus rl_tools_inference_applications_l2f_control(uint64_t nanoseconds, RLtoolsInferenceApplicationsL2FObservation* observation, RLtoolsInferenceApplicationsL2FAction* action);
+    const char* rl_tools_inference_applications_l2f_checkpoint_name();
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif