A3CModel.h

#ifndef A3C_MODEL_H
#define A3C_MODEL_H

#include "RLModel.h"
#include <memory>
#include <vector>
#include <deque>
#include <mutex>
#include <random>
#include <cmath>
#include <thread>
#include <atomic>
#include <fstream>
#include "hyperparameter_tuner.h"
#include "actor_critic.h"
#include "Globals.h"

// Forward-deklaraatiot
class A3CModel;
class A3CNetwork;
class A3CWorker;

// A3C-työntekijäluokka, joka suorittaa oppimisen yhdessä säikeessä
class A3CWorker {
private:
    int workerId;
    ActorCritic localNetwork;
    A3CNetwork& globalNetwork;
    
    // Gradienttien keräämiseen
    std::vector<float> states;
    std::vector<float> actions;
    std::vector<float> rewards;
    std::vector<float> values;
    
    // Hyperparametrit
    float gamma;
    
public:
    A3CWorker(int id, A3CNetwork& global, float g = 0.99f, int updateFreq = 20);
    
    // Suorita eteenpäinkulku paikallisella verkolla
    void forward(float state[STATE_SIZE], float action[ACTION_SIZE], float& value);
    
    // Kerää kokemus gradienttien laskemista varten
    void collectExperience(float state[STATE_SIZE], float action[ACTION_SIZE], 
                          float reward, float value);
    
    // Laske gradientit ja päivitä globaali verkko
    void updateGlobalNetwork(float nextStateValue, bool isTerminal);
    
    // Tarkista pitäisikö päivittää globaali verkko
    bool shouldUpdate() const;
    
    // Palauta työntekijän ID
    int getId() const;
    
    // Palauta paikallinen verkko
    ActorCritic& getLocalNetwork() const;
    
    // Aseta päivitystaajuus
    void setUpdateFrequency(int freq);
    
    // Palauta rewards-vektorin koko
    size_t getRewardsSize() const;
    
    // Aseta hyperparametrit
    void setHyperParams(const HyperParameters& params);
};

// A3C (Asynchronous Advantage Actor-Critic) verkko
class A3CNetwork {
private:
    // Globaali verkko, jota kaikki säikeet päivittävät
    ActorCritic globalNetwork;
    
    // Mutex globaalin verkon päivityksille
    std::mutex globalNetworkMutex;
    
    // Hyperparametrit
    float learningRate;
    float gamma;
    float tau; // Target-verkkojen päivitysnopeus
    
    // Tilastot
    std::atomic<int> totalUpdates{0};
    std::atomic<float> averageReward{0.0f};
    
public:
    A3CNetwork(float lr = 0.0001f, float g = 0.99f, float t = 0.001f);
    
    // Alusta työntekijäverkko globaalin verkon painoilla
    void initializeWorker(ActorCritic& worker);
    
    // Kopioi verkon painot lähteestä kohteeseen
    void copyNetworkWeights(const ActorCritic& source, ActorCritic& target);
    
    // Päivitä globaali verkko työntekijän gradienteilla
    void updateGlobalNetwork(ActorCritic& worker);
    
    // Päivitä target-verkot soft-update-menetelmällä
    void updateTargetNetworks();
    
    // Hae globaalin verkon painot työntekijälle
    void pullGlobalNetworkWeights(ActorCritic& worker);
    
    // Tallenna globaalin verkon painot tiedostoon
    void saveGlobalWeights(const std::string& filename);
    
    // Lataa globaalin verkon painot tiedostosta
    void loadGlobalWeights(const std::string& filename);
    
    // Päivitä oppimisnopeutta
    void updateLearningRate(float newLR);
    
    // Päivitä keskimääräistä palkkiota
    void updateAverageReward(float reward);
    
    // Getterit
    float getAverageReward() const;
    int getTotalUpdates() const;
    float getLearningRate() const;
};

// A3C-mallin toteutus RLModel-rajapinnan kautta
class A3CModel : public RLModel {
private:
    A3CWorker& worker;
    
public:
    A3CModel(A3CWorker& w);
    
    void forward(float state[/*STATE_SIZE*/], float action[/*ACTION_SIZE*/], float& value) override;
    void collectExperience(float state[/*STATE_SIZE*/], float action[/*ACTION_SIZE*/], 
                          float reward, float value) override;
    void update(float nextStateValue, bool isTerminal) override;
    bool shouldUpdate() const override;
    size_t getRewardsSize() const override;
    std::string getName() const override;
    float getLastAdvantage() const override;
    float getLastWeightUpdate() const override;
    float getTDError() const override;
    int getUpdateCounter() const override;
    void setUpdateFrequency(int freq) override;
    const HyperParameters& getHyperParams() const override;
    bool saveModel(const std::string& filename) const override;
    bool loadModel(const std::string& filename) override;
    void setHyperParams(const HyperParameters& params) override;
    // Staattinen metodi, joka luo ja lataa A3C-mallin
    static std::unique_ptr<RLModel> createAndLoad(A3CWorker& worker, const std::string& filename);
};

#endif // A3C_MODEL_H