OldPOMDPModel.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_OLD_POMDP_MODEL_HEADER_FILE
#define AI_TOOLBOX_OLD_POMDP_MODEL_HEADER_FILE
 
#include <random>
 
#include <AIToolbox/Seeder.hpp>
#include <AIToolbox/Utils/Core.hpp>
#include <AIToolbox/Utils/Probability.hpp>
#include <AIToolbox/Types.hpp>
#include <AIToolbox/TypeTraits.hpp>
#include <AIToolbox/MDP/Types.hpp>
#include <AIToolbox/MDP/TypeTraits.hpp>
#include <AIToolbox/POMDP/Types.hpp>
#include <AIToolbox/POMDP/TypeTraits.hpp>
 
template <AIToolbox::MDP::IsModel M>
class OldPOMDPModel : public M {
    public:
        using ObservationMatrix = AIToolbox::DumbMatrix3D;
 
        template <typename... Args>
        OldPOMDPModel(size_t o, Args&&... parameters);
 
        // Check that ObFun is a triple-matrix, otherwise we'll call the other constructor!
        template <AIToolbox::IsNaive3DMatrix ObFun, typename... Args>
        OldPOMDPModel(size_t o, ObFun && of, Args&&... parameters);
 
        template <typename PM>
        requires AIToolbox::POMDP::IsModel<PM> && std::constructible_from<M, PM>
        OldPOMDPModel(const PM& model);
 
        template <AIToolbox::IsNaive3DMatrix ObFun>
        void setObservationFunction(const ObFun & of);
 
        std::tuple<size_t,size_t, double> sampleSOR(size_t s,size_t a) const;
 
        std::tuple<size_t, double> sampleOR(size_t s,size_t a,size_t s1) const;
 
        double getObservationProbability(size_t s1, size_t a, size_t o) const;
 
        size_t getO() const;
 
        const ObservationMatrix & getObservationFunction() const;
 
    private:
        size_t O;
        ObservationMatrix observations_;
        // We need this because we don't know if our parent already has one,
        // and we wouldn't know how to access it!
        mutable AIToolbox::RandomEngine rand_;
};
 
template <AIToolbox::MDP::IsModel M>
template <typename... Args>
OldPOMDPModel<M>::OldPOMDPModel(size_t o, Args&&... params) : M(std::forward<Args>(params)...), O(o), observations_(boost::extents[this->getS()][this->getA()][O]),
                                              rand_(AIToolbox::Seeder::getSeed())
{
    for ( size_t s = 0; s < this->getS(); ++s )
        for ( size_t a = 0; a < this->getA(); ++a )
            observations_[s][a][0] = 1.0;
}
 
template <AIToolbox::MDP::IsModel M>
template <AIToolbox::IsNaive3DMatrix ObFun, typename... Args>
OldPOMDPModel<M>::OldPOMDPModel(size_t o, ObFun && of, Args&&... params) : M(std::forward<Args>(params)...), O(o), observations_(boost::extents[this->getS()][this->getA()][O]),
                                                                rand_(AIToolbox::Seeder::getSeed())
{
    setObservationFunction(of);
}
 
template <AIToolbox::MDP::IsModel M>
template <typename PM>
requires AIToolbox::POMDP::IsModel<PM> && std::constructible_from<M, PM>
OldPOMDPModel<M>::OldPOMDPModel(const PM& model) : M(model), O(model.getO()), observations_(boost::extents[this->getS()][this->getA()][O]),
                                   rand_(AIToolbox::Seeder::getSeed())
{
    for ( size_t s1 = 0; s1 < this->getS(); ++s1 )
        for ( size_t a = 0; a < this->getA(); ++a ) {
            for ( size_t o = 0; o < O; ++o ) {
                observations_[s1][a][o] = model.getObservationProbability(s1, a, o);
            }
            if ( ! AIToolbox::isProbability(O, observations_[s1][a]) ) throw std::invalid_argument("Input observation matrix does not contain valid probabilities.");
        }
}
 
template <AIToolbox::MDP::IsModel M>
template <AIToolbox::IsNaive3DMatrix ObFun>
void OldPOMDPModel<M>::setObservationFunction(const ObFun & of) {
    for ( size_t s1 = 0; s1 < this->getS(); ++s1 )
        for ( size_t a = 0; a < this->getA(); ++a )
            if ( ! AIToolbox::isProbability(O, of[s1][a]) ) throw std::invalid_argument("Input observation matrix does not contain valid probabilities.");
 
    copyDumb3D(of, observations_, this->getS(), this->getA(), O);
}
 
template <AIToolbox::MDP::IsModel M>
double OldPOMDPModel<M>::getObservationProbability(size_t s1, size_t a, size_t o) const {
    return observations_[s1][a][o];
}
 
template <AIToolbox::MDP::IsModel M>
size_t OldPOMDPModel<M>::getO() const {
    return O;
}
 
template <AIToolbox::MDP::IsModel M>
const typename OldPOMDPModel<M>::ObservationMatrix & OldPOMDPModel<M>::getObservationFunction() const {
    return observations_;
}
 
template <AIToolbox::MDP::IsModel M>
std::tuple<size_t,size_t, double> OldPOMDPModel<M>::sampleSOR(size_t s, size_t a) const {
    size_t s1, o;
    double r;
 
    std::tie(s1, r) = this->sampleSR(s, a);
    o = AIToolbox::sampleProbability(O, observations_[s1][a], rand_);
 
    return std::make_tuple(s1, o, r);
}
 
template <AIToolbox::MDP::IsModel M>
std::tuple<size_t, double> OldPOMDPModel<M>::sampleOR(size_t s, size_t a, size_t s1) const {
    size_t o = AIToolbox::sampleProbability(O, observations_[s1][a], rand_);
    double r = this->getExpectedReward(s, a, s1);
    return std::make_tuple(o, r);
}
 
#endif