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 }
