SparseModel.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_POMDP_SPARSE_MODEL_HEADER_FILE
#define AI_TOOLBOX_POMDP_SPARSE_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/MDP/TypeTraits.hpp>
#include <AIToolbox/POMDP/Types.hpp>
#include <AIToolbox/POMDP/TypeTraits.hpp>
 
namespace AIToolbox::POMDP {
    template <MDP::IsModel M>
    class SparseModel;
 
    // Declaration to warn the compiler that this is a template function
    template <MDP::IsModel M>
    std::istream& operator>>(std::istream &is, SparseModel<M> & m);
 
    template <MDP::IsModel M>
    class SparseModel : public M {
        public:
            using ObservationMatrix = SparseMatrix3D;
 
            template <typename... Args>
            SparseModel(size_t o, Args&&... parameters);
 
            // Check that ObFun is a triple-matrix, otherwise we'll call the other constructor!
            template <IsNaive3DMatrix ObFun, typename... Args>
            SparseModel(size_t o, ObFun && of, Args&&... parameters);
 
            template <typename PM>
            requires IsModel<PM> && std::constructible_from<M, PM>
            SparseModel(const PM& model);
 
            template <typename... Args>
            SparseModel(NoCheck, size_t o, ObservationMatrix && ot, Args&&... parameters);
 
            template <IsNaive3DMatrix ObFun>
            void setObservationFunction(const ObFun & of);
 
            void setObservationFunction(const ObservationMatrix & 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;
 
            double getObservationProbability(const Belief & b, size_t o, size_t a) const;
 
            const SparseMatrix2D & 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>
    SparseModel<M>::SparseModel(const size_t o, Args&&... params) :
            M(std::forward<Args>(params)...), O(o), observations_(this->getA(),
            SparseMatrix2D(this->getS(), O)), rand_(Seeder::getSeed())
    {
        for ( size_t a = 0; a < this->getA(); ++a ) {
            for ( size_t s1 = 0; s1 < this->getS(); ++s1 )
                observations_[a].insert(s1, 0) = 1.0;
            observations_[a].makeCompressed();
        }
    }
 
    template <MDP::IsModel M>
    template <IsNaive3DMatrix ObFun, typename... Args>
    SparseModel<M>::SparseModel(const size_t o, ObFun && of, Args&&... params) :
            M(std::forward<Args>(params)...), O(o),
            observations_(this->getA(), SparseMatrix2D(this->getS(), O)), rand_(Seeder::getSeed())
    {
        setObservationFunction(of);
    }
 
    template <MDP::IsModel M>
    template <typename... Args>
    SparseModel<M>::SparseModel(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>
    SparseModel<M>::SparseModel(const PM& model) :
            M(model), O(model.getO()), observations_(this->getA(), SparseMatrix2D(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 ) {
                    const double p = model.getObservationProbability(s1, a, o);
                    if ( p < 0.0 || p > 1.0 )
                        throw std::invalid_argument("Input observation matrix contains an invalid value.");
 
                    if ( checkDifferentSmall( p, 0.0 ) ) observations_[a].insert(s1, o) = p;
                }
                if ( checkDifferentSmall(1.0, observations_[a].row(s1).sum()) )
                    throw std::invalid_argument("Input observation matrix contains an invalid row.");
            }
            observations_[a].makeCompressed();
        }
    }
 
    template <MDP::IsModel M>
    template <IsNaive3DMatrix ObFun>
    void SparseModel<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 a = 0; a < this->getA(); ++a ) {
            observations_[a].setZero();
            for ( size_t s1 = 0; s1 < this->getS(); ++s1 )
            for ( size_t o = 0; o < O; ++o ) {
                const double p = of[s1][a][o];
                if ( checkDifferentSmall( p, 0.0 ) )
                    observations_[a].insert(s1, o) = p;
            }
        }
 
        for ( size_t a = 0; a < this->getA(); ++a )
            observations_[a].makeCompressed();
    }
 
    template <MDP::IsModel M>
    void SparseModel<M>::setObservationFunction(const SparseMatrix3D & of) {
        if (!isProbability(of))
            throw std::invalid_argument("Input observation matrix does not contain valid probabilities.");
        // Then we copy.
        observations_ = of;
    }
 
    template <MDP::IsModel M>
    double SparseModel<M>::getObservationProbability(const size_t s1, const size_t a, const size_t o) const {
        return observations_[a].coeff(s1, o);
    }
 
    template <MDP::IsModel M>
    const SparseMatrix2D & SparseModel<M>::getObservationFunction(const size_t a) const {
        return observations_[a];
    }
 
    template <MDP::IsModel M>
    size_t SparseModel<M>::getO() const {
        return O;
    }
 
    template <MDP::IsModel M>
    const typename SparseModel<M>::ObservationMatrix & SparseModel<M>::getObservationFunction() const {
        return observations_;
    }
 
    template <MDP::IsModel M>
    std::tuple<size_t,size_t, double> SparseModel<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> SparseModel<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