Model.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_POMDP_MODEL_HEADER_FILE
#define AI_TOOLBOX_POMDP_MODEL_HEADER_FILE
 
#include <random>
 
#include <AIToolbox/Seeder.hpp>
#include <AIToolbox/Utils/Core.hpp>
#include <AIToolbox/Utils/Probability.hpp>
#include <AIToolbox/MDP/Types.hpp>
#include <AIToolbox/POMDP/Types.hpp>
#include <AIToolbox/POMDP/TypeTraits.hpp>
 
namespace AIToolbox::POMDP {
    template <MDP::IsModel M>
    class Model;
 
    // Declaration to warn the compiler that this is a template function
    template <MDP::IsModel M>
    std::istream& operator>>(std::istream &is, Model<M> & m);
 
    template <MDP::IsModel M>
    class Model : public M {
        public:
            using ObservationMatrix = Matrix3D;
 
            template <typename... Args>
            Model(size_t o, Args&&... parameters);
 
            // Check that ObFun is a triple-matrix, otherwise we'll call the other constructor!
            template <IsNaive3DMatrix ObFun, typename... Args>
            Model(size_t o, ObFun && of, Args&&... parameters);
 
            template <typename PM>
            requires IsModel<PM> && std::constructible_from<M, PM>
            Model(const PM& model);
 
            template <typename... Args>
            Model(NoCheck, size_t o, ObservationMatrix && ot, Args&&... parameters);
 
            template <IsNaive3DMatrix ObFun>
            void setObservationFunction(const ObFun & of);
 
            void setObservationFunction(const ObservationMatrix & o);
 
            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;
 
            const Matrix2D & getObservationFunction(size_t a) 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 RandomEngine rand_;
    };
 
    template <MDP::IsModel M>
    template <typename... Args>
    Model<M>::Model(const size_t o, Args&&... params) :
            M(std::forward<Args>(params)...), O(o),
            observations_(this->getA(), Matrix2D(this->getS(), O)), rand_(Seeder::getSeed())
    {
        for ( size_t a = 0; a < this->getA(); ++a ) {
            observations_[a].rightCols(O-1).setZero();
            observations_[a].col(0).fill(1.0);
        }
    }
 
    template <MDP::IsModel M>
    template <IsNaive3DMatrix ObFun, typename... Args>
    Model<M>::Model(const size_t o, ObFun && of, Args&&... params) :
            M(std::forward<Args>(params)...), O(o),
            observations_(this->getA(), Matrix2D(this->getS(), O)), rand_(Seeder::getSeed())
    {
        setObservationFunction(of);
    }
 
    template <MDP::IsModel M>
    template <typename... Args>
    Model<M>::Model(NoCheck, size_t o, ObservationMatrix && ot, Args&&... params) :
            M(std::forward<Args>(params)...), O(o),
            observations_(std::move(ot))
    {}
 
    template <MDP::IsModel M>
    template <typename PM>
    requires IsModel<PM> && std::constructible_from<M, PM>
    Model<M>::Model(const PM& model) :
            M(model), O(model.getO()), observations_(this->getA(), Matrix2D(this->getS(), O)),
            rand_(Seeder::getSeed())
    {
        for ( size_t a = 0; a < this->getA(); ++a )
            for ( size_t s1 = 0; s1 < this->getS(); ++s1 ) {
                for ( size_t o = 0; o < O; ++o ) {
                    observations_[a](s1, o) = model.getObservationProbability(s1, a, o);
                }
                if ( !isProbability(O, observations_[a].row(s1)) )
                    throw std::invalid_argument("Input observation matrix does not contain valid probabilities.");
            }
    }
 
    template <MDP::IsModel M>
    template <IsNaive3DMatrix ObFun>
    void Model<M>::setObservationFunction(const ObFun & of) {
        for ( size_t s1 = 0; s1 < this->getS(); ++s1 )
            for ( size_t a = 0; a < this->getA(); ++a )
                if ( !isProbability(O, of[s1][a]) )
                    throw std::invalid_argument("Input observation matrix does not contain valid probabilities.");
 
        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_[a](s1, o) = of[s1][a][o];
    }
 
    template <MDP::IsModel M>
    void Model<M>::setObservationFunction(const ObservationMatrix & of) {
        if (!isProbability(of))
            throw std::invalid_argument("Input observation matrix does not contain valid probabilities.");
 
        observations_ = of;
    }
 
    template <MDP::IsModel M>
    double Model<M>::getObservationProbability(const size_t s1, const size_t a, const size_t o) const {
        return observations_[a](s1, o);
    }
 
    template <MDP::IsModel M>
    const Matrix2D & Model<M>::getObservationFunction(const size_t a) const {
        return observations_[a];
    }
 
    template <MDP::IsModel M>
    size_t Model<M>::getO() const {
        return O;
    }
 
    template <MDP::IsModel M>
    const typename Model<M>::ObservationMatrix & Model<M>::getObservationFunction() const {
        return observations_;
    }
 
    template <MDP::IsModel M>
    std::tuple<size_t,size_t, double> Model<M>::sampleSOR(const size_t s, const size_t a) const {
        const auto [s1, r] = this->sampleSR(s, a);
        const auto o = sampleProbability(O, observations_[a].row(s1), rand_);
        return std::make_tuple(s1, o, r);
    }
 
    template <MDP::IsModel M>
    std::tuple<size_t, double> Model<M>::sampleOR(const size_t s, const size_t a, const size_t s1) const {
        const size_t o = sampleProbability(O, observations_[a].row(s1), rand_);
        const double r = this->getExpectedReward(s, a, s1);
        return std::make_tuple(o, r);
    }
}
 
#endif