hyperray 0.0.1__py3-none-any.whl

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/extrack/config.h

@@ -0,0 +1,22 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_EXTRACK_CONFIG_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_EXTRACK_CONFIG_H
+
+#include "state.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::loop::steps::extrack{
+    template<typename T_NEXT>
+    struct Config: T_NEXT {
+        using NEXT = T_NEXT;
+        template <typename CONFIG>
+        using State = State<CONFIG>;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif
+
+
+
+

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/extrack/operations_cpu.h

@@ -0,0 +1,44 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_EXTRACK_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_EXTRACK_OPERATIONS_CPU_H
+
+#include "config.h"
+#include "../../../../utils/extrack/operations_cpu.h"
+
+#include <iostream>
+#include <chrono>
+#include <iomanip>
+#include <ctime>
+#include <sstream>
+
+#include <cstdlib>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE, typename T_CONFIG>
+    void init(DEVICE& device, rl::loop::steps::extrack::State<T_CONFIG>& ts, typename T_CONFIG::TI seed = 0){
+        using STATE = rl::loop::steps::extrack::State<T_CONFIG>;
+        init(device, static_cast<typename STATE::NEXT&>(ts), seed);
+        init(device, ts.extrack_config, ts.extrack_paths, seed);
+    }
+
+
+    template <typename DEVICE, typename T_CONFIG>
+    void free(DEVICE& device, rl::loop::steps::extrack::State<T_CONFIG>& ts){
+        using STATE = rl::loop::steps::extrack::State<T_CONFIG>;
+        free(device, static_cast<typename STATE::NEXT&>(ts));
+    }
+
+    template <typename DEVICE, typename CONFIG>
+    bool step(DEVICE& device, rl::loop::steps::extrack::State<CONFIG>& ts){
+        using TI = typename CONFIG::TI;
+        using STATE = rl::loop::steps::extrack::State<CONFIG>;
+        bool finished = step(device, static_cast<typename STATE::NEXT&>(ts));
+        return finished;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/extrack/persist.h

@@ -0,0 +1,20 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_EXTRACK_PERSIST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_EXTRACK_PERSIST_H
+#include "state.h"
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE, typename T_CONFIG, typename GROUP>
+    void save(DEVICE& device, rl::loop::steps::extrack::State<T_CONFIG>& ts, GROUP& group){
+        using STATE = rl::loop::steps::extrack::State<T_CONFIG>;
+        save(device, static_cast<typename STATE::NEXT&>(ts), group);
+    }
+    template <typename DEVICE, typename T_CONFIG, typename GROUP>
+    bool load(DEVICE& device, rl::loop::steps::extrack::State<T_CONFIG>& ts, GROUP& group){
+        using STATE = rl::loop::steps::extrack::State<T_CONFIG>;
+        return load(device, static_cast<typename STATE::NEXT&>(ts), group);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/extrack/state.h

@@ -0,0 +1,26 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_EXTRACK_STATE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_EXTRACK_STATE_H
+
+
+#include <chrono>
+#include <filesystem>
+#include "../../../../utils/extrack/operations_cpu.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::loop::steps::extrack{
+    template<typename T_CONFIG, typename T_NEXT = typename T_CONFIG::NEXT::template State<typename T_CONFIG::NEXT>>
+    struct State: T_NEXT {
+        using CONFIG = T_CONFIG;
+        using NEXT = T_NEXT;
+        rl_tools::utils::extrack::Config<typename T_CONFIG::TI> extrack_config;
+        rl_tools::utils::extrack::Paths extrack_paths;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif
+
+
+
+

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/nn_analytics/config.h

@@ -0,0 +1,37 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_NN_ANALYTICS_CONFIG_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_NN_ANALYTICS_CONFIG_H
+
+
+#include "../../../../rl/environments/environments.h"
+
+#include "state.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::loop::steps::nn_analytics{
+    struct ParametersTag{};
+    template <typename TYPE_POLICY, typename TI, typename NEXT>
+    struct Parameters{
+        using TAG = ParametersTag;
+        static constexpr TI INTERVAL = 1000;
+        static constexpr TI WARMUP_STEPS = 0;
+    };
+    struct ConfigTag{};
+    template<typename T_NEXT, typename T_PARAMETERS = Parameters<typename T_NEXT::TYPE_POLICY, typename T_NEXT::TI, T_NEXT>>
+    struct Config: T_NEXT {
+        using TAG = ConfigTag;
+        using NEXT = T_NEXT;
+        using NN_ANALYTICS_PARAMETERS = T_PARAMETERS;
+        using TYPE_POLICY = typename NEXT::TYPE_POLICY;
+        using TI = typename NEXT::TI;
+        template <typename CONFIG>
+        using State = State<CONFIG>;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif
+
+
+
+

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/nn_analytics/operations_cpu.h

@@ -0,0 +1,113 @@
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_NN_ANALYTICS_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_NN_ANALYTICS_OPERATIONS_CPU_H
+
+#include "../../../../rl/algorithms/sac/operations_generic.h"
+#include "../../../../rl/components/off_policy_runner/operations_generic.h"
+
+#include "../../../../rl/environments/operations_generic.h"
+
+
+#include "../../../../rl/utils/evaluation/operations_generic.h"
+
+#include "../../../../utils/zlib/operations_cpu.h"
+
+#include "config.h"
+#include <string>
+#include <sstream>
+#include <fstream>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE, typename T_CONFIG>
+    void malloc(DEVICE& device, rl::loop::steps::nn_analytics::State<T_CONFIG>& ts){
+        using STATE = rl::loop::steps::nn_analytics::State<T_CONFIG>;
+        malloc(device, static_cast<typename STATE::NEXT&>(ts));
+    }
+    template <typename DEVICE, typename T_CONFIG>
+    void init(DEVICE& device, rl::loop::steps::nn_analytics::State<T_CONFIG>& ts, typename T_CONFIG::TI seed = 0){
+        using STATE = rl::loop::steps::nn_analytics::State<T_CONFIG>;
+        init(device, static_cast<typename STATE::NEXT&>(ts), seed);
+    }
+
+    template <typename DEVICE, typename T_CONFIG>
+    void free(DEVICE& device, rl::loop::steps::nn_analytics::State<T_CONFIG>& ts){
+        using STATE = rl::loop::steps::nn_analytics::State<T_CONFIG>;
+        free(device, static_cast<typename STATE::NEXT&>(ts));
+    }
+
+    namespace rl::loop::steps::nn_analytics{
+        template <auto INDEX, typename DEVICE, typename TS>
+        std::string accumulate_nns(DEVICE& device, TS& ts){
+            using TI = typename DEVICE::index_t;
+            constexpr TI N = TS::CONFIG::NUM_NNS;
+            static_assert(N >= 1);
+            std::string data;
+            if(INDEX == 0){
+                data += "{";
+            }
+            if(INDEX < N){
+                auto& nn = get_nn<INDEX>(device, ts);
+                std::string name = get_nn_name<INDEX>(device, ts);
+                data += "\"" + name + "\": " + rl_tools::nn_analytics(device, nn);
+            }
+            if constexpr(INDEX < N - 1){
+                data += ",";
+                data += accumulate_nns<INDEX + 1>(device, ts);
+            }
+            if (INDEX == 0){
+                data += "}";
+            }
+            return data;
+        }
+    }
+
+    template <typename DEVICE, typename CONFIG>
+    bool step(DEVICE& device, rl::loop::steps::nn_analytics::State<CONFIG>& ts){
+        using TS = rl::loop::steps::nn_analytics::State<CONFIG>;
+        using TI = typename CONFIG::TI;
+        using PARAMETERS = typename CONFIG::NN_ANALYTICS_PARAMETERS;
+        using STATE = rl::loop::steps::nn_analytics::State<CONFIG>;
+        if(ts.step % PARAMETERS::INTERVAL == 0 && (ts.step == 0 || ts.step >= PARAMETERS::WARMUP_STEPS)){
+            const char * env_var = environment_variable(device, "RL_TOOLS_NN_ANALYTICS");
+            if(env_var != nullptr && std::string(env_var) != "1"){
+                std::cout << "RL_TOOLS_NN_ANALYTICS=" << env_var << " is set. Skipping NN Analytics step." << std::endl;
+            }
+            else
+            {
+                std::stringstream step_ss;
+                step_ss << std::setw(15) << std::setfill('0') << ts.step;
+                std::filesystem::path step_path = ts.extrack_paths.seed / "steps" / step_ss.str();
+                std::filesystem::create_directories(step_path);
+                auto data = rl::loop::steps::nn_analytics::accumulate_nns<0>(device, ts);
+#ifndef RL_TOOLS_ENABLE_ZLIB
+                std::string file_extension = "json";
+                std::string data_output = data;
+#else
+                std::string file_extension = "json.gz";
+                std::vector<uint8_t> data_output;
+                if(!compress_zlib(data, data_output)){
+                    std::cerr << "Error while compressing trajectories." << std::endl;
+                    return true;
+                }
+#endif
+                std::ofstream file(step_path / ("nn_analytics." + file_extension), std::ios::binary);
+                file.write(reinterpret_cast<const char*>(data_output.data()), data_output.size());
+                file.close();
+            }
+        }
+        bool finished = step(device, static_cast<typename STATE::NEXT&>(ts));
+        return finished;
+    }
+    // to log the configuration
+    template <typename DEVICE, typename PARAMETERS, typename utils::typing::enable_if<utils::typing::is_same_v<typename PARAMETERS::TAG, rl::loop::steps::nn_analytics::ParametersTag>>::type* = nullptr>
+    void log(DEVICE& device, PARAMETERS){}
+    template <typename DEVICE, typename CONFIG, typename utils::typing::enable_if<utils::typing::is_same_v<typename CONFIG::TAG, rl::loop::steps::nn_analytics::ConfigTag>>::type* = nullptr>
+    void log(DEVICE& device, CONFIG){
+        log(device, typename CONFIG::NEXT{});
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/nn_analytics/persist.h

@@ -0,0 +1,20 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_NN_ANALYTICS_PERSIST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_NN_ANALYTICS_PERSIST_H
+#include "state.h"
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE, typename T_CONFIG, typename GROUP>
+    void save(DEVICE& device, rl::loop::steps::nn_analytics::State<T_CONFIG>& ts, GROUP& group){
+        using STATE = rl::loop::steps::nn_analytics::State<T_CONFIG>;
+        save(device, static_cast<typename STATE::NEXT&>(ts), group);
+    }
+    template <typename DEVICE, typename T_CONFIG, typename GROUP>
+    bool load(DEVICE& device, rl::loop::steps::nn_analytics::State<T_CONFIG>& ts, GROUP& group){
+        using STATE = rl::loop::steps::nn_analytics::State<T_CONFIG>;
+        return load(device, static_cast<typename STATE::NEXT&>(ts), group);
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/nn_analytics/state.h

@@ -0,0 +1,24 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_NN_ANALYTICS_STATE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_NN_ANALYTICS_STATE_H
+
+#include "../../../../rl/utils/evaluation/evaluation.h"
+#include "../../../../utils/generic/typing.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::loop::steps::nn_analytics{
+    template<typename T_CONFIG, typename T_NEXT = typename T_CONFIG::NEXT::template State<typename T_CONFIG::NEXT>>
+    struct State: T_NEXT {
+        using CONFIG = T_CONFIG;
+        using NEXT = T_NEXT;
+        using TYPE_POLICY = typename CONFIG::TYPE_POLICY;
+        using TI = typename CONFIG::TI;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif
+
+
+
+

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/save_trajectories/config.h

@@ -0,0 +1,43 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_SAVE_TRAJECTORIES_CONFIG_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_SAVE_TRAJECTORIES_CONFIG_H
+
+
+#include "../../../../rl/environments/environments.h"
+
+#include "state.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::loop::steps::save_trajectories{
+    struct ParametersTag{};
+    template <typename TYPE_POLICY, typename TI, typename NEXT>
+    struct Parameters{
+        using TAG = ParametersTag;
+        static constexpr bool DETERMINISTIC_EVALUATION = true;
+        static constexpr TI INTERVAL = 1000;
+        static constexpr TI NUM_EPISODES = 10;
+        static constexpr TI EPISODE_STEP_LIMIT = NEXT::CORE_PARAMETERS::EPISODE_STEP_LIMIT;
+        static constexpr bool SAVE_TRAJECTORIES = true;
+        static constexpr bool DETERMINISTIC_INITIAL_STATE = false;
+    };
+    struct ConfigTag{};
+    template<typename T_NEXT, typename T_PARAMETERS = Parameters<typename T_NEXT::TYPE_POLICY, typename T_NEXT::TI, T_NEXT>, typename T_UI = environments::DummyUI>
+    struct Config: T_NEXT {
+        using TAG = ConfigTag;
+        using NEXT = T_NEXT;
+        using SAVE_TRAJECTORIES_PARAMETERS = T_PARAMETERS;
+        using UI = T_UI;
+        using TYPE_POLICY = typename NEXT::TYPE_POLICY;
+        using TI = typename NEXT::TI;
+        using SAVE_TRAJECTORIES_SPEC = rl::utils::evaluation::Specification<TYPE_POLICY, TI, typename NEXT::ENVIRONMENT_EVALUATION, SAVE_TRAJECTORIES_PARAMETERS::NUM_EPISODES, SAVE_TRAJECTORIES_PARAMETERS::EPISODE_STEP_LIMIT, SAVE_TRAJECTORIES_PARAMETERS::DETERMINISTIC_INITIAL_STATE>;
+        template <typename CONFIG>
+        using State = State<CONFIG>;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif
+
+
+
+

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/save_trajectories/operations_cpu.h

@@ -0,0 +1,190 @@
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_SAVE_TRAJECTORIES_OPERATIONS_CPU_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_SAVE_TRAJECTORIES_OPERATIONS_CPU_H
+
+#include "../../../../rl/algorithms/sac/operations_generic.h"
+#include "../../../../rl/components/off_policy_runner/operations_generic.h"
+
+#include "../../../../rl/environments/operations_generic.h"
+
+
+#include "../../../../rl/utils/evaluation/operations_generic.h"
+
+#include "../../../../utils/zlib/operations_cpu.h"
+#include "../../../../utils/extrack/operations_cpu.h"
+
+#include "config.h"
+#include <string>
+#include <sstream>
+#include <fstream>
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE, typename T_CONFIG>
+    void malloc(DEVICE& device, rl::loop::steps::save_trajectories::State<T_CONFIG>& ts){
+        using STATE = rl::loop::steps::save_trajectories::State<T_CONFIG>;
+        malloc(device, ts.actor_deterministic_save_trajectories_state);
+        malloc(device, ts.actor_deterministic_save_trajectories_buffers);
+        malloc(device, ts.rng_save_trajectories);
+        malloc(device, ts.save_trajectories_buffer);
+        malloc(device, ts.save_trajectories_data);
+        malloc(device, static_cast<typename STATE::NEXT&>(ts));
+    }
+    template <typename DEVICE, typename T_CONFIG>
+    void free(DEVICE& device, rl::loop::steps::save_trajectories::State<T_CONFIG>& ts){
+        using STATE = rl::loop::steps::save_trajectories::State<T_CONFIG>;
+        free(device, ts.actor_deterministic_save_trajectories_state);
+        free(device, ts.actor_deterministic_save_trajectories_buffers);
+        free(device, ts.rng_save_trajectories);
+        free(device, ts.save_trajectories_buffer);
+        free(device, ts.save_trajectories_data);
+        free(device, static_cast<typename STATE::NEXT&>(ts));
+    }
+    template <typename DEVICE, typename T_CONFIG>
+    void init(DEVICE& device, rl::loop::steps::save_trajectories::State<T_CONFIG>& ts, typename T_CONFIG::TI seed = 0){
+        using STATE = rl::loop::steps::save_trajectories::State<T_CONFIG>;
+        init(device, static_cast<typename STATE::NEXT&>(ts), seed);
+        init(device, ts.rng_save_trajectories, seed);
+        ts.save_trajectories_ui_written = false;
+        ts.save_trajectories_this_step = false;
+    }
+
+
+    namespace rl::loop::steps::save_trajectories{
+        template <typename DEVICE, typename ENVIRONMENT, typename DATA_SPEC>
+        std::string to_string(DEVICE& device, ENVIRONMENT& env, rl::utils::evaluation::Data<DATA_SPEC>& data){
+            using SPEC = typename DATA_SPEC::SPEC;
+            using TI = typename DEVICE::index_t;
+            std::string episodes_json = "[";
+            for(TI episode_i = 0; episode_i < SPEC::N_EPISODES; episode_i++){
+                std::string episode_json = "{";
+                auto& parameters = get_ref(device, data.parameters, episode_i);
+                episode_json += "\"parameters\": " + std::string(json(device, env, parameters)) + ", \n";
+                std::string trajectory_json = "[";
+                for(TI step_i = 0; step_i < SPEC::STEP_LIMIT; step_i++){
+                    std::string step_json = "{";
+                    auto& state = get_ref(device, data.states, episode_i, step_i);
+                    step_json += "\"state\":" + std::string(json(device, env, parameters, state)) + ", ";
+                    std::string action_json = "\"action\":[";
+                    for(TI action_i = 0; action_i < ENVIRONMENT::ACTION_DIM; action_i++){
+                        action_json += std::to_string(get(device, data.actions, episode_i, step_i, action_i));
+                        action_json += (action_i < ENVIRONMENT::ACTION_DIM - 1) ? ", " : "";
+                        action_json += "\n";
+                    }
+                    action_json.pop_back();
+                    action_json += "]";
+                    step_json += action_json + ",";
+                    step_json += "\"dt\":" + std::to_string(get(device, data.dt, episode_i, step_i)) + ",";
+                    step_json += "\"reward\":" + std::to_string(get(device, data.rewards, episode_i, step_i)) + ",";
+                    step_json += "\"terminated\":" + (get(device, data.terminated, episode_i, step_i) ? std::string("true") : std::string("false"));;
+                    step_json += "}";
+                    trajectory_json += step_json + ",";
+                }
+                trajectory_json.pop_back();
+                trajectory_json += "]";
+                episode_json += "\"trajectory\":" + trajectory_json + "}";
+                episode_json += episode_i < (SPEC::N_EPISODES - 1) ? ", " : "";
+                episode_json += "\n";
+                episodes_json += episode_json;
+            }
+            episodes_json.pop_back();
+            episodes_json += "]";
+            return episodes_json;
+        }
+        template <typename DEVICE>
+        bool write_to_file(DEVICE& device, std::string trajectories_json, std::filesystem::path step_folder, std::filesystem::path latest_folder, typename DEVICE::index_t step, std::string filename) {
+#ifndef RL_TOOLS_ENABLE_ZLIB
+            std::string file_extension = "json";
+            std::string trajectories_output = trajectories_json;
+#else
+            std::string file_extension = "json.gz";
+            std::vector<uint8_t> trajectories_output;
+            if(!compress_zlib(trajectories_json, trajectories_output)){
+                std::cerr << "Error while compressing trajectories." << std::endl;
+                return false;
+            }
+#endif
+            {
+                std::filesystem::path trajectories_path = step_folder / (filename + "." + file_extension);
+                std::cerr << "Saving Trajectories to: " << trajectories_path << std::endl;
+#ifndef RL_TOOLS_ENABLE_ZLIB
+                std::ofstream trajectories_file(trajectories_path);
+                trajectories_file << trajectories_output;
+#else
+                std::ofstream trajectories_file(trajectories_path, std::ios::binary);
+                trajectories_file.write(reinterpret_cast<const char*>(trajectories_output.data()), trajectories_output.size());
+#endif
+                trajectories_file.close();
+                link_latest_artifact(device, latest_folder, trajectories_path, step_folder, step);
+            }
+            return true;
+        }
+        template <typename DEVICE>
+        bool write_to_file(DEVICE& device, std::string trajectories_json, std::filesystem::path step_folder, std::string filename) {
+            return write_to_file(device, trajectories_json, step_folder, std::filesystem::path{}, 0, filename);
+        }
+
+    }
+
+    template <typename DEVICE, typename CONFIG>
+    bool step(DEVICE& device, rl::loop::steps::save_trajectories::State<CONFIG>& ts){
+        using TS = rl::loop::steps::save_trajectories::State<CONFIG>;
+        using TI = typename CONFIG::TI;
+        using PARAMETERS = typename CONFIG::SAVE_TRAJECTORIES_PARAMETERS;
+        using STATE = rl::loop::steps::save_trajectories::State<CONFIG>;
+        if constexpr(PARAMETERS::SAVE_TRAJECTORIES == true){
+            if(ts.step % PARAMETERS::INTERVAL == 0 || ts.save_trajectories_this_step){
+                ts.save_trajectories_this_step = false;
+                const char * env_var = environment_variable(device, "RL_TOOLS_SAVE_TRAJECTORIES");
+                if(env_var != nullptr && std::string(env_var) != "1"){
+                    std::cout << "RL_TOOLS_SAVE_TRAJECTORIES=" << env_var << " is set. Skipping save trajectories step." << std::endl;
+                }
+                else{
+                    if(!ts.save_trajectories_ui_written){
+                        ts.save_trajectories_ui_written = true;
+                        std::string ui = get_ui(device, ts.env_eval);
+                        if(!ui.empty()){
+                            std::filesystem::create_directories(ts.extrack_paths.seed);
+                            std::ofstream ui_jsmf(ts.extrack_paths.seed / "ui.esm.js");
+                            ui_jsmf << ui;
+                            std::cout << "UI written to: " << ts.extrack_paths.seed / "ui.esm.js" << std::endl;
+                        }
+                        std::string description = get_description(device, ts.env_eval);
+                        if(!description.empty()){
+                            std::filesystem::create_directories(ts.extrack_paths.seed);
+                            std::ofstream description_file(ts.extrack_paths.seed / "description.txt");
+                            description_file << description;
+                            std::cout << "Description written to: " << ts.extrack_paths.seed / "description.txt" << std::endl;
+                        }
+                    }
+                    typename TS::SAVE_TRAJECTORIES_ACTOR_TYPE evaluation_actor;
+                    malloc(device, evaluation_actor);
+                    auto actor = get_actor(ts);
+                    copy(device, device, actor, evaluation_actor);
+                    evaluate(device, ts.env_eval, ts.ui, evaluation_actor, ts.actor_deterministic_save_trajectories_state, ts.actor_deterministic_save_trajectories_buffers, ts.save_trajectories_buffer, ts.save_trajectories_result, ts.save_trajectories_data, ts.rng_save_trajectories, ts.evaluation_mode);
+                    free(device, evaluation_actor);
+
+                    using PARAMS = typename CONFIG::SAVE_TRAJECTORIES_PARAMETERS;
+
+                    std::string trajectories_json = rl::loop::steps::save_trajectories::to_string(device, ts.env_eval, ts.save_trajectories_data);
+                    auto step_folder = get_step_folder(device, ts.extrack_config, ts.extrack_paths, ts.step);
+                    auto latest_folder = get_latest_folder(device, ts.extrack_paths);
+                    rl::loop::steps::save_trajectories::write_to_file(device, trajectories_json, step_folder, latest_folder, ts.step, "trajectories");
+                }
+            }
+        }
+        bool finished = step(device, static_cast<typename STATE::NEXT&>(ts));
+        return finished;
+    }
+    // to log the configuration
+    template <typename DEVICE, typename PARAMETERS, typename utils::typing::enable_if<utils::typing::is_same_v<typename PARAMETERS::TAG, rl::loop::steps::save_trajectories::ParametersTag>>::type* = nullptr>
+    void log(DEVICE& device, PARAMETERS){}
+    template <typename DEVICE, typename CONFIG, typename utils::typing::enable_if<utils::typing::is_same_v<typename CONFIG::TAG, rl::loop::steps::save_trajectories::ConfigTag>>::type* = nullptr>
+    void log(DEVICE& device, CONFIG){
+        log(device, typename CONFIG::NEXT{});
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+
+
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/save_trajectories/persist.h

@@ -0,0 +1,30 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_SAVE_TRAJECTORIES_PERSIST_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_SAVE_TRAJECTORIES_PERSIST_H
+#include "state.h"
+#include "../../../../random/persist.h"
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools{
+    template <typename DEVICE, typename T_CONFIG, typename GROUP>
+    void save(DEVICE& device, rl::loop::steps::save_trajectories::State<T_CONFIG>& ts, GROUP& group){
+        using STATE = rl::loop::steps::save_trajectories::State<T_CONFIG>;
+        save(device, static_cast<typename STATE::NEXT&>(ts), group);
+        auto save_trajectories_group = create_group(device, group, "save_trajectories");
+        auto rng_group = create_group(device, save_trajectories_group, "rng_save_trajectories");
+        save(device, ts.rng_save_trajectories, rng_group);
+    }
+    template <typename DEVICE, typename T_CONFIG, typename GROUP>
+    bool load(DEVICE& device, rl::loop::steps::save_trajectories::State<T_CONFIG>& ts, GROUP& group){
+        using STATE = rl::loop::steps::save_trajectories::State<T_CONFIG>;
+        bool success = load(device, static_cast<typename STATE::NEXT&>(ts), group);
+        auto save_trajectories_group = get_group(device, group, "save_trajectories");
+        auto rng_group = get_group(device, save_trajectories_group, "rng_save_trajectories");
+        bool step_result = load(device, ts.rng_save_trajectories, rng_group);
+        if(!step_result){ log(device, device.logger, "Save trajectories loop load failed: rng_save_trajectories"); }
+        success &= step_result;
+        return success;
+    }
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/save_trajectories/state.h

@@ -0,0 +1,37 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_SAVE_TRAJECTORIES_STATE_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_SAVE_TRAJECTORIES_STATE_H
+
+#include "../../../../rl/utils/evaluation/evaluation.h"
+#include "../../../../utils/generic/typing.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::loop::steps::save_trajectories{
+    template<typename T_CONFIG, typename T_NEXT = typename T_CONFIG::NEXT::template State<typename T_CONFIG::NEXT>>
+    struct State: T_NEXT {
+        using CONFIG = T_CONFIG;
+        using NEXT = T_NEXT;
+        using TYPE_POLICY = typename CONFIG::TYPE_POLICY;
+        using TI = typename CONFIG::TI;
+        rl::utils::evaluation::Buffer<rl::utils::evaluation::BufferSpecification<typename CONFIG::SAVE_TRAJECTORIES_SPEC, CONFIG::DYNAMIC_ALLOCATION>> save_trajectories_buffer;
+        rl::utils::evaluation::Result<typename CONFIG::SAVE_TRAJECTORIES_SPEC> save_trajectories_result;
+        template <typename SPEC>
+        using DATA_TYPE = rl_tools::utils::typing::conditional_t<CONFIG::SAVE_TRAJECTORIES_PARAMETERS::SAVE_TRAJECTORIES, rl::utils::evaluation::Data<rl::utils::evaluation::DataSpecification<SPEC>>, rl::utils::evaluation::NoData<rl::utils::evaluation::DataSpecification<SPEC>>>;
+        DATA_TYPE<typename CONFIG::SAVE_TRAJECTORIES_SPEC> save_trajectories_data;
+        typename CONFIG::RNG rng_save_trajectories;
+        using SAVE_TRAJECTORIES_ACTOR_TYPE_BATCH_SIZE = typename CONFIG::NN::ACTOR_TYPE::template CHANGE_BATCH_SIZE<TI, CONFIG::SAVE_TRAJECTORIES_PARAMETERS::NUM_EPISODES>;
+        using SAVE_TRAJECTORIES_ACTOR_TYPE = typename SAVE_TRAJECTORIES_ACTOR_TYPE_BATCH_SIZE::template CHANGE_CAPABILITY<nn::capability::Forward<CONFIG::DYNAMIC_ALLOCATION>>;
+        typename SAVE_TRAJECTORIES_ACTOR_TYPE::template State<CONFIG::DYNAMIC_ALLOCATION> actor_deterministic_save_trajectories_state;
+        typename SAVE_TRAJECTORIES_ACTOR_TYPE::template Buffer<CONFIG::DYNAMIC_ALLOCATION> actor_deterministic_save_trajectories_buffers;
+        typename CONFIG::UI ui_save_trajectories;
+        bool save_trajectories_ui_written = false;
+        bool save_trajectories_this_step = false;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif
+
+
+
+

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/steps.h

@@ -0,0 +1,4 @@
+#include "checkpoint/config.h"
+#include "evaluation/config.h"
+#include "extrack/config.h"
+#include "timing/config.h"

hyperdrone/_vendor/rl-tools/include/rl_tools/rl/loop/steps/timing/config.h

@@ -0,0 +1,27 @@
+#include "../../../../version.h"
+#if (defined(RL_TOOLS_DISABLE_INCLUDE_GUARDS) || !defined(RL_TOOLS_RL_LOOP_STEPS_TIMING_CONFIG_H)) && (RL_TOOLS_USE_THIS_VERSION == 1)
+#pragma once
+#define RL_TOOLS_RL_LOOP_STEPS_TIMING_CONFIG_H
+
+#include "state.h"
+
+RL_TOOLS_NAMESPACE_WRAPPER_START
+namespace rl_tools::rl::loop::steps::timing{
+    template<typename T_TI, T_TI T_INTERVAL=1>
+    struct Parameters{
+        static constexpr T_TI INTERVAL = T_INTERVAL;
+    };
+    template<typename T_NEXT, typename T_PARAMETERS = Parameters<typename T_NEXT::TI>>
+    struct Config: T_NEXT {
+        using NEXT = T_NEXT;
+        using PARAMETERS = T_PARAMETERS;
+        template <typename CONFIG>
+        using State = State<CONFIG>;
+    };
+}
+RL_TOOLS_NAMESPACE_WRAPPER_END
+#endif
+
+
+
+