Caffe源码（六）: pooling_layer 分析

最新推荐文章于 2023-12-12 18:45:58 发布
最新推荐文章于 2023-12-12 18:45:58 发布
阅读量7.4k 收藏 3
点赞数 1
分类专栏： caffe源码解析 文章标签： 源码 pooling caffe
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/seven_first/article/details/47702403
版权

目录

简单介绍

pooling_layer 是Layer 的子类，实现了pooling操作。其主要函数有LayerSetUp，Reshape，Forward_cpu， Backward_cpu。

主要函数

1.LayerSetUp 函数：

template <typename Dtype>
void PoolingLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  PoolingParameter pool_param = this->layer_param_.pooling_param();
  if (pool_param.global_pooling()) {
    CHECK(!(pool_param.has_kernel_size() ||
      pool_param.has_kernel_h() || pool_param.has_kernel_w()))
      << "With Global_pooling: true Filter size cannot specified";
  } else {
    CHECK(!pool_param.has_kernel_size() !=
      !(pool_param.has_kernel_h() && pool_param.has_kernel_w()))
      << "Filter size is kernel_size OR kernel_h and kernel_w; not both";
    CHECK(pool_param.has_kernel_size() ||
      (pool_param.has_kernel_h() && pool_param.has_kernel_w()))
      << "For non-square filters both kernel_h and kernel_w are required.";
  }
  CHECK((!pool_param.has_pad() && pool_param.has_pad_h()
      && pool_param.has_pad_w())
      || (!pool_param.has_pad_h() && !pool_param.has_pad_w()))
      << "pad is pad OR pad_h and pad_w are required.";
  CHECK((!pool_param.has_stride() && pool_param.has_stride_h()
      && pool_param.has_stride_w())
      || (!pool_param.has_stride_h() && !pool_param.has_stride_w()))
      << "Stride is stride OR stride_h and stride_w are required.";
  global_pooling_ = pool_param.global_pooling();
  if (global_pooling_) {
    kernel_h_ = bottom[0]->height();
    kernel_w_ = bottom[0]->width(); //全局pooling
  } else {
    if (pool_param.has_kernel_size()) {
      kernel_h_ = kernel_w_ = pool_param.kernel_size();
    } else {
      kernel_h_ = pool_param.kernel_h();
      kernel_w_ = pool_param.kernel_w();
    }//用户自定义的kernel大小
  }
  CHECK_GT(kernel_h_, 0) << "Filter dimensions cannot be zero.";
  CHECK_GT(kernel_w_, 0) << "Filter dimensions cannot be zero.";
  if (!pool_param.has_pad_h()) {
    pad_h_ = pad_w_ = pool_param.pad();
  } else {
    pad_h_ = pool_param.pad_h();
    pad_w_ = pool_param.pad_w();
  }//填充
  if (!pool_param.has_stride_h()) {
    stride_h_ = stride_w_ = pool_param.stride();
  } else {
    stride_h_ = pool_param.stride_h();
    stride_w_ = pool_param.stride_w();
  }//步长
  if (global_pooling_) {
    CHECK(pad_h_ == 0 && pad_w_ == 0 && stride_h_ == 1 && stride_w_ == 1)
      << "With Global_pooling: true; only pad = 0 and stride = 1";
  }
  if (pad_h_ != 0 || pad_w_ != 0) {
    CHECK(this->layer_param_.pooling_param().pool()
        == PoolingParameter_PoolMethod_AVE
        || this->layer_param_.pooling_param().pool()
        == PoolingParameter_PoolMethod_MAX)
        << "Padding implemented only for average and max pooling.";
    CHECK_LT(pad_h_, kernel_h_);
    CHECK_LT(pad_w_, kernel_w_);
  }
}//初始化一些参数

2.Reshape 函数：

template <typename Dtype>
void PoolingLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  CHECK_EQ(4, bottom[0]->num_axes()) << "Input must have 4 axes, "
      << "corresponding to (num, channels, height, width)";
  channels_ = bottom[0]->channels();
  height_ = bottom[0]->height();
  width_ = bottom[0]->width();
  if (global_pooling_) {
    kernel_h_ = bottom[0]->height();
    kernel_w_ = bottom[0]->width();
  }
  pooled_height_ = static_cast<int>(ceil(static_cast<float>(
      height_ + 2 * pad_h_ - kernel_h_) / stride_h_)) + 1;
  pooled_width_ = static_cast<int>(ceil(static_cast<float>(
      width_ + 2 * pad_w_ - kernel_w_) / stride_w_)) + 1;
      //pooling之后的height 和 width
  if (pad_h_ || pad_w_) {
    // If we have padding, ensure that the last pooling starts strictly
    // inside the image (instead of at the padding); otherwise clip the last.
    if ((pooled_height_ - 1) * stride_h_ >= height_ + pad_h_) {
      --pooled_height_;
    }
    if ((pooled_width_ - 1) * stride_w_ >= width_ + pad_w_) {
      --pooled_width_;
    }
    CHECK_LT((pooled_height_ - 1) * stride_h_, height_ + pad_h_);
    CHECK_LT((pooled_width_ - 1) * stride_w_, width_ + pad_w_);
  }
  top[0]->Reshape(bottom[0]->num(), channels_, pooled_height_,
      pooled_width_);//输出top blob 的shape
  if (top.size() > 1) {
    top[1]->ReshapeLike(*top[0]);
  }
  // If max pooling, we will initialize the vector index part.
  if (this->layer_param_.pooling_param().pool() ==
      PoolingParameter_PoolMethod_MAX && top.size() == 1) {
    max_idx_.Reshape(bottom[0]->num(), channels_, pooled_height_,
        pooled_width_);
  }//max pooling 反向求导时要用到取最大值的位置，max_idx_就是记录pooling过程中取max value 的index ，它是一个int型的blob 和输出top具有相同的shape
  // If stochastic pooling, we will initialize the random index part.
  if (this->layer_param_.pooling_param().pool() ==
      PoolingParameter_PoolMethod_STOCHASTIC) {
    rand_idx_.Reshape(bottom[0]->num(), channels_, pooled_height_,
      pooled_width_);
  }//类似于max pooling
}

3.Forward_cpu 函数：

template <typename Dtype>
void PoolingLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  const Dtype* bottom_data = bottom[0]->cpu_data();
  Dtype* top_data = top[0]->mutable_cpu_data();
  const int top_count = top[0]->count();
  // We'll output the mask to top[1] if it's of size >1.
  const bool use_top_mask = top.size() > 1;
  int* mask = NULL;  // suppress warnings about uninitalized variables
  Dtype* top_mask = NULL;
  // Different pooling methods. We explicitly do the switch outside the for
  // loop to save time, although this results in more code.
  switch (this->layer_param_.pooling_param().pool()) {
  case PoolingParameter_PoolMethod_MAX:                        
   // max pooling
    // Initialize
    if (use_top_mask) {
      top_mask = top[1]->mutable_cpu_data();
      caffe_set(top_count, Dtype(-1), top_mask);
    } else {
      mask = max_idx_.mutable_cpu_data();
      caffe_set(top_count, -1, mask);
    } //（*1）设为负无穷
    // The main loop
    for (int n = 0; n < bottom[0]->num(); ++n) {
      for (int c = 0; c < channels_; ++c) {
        for (int ph = 0; ph < pooled_height_; ++ph) {
          for (int pw = 0; pw < pooled_width_; ++pw) {
            int hstart = ph * stride_h_ - pad_h_;
            int wstart = pw * stride_w_ - pad_w_;
            int hend = min(hstart + kernel_h_, height_);
            int wend = min(wstart + kernel_w_, width_);         
 //这四个量给出未pooling矩阵中确定pooling区域的两个顶点。
            hstart = max(hstart, 0);
            wstart = max(wstart, 0);                             
            //caffe 数据存储是一维数组的形式
 //ph为pooling后输出top的height index，pool_index为对应一维数组index。
            for (int h = hstart; h < hend; ++h) {
              for (int w = wstart; w < wend; ++w) {
                const int index = h * width_ + w;                
                //对应一维数组的index
                if (bottom_data[index] > top_data[pool_index]) {
 //由（*1）可知该循环将bottom中pooling区域（kernel的大小）的最大值放到对应top
                  if (use_top_mask) {
                    top_mask[pool_index] = static_cast<Dtype>(index);
                  } else {
 //记录top得到的max value在bottom中的index
                  }
                }
              }
            }
          }
        }
        // compute offset
        bottom_data += bottom[0]->offset(0, 1);
        top_data += top[0]->offset(0, 1);
        if (use_top_mask) {
          top_mask += top[0]->offset(0, 1);
        } else {
          mask += top[0]->offset(0, 1);    //取下一个channel的mask
        }
      }
    }
    break;
  case PoolingParameter_PoolMethod_AVE:    //average pooling
    for (int i = 0; i < top_count; ++i) {
      top_data[i] = 0;                     //将top初始化为0
    }
    // The main loop
    for (int n = 0; n < bottom[0]->num(); ++n) {
      for (int c = 0; c < channels_; ++c) {
        for (int ph = 0; ph < pooled_height_; ++ph) {
          for (int pw = 0; pw < pooled_width_; ++pw) {
            int hstart = ph * stride_h_ - pad_h_;
            int wstart = pw * stride_w_ - pad_w_;
            int hend = min(hstart + kernel_h_, height_ + pad_h_);
            int wend = min(wstart + kernel_w_, width_ + pad_w_);
            int pool_size = (hend - hstart) * (wend - wstart);
            //pooling 区域的element 个数
            hstart = max(hstart, 0);
            wstart = max(wstart, 0);
            hend = min(hend, height_);
            wend = min(wend, width_);
            for (int h = hstart; h < hend; ++h) {
              for (int w = wstart; w < wend; ++w) {
                top_data[ph * pooled_width_ + pw] +=
 //将pooling区域的element个数加起来
              }
            }
            top_data[ph * pooled_width_ + pw] /= pool_size;    //求平均值
          }
        }
        // compute offset
        bottom_data += bottom[0]->offset(0, 1);
        top_data += top[0]->offset(0, 1);
      }
    }
    break;
  case PoolingParameter_PoolMethod_STOCHASTIC:                    
    NOT_IMPLEMENTED;
    break;
  default:
    LOG(FATAL) << "Unknown pooling method.";
  }
}

4.Backward_cpu 函数

关于pooling的求导可以参考这里

template <typename Dtype>
void PoolingLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  if (!propagate_down[0]) {
    return;
  }
  const Dtype* top_diff = top[0]->cpu_diff();
  Dtype* bottom_diff = bottom[0]->mutable_cpu_diff();//初始化bottom_diff 为0
  // Different pooling methods. We explicitly do the switch outside the for
  // loop to save time, although this results in more codes.
  caffe_set(bottom[0]->count(), Dtype(0), bottom_diff);
  // We'll output the mask to top[1] if it's of size >1.
  const bool use_top_mask = top.size() > 1;
  const int* mask = NULL;  // suppress warnings about uninitialized variables
  const Dtype* top_mask = NULL;
  switch (this->layer_param_.pooling_param().pool()) {
  case PoolingParameter_PoolMethod_MAX:
    // The main loop
    if (use_top_mask) {
      top_mask = top[1]->cpu_data();
    } else {
      mask = max_idx_.cpu_data();
    }
    for (int n = 0; n < top[0]->num(); ++n) {
      for (int c = 0; c < channels_; ++c) {
        for (int ph = 0; ph < pooled_height_; ++ph) {
          for (int pw = 0; pw < pooled_width_; ++pw) {
            const int index = ph * pooled_width_ + pw;
            const int bottom_index =
                use_top_mask ? top_mask[index] : mask[index];
            bottom_diff[bottom_index] += top_diff[index];  //计算“敏感值”分布
          }
        }
        bottom_diff += bottom[0]->offset(0, 1);
        top_diff += top[0]->offset(0, 1);                //指向下一个channel
        if (use_top_mask) {
          top_mask += top[0]->offset(0, 1);
        } else {
          mask += top[0]->offset(0, 1);
        }
      }
    }
    break;
  case PoolingParameter_PoolMethod_AVE:
    // The main loop
    for (int n = 0; n < top[0]->num(); ++n) {
      for (int c = 0; c < channels_; ++c) {
        for (int ph = 0; ph < pooled_height_; ++ph) {
          for (int pw = 0; pw < pooled_width_; ++pw) {
            int hstart = ph * stride_h_ - pad_h_;
            int wstart = pw * stride_w_ - pad_w_;
            int hend = min(hstart + kernel_h_, height_ + pad_h_);
            int wend = min(wstart + kernel_w_, width_ + pad_w_);
            int pool_size = (hend - hstart) * (wend - wstart);
            hstart = max(hstart, 0);
            wstart = max(wstart, 0);
            hend = min(hend, height_);
            wend = min(wend, width_);
            for (int h = hstart; h < hend; ++h) {
              for (int w = wstart; w < wend; ++w) {//遍历pooling区域
                bottom_diff[h * width_ + w] +=
                    top_diff[ph * pooled_width_ + pw] / pool_size; //反向传播时各层间“误差敏感”总和不变，所以对应每个值需要平摊
              }
            }
          }
        }
        // offset
        bottom_diff += bottom[0]->offset(0, 1);
        top_diff += top[0]->offset(0, 1);//指向下一个channel
      }
    }
    break;
  case PoolingParameter_PoolMethod_STOCHASTIC:
    NOT_IMPLEMENTED;
    break;
  default:
    LOG(FATAL) << "Unknown pooling method.";
  }
}
seven_first
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
caffe 学习笔记之PoolingParameter
learning notes
06-22 1678
caffe的官方描述 Pooling在proto中的定义为message PoolingParameter { enum PoolMethod { MAX = 0; AVE = 1; STOCHASTIC = 2; } optional PoolMethod pool = 1 [default = MAX]; // The pooling method //
Caffe_Linux学习笔记（二）细粒度图像分类
huang2818138的博客
10-16 897
0、参考文献 参考我上一次在Win10上跑的实验 1、跳至第五步 2、耐心等待完成 3、计算均值并保存 结果： 4、synset_words.txt文件 因为有196类汽车，没必要一一写清楚，我就用数字代替类，唯独31类是我的测试选择，故如图 5、deploy.txt文件 name: "GoogleNet" layer { name: "data" t
vggnet代码matlab-caffe_ssd:caffe_ssd
05-27
vggnet代码matlab SSD：单发MultiBox检测器 由，，，，傅成扬。 介绍 SSD是使用单个网络进行对象检测的统一框架。 您可以使用代码来训练/评估用于对象检测任务的网络。 有关更多详细信息，请参阅我们的。 系统 VOC2007测试图 第一人称射击（Titan X） 箱数 73.2 7 300 62.1 17 300 63.4 45 98 52.7 155 98 固态硬盘300（VGG16） 72.1 58 7308 SSD300（VGG16，cuDNN v5） 72.1 72 7308 SSD500（VGG16） 75.1 23 20097 引用SSD 如果有助于研究，请在出版物中引用SSD： @article{liu15ssd, Title = {{SSD}: Single Shot MultiBox Detector}, Author = {Liu, Wei and Anguelov, Dragomir and Erhan, Dumitru and Szegedy, Christian and Reed, Scott and Fu, Cheng-Yang and
caffe之(二)pooling层
weixin_30312557的博客
03-04 329
在caffe中，网络的结构由prototxt文件中给出，由一些列的Layer（层）组成，常用的层如：数据加载层、卷积操作层、pooling层、非线性变换层、内积运算层、归一化层、损失计算层等；本篇主要介绍pooling层 1. Pooling层总述 下面首先给出pooling层的结构设置的一个小例子（定义在.prototxt文件中） layer { name: "pool1" ...
caffe深度学习【十四】训练出错：Message type "caffe.PoolingParameter" has no field named "ceil_mode".
volcano_Lin 的博客
08-31 2218
背景： 今天下了DPN的源码，想自己跑一跑，源码如下： https://github.com/soeaver/caffe-model/tree/master/cls/dpn 但是caffe运行时出现了Message type “caffe.PoolingParameter” has no field named “ceil_mode”.的错误 主要是参考  https://github.c...
pooling layer(池化层)介绍及作用
QFJIZHI的博客
11-30 1万+
1. 种类 常见的的池化层有最大池化(max pooling)和平均池化(average pooling): 2. 作用 通过池化层可以减少空间信息的大小,也就提高了运算效率; 减少空间信息也就意味着减少参数,这也降低了overfit的风险; 获得空间变换不变性(translation rotation scale invarance,平移旋转缩放的不变性); 下面展示了不变性的例子,下面的...
详解Keras3.0 Layers API: Pooling layers （MaxPooling1D、MaxPooling2D、MaxPooling3D）
最新发布
lymake的博客
12-12 740
【代码】详解Keras3.0 Layers API: Pooling layers （MaxPooling1D、MaxPooling2D、MaxPooling3D）
Pytorch深度学习—— 卷积神经网络基础篇（B站刘二大人P10学习笔记）
Learning_AI的博客
01-22 2165
之前我们学习的网络全是由线性层串行连接起来的，这种网络被称为全连接网络，全连接网络在数值计算的时候，会丧失掉图片特征中的一些空间的信息。而卷积神经网络可以很好的保留图像的空间特征。如图所示，是卷积神经网络的基本工作方式：
深度学习——池化层理论学习（Pooling Layer）
gy的博客
08-04 5747
这里写目录标题1. 什么是池化层2. 池化层作用3. 常见的池化层3.1 最大池化层（max pooling layer）3.2 平均池化层（average pooling layer）3.3 重叠池化层（Overlapping Pooling layer）：3.4 其它池化层4. 参考资料 1. 什么是池化层 池化是缩小高、长方向上的空间的运算。池化层是具有这种功能的一个深度学习的层。 对输入的特征图进行压缩，一方面使特征图变小，简化网络计算复杂度；一方面进行特征压缩，提取主要特征。 下图是Max池化
Day10 最大池化层 Pooling layer MaxPool2d
weixin_45417707的博客
06-25 413
池化：在保留数据特征的情况下减小数据量，它实际上是一种形式的降采样。有多种不同形式的非线性池化函数，而其中“最大池化（Maxpooling）”是最为常见的。它是将输入的图像划分为若干个矩形区域，对每个子区域输出最大值。与卷积不用，池化是选取核中最大数作为output通常来说，CNN的卷积层之间都会周期性地插入池化层。
matlab代码变成.exe-caffe_rcnn:caffe_rcnn
05-27
Caffe 这是一个由Guillaume Dumont（@willyd）领导的基于社区的实验性分支。 这是一个进行中的工作。 Caffe的此分支将框架移植到Windows。 Travis（Linux构建） AppVeyor（Windows构建） Windows安装程序 要求 ...
caffe多标签源码_image_data_layer
02-01
修改caffe源码，使image_data_layer支持多标签输入，主要用于回归任务
openpose官方模型库:pose_iter_xxxxxx.caffemodel
08-18
pose_iter_584000.caffemodel) coco(pose_deploy_linevec.prototxt; pose_iter_440000.caffemodel) mpi(pose_deploy_linevec.prototxt; pose_deploy_linevec_faster_4_stages.prototxt; pose_iter_160000.caffe...
信号检测matlab代码-MTCNN_face_detection_caffe:MTCNN_face_detection_caffe
05-27
信号检测matlab代码MTCNN_face_detection_caffe 关于 这是Detection and Alignment using Multi-task Cascaded Convolutional Neural Networks进行Detection and Alignment using Multi-task Cascaded Convolutional...
Caffe源码（一）：math_functions 分析
热门推荐
seven_first的博客
08-09 8万+
目录目录 主要函数 caffe_cpu_gemm 函数 caffe_cpu_gemv 函数 caffe_axpy 函数 caffe_set 函数 caffe_add_scalar 函数 caffe_copy 函数 caffe_scal 函数 caffeine_cup_axpby 函数 caffe_add caffe_sub caffe_mul caffe_div 函数 caffe_powx caff
Caffe源码（十）：eltwise_layer 分析
seven_first的博客
08-18 1万+
目录目录 简单介绍 主要函数LayerSetUp 函数 Reshape 函数 Forward_cpu 函数 Backward_cpu 函数简单介绍eltwise_layer 实现多个blobs element-wise 的相加，相乘或者取最大值。主要函数1.LayerSetUp 函数：template <typename Dtype> void EltwiseLayer<Dtype>::LayerS
Caffe源码（二）：blob 分析
seven_first的博客
08-10 1万+
目录目录 简单介绍 源代码分析 Reshape 函数 Blob 构造函数 data_数据操作函数 反向传播导数diff_ 操作函数 ShareData 函数 Updata 函数 asum_data 函数 asum_diff 函数 sumsq_data 函数 sumsq_diff函数 scale_data 函数 scale_diff函数 ShapeEquals函数 CopyFrom 函数 FromPr
Caffe 源码（九）：euclidean_loss_layer 分析
seven_first的博客
08-17 1万+
目录目录 简单介绍 主要函数 Reshape 函数 Forward_cpu 函数 Backward_cpu 函数简单介绍Euclidean loss layer 计算两个输入的差的平方和：12N∑Ni=1||x1i−x2i||22\frac{1}{2N}\sum_{i = 1}^N||x_{1i}-x_{2i}||_2^2主要函数1.Reshape 函数：template <typename Dty
Caffe源码（三）：layer 分析
seven_first的博客
08-11 1万+
目录目录 简单介绍 Message LayerParameter Layer 类 构造函数 LayerSetUp 函数 Forword 函数 Backword 函数 blobslayer_param函数 ToProto 函数 loss set_loss函数 一些返回特定参数的函数 set_param_propagate_downparam_propagate_down 函数 CheckBlobCou
torch::Tensor 转为 caffe2::Tensor
03-29
可以使用以下代码将 torch::Tensor 转换为 caffe2::Tensor： ```c++ #include <caffe2/core/tensor.h> #include caffe2::Tensor convert_torch_to_caffe2(const torch::Tensor& input_tensor) { // 获取张量的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值