vision_test.cc

   1 /*
   2  *  svrt is the ``Synthetic Visual Reasoning Test'', an image
   3  *  generator for evaluating classification performance of machine
   4  *  learning systems, humans and primates.
   5  *
   6  *  Copyright (c) 2009 Idiap Research Institute, http://www.idiap.ch/
   7  *  Written by Francois Fleuret <francois.fleuret@idiap.ch>
   8  *
   9  *  This file is part of svrt.
  10  *
  11  *  svrt is free software: you can redistribute it and/or modify it
  12  *  under the terms of the GNU General Public License version 3 as
  13  *  published by the Free Software Foundation.
  14  *
  15  *  svrt is distributed in the hope that it will be useful, but
  16  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  *  General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with selector.  If not, see <http://www.gnu.org/licenses/>.
  22  *
  23  */
  24
  25 #include <iostream>
  26 #include <fstream>
  27 #include <cmath>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30
  31 using namespace std;
  32
  33 #include "rgb_image.h"
  34 #include "param_parser.h"
  35 #include "global.h"
  36
  37 #include "vignette.h"
  38 #include "shape.h"
  39 #include "classifier.h"
  40 #include "classifier_reader.h"
  41 #include "naive_bayesian_classifier.h"
  42 #include "boosted_classifier.h"
  43 #include "error_rates.h"
  44
  45 #include "vision_problem_1.h"
  46 #include "vision_problem_2.h"
  47 #include "vision_problem_3.h"
  48 #include "vision_problem_5.h"
  49 #include "vision_problem_6.h"
  50 #include "vision_problem_8.h"
  51 #include "vision_problem_11.h"
  52 #include "vision_problem_12.h"
  53 #include "vision_problem_13.h"
  54 #include "vision_problem_17.h"
  55 #include "vision_problem_18.h"
  56 #include "vision_problem_20.h"
  57 #include "vision_problem_21.h"
  58
  59 //////////////////////////////////////////////////////////////////////
  60
  61 void check(bool condition, const char *message) {
  62   if(!condition) {
  63     cerr << message << endl;
  64     exit(1);
  65   }
  66 }
  67
  68 int main(int argc, char **argv) {
  69
  70   char buffer[buffer_size];
  71   char *new_argv[argc];
  72   int new_argc = 0;
  73
  74   cout << "-- ARGUMENTS ---------------------------------------------------------" << endl;
  75
  76   for(int i = 0; i < argc; i++)
  77     cout << (i > 0 ? "  " : "") << argv[i] << (i < argc - 1 ? " \\" : "")
  78          << endl;
  79
  80   cout << "-- PARAMETERS --------------------------------------------------------" << endl;
  81
  82   {
  83     ParamParser parser;
  84     global.init_parser(&parser);
  85     parser.parse_options(argc, argv, false, &new_argc, new_argv);
  86     global.read_parser(&parser);
  87     parser.print_all(&cout);
  88   }
  89
  90   nice(global.niceness);
  91   srand48(global.random_seed);
  92
  93   VignetteGenerator *generator;
  94
  95   switch(global.problem_number) {
  96   case 1:
  97     generator = new VisionProblem_1();
  98     break;
  99   case 2:
 100     generator = new VisionProblem_2();
 101     break;
 102   case 3:
 103     generator = new VisionProblem_3();
 104     break;
 105   // case 4:
 106     // generator = new VisionProblem_4();
 107     // break;
 108   case 5:
 109     generator = new VisionProblem_5();
 110     break;
 111   case 6:
 112     generator = new VisionProblem_6();
 113     break;
 114   // case 7:
 115     // generator = new VisionProblem_7();
 116     // break;
 117   case 8:
 118     generator = new VisionProblem_8();
 119     break;
 120   // case 9:
 121     // generator = new VisionProblem_9();
 122     // break;
 123   // case 10:
 124     // generator = new VisionProblem_10();
 125     // break;
 126   case 11:
 127     generator = new VisionProblem_11();
 128     break;
 129   case 12:
 130     generator = new VisionProblem_12();
 131     break;
 132   case 13:
 133     generator = new VisionProblem_13();
 134     break;
 135   // case 14:
 136     // generator = new VisionProblem_14();
 137     // break;
 138   // case 15:
 139     // generator = new VisionProblem_15();
 140     // break;
 141   // case 16:
 142     // generator = new VisionProblem_16();
 143     // break;
 144   case 17:
 145     generator = new VisionProblem_17();
 146     break;
 147   case 18:
 148     generator = new VisionProblem_18();
 149     break;
 150   // case 19:
 151     // generator = new VisionProblem_19();
 152     // break;
 153   case 20:
 154     generator = new VisionProblem_20();
 155     break;
 156   case 21:
 157     generator = new VisionProblem_21();
 158     break;
 159   // case 22:
 160     // generator = new VisionProblem_22();
 161     // break;
 162   // case 23:
 163     // generator = new VisionProblem_23();
 164     // break;
 165   default:
 166     cerr << "Can not find problem "
 167          << global.problem_number
 168          << endl;
 169     exit(1);
 170   }
 171
 172   generator->precompute();
 173
 174   //////////////////////////////////////////////////////////////////////
 175
 176   Vignette *train_samples;
 177   int *train_labels;
 178
 179   train_samples = new Vignette[global.nb_train_samples];
 180   train_labels = new int[global.nb_train_samples];
 181
 182   //////////////////////////////////////////////////////////////////////
 183
 184   Classifier *classifier = 0;
 185
 186   cout << "-- COMPUTATIONS ------------------------------------------------------" << endl;
 187
 188   for(int c = 1; c < new_argc; c++) {
 189
 190     if(strcmp(new_argv[c], "randomize-train") == 0) {
 191       cout << "Generating the training set." << endl;
 192       for(int n = 0; n < global.nb_train_samples; n++) {
 193         train_labels[n] = int(drand48() * 2);
 194         generator->generate(train_labels[n], &train_samples[n]);
 195       }
 196     }
 197
 198     else if(strcmp(new_argv[c], "adaboost") == 0) {
 199       delete classifier;
 200       cout << "Building and training adaboost classifier." << endl;
 201       classifier = new BoostedClassifier(global.nb_weak_learners);
 202       classifier->train(global.nb_train_samples, train_samples, train_labels);
 203     }
 204
 205     else if(strcmp(new_argv[c], "naive-bayesian") == 0) {
 206       delete classifier;
 207       cout << "Building and training naive bayesian classifier." << endl;
 208       classifier = new NaiveBayesianClassifier();
 209       classifier->train(global.nb_train_samples, train_samples, train_labels);
 210     }
 211
 212     else if(strcmp(new_argv[c], "read-classifier") == 0) {
 213       delete classifier;
 214       sprintf(buffer, "%s", global.classifier_name);
 215       cout << "Reading classifier from " << buffer << "." << endl;
 216       ifstream in(buffer);
 217       if(in.fail()) {
 218         cerr << "Can not open " << buffer << " for reading." << endl;
 219         exit(1);
 220       }
 221       classifier = read_classifier(&in);
 222     }
 223
 224     else if(strcmp(new_argv[c], "write-classifier") == 0) {
 225       check(classifier, "No classifier.");
 226       sprintf(buffer, "%s/%s", global.result_path, global.classifier_name);
 227       cout << "Writing classifier to " << buffer << "." << endl;
 228       ofstream out(buffer);
 229       if(out.fail()) {
 230         cerr << "Can not open " << buffer << " for writing." << endl;
 231         exit(1);
 232       }
 233       classifier->write(&out);
 234     }
 235
 236     else if(strcmp(new_argv[c], "compute-errors-vs-nb-samples") == 0) {
 237       for(int t = global.nb_train_samples; t >= 100; t /= 10) {
 238         for(int n = 0; n < t; n++) {
 239           train_labels[n] = int(drand48() * 2);
 240           generator->generate(train_labels[n], &train_samples[n]);
 241         }
 242         Classifier *classifier = 0;
 243         cout << "Building and training adaboost classifier with " << t << " samples." << endl;
 244         classifier = new BoostedClassifier(global.nb_weak_learners);
 245         classifier->train(t, train_samples, train_labels);
 246         cout << "ERROR_RATES_VS_NB_SAMPLES "
 247              << t
 248              << " TRAIN_ERROR "
 249              << error_rate(classifier, t, train_samples, train_labels)
 250              << " TEST_ERROR "
 251              << test_error_rate(generator, classifier, global.nb_test_samples) << endl;
 252         delete classifier;
 253       }
 254     }
 255
 256     else if(strcmp(new_argv[c], "compute-train-error") == 0) {
 257       check(classifier, "No classifier.");
 258       cout << "TRAIN_ERROR_RATE "
 259            << classifier->name()
 260            << " "
 261            << error_rate(classifier, global.nb_train_samples, train_samples, train_labels)
 262            << endl;
 263     }
 264
 265     else if(strcmp(new_argv[c], "compute-test-error") == 0) {
 266       check(classifier, "No classifier.");
 267       cout << "TEST_ERROR_RATE "
 268            << classifier->name()
 269            << " "
 270            << test_error_rate(generator, classifier, global.nb_test_samples) << endl;
 271     }
 272
 273     else if(strcmp(new_argv[c], "write-samples") == 0) {
 274       Vignette vignette;
 275       for(int k = 0; k < global.nb_train_samples; k++) {
 276         for(int l = 0; l < 2; l++) {
 277           generator->generate(l, &vignette);
 278           sprintf(buffer, "%s/sample_%01d_%04d.png", global.result_path, l, k);
 279           vignette.write_png(buffer, 1);
 280           cout << "Wrote " << buffer << endl;
 281         }
 282       }
 283     }
 284
 285     //////////////////////////////////////////////////////////////////////
 286
 287     //////////////////////////////////////////////////////////////////////
 288
 289     else {
 290       cerr << "Unknown action " << new_argv[c] << endl;
 291       exit(1);
 292     }
 293
 294   }
 295
 296   cout << "-- FINISHED ----------------------------------------------------------" << endl;
 297
 298   delete classifier;
 299   delete[] train_labels;
 300   delete[] train_samples;
 301   delete generator;
 302 }