caffe: test code for PETA dataset

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

7

8 #include

9 #include

10 #include

11 #include

12

13 #include "boost/algorithm/string.hpp"

14 #include "caffe/caffe.hpp"

15 #include "caffe/util/signal_handler.h"

16 #include

17 #include

18 #include

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 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* 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 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(strings[i]));

102 }

103 } else {

104 CHECK_EQ(gpus->size(), 0);

105 }

106 }

107

108 // caffe commands to call by

109 // caffe

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 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* solver, const std::string& model_list) {

130 std::vector 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(solver_param.device_id());

174 } else { // Set default GPU if unspecified

175 FLAGS_gpu = "" + boost::lexical_cast(0);

176 }

177 }

178

179 vector 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 >

202 solver(caffe::GetSolver(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 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 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 caffe_net(FLAGS_model, caffe::TEST);

267 caffe_net.CopyTrainedLayersFrom(FLAGS_weights);

268 LOG(INFO) << "Running for " << FLAGS_iterations << " iterations.";

269

270 vector* > bottom_vec;

271 vector test_score_output_id;

272 vector 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*>& 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 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 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*>(), &initial_loss);

434 LOG(INFO) << "Initial loss: " << initial_loss;

435 LOG(INFO) << "Performing Backward";

436 caffe_net.Backward();

437

438 const vector > >& layers = caffe_net.layers();

439 const vector*> >& bottom_vecs = caffe_net.bottom_vecs();

440 const vector*> >& top_vecs = caffe_net.top_vecs();

441 const vector >& 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 forward_time_per_layer(layers.size(), 0.0);

451 std::vector 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 \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 }

精彩文章