int main() {
GridWorld world;
// This is optional, and should make solving the model almost instantaneous.
// Unfortunately, since our main model is so big, the copying process
// still takes a lot of time. But at least that would be a one-time cost!
std::cout << currentTimeString() << "- Copying model...!\n";
AIToolbox::MDP::SparseModel model(world);
std::cout << currentTimeString() << "- Init solver...!\n";
// This is a method that solves MDPs completely. It has a couple of
// parameters available.
// The only non-optional parameter is the horizon of the solution; as in
// how many steps should the solution look ahead in order to decide which
// move to take. If we chose 1, for example, the tiger would only consider
// cells next to it to decide where to move; this wouldn't probably be
// what we want.
// We want the tiger to think for infinite steps: this can be
// approximated with a very high horizon, since in theory the final solution
// will converge to a single policy anyway. Thus we put a very high number
// as the horizon here.
AIToolbox::MDP::ValueIteration<decltype(model)> solver(1000000);
std::cout << currentTimeString() << "- Starting solver!\n";
// This is where the magic happen. This could take around 10-20 minutes,
// depending on your machine (most of the time is spent on this tutorial's
// code, however, since it is a pretty inefficient implementation).
// But you can play with it and make it better!
//
// If you are using the Sparse Model though, it is instantaneous since
// Eigen is very very efficient in computing the values we need!
auto solution = solver(model);
std::cout << currentTimeString() << "- Problem solved? " << std::get<0>(solution) << "\n";
AIToolbox::MDP::Policy policy(world.getS(), world.getA(), std::get<1>(solution));
std::cout << "Printing best actions when prey is in (5,5):\n\n";
for ( int y = 10; y >= 0; --y ) {
for ( int x = 0; x < 11; ++x ) {
std::cout << policy.sampleAction( encodeState(CoordType{{x, y, 5, 5}}) ) << " ";
}
std::cout << "\n";
}
std::cout << "\nSaving policy to file for later usage...\n";
{
// You can load up this policy again using ifstreams.
// You will not need to solve the model again ever, and you
// can embed the policy into any application you want!
std::ofstream output("policy.txt");
output << policy;
}
return 0;
}
int main() {
GridWorld world;
// This is a method that solves MDPs completely. It has a couple of
// parameters available, but in our case the defaults are perfectly
// fine.
AIToolbox::MDP::ValueIteration solver;
std::cout << "Starting solver!\n";
// This is where the magic happen. This could take around 10-20 minutes,
// depending on your machine (most of the time is spent on this tutorial's
// code, however, since it is a pretty inefficient implementation).
// But you can play with it and make it better!
auto solution = solver(world);
std::cout << "Problem solved? " << std::get<0>(solution) << "\n";
AIToolbox::MDP::Policy policy(world.getS(), world.getA(), std::get<1>(solution));
std::cout << "Printing best actions when prey is in (5,5):\n\n";
for ( int y = 10; y >= 0; --y ) {
for ( int x = 0; x < 11; ++x ) {
std::cout << policy.sampleAction( encodeState(CoordType{{x, y, 5, 5}}) ) << " ";
}
std::cout << "\n";
}
std::cout << "\nSaving policy to file for later usage...\n";
{
// You can load up this policy again using ifstreams.
// You will not need to solve the model again ever, and you
// can embed the policy into any application you want!
std::ofstream output("policy.txt");
output << policy;
}
return 0;
}