caffe源码深入学习8：caffe框架深度神经网络反传代码解析（二）之pooling层源码解析

最新推荐文章于 2021-01-12 03:07:11 发布
最新推荐文章于 2021-01-12 03:07:11 发布
阅读量1.4k 收藏 2
点赞数 2
分类专栏： caffe 源码解析 文章标签： caffe 源码解析 深度学习 神经网络 池化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiongnima/article/details/102324981
版权

caffe源码深入学习8：caffe框架深度神经网络反传代码解析（二）之pooling层源码解析

写在前面

在上一篇博客，即重启caffe源码深入学习7中，笔者从最简单的激活层开始，进行了caffe源码的解析，尤其讲述了梯度反传的部分。在本篇博客中，笔者将解析另一个基础层的源码，即池化层，池化层与激活层类似，其中不包含任何可训练参数。caffe池化层中包含的最大池化，平均池化等也是在深度学习中使用非常广泛的一种结构。因此，笔者通过注释池化层源码，尤其是反传部分，向大家讲解梯度反传在caffe框架中的实现，下面正式开启干货。

池化层源码及注释

按照笔者的一贯风格，首先放出经过注释的池化层源码。
首先是pooling_layer.hpp源码：

#ifndef CAFFE_POOLING_LAYER_HPP_
#define CAFFE_POOLING_LAYER_HPP_

#include <vector>

#include "caffe/blob.hpp"
#include "caffe/layer.hpp"
#include "caffe/proto/caffe.pb.h"

namespace caffe {

/**
 * @brief Pools the input image by taking the max, average, etc. within regions.
 *
 * TODO(dox): thorough documentation for Forward, Backward, and proto params.
 */
template <typename Dtype>
class PoolingLayer : public Layer<Dtype> {
 public:
  explicit PoolingLayer(const LayerParameter& param)
      : Layer<Dtype>(param) {} //构造函数直接继承
  virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top); //需要在cpp文件中实现的LayerSetUp函数
  virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top); //需要在cpp文件中实现的Reshape函数

  virtual inline const char* type() const { return "Pooling"; }
  virtual inline int ExactNumBottomBlobs() const { return 1; } //底层的blob数量必须为1
  virtual inline int MinTopBlobs() const { return 1; } //至少输出一个顶层blob
  // MAX POOL layers can output an extra top blob for the mask;
  // others can only output the pooled inputs.
  virtual inline int MaxTopBlobs() const {
    return (this->layer_param_.pooling_param().pool() ==
            PoolingParameter_PoolMethod_MAX) ? 2 : 1;
  } //如果是最大池化，池化层最多输出2个blob；否则只能输出1个blob

 protected:
  virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top); //cpu前传
  virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top); //gpu前传
  virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom); //cpu反传
  virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom); //gpu反传

  int kernel_h_, kernel_w_; //池化操作所使用的核的高与宽
  int stride_h_, stride_w_; //池化操作在高和宽方向上的步长
  int pad_h_, pad_w_; //需要在输入blob高和宽上pad的尺度
  int channels_; //输入blob的通道数
  int height_, width_; //输入blob的宽与高
  int pooled_height_, pooled_width_; //输出blob的宽与高
  bool global_pooling_; //是否在高和宽方向上进行全局池化操作
  PoolingParameter_RoundMode round_mode_; //池化输出尺度计算的标准，到底是向上取整还是向下取整
  Blob<Dtype> rand_idx_; //随机池化需要的记录输出元素在输入blob中的位置的blob
  Blob<int> max_idx_; //最大池化需要的记录输出元素在输入blob中的位置的blob
};

}  // namespace caffe

#endif  // CAFFE_POOLING_LAYER_HPP_

然后是pooling_layer.cpp源码：

#include <algorithm>
#include <cfloat>
#include <vector>

#include "caffe/layers/pooling_layer.hpp"
#include "caffe/util/math_functions.hpp"

namespace caffe {

using std::min;
using std::max;

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."; //必须在层设置参数中注明对输入blob高和宽上的pad(填充)参数
  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(); //是否做global_pooling
  round_mode_ = pool_param.round_mode(); //池化层输出尺度的取整模式
  if (global_pooling_) { //如果是全局池化，那么池化核宽高就直接是输入blob的宽高
    kernel_h_ = bottom[0]->height();
    kernel_w_ = bottom[0]->width();
  } 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();
    }
  }
  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()) { //初始化一下在输入blob高和宽上的pad尺寸，记录在pad_h_和pad_w_中
    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()) { //初始化一下在输入blob高和宽上的操作步长，记录在stride_h_和stride_w_中
    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";
  } //如果是global_pooling，长宽pad只能为0，并且长宽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_); //检查一下pad的尺度是否小于池化核的尺度
    CHECK_LT(pad_w_, kernel_w_);
  }
}

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)"; //检查一下输入的blob是否是4维的(n,c,h,w)
  channels_ = bottom[0]->channels(); //channels_记录输入blob的通道数
  height_ = bottom[0]->height(); //height_记录输入blob的高
  width_ = bottom[0]->width(); //width_记录输入blob的宽
  if (global_pooling_) { //如果是全局池化，那么池化核的宽高直接就是输入blob的宽高
    kernel_h_ = bottom[0]->height();
    kernel_w_ = bottom[0]->width();
  }
  switch (round_mode_) {
  case PoolingParameter_RoundMode_CEIL: //如果输出的尺寸是向上取整，那么就在除法中使用ceil
    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;
    break;
  case PoolingParameter_RoundMode_FLOOR: //如果输出的储存室向下取整，那么就在除法中使用floor
    pooled_height_ = static_cast<int>(floor(static_cast<float>(
        height_ + 2 * pad_h_ - kernel_h_) / stride_h_)) + 1;
    pooled_width_ = static_cast<int>(floor(static_cast<float>(
        width_ + 2 * pad_w_ - kernel_w_) / stride_w_)) + 1;
    break;
  default:
    LOG(FATAL) << "Unknown rounding mode.";
  }
  if (pad_h_ || pad_w_) { //为了使得高和宽上最末尾的池化操作在原blob内部开始(而不是在pad的元素中开始)，需要对池化输出的尺度进行调整
    // 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_) { //如果在高方向上pad太多了，就减少高方向池化输出的尺度
      --pooled_height_;
    }
    if ((pooled_width_ - 1) * stride_w_ >= width_ + pad_w_) { //如果在宽方向上pad太多了，就减少宽方向池化输出的尺度
      --pooled_width_;
    }
    CHECK_LT((pooled_height_ - 1) * stride_h_, height_ + pad_h_); //检验一下，在高方向上，最后一次池化操作有包含输入blob的内容
    CHECK_LT((pooled_width_ - 1) * stride_w_, width_ + pad_w_); //检验一下，在宽方向上，最后一次池化操作有包含输入blob的内容
  }
  top[0]->Reshape(bottom[0]->num(), channels_, pooled_height_,
      pooled_width_); //对池化的输出进行初始化
  if (top.size() > 1) {
    top[1]->ReshapeLike(*top[0]); //如果输出的blob大于一个，则将top[1]初始化为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_); //如果是最大池化，并且只有top[0]，那么初始化max_idx_记录元素选择下标，在反传中作用较大。
  }
  // 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_); //如果是随机池化，那么初始化rand_idx_记录元素选择下标，在反传中作用较大。
  }
}

// TODO(Yangqing): Is there a faster way to do pooling in the channel-first
// case?
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(); //输入blob
  Dtype* top_data = top[0]->mutable_cpu_data(); //输出blob
  const int top_count = top[0]->count(); //输出的数据总量(n×c×h×w)
  // We'll output the mask to top[1] if it's of size >1.
  const bool use_top_mask = top.size() > 1; //如果是输出多个top blob，那么就是使用了top_mask
  int* mask = NULL;  // suppress warnings about uninitialized variables //定义mask指针，为int型，因为记录的是下标
  Dtype* top_mask = NULL; //定义一下top_mask指针
  // 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: //如果是进行最大池化
    // Initialize
    if (use_top_mask) { //如果要使用top_mask
      top_mask = top[1]->mutable_cpu_data();
      caffe_set(top_count, Dtype(-1), top_mask); //就全部初始化为-1
    } else {
      mask = max_idx_.mutable_cpu_data(); //否则就直接使用max_idx_
      caffe_set(top_count, -1, mask); //也全部初始化为-1
    }
    caffe_set(top_count, Dtype(-FLT_MAX), top_data); //初始化一下top_data，全部设置为最小的数(-FLT_MAX)
    // The main loop
    for (int n = 0; n < bottom[0]->num(); ++n) { //一个batch中逐图像处理
      for (int c = 0; c < channels_; ++c) { //一张图像的特征中逐通道处理
        for (int ph = 0; ph < pooled_height_; ++ph) { //对于输出数据blob，在高方向上逐一进行求值
          for (int pw = 0; pw < pooled_width_; ++pw) { //对于输出数据blob，在宽方向上逐一进行求值
            int hstart = ph * stride_h_ - pad_h_; //找到在输入blob上，该次池化操作在高方向的起始点
            int wstart = pw * stride_w_ - pad_w_; //找到在输入blob上，该次池化操作在宽方向的起始点
            int hend = min(hstart + kernel_h_, height_); //找到在输入blob上，该次池化操作在高方向的结束点
            int wend = min(wstart + kernel_w_, width_); //找到在输入blob上，该次池化操作在宽方向的结束点
            hstart = max(hstart, 0); //确认一下池化操作在高上的起始点大于等于0
            wstart = max(wstart, 0); //确认一下池化操作在宽上的起始点大于等于0
            const int pool_index = ph * pooled_width_ + pw; //初始化一下池化输出的元素在mask中的位置
            for (int h = hstart; h < hend; ++h) {
              for (int w = wstart; w < wend; ++w) { //这两个for循环，遍历一个输入blob中的单次池化区域
                const int index = h * width_ + w; //记录一下选择的最大值在输入blob中的位置
                if (bottom_data[index] > top_data[pool_index]) {
                  top_data[pool_index] = bottom_data[index]; //找到一个区域中的最大的元素
                  if (use_top_mask) {
                    top_mask[pool_index] = static_cast<Dtype>(index); //如果使用top_mask，就在top_mask中记录一下，该位置输出的数据在输入blob中的位置
                  } else {
                    mask[pool_index] = index; //如果不使用top_mask，就在mask中记录一下，该位置输出的数据在输入blob中的位置
                  }
                }
              }
            }
          }
        }
        // compute offset
        bottom_data += bottom[0]->offset(0, 1); //输入数据移动一个channel
        top_data += top[0]->offset(0, 1); //输出数据移动一个channel
        if (use_top_mask) {
          top_mask += top[0]->offset(0, 1); //如果使用了top_mask，那么就将top_mask移动一个channel
        } else {
          mask += top[0]->offset(0, 1); //否则就仅将mask移动一个channel
        }
      }
    }
    break; //池化操作处理完毕，直接break
  case PoolingParameter_PoolMethod_AVE: //如果是进行平均池化
    for (int i = 0; i < top_count; ++i) { //首先把输出数据全部置0
      top_data[i] = 0;
    }
    // The main loop
    for (int n = 0; n < bottom[0]->num(); ++n) { //一个batch中逐图像处理
      for (int c = 0; c < channels_; ++c) { //一张图像的特征中逐通道处理
        for (int ph = 0; ph < pooled_height_; ++ph) { //对于输出数据blob，在高方向上逐一进行求值
          for (int pw = 0; pw < pooled_width_; ++pw) { //对于输出数据blob，在宽方向上逐一进行求值
            int hstart = ph * stride_h_ - pad_h_; //找到在输入blob上，该次池化操作在高方向的起始点
            int wstart = pw * stride_w_ - pad_w_; //找到在输入blob上，该次池化操作在宽方向的起始点
            int hend = min(hstart + kernel_h_, height_ + pad_h_); //找到在输入blob上，该次池化操作在高方向的结束点
            int wend = min(wstart + kernel_w_, width_ + pad_w_); //找到在输入blob上，该次池化操作在宽方向的结束点
            int pool_size = (hend - hstart) * (wend - wstart); //计算一下在多少个输入数据上求平均值
            hstart = max(hstart, 0); //确认一下池化操作在高上的起始点大于等于0
            wstart = max(wstart, 0); //确认一下池化操作在宽上的起始点大于等于0
            hend = min(hend, height_); //确认一下在输入blob上，该次操作在高方向的结束点小于输出blob的高
            wend = min(wend, width_); //确认一下在输入blob上，该次操作在宽方向的结束点小于输出blob的宽
            for (int h = hstart; h < hend; ++h) {
              for (int w = wstart; w < wend; ++w) { //这两个for循环，遍历一个输入blob中的单次池化区域
                top_data[ph * pooled_width_ + pw] +=
                    bottom_data[h * width_ + w]; //将一次池化区域的数据全部加起来
              }
            }
            top_data[ph * pooled_width_ + pw] /= pool_size; //然后，将输出求平均值
          }
        }
        // compute offset
        bottom_data += bottom[0]->offset(0, 1); //输入数据移动一个channel
        top_data += top[0]->offset(0, 1); //输出数据移动一个channel
      }
    }
    break;
  case PoolingParameter_PoolMethod_STOCHASTIC: //如果是进行随机池化
    NOT_IMPLEMENTED; //暂时还没实现前传
    break;
  default:
    LOG(FATAL) << "Unknown pooling method.";
  }
}

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; //直接return
  }
  const Dtype* top_diff = top[0]->cpu_diff(); //top_diff记录了误差对于输出数据的梯度
  Dtype* bottom_diff = bottom[0]->mutable_cpu_diff(); //bottom_diff记录了误差对与输入数据的梯度
  // 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); //将输入数据的梯度全初始化为0
  // We'll output the mask to top[1] if it's of size >1.
  const bool use_top_mask = top.size() > 1; //如果是输出多个top blob，那么就是使用了top_mask
  const int* mask = NULL;  // suppress warnings about uninitialized variables //定义mask指针，为int型，因为记录的是下标
  const Dtype* top_mask = NULL; //定义一下top_mask指针
  switch (this->layer_param_.pooling_param().pool()) { //判断池化方式
  case PoolingParameter_PoolMethod_MAX: //如果是最大池化
    // The main loop
    if (use_top_mask) { //使用top_mask
      top_mask = top[1]->cpu_data(); //就读出数据
    } else {
      mask = max_idx_.cpu_data(); //否则直接读出mask的数据
    }
    for (int n = 0; n < top[0]->num(); ++n) { //一个batch中逐图像处理
      for (int c = 0; c < channels_; ++c) { //一张图像的特征中逐通道处理
        for (int ph = 0; ph < pooled_height_; ++ph) { //在输出blob的高方向上，逐一求得输入blob的梯度
          for (int pw = 0; pw < pooled_width_; ++pw) { //在输出blob的宽方向上，逐一求得输入blob的梯度
            const int index = ph * pooled_width_ + pw; //初始化一下输出的元素在mask中的位置
            const int bottom_index =
                use_top_mask ? top_mask[index] : mask[index]; //求得该输出的元素在输入blob中的位置
            bottom_diff[bottom_index] += top_diff[index]; //将该输入元素梯度的位置进行梯度，直接将输出元素的梯度拿过来加在对应位置上
          }
        }
        bottom_diff += bottom[0]->offset(0, 1); //输入数据梯度移动一个channel
        top_diff += top[0]->offset(0, 1); //输出数据梯度移动一个channel
        if (use_top_mask) {
          top_mask += top[0]->offset(0, 1); //如果使用了top_mask，那么就将top_mask移动一个channel
        } else {
          mask += top[0]->offset(0, 1); //否则就将mask移动一个channel
        }
      }
    }
    break;
  case PoolingParameter_PoolMethod_AVE: //如果是进行平均池化
    // The main loop
    for (int n = 0; n < top[0]->num(); ++n) { //一个batch中逐图像处理
      for (int c = 0; c < channels_; ++c) { //一张图像的特征中逐通道处理
        for (int ph = 0; ph < pooled_height_; ++ph) { //在输出blob的高方向上，逐一求得输入blob的梯度
          for (int pw = 0; pw < pooled_width_; ++pw) { //在输出blob的宽方向上，逐一求得输入blob的梯度
            int hstart = ph * stride_h_ - pad_h_; //找到在输入blob上，前传时进行该次池化操作时在高方向的起始点
            int wstart = pw * stride_w_ - pad_w_; //找到在输入blob上，前传时进行该次池化操作时在宽方向的起始点
            int hend = min(hstart + kernel_h_, height_ + pad_h_); //找到在输入blob上，前传时进行该次池化操作时在高方向的结束点
            int wend = min(wstart + kernel_w_, width_ + pad_w_); //找到在输入blob上，前传时进行该次池化操作时在宽方向的结束点
            int pool_size = (hend - hstart) * (wend - wstart); //计算一下前传时在多少个输入数据上求平均值
            hstart = max(hstart, 0); //确认一下前传时池化操作在高上的起始点大于等于0
            wstart = max(wstart, 0); //确认一下前传时池化操作在宽上的起始点大于等于0
            hend = min(hend, height_); //确认一下在输入blob上，前传时该次操作在高方向的结束点小于输出blob的高
            wend = min(wend, width_); //确认一下在输入blob上，前传时该次操作在宽方向的结束点小于输出blob的宽
            for (int h = hstart; h < hend; ++h) {
              for (int w = wstart; w < wend; ++w) { //在前传时该次池化操作的区域内
                bottom_diff[h * width_ + w] +=
                  top_diff[ph * pooled_width_ + pw] / pool_size; //输入数据每个位置上的梯度均分输出的那一个区域对应梯度
              }
            }
          }
        }
        // offset
        bottom_diff += bottom[0]->offset(0, 1); //输入数据梯度移动一个channel
        top_diff += top[0]->offset(0, 1); //输出数据梯度移动一个channel
      }
    }
    break;
  case PoolingParameter_PoolMethod_STOCHASTIC: //如果是进行随机池化
    NOT_IMPLEMENTED; //暂时还没实现反传
    break;
  default:
    LOG(FATAL) << "Unknown pooling method.";
  }
}


#ifdef CPU_ONLY
STUB_GPU(PoolingLayer);
#endif

INSTANTIATE_CLASS(PoolingLayer);

}  // namespace caffe

池化层源码解析

在上面的池化层源码中，笔者解析了代码前传与反传中的具体操作，在caffe中的池化层中，池化操作分为最大池化与平均池化。在进行最大池化与平均池化的过程中，caffe框架都是按照batch->channel->池化操作的具体区域这个顺序来实现的。下面，笔者通过画图来阐释caffe中池化层源码，尤其是反传时的操作原理。

最大池化

对于一个训练批次(batch)中一张图像对应的特征的一个通道，假设池化核长宽为3，长宽方向步长为3，一次最大池化的前传操作过程如下图所示：
caffe最大池化前传如上图所示，左边是输入blob，右边是输出blob。在输入blob中第一个3×3的区域就是池化操作的区域，假设红色的方块代表最大值，那么在前传的时候，该区域输出的值就是红色方块的值。选择最大值的过程可在Forward_cpu中最大池化操作的最后两个for循环找到。

for (int h = hstart; h < hend; ++h) {
              for (int w = wstart; w < wend; ++w) { //这两个for循环，遍历一个输入blob中的单次池化区域
                const int index = h * width_ + w; //记录一下选择的最大值在输入blob中的位置
                if (bottom_data[index] > top_data[pool_index]) {
                  top_data[pool_index] = bottom_data[index]; //找到一个区域中的最大的元素
                  if (use_top_mask) {
                    top_mask[pool_index] = static_cast<Dtype>(index); //如果使用top_mask，就在top_mask中记录一下，该位置输出的数据在输入blob中的位置
                  } else {
                    mask[pool_index] = index; //如果不使用top_mask，就在mask中记录一下，该位置输出的数据在输入blob中的位置
                  }
                }
              }
            }

在前传的过程中，比较重要的是，在输入blob中选择数据的位置被记录在了mask数组里面，mask数组这将在反传过程中起到重要的作用。

相应地，一次最大池化的反传操作过程如下图所示：
caffe最大池化反传如上图所示，==在进行反传时，对应输出区域的梯度直接传给了前传过程中选择的最大值区域。那么是怎么找到这个区域的呢？答案就是依赖前传过程中的mask数组啦！==体现在源码中Backward_cpu函数中的下列代码中：

bottom_diff[bottom_index] += top_diff[index];

到这里就解释清楚了，pooling层中最大池化的反传是如何实现的。下面，我们来看看平均池化。

平均池化

对于一个训练批次(batch)中一张图像对应的特征的一个通道，假设池化核长宽为3，长宽方向步长为3，一次平均池化的前传操作过程如下图所示：
caffe平均池化前传
在caffe平均池化的前传中，对于一次池化操作的区域，直接求平均值就能得到输出，在Forward_cpu函数中平均池化的前传部分可以很容易地找到求均值的代码。

top_data[ph * pooled_width_ + pw] /= pool_size;

相应地，在caffe平均池化的反传中，根据求导原则，一次前传过程中池化操作区域每个元素的梯度之和，就等于输出元素梯度。那么，只需要将输出元素的梯度除以参与池化操作的输入数据个数。平均池化的反传操作如下图所示：
caffe平均池化反传均分顶层梯度的操作在Backward_cpu函数中的平均池化部分也很容易找到。

bottom_diff[h * width_ + w] +=
                  top_diff[ph * pooled_width_ + pw] / pool_size;

如上就解析了caffe框架中池化(pooling)层的具体实现过程了，本篇博客也接近尾声了。笔者衷心希望本篇博文能为大家在深度学习理论与工程方面带来帮助。

欢迎阅读笔者后续博客，各位读者朋友的支持与鼓励是我最大的动力。

written by jiong
人生易老天难老，岁岁重阳，
今又重阳，战地黄花分外香。
一年一度秋风劲，不似春光，
胜似春光，寥廓江天万里霜。

jiongnima
关注
专栏目录
Roi_Pooling层caffe源码解读
JoliceYu的技术博客
12-01 2921
在看fasterrcnn以及和maskrcnn的时候，发现自己对fasterrcnn的roi_pooling层的原理还是不是很明白，之前只是知道roi_pooling是将rpn输出的一个roi的区域映射成一个固定大小的map，再送入后面的分类层进行分类。最近看了下roi_pooling层的源码，顿悟了。1、roi_pooling在proto中的定义根据看caffe源码的原则，先看该成在caffe.p
深度学习框架Caffe源码解析
CSDN 人工智能
12-13 2163
作者：薛云峰(https://github.com/HolidayXue)，主要从事视频图像算法的研究，就职于浙江捷尚视觉科技股份有限公司担任深度学习算法研究员。 本文来源微信公众号：深度学习大讲堂。 原文：深度学习框架Caffe源码解析 欢迎技术投稿、约稿、给文章纠错，请发送邮件至heyc@csdn.net 相信社区中很多小伙伴和我一样使用了很长时间的Caffe深度学习框...
神经网络：caffe特征可视化的代码例子
diandingyin9417的博客
08-17 118
caffe特征可视化的代码例子 不少读者看了我前面两篇文章 总结一下用caffe跑图片数据的研究流程 deep learning实践经验总结2--准确率再次提升，到达0.8。再来总结一下 之后。想知道我是怎么实现特征可视化的。 简单来说，事实上就是让神经网络正向传播一次。然后把某层的特征值给取出来。然后转换为图片保存。 以下我提供一个dem...
caffe之(二)pooling层
weixin_30312557的博客
03-04 343
在caffe中，网络的结构由prototxt文件中给出，由一些列的Layer（层）组成，常用的层如：数据加载层、卷积操作层、pooling层、非线性变换层、内积运算层、归一化层、损失计算层等；本篇主要介绍pooling层 1. Pooling层总述 下面首先给出pooling层的结构设置的一个小例子（定义在.prototxt文件中） layer { name: "pool1" ...
Caffe源码：pooling_layer.cpp
zzqiuzz的博客
12-07 516
@brief PoolingLayer层反向传播conv2–>pool2只将梯度传到贡献损失的神经元即max\max所在的神经元索引 核心代码： bottom_diff[bottom_index] += top_diff[index];//计算梯度并更新原始bottom_diff主体代码#include <algorithm> #include <cfloat> #include <vector>
【caffe】caffe之pooling层
大雄的专栏
11-16 2461
PoolingLayerLayerSetUp//主要对pooling的kernel、pad、stride进行初始化 template <typename Dtype> void PoolingLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) { P
caffe源码——深度学习框架
06-27
《Caffe深度学习框架详解——源码解析及接口应用》 Caffe，全称为Convolutional Architecture for Fast Feature Embedding，是由Berkeley Vision and Learning Center（BVLC）开发的开源深度学习框架，以其高效、...
深度学习框架caffe源码
07-16
这个文件描述了神经网络的层次结构，包括卷积层(Convolution)、池化层(Pooling)、全连接层(Fully Connected)等。用户可以通过修改这些文件来定制自己的网络架构。 2. **模型权重**：Caffe支持两种类型的模型文件，`...
caffe 源码解析部分
07-06
**深度学习框架Caffe源码解析** Caffe（Convolutional Architecture for Fast Feature Embedding）是由Berkeley Vision and Learning Center（BVLC）开发的一款高效、开源的深度学习框架，广泛应用于计算机视觉领域...
caffe源码（2015年8月15日）
08-22
“caffe”标签显然指的是Caffe框架，“cnn”则是卷积神经网络（Convolutional Neural Networks）的缩写，这是深度学习中最常用的一种模型，特别是在图像识别和计算机视觉任务中。Caffe以其高效、简洁和易于扩展的...
Caffe源码解析7：Pooling_Layer
weixin_30444105的博客
02-23 128
转载请注明出处，楼燚(yì)航的blog，http://home.cnblogs.com/louyihang-loves-baiyan/ Pooling 层一般在网络中是跟在Conv卷积层之后，做采样操作，其实是为了进一步缩小feature map，同时也能增大神经元的视野。在Caffe中，pooling层属于vision_layer的一部分，其相关的定义也在vision_layer.hpp的头文...
caffe之pooling层
信大傲飞的博客
10-22 1062
1. Pooling层总述 下面首先给出pooling层的结构设置的一个小例子（定义在.prototxt文件中）  layer { name: "pool1" //该层的名称 type: "Pooling" //该层的类型 bottom: "norm1" //该层的输入数据blob top: "pool1" //该层的输出数据blob // 该层的相关
Caffe入门：global pooling (全局池化)
那年聪聪
10-19 7519
global pooling (全局池化)
caffe学习笔记24-Pooling层学习
YiLiang
03-05 922
caffe学习记录
CAFFE源码学习笔记之池化层pooling_layer
sinat_22336563的博客
04-10 4320
一、前言 池化层的输入来自上一个卷积层的输出，主要作用是提供了平移不变性，并且减少了参数的数量，防止过拟合现象的发生。比如在最大池化中，选择区域内最大的值为采样点，这样在发生平移的时候，采样点不变。 池化层一般没有参数，所以反向传播的时候，只需对输入参数求导，不需要进行权值更新。平均值效果不佳，一般选择最大池化。 二、源码分析 1、LayerSetUp函数 跟卷积层类似，主要是导入池化层的
caffe源码分析--poolinger_layer.cpp
linger(心怀梦想，活在当下，知乎ID：linger liu)
07-30 5482
caffe源码分析--poolinger_layer.cpp 对于采样层，cafffe里实现了最大采样和平均采样的算法。 最大采样，给定一个扫描窗口，找最大值， 平均采样，扫描窗口内所有值的平均值。
向上取整的方法_通过修改源码解决caffe的pooling向上取整的问题
weixin_31910545的博客
01-12 378
caffe框架下载入模型的时候，经常会遇到这样的bug。Check failed: bottom[0] ->shape() == bottom[i] ->shape() bottom[0]: 1 64 56 56 (200704), bottom[1]: 1 64 57 57 (207936)。后来通过比对prototxt的layer标号和这里的错误信息，才知道是pooling层的锅。...
Caffe源码（六）: pooling_layer 分析
seven_first的博客
08-16 7611
目录目录 简单介绍 主要函数 LayerSetUp 函数 Reshape 函数 Forward_cpu 函数 Backward_cpu 函数简单介绍pooling_layer 是Layer 的子类，实现了pooling操作。其主要函数有LayerSetUp，Reshape，Forward_cpu， Backward_cpu。 主要函数1.LayerSetUp 函数：template <typenam
Caffe框架源码剖析(6)—池化层PoolingLayer
edmond999的专栏
11-13 907
卷积层ConvolutionLayer正向传导的目标层往往是池化层PoolingLayer。池化层通过降采样来降低卷积层输出的特征向量，同时改善结果，不易出现过拟合。最常用的降采样方法有均值采样（取区域平均值作为降采样值）、最大值采样（取区域最大值作为降采样值）和随机采样（取区域内随机一个像素）等。     PoolingLayer类从Layer基类单一继承而来，没有派生其它子类。具体定义在po
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值