caffe: test code for PETA dataset

test code for PETA datasets ....

 #ifdef WITH_PYTHON_LAYER
 #include "boost/python.hpp"
 namespace bp = boost::python;
 #endif

 #include <glog/logging.h>

 #include <cstring>
 #include <map>
 #include <string>
 #include <vector>

 #include "boost/algorithm/string.hpp"
 #include "caffe/caffe.hpp"
 #include "caffe/util/signal_handler.h"
 #include <fstream>
 #include <sstream>
 #include <iostream>

 using caffe::Blob;
 using caffe::Caffe;
 using caffe::Net;
 using caffe::Layer;
 using caffe::Solver;
 using caffe::shared_ptr;
 using caffe::string;
 using caffe::Timer;
 using caffe::vector;
 using std::ostringstream;
 using namespace std;

 DEFINE_string(gpu, "",
     "Optional; run in GPU mode on given device IDs separated by ','."
     "Use '-gpu all' to run on all available GPUs. The effective training "
     "batch size is multiplied by the number of devices.");
 DEFINE_string(solver, "",
     "The solver definition protocol buffer text file.");
 DEFINE_string(model, "",
     "The model definition protocol buffer text file..");
 DEFINE_string(snapshot, "",
     "Optional; the snapshot solver state to resume training.");
 DEFINE_string(weights, "",
     "Optional; the pretrained weights to initialize finetuning, "
     "separated by ','. Cannot be set simultaneously with snapshot.");
 // DEFINE_int32(iteratinos, 29329,
 DEFINE_int32(iterations, ,
     "The number of iterations to run.");
 DEFINE_string(sigint_effect, "stop",
              "Optional; action to take when a SIGINT signal is received: "
               "snapshot, stop or none.");
 DEFINE_string(sighup_effect, "snapshot",
              "Optional; action to take when a SIGHUP signal is received: "
              "snapshot, stop or none.");

 // A simple registry for caffe commands.
 typedef int (*BrewFunction)();
 typedef std::map<caffe::string, BrewFunction> BrewMap;
 BrewMap g_brew_map;

 #define RegisterBrewFunction(func) \
 namespace { \
 class __Registerer_##func { \
  public: /* NOLINT */ \
   __Registerer_##func() { \
     g_brew_map[#func] = &func; \
   } \
 }; \
 __Registerer_##func g_registerer_##func; \
 }

 static BrewFunction GetBrewFunction(const caffe::string& name) {
   if (g_brew_map.count(name)) {
     return g_brew_map[name];
   } else {
     LOG(ERROR) << "Available caffe actions:";
     for (BrewMap::iterator it = g_brew_map.begin();
          it != g_brew_map.end(); ++it) {
       LOG(ERROR) << "\t" << it->first;
     }
     LOG(FATAL) << "Unknown action: " << name;
     return NULL;  // not reachable, just to suppress old compiler warnings.
   }
 }

 // Parse GPU ids or use all available devices
 static void get_gpus(vector<int>* gpus) {
   if (FLAGS_gpu == "all") {
     int count = ;
 #ifndef CPU_ONLY
     CUDA_CHECK(cudaGetDeviceCount(&count));
 #else
     NO_GPU;
 #endif
     for (int i = ; i < count; ++i) {
       gpus->push_back(i);
     }
   } else if (FLAGS_gpu.size()) {
     vector<string> strings;
     boost::split(strings, FLAGS_gpu, boost::is_any_of(","));
     for (int i = ; i < strings.size(); ++i) {
       gpus->push_back(boost::lexical_cast<int>(strings[i]));
     }
   } else {
     CHECK_EQ(gpus->size(), );
   }
 }

 // caffe commands to call by
 //     caffe <command> <args>
 //
 // To add a command, define a function "int command()" and register it with
 // RegisterBrewFunction(action);

 // Device Query: show diagnostic information for a GPU device.
 int device_query() {
   LOG(INFO) << "Querying GPUs " << FLAGS_gpu;
   vector<int> gpus;
   get_gpus(&gpus);
   for (int i = ; i < gpus.size(); ++i) {
     caffe::Caffe::SetDevice(gpus[i]);
     caffe::Caffe::DeviceQuery();
   }
   return ;
 }
 RegisterBrewFunction(device_query);

 // Load the weights from the specified caffemodel(s) into the train and
 // test nets.
 void CopyLayers(caffe::Solver<float>* solver, const std::string& model_list) {
   std::vector<std::string> model_names;
   boost::split(model_names, model_list, boost::is_any_of(",") );
   for (int i = ; i < model_names.size(); ++i) {
     LOG(INFO) << "Finetuning from " << model_names[i];
     solver->net()->CopyTrainedLayersFrom(model_names[i]);
     for (int j = ; j < solver->test_nets().size(); ++j) {
       solver->test_nets()[j]->CopyTrainedLayersFrom(model_names[i]);
     }
   }
 }

 // Translate the signal effect the user specified on the command-line to the
 // corresponding enumeration.
 caffe::SolverAction::Enum GetRequestedAction(
     const std::string& flag_value) {
   if (flag_value == "stop") {
     return caffe::SolverAction::STOP;
   }
   if (flag_value == "snapshot") {
     return caffe::SolverAction::SNAPSHOT;
   }
   if (flag_value == "none") {
     return caffe::SolverAction::NONE;
   }
   LOG(FATAL) << "Invalid signal effect \""<< flag_value << "\" was specified";
 }

 // Train / Finetune a model.
 int train() {
   CHECK_GT(FLAGS_solver.size(), ) << "Need a solver definition to train.";
   CHECK(!FLAGS_snapshot.size() || !FLAGS_weights.size())
       << "Give a snapshot to resume training or weights to finetune "
       "but not both.";

   caffe::SolverParameter solver_param;
   caffe::ReadProtoFromTextFileOrDie(FLAGS_solver, &solver_param);

   // If the gpus flag is not provided, allow the mode and device to be set
   // in the solver prototxt.
   if (FLAGS_gpu.size() ==
       && solver_param.solver_mode() == caffe::SolverParameter_SolverMode_GPU) {
       if (solver_param.has_device_id()) {
           FLAGS_gpu = ""  +
               boost::lexical_cast<string>(solver_param.device_id());
       } else {  // Set default GPU if unspecified
           FLAGS_gpu = "" + boost::lexical_cast<string>();
       }
   }

   vector<int> gpus;
   get_gpus(&gpus);
   if (gpus.size() == ) {
     LOG(INFO) << "Use CPU.";
     Caffe::set_mode(Caffe::CPU);
   } else {
     ostringstream s;
     for (int i = ; i < gpus.size(); ++i) {
       s << (i ? ", " : "") << gpus[i];
     }
     LOG(INFO) << "Using GPUs " << s.str();

     solver_param.set_device_id(gpus[]);
     Caffe::SetDevice(gpus[]);
     Caffe::set_mode(Caffe::GPU);
     Caffe::set_solver_count(gpus.size());
   }

   caffe::SignalHandler signal_handler(
         GetRequestedAction(FLAGS_sigint_effect),
         GetRequestedAction(FLAGS_sighup_effect));

   shared_ptr<caffe::Solver<float> >
     solver(caffe::GetSolver<float>(solver_param));

   solver->SetActionFunction(signal_handler.GetActionFunction());

   if (FLAGS_snapshot.size()) {
     LOG(INFO) << "Resuming from " << FLAGS_snapshot;
     solver->Restore(FLAGS_snapshot.c_str());
   } else if (FLAGS_weights.size()) {
     CopyLayers(solver.get(), FLAGS_weights);
   }

   if (gpus.size() > ) {
     caffe::P2PSync<float> sync(solver, NULL, solver->param());
     sync.run(gpus);
   } else {
     LOG(INFO) << "Starting Optimization";
     solver->Solve();
   }
   LOG(INFO) << "Optimization Done.";
   return ;
 }
 RegisterBrewFunction(train);

 // Test: score a model.
 int test() {
   CHECK_GT(FLAGS_model.size(), ) << "Need a model definition to score.";
   CHECK_GT(FLAGS_weights.size(), ) << "Need model weights to score.";

   // Set device id and mode
   vector<int> gpus;
   get_gpus(&gpus);
   if (gpus.size() != ) {
     LOG(INFO) << "Use GPU with device ID " << gpus[];
     Caffe::SetDevice(gpus[]);
     Caffe::set_mode(Caffe::GPU);
   } else {
     LOG(INFO) << "Use CPU.";
     Caffe::set_mode(Caffe::CPU);
   }

   // Instantiate the caffe net.
   Net<float> caffe_net(FLAGS_model, caffe::TEST);
   caffe_net.CopyTrainedLayersFrom(FLAGS_weights);
   LOG(INFO) << "Running for " << FLAGS_iterations << " iterations.";

   vector<Blob<float>* > bottom_vec;
   vector<int> test_score_output_id;
   vector<float> test_score;
   // float loss = 0;
   int nu = ;
   // int num = 0;
   // int num2 = 0;

   const  int att_num = ;
   static int TP[att_num] = {};
   static int TN[att_num] = {};
   static int FP[att_num] = {};
   static int FN[att_num] = {};

   for (int i = ; i < FLAGS_iterations; ++i) {  // num of images;  test image:7600

     LOG(INFO) << "batch " << i << "/" << FLAGS_iterations << ", waiting...";

     float iter_loss;
     const vector<Blob<float>*>& result =
         caffe_net.Forward(bottom_vec, &iter_loss);  // outPut result 

     LOG(INFO) << "result.size: " << result.size() << " " << result[]->count() << " " << result[]->count()
               << " " << result[]->count() ;

     const float* result_index = result[]->cpu_data(); // index
     const float* result_score = result[]->cpu_data(); // predict score;
     const float* result_label = result[]->cpu_data(); // Groundtruth label;

       for (int k = ; k < att_num; ++k) {  // for 35 attributes 

         // const float index_        = result_index;
         const float Predict_score = result_score[k];
         const float GT_label      = result_label[k];

         float threshold_ = 0.4;
         if ((Predict_score < threshold_) && (int(GT_label) == ))
           TN[k] = TN[k] + ;
         if ((Predict_score > threshold_) && (int(GT_label) == ))
           FP[k] = FP[k] + ;
         if ((Predict_score < threshold_) && (int(GT_label) == ))
           FN[k] = FN[k] + ;
         if ((Predict_score > threshold_) && (int(GT_label) == ))
           TP[k] = TP[k] + ;

       // write the predicted score into txt files
       ofstream file("/home/wangxiao/Downloads/whole_benchmark/Sec_Batch_/sec_Batch_unlabel.txt",ios::app);
       if(!file) return -;

       if(nu < att_num){
         file << Predict_score << " " ;
         nu++;
       } else {
         nu = ;
         file << endl;
         file << Predict_score << " " ;
       }
       file.close();

       // // write the Index into txt files
       // ofstream file2("/home/wangxiao/Downloads/caffe-master/wangxiao/bvlc_alexnet/43_attributes_index.txt",ios::app);
       // if(!file2) return -1;

       // if(num < att_num){
       //   file2 << index_ << " " ;
       //   num++;
       // } else {
       //   num = 1;
       //   file2 << endl;
       //   file2 << index_ << " " ;
       // }
       // file2.close();

       // // write the GroundTruth Label into txt files
       // ofstream file3("/home/wangxiao/Downloads/whole_benchmark/Unlabeled_data/Unlabeled_AnHui_label.txt",ios::app);
       // if(!file3) return -1;

       // if(num2 < att_num){
       //   file3 << GT_label << " " ;
       //   num2++;
       // } else {
       //   num2 = 1;
       //   file3 << endl;
       //   file3 << GT_label << " " ;
       // }
       // file3.close();

       }
     }

     double aver_accuracy = ;

     for (int k = ; k < att_num; ++k){
       aver_accuracy += 0.5*(double(TP[k])/(TP[k]+FN[k]) + double(TN[k])/(TN[k] + FP[k]));
       LOG(INFO) << "Accuracy: " << k << " "
                 << 0.5*(double(TP[k])/(TP[k]+FN[k]) + double(TN[k])/(TN[k] + FP[k]));
       LOG(INFO) << "TP = " << double(TP[k]);
       LOG(INFO) << "FN = " << double(FN[k]);
       LOG(INFO) << "FP = " << double(FP[k]);
       LOG(INFO) << "TN = " << double(TN[k]);
     }

       LOG(INFO) << "####################";
       LOG(INFO) << " ";
       LOG(INFO) << "Average_accuracy: " << aver_accuracy / att_num;
       LOG(INFO) << " ";
       LOG(INFO) << "####################";

       return ;
 }

 RegisterBrewFunction(test);

 // Time: benchmark the execution time of a model.
 int time() {
   CHECK_GT(FLAGS_model.size(), ) << "Need a model definition to time.";

   // Set device id and mode
   vector<int> gpus;
   get_gpus(&gpus);
   if (gpus.size() != ) {
     LOG(INFO) << "Use GPU with device ID " << gpus[];
     Caffe::SetDevice(gpus[]);
     Caffe::set_mode(Caffe::GPU);
   } else {
     LOG(INFO) << "Use CPU.";
     Caffe::set_mode(Caffe::CPU);
   }
   // Instantiate the caffe net.
   Net<float> caffe_net(FLAGS_model, caffe::TRAIN);

   // Do a clean forward and backward pass, so that memory allocation are done
   // and future iterations will be more stable.
   LOG(INFO) << "Performing Forward";
   // Note that for the speed benchmark, we will assume that the network does
   // not take any input blobs.
   float initial_loss;
   caffe_net.Forward(vector<Blob<float>*>(), &initial_loss);
   LOG(INFO) << "Initial loss: " << initial_loss;
   LOG(INFO) << "Performing Backward";
   caffe_net.Backward();

   const vector<shared_ptr<Layer<float> > >& layers = caffe_net.layers();
   const vector<vector<Blob<float>*> >& bottom_vecs = caffe_net.bottom_vecs();
   const vector<vector<Blob<float>*> >& top_vecs = caffe_net.top_vecs();
   const vector<vector<bool> >& bottom_need_backward =
       caffe_net.bottom_need_backward();
   LOG(INFO) << "*** Benchmark begins ***";
   LOG(INFO) << "Testing for " << FLAGS_iterations << " iterations.";
   Timer total_timer;
   total_timer.Start();
   Timer forward_timer;
   Timer backward_timer;
   Timer timer;
   std::vector<double> forward_time_per_layer(layers.size(), 0.0);
   std::vector<double> backward_time_per_layer(layers.size(), 0.0);
   double forward_time = 0.0;
   double backward_time = 0.0;
   for (int j = ; j < FLAGS_iterations; ++j) {
     Timer iter_timer;
     iter_timer.Start();
     forward_timer.Start();
     for (int i = ; i < layers.size(); ++i) {
       timer.Start();
       layers[i]->Forward(bottom_vecs[i], top_vecs[i]);
       forward_time_per_layer[i] += timer.MicroSeconds();
     }
     forward_time += forward_timer.MicroSeconds();
     backward_timer.Start();
     for (int i = layers.size() - ; i >= ; --i) {
       timer.Start();
       layers[i]->Backward(top_vecs[i], bottom_need_backward[i],
                           bottom_vecs[i]);
       backward_time_per_layer[i] += timer.MicroSeconds();
     }
     backward_time += backward_timer.MicroSeconds();
     LOG(INFO) << "Iteration: " << j +  << " forward-backward time: "
       << iter_timer.MilliSeconds() << " ms.";
   }
   LOG(INFO) << "Average time per layer: ";
   for (int i = ; i < layers.size(); ++i) {
     const caffe::string& layername = layers[i]->layer_param().name();
     LOG(INFO) << std::setfill(' ') << std::setw() << layername <<
       "\tforward: " << forward_time_per_layer[i] /  /
       FLAGS_iterations << " ms.";
     LOG(INFO) << std::setfill(' ') << std::setw() << layername  <<
       "\tbackward: " << backward_time_per_layer[i] /  /
       FLAGS_iterations << " ms.";
   }
   total_timer.Stop();
   LOG(INFO) << "Average Forward pass: " << forward_time /  /
     FLAGS_iterations << " ms.";
   LOG(INFO) << "Average Backward pass: " << backward_time /  /
     FLAGS_iterations << " ms.";
   LOG(INFO) << "Average Forward-Backward: " << total_timer.MilliSeconds() /
     FLAGS_iterations << " ms.";
   LOG(INFO) << "Total Time: " << total_timer.MilliSeconds() << " ms.";
   LOG(INFO) << "*** Benchmark ends ***";
   return ;
 }
 RegisterBrewFunction(time);

 int main(int argc, char** argv) {
   // Print output to stderr (while still logging).
   FLAGS_alsologtostderr = ;
   // Usage message.
   gflags::SetUsageMessage("command line brew\n"
       "usage: caffe <command> <args>\n\n"
       "commands:\n"
       "  train           train or finetune a model\n"
       "  test            score a model\n"
       "  device_query    show GPU diagnostic information\n"
       "  time            benchmark model execution time");
   // Run tool or show usage.
   caffe::GlobalInit(&argc, &argv);
   if (argc == ) {
 #ifdef WITH_PYTHON_LAYER
     try {
 #endif
       return GetBrewFunction(caffe::string(argv[]))();
 #ifdef WITH_PYTHON_LAYER
     } catch (bp::error_already_set) {
       PyErr_Print();
       return ;
     }
 #endif
   } else {
     gflags::ShowUsageWithFlagsRestrict(argv[], "tools/caffe");
   }
 }