Caffe学习--Blob分析

Caffe_blob

1.基本数据结构

Blob为模板类，可以理解为四维数组，n * c * h * w的结构,Layer内为blob输入data和diff，Layer间的blob为学习的参数.内部封装了SyncedMemory类,该类负责存储分配和主机与设备的同步

protected:
    shared_ptr<SyncedMemory> data_; // data指针
    shared_ptr<SyncedMemory> diff_; // diff指针
    vector<int> shape_; // blob形状
    int count_; // blob的nchw
    // 当前的Blob容量，当Blob reshape后count> capacity_时，capacity_ = count_;
    // 重新new 然后 reset data和 diff
    int capacity_;

2.常用函数

Blob类中常用的函数如下所示

    Blob<float>test;
    //explicit关键字的作用是禁止单参数构造函数的隐式转换
    explicit Blob(const int num, const int channels, const int height,
      const int width);
    test.shape_string();//初始为空 0 0 0 0
    //Reshape函数将num,channels,height,width传递给vector shape_
    test.Reshape(1,2,3,4);// shape_string() 1,2,3,4

    test.shape(i);// NCHW
    test.count(int start_axis,int end_axis); // start_axis---end_axis .x* shape[i]
    test.count();// nchw  count(1) chw count(2) hw.....
    //shared_ptr<SyncedMemory> data_->cpu_data();
    const float* data = test.cpu_data();
    const float* diff = test.cpu_diff();
    float* data_1 = test.mutable_cpu_data();//mutable修饰的表示可以修改内部值
    float* diff_1 = test.mutable_cpu_diff();
    test.asum_data();//求和 L1范数
    test.sumsq_data();//平方和 L2范数
    test.Update();//data = data-diff;
    a.ToProto(BlobProto& bp,true/false);//(FromProto)
    // if < 0 ,return num_axis()+axis_index;//索引序列
    int index = a.CanonicalAxisIndex(int axis_index);
    int offset(n,c,h,w);//((n*channels()+c)*height()+h)*width()+w
    float data_at(n,c,h,w);//return cpu_data()[offset(n,c,h,w)];
    float diff_at(n,c,h,w);//return cpu_diff()[offset(n,c,h,w)];
    inline const shared_ptr<SyncedMemory>& data() const{return _data};
    void scale_data(Dtype scale_factor);// data乘以一个标量。同理 scale_diff();
    void CopyFrom(const Blob<Dtype>& source, bool copy_diff = false,
      bool reshape = false);  // copy_diff是否复制diff

3.写入磁盘操作

  //Blob内部值写入到磁盘
  Blob<float>a;
  a.Reshape(1,2,3,4);
  const int count = a.count();
  for (size_t i = 0; i < count; i++) {
      a[i] = i;//init the test Blob
  }
  BlobProto bp,bp2;
  a.ToProto(&bp,true);//写入data和diff到bp中
  WriteProtoToBinaryFile(bp,"a.blob");//写入磁盘
  ReadProtoFromBinaryFile("a.blob",&bp2);//从磁盘读取blob
  Blob<float>b;
  b.FromProto(bp2,true);//序列化对象bp2中克隆b，完整克隆
  for (size_t n = 0; n < b.num(); n++) {
      for (size_t c = 0; c < b.channels(); c++) {
         for (size_t h = 0; h < b.height(); h++) {
             for (size_t w = 0; w < b.width(); w++) {
                 cout<<"b["<<n<<"]["<<c<<"]["<<h<<"]["<<w<<"]["<<w<<"]="<<
                 b[(((n*b.channels()+c)*b.height)+h)*b.width()+w]<<endl;
                 //(((n*c+ci)*h+hi)*w+wi)
             }
         }
      }
  }

4.部分函数的具体实现

本部分的实现未考虑参数是否合理。一般操作blob需要分CPU和GPU,采用math_functions具体计算

  template <typename Dtype>
  void Blob<Dtype>::Reshape(const vector<int>& shape){//reshape操作
    count_ = 1;//初始count_ NCHW;
    shape_.resize(shape.size());
    for (size_t i = 0; i < shape.size(); i++) {
      count_ *= shape[i];
      shape_[i] = shape[i];
      if (count_ > capacity_) { //reshape的size大于了目前的最大容量
         capacity_ = count_;
         data_.reset(new SyncedMemory(capacity_*sizeof(Dtype)));
         diff_.reset(new SyncedMemory(capacity_*sizeof(Dtype)));
      }
    }
  }

 template <typename Dtype>
 void Blob<Dtype>::Reshape(int n,int c,int h ,int w){//reshape操作
   vector<int>shape(4);
   shape[0] = n;
   shape[1] = c;
   shape[2] = h;
   shape[3] = w;
   Reshape(shape);
 }

 template <typename Dtype>
 const Dtype* Blob<Dtype>::cpu_data(){
   //实际调用的shared_ptr<SyncedMemory>data_->cpu_data();,同理cpu_diff();
   CHECK(data_);
   return (const Dtype*)data_->cpu_data();
 }

template <typename Dtype>
void Blob<Dtype>::Updata(){ //data = data-diff;需要判断cpu OR gpu
  switch (data_->head()) {
    case SyncedMemory::HEAD_AT_CPU:
      caffe_axpy<Dtype>(count_,Dtype(-1),
      static_cast<const<Dtype*>(diff_->cpu_data()),
      static_cast<Dtype*>(data_->mutable_cpu_data()));
  }
    case SyncedMemory::HEAD_AT_GPU://在gpu或者CPU/GPU已经同步
    case SyncedMemory::SYNCED:
    #ifndef CPU_ONLY
      caffe_gpu_axpy<Dtype>(count_.Dtype(-1),
      static_cast<const<Dtype*>(diff_->gpu_data()),
      static_cast<Dtype*>(data_->mutable_gpu_data()))
}

template <typename Dtype> //从source 拷贝数据,copy_diff控制是拷贝diff还是data
void Blob<Dtype>::CopyFrom(const Blob& source, bool copy_diff, bool reshape) {
  if (source.count() != count_ || source.shape() != shape_) {
    if (reshape) {
      ReshapeLike(source);
    }
  }
  switch (Caffe::mode()) {
  case Caffe::GPU:
    if (copy_diff) {  //copy diff
      caffe_copy(count_, source.gpu_diff(),
          static_cast<Dtype*>(diff_->mutable_gpu_data()));
    } else {
      caffe_copy(count_, source.gpu_data(),
          static_cast<Dtype*>(data_->mutable_gpu_data()));
    }
    break;
  case Caffe::CPU:
    if (copy_diff) {
      caffe_copy(count_, source.cpu_diff(),
          static_cast<Dtype*>(diff_->mutable_cpu_data()));
    } else {
      caffe_copy(count_, source.cpu_data(),
          static_cast<Dtype*>(data_->mutable_cpu_data()));
    }
    break;
  default:
    LOG(FATAL) << "Unknown caffe mode.";
  }
}

template <typename Dtype>
void Blob<Dtype>::ToProto(BlobProto* proto,bool write_diff){
    proto->clear_shape();
    for (size_t i = 0; i < shaoe_.size(); i++) {
        proto->mutable_shape()->add_dim(shape_[i]);
    }
    proto->clear_data();
    proto->clear_diff();
    const Dtype* data_vec = cpu_data();
    for (size_t i = 0; i < count_; i++) {
        proto->add_data(data_vec[i]);//data写入proto
    }
    if (write_diff) {
        const Dtype* diff_vec = cpu_diff();
        for (size_t i = 0; i < count_; i++) {
            proto->add_diff(diff_vec[i]);//diff写入proto
        }
    }
}

5.说明

    /*Blob作为一个最基础的类，其中构造函数开辟一个内存空间来存储数据，Reshape
    函数在Layer中的reshape或者forward操作中来调整top的输出维度。同时在改变Blob
    大小时， 内存将会被重新分配如果内存大小不够了，并且额外的内存将不会被释放。
    对input的blob进行reshape, 若立马调用Net::Backward是会出错的，因为reshape
    之后，要么Net::forward或者Net::Reshape就会被调用来将新的input shape传播
    到高层 */