Caffe中Interp层的使用
最近实验当中借鉴了FPN网络，由于FPN网络对图片shape有要求，采用了两种方式，其一是在data_layer.cpp中，对原图进行padding操作；其二是需要对特征图进行类似crop操作，使得两者进行eltwise操作的时候shape是一致的。
简单说一下添加padding的操作，在data_layer.cpp的DataSetup()和load_batch()函数中添加：
1 //cv_img是读入的原图像，ext_img是填充pad的图像 2 //extRows，extCols是填充的行和列，具体可查opencv中的copyMakeBorder用法 3 copyMakeBorder(cv_img,ext_img,0,extRows,0,extCols,BORDER_CONSTANT);
下面介绍第二种Interp插值操作：
第一步：添加相应的代码，主要代码来源于：https://github.com/hszhao/PSPNet
1.在PSPNet/include/cafffe/layers/interp_layer.hpp添加代码，代码如下：
1 #ifndef CAFFE_INTERP_LAYER_HPP_
2 #define CAFFE_INTERP_LAYER_HPP_
3
4 #include <vector>
5
6 #include "caffe/blob.hpp"
7 #include "caffe/layer.hpp"
8 #include "caffe/proto/caffe.pb.h"
9
10 namespace caffe {
11 /**
12 * @brief Changes the spatial resolution by bi-linear interpolation.
13 * The target size is specified in terms of pixels.
14 * The start and end pixels of the input are mapped to the start
15 * and end pixels of the output.
16 */
17 template <typename Dtype>
18 class InterpLayer : public Layer<Dtype> {
19 public:
20 explicit InterpLayer(const LayerParameter& param)
21 : Layer<Dtype>(param) {}
22 virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
23 const vector<Blob<Dtype>*>& top);
24 virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
25 const vector<Blob<Dtype>*>& top);
26
27 virtual inline const char* type() const { return "Interp"; }
28 virtual inline int ExactNumBottomBlobs() const { return 1; } //此处可以根据需求修改Interp层的输入个数，默认是1；下同
29 virtual inline int ExactNumTopBlobs() const { return 1; }
30
31 protected:
32 virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
33 const vector<Blob<Dtype>*>& top);
34 virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
35 const vector<Blob<Dtype>*>& top);
36 virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
37 const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);
38 virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
39 const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);
40
41 int num_, channels_;
42 int height_in_, width_in_;
43 int height_out_, width_out_;
44 int pad_beg_, pad_end_;
45 int height_in_eff_, width_in_eff_;
46 };
47
48 } // namespace caffe
49
50 #endif // CAFFE_CONV_LAYER_HPP_2.在PSPNet/include/caffe/util/interp.hpp中添加代码，代码如下：
1 #ifndef CAFFE_UTIL_INTERP_H_
2 #define CAFFE_UTIL_INTERP_H_
3
4 #include <cublas_v2.h>
5 #include "caffe/proto/caffe.pb.h"
6
7 namespace caffe {
8
9 // Bi-linear interpolation
10 // IN : [channels height1 width1] cropped from a bigger [Height1 Width1] image
11 // OUT: [channels height2 width2] cropped from a bigger [Height2 Width2] image
12
13 template <typename Dtype, bool packed>
14 void caffe_cpu_interp2(const int channels,
15 const Dtype *data1, const int x1, const int y1, const int height1, const int width1, const int Height1, const int Width1,
16 Dtype *data2, const int x2, const int y2, const int height2, const int width2, const int Height2, const int Width2);
17
18 template <typename Dtype, bool packed>
19 void caffe_gpu_interp2(const int channels,
20 const Dtype *data1, const int x1, const int y1, const int height1, const int width1, const int Height1, const int Width1,
21 Dtype *data2, const int x2, const int y2, const int height2, const int width2, const int Height2, const int Width2);
22
23 // Backward (adjoint) operation
24 template <typename Dtype, bool packed>
25 void caffe_cpu_interp2_backward(const int channels,
26 Dtype *data1, const int x1, const int y1, const int height1, const int width1, const int Height1, const int Width1,
27 const Dtype *data2, const int x2, const int y2, const int height2, const int width2, const int Height2, const int Width2);
28
29 template <typename Dtype, bool packed>
30 void caffe_gpu_interp2_backward(const int channels,
31 Dtype *data1, const int x1, const int y1, const int height1, const int width1, const int Height1, const int Width1,
32 const Dtype *data2, const int x2, const int y2, const int height2, const int width2, const int Height2, const int Width2);
33
34 // Create Gaussian pyramid of an image. Assume output space is pre-allocated.
35 // IN : [channels height width]
36 template <typename Dtype, bool packed>
37 void caffe_cpu_pyramid2(const int channels,
38 const Dtype *data, const int height, const int width,
39 Dtype *data_pyr, const int levels);
40
41 template <typename Dtype, bool packed>
42 void caffe_gpu_pyramid2(const int channels,
43 const Dtype *data, const int height, const int width,
44 Dtype *data_pyr, const int levels);
45
46 /*
47 template <typename Dtype, bool packed>
48 void caffe_cpu_mosaic(const int channels,
49 const Dtype *data1, const MosaicParameter mosaic_params1,
50 const Dtype *data_pyr, const int levels,
51 Dtype *data2, const MosaicParameter mosaic_params2);
52 template <typename Dtype, bool packed>
53 void caffe_gpu_mosaic(const int channels,
54 const Dtype *data1, const MosaicParameter mosaic_params1,
55 const Dtype *data_pyr, const int levels,
56 Dtype *data2, const MosaicParameter mosaic_params2);
57 */
58
59 } // namespace caffe
60
61 #endif3.在PSPNet/include/caffe/common.cuh 添加代码，代码如下：
1 #ifndef CAFFE_COMMON_CUH_
2 #define CAFFE_COMMON_CUH_
3
4 #include <cuda.h>
5
6 #if !defined(__CUDA_ARCH__) || __CUDA_ARCH__ >= 600 //注意标红需要添加，不然会报错（根据自己服务器CUDA配置需求添加）
7
8 #else
9 // CUDA: atomicAdd is not defined for doubles
10 static __inline__ __device__ double atomicAdd(double *address, double val) {
11 unsigned long long int* address_as_ull = (unsigned long long int*)address;
12 unsigned long long int old = *address_as_ull, assumed;
13 if (val==0.0)
14 return __longlong_as_double(old);
15 do {
16 assumed = old;
17 old = atomicCAS(address_as_ull, assumed, __double_as_longlong(val +__longlong_as_double(assumed)));
18 } while (assumed != old);
19 return __longlong_as_double(old);
20 }
21
22 #endif
23 #endif4.在PSPNet/src/caffe/layers/interp_layer.cpp 下添加代码，代码如下：
1 #include <vector>
2
3 #include "caffe/layer.hpp"
4 #include "caffe/util/math_functions.hpp"
5 #include "caffe/util/interp.hpp"
6 #include "caffe/layers/interp_layer.hpp"
7
8 namespace caffe {
9
10 template <typename Dtype>
11 void InterpLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
12 const vector<Blob<Dtype>*>& top) {
13 InterpParameter interp_param = this->layer_param_.interp_param();
14 pad_beg_ = interp_param.pad_beg();
15 pad_end_ = interp_param.pad_end();
16 CHECK_LE(pad_beg_, 0) << "Only supports non-pos padding (cropping) for now";
17 CHECK_LE(pad_end_, 0) << "Only supports non-pos padding (cropping) for now";
18 }
19
20 template <typename Dtype>
21 void InterpLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,
22 const vector<Blob<Dtype>*>& top) {
23 num_ = bottom[0]->num();
24 channels_ = bottom[0]->channels();
25 height_in_ = bottom[0]->height();
26 width_in_ = bottom[0]->width();
27 height_in_eff_ = height_in_ + pad_beg_ + pad_end_;
28 width_in_eff_ = width_in_ + pad_beg_ + pad_end_;
29 InterpParameter interp_param = this->layer_param_.interp_param();
30 if (interp_param.has_shrink_factor() &&
31 !interp_param.has_zoom_factor()) {
32 const int shrink_factor = interp_param.shrink_factor();
33 CHECK_GE(shrink_factor, 1) << "Shrink factor must be positive";
34 height_out_ = (height_in_eff_ - 1) / shrink_factor + 1;
35 width_out_ = (width_in_eff_ - 1) / shrink_factor + 1;
36 } else if (interp_param.has_zoom_factor() &&
37 !interp_param.has_shrink_factor()) {
38 const int zoom_factor = interp_param.zoom_factor();
39 CHECK_GE(zoom_factor, 1) << "Zoom factor must be positive";
40 height_out_ = height_in_eff_ + (height_in_eff_ - 1) * (zoom_factor - 1);
41 width_out_ = width_in_eff_ + (width_in_eff_ - 1) * (zoom_factor - 1);
42 } else if (interp_param.has_height() && interp_param.has_width()) {
43 height_out_ = interp_param.height();
44 width_out_ = interp_param.width();
45 } else if (interp_param.has_shrink_factor() &&
46 interp_param.has_zoom_factor()) {
47 const int shrink_factor = interp_param.shrink_factor();
48 const int zoom_factor = interp_param.zoom_factor();
49 CHECK_GE(shrink_factor, 1) << "Shrink factor must be positive";
50 CHECK_GE(zoom_factor, 1) << "Zoom factor must be positive";
51 height_out_ = (height_in_eff_ - 1) / shrink_factor + 1;
52 width_out_ = (width_in_eff_ - 1) / shrink_factor + 1;
53 height_out_ = height_out_ + (height_out_ - 1) * (zoom_factor - 1);
54 width_out_ = width_out_ + (width_out_ - 1) * (zoom_factor - 1);
55 } else {
56 LOG(FATAL);
57 }
58 CHECK_GT(height_in_eff_, 0) << "height should be positive";
59 CHECK_GT(width_in_eff_, 0) << "width should be positive";
60 CHECK_GT(height_out_, 0) << "height should be positive";
61 CHECK_GT(width_out_, 0) << "width should be positive";
62 top[0]->Reshape(num_, channels_, height_out_, width_out_);
63 }
64
65 template <typename Dtype>
66 void InterpLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
67 const vector<Blob<Dtype>*>& top) {
68 caffe_cpu_interp2<Dtype,false>(num_ * channels_,
69 bottom[0]->cpu_data(), - pad_beg_, - pad_beg_, height_in_eff_, width_in_eff_, height_in_, width_in_,
70 top[0]->mutable_cpu_data(), 0, 0, height_out_, width_out_, height_out_, width_out_);
71 }
72
73 template <typename Dtype>
74 void InterpLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
75 const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
76 if (!propagate_down[0]) { return; }
77 caffe_set(bottom[0]->count(), Dtype(0), bottom[0]->mutable_cpu_diff());
78 caffe_cpu_interp2_backward<Dtype,false>(num_ * channels_,
79 bottom[0]->mutable_cpu_diff(), - pad_beg_, - pad_beg_, height_in_eff_, width_in_eff_, height_in_, width_in_,
80 top[0]->cpu_diff(), 0, 0, height_out_, width_out_, height_out_, width_out_);
81 }
82
83 #ifndef CPU_ONLY
84 template <typename Dtype>
85 void InterpLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
86 const vector<Blob<Dtype>*>& top) {
87 caffe_gpu_interp2<Dtype,false>(num_ * channels_,
88 bottom[0]->gpu_data(), - pad_beg_, - pad_beg_, height_in_eff_, width_in_eff_, height_in_, width_in_,
89 top[0]->mutable_gpu_data(), 0, 0, height_out_, width_out_, height_out_, width_out_);
90 }
91
92 template <typename Dtype>
93 void InterpLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
94 const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
95 if (!propagate_down[0]) { return; }
96 caffe_gpu_set(bottom[0]->count(), Dtype(0), bottom[0]->mutable_gpu_diff());
97 caffe_gpu_interp2_backward<Dtype,false>(num_ * channels_,
98 bottom[0]->mutable_gpu_diff(), - pad_beg_, - pad_beg_, height_in_eff_, width_in_eff_, height_in_, width_in_,
99 top[0]->gpu_diff(), 0, 0, height_out_, width_out_, height_out_, width_out_);
100 }
101 #endif
102
103 #ifdef CPU_ONLY
104 STUB_GPU(InterpLayer);
105 #endif
106
107 INSTANTIATE_CLASS(InterpLayer);
108 REGISTER_LAYER_CLASS(Interp);
109
110 } // namespace caffe4.在PSPNet/src/caffe/util/interp.cpp中添加代码，代码如下：
1 #include "caffe/common.hpp"
2 #include "caffe/util/interp.hpp"
3 #include <algorithm>
4 #include <cmath>
5
6 namespace caffe {
7
8 // Bi-linear interpolation
9 // IN : [channels height1 width1] cropped from a bigger [Height1 Width1] image
10 // OUT: [channels height2 width2] cropped from a bigger [Height2 Width2] image
11 template <typename Dtype, bool packed>
12 void caffe_cpu_interp2(const int channels,
13 const Dtype *data1, const int x1, const int y1, const int height1, const int width1, const int Height1, const int Width1,
14 Dtype *data2, const int x2, const int y2, const int height2, const int width2, const int Height2, const int Width2) {
15 CHECK(x1 >= 0 && y1 >= 0 && height1 > 0 && width1 > 0 && x2 >= 0 && y2 >= 0 && height2 > 0 && width2 > 0);
16 CHECK(Width1 >= width1 + x1 && Height1 >= height1 + y1 && Width2 >= width2 + x2 && Height2 >= height2 + y2);
17 // special case: just copy
18 if (height1 == height2 && width1 == width2) {
19 for (int h2 = 0; h2 < height2; ++h2) {
20 const int h1 = h2;
21 for (int w2 = 0; w2 < width2; ++w2) {
22 const int w1 = w2;
23 if (packed) {
24 const Dtype* pos1 = &data1[channels * ((y1 + h1) * Width1 + (x1 + w1))];
25 Dtype* pos2 = &data2[channels * ((y2 + h2) * Width2 + (x2 + w2))];
26 for (int c = 0; c < channels; ++c) {
27 pos2[0] = pos1[0];
28 pos1++;
29 pos2++;
30 }
31 }
32 else {
33 const Dtype* pos1 = &data1[(y1 + h1) * Width1 + (x1 + w1)];
34 Dtype* pos2 = &data2[(y2 + h2) * Width2 + (x2 + w2)];
35 for (int c = 0; c < channels; ++c) {
36 pos2[0] = pos1[0];
37 pos1 += Width1 * Height1;
38 pos2 += Width2 * Height2;
39 }
40 }
41 }
42 }
43 return;
44 }
45 const float rheight = (height2 > 1) ? static_cast<float>(height1 - 1) / (height2 - 1) : 0.f;
46 const float rwidth = (width2 > 1) ? static_cast<float>(width1 - 1) / (width2 - 1) : 0.f;
47 for (int h2 = 0; h2 < height2; ++h2) {
48 const float h1r = rheight * h2;
49 const int h1 = h1r;
50 const int h1p = (h1 < height1 - 1) ? 1 : 0;
51 const Dtype h1lambda = h1r - h1;
52 const Dtype h0lambda = Dtype(1.) - h1lambda;
53 for (int w2 = 0; w2 < width2; ++w2) {
54 const float w1r = rwidth * w2;
55 const int w1 = w1r;
56 const int w1p = (w1 < width1 - 1) ? 1 : 0;
57 const Dtype w1lambda = w1r - w1;
58 const Dtype w0lambda = Dtype(1.) - w1lambda;
59 if (packed) {
60 const Dtype* pos1 = &data1[channels * ((y1 + h1) * Width1 + (x1 + w1))];
61 Dtype* pos2 = &data2[channels * ((y2 + h2) * Width2 + (x2 + w2))];
62 for (int c = 0; c < channels; ++c) {
63 pos2[0] =
64 h0lambda * (w0lambda * pos1[0] + w1lambda * pos1[channels * w1p]) +
65 h1lambda * (w0lambda * pos1[channels * h1p * Width1] + w1lambda * pos1[channels * (h1p * Width1 + w1p)]);
66 pos1++;
67 pos2++;
68 }
69 }
70 else {
71 const Dtype* pos1 = &data1[(y1 + h1) * Width1 + (x1 + w1)];
72 Dtype* pos2 = &data2[(y2 + h2) * Width2 + (x2 + w2)];
73 for (int c = 0; c < channels; ++c) {
74 pos2[0] =
75 h0lambda * (w0lambda * pos1[0] + w1lambda * pos1[w1p]) +
76 h1lambda * (w0lambda * pos1[h1p * Width1] + w1lambda * pos1[h1p * Width1 + w1p]);
77 pos1 += Width1 * Height1;
78 pos2 += Width2 * Height2;
79 }
80 }
81 }
82 }
83 }
84
85
86 // Backward (adjoint) operation 1 <- 2 (accumulates)
87 template <typename Dtype, bool packed>
88 void caffe_cpu_interp2_backward(const int channels,
89 Dtype *data1, const int x1, const int y1, const int height1, const int width1, const int Height1, const int Width1,
90 const Dtype *data2, const int x2, const int y2, const int height2, const int width2, const int Height2, const int Width2) {
91 CHECK(x1 >= 0 && y1 >= 0 && height1 > 0 && width1 > 0 && x2 >= 0 && y2 >= 0 && height2 > 0 && width2 > 0);
92 CHECK(Width1 >= width1 + x1 && Height1 >= height1 + y1 && Width2 >= width2 + x2 && Height2 >= height2 + y2);
93 // special case: same-size matching grids
94 if (height1 == height2 && width1 == width2) {
95 for (int h2 = 0; h2 < height2; ++h2) {
96 const int h1 = h2;
97 for (int w2 = 0; w2 < width2; ++w2) {
98 const int w1 = w2;
99 if (packed) {
100 Dtype* pos1 = &data1[channels * ((y1 + h1) * Width1 + (x1 + w1))];
101 const Dtype* pos2 = &data2[channels * ((y2 + h2) * Width2 + (x2 + w2))];
102 for (int c = 0; c < channels; ++c) {
103 pos1[0] += pos2[0];
104 pos1++;
105 pos2++;
106 }
107 }
108 else {
109 Dtype* pos1 = &data1[(y1 + h1) * Width1 + (x1 + w1)];
110 const Dtype* pos2 = &data2[(y2 + h2) * Width2 + (x2 + w2)];
111 for (int c = 0; c < channels; ++c) {
112 pos1[0] += pos2[0];
113 pos1 += Width1 * Height1;
114 pos2 += Width2 * Height2;
115 }
116 }
117 }
118 }
119 return;
120 }
121 const float rheight = (height2 > 1) ? static_cast<float>(height1 - 1) / (height2 - 1) : 0.f;
122 const float rwidth = (width2 > 1) ? static_cast<float>(width1 - 1) / (width2 - 1) : 0.f;
123 for (int h2 = 0; h2 < height2; ++h2) {
124 const float h1r = rheight * h2;
125 const int h1 = h1r;
126 const int h1p = (h1 < height1 - 1) ? 1 : 0;
127 const Dtype h1lambda = h1r - h1;
128 const Dtype h0lambda = Dtype(1.) - h1lambda;
129 for (int w2 = 0; w2 < width2; ++w2) {
130 const float w1r = rwidth * w2;
131 const int w1 = w1r;
132 const int w1p = (w1 < width1 - 1) ? 1 : 0;
133 const Dtype w1lambda = w1r - w1;
134 const Dtype w0lambda = Dtype(1.) - w1lambda;
135 if (packed) {
136 Dtype* pos1 = &data1[channels * ((y1 + h1) * Width1 + (x1 + w1))];
137 const Dtype* pos2 = &data2[channels * ((y2 + h2) * Width2 + (x2 + w2))];
138 for (int c = 0; c < channels; ++c) {
139 pos1[0] += h0lambda * w0lambda * pos2[0];
140 pos1[channels * w1p] += h0lambda * w1lambda * pos2[0];
141 pos1[channels * h1p * Width1] += h1lambda * w0lambda * pos2[0];
142 pos1[channels * (h1p * Width1 + w1p)] += h1lambda * w1lambda * pos2[0];
143 pos1++;
144 pos2++;
145 }
146 }
147 else {
148 Dtype* pos1 = &data1[(y1 + h1) * Width1 + (x1 + w1)];
149 const Dtype* pos2 = &data2[(y2 + h2) * Width2 + (x2 + w2)];
150 for (int c = 0; c < channels; ++c) {
151 pos1[0] += h0lambda * w0lambda * pos2[0];
152 pos1[w1p] += h0lambda * w1lambda * pos2[0];
153 pos1[h1p * Width1] += h1lambda * w0lambda * pos2[0];
154 pos1[h1p * Width1 + w1p] += h1lambda * w1lambda * pos2[0];
155 pos1 += Width1 * Height1;
156 pos2 += Width2 * Height2;
157 }
158 }
159 }
160 }
161 }
162
163 // Create Gaussian pyramid of an image. Assume output space is pre-allocated.
164 // IN : [channels height width]
165 template <typename Dtype, bool packed>
166 void caffe_cpu_pyramid2(const int channels,
167 const Dtype *data, const int height, const int width,
168 Dtype *data_pyr, const int levels) {
169 CHECK(height > 0 && width > 0 && levels >= 0);
170 int height1 = height, width1 = width;
171 int height2 = height, width2 = width;
172 const Dtype *data1 = data;
173 Dtype *data2 = data_pyr;
174 for (int l = 0; l < levels; ++l) {
175 height2 /= 2;
176 width2 /= 2;
177 if (height2 == 0 || width2 == 0) {
178 break;
179 }
180 for (int h2 = 0; h2 < height2; ++h2) {
181 const int h1 = 2 * h2;
182 for (int w2 = 0; w2 < width2; ++w2) {
183 const int w1 = 2 * w2;
184 if (packed) {
185 const Dtype* pos1 = &data1[channels * (h1 * width1 + w1)];
186 Dtype* pos2 = &data2[channels * (h2 * width2 + w2)];
187 for (int c = 0; c < channels; ++c) {
188 pos2[0] = static_cast<Dtype>(.25) *
189 (pos1[0] + pos1[channels] +
190 pos1[channels * width1] + pos1[channels * (width1 + 1)]);
191 pos1++;
192 pos2++;
193 }
194 }
195 else {
196 const Dtype* pos1 = &data1[h1 * width1 + w1];
197 Dtype* pos2 = &data2[h2 * width2 + w2];
198 for (int c = 0; c < channels; ++c) {
199 pos2[0] = static_cast<Dtype>(.25) *
200 (pos1[0] + pos1[1] +
201 pos1[width1] + pos1[width1 + 1]);
202 pos1 += width1 * height1;
203 pos2 += width2 * height2;
204 }
205 }
206 }
207 }
208 data1 = data2;
209 height1 = height2;
210 width1 = width2;
211 data2 += channels * height2 * width2;
212 }
213 }
214
215 /*
216 template <typename Dtype, bool packed>
217 void caffe_cpu_mosaic(const int channels,
218 const Dtype *data1, const MosaicParameter mosaic_params1,
219 const Dtype *data_pyr, const int levels,
220 Dtype *data2, const MosaicParameter mosaic_params2) {
221 const int num1 = mosaic_params1.rects_size();
222 const int num2 = mosaic_params2.rects_size();
223 CHECK(num1 == num2 || (num1 == 1 && num2 > 1) || (num2 == 1 && num1 > 1));
224 const int num = std::max(num1, num2);
225 for (int i = 0; i < num; ++i) {
226 const Rect rect1 = mosaic_params1.rects((i < num1) ? i : 0);
227 const Rect rect2 = mosaic_params2.rects((i < num2) ? i : 0);
228 int level = log2(sqrt((float)rect1.height() * rect1.width() / rect2.height() / rect2.width()));
229 level = std::max(0, std::min(levels, level));
230 if (data_pyr == 0 || level == 0) {
231 caffe_cpu_interp2<Dtype,packed>(channels,
232 data1, rect1.x(), rect1.y(), rect1.height(), rect1.width(), mosaic_params1.height(), mosaic_params1.width(),
233 data2, rect2.x(), rect2.y(), rect2.height(), rect2.width(), mosaic_params2.height(), mosaic_params2.width());
234 }
235 else {
236 const Dtype *data_pyr_l = data_pyr;
237 int factor = 2;
238 for (int l = 1; l < level; ++l) {
239 data_pyr_l += channels * (mosaic_params1.height() / factor) * (mosaic_params1.width() / factor);
240 factor *= 2;
241 }
242 caffe_cpu_interp2<Dtype,packed>(channels,
243 data_pyr_l, rect1.x() / factor, rect1.y() / factor, rect1.height() / factor, rect1.width() / factor, mosaic_params1.height() / factor, mosaic_params1.width() / factor,
244 data2, rect2.x(), rect2.y(), rect2.height(), rect2.width(), mosaic_params2.height(), mosaic_params2.width());
245 }
246 }
247 }
248 template <typename Dtype, bool packed>
249 void caffe_gpu_mosaic(const int channels,
250 const Dtype *data1, const MosaicParameter mosaic_params1,
251 const Dtype *data_pyr, const int levels,
252 Dtype *data2, const MosaicParameter mosaic_params2) {
253 const int num1 = mosaic_params1.rects_size();
254 const int num2 = mosaic_params2.rects_size();
255 CHECK(num1 == num2 || (num1 == 1 && num2 > 1) || (num2 == 1 && num1 > 1));
256 const int num = std::max(num1, num2);
257 for (int i = 0; i < num; ++i) {
258 const Rect rect1 = mosaic_params1.rects((i < num1) ? i : 0);
259 const Rect rect2 = mosaic_params2.rects((i < num2) ? i : 0);
260 int level = log2(sqrt((float)rect1.height() * rect1.width() / rect2.height() / rect2.width()));
261 level = std::max(0, std::min(levels, level));
262 if (data_pyr == 0 || level == 0) {
263 caffe_gpu_interp2<Dtype,packed>(channels,
264 data1, rect1.x(), rect1.y(), rect1.height(), rect1.width(), mosaic_params1.height(), mosaic_params1.width(),
265 data2, rect2.x(), rect2.y(), rect2.height(), rect2.width(), mosaic_params2.height(), mosaic_params2.width());
266 }
267 else {
268 const Dtype *data_pyr_l = data_pyr;
269 int factor = 2;
270 for (int l = 1; l < level; ++l) {
271 data_pyr_l += channels * (mosaic_params1.height() / factor) * (mosaic_params1.width() / factor);
272 factor *= 2;
273 }
274 caffe_gpu_interp2<Dtype,packed>(channels,
275 data_pyr_l, rect1.x() / factor, rect1.y() / factor, rect1.height() / factor, rect1.width() / factor, mosaic_params1.height() / factor, mosaic_params1.width() / factor,
276 data2, rect2.x(), rect2.y(), rect2.height(), rect2.width(), mosaic_params2.height(), mosaic_params2.width());
277 }
278 }
279 }
280 */
281
282 // Explicit instances
283 template void caffe_cpu_interp2<float,false>(const int, const float *, const int, const int, const int, const int, const int, const int, float *, const int, const int, const int, const int, const int, const int);
284 template void caffe_cpu_interp2<float,true>(const int, const float *, const int, const int, const int, const int, const int, const int, float *, const int, const int, const int, const int, const int, const int);
285 template void caffe_cpu_interp2<double,false>(const int, const double *, const int, const int, const int, const int, const int, const int, double *, const int, const int, const int, const int, const int, const int);
286 template void caffe_cpu_interp2<double,true>(const int, const double *, const int, const int, const int, const int, const int, const int, double *, const int, const int, const int, const int, const int, const int);
287
288 template void caffe_cpu_interp2_backward<float,false>(const int, float *, const int, const int, const int, const int, const int, const int, const float *, const int, const int, const int, const int, const int, const int);
289 template void caffe_cpu_interp2_backward<double,false>(const int, double *, const int, const int, const int, const int, const int, const int, const double *, const int, const int, const int, const int, const int, const int);
290
291 template void caffe_cpu_pyramid2<float,false>(const int, const float *, const int, const int, float *, const int);
292 template void caffe_cpu_pyramid2<float,true>(const int, const float *, const int, const int, float *, const int);
293 template void caffe_cpu_pyramid2<double,false>(const int, const double *, const int, const int, double *, const int);
294 template void caffe_cpu_pyramid2<double,true>(const int, const double *, const int, const int, double *, const int);
295
296 /*
297 template void caffe_cpu_mosaic<float,false>(const int, const float *, const MosaicParameter, const float *, const int, float *, const MosaicParameter);
298 template void caffe_cpu_mosaic<float,true>(const int, const float *, const MosaicParameter, const float *, const int, float *, const MosaicParameter);
299 template void caffe_cpu_mosaic<double,false>(const int, const double *, const MosaicParameter, const double *, const int, double *, const MosaicParameter);
300 template void caffe_cpu_mosaic<double,true>(const int, const double *, const MosaicParameter, const double *, const int, double *, const MosaicParameter);
301 template void caffe_gpu_mosaic<float,false>(const int, const float *, const MosaicParameter, const float *, const int, float *, const MosaicParameter);
302 template void caffe_gpu_mosaic<float,true>(const int, const float *, const MosaicParameter, const float *, const int, float *, const MosaicParameter);
303 template void caffe_gpu_mosaic<double,false>(const int, const double *, const MosaicParameter, const double *, const int, double *, const MosaicParameter);
304 template void caffe_gpu_mosaic<double,true>(const int, const double *, const MosaicParameter, const double *, const int, double *, const MosaicParameter);
305 */
306
307 } // namespace caffe5.在PSPNet/src/caffe/util/interp.cu中添加代码，代码如下：
1 #include "caffe/common.hpp"
2 #include "caffe/common.cuh"
3 #include "caffe/util/interp.hpp"
4
5 namespace caffe {
6
7 // Bi-linear interpolation
8 // IN : [channels height1 width1] cropped from a bigger [Height1 Width1] image
9 // OUT: [channels height2 width2] cropped from a bigger [Height2 Width2] image
10 template <typename Dtype, bool packed>
11 __global__ void caffe_gpu_interp2_kernel(const int n, const float rheight, const float rwidth,
12 const int channels,
13 const Dtype *data1, const int x1, const int y1, const int height1, const int width1, const int Height1, const int Width1,
14 Dtype *data2, const int x2, const int y2, const int height2, const int width2, const int Height2, const int Width2) {
15 int index = threadIdx.x + blockIdx.x * blockDim.x;
16 if (index < n) {
17 const int w2 = index % width2; // 0:width2-1
18 const int h2 = index / width2; // 0:height2-1
19 // special case: just copy
20 if (height1 == height2 && width1 == width2) {
21 const int h1 = h2;
22 const int w1 = w2;
23 if (packed) {
24 const Dtype* pos1 = &data1[channels * ((y1 + h1) * Width1 + (x1 + w1))];
25 Dtype* pos2 = &data2[channels * ((y2 + h2) * Width2 + (x2 + w2))];
26 for (int c = 0; c < channels; ++c) {
27 pos2[0] = pos1[0];
28 pos1++;
29 pos2++;
30 }
31 }
32 else {
33 const Dtype* pos1 = &data1[(y1 + h1) * Width1 + (x1 + w1)];
34 Dtype* pos2 = &data2[(y2 + h2) * Width2 + (x2 + w2)];
35 for (int c = 0; c < channels; ++c) {
36 pos2[0] = pos1[0];
37 pos1 += Width1 * Height1;
38 pos2 += Width2 * Height2;
39 }
40 }
41 return;
42 }
43 //
44 const float h1r = rheight * h2;
45 const int h1 = h1r;
46 const int h1p = (h1 < height1 - 1) ? 1 : 0;
47 const Dtype h1lambda = h1r - h1;
48 const Dtype h0lambda = Dtype(1.) - h1lambda;
49 //
50 const float w1r = rwidth * w2;
51 const int w1 = w1r;
52 const int w1p = (w1 < width1 - 1) ? 1 : 0;
53 const Dtype w1lambda = w1r - w1;
54 const Dtype w0lambda = Dtype(1.) - w1lambda;
55 //
56 if (packed) {
57 const Dtype* pos1 = &data1[channels * ((y1 + h1) * Width1 + (x1 + w1))];
58 Dtype* pos2 = &data2[channels * ((y2 + h2) * Width2 + (x2 + w2))];
59 for (int c = 0; c < channels; ++c) {
60 pos2[0] =
61 h0lambda * (w0lambda * pos1[0] + w1lambda * pos1[channels * w1p]) +
62 h1lambda * (w0lambda * pos1[channels * h1p * Width1] + w1lambda * pos1[channels * (h1p * Width1 + w1p)]);
63 pos1++;
64 pos2++;
65 }
66 }
67 else {
68 const Dtype* pos1 = &data1[(y1 + h1) * Width1 + (x1 + w1)];
69 Dtype* pos2 = &data2[(y2 + h2) * Width2 + (x2 + w2)];
70 for (int c = 0; c < channels; ++c) {
71 pos2[0] =
72 h0lambda * (w0lambda * pos1[0] + w1lambda * pos1[w1p]) +
73 h1lambda * (w0lambda * pos1[h1p * Width1] + w1lambda * pos1[h1p * Width1 + w1p]);
74 pos1 += Width1 * Height1;
75 pos2 += Width2 * Height2;
76 }
77 }
78 }
79 }
80
81 template <typename Dtype, bool packed>
82 void caffe_gpu_interp2(const int channels,
83 const Dtype *data1, const int x1, const int y1, const int height1, const int width1, const int Height1, const int Width1,
84 Dtype *data2, const int x2, const int y2, const int height2, const int width2, const int Height2, const int Width2) {
85 CHECK(x1 >= 0 && y1 >= 0 && height1 > 0 && width1 > 0 && x2 >= 0 && y2 >= 0 && height2 > 0 && width2 > 0);
86 CHECK(Width1 >= width1 + x1 && Height1 >= height1 + y1 && Width2 >= width2 + x2 && Height2 >= height2 + y2);
87 const float rheight = (height2 > 1) ? static_cast<float>(height1 - 1) / (height2 - 1) : 0.f;
88 const float rwidth = (width2 > 1) ? static_cast<float>(width1 - 1) / (width2 - 1) : 0.f;
89 const int num_kernels = height2 * width2;
90 caffe_gpu_interp2_kernel<Dtype,packed><<<CAFFE_GET_BLOCKS(num_kernels), CAFFE_CUDA_NUM_THREADS>>>
91 (num_kernels, rheight, rwidth, channels,
92 data1, x1, y1, height1, width1, Height1, Width1,
93 data2, x2, y2, height2, width2, Height2, Width2);
94 CUDA_POST_KERNEL_CHECK;
95 }
96
97 // Backward (adjoint) operation 1 <- 2 (accumulates)
98 template <typename Dtype, bool packed>
99 __global__ void caffe_gpu_interp2_kernel_backward(const int n, const float rheight, const float rwidth,
100 const int channels,
101 Dtype *data1, const int x1, const int y1, const int height1, const int width1, const int Height1, const int Width1,
102 const Dtype *data2, const int x2, const int y2, const int height2, const int width2, const int Height2, const int Width2) {
103 int index = threadIdx.x + blockIdx.x * blockDim.x;
104 if (index < n) {
105 const int w2 = index % width2; // 0:width2-1
106 const int h2 = index / width2; // 0:height2-1
107 // special case: just copy
108 if (height1 == height2 && width1 == width2) {
109 const int h1 = h2;
110 const int w1 = w2;
111 if (packed) {
112 Dtype* pos1 = &data1[channels * ((y1 + h1) * Width1 + (x1 + w1))];
113 const Dtype* pos2 = &data2[channels * ((y2 + h2) * Width2 + (x2 + w2))];
114 for (int c = 0; c < channels; ++c) {
115 pos1[0] += pos2[0];
116 pos1++;
117 pos2++;
118 }
119 }
120 else {
121 Dtype* pos1 = &data1[(y1 + h1) * Width1 + (x1 + w1)];
122 const Dtype* pos2 = &data2[(y2 + h2) * Width2 + (x2 + w2)];
123 for (int c = 0; c < channels; ++c) {
124 pos1[0] += pos2[0];
125 pos1 += Width1 * Height1;
126 pos2 += Width2 * Height2;
127 }
128 }
129 return;
130 }
131 //
132 const float h1r = rheight * h2;
133 const int h1 = h1r;
134 const int h1p = (h1 < height1 - 1) ? 1 : 0;
135 const Dtype h1lambda = h1r - h1;
136 const Dtype h0lambda = Dtype(1.) - h1lambda;
137 //
138 const float w1r = rwidth * w2;
139 const int w1 = w1r;
140 const int w1p = (w1 < width1 - 1) ? 1 : 0;
141 const Dtype w1lambda = w1r - w1;
142 const Dtype w0lambda = Dtype(1.) - w1lambda;
143 //
144 if (packed) {
145 Dtype* pos1 = &data1[channels * ((y1 + h1) * Width1 + (x1 + w1))];
146 const Dtype* pos2 = &data2[channels * ((y2 + h2) * Width2 + (x2 + w2))];
147 for (int c = 0; c < channels; ++c) {
148 atomicAdd(&pos1[0], h0lambda * w0lambda * pos2[0]);
149 atomicAdd(&pos1[channels * w1p], h0lambda * w1lambda * pos2[0]);
150 atomicAdd(&pos1[channels * h1p * Width1], h1lambda * w0lambda * pos2[0]);
151 atomicAdd(&pos1[channels * (h1p * Width1 + w1p)], h1lambda * w1lambda * pos2[0]);
152 pos1++;
153 pos2++;
154 }
155 }
156 else {
157 Dtype* pos1 = &data1[(y1 + h1) * Width1 + (x1 + w1)];
158 const Dtype* pos2 = &data2[(y2 + h2) * Width2 + (x2 + w2)];
159 for (int c = 0; c < channels; ++c) {
160 atomicAdd(&pos1[0], h0lambda * w0lambda * pos2[0]);
161 atomicAdd(&pos1[w1p], h0lambda * w1lambda * pos2[0]);
162 atomicAdd(&pos1[h1p * Width1], h1lambda * w0lambda * pos2[0]);
163 atomicAdd(&pos1[h1p * Width1 + w1p], h1lambda * w1lambda * pos2[0]);
164 pos1 += Width1 * Height1;
165 pos2 += Width2 * Height2;
166 }
167 }
168 }
169 }
170
171 template <typename Dtype, bool packed>
172 void caffe_gpu_interp2_backward(const int channels,
173 Dtype *data1, const int x1, const int y1, const int height1, const int width1, const int Height1, const int Width1,
174 const Dtype *data2, const int x2, const int y2, const int height2, const int width2, const int Height2, const int Width2) {
175 CHECK(x1 >= 0 && y1 >= 0 && height1 > 0 && width1 > 0 && x2 >= 0 && y2 >= 0 && height2 > 0 && width2 > 0);
176 CHECK(Width1 >= width1 + x1 && Height1 >= height1 + y1 && Width2 >= width2 + x2 && Height2 >= height2 + y2);
177 const float rheight = (height2 > 1) ? static_cast<float>(height1 - 1) / (height2 - 1) : 0.f;
178 const float rwidth = (width2 > 1) ? static_cast<float>(width1 - 1) / (width2 - 1) : 0.f;
179 const int num_kernels = height2 * width2;
180 caffe_gpu_interp2_kernel_backward<Dtype,packed><<<CAFFE_GET_BLOCKS(num_kernels), CAFFE_CUDA_NUM_THREADS>>>
181 (num_kernels, rheight, rwidth, channels,
182 data1, x1, y1, height1, width1, Height1, Width1,
183 data2, x2, y2, height2, width2, Height2, Width2);
184 CUDA_POST_KERNEL_CHECK;
185 }
186
187
188 // Create Gaussian pyramid of an image. Assume output space is pre-allocated.
189 // IN : [channels height width]
190 template <typename Dtype, bool packed>
191 __global__ void caffe_gpu_pyramid2_kernel(const int n, const int channels,
192 const Dtype *data1, const int height1, const int width1,
193 Dtype *data2, const int height2, const int width2) {
194 int index = threadIdx.x + blockIdx.x * blockDim.x;
195 if (index < n) {
196 const int w2 = index % width2; // 0:width2-1
197 const int h2 = index / width2; // 0:height2-1
198 const int w1 = 2 * w2;
199 const int h1 = 2 * h2;
200 if (packed) {
201 const Dtype* pos1 = &data1[channels * (h1 * width1 + w1)];
202 Dtype* pos2 = &data2[channels * (h2 * width2 + w2)];
203 for (int c = 0; c < channels; ++c) {
204 pos2[0] = static_cast<Dtype>(.25) *
205 (pos1[0] + pos1[channels] +
206 pos1[channels * width1] + pos1[channels * (width1 + 1)]);
207 pos1++;
208 pos2++;
209 }
210 }
211 else {
212 const Dtype* pos1 = &data1[h1 * width1 + w1];
213 Dtype* pos2 = &data2[h2 * width2 + w2];
214 for (int c = 0; c < channels; ++c) {
215 pos2[0] = static_cast<Dtype>(.25) *
216 (pos1[0] + pos1[1] +
217 pos1[width1] + pos1[width1 + 1]);
218 pos1 += width1 * height1;
219 pos2 += width2 * height2;
220 }
221 }
222 }
223 }
224
225 template <typename Dtype, bool packed>
226 void caffe_gpu_pyramid2(const int channels,
227 const Dtype *data, const int height, const int width,
228 Dtype *data_pyr, const int levels) {
229 CHECK(height > 0 && width > 0 && levels >= 0);
230 int height1 = height, width1 = width;
231 int height2 = height, width2 = width;
232 const Dtype *data1 = data;
233 Dtype *data2 = data_pyr;
234 for (int l = 0; l < levels; ++l) {
235 height2 /= 2;
236 width2 /= 2;
237 if (height2 == 0 || width2 == 0) {
238 break;
239 }
240 const int num_kernels = height2 * width2;
241 caffe_gpu_pyramid2_kernel<Dtype,packed><<<CAFFE_GET_BLOCKS(num_kernels), CAFFE_CUDA_NUM_THREADS>>>
242 (num_kernels, channels, data1, height1, width1, data2, height2, width2);
243 CUDA_POST_KERNEL_CHECK;
244 data1 = data2;
245 height1 = height2;
246 width1 = width2;
247 data2 += channels * height2 * width2;
248 }
249 }
250
251
252 // Explicit instances
253 template void caffe_gpu_interp2<float,false>(const int, const float *, const int, const int, const int, const int, const int, const int, float *, const int, const int, const int, const int, const int, const int);
254 template void caffe_gpu_interp2<float,true>(const int, const float *, const int, const int, const int, const int, const int, const int, float *, const int, const int, const int, const int, const int, const int);
255 template void caffe_gpu_interp2<double,false>(const int, const double *, const int, const int, const int, const int, const int, const int, double *, const int, const int, const int, const int, const int, const int);
256 template void caffe_gpu_interp2<double,true>(const int, const double *, const int, const int, const int, const int, const int, const int, double *, const int, const int, const int, const int, const int, const int);
257
258 template void caffe_gpu_interp2_backward<float,false>(const int, float *, const int, const int, const int, const int, const int, const int, const float *, const int, const int, const int, const int, const int, const int);
259 template void caffe_gpu_interp2_backward<double,false>(const int, double *, const int, const int, const int, const int, const int, const int, const double *, const int, const int, const int, const int, const int, const int);
260
261 template void caffe_gpu_pyramid2<float,false>(const int, const float *, const int, const int, float *, const int);
262 template void caffe_gpu_pyramid2<float,true>(const int, const float *, const int, const int, float *, const int);
263 template void caffe_gpu_pyramid2<double,false>(const int, const double *, const int, const int, double *, const int);
264 template void caffe_gpu_pyramid2<double,true>(const int, const double *, const int, const int, double *, const int);
265
266 } // namespace caffe6.在PSPNet/src/caffe/proto/caffe.proto中添加代码，代码如下：
1 message LayerParameter {
2 optional string name = 1; // the layer name
3 optional string type = 2; // the layer type
4 repeated string bottom = 3; // the name of each bottom blob
5 repeated string top = 4; // the name of each top blob
6
7 // The train / test phase for computation.
8 optional Phase phase = 10;
9
10 // The amount of weight to assign each top blob in the objective.
11 // Each layer assigns a default value, usually of either 0 or 1,
12 // to each top blob.
13 repeated float loss_weight = 5;
14
15 // Specifies training parameters (multipliers on global learning constants,
16 // and the name and other settings used for weight sharing).
17 repeated ParamSpec param = 6;
18
19 // The blobs containing the numeric parameters of the layer.
20 repeated BlobProto blobs = 7;
21
22 // Specifies on which bottoms the backpropagation should be skipped.
23 // The size must be either 0 or equal to the number of bottoms.
24 repeated bool propagate_down = 11;
25
26 // Rules controlling whether and when a layer is included in the network,
27 // based on the current NetState. You may specify a non-zero number of rules
28 // to include OR exclude, but not both. If no include or exclude rules are
29 // specified, the layer is always included. If the current NetState meets
30 // ANY (i.e., one or more) of the specified rules, the layer is
31 // included/excluded.
32 repeated NetStateRule include = 8;
33 repeated NetStateRule exclude = 9;
34
35 // Parameters for data pre-processing.
36 optional TransformationParameter transform_param = 100;
37
38 // Parameters shared by loss layers.
39 optional LossParameter loss_param = 101;
40
41 // Layer type-specific parameters.
42 //
43 // Note: certain layers may have more than one computational engine
44 // for their implementation. These layers include an Engine type and
45 // engine parameter for selecting the implementation.
46 // The default for the engine is set by the ENGINE switch at compile-time.
47 optional AccuracyParameter accuracy_param = 102;
48 optional AdaptiveBiasChannelParameter adaptive_bias_channel_param = 148;
49 optional ArgMaxParameter argmax_param = 103;
50 optional BatchNormParameter batch_norm_param = 139;
51 optional BNParameter bn_param = 152;
52 optional BiasParameter bias_param = 141;
53 optional BiasChannelParameter bias_channel_param = 149;
54 optional ConcatParameter concat_param = 104;
55 optional ContrastiveLossParameter contrastive_loss_param = 105;
56 optional ConvolutionParameter convolution_param = 106;
57 optional DataParameter data_param = 107;
58 optional DenseCRFParameter dense_crf_param = 146;
59 optional DomainTransformParameter domain_transform_param = 147;
60 optional DropoutParameter dropout_param = 108;
61 optional DummyDataParameter dummy_data_param = 109;
62 optional EltwiseParameter eltwise_param = 110;
63 optional ELUParameter elu_param = 140;
64 optional EmbedParameter embed_param = 137;
65 optional ExpParameter exp_param = 111;
66 optional FlattenParameter flatten_param = 135;
67 optional HDF5DataParameter hdf5_data_param = 112;
68 optional HDF5OutputParameter hdf5_output_param = 113;
69 optional HingeLossParameter hinge_loss_param = 114;
70 optional ImageDataParameter image_data_param = 115;
71 optional InfogainLossParameter infogain_loss_param = 116;
72 optional InnerProductParameter inner_product_param = 117;
73 optional InterpParameter interp_param = 143; //注意143不能和其他的数字重复，可以自己情况调整
74 optional LogParameter log_param = 134;
75 optional LRNParameter lrn_param = 118;
76 optional MatReadParameter mat_read_param = 151;
77 optional MatWriteParameter mat_write_param = 145;
78 optional MemoryDataParameter memory_data_param = 119;
79 optional MVNParameter mvn_param = 120;
80 optional PoolingParameter pooling_param = 121;
81 optional PowerParameter power_param = 122;
82 optional PReLUParameter prelu_param = 131;
83 optional PythonParameter python_param = 130;
84 optional ReductionParameter reduction_param = 136;
85 optional ReLUParameter relu_param = 123;
86 optional ReshapeParameter reshape_param = 133;
87 optional ScaleParameter scale_param = 142;
88 optional SegAccuracyParameter seg_accuracy_param = 144;
89 optional SigmoidParameter sigmoid_param = 124;
90 optional SoftmaxParameter softmax_param = 125;
91 optional SPPParameter spp_param = 132;
92 optional SliceParameter slice_param = 126;
93 optional TanHParameter tanh_param = 127;
94 optional ThresholdParameter threshold_param = 128;
95 optional TileParameter tile_param = 138;
96 optional UniqueLabelParameter unique_label_param = 150;
97 optional WindowDataParameter window_data_param = 129;
98 }1 message InterpParameter {
2 optional int32 height = 1 [default = 0]; // Height of output
3 optional int32 width = 2 [default = 0]; // Width of output
4 optional int32 zoom_factor = 3 [default = 1]; // zoom factor
5 optional int32 shrink_factor = 4 [default = 1]; // shrink factor
6 optional int32 pad_beg = 5 [default = 0]; // padding at begin of input
7 optional int32 pad_end = 6 [default = 0]; // padding at end of input
8 }7.在网络结构中添加Interp层，代码如下：
1 layer{
2 bottom:"input"
3 top:"output"
4 name:"interp_layer"
5 type:"Interp"
6 interp_param{ //注意可按需求改为interp_param{height:60 width:60}（即固定特征图的尺寸），也可以不需要这个interp_param参数
7 shrink_factor:4
8 zoom_factor:3
9 pad_beg:0
10 pad_end:0
11 }
12 }第二步，添加完相应的代码，则进行编译
1.因为修改过caffe.proto，所以需要重新编译proto,需要先安装protobuf，安装之后需要编译caffe.proto文件，生成caffe.pb.h和caffe.pb.cc文件。编译过程如下：
1 # 确定protobuf的版本 2 $ protoc --version 3 libprotoc 2.5.0 4 5 # 编译caffe.proto，需要先进入src/caffe/proto目录下，也可以不进入，指定路径 6 $ protoc -I=./ --cpp_out=./ ./caffe.proto 7 8 # 查看编译结果 9 $ ls 10 caffe.pb.cc caffe.pb.h caffe.proto
2.编译caffe，退到caffe路径下，编译：
1 //确保每一步都成功执行 2 make clean 3 make -j8 4 make pycaffe
...大体上是这样一个流程，编译过程中遇到相应问题再百度，有错误的地方欢迎大家指正。
版权声明：
作者：王老头
出处：http://www.cnblogs.com/wmr95/p/8715607.html
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，并在文章页面明显位置给出原文链接，否则，作者将保留追究法律责任的权利。