test code for PETA datasets ....
1 #ifdef WITH_PYTHON_LAYER 2 #include "boost/python.hpp" 3 namespace bp = boost::python; 4 #endif 5 6 #include <glog/logging.h> 7 8 #include <cstring> 9 #include <map> 10 #include <string> 11 #include <vector> 12 13 #include "boost/algorithm/string.hpp" 14 #include "caffe/caffe.hpp" 15 #include "caffe/util/signal_handler.h" 16 #include <fstream> 17 #include <sstream> 18 #include <iostream> 19 20 using caffe::Blob; 21 using caffe::Caffe; 22 using caffe::Net; 23 using caffe::Layer; 24 using caffe::Solver; 25 using caffe::shared_ptr; 26 using caffe::string; 27 using caffe::Timer; 28 using caffe::vector; 29 using std::ostringstream; 30 using namespace std; 31 32 DEFINE_string(gpu, "", 33 "Optional; run in GPU mode on given device IDs separated by ','." 34 "Use '-gpu all' to run on all available GPUs. The effective training " 35 "batch size is multiplied by the number of devices."); 36 DEFINE_string(solver, "", 37 "The solver definition protocol buffer text file."); 38 DEFINE_string(model, "", 39 "The model definition protocol buffer text file.."); 40 DEFINE_string(snapshot, "", 41 "Optional; the snapshot solver state to resume training."); 42 DEFINE_string(weights, "", 43 "Optional; the pretrained weights to initialize finetuning, " 44 "separated by ','. Cannot be set simultaneously with snapshot."); 45 // DEFINE_int32(iteratinos, 29329, 46 DEFINE_int32(iterations, 7615, 47 "The number of iterations to run."); 48 DEFINE_string(sigint_effect, "stop", 49 "Optional; action to take when a SIGINT signal is received: " 50 "snapshot, stop or none."); 51 DEFINE_string(sighup_effect, "snapshot", 52 "Optional; action to take when a SIGHUP signal is received: " 53 "snapshot, stop or none."); 54 55 // A simple registry for caffe commands. 56 typedef int (*BrewFunction)(); 57 typedef std::map<caffe::string, BrewFunction> BrewMap; 58 BrewMap g_brew_map; 59 60 #define RegisterBrewFunction(func) \ 61 namespace { \ 62 class __Registerer_##func { \ 63 public: /* NOLINT */ \ 64 __Registerer_##func() { \ 65 g_brew_map[#func] = &func; \ 66 } \ 67 }; \ 68 __Registerer_##func g_registerer_##func; \ 69 } 70 71 static BrewFunction GetBrewFunction(const caffe::string& name) { 72 if (g_brew_map.count(name)) { 73 return g_brew_map[name]; 74 } else { 75 LOG(ERROR) << "Available caffe actions:"; 76 for (BrewMap::iterator it = g_brew_map.begin(); 77 it != g_brew_map.end(); ++it) { 78 LOG(ERROR) << "\t" << it->first; 79 } 80 LOG(FATAL) << "Unknown action: " << name; 81 return NULL; // not reachable, just to suppress old compiler warnings. 82 } 83 } 84 85 // Parse GPU ids or use all available devices 86 static void get_gpus(vector<int>* gpus) { 87 if (FLAGS_gpu == "all") { 88 int count = 0; 89 #ifndef CPU_ONLY 90 CUDA_CHECK(cudaGetDeviceCount(&count)); 91 #else 92 NO_GPU; 93 #endif 94 for (int i = 0; i < count; ++i) { 95 gpus->push_back(i); 96 } 97 } else if (FLAGS_gpu.size()) { 98 vector<string> strings; 99 boost::split(strings, FLAGS_gpu, boost::is_any_of(",")); 100 for (int i = 0; i < strings.size(); ++i) { 101 gpus->push_back(boost::lexical_cast<int>(strings[i])); 102 } 103 } else { 104 CHECK_EQ(gpus->size(), 0); 105 } 106 } 107 108 // caffe commands to call by 109 // caffe <command> <args> 110 // 111 // To add a command, define a function "int command()" and register it with 112 // RegisterBrewFunction(action); 113 114 // Device Query: show diagnostic information for a GPU device. 115 int device_query() { 116 LOG(INFO) << "Querying GPUs " << FLAGS_gpu; 117 vector<int> gpus; 118 get_gpus(&gpus); 119 for (int i = 0; i < gpus.size(); ++i) { 120 caffe::Caffe::SetDevice(gpus[i]); 121 caffe::Caffe::DeviceQuery(); 122 } 123 return 0; 124 } 125 RegisterBrewFunction(device_query); 126 127 // Load the weights from the specified caffemodel(s) into the train and 128 // test nets. 129 void CopyLayers(caffe::Solver<float>* solver, const std::string& model_list) { 130 std::vector<std::string> model_names; 131 boost::split(model_names, model_list, boost::is_any_of(",") ); 132 for (int i = 0; i < model_names.size(); ++i) { 133 LOG(INFO) << "Finetuning from " << model_names[i]; 134 solver->net()->CopyTrainedLayersFrom(model_names[i]); 135 for (int j = 0; j < solver->test_nets().size(); ++j) { 136 solver->test_nets()[j]->CopyTrainedLayersFrom(model_names[i]); 137 } 138 } 139 } 140 141 // Translate the signal effect the user specified on the command-line to the 142 // corresponding enumeration. 143 caffe::SolverAction::Enum GetRequestedAction( 144 const std::string& flag_value) { 145 if (flag_value == "stop") { 146 return caffe::SolverAction::STOP; 147 } 148 if (flag_value == "snapshot") { 149 return caffe::SolverAction::SNAPSHOT; 150 } 151 if (flag_value == "none") { 152 return caffe::SolverAction::NONE; 153 } 154 LOG(FATAL) << "Invalid signal effect \""<< flag_value << "\" was specified"; 155 } 156 157 // Train / Finetune a model. 158 int train() { 159 CHECK_GT(FLAGS_solver.size(), 0) << "Need a solver definition to train."; 160 CHECK(!FLAGS_snapshot.size() || !FLAGS_weights.size()) 161 << "Give a snapshot to resume training or weights to finetune " 162 "but not both."; 163 164 caffe::SolverParameter solver_param; 165 caffe::ReadProtoFromTextFileOrDie(FLAGS_solver, &solver_param); 166 167 // If the gpus flag is not provided, allow the mode and device to be set 168 // in the solver prototxt. 169 if (FLAGS_gpu.size() == 0 170 && solver_param.solver_mode() == caffe::SolverParameter_SolverMode_GPU) { 171 if (solver_param.has_device_id()) { 172 FLAGS_gpu = "" + 173 boost::lexical_cast<string>(solver_param.device_id()); 174 } else { // Set default GPU if unspecified 175 FLAGS_gpu = "" + boost::lexical_cast<string>(0); 176 } 177 } 178 179 vector<int> gpus; 180 get_gpus(&gpus); 181 if (gpus.size() == 0) { 182 LOG(INFO) << "Use CPU."; 183 Caffe::set_mode(Caffe::CPU); 184 } else { 185 ostringstream s; 186 for (int i = 0; i < gpus.size(); ++i) { 187 s << (i ? ", " : "") << gpus[i]; 188 } 189 LOG(INFO) << "Using GPUs " << s.str(); 190 191 solver_param.set_device_id(gpus[0]); 192 Caffe::SetDevice(gpus[0]); 193 Caffe::set_mode(Caffe::GPU); 194 Caffe::set_solver_count(gpus.size()); 195 } 196 197 caffe::SignalHandler signal_handler( 198 GetRequestedAction(FLAGS_sigint_effect), 199 GetRequestedAction(FLAGS_sighup_effect)); 200 201 shared_ptr<caffe::Solver<float> > 202 solver(caffe::GetSolver<float>(solver_param)); 203 204 solver->SetActionFunction(signal_handler.GetActionFunction()); 205 206 if (FLAGS_snapshot.size()) { 207 LOG(INFO) << "Resuming from " << FLAGS_snapshot; 208 solver->Restore(FLAGS_snapshot.c_str()); 209 } else if (FLAGS_weights.size()) { 210 CopyLayers(solver.get(), FLAGS_weights); 211 } 212 213 if (gpus.size() > 1) { 214 caffe::P2PSync<float> sync(solver, NULL, solver->param()); 215 sync.run(gpus); 216 } else { 217 LOG(INFO) << "Starting Optimization"; 218 solver->Solve(); 219 } 220 LOG(INFO) << "Optimization Done."; 221 return 0; 222 } 223 RegisterBrewFunction(train); 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 // Test: score a model. 249 int test() { 250 CHECK_GT(FLAGS_model.size(), 0) << "Need a model definition to score."; 251 CHECK_GT(FLAGS_weights.size(), 0) << "Need model weights to score."; 252 253 // Set device id and mode 254 vector<int> gpus; 255 get_gpus(&gpus); 256 if (gpus.size() != 0) { 257 LOG(INFO) << "Use GPU with device ID " << gpus[0]; 258 Caffe::SetDevice(gpus[0]); 259 Caffe::set_mode(Caffe::GPU); 260 } else { 261 LOG(INFO) << "Use CPU."; 262 Caffe::set_mode(Caffe::CPU); 263 } 264 265 // Instantiate the caffe net. 266 Net<float> caffe_net(FLAGS_model, caffe::TEST); 267 caffe_net.CopyTrainedLayersFrom(FLAGS_weights); 268 LOG(INFO) << "Running for " << FLAGS_iterations << " iterations."; 269 270 vector<Blob<float>* > bottom_vec; 271 vector<int> test_score_output_id; 272 vector<float> test_score; 273 // float loss = 0; 274 int nu = 0; 275 // int num = 0; 276 // int num2 = 0; 277 278 const int att_num = 43; 279 static int TP[att_num] = {0}; 280 static int TN[att_num] = {0}; 281 static int FP[att_num] = {0}; 282 static int FN[att_num] = {0}; 283 284 for (int i = 0; i < FLAGS_iterations; ++i) { // num of images; test image:7600 285 286 LOG(INFO) << "batch " << i << "/" << FLAGS_iterations << ", waiting..."; 287 288 float iter_loss; 289 const vector<Blob<float>*>& result = 290 caffe_net.Forward(bottom_vec, &iter_loss); // outPut result 291 292 LOG(INFO) << "result.size: " << result.size() << " " << result[0]->count() << " " << result[1]->count() 293 << " " << result[2]->count() ; 294 295 const float* result_index = result[0]->cpu_data(); // index 296 const float* result_score = result[1]->cpu_data(); // predict score; 297 const float* result_label = result[2]->cpu_data(); // Groundtruth label; 298 299 for (int k = 0; k < att_num; ++k) { // for 35 attributes 300 301 // const float index_ = result_index; 302 const float Predict_score = result_score[k]; 303 const float GT_label = result_label[k]; 304 305 float threshold_ = 0.4; 306 if ((Predict_score < threshold_) && (int(GT_label) == 0)) 307 TN[k] = TN[k] + 1; 308 if ((Predict_score > threshold_) && (int(GT_label) == 0)) 309 FP[k] = FP[k] + 1; 310 if ((Predict_score < threshold_) && (int(GT_label) == 1)) 311 FN[k] = FN[k] + 1; 312 if ((Predict_score > threshold_) && (int(GT_label) == 1)) 313 TP[k] = TP[k] + 1; 314 315 316 // write the predicted score into txt files 317 ofstream file("/home/wangxiao/Downloads/whole_benchmark/Sec_Batch_/sec_Batch_unlabel.txt",ios::app); 318 if(!file) return -1; 319 320 if(nu < att_num){ 321 file << Predict_score << " " ; 322 nu++; 323 } else { 324 nu = 1; 325 file << endl; 326 file << Predict_score << " " ; 327 } 328 file.close(); 329 330 331 // // write the Index into txt files 332 // ofstream file2("/home/wangxiao/Downloads/caffe-master/wangxiao/bvlc_alexnet/43_attributes_index.txt",ios::app); 333 // if(!file2) return -1; 334 335 // if(num < att_num){ 336 // file2 << index_ << " " ; 337 // num++; 338 // } else { 339 // num = 1; 340 // file2 << endl; 341 // file2 << index_ << " " ; 342 // } 343 // file2.close(); 344 345 // // write the GroundTruth Label into txt files 346 // ofstream file3("/home/wangxiao/Downloads/whole_benchmark/Unlabeled_data/Unlabeled_AnHui_label.txt",ios::app); 347 // if(!file3) return -1; 348 349 // if(num2 < att_num){ 350 // file3 << GT_label << " " ; 351 // num2++; 352 // } else { 353 // num2 = 1; 354 // file3 << endl; 355 // file3 << GT_label << " " ; 356 // } 357 // file3.close(); 358 359 360 } 361 } 362 363 double aver_accuracy = 0; 364 365 for (int k = 0; k < att_num; ++k){ 366 aver_accuracy += 0.5*(double(TP[k])/(TP[k]+FN[k]) + double(TN[k])/(TN[k] + FP[k])); 367 LOG(INFO) << "Accuracy: " << k << " " 368 << 0.5*(double(TP[k])/(TP[k]+FN[k]) + double(TN[k])/(TN[k] + FP[k])); 369 LOG(INFO) << "TP = " << double(TP[k]); 370 LOG(INFO) << "FN = " << double(FN[k]); 371 LOG(INFO) << "FP = " << double(FP[k]); 372 LOG(INFO) << "TN = " << double(TN[k]); 373 } 374 375 LOG(INFO) << "####################"; 376 LOG(INFO) << " "; 377 LOG(INFO) << "Average_accuracy: " << aver_accuracy / att_num; 378 LOG(INFO) << " "; 379 LOG(INFO) << "####################"; 380 381 return 0; 382 } 383 384 RegisterBrewFunction(test); 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 // Time: benchmark the execution time of a model. 410 int time() { 411 CHECK_GT(FLAGS_model.size(), 0) << "Need a model definition to time."; 412 413 // Set device id and mode 414 vector<int> gpus; 415 get_gpus(&gpus); 416 if (gpus.size() != 0) { 417 LOG(INFO) << "Use GPU with device ID " << gpus[0]; 418 Caffe::SetDevice(gpus[0]); 419 Caffe::set_mode(Caffe::GPU); 420 } else { 421 LOG(INFO) << "Use CPU."; 422 Caffe::set_mode(Caffe::CPU); 423 } 424 // Instantiate the caffe net. 425 Net<float> caffe_net(FLAGS_model, caffe::TRAIN); 426 427 // Do a clean forward and backward pass, so that memory allocation are done 428 // and future iterations will be more stable. 429 LOG(INFO) << "Performing Forward"; 430 // Note that for the speed benchmark, we will assume that the network does 431 // not take any input blobs. 432 float initial_loss; 433 caffe_net.Forward(vector<Blob<float>*>(), &initial_loss); 434 LOG(INFO) << "Initial loss: " << initial_loss; 435 LOG(INFO) << "Performing Backward"; 436 caffe_net.Backward(); 437 438 const vector<shared_ptr<Layer<float> > >& layers = caffe_net.layers(); 439 const vector<vector<Blob<float>*> >& bottom_vecs = caffe_net.bottom_vecs(); 440 const vector<vector<Blob<float>*> >& top_vecs = caffe_net.top_vecs(); 441 const vector<vector<bool> >& bottom_need_backward = 442 caffe_net.bottom_need_backward(); 443 LOG(INFO) << "*** Benchmark begins ***"; 444 LOG(INFO) << "Testing for " << FLAGS_iterations << " iterations."; 445 Timer total_timer; 446 total_timer.Start(); 447 Timer forward_timer; 448 Timer backward_timer; 449 Timer timer; 450 std::vector<double> forward_time_per_layer(layers.size(), 0.0); 451 std::vector<double> backward_time_per_layer(layers.size(), 0.0); 452 double forward_time = 0.0; 453 double backward_time = 0.0; 454 for (int j = 0; j < FLAGS_iterations; ++j) { 455 Timer iter_timer; 456 iter_timer.Start(); 457 forward_timer.Start(); 458 for (int i = 0; i < layers.size(); ++i) { 459 timer.Start(); 460 layers[i]->Forward(bottom_vecs[i], top_vecs[i]); 461 forward_time_per_layer[i] += timer.MicroSeconds(); 462 } 463 forward_time += forward_timer.MicroSeconds(); 464 backward_timer.Start(); 465 for (int i = layers.size() - 1; i >= 0; --i) { 466 timer.Start(); 467 layers[i]->Backward(top_vecs[i], bottom_need_backward[i], 468 bottom_vecs[i]); 469 backward_time_per_layer[i] += timer.MicroSeconds(); 470 } 471 backward_time += backward_timer.MicroSeconds(); 472 LOG(INFO) << "Iteration: " << j + 1 << " forward-backward time: " 473 << iter_timer.MilliSeconds() << " ms."; 474 } 475 LOG(INFO) << "Average time per layer: "; 476 for (int i = 0; i < layers.size(); ++i) { 477 const caffe::string& layername = layers[i]->layer_param().name(); 478 LOG(INFO) << std::setfill(' ') << std::setw(10) << layername << 479 "\tforward: " << forward_time_per_layer[i] / 1000 / 480 FLAGS_iterations << " ms."; 481 LOG(INFO) << std::setfill(' ') << std::setw(10) << layername << 482 "\tbackward: " << backward_time_per_layer[i] / 1000 / 483 FLAGS_iterations << " ms."; 484 } 485 total_timer.Stop(); 486 LOG(INFO) << "Average Forward pass: " << forward_time / 1000 / 487 FLAGS_iterations << " ms."; 488 LOG(INFO) << "Average Backward pass: " << backward_time / 1000 / 489 FLAGS_iterations << " ms."; 490 LOG(INFO) << "Average Forward-Backward: " << total_timer.MilliSeconds() / 491 FLAGS_iterations << " ms."; 492 LOG(INFO) << "Total Time: " << total_timer.MilliSeconds() << " ms."; 493 LOG(INFO) << "*** Benchmark ends ***"; 494 return 0; 495 } 496 RegisterBrewFunction(time); 497 498 int main(int argc, char** argv) { 499 // Print output to stderr (while still logging). 500 FLAGS_alsologtostderr = 1; 501 // Usage message. 502 gflags::SetUsageMessage("command line brew\n" 503 "usage: caffe <command> <args>\n\n" 504 "commands:\n" 505 " train train or finetune a model\n" 506 " test score a model\n" 507 " device_query show GPU diagnostic information\n" 508 " time benchmark model execution time"); 509 // Run tool or show usage. 510 caffe::GlobalInit(&argc, &argv); 511 if (argc == 2) { 512 #ifdef WITH_PYTHON_LAYER 513 try { 514 #endif 515 return GetBrewFunction(caffe::string(argv[1]))(); 516 #ifdef WITH_PYTHON_LAYER 517 } catch (bp::error_already_set) { 518 PyErr_Print(); 519 return 1; 520 } 521 #endif 522 } else { 523 gflags::ShowUsageWithFlagsRestrict(argv[0], "tools/caffe"); 524 } 525 }
