This C++ toolbox is aimed at representing and solving common AI problems, implementing an easy-to-use interface which should be hopefully extensible to many problems, while keeping code readable.
Current development includes MDPs, POMDPs and related algorithms. This toolbox
has been developed taking inspiration from the Matlab
MDPToolbox, which you
can find here, and from the
pomdp-solve software written by A. R. Cassandra, which you can find
This toolbox is aimed at Decision Theoretic Control algorithms. The general idea is to create algorithms that are able to interact with an environment in order to obtain some reward using actions, and to find the best policy of actions to use to do so.
The field divides itself into planning and reinforcement learning: planning focuses into solving problems that we know how to model: think chess, or 2048. Reinforcement learning focuses into creating a model for an environment we do not know in advance, and while learning the best policy for it. An excellent introduction to the basics can be found freely online in this book.
There are many variants of these problems, with single agent worlds, multi agent, multi objective, competitive, cooperative, partially observable and so on. This framework is a work in progress that tries to implement many DTC algorithms in one place, much like OpenCV is for Computer Vision algorithms.
Please note that the API is not yet stable (although most things at this point are) since at every algorithm I add I may decide to alter the API a bit, to offer a more consistent interface throughout the library.
Decision Theoretic Control is a field which is in rapid development. There are incredibly many methods to solve problems, each with a huge number of variants. This framework only tries to implement the most influential methods, and in their vanilla form (or the form that is most widely used in the research community to my knowledge), trying to keep the code as simple as possible.
If you need any of the variants, the code is structured so that it is easy to read it and modify it to your requirements, versus providing an endless list of parameters and include all the variants. Some toolboxes do this, but my opinion is that this makes the code very hard to digest, which makes it also hard to find out what parameters to set to get the algorithm variant you want.
Since Python does not allow templates, the classes are binded with as many as possible instantiations. This toolbox does lose quite a bit of power in terms of efficient customization when used from Python, but it allows to rapidly iterate in order to find out what works and what doesn’t.
Single Agent MDP:
- Value Iteration
- Win or Learn Fast Policy Iteration (WoLF)
- Prioritized Sweeping
- Monte Carlo Tree Search (MCTS)
- Normal Policy
- Epsilon-Greedy Policy
- Softmax Policy
- Q-Greedy Policy
- WoLF Policy
Single Agent POMDP:
- Incremental Pruning
- Point Based Value Iteration (PBVI)
- POMCP with UCB1
- Real-Time Belief State Search (RTBSS)
- Augmented MDP (AMDP)
- Normal Policy
Not in Python yet.
- SingleAction Policy
- Epsilon-Greedy Policy
- Q-Greedy Policy
To build the library you need:
In addition, full C++11 support is required (note: g++ 4.8 will not work as it has a bug which prevents it from successfully compiling the library, 4.9 will compile everything but the examples, 5.0 works for all).
If you want to build the POMDP part of the library you will also need:
- the lp_solve library is also required (a shared library must be available to compile the Python libraries).
- Alternatively, an implementation using COIN-OR is available, but must be activated in the CMake files and source files.
Once you have all required dependencies, you can simply execute the following commands from the project’s main folder:
mkdir build cd build/ cmake .. make
cmake can be called with a series of flags in order to customize the output,
if building everything is not desirable. The following flags are available:
CMAKE_BUILD_TYPE # Defines the build type MAKE_ALL # Builds all there is to build in the project MAKE_LIB # Builds the core C++ library MAKE_MDP # Builds the core C++ MDP library MAKE_POMDP # Builds the core C++ POMDP and MDP library MAKE_PYTHON # Builds Python bindings for the compiled core library MAKE_TESTS # Builds the library's tests for the compiled core library MAKE_EXAMPLES # Builds the library's examples using the compiled core library
These flags can be combined as needed. For example:
# Will build MDP and MDP Python bindings cmake -DCMAKE_BUILD_TYPE=Debug -DMAKE_MDP=1 -DMAKE_PYTHON=1 ..
The default flags when nothing is specified are
The static library files will be available directly in the build directory. At
the moment two separate libraries are created:
AIToolboxPOMDP. In case you want to link against the POMDP library, you will
also need to link against the MDP one, since POMDP uses MDP functionality.
A number of small tests are included which you can find in the
You can execute them after building the project using the following command
directly from the
build directory, just after you finish
The tests also offer a brief introduction for the framework, waiting for a more complete descriptive write-up. Only the tests for the parts of the library that you compiled are going to be built.
To compile the library’s documentation you need the Doxygen tool. To use it it is sufficient to execute the following command from the project’s root folder:
After that the documentation will be generated into an
html folder in the
Compiling a Program
To compile a program that uses this library, simply link it against
libAIToolboxMDP.a and possibly both
libAIToolboxPOMDP.a and all
libraries. Please note that since the POMDP code relies on the MDP code, you
MUST link the MDP library after the POMDP one, otherwise it may result in
undefined reference errors.
For Python, you just need to import the
POMDP.so modules, and
you’ll be able to use the classes as exported to Python. All classes are
documented, and you can run in the Python CLI
to see the documentation for each specific class.
The latest documentation is available here. Keep in mind that it may not always be 100% up to date with the latest commits, while the one you compile yourself will of course be.
For Python docs you can find them by typing
from the interpreter. It should show the exported API for each class, along with
any differences in input/output.