caffe导读（1） caffe源码修改：抽取任意一张图片的特征

caffe源码修改：抽取任意一张图片的特征

目前caffe不是很完善，输入的图片数据需要在prototxt指定路径。但是我们往往有这么一个需求：训练后得到一个模型文件，我们想拿这个模型文件来对一张图片抽取特征或者预测分类等。如果非得在prototxt指定路径，就很不方便。因此，这样的工具才是我们需要的：给一个可执行文件通过命令行来传递图片路径，然后caffe读入图片数据，进行一次正向传播。

因此我做了这么一个工具，用来抽取任意一张图片的特征。

这工具的使用方法如下：

extract_one_feature.bin ./model/caffe_reference_imagenet_model ./examples/_temp/imagenet_val.prototxt fc7 ./examples/_temp/features /media/G/imageset/clothing/针织衫/针织衫_426.jpg CPU

参数1：./model/caffe_reference_imagenet_model是训练后的模型文件

参数2：./examples/_temp/imagenet_val.prototxt 网络配置文件

参数3：fc7是blob的名字

参数4：./examples/_temp/features 将该图片的特征保存在该文件

参数5：图片路径

参数6：GPU或者CPU模式

（其实我还想到更好的工具，如果该可执行文件是监听模式的，就是通过一定的方式，给该进程传递 图片路径，进程接到任务就执行。

这样子的话，就不需要每次抽一张图片都要申请内存空间。(*^__^*) 嘻嘻……）

下面给出初步修改方法，大家可以根据自己需求再修改。

extract_one_feature.cpp（该文件参考过源码中extract_features.cpp修改）

 #include <stdio.h>  // for snprintf
 #include <string>
 #include <vector>
 #include <iostream>
 #include <fstream>

 #include "boost/algorithm/string.hpp"
 #include "google/protobuf/text_format.h"
 #include "leveldb/db.h"
 #include "leveldb/write_batch.h"

 #include "caffe/blob.hpp"
 #include "caffe/common.hpp"
 #include "caffe/net.hpp"
 #include "caffe/proto/caffe.pb.h"
 #include "caffe/util/io.hpp"
 #include "caffe/vision_layers.hpp"

 using namespace caffe;  // NOLINT(build/namespaces)

 template<typename Dtype>
 int feature_extraction_pipeline(int argc, char** argv);

 int main(int argc, char** argv) {
   return feature_extraction_pipeline<float>(argc, argv);
 //  return feature_extraction_pipeline<double>(argc, argv);
 }

 template<typename Dtype>
 class writeDb
 {
 public:
     void open(string dbName)
     {
         db.open(dbName.c_str());
     }
     void write(const Dtype &data)
     {
         db<<data;
     }
     void write(const string &str)
     {
         db<<str;
     }
     virtual ~writeDb()
     {
         db.close();
     }
 private:
     std::ofstream db;
 };

 template<typename Dtype>
 int feature_extraction_pipeline(int argc, char** argv) {
   ::google::InitGoogleLogging(argv[0]);
   const int num_required_args = 6;
   if (argc < num_required_args) {
     LOG(ERROR)<<
     "This program takes in a trained network and an input data layer, and then"
     " extract features of the input data produced by the net.\n"
     "Usage: extract_features  pretrained_net_param"
     "  feature_extraction_proto_file  extract_feature_blob_name1[,name2,...]"
     "  save_feature_leveldb_name1[,name2,...]  img_path  [CPU/GPU]"
     "  [DEVICE_ID=0]\n"
     "Note: you can extract multiple features in one pass by specifying"
     " multiple feature blob names and leveldb names seperated by ','."
     " The names cannot contain white space characters and the number of blobs"
     " and leveldbs must be equal.";
     return 1;
   }
   int arg_pos = num_required_args;

   arg_pos = num_required_args;
   if (argc > arg_pos && strcmp(argv[arg_pos], "GPU") == 0) {
     LOG(ERROR)<< "Using GPU";
     uint device_id = 0;
     if (argc > arg_pos + 1) {
       device_id = atoi(argv[arg_pos + 1]);
       CHECK_GE(device_id, 0);
     }
     LOG(ERROR) << "Using Device_id=" << device_id;
     Caffe::SetDevice(device_id);
     Caffe::set_mode(Caffe::GPU);
   } else {
     LOG(ERROR) << "Using CPU";
     Caffe::set_mode(Caffe::CPU);
   }
   Caffe::set_phase(Caffe::TEST);

   arg_pos = 0;  // the name of the executable
   string pretrained_binary_proto(argv[++arg_pos]);//网络模型参数文件

   string feature_extraction_proto(argv[++arg_pos]);

   shared_ptr<Net<Dtype> > feature_extraction_net(
       new Net<Dtype>(feature_extraction_proto));

   feature_extraction_net->CopyTrainedLayersFrom(pretrained_binary_proto);//将网络参数load进内存


   string extract_feature_blob_names(argv[++arg_pos]);
   vector<string> blob_names;//要抽取特征的layer的名字，可以是多个
   boost::split(blob_names, extract_feature_blob_names, boost::is_any_of(","));

   string save_feature_leveldb_names(argv[++arg_pos]);
   vector<string> leveldb_names;// 这里我改写成一个levedb为一个文件，数据格式不使用真正的levedb，而是自定义
   boost::split(leveldb_names, save_feature_leveldb_names,
                boost::is_any_of(","));
   CHECK_EQ(blob_names.size(), leveldb_names.size()) <<
       " the number of blob names and leveldb names must be equal";
   size_t num_features = blob_names.size();

   for (size_t i = 0; i < num_features; i++) {
     CHECK(feature_extraction_net->has_blob(blob_names[i]))  //检测blob的名字在网络中是否存在
         << "Unknown feature blob name " << blob_names[i]
         << " in the network " << feature_extraction_proto;
   }


   vector<shared_ptr<writeDb<Dtype> > > feature_dbs;
   for (size_t i = 0; i < num_features; ++i) //打开db，准备写入数据
   {
     LOG(INFO)<< "Opening db " << leveldb_names[i];
     writeDb<Dtype>* db = new writeDb<Dtype>();
     db->open(leveldb_names[i]);
     feature_dbs.push_back(shared_ptr<writeDb<Dtype> >(db));
   }



   LOG(ERROR)<< "Extacting Features";

   const shared_ptr<Layer<Dtype> > layer = feature_extraction_net->layer_by_name("data");//获取第一层
   MyImageDataLayer<Dtype>* my_layer = (MyImageDataLayer<Dtype>*)layer.get();
   my_layer->setImgPath(argv[++arg_pos],1);//"/media/G/imageset/clothing/针织衫/针织衫_1.jpg"
   //设置图片路径

   vector<Blob<float>*> input_vec;
   vector<int> image_indices(num_features, 0);
   int num_mini_batches = 1;//atoi(argv[++arg_pos]);//共多少次迭代。  每次迭代的数量在prototxt用batchsize指定
   for (int batch_index = 0; batch_index < num_mini_batches; ++batch_index) //共num_mini_batches次迭代
   {
     feature_extraction_net->Forward(input_vec);//一次正向传播
     for (int i = 0; i < num_features; ++i) //多层特征
     {
       const shared_ptr<Blob<Dtype> > feature_blob = feature_extraction_net
           ->blob_by_name(blob_names[i]);
       int batch_size = feature_blob->num();
       int dim_features = feature_blob->count() / batch_size;

       Dtype* feature_blob_data;

       for (int n = 0; n < batch_size; ++n)
       {
         feature_blob_data = feature_blob->mutable_cpu_data() +
             feature_blob->offset(n);
         feature_dbs[i]->write("3 ");
         for (int d = 0; d < dim_features; ++d)
         {
           feature_dbs[i]->write((Dtype)(d+1));
           feature_dbs[i]->write(":");
           feature_dbs[i]->write(feature_blob_data[d]);
           feature_dbs[i]->write(" ");
         }
         feature_dbs[i]->write("\n");

       }  // for (int n = 0; n < batch_size; ++n)
     }  // for (int i = 0; i < num_features; ++i)
   }  // for (int batch_index = 0; batch_index < num_mini_batches; ++batch_index)


   LOG(ERROR)<< "Successfully extracted the features!";
   return 0;
 }

my_data_layer.cpp（参考image_data_layer修改）

 #include <fstream>  // NOLINT(readability/streams)
 #include <iostream>  // NOLINT(readability/streams)
 #include <string>
 #include <utility>
 #include <vector>

 #include "caffe/layer.hpp"
 #include "caffe/util/io.hpp"
 #include "caffe/util/math_functions.hpp"
 #include "caffe/util/rng.hpp"
 #include "caffe/vision_layers.hpp"

 namespace caffe {


 template <typename Dtype>
 MyImageDataLayer<Dtype>::~MyImageDataLayer<Dtype>() {
 }


 template <typename Dtype>
 void MyImageDataLayer<Dtype>::setImgPath(string path,int label)
 {
     lines_.clear();
     lines_.push_back(std::make_pair(path, label));
 }


 template <typename Dtype>
 void MyImageDataLayer<Dtype>::SetUp(const vector<Blob<Dtype>*>& bottom,
       vector<Blob<Dtype>*>* top) {
   Layer<Dtype>::SetUp(bottom, top);
   const int new_height  = this->layer_param_.image_data_param().new_height();
   const int new_width  = this->layer_param_.image_data_param().new_width();
   CHECK((new_height == 0 && new_width == 0) ||
       (new_height > 0 && new_width > 0)) << "Current implementation requires "
       "new_height and new_width to be set at the same time.";

   /*
    * 因为下面需要随便拿一张图片来初始化blob。
    * 因此需要硬盘上有一张图片。
    * 1 从prototxt读取一张图片的路径，
    * 2 其实也可以在这里将用于初始化的图片路径写死
   */

   /*1*/
   /*
   const string& source = this->layer_param_.image_data_param().source();
   LOG(INFO) << "Opening file " << source;
   std::ifstream infile(source.c_str());
   string filename;
   int label;
   while (infile >> filename >> label) {
     lines_.push_back(std::make_pair(filename, label));
   }
   */

   /*2*/
   lines_.push_back(std::make_pair("/home/linger/init.jpg",1));

   //上面1和2代码可以任意用一段

   lines_id_ = 0;
   // Read a data point, and use it to initialize the top blob. (随便)读取一张图片，来初始化blob
   Datum datum;
   CHECK(ReadImageToDatum(lines_[lines_id_].first, lines_[lines_id_].second,
                          new_height, new_width, &datum));
   // image
   const int crop_size = this->layer_param_.image_data_param().crop_size();
   const int batch_size = 1;//this->layer_param_.image_data_param().batch_size();
   const string& mean_file = this->layer_param_.image_data_param().mean_file();
   if (crop_size > 0) {
     (*top)[0]->Reshape(batch_size, datum.channels(), crop_size, crop_size);
     prefetch_data_.Reshape(batch_size, datum.channels(), crop_size, crop_size);
   } else {
     (*top)[0]->Reshape(batch_size, datum.channels(), datum.height(),
                        datum.width());
     prefetch_data_.Reshape(batch_size, datum.channels(), datum.height(),
         datum.width());
   }
   LOG(INFO) << "output data size: " << (*top)[0]->num() << ","
       << (*top)[0]->channels() << "," << (*top)[0]->height() << ","
       << (*top)[0]->width();
   // label
   (*top)[1]->Reshape(batch_size, 1, 1, 1);
   prefetch_label_.Reshape(batch_size, 1, 1, 1);
   // datum size
   datum_channels_ = datum.channels();
   datum_height_ = datum.height();
   datum_width_ = datum.width();
   datum_size_ = datum.channels() * datum.height() * datum.width();
   CHECK_GT(datum_height_, crop_size);
   CHECK_GT(datum_width_, crop_size);
   // check if we want to have mean
   if (this->layer_param_.image_data_param().has_mean_file()) {
     BlobProto blob_proto;
     LOG(INFO) << "Loading mean file from" << mean_file;
     ReadProtoFromBinaryFile(mean_file.c_str(), &blob_proto);
     data_mean_.FromProto(blob_proto);
     CHECK_EQ(data_mean_.num(), 1);
     CHECK_EQ(data_mean_.channels(), datum_channels_);
     CHECK_EQ(data_mean_.height(), datum_height_);
     CHECK_EQ(data_mean_.width(), datum_width_);
   } else {
     // Simply initialize an all-empty mean.
     data_mean_.Reshape(1, datum_channels_, datum_height_, datum_width_);
   }
   // Now, start the prefetch thread. Before calling prefetch, we make two
   // cpu_data calls so that the prefetch thread does not accidentally make
   // simultaneous cudaMalloc calls when the main thread is running. In some
   // GPUs this seems to cause failures if we do not so.
   prefetch_data_.mutable_cpu_data();
   prefetch_label_.mutable_cpu_data();
   data_mean_.cpu_data();


 }

 //--------------------------------下面是读取一张图片数据-----------------------------------------------
 template <typename Dtype>
 void MyImageDataLayer<Dtype>::fetchData() {
       Datum datum;
       CHECK(prefetch_data_.count());
       Dtype* top_data = prefetch_data_.mutable_cpu_data();
       Dtype* top_label = prefetch_label_.mutable_cpu_data();
       ImageDataParameter image_data_param = this->layer_param_.image_data_param();
       const Dtype scale = image_data_param.scale();//image_data_layer相关参数
       const int batch_size = 1;//image_data_param.batch_size(); 这里我们只需要一张图片

       const int crop_size = image_data_param.crop_size();
       const bool mirror = image_data_param.mirror();
       const int new_height = image_data_param.new_height();
       const int new_width = image_data_param.new_width();

       if (mirror && crop_size == 0) {
         LOG(FATAL) << "Current implementation requires mirror and crop_size to be "
             << "set at the same time.";
       }
       // datum scales
       const int channels = datum_channels_;
       const int height = datum_height_;
       const int width = datum_width_;
       const int size = datum_size_;
       const int lines_size = lines_.size();
       const Dtype* mean = data_mean_.cpu_data();

       for (int item_id = 0; item_id < batch_size; ++item_id) {//读取一图片
         // get a blob
         CHECK_GT(lines_size, lines_id_);
         if (!ReadImageToDatum(lines_[lines_id_].first,
               lines_[lines_id_].second,
               new_height, new_width, &datum)) {
           continue;
         }
         const string& data = datum.data();
         if (crop_size) {
           CHECK(data.size()) << "Image cropping only support uint8 data";
           int h_off, w_off;
           // We only do random crop when we do training.
             h_off = (height - crop_size) / 2;
             w_off = (width - crop_size) / 2;

             // Normal copy 正常读取，把裁剪后的图片数据读给top_data
             for (int c = 0; c < channels; ++c) {
               for (int h = 0; h < crop_size; ++h) {
                 for (int w = 0; w < crop_size; ++w) {
                   int top_index = ((item_id * channels + c) * crop_size + h)
                                   * crop_size + w;
                   int data_index = (c * height + h + h_off) * width + w + w_off;
                   Dtype datum_element =
                       static_cast<Dtype>(static_cast<uint8_t>(data[data_index]));
                   top_data[top_index] = (datum_element - mean[data_index]) * scale;
                 }
               }
             }

         } else {
           // Just copy the whole data 正常读取，把图片数据读给top_data
           if (data.size()) {
             for (int j = 0; j < size; ++j) {
               Dtype datum_element =
                   static_cast<Dtype>(static_cast<uint8_t>(data[j]));
               top_data[item_id * size + j] = (datum_element - mean[j]) * scale;
             }
           } else {
             for (int j = 0; j < size; ++j) {
               top_data[item_id * size + j] =
                   (datum.float_data(j) - mean[j]) * scale;
             }
           }
         }
         top_label[item_id] = datum.label();//读取该图片的标签

       }
 }

 template <typename Dtype>
 Dtype MyImageDataLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
       vector<Blob<Dtype>*>* top) {

   //更新input
     fetchData();

   // Copy the data
   caffe_copy(prefetch_data_.count(), prefetch_data_.cpu_data(),
              (*top)[0]->mutable_cpu_data());
   caffe_copy(prefetch_label_.count(), prefetch_label_.cpu_data(),
              (*top)[1]->mutable_cpu_data());

   return Dtype(0.);
 }

 #ifdef CPU_ONLY
 STUB_GPU_FORWARD(ImageDataLayer, Forward);
 #endif

 INSTANTIATE_CLASS(MyImageDataLayer);

 }  // namespace caffe

在data_layers.hpp添加一下代码，参考ImageDataLayer写的。

 template <typename Dtype>
 class MyImageDataLayer : public Layer<Dtype>  {
  public:
   explicit MyImageDataLayer(const LayerParameter& param)
       : Layer<Dtype>(param) {}
   virtual ~MyImageDataLayer();
   virtual void SetUp(const vector<Blob<Dtype>*>& bottom,
       vector<Blob<Dtype>*>* top);

   virtual inline LayerParameter_LayerType type() const {
     return LayerParameter_LayerType_MY_IMAGE_DATA;
   }
   virtual inline int ExactNumBottomBlobs() const { return 0; }
   virtual inline int ExactNumTopBlobs() const { return 2; }
   void fetchData();
   void setImgPath(string path,int label);
  protected:
   virtual Dtype Forward_cpu(const vector<Blob<Dtype>*>& bottom,
       vector<Blob<Dtype>*>* top);

   virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
       const vector<bool>& propagate_down, vector<Blob<Dtype>*>* bottom) {}


   vector<std::pair<std::string, int> > lines_;
   int lines_id_;
   int datum_channels_;
   int datum_height_;
   int datum_width_;
   int datum_size_;
   Blob<Dtype> prefetch_data_;
   Blob<Dtype> prefetch_label_;
   Blob<Dtype> data_mean_;
   Caffe::Phase phase_;
 };

修改caffe.proto,在适当的位置添加下面信息，也是参考image_data写的。

MY_IMAGE_DATA = 36;

optional MyImageDataParameter my_image_data_param = 36;

// Message that stores parameters used by MyImageDataLayer
message MyImageDataParameter {
  // Specify the data source.
  optional string source = 1;
  // For data pre-processing, we can do simple scaling and subtracting the
  // data mean, if provided. Note that the mean subtraction is always carried
  // out before scaling.
  optional float scale = 2 [default = 1];
  optional string mean_file = 3;
  // Specify the batch size.
  optional uint32 batch_size = 4;
  // Specify if we would like to randomly crop an image.
  optional uint32 crop_size = 5 [default = 0];
  // Specify if we want to randomly mirror data.
  optional bool mirror = 6 [default = false];
  // The rand_skip variable is for the data layer to skip a few data points
  // to avoid all asynchronous sgd clients to start at the same point. The skip
  // point would be set as rand_skip * rand(0,1). Note that rand_skip should not
  // be larger than the number of keys in the leveldb.
  optional uint32 rand_skip = 7 [default = 0];
  // Whether or not ImageLayer should shuffle the list of files at every epoch.
  optional bool shuffle = 8 [default = false];
  // It will also resize images if new_height or new_width are not zero.
  optional uint32 new_height = 9 [default = 0];
  optional uint32 new_width = 10 [default = 0];
}

以上每行位置不在一起，可以参考读一个image_data对应的位置。

本文作者：linger

本文链接：http://blog.csdn.net/lingerlanlan/article/details/39400375