【caffe I/O】数据读取层 代码中文注释

caffe.proto中DataParameter部分

message DataParameter {
  //输入数据使用的DB类型
  enum DB {
    LEVELDB = ;//使用LEVELDB
    LMDB = ;   //使用LMDB
  }
  // Specify the data source.源数据的路径
  optional string source = ;
  // Specify the batch size.一个批量数据包含的图片数目
  optional uint32 batch_size = ;
  // 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 database.
  // DEPRECATED. Each solver accesses a different subset of the database.
  // 随机跳过若干图片。防止SGD从同一起点开始。已弃用。
  optional uint32 rand_skip =  [default = ];
  optional DB backend =  [default = LEVELDB];//默认输入数据使用DB类型。默认LEVELDB
  // DEPRECATED. See TransformationParameter. 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.
  // 弃用。使用TransformationParameter
  optional float scale =  [default = ];
  optional string mean_file = ;
  // DEPRECATED. See TransformationParameter. Specify if we would like to randomly
  // crop an image.
  optional uint32 crop_size =  [default = ];
  // DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror
  // data.
  optional bool mirror =  [default = false];
  // Force the encoded image to have 3 color channels 强制编码图像为三通道彩色图像
  optional bool force_encoded_color =  [default = false];
  // Prefetch queue (Increase if data feeding bandwidth varies, within the
  // limit of device memory for GPU training)
  // 预取队列 （在硬件设备允许的情况下，预先放到主机内存中的批量数，默认为4个batch）
  optional uint32 prefetch =  [default = ];
}

include/caffe/layers/base_data_layer.hpp

 #ifndef CAFFE_DATA_LAYERS_HPP_
 #define CAFFE_DATA_LAYERS_HPP_

 #include <vector>

 #include "caffe/blob.hpp"
 #include "caffe/data_transformer.hpp"
 #include "caffe/internal_thread.hpp"
 #include "caffe/layer.hpp"
 #include "caffe/proto/caffe.pb.h"
 #include "caffe/util/blocking_queue.hpp"

 namespace caffe {

 /**
  * @brief Provides base for data layers that feed blobs to the Net.
  *
  * TODO(dox): thorough documentation for Forward and proto params.
  */
 //基本数据层，派生于Layer
 template <typename Dtype>
 class BaseDataLayer : public Layer<Dtype> {
  public:
   explicit BaseDataLayer(const LayerParameter& param);
   // LayerSetUp: implements common data layer setup functionality, and calls
   // DataLayerSetUp to do special data layer setup for individual layer types.
   // This method may not be overridden except by the BasePrefetchingDataLayer.
   //通用层配置功能。之后调用DataLayerSetUp进行数据读取层的特殊配置
   virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
       const vector<Blob<Dtype>*>& top);
   virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,
       const vector<Blob<Dtype>*>& top) {}
   // Data layers have no bottoms, so reshaping is trivial.
   //数据读取层没有输入Bottom Blob，变形操作不是很重要
   virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
       const vector<Blob<Dtype>*>& top) {}
   //反向传播函数不需要做任何事情
   virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
       const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {}
   virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
       const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {}

  protected:
   TransformationParameter transform_param_;//数据预处理变换器参数
   shared_ptr<DataTransformer<Dtype> > data_transformer_;//数据预处理变换器
   bool output_labels_;//是否输出标签数据
 };

 //批量数据，用于存放数据读取层输出
 template <typename Dtype>
 class Batch {
  public:
   Blob<Dtype> data_, label_;//两个Blob分别用来存储图片数据和标签
 };

 //带预取功能的数据读取层，派生于BaseDataLayer和InternalThread
 template <typename Dtype>
 class BasePrefetchingDataLayer :
     public BaseDataLayer<Dtype>, public InternalThread {
  public:
   explicit BasePrefetchingDataLayer(const LayerParameter& param);
   // LayerSetUp: implements common data layer setup functionality, and calls
   // DataLayerSetUp to do special data layer setup for individual layer types.
   // This method may not be overridden.层设置
   void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
       const vector<Blob<Dtype>*>& top);

   virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
       const vector<Blob<Dtype>*>& top);//前向
   virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
       const vector<Blob<Dtype>*>& top);

  protected:
   virtual void InternalThreadEntry();//内部线程入口
   virtual void load_batch(Batch<Dtype>* batch) = ;//载入批量数据，纯虚函数

   vector<shared_ptr<Batch<Dtype> > > prefetch_;//抓取
   BlockingQueue<Batch<Dtype>*> prefetch_free_;//空闲Batch队列
   BlockingQueue<Batch<Dtype>*> prefetch_full_;//已加载Batch队列
   Batch<Dtype>* prefetch_current_;

   Blob<Dtype> transformed_data_;//变换后的数据
 };

 }  // namespace caffe

 #endif  // CAFFE_DATA_LAYERS_HPP_

src/caffe/layers/base_data_layer.cpp

 #include <boost/thread.hpp>
 #include <vector>

 #include "caffe/blob.hpp"
 #include "caffe/data_transformer.hpp"
 #include "caffe/internal_thread.hpp"
 #include "caffe/layer.hpp"
 #include "caffe/layers/base_data_layer.hpp"
 #include "caffe/proto/caffe.pb.h"
 #include "caffe/util/blocking_queue.hpp"

 namespace caffe {

 //构造函数。初始化Layer参数、数据变换器参数
 template <typename Dtype>
 BaseDataLayer<Dtype>::BaseDataLayer(const LayerParameter& param)
     : Layer<Dtype>(param),
       transform_param_(param.transform_param()) {
 }

 //BaseDataLayer层设置
 template <typename Dtype>
 void BaseDataLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
       const vector<Blob<Dtype>*>& top) {
   if (top.size() == ) {//判断输出Blob数目。1则只输出data，2则输出data和label
     output_labels_ = false;
   } else {
     output_labels_ = true;
   }
   //初始化数据变换器对象
   data_transformer_.reset(
       new DataTransformer<Dtype>(transform_param_, this->phase_));
   data_transformer_->InitRand();
   // The subclasses should setup the size of bottom and top
   DataLayerSetUp(bottom, top);//子类负责设置Top Blob形状
 }

 //BasePrefetchingDataLayer构造函数
 template <typename Dtype>
 BasePrefetchingDataLayer<Dtype>::BasePrefetchingDataLayer(
     const LayerParameter& param)
     : BaseDataLayer<Dtype>(param),
       prefetch_(param.data_param().prefetch()),
       prefetch_free_(), prefetch_full_(), prefetch_current_() {
   for (int i = ; i < prefetch_.size(); ++i) {
     prefetch_[i].reset(new Batch<Dtype>());
     prefetch_free_.push(prefetch_[i].get());//将batch对象都放入空闲队列
   }
 }

 //BasePrefetchingDataLayer层配置函数
 template <typename Dtype>
 void BasePrefetchingDataLayer<Dtype>::LayerSetUp(
     const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
   BaseDataLayer<Dtype>::LayerSetUp(bottom, top);

   // Before starting the prefetch thread, we make cpu_data and gpu_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.
   //在开启数据预取线程前，通过调用Blob相应函数先进行cudaMalloc，
   //避免多线程情况下同时进行cudaMalloc，会导致cuda API调用失败
   for (int i = ; i < prefetch_.size(); ++i) {
     prefetch_[i]->data_.mutable_cpu_data();
     if (this->output_labels_) {
       prefetch_[i]->label_.mutable_cpu_data();
     }
   }
   //GPU
 #ifndef CPU_ONLY
   if (Caffe::mode() == Caffe::GPU) {
     for (int i = ; i < prefetch_.size(); ++i) {
       prefetch_[i]->data_.mutable_gpu_data();
       if (this->output_labels_) {
         prefetch_[i]->label_.mutable_gpu_data();
       }
     }
   }
 #endif
   DLOG(INFO) << "Initializing prefetch";
   this->data_transformer_->InitRand();
   StartInternalThread();//开启内部预取线程
   DLOG(INFO) << "Prefetch initialized.";
 }

 //内部线程入口
 template <typename Dtype>
 void BasePrefetchingDataLayer<Dtype>::InternalThreadEntry() {
 //创建CUDA Stream，非阻塞类型
 #ifndef CPU_ONLY
   cudaStream_t stream;
   if (Caffe::mode() == Caffe::GPU) {
     CUDA_CHECK(cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking));
   }
 #endif

   try {
     while (!must_stop()) {//循环载入批量数据
       Batch<Dtype>* batch = prefetch_free_.pop();//得到一个空闲batch
       load_batch(batch);//载入批量数据
 #ifndef CPU_ONLY
       if (Caffe::mode() == Caffe::GPU) {
         batch->data_.data().get()->async_gpu_push(stream);
         if (this->output_labels_) {
           batch->label_.data().get()->async_gpu_push(stream);
         }
         CUDA_CHECK(cudaStreamSynchronize(stream));//同步到GPU
       }
 #endif
       prefetch_full_.push(batch);//加入到带负载的Batch队列中
     }
   } catch (boost::thread_interrupted&) {//捕获到异常则退出循环
     // Interrupted exception is expected on shutdown
   }
 #ifndef CPU_ONLY
   if (Caffe::mode() == Caffe::GPU) {
     CUDA_CHECK(cudaStreamDestroy(stream));//销毁CUDA Stream
   }
 #endif
 }

 //前向传播函数
 template <typename Dtype>
 void BasePrefetchingDataLayer<Dtype>::Forward_cpu(
     const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
   if (prefetch_current_) {
     prefetch_free_.push(prefetch_current_);
   }
   //从带负载的Batch中取出一个Batch对象
   prefetch_current_ = prefetch_full_.pop("Waiting for data");
   // Reshape to loaded data.输出Top Blob根据Batch形状进行变形
   top[]->ReshapeLike(prefetch_current_->data_);
   top[]->set_cpu_data(prefetch_current_->data_.mutable_cpu_data());
   if (this->output_labels_) {//如果需要输出便签数据
     // Reshape to loaded labels.
     top[]->ReshapeLike(prefetch_current_->label_);//Top Blob根据Batch中lable_形状进行变形
     top[]->set_cpu_data(prefetch_current_->label_.mutable_cpu_data());
   }
 }

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

 INSTANTIATE_CLASS(BaseDataLayer);
 INSTANTIATE_CLASS(BasePrefetchingDataLayer);

 }  // namespace caffe

摘抄参看赵永科《21天实战caffe》