torch_policy.h

Go to the documentation of this file.

#ifndef TORCH_POLICY_H
#define TORCH_POLICY_H
 
/*
#include "kernel/base/config.h"
 
#ifdef USE_PYTORCH
 
#include "cubic_engine/base/cubic_engine_types.h"
#include "cubic_engine/rl/actions/action_space.h"
#include "cubic_engine/rl/utils/torch_observation_normalizer.h"
#include "cubic_engine/rl/networks/torch_nn.h"
#include "cubic_engine/ml/neural_networks/torch_output_layers.h"
#include "torch/torch.h"
 
#include <memory>
#include <vector>
 
namespace cengine {
namespace rl {
namespace policies {
 
 
 
class TorchPolicyImpl: public torch::nn::Module
{
 
public:
 
    TorchPolicyImpl(actions::ActionSpace action_space,
                    std::shared_ptr<nets::TorchNNBase> base,
                    bool normalize_observations = false);
 
    std::vector<torch::Tensor> act(torch::Tensor inputs,
                                   torch::Tensor rnn_hxs,
                                   torch::Tensor masks) const;
 
    std::vector<torch::Tensor> evaluate_actions(torch::Tensor inputs,
                                                torch::Tensor rnn_hxs,
                                                torch::Tensor masks,
                                                torch::Tensor actions) const;
 
    torch::Tensor get_probs(torch::Tensor inputs,
                            torch::Tensor rnn_hxs,
                            torch::Tensor masks) const;
 
    torch::Tensor get_values(torch::Tensor inputs,
                             torch::Tensor rnn_hxs,
                             torch::Tensor masks) const;
 
    void update_observation_normalizer(torch::Tensor observations);
 
    //bool is_recurrent() const { return base->is_recurrent(); }
 
    uint_t get_hidden_size() const{return base_->get_hidden_size();}
 
    bool using_observation_normalizer() const{return !observation_normalizer_.is_empty();}
 
private:
 
    actions::ActionSpace action_space_;
 
    std::shared_ptr<nets::TorchNNBase> base_;
 
    utils::TorchObservationNormalizer observation_normalizer_;
 
    std::shared_ptr<cengine::ml::nets::LinearOutputLayer> output_layer_;
 
    std::vector<torch::Tensor> forward_gru(torch::Tensor x,
                                           torch::Tensor hxs,
                                           torch::Tensor masks);
 
};
 
TORCH_MODULE(TorchPolicy);
}
 
}
 
}
#endif
*/
#endif // TORCH_POLICY_H