/*
* ---------------------------------------------------
* Slots
* ---------------------------------------------------
*/
void Grid::extract() {
// sness
if ( _collection->getNumTracks() > 0 ) {
int index = 0;
// !!! use itunes to generate the collection file rather then using a file
ofstream featureFile;
featureFile.open("margrid_train.mf", std::ios::out | std::ios::binary);
//featureFile.open("music.mf");
_collection->generatePlayList(featureFile, playlist_.c_str());
extractAction("margrid_train.mf");
} else if (trainFile_.length() > 0) {
cout << "Grid::extract() :: trainFile_.length() > 0" << endl;
cout << "trainFile_=" << trainFile_ << endl;
extractAction(trainFile_);
} else
{
emit errorBox("Need to load a collection of audio files first!");
}
}
/* Handles logging for each room, simply returning if logfile is not defined */
void con_room_log(cnr room, char *nick, char *message)
{
time_t t;
xmlnode xml;
jid user;
char *output;
char timestr[80];
size_t timelen = 79;
FILE *logfile;
pool p;
if(message == NULL || room == NULL)
{
log_warn(NAME, "[%s] ERR: Aborting - NULL reference found - ", FZONE);
return;
}
logfile = room->logfile;
if(logfile == NULL)
{
log_debug(NAME, "[%s] Logging not enabled for this room", FZONE);
return;
}
p = pool_heap(1024);
/* nicked from mod_time */
t = time(NULL);
if(room->logformat == LOG_XHTML)
strftime(timestr, timelen, "<a name=\"t%H:%M:%S\" href=\"#t%H:%M:%S\">[%H:%M:%S]</a>", localtime(&t));
else
strftime(timestr, timelen, "[%H:%M:%S]", localtime(&t));
if(room->logformat == LOG_XML)
{
xml = jutil_msgnew("groupchat", jid_full(room->id) , NULL, strescape(p, message));
user = jid_new(xmlnode_pool(xml), jid_full(room->id));
jid_set(user, strescape(p, nick), JID_RESOURCE);
xmlnode_put_attrib(xml, "from", jid_full(user));
jutil_delay(xml, NULL);
fprintf(logfile, "%s\n", xmlnode2str(xml));
xmlnode_free(xml);
}
else if(room->logformat == LOG_XHTML)
{
if(nick)
{
if(j_strncmp(message, "/me ", 4) == 0)
{
output = extractAction(_con_room_xhtml_strescape(p, message), p);
fprintf(logfile, "<span class=\"time\">%s</span> * <span class=\"nick\">%s</span>%s<br />\n", timestr, strescape(p, nick), output);
}
else
{
fprintf(logfile, "<span class=\"time\">%s</span> <<span class=\"nick\">%s</span>> %s<br />\n", timestr, strescape(p, nick), _con_room_xhtml_strescape(p, message));
}
}
else
{
fprintf(logfile, "<span class=\"time\">%s</span> --- %s<br />\n", timestr, message);
}
}
else
{
if(nick)
{
if(j_strncmp(message, "/me ", 4) == 0)
{
output = extractAction(message, p);
fprintf(logfile, "%s * %s%s\n", timestr, nick, output);
}
else
{
fprintf(logfile, "%s <%s> %s\n", timestr, nick, message);
}
}
else
{
fprintf(logfile, "%s --- %s\n", timestr, message);
}
}
fflush(logfile);
pool_free(p);
return;
}
void makeMultiExperimentPOMCP(
unsigned numExperiments, unsigned numTargets,
unsigned modelHorizon, const Model & model, const ap::Belief & modelBelief,
unsigned solverHorizon, std::vector<Solver> & solvers, const ap::Belief & solverBelief,
const std::string & outputFilename, bool useTrajectory = false )
{
static std::default_random_engine rand(AIToolbox::Impl::Seeder::getSeed());
double totalReward = 0.0;
std::vector<double> timestepTotalReward(modelHorizon, 0.0);
double avgReward = 0.0;
std::vector<size_t> obs(numTargets), pos(numTargets);
std::cout << numExperiments << " experiments with: Submodular POMCP! ";
std::cout << "Initial Belief: " << printBelief(modelBelief) << '\n';
std::cout << "Solver Belief: " << printBelief(solverBelief) << '\n';
unsigned experiment = 1;
for ( ; experiment <= numExperiments; ++experiment ) {
// Run pomcp, but don't get actions yet
for ( unsigned p = 0; p < numTargets; ++p ) {
pos[p] = AIToolbox::sampleProbability(model.getS(), modelBelief, rand);
solvers[p].sampleAction(solverBelief, std::min(solverHorizon, modelHorizon));
}
// Extract action
size_t a = extractAction(solvers);
std::vector<std::vector<size_t>> trajectories;
if ( useTrajectory ) {
for ( unsigned p = 0; p < numTargets; ++p ) trajectories.push_back( makeTrajectory(model, modelHorizon + 1, modelBelief) );
}
for ( unsigned i = 1; i <= modelHorizon; ++i ) {
double rew = 0.0;
#ifdef VISUALIZE
auto oldp = pos;
#endif
// Extract observations and rewards, and update positions of targets.
for ( unsigned p = 0; p < numTargets; ++p ) {
rew += ( model.getTrueState(solvers[p].getGuess()) == model.getTrueState(pos[p]) );
if ( useTrajectory ) {
pos[p] = trajectories[p][i];
std::tie(obs[p], std::ignore) = model.sampleOR( trajectories[p][i-1], a, trajectories[p][i] );
}
else
std::tie(pos[p], obs[p], std::ignore) = model.sampleSOR( pos[p], a );
}
totalReward += rew;
timestepTotalReward[i-1] += rew;
if ( experiment == 1 )
avgReward = totalReward;
else
avgReward = totalReward / (experiment - 1 + ((double)i)/modelHorizon);
std::cout // << "[S = " << s << "][A = " << a << "][S1 = " << s1 << "][ O = " << o << " ][ R = " << rew << " ]"
<< "EXPERIMENT " << std::setw(4) << experiment
<< ", TIMESTEP " << std::setw(4) << i
<< "\tTotal rew: " << std::setw(4) << totalReward
<< "\tAvg: " << std::setw(4) << avgReward;
#ifdef VISUALIZE
std::cout << '\n';
model.visualize(oldp, a);
#else
std::cout << '\r' << std::flush;
#endif
for ( unsigned p = 0; p < numTargets; ++p )
solvers[p].sampleAction(a, obs[p], std::min(solverHorizon, modelHorizon - i));
a = extractAction(solvers);
}
if ( processInterrupted ) break;
if ( ! (experiment % 100) )
gnuplotCumulativeSave(timestepTotalReward, outputFilename, experiment);
}
gnuplotCumulativeSave(timestepTotalReward, outputFilename, std::min(experiment, numExperiments));
}
