MobileNet DepthwiseConvolution、ShuffleNet shuffle channel、CenterLoss在Caffe下实现
针对Caffe下特殊操作实现
- MobileNet-DepthwiseConvolution在Caffe下实现
- 实现步骤
- 源码：
- depthwise_conv_layer.hpp
- depthwise_conv_layer.cpp
- depthwise_conv_layer.cu
- ShuffleNet通道混洗操作（shuffle channel）在Caffe下的实现
- 实现步骤
- 源码
- shuffle_channel_layer.hpp
- shuffle_channel_layer.cpp
- shuffle_channel_layer.cu
- 损失函数CenterLoss在Caffe下的实现
- 实现步骤
- 源码
- center_loss_layer.hpp
- center_loss_layer.cpp
- center_loss_layer.cu
本篇博客主要讲解Caffe下一些特殊操作的实现，主要涉及MobileNet深度可分离卷积操作的实现、ShuffleNet的通道混洗操作、CenterLoss损失函数的实现
系统：Linux-Ubuntu
MobileNet-DepthwiseConvolution在Caffe下实现
我用的是Github上shicai的源码，可在以下链接进行下载：Github上DepthwiseConvolution实现源码下载
深度可分离卷积操作即（DepthwiseConvolution）的实现不需要对Caffe目录下的/src/caffe/proto/caffe.proto进行修改。
下载链接中的代码后，在目录caffe下有两个文件夹：include和src
在两个文件夹下分别有我们需要的源码：
- include：depthwise_conv_layer.hpp
- src：depthwise_conv_layer.cpp、depthwise_conv_layer.cu
| 文件名字 | 文件用途 |
|---|---|
| depthwise_conv_layer.hpp | 头文件 |
| depthwise_conv_layer.cpp | DepthwiseConvolution的CPU实现 |
| depthwise_conv_layer.cu | DepthwiseConvolution的GPU实现 |
实现步骤
-
我们需要做的操作就是：
将include下的depthwise_conv_layer.hpp放到/caffeMS/include/caffe/layers/目录下
将src下的depthwise_conv_layer.cpp和 depthwise_conv_layer.cu放到/caffeMS/src/caffe/layers/目录下。
然后重新编译Caffe即可。
make all -j8
make test -j8
make runtest -j8
实际使用：
对dw层，即group参数大于1的层，将其type由"Convolution"改为 “DepthwiseConvolution”
layer {
name: "conv2_1/dw"
type: "DepthwiseConvolution"
bottom: "conv1"
top: "conv2_1/dw"
param {
lr_mult: 1.0
decay_mult: 1.0
}
convolution_param {
num_output: 32
bias_term: false
pad: 1
kernel_size: 3
group: 32
stride: 1
weight_filler {
type: "msra"
}
engine: CAFFE
}
}
- 不过，链接中下载的文件“transferTypeToDepthwiseConvolution.py”可以直接完成这个操作
python2 transferTypeToDepthwiseConvolution.py mobilenet_train.prototxt mobilenet_train_dw.prototxt
import caffe.proto.caffe_pb2 as caffe_pb2
from google.protobuf.text_format import Merge
import argparse
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('source_prototxt')
parser.add_argument('target_prototxt')
args = parser.parse_args()
net = caffe_pb2.NetParameter()
Merge(open(args.source_prototxt, 'r').read(), net)
for layer in net.layer:
if layer.type == "Convolution":
if layer.convolution_param.group !=1:
layer.type = "DepthwiseConvolution"
with open(args.target_prototxt, 'w') as tf:
tf.write(str(net))
源码：
depthwise_conv_layer.hpp
/*
* depthwise_conv_layer.hpp
*
* Created on: May 23, 2017
* Author: liuhao
*/
#ifndef CAFFE_DEPTHWISE_CONV_LAYER_HPP_
#define CAFFE_DEPTHWISE_CONV_LAYER_HPP_
#include depthwise_conv_layer.cpp
#include depthwise_conv_layer.cu
#include
template <typename Dtype>
__global__ void ConvBackwardWeight(const int nthreads,
const Dtype* const top_diff,
const int num, const int channels, const int height,
const int width, const int conved_height, const int conved_width,
const int kernel_h, const int kernel_w, const int stride_h,
const int stride_w, const int pad_h, const int pad_w,
Dtype* const weight_diff,
const Dtype* const bottom_data) {
CUDA_KERNEL_LOOP(index, nthreads) {
const int kw=index % kernel_w;
const int kh= (index /kernel_w)%kernel_h;
const int c=index /kernel_w/kernel_h;
// if (index==5) {
// printf("kh%d kw%d kc%d\n",kh,kw,c);
// }
Dtype gradient = 0;
for( int n=0;n<num;n++) {
const Dtype* const top_diff_slice = top_diff + (n * channels + c) * conved_height * conved_width;
const Dtype* const bottom_data_slice = bottom_data + (n * channels + c) * height * width;
const int phstart=max(DIVIDE_CEIL((pad_h-kh),stride_h),0);
const int phend=min(DIVIDE_CEIL((height+pad_h-kh),stride_h),conved_height);
const int pwstart=max(DIVIDE_CEIL((pad_w-kw),stride_w),0);
const int pwend=min(DIVIDE_CEIL((width+pad_w-kw),stride_w),conved_width);
// if (index==5) {
// printf("phstart%d phend%d pwstart%d pwend%d \n",phstart,phend,pwstart,pwend);
// }
//
for(int ph=phstart;ph<phend;ph++){
for (int pw=pwstart;pw<pwend;pw++){
const int h=ph*stride_h+kh-pad_h;
const int w=pw*stride_w+kw-pad_w;
gradient+=top_diff_slice[ph * conved_width + pw]*bottom_data_slice[h*width+w];
// if (index==5) {
// printf("n%d h%d w%d ph%d pw%d topdiff%f bottomdata%f\n",n,h,w,ph,pw,top_diff_slice[ph * conved_width + pw],bottom_data_slice[h*width+w]);
// // printf("phstart%d phend%d pwstart%d pwend%d \n",phstart,phend,pwstart,pwend);
// }
}
}
}
weight_diff[c * kernel_h * kernel_w+kh*kernel_w+kw]+=gradient;
}
}
template <typename Dtype>
__global__ void ConvBackwardBias(const int nthreads,
const Dtype* const top_diff,
const int num, const int channels, const int height,
const int width, const int conved_height, const int conved_width,
const int kernel_h, const int kernel_w, const int stride_h,
const int stride_w, const int pad_h, const int pad_w,
Dtype* const bias_diff) {
CUDA_KERNEL_LOOP(index, nthreads) {
const int c = index;
Dtype gradient=0;
for( int n=0;n<num;n++) {
const Dtype* const top_diff_slice =
top_diff + (n * channels + c) * conved_height * conved_width;
for(int ph=0;ph<conved_height;ph++) {
for (int pw=0;pw<conved_width;pw++) {
gradient+=top_diff_slice[ph * conved_width + pw];
}
}
}
bias_diff[c]+=gradient;
}
}
template<typename Dtype>
void DepthwiseConvolutionLayer<Dtype>::Backward_gpu(
const vector<Blob<Dtype>*>& top, const vector<bool>& propagate_down,
const vector<Blob<Dtype>*>& bottom) {
int* kernel_shape_data = this->kernel_shape_.mutable_cpu_data();
int* stride_data = this->stride_.mutable_cpu_data();
int* pad_data = this->pad_.mutable_cpu_data();
const Dtype* weight = this->blobs_[0]->gpu_data();
Dtype* weight_diff = this->blobs_[0]->mutable_gpu_diff();
const bool bias_term_ = this->bias_term_;
Dtype* bias_diff = bias_term_ ? this->blobs_[1]->mutable_gpu_diff() : 0;
const bool bias_propagate_down_ = this->param_propagate_down_[1];
const bool weight_propagate_down_ = this->param_propagate_down_[0];
const int kernel_h_ = kernel_shape_data[0];
const int kernel_w_ = kernel_shape_data[1];
const int stride_h_ = stride_data[0];
const int stride_w_ = stride_data[1];
const int pad_h_ = pad_data[0];
const int pad_w_ = pad_data[1];
const int conved_height = this->output_shape_[0];
const int conved_weight = this->output_shape_[1];
// CHECK_EQ(stride_h_, 1)
// << "The backward of the net whose stride is bigger than 1 is not implemented now. ";
// CHECK_EQ(stride_w_, 1)
// << "The backward of the net whose stride is bigger than 1 is not implemented now. ";
for (int i = 0; i < top.size(); ++i) {
const Dtype* top_diff = top[i]->gpu_diff();
const Dtype* bottom_data = bottom[i]->gpu_data();
Dtype* bottom_diff = bottom[i]->mutable_gpu_diff();
vector<int> shape_ = bottom[i]->shape();
const int channels_ = shape_[1];
const int height_ = shape_[2];
const int width_ = shape_[3];
// Bias gradient, if necessary.
if (bias_term_ && bias_propagate_down_) {
const int count_bias = channels_;
ConvBackwardBias<Dtype><<<CAFFE_GET_BLOCKS(count_bias), CAFFE_CUDA_NUM_THREADS>>>(
count_bias, top_diff, bottom[i]->num(), channels_,
height_, width_,conved_height,conved_weight,kernel_h_,
kernel_w_, stride_h_, stride_w_, pad_h_, pad_w_,
bias_diff);
}
// gradient w.r.t. weight. Note that we will accumulate diffs.
if (weight_propagate_down_) {
const int count_weight = channels_ * kernel_h_ * kernel_w_;
ConvBackwardWeight<Dtype><<<CAFFE_GET_BLOCKS(count_weight), CAFFE_CUDA_NUM_THREADS>>>(
count_weight, top_diff, bottom[i]->num(), channels_,
height_, width_,conved_height,conved_weight,kernel_h_,
kernel_w_, stride_h_, stride_w_, pad_h_, pad_w_,
weight_diff,
bottom_data);
}
// gradient w.r.t. bottom data, if necessary.
if (propagate_down[i]) {
const int count_bottom=bottom[i]->count();
ConvBackward<Dtype><<<CAFFE_GET_BLOCKS(count_bottom), CAFFE_CUDA_NUM_THREADS>>>(
count_bottom, top_diff, bottom[i]->num(), channels_,
height_, width_,conved_height,conved_weight,kernel_h_,
kernel_w_, stride_h_, stride_w_, pad_h_, pad_w_,
bottom_diff,
weight);
}
}
}
INSTANTIATE_LAYER_GPU_FUNCS (DepthwiseConvolutionLayer);
} // namespace caffe
ShuffleNet通道混洗操作（shuffle channel）在Caffe下的实现
我用的是Github上farmingyard的源码，可在以下链接下载： Github上shuffle channel实现源码
和DepthwiseConvolution的实现差不太多，唯一不同的是需要对Caffe目录下的/src/caffe/proto/caffe.proto文件进行修改。
- 还是三个文件：
| 文件名字 | 文件用途 |
|---|---|
| shuffle_channel_layer.hpp | 头文件 |
| shuffle_channel_layer.cpp | shuffle channel的CPU实现 |
| shuffle_channel_layer.cu | shuffle channel的GPU实现 |
实现步骤
-
我们需要做的操作：
将shuffle_channel_layer.hpp放到/caffeMS/include/caffe/layers/目录下
将shuffle_channel_layer.cpp和 shuffle_channel_layer.cu放到/caffeMS/src/caffe/layers/目录下。
修改/caffeMS/src/caffe/proto/caffe.proto文件：
大概是在420行左右，在message LayerParameter中添加一行代码如下，注意164可以随意取，但是不能和其他已有操作的数值一样
message LayerParameter {
...
optional ShuffleChannelParameter shuffle_channel_param = 164;
...
}
在文件最后添加：
message ShuffleChannelParameter {
optional uint32 group = 1[default = 1]; // The number of group
}
然后重新编译Caffe即可。
make all -j8
make test -j8
make runtest -j8
源码
shuffle_channel_layer.hpp
#ifndef CAFFE_SHUFFLE_CHANNEL_LAYER_HPP_
#define CAFFE_SHUFFLE_CHANNEL_LAYER_HPP_
#include temp_blob_;
int group_;
};
} // namespace caffe
#endif // CAFFE_SHUFFLE_CHANNEL_LAYER_HPP_
shuffle_channel_layer.cpp
#include shuffle_channel_layer.cu
#include 损失函数CenterLoss在Caffe下的实现
CenterLoss主要用在人脸识别上，某个网络需要用到，所以我学习了下怎么使用。我用的是Github上ydwen的官方源码，可在以下链接下载： Github上CenterLoss实现源码
和shuffle channel实现一样，同样也需要对/caffeMS/src/caffe/proto/caffe.proto文件进行修改。
- 三个文件：
| 文件名字 | 文件用途 |
|---|---|
| center_loss_layer.hpp | 头文件 |
| center_loss_layer.cpp | CenterLoss的CPU实现 |
| center_loss_layer.cu | CenterLoss的GPU实现 |
实现步骤
-
我们需要做的操作：
将center_loss_layer.hpp放到/caffeMS/include/caffe/layers/目录下
将center_loss_layer.cpp和 center_loss_layer.cu放到/caffeMS/src/caffe/layers/目录下。
修改/caffeMS/src/caffe/proto/caffe.proto文件：
大概是在420行左右，在message LayerParameter中添加一行代码如下，注意147可以随意取，但是不能和其他已有操作的数值一样
message LayerParameter {
...
optional CenterLossParameter center_loss_param = 147;
...
}
在文件最后添加：
message CenterLossParameter {
optional uint32 num_output = 1; // The number of outputs for the layer
optional FillerParameter center_filler = 2; // The filler for the centers
// The first axis to be lumped into a single inner product computation;
// all preceding axes are retained in the output.
// May be negative to index from the end (e.g., -1 for the last axis).
optional int32 axis = 3 [default = 1];
}
然后重新编译Caffe即可。
make all -j8
make test -j8
make runtest -j8
源码
center_loss_layer.hpp
#ifndef CAFFE_CENTER_LOSS_LAYER_HPP_
#define CAFFE_CENTER_LOSS_LAYER_HPP_
#include center_loss_layer.cpp
#include center_loss_layer.cu
#include Caffe下关于DepthwiseConvolution、shuffle channel、CenterLoss的实现至此已介绍完毕。
希望能帮到大家。谢谢
2019.7.12