Max Pooling算子的设计实现-电子发烧友网

Max Pooling算子的定义

池化层在深度学习网络中的作用一般是用来缓解卷积层对位置的过度敏感性。池化层每次对输入数据的一个固定形状窗口(池化窗口的大小为pooling height, pooling width)中的元素计算输出，池化层直接计算池化窗口内元素的最大值或者平均值，因此该运算也分别叫做最大池化或平均池化。

在我们本节课要讲的二维最大池化中，池化窗口从输入数组的最左上方开始，按从左往右、从上往下的顺序，依次在输入数组上滑动(滑动的幅度被称为stride)。当池化窗口滑动到某一位置时，窗口中的输入子数组的最大值即输出数组中相应位置的元素。

图1展示了池化窗口形状为 2×2 的最大池化，阴影部分为第一个输出元素及其计算所使用的输入元素。

输出数组的高和宽分别为2，其中的4个元素由取最大值运算 max 得出。如下公式所示，池化操作的步骤依次为从左到右，从上到下，每次向下移动的步长为stride height, 向右移动的步长为stride width. 进行池化操作元素的数量由pooling height和pooling width所组成的2×2的窗口所决定。

Max Pooling Operator的实现

classMaxPoolingOp:publicOperator{
public:
explicitMaxPoolingOp(uint32_tpooling_h,uint32_tpooling_w,uint32_tstride_h,
uint32_tstride_w,uint32_tpadding_h,uint32_tpadding_w);

voidset_pooling_h(uint32_tpooling_height);
voidset_pooling_w(uint32_tpooling_width);

voidset_stride_w(uint32_tstride_width);
voidset_stride_h(uint32_tstride_height);

voidset_padding_h(uint32_tpadding_height);
voidset_padding_w(uint32_tpadding_width);

uint32_tpadding_height()const;
uint32_tpadding_width()const;

uint32_tstride_width()const;
uint32_tstride_height()const;

uint32_tpooling_height()const;
uint32_tpooling_width()const;
private:
uint32_tpooling_h_;//池化核高度大小
uint32_tpooling_w_;//池化核宽度大小
uint32_tstride_h_;//高度上的步长
uint32_tstride_w_;//宽度上的步长
uint32_tpadding_h_;//高度上的填充
uint32_tpadding_w_;//宽度上的填充
};

可以看到如上的Operator中,有6个类内属性，分别对应着我们第一节中讲过的步长(stride), 池化核(pooling)以及在池化前对边缘的扩充，以下我们在分别讲讲：

stride: 池化核每次移动的步长

pooling: 池化核的大小

padding: 对输入特征图的边缘扩充

如下图2是pad(padding值为1)后输入特征图的池化操作(池化核为2):

Max Pooling Layer的实现

MaxPoolingLayer::MaxPoolingLayer(conststd::shared_ptr&op):Layer("maxpooling"){
CHECK(op->op_type_==OpType::kOperatorMaxPooling)<< "Operator has a wrong type: " << int(op->op_type_);
MaxPoolingOp*max_pooling_op=dynamic_cast(op.get());

CHECK(max_pooling_op!=nullptr)<< "MaxPooling operator is empty";
  this->op_=std::make_unique(*max_pooling_op);
}

voidMaxPoolingLayer::Forwards(conststd::vector>>&inputs,
std::vector>>&outputs){
CHECK(this->op_!=nullptr);
CHECK(this->op_->op_type_==OpType::kOperatorMaxPooling);
CHECK(!inputs.empty());
constuint32_tpadding_h=this->op_->padding_height();
constuint32_tpadding_w=this->op_->padding_width();
constuint32_tkernel_h=this->op_->pooling_height();
constuint32_tkernel_w=this->op_->pooling_width();
constuint32_tstride_h=this->op_->stride_height();
constuint32_tstride_w=this->op_->stride_width();

constuint32_tbatch_size=inputs.size();
for(uint32_ti=0;i< batch_size; ++i) {
    const std::shared_ptr>&input_data_=inputs.at(i)->Clone();
input_data_->Padding({padding_h,padding_h,padding_w,padding_w},std::numeric_limits::lowest());
constuint32_tinput_h=input_data_->rows();
constuint32_tinput_w=input_data_->cols();
constuint32_tinput_c=input_data_->channels();
constuint32_toutput_c=input_c;

constuint32_toutput_h=uint32_t(std::floor((input_h-kernel_h)/stride_h+1));
constuint32_toutput_w=uint32_t(std::floor((input_w-kernel_w)/stride_w+1));
CHECK(output_w>0&&output_h>0);

std::shared_ptr>output_data=std::make_shared>(output_c,output_h,output_w);
for(uint32_tic=0;ic< input_c; ++ic) {
      const arma::fmat &input_channel = input_data_->at(ic);
arma::fmat&output_channel=output_data->at(ic);
for(uint32_tr=0;r< input_h - kernel_h + 1; r += stride_h) {
        for (uint32_t c = 0; c < input_w - kernel_w + 1; c += stride_w) {
          const arma::fmat ®ion = input_channel.submat(r, c, r + kernel_h - 1, c + kernel_w - 1);
          output_channel.at(int(r / stride_h), int(c / stride_w)) = region.max();
        }
      }
    }
    outputs.push_back(output_data);
  }
}

std::shared_ptrMaxPoolingLayer::CreateInstance(conststd::shared_ptr&op){
CHECK(op->op_type_==OpType::kOperatorMaxPooling);
std::shared_ptrmax_layer=std::make_sh了ared(op);
returnmax_layer;
}

LayerRegistererWrapperkMaxPoolingLayer(OpType::kOperatorMaxPooling,MaxPoolingLayer::CreateInstance);

voidMaxPoolingLayer::Forwards(conststd::vector>>&inputs,
std::vector>>&outputs){
CHECK(this->op_!=nullptr);
CHECK(this->op_->op_type_==OpType::kOperatorMaxPooling);
CHECK(!inputs.empty());
}

我们重点来看Forwards函数, 首先判断输入是否为空并获得池化操作相关的属性值(原本存放在op中).

计算池化后的输出特征图大小, 公式为：

for(uint32_ti=0;i< batch_size; ++i) {
    const std::shared_ptr>&input_data_=inputs.at(i)->Clone();
input_data_->Padding({padding_h,padding_h,padding_w,padding_w},std::numeric_limits::lowest());

如上的过程表示对输入的特征图四周进行填充，填充的大小由于padding_w和padding_h决定。这两个Layer计算时候的属性由op中得到，也就是说padding_w和padding_h存放在this->op中， this->op_ = std::make_unique(*max_pooling_op);

for(uint32_ti=0;i< batch_size; ++i) {
    const std::shared_ptr>&input_data_=inputs.at(i)->Clone();
input_data_->Padding({padding_h,padding_h,padding_w,padding_w},std::numeric_limits::lowest());
constuint32_tinput_h=input_data_->rows();
constuint32_tinput_w=input_data_->cols();
constuint32_tinput_c=input_data_->channels();
constuint32_toutput_c=input_c;

constuint32_toutput_h=uint32_t(std::floor((input_h-kernel_h)/stride_h+1));
constuint32_toutput_w=uint32_t(std::floor((input_w-kernel_w)/stride_w+1));
CHECK(output_w>0&&output_h>0);

如上的过程表示根据输入的特征图大小input_h和input_w来计算对应的输出特征值大小output_h和output_w. 计算的公式如上文所示。如果输入的特征数据input_data_有填充，则根据填充数据的输入大小来计算对应的输出大小。

for(uint32_ti=0;i< batch_size; ++i) {
  ...
    for (uint32_t ic = 0; ic < input_c; ++ic) {
      const arma::fmat &input_channel = input_data_->at(ic);
arma::fmat&output_channel=output_data->at(ic);
for(uint32_tr=0;r< input_h - kernel_h + 1; r += stride_h) {
        for (uint32_t c = 0; c < input_w - kernel_w + 1; c += stride_w) {
          const arma::fmat ®ion = input_channel.submat(r, c, r + kernel_h - 1, c + kernel_w - 1);
          output_channel.at(int(r / stride_h), int(c / stride_w)) = region.max();
        }
      }
    }
}

for(uint32_t ic =0; ic < input_c;++ic) 表示对输入的特征图进行逐通道的池化操作, 设当前进行操作的输入特征图通道为input_channel, 池化后的输出特征图放置于output_channel中。池化的过程如下公式所描述：

在上述的代码中region表示当前输入特征数据需要进行池化的部分，对应于公式中[r:r+kernel height -1,c:c+kernel width -1]

中的数据。输入特征的数据是逐个通道进行处理（池化操作）的，从ic = 0到ic = input_channel - 1, 当前池化的数据保存在region中。

input_channel.submat(r, c, r + kernel_h -1, c + kernel_w -1)取得一个池化区域内的所有元素，随后使用region.max()取得区域内(kernel_h和kernel_w组成的范围)的最大值, 并且每次区域移动的位置是stride_h和stride_w, 取得最大值后存放在输出特征图中对应的位置中，输出存放的位置为输出特征图outut_channel的(int(r/stride_h),int(c/stride_w))的位置中。这部分可能描述地比较晦涩，请结合视频一起食用。

Max Pooling Layer的其他部分

MaxPoolingLayer::MaxPoolingLayer(conststd::shared_ptr&op):Layer("maxpooling"){
CHECK(op->op_type_==OpType::kOperatorMaxPooling)<< "Operator has a wrong type: " << int(op->op_type_);
MaxPoolingOp*max_pooling_op=dynamic_cast(op.get());

CHECK(max_pooling_op!=nullptr)<< "MaxPooling operator is empty";
  this->op_=std::make_unique(*max_pooling_op);
}

LayerRegistererWrapperkMaxPoolingLayer(OpType::kOperatorMaxPooling,MaxPoolingLayer::CreateInstance);

以上的步骤完成了Max Pooling层的注册, 具体流程已经在第五节中讲过。MaxPoolingLayer::MaxPoolingLayer初始化部分根据传入的op对this->op_进行赋值，this->op_中保存了stride,padding,pooling等计算时需要的属性信息。

单元测试

TEST(test_layer,forward_maxpooling1){
usingnamespacekuiper_infer;
uint32_tstride_h=1;
uint32_tstride_w=1;
uint32_tpadding_h=0;
uint32_tpadding_w=0;
uint32_tpooling_h=2;
uint32_tpooling_w=2;

std::shared_ptr
max_op=std::make_shared(pooling_h,pooling_w,stride_h,stride_w,padding_h,padding_w);
std::shared_ptrmax_layer=LayerRegisterer::CreateLayer(max_op);
CHECK(max_layer!=nullptr);

arma::fmatinput_data="012;"
"345;"
"678;";
std::shared_ptr>input=std::make_shared>(2,input_data.n_rows,input_data.n_cols);
input->at(0)=input_data;
input->at(1)=input_data;

std::vector>>inputs;
std::vector>>outputs;
inputs.push_back(input);

max_layer->Forwards(inputs,outputs);
ASSERT_EQ(outputs.size(),1);
constauto&output=outputs.at(0);
LOG(INFO)<< "
" << output->data();
ASSERT_EQ(output->rows(),2);
ASSERT_EQ(output->cols(),2);

ASSERT_EQ(output->at(0,0,0),4);
ASSERT_EQ(output->at(0,0,1),5);
ASSERT_EQ(output->at(0,1,0),7);
ASSERT_EQ(output->at(0,1,1),8);

ASSERT_EQ(output->at(1,0,0),4);
ASSERT_EQ(output->at(1,0,1),5);
ASSERT_EQ(output->at(1,1,0),7);
ASSERT_EQ(output->at(1,1,1),8);
}

可以看到, 我们的输入为 arma::fmat input_data ="0 1 2 ; 3 4 5 ;6 7 8; " , 池化核的大小为2, 每次移动的步长stride =1,所以根据我们在第一节中的计算, 最后的输出特征图大小应该是2乘2大小, 池化得到的值分别为4 5 7 8.