TigerProblem.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_POMDP_TIGER_PROBLEM_HEADER_FILE
#define AI_TOOLBOX_POMDP_TIGER_PROBLEM_HEADER_FILE
 
#include <AIToolbox/MDP/Model.hpp>
#include <AIToolbox/POMDP/Model.hpp>
 
namespace AIToolbox::POMDP {
    namespace TigerProblemUtils {
        enum Action {
            A_LISTEN = 0,
            A_LEFT   = 1,
            A_RIGHT  = 2,
        };
 
        enum State {
            TIG_LEFT    = 0,
            TIG_RIGHT   = 1,
        };
 
        constexpr double listenError = 0.15;
    }
 
    inline AIToolbox::POMDP::Model<AIToolbox::MDP::Model> makeTigerProblem() {
        using namespace TigerProblemUtils;
 
        // Actions are: 0-listen, 1-open-left, 2-open-right
        constexpr size_t S = 2, A = 3, O = 2;
 
        AIToolbox::POMDP::Model<AIToolbox::MDP::Model> model(O, S, A);
 
        AIToolbox::DumbMatrix3D transitions(boost::extents[S][A][S]);
        AIToolbox::DumbMatrix3D rewards(boost::extents[S][A][S]);
        AIToolbox::DumbMatrix3D observations(boost::extents[S][A][O]);
 
        // Transitions
        // If we listen, nothing changes.
        for ( size_t s = 0; s < S; ++s )
            transitions[s][A_LISTEN][s] = 1.0;
 
        // If we pick a door, tiger and treasure shuffle.
        for ( size_t s = 0; s < S; ++s ) {
            for ( size_t s1 = 0; s1 < S; ++s1 ) {
                transitions[s][A_LEFT ][s1] = 1.0 / S;
                transitions[s][A_RIGHT][s1] = 1.0 / S;
            }
        }
 
        // Observations
        // If we listen, we guess right 85% of the time.
        observations[TIG_LEFT ][A_LISTEN][TIG_LEFT ] = 1.0 - listenError;
        observations[TIG_LEFT ][A_LISTEN][TIG_RIGHT] = listenError;
 
        observations[TIG_RIGHT][A_LISTEN][TIG_RIGHT] = 1.0 - listenError;
        observations[TIG_RIGHT][A_LISTEN][TIG_LEFT ] = listenError;
 
        // Otherwise we get no information on the environment.
        for ( size_t s = 0; s < S; ++s ) {
            for ( size_t o = 0; o < O; ++o ) {
                observations[s][A_LEFT ][o] = 1.0 / O;
                observations[s][A_RIGHT][o] = 1.0 / O;
            }
        }
 
        // Rewards
        // Listening has a small penalty
        for ( size_t s = 0; s < S; ++s )
            for ( size_t s1 = 0; s1 < S; ++s1 )
                rewards[s][A_LISTEN][s1] = -1.0;
 
        // Treasure has a decent reward, and tiger a bad penalty.
        for ( size_t s1 = 0; s1 < S; ++s1 ) {
            rewards[TIG_RIGHT][A_LEFT][s1] = 10.0;
            rewards[TIG_LEFT ][A_LEFT][s1] = -100.0;
 
            rewards[TIG_LEFT ][A_RIGHT][s1] = 10.0;
            rewards[TIG_RIGHT][A_RIGHT][s1] = -100.0;
        }
 
        model.setTransitionFunction(transitions);
        model.setRewardFunction(rewards);
        model.setObservationFunction(observations);
 
        return model;
    }
}
 
#endif