/**
*
* Execute the best play
*
* */
zet Agent::play(board& b,bool player){
this->playing_color = player;
if (lapse(get_generator())){
std::vector<zet> s = enumerate_moves(b,player);
int rn_n = std::uniform_int_distribution<int>(0,s.size()-1)(get_generator());
FILE_LOG(logDEBUG)<<" * lapsing - returning random move" <<std::endl;
return s[rn_n];
}
std::vector<zet> s = solve(b,player);
FILE_LOG(logDEBUG)<<"Playing for player "<<((player==BLACK)?"BLACK":"WHITE")<< " there are "<< s.size() <<" moves" << std::endl;
FILE_LOG(logDEBUG)<<" board is :" <<b<<std::endl;
if(s.empty()){
FILE_LOG(logERROR)<<" board with no moves "<<b <<std::endl;
}
assert(!s.empty());
zet r;
//std::random_shuffle(s.begin(),s.end());
if (player == BLACK || is_negamax()){
r=*std::max_element(s.begin(),s.end(),[](const zet& z1, const zet& z2 ){ return z1.val < z2.val;});
} else{
r=*std::min_element(s.begin(),s.end(),[](const zet& z1, const zet& z2 ){ return z1.val < z2.val;});
}
FILE_LOG(logDEBUG)<<((player==BLACK)?"BLACK":"WHITE")<<" playes move "<<r.zet_id<<" with value:"<<r.val <<std::endl;
return r;
}
void UCTAgent::init(){
FILE_LOG(logDEBUG) << " Init UCTAgent. Init Treeagent first "<<std::endl;
TreeAgent::init();
if (policy == NULL){
FILE_LOG(logDEBUG) << " Getting policy code "<<std::endl;
int policy_code =get_policy_code();
FILE_LOG(logDEBUG) << " Selecting policy "<<policy_code<<std::endl;
switch(policy_code){
case 0:
policy = new RandomPlayout();
FILE_LOG(logDEBUG) << " Assigned Random policy for uct "<<std::endl;
break;
case 1:
policy = new GeometricRandomPlayout(h);
FILE_LOG(logDEBUG) << " Assigned GeoRandom policy for uct "<<std::endl;
break;
case 2:
policy = new MyopicPolicyPlayout(h,get_generator(),get_policy_lapse_rate());
FILE_LOG(logDEBUG) << " Assigned Myopic policy for uct "<<std::endl;
break;
case 3:
policy = new PseudoRandomPlayout();
FILE_LOG(logDEBUG) << " Assigned PseudoRandomPlayout policy for uct "<<std::endl;
break;
default:
throw std::runtime_error("no policy");
}
}
}
/**
* Generate a uniform random real_t on the interval [0, 1)
*/
real_t random_uniform()
{
std::uniform_real_distribution<real_t> dist =
std::uniform_real_distribution<real_t>();
real_t result = dist(*get_generator());
return result;
}
void Metalink4Writer::write_metalink()
{
write_text(wxT("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"));
start(wxT("metalink"));
add_attr(wxT("xmlns"), wxT("urn:ietf:params:xml:ns:metalink"));
close_start();
add_element(wxT("generator"), get_generator());
const std::vector<MetalinkFile>& files = metalink_.get_files();
for(std::vector<MetalinkFile>::const_iterator i = files.begin(),
eoi = files.end(); i != eoi; ++i) {
write_file(*i);
}
end(wxT("metalink"));
}
void Metalink3Writer::write_metalink()
{
write_text(wxString(wxT("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")), true);
start(wxT("metalink"));
add_attr(wxT("version"), wxT("3.0"));
add_attr(wxT("generator"), get_generator());
add_attr(wxT("xmlns"), wxT("http://www.metalinker.org/"));
close_start();
start(wxT("files"));
close_start();
const std::vector<MetalinkFile>& files = metalink_.get_files();
for(std::vector<MetalinkFile>::const_iterator i = files.begin(),
eoi = files.end(); i != eoi; ++i) {
write_file(*i);
}
end(wxT("files"));
end(wxT("metalink"));
}
/**
* Generate a uniform random real_t from N(0, 1)
*/
real_t random_gaussian()
{
std::normal_distribution<real_t> dist =
std::normal_distribution<real_t>();
return dist(*get_generator());
}
/**
* Generate a uniformly random integer between 0 (incl) and n (excl)
*/
int random_int(int n){
std::uniform_int_distribution<> dist(0, n-1);
return dist(*get_generator());
}
typename DistType::result_type gen() { return m_dist(get_generator()); }
/**
* Select a random move
*/
uint64 Agent::select_random_move(std::vector<zet> &moves){
return moves[get_generator()() % moves.size()].zet_id; //TODO: uniform_distribution
}
int main(int argc, const char* argv[])
{
argc--;
argv++;
srand (time(NULL));
db_ranking db;
int change_rate = 10;
if ( argc > 1 ){
sscanf(argv[1], "%d", &change_rate);
}
diagnosis_phase_detector::phase phases[4] = {
diagnosis_phase_detector::diagnosis_plain,
diagnosis_phase_detector::diagnosis_green,
diagnosis_phase_detector::diagnosis_hinselmann,
diagnosis_phase_detector::diagnosis_schiller
};
map<diagnosis_phase_detector::phase, string> names;
names[diagnosis_phase_detector::diagnosis_plain] = "plain";
names[diagnosis_phase_detector::diagnosis_green] = "green";
names[diagnosis_phase_detector::diagnosis_hinselmann] = "hinselmann";
names[diagnosis_phase_detector::diagnosis_schiller] = "schiller";
int current_phase_index = 0;
diagnosis_phase_detector::phase cphase = phases[current_phase_index];
// Parse the videos specified in the input file
ifstream fin(argv[0]);
string next_seq;
//int counter = 5;
int vindex = 0;
while ( getline(fin, next_seq) != 0 /*&& counter-- > 0*/ ){
cout << next_seq << endl;
// Filaname
filenames.push_back(next_seq);
// Index
v_index.push_back(db.get_video_index(next_seq));
// Sequence of frames
map<diagnosis_phase_detector::phase, vector<int> > next_frames;
get_sequence(next_seq.c_str(), next_frames);
frames.push_back(next_frames);
// Frame generator
map<diagnosis_phase_detector::phase, layer_generator> next_generator;
get_generator(next_frames, next_generator);
generators.push_back(next_generator);
// Annotated instance
anonadado::instance* next_instance = new anonadado::instance();
next_instance->read(next_seq.c_str());
instances.push_back(next_instance);
cout << "Video " << vindex++ << " done." << endl;
}
fin.close();
bool has = true;
bool exit = false;
bool go_to_next_phase = false;
while ( !exit && has ){
int remaining = change_rate;
go_to_next_phase = false;
cout << "\n\n\n NEEEEXT!\n\n\n";
cout << current_phase_index << " " << cphase << endl;
cout << endl << endl;
for ( int level = 0; has && !exit && !go_to_next_phase; level++ )
{
cout << "LEVEL " << level << endl;
//boost::this_thread::sleep( boost::posix_time::seconds(1) );
vector< pair<int, pair< pair<int, int>,
pair<int, int>
>
>
> pairs;
// Generate pairs <(video, frame), (video, frame)> for this level
for ( size_t va = 0; va < instances.size(); va++ ){
vector<int> framesl_a;
generators[va][cphase].get_next(framesl_a, level);
for ( size_t fa = 0; fa < framesl_a.size(); fa++){
for ( size_t vb = 0; vb < va; vb++ ){
vector<int> framesl_b;
generators[vb][cphase].get_next(framesl_b, level);
for ( size_t fb = 0; fb < framesl_b.size(); fb++ ){
if ( va == vb && framesl_a[fa] == framesl_b[fb] ){
continue;
}
int priority =
min(db.num_annotated_frames(v_index[va]),
db.num_annotated_frames(v_index[vb]));
pairs.push_back(
make_pair(priority,
make_pair(make_pair(va,
framesl_a[fa]),
make_pair(vb,
framesl_b[fb])
)
)
);
}
}
}
}
if ( pairs.size() == 0 ){
has = false;
break;
} else {
has = true;
}
// Randomly sort these pairs
vector<int> change_priorities;
sort(pairs.begin(), pairs.end());
change_priorities.push_back(0);
for (size_t i = 1; i < pairs.size(); i++){
if ( pairs[i].first != pairs[i - 1].first ){
change_priorities.push_back(i);
}
}
change_priorities.push_back(pairs.size());
for (size_t i = 0; i + 1 < change_priorities.size(); i++){
random_shuffle(pairs.begin() + change_priorities[i],
pairs.begin() + change_priorities[i + 1]);
}
// Eval these pairs
for ( size_t i = 0; i < pairs.size() && !go_to_next_phase; i++ ){
int va = pairs[i].second.first.first;
int fa = pairs[i].second.first.second;
int vb = pairs[i].second.second.first;
int fb = pairs[i].second.second.second;
cout << filenames[va] << " " << filenames[vb] << endl;
cout << "(" << va << ":" << fa << ") "
<< "(" << vb << ":" << fb << ") " << endl;
if ( db.exists(cphase,
v_index[va], frames[va][cphase][fa],
v_index[vb], frames[vb][cphase][fb])
)
{
continue;
}
better = -1;
bool save = true;
while ( true ){
Mat a, b, dst;
instances[va]->get_frame(frames[va][cphase][fa], a);
instances[vb]->get_frame(frames[vb][cphase][fb], b);
draw_ui(a, b, dst);
imshow(names[cphase], dst);
int key = waitKey(0) % 0x100;
if ( key == 81 ){
better = 1;
} else if ( key == 83 ){
better = 0;
} else if ( key == 32 ){
break;
} else if ( key == 27 ){
exit = true;
has = false;
break;
} else if ( key == 115 ){ // Skip
save = false;
break;
} else {
better = -1;
}
}
if ( exit ){
break;
}
// Save the annotation
if ( save ){
db.insert_annotation(cphase,
v_index[va], frames[va][cphase][fa],
v_index[vb], frames[vb][cphase][fb],
better);
}
cout << "remaining " << remaining << endl;
remaining--;
if ( remaining <= 0 ){
go_to_next_phase = true;
break;
}
}
}
cout << "go to next\n";
cvDestroyWindow(names[cphase].c_str());
current_phase_index = (current_phase_index + 1) % 4;
cphase = phases[current_phase_index];
}
cout << "Bye!\n";
return 0;
}
