Agent.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "common/Result.h"
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::agent {
 
enum class Outcome { Running, Success, Failure };
 
struct Observation {
    std::vector<float>         features;
    std::vector<std::uint32_t> legalActions;
    std::vector<std::string>   coverage;
    double                     reward  = 0;
    Outcome                    outcome = Outcome::Running;
    std::string                finding;
};
 
class IEnvironment {
public:
    virtual ~IEnvironment() = default;
    [[nodiscard]] virtual Result<Observation> reset(std::uint64_t seed) = 0;
    [[nodiscard]] virtual Result<Observation> step(std::uint32_t action, double dt) = 0;
};
 
enum class Strategy { Random, EvolutionLearning };
 
enum class Backend { Cpu, Tensor, Gpu };
 
struct Config {
    std::uint32_t featureCount        = 1;
    std::uint32_t actionCount         = 2;
    std::uint32_t population          = 24;
    std::uint32_t generations         = 8;
    std::uint32_t horizon             = 32;
    std::uint32_t elites              = 6;
    std::uint32_t hiddenWidth         = 16;
    std::uint32_t trainingEpochs      = 3;
    std::uint32_t maxFindings         = 16;
    std::uint64_t environmentSeed     = 1;
    std::uint64_t searchSeed          = 2;
    std::uint64_t learningSeed        = 3;
    double        dt                  = 1.0 / 60.0;
    double        mutationProbability = 0.2;
    double        randomProbability   = 0.2;
    double        coverageWeight      = 0;
    double        failureWeight       = 0;
    double        learningRate        = 0.01;
    Strategy      strategy            = Strategy::EvolutionLearning;
    Backend       backend             = Backend::Cpu;
};
 
struct TraceStep {
    std::uint32_t action = 0;
    Observation   observation;
};
 
struct Trace {
    std::string            schemaId        = "evengine.agent.trace";
    std::uint32_t          schemaVersion   = 1;
    std::uint64_t          environmentSeed = 0;
    double                 dt              = 0;
    Observation            initial;
    std::vector<TraceStep> steps;
};
 
struct Policy {
    std::string         schemaId      = "evengine.agent.policy";
    std::uint32_t       schemaVersion = 1;
    std::uint32_t       featureCount  = 0;
    std::uint32_t       actionCount   = 0;
    std::uint32_t       hiddenWidth   = 0;
    std::vector<double> weights;
};
 
class IPolicyBackend {
public:
    static constexpr const char* capabilityName = "agent.IPolicyBackend";
    virtual ~IPolicyBackend()                   = default;
    [[nodiscard]] virtual std::string name() const = 0;
    [[nodiscard]] virtual Result<std::vector<double>> evaluate(const Policy&      policy,
                                                               const Observation& observation) = 0;
};
 
class IGpuPolicyBackend : public IPolicyBackend {
public:
    static constexpr const char* capabilityName = "agent.IGpuPolicyBackend";
    [[nodiscard]] virtual Result<void> available() const = 0;
    [[nodiscard]] virtual Result<Policy> train(const Policy& policy, const Observation& observation,
                                               std::uint32_t action, double rate) = 0;
};
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<void> validatePolicy(const Policy& policy);
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<std::string> backendName(Backend backend);
 
struct Report {
    Policy                   policy;
    Trace                    best;
    std::vector<Trace>       findings;
    std::vector<std::string> coverage;
    std::uint64_t            episodes        = 0;
    std::uint64_t            steps           = 0;
    std::uint64_t            failures        = 0;
    std::uint64_t            trainingSamples = 0;
    double                   bestScore       = 0;
    std::string              backend         = "cpu-mlp";
    std::string              trainingBackend = "cpu-sgd";
};
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<Report> run(const Config& config, IEnvironment& environment);
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<std::vector<double>> infer(const Policy&      policy,
                                                                        const Observation& observation,
                                                                        Backend            backend = Backend::Cpu);
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<void> replay(const Trace& trace, IEnvironment& environment,
                                                          double absoluteTolerance = 1e-6);
 
}  // namespace eve::agent