main.cc

   1
   2 // Written and (C) by Francois Fleuret
   3 // Contact <francois.fleuret@idiap.ch> for comments & bug reports
   4
   5 #include <iostream>
   6 #include <fstream>
   7 #include <cmath>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <stdint.h>
  11 #include <errno.h>
  12 #include <string.h>
  13
  14 using namespace std;
  15
  16 #include "misc.h"
  17 #include "task.h"
  18 #include "simple_window.h"
  19 #include "universe.h"
  20 #include "plotter.h"
  21 #include "retina.h"
  22 #include "manipulator.h"
  23 #include "intelligence.h"
  24 #include "canvas_cairo.h"
  25
  26 #include "xfig_tracer.h"
  27
  28 void generate_png(Universe *universe, scalar_t scale, FILE *file) {
  29   CanvasCairo canvas(scale, universe->width(), universe->height());
  30   universe->draw(&canvas);
  31   canvas.write_png(file);
  32 }
  33
  34 // To train
  35 // ./main --task hit_shape.task 0 --action-mode=random --nb-ticks=5000 --proportion-for-training=0.5 --save-file=dump.mem --no-window
  36
  37 // To test
  38 // ./main --task hit_shape.task 0 --action-mode=intelligent --load-file=dump.mem
  39
  40 //////////////////////////////////////////////////////////////////////
  41
  42 void check_opt(int argc, char **argv, int n_opt, int n, const char *help) {
  43   if(n_opt + n >= argc) {
  44     cerr << "Missing argument for " << argv[n_opt] << "." << endl;
  45     cerr << "Expecting " << help << "." << endl;
  46     exit(1);
  47   }
  48 }
  49
  50 void print_help_and_exit(int e) {
  51   cout << "Arguments:" << endl;
  52   cout << "  --no-window" << endl;
  53   cout << "  --nb-ticks=<int: number of ticks>" << endl;
  54   cout << "  --nb-training-iterations=<int: number of training iterations>" << endl;
  55   cout << "  --load-file=<filename: dump file>" << endl;
  56   cout << "  --save-file=<filename: dump file>" << endl;
  57   cout << "  --proportion-for-training=<float: proportion of samples for training>" << endl;
  58   cout << "  --action-mode=<idle|random|intelligent>" << endl;
  59   cout << "  --task <filename: task to load> <int: degree>" << endl;
  60   exit(e);
  61 }
  62
  63 //////////////////////////////////////////////////////////////////////
  64
  65 int main(int argc, char **argv) {
  66
  67   const int buffer_size = 256;
  68   char intelligence_load_file[buffer_size] = "", intelligence_save_file[buffer_size] = "";
  69
  70   Task *task = 0;
  71   int task_degree = 0;
  72
  73   int nb_ticks = 10000;
  74   int nb_training_iterations = 10;
  75   scalar_t proportion_for_training = -1;
  76
  77   Polygon *grabbed_polygon = 0;
  78   scalar_t relative_grab_x = 0, relative_grab_y = 0;
  79
  80   bool quit = false;
  81   bool press_shift = false;
  82   enum { IDLE, RANDOM, INTELLIGENT } action_mode = IDLE;
  83   bool got_event = true;
  84   int current_action = 0;
  85
  86   scalar_t last_hand_x = 0, last_hand_y = 0;
  87   Polygon *last_grabbing = 0;
  88   bool no_window = false;
  89
  90   //////////////////////////////////////////////////////////////////////
  91   //                    Parsing the shell arguments
  92   //////////////////////////////////////////////////////////////////////
  93
  94   int i = 1;
  95   while(i < argc) {
  96     if(argc == 1 || strcmp(argv[i], "--help") == 0) print_help_and_exit(0);
  97
  98     else if(strcmp(argv[i], "--test") == 0) {
  99       test_approximer();
 100       exit(0);
 101     }
 102
 103     else if(strcmp(argv[i], "--task") == 0) {
 104       check_opt(argc, argv, i, 2, "<filename: task to load> <int: degree>");
 105       if(task) {
 106         cerr << "Can not load two tasks." << endl;
 107         exit(1);
 108       }
 109       task = load_task(argv[i+1]);
 110       task_degree = atoi(argv[i+2]);
 111       i += 3;
 112
 113     } else if(strncmp(argv[i], "--", 2) == 0) {
 114       char variable_name[buffer_size] = "", variable_value[buffer_size] = "";
 115       char *o = argv[i]+2, *s = variable_name, *u = variable_value;
 116       while(*o && *o != '=') *s++ = *o++;
 117       if(*o) {
 118         o++;
 119         while(*o) *u++ = *o++;
 120       }
 121
 122       if(strcmp(variable_name, "nb-ticks") == 0)
 123         nb_ticks = atoi(variable_value);
 124       else if(strcmp(variable_name, "nb-training-iterations") == 0)
 125         nb_training_iterations = atoi(variable_value);
 126       else if(strcmp(variable_name, "proportion-for-training") == 0)
 127         proportion_for_training = atof(variable_value);
 128       else if(strcmp(variable_name, "no-window") == 0)
 129         no_window = true;
 130       else if(strcmp(variable_name, "save-file") == 0)
 131         strcpy(intelligence_save_file, variable_value);
 132       else if(strcmp(variable_name, "load-file") == 0)
 133         strcpy(intelligence_load_file, variable_value);
 134       else if(strcmp(variable_name, "action-mode") == 0) {
 135         if(strcmp(variable_value, "idle") == 0) action_mode = IDLE;
 136         else if(strcmp(variable_value, "random") == 0) action_mode = RANDOM;
 137         else if(strcmp(variable_value, "intelligent") == 0) action_mode = INTELLIGENT;
 138         else {
 139           cerr << "The only known modes are idle, random and intelligent" << endl;
 140           exit(1);
 141         }
 142       } else {
 143         cerr << "Unknown option " << argv[i] << endl;
 144         print_help_and_exit(1);
 145       }
 146       i++;
 147     } else {
 148       cerr << "Unknown option " << argv[i] << endl;
 149       print_help_and_exit(1);
 150     }
 151   }
 152
 153   cout << "FlatLand, a toy universe for goal-planning experiments." << endl;
 154
 155   if(!task) {
 156     task = load_task("dummy.so");
 157     task_degree = 0;
 158   }
 159
 160   cout << "Loaded task " << task->name()
 161        << " with degree " << task_degree << "/" << task->nb_degrees()
 162        << endl;
 163
 164   if(task_degree < 0 || task_degree >= task->nb_degrees()) {
 165     cout << "Invalid degree: " << task_degree << "." << endl;
 166     exit(1);
 167   }
 168
 169   //////////////////////////////////////////////////////////////////////
 170   //                      Various initializations
 171   //////////////////////////////////////////////////////////////////////
 172
 173   Universe universe(100, task->width(), task->height());
 174   task->init(&universe, task_degree);
 175   Retina retina(&universe);
 176   Manipulator manipulator(task);
 177   manipulator.force_move(task->width()/2, task->height()/2);
 178   retina.set_location(manipulator.hand_x(), manipulator.hand_y());
 179
 180   SimpleWindow *window_main = 0, *window_brain = 0;
 181   int window_main_fd = -1;
 182
 183 #ifdef CAIRO_SUPPORT
 184   // cairo_t *window_main_cairo_cr = 0;
 185 #endif
 186
 187   MapConcatener sensory_map(2);
 188   sensory_map.add_map(&retina);
 189   sensory_map.add_map(&manipulator);
 190   sensory_map.init();
 191
 192   MapExpander expanded_map(1000);
 193   expanded_map.set_input(&sensory_map);
 194   expanded_map.init();
 195
 196   Intelligence intelligence(&expanded_map, &manipulator, nb_ticks + 1, nb_training_iterations);
 197   intelligence.update(0, 0.0);
 198
 199   if(intelligence_load_file[0]) {
 200     cout << "Loading from " << intelligence_load_file << " ... " ;
 201     cout.flush();
 202     ifstream in(intelligence_load_file);
 203     if(in.fail()) {
 204       cerr << "error reading " << intelligence_load_file << "." << endl;
 205       exit(1);
 206     }
 207     intelligence.load(in);
 208     cout << "done." << endl ;
 209   }
 210
 211   if(no_window) {
 212     cout << "Started without windows." << endl;
 213   } else {
 214     window_main = new SimpleWindow("Universe (main window)", 4, 4, task->width(), task->height());
 215     window_main_fd = window_main->file_descriptor();
 216     window_main->map();
 217 #ifdef CAIRO_SUPPORT
 218     // window_main_cairo_cr = window_main->get_cairo_context_resource();
 219 #endif
 220     cout << "When the main window has the focus, press `q' to quit and click and drag to move" << endl
 221          << "objects." << endl;
 222     window_brain = new SimpleWindow("Universe (brain)",
 223                                     12 + task->width(), 4,
 224                                     retina.width(), retina.height() + manipulator.parameter_height());
 225     window_brain->map();
 226   }
 227
 228   int tick = 0;
 229   time_t last_t = 0;
 230   scalar_t sum_reward = 0;
 231
 232   //////////////////////////////////////////////////////////////////////
 233   //                         The main loop
 234   //////////////////////////////////////////////////////////////////////
 235
 236   while(!quit && tick != nb_ticks) {
 237
 238     int r;
 239     fd_set fds;
 240
 241
 242     if(window_main) {
 243       struct timeval tv;
 244       FD_ZERO (&fds);
 245       FD_SET (window_main_fd, &fds);
 246       tv.tv_sec = 0;
 247       tv.tv_usec = 5000; // 0.05s
 248       r = select(window_main_fd + 1, &fds, 0, 0, &tv);
 249     } else r = 0;
 250
 251     time_t t = time(0);
 252
 253     if(t > last_t) {
 254       last_t = t;
 255       cout << tick << " " << sum_reward << "              \r"; cout.flush();
 256     }
 257
 258     if(r == 0) { // No window event, thus it's the clock tick
 259
 260         int nb_it = 10;
 261
 262         bool changed = got_event;
 263         got_event = false;
 264
 265         switch(action_mode) {
 266         case IDLE:
 267           break;
 268         case RANDOM:
 269           current_action = manipulator.random_action();
 270           break;
 271         case INTELLIGENT:
 272           current_action = intelligence.best_action();
 273           //           if(drand48() < 0.5) current_action = intelligence.best_action();
 274           //           else                current_action = manipulator.random_action();
 275           break;
 276         }
 277
 278         manipulator.do_action(current_action);
 279
 280         scalar_t dt = 1.0/scalar_t(nb_it);
 281         for(int k = 0; k < nb_it; k++) {
 282           manipulator.update(dt, &universe);
 283           task->update(dt, &universe, &manipulator);
 284           changed |= universe.update(dt);
 285         }
 286
 287         tick++;
 288
 289         changed |= manipulator.hand_x() != last_hand_x ||
 290           manipulator.hand_y() != last_hand_y ||
 291           manipulator.grabbing() != last_grabbing;
 292
 293         scalar_t reward = task->reward(&universe, &manipulator);
 294         sum_reward += abs(reward);
 295         intelligence.update(current_action, reward);
 296         expanded_map.update_map();
 297
 298         if(changed) {
 299           last_hand_x = manipulator.hand_x();
 300           last_hand_y = manipulator.hand_y();
 301           last_grabbing = manipulator.grabbing();
 302
 303           retina.set_location(manipulator.hand_x(),
 304                               manipulator.hand_y());
 305
 306           if(window_main) {
 307             window_main->color(0.0, 0.0, 0.0);
 308             window_main->color(1.0, 1.0, 1.0);
 309             window_main->fill();
 310
 311 // #ifdef CAIRO_SUPPORT
 312             // CanvasCairo cc;
 313             // cc._context_resource = window_main_cairo_cr;
 314             // universe.draw(&cc);
 315 // #else
 316             universe.draw(window_main);
 317 // #endif
 318
 319             task->draw(window_main);
 320             manipulator.draw_on_universe(window_main);
 321             retina.draw_on_universe(window_main);
 322
 323             if(grabbed_polygon) {
 324               int x, y, delta = 3;
 325               x = int(grabbed_polygon->absolute_x(relative_grab_x, relative_grab_y));
 326               y = int(grabbed_polygon->absolute_y(relative_grab_x, relative_grab_y));
 327               window_main->color(0.0, 0.0, 0.0);
 328               window_main->draw_line(x - delta, y, x + delta, y);
 329               window_main->draw_line(x, y - delta, x, y + delta);
 330             }
 331
 332             window_main->show();
 333
 334             if(window_brain) {
 335               retina.draw_parameters(0, 0, window_brain);
 336               manipulator.draw_parameters(0, retina.height() + 1, window_brain);
 337               window_brain->show();
 338             }
 339           }
 340         }
 341
 342     } else if(r > 0) { // We got window events, let's process them
 343
 344       got_event = true;
 345
 346       if(FD_ISSET(window_main_fd, &fds)) {
 347
 348         SimpleEvent se;
 349
 350         do {
 351           se = window_main->event();
 352
 353           switch(se.type) {
 354
 355           case SimpleEvent::MOUSE_CLICK_PRESS:
 356             {
 357               switch(se.button) {
 358
 359               case 1:
 360                 if(press_shift) {
 361                   manipulator.force_move(se.x, se.y);
 362                   manipulator.do_action(Manipulator::ACTION_GRAB);
 363                 } else {
 364                   grabbed_polygon = universe.pick_polygon(se.x, se.y);
 365                   if(grabbed_polygon) {
 366                     relative_grab_x = grabbed_polygon->relative_x(se.x, se.y);
 367                     relative_grab_y = grabbed_polygon->relative_y(se.x, se.y);
 368                   }
 369                 }
 370                 break;
 371               case 4:
 372                 {
 373                   Polygon *g = universe.pick_polygon(se.x, se.y);
 374                   if(g) g->_theta += M_PI/32;
 375                 }
 376                 break;
 377               case 5:
 378                 {
 379                   Polygon *g = universe.pick_polygon(se.x, se.y);
 380                   if(g) g->_theta -= M_PI/32;
 381                 }
 382                 break;
 383               }
 384             }
 385             break;
 386
 387           case SimpleEvent::MOUSE_CLICK_RELEASE:
 388             switch(se.button) {
 389             case 1:
 390               if(press_shift) manipulator.do_action(Manipulator::ACTION_RELEASE);
 391               else            grabbed_polygon = 0;
 392               break;
 393             default:
 394               break;
 395             }
 396
 397           case SimpleEvent::MOUSE_MOTION:
 398             {
 399               if(press_shift) {
 400                 manipulator.force_move(se.x, se.y);
 401               } else if(grabbed_polygon) {
 402                 scalar_t xf, yf, force_x, force_y, f, fmax = 100;
 403                 xf = grabbed_polygon->absolute_x(relative_grab_x, relative_grab_y);
 404                 yf = grabbed_polygon->absolute_y(relative_grab_x, relative_grab_y);
 405                 force_x = se.x - xf;
 406                 force_y = se.y - yf;
 407                 f = sqrt(sq(force_x) + sq(force_y));
 408                 if(f > fmax) { force_x = (force_x * fmax)/f; force_y = (force_y * fmax)/f; }
 409                 grabbed_polygon->apply_force(0.1, xf, yf, force_x, force_y);
 410               }
 411               break;
 412             }
 413             break;
 414
 415           case SimpleEvent::KEY_PRESS:
 416             {
 417               if(strcmp(se.key, "q") == 0) {
 418                 quit = true;
 419               }
 420
 421               else if(strcmp(se.key, "s") == 0) {
 422
 423                 retina.save_as_ppm("/tmp/retina.ppm");
 424                 cout << "Retina screen shot saved in /tmp/retina.ppm" << endl;
 425
 426                 {
 427                   Plotter plotter(int(universe.width()), int(universe.height()), 4);
 428                   plotter.save_as_ppm(&universe, "/tmp/plotter.ppm", 16);
 429                 }
 430
 431 #ifdef XFIG_SUPPORT
 432                 {
 433                   XFigTracer tracer("/tmp/universe.fig");
 434                   universe.print_xfig(&tracer);
 435                 }
 436 #endif
 437
 438 #ifdef CAIRO_SUPPORT
 439                 {
 440                   FILE *file = fopen("/tmp/universe.png", "w");
 441                   generate_png(&universe, 0.25, file);
 442                   // generate_png(task->width(), task->height(), &universe, "/tmp/universe.png");
 443                   cout << "Universe image saved in /tmp/universe.png" << endl;
 444                 }
 445 #endif
 446
 447               }
 448
 449               else if(strcmp(se.key, "Shift_L") == 0 || strcmp(se.key, "Shift_R") == 0) {
 450                 press_shift = true;
 451               }
 452
 453               else if(strcmp(se.key, "Up") == 0) {
 454                 manipulator.do_action(Manipulator::ACTION_MOVE_UP);
 455               }
 456
 457               else if(strcmp(se.key, "Right") == 0) {
 458                 manipulator.do_action(Manipulator::ACTION_MOVE_RIGHT);
 459               }
 460
 461               else if(strcmp(se.key, "Down") == 0) {
 462                 manipulator.do_action(Manipulator::ACTION_MOVE_DOWN);
 463               }
 464
 465               else if(strcmp(se.key, "Left") == 0) {
 466                 manipulator.do_action(Manipulator::ACTION_MOVE_LEFT);
 467               }
 468
 469               else if(strcmp(se.key, "g") == 0) {
 470                 manipulator.do_action(Manipulator::ACTION_GRAB);
 471               }
 472
 473               else if(strcmp(se.key, "r") == 0) {
 474                 manipulator.do_action(Manipulator::ACTION_RELEASE);
 475               }
 476
 477               else if(strcmp(se.key, "space") == 0) {
 478                 switch(action_mode) {
 479                 case IDLE:
 480                   action_mode = RANDOM;
 481                   cout << "Switched to random mode" << endl;
 482                   break;
 483                 case RANDOM:
 484                   action_mode = INTELLIGENT;
 485                   cout << "Switched to intelligent mode" << endl;
 486                   break;
 487                 case INTELLIGENT:
 488                   cout << "Switched to idle mode" << endl;
 489                   action_mode = IDLE;
 490                   break;
 491                 }
 492               }
 493
 494               else cout << "Undefined key " << se.key << endl;
 495             }
 496             break;
 497
 498           case SimpleEvent::KEY_RELEASE:
 499             {
 500               if(strcmp(se.key, "Shift_L") == 0 || strcmp(se.key, "Shift_R") == 0) press_shift = false;
 501             }
 502             break;
 503
 504           default:
 505             break;
 506
 507           }
 508         } while(se.type != SimpleEvent::NO_EVENT);
 509       } else {
 510         cerr << "Error on select: " << strerror(errno) << endl;
 511         exit(1);
 512       }
 513     }
 514   }
 515
 516   if(proportion_for_training > 0) {
 517     cout << "Learning ... "; cout.flush();
 518     intelligence.learn(proportion_for_training);
 519     cout << "done." << endl;
 520   }
 521
 522   if(intelligence_save_file[0]) {
 523     cout << "Saving to " << intelligence_save_file << endl; cout.flush();
 524     ofstream os(intelligence_save_file);
 525     if(os.fail()) {
 526       cerr << "error writing " << intelligence_save_file << "." << endl;
 527       exit(1);
 528     }
 529     cout << "done." << endl;
 530     intelligence.save(os);
 531   }
 532
 533   delete window_brain;
 534   delete window_main;
 535
 536 }