├── LICENSE
├── README.md
├── config
├── GAIC_config.py
└── GAIC_params.yaml
├── dataset
├── candidate_generation.py
└── cropping_dataset.py
├── evaluate
├── demo.py
└── test.py
├── networks
├── GAIC_model.py
└── __init__.py
├── requirements.txt
├── result_images
├── 211958.jpg
├── 265813.jpg
└── 297406.jpg
├── test_images
├── 211958.jpg
├── 265813.jpg
└── 297406.jpg
├── train
└── train.py
└── untils
├── make_all.sh
├── rod_align
├── __init__.py
├── functions
│ ├── __init__.py
│ └── rod_align.py
├── make.sh
├── make_python2.sh
├── modules
│ ├── __init__.py
│ └── rod_align.py
├── setup.py
└── src
│ ├── rod_align.cpp
│ ├── rod_align.h
│ ├── rod_align_cuda.cpp
│ ├── rod_align_cuda.h
│ ├── rod_align_kernel.cu
│ └── rod_align_kernel.h
└── roi_align
├── __init__.py
├── functions
├── __init__.py
└── roi_align.py
├── make.sh
├── make_python2.sh
├── modules
├── __init__.py
└── roi_align.py
├── setup.py
└── src
├── roi_align.cpp
├── roi_align.h
├── roi_align_cuda.cpp
├── roi_align_cuda.h
├── roi_align_kernel.cu
└── roi_align_kernel.h
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2022 bo-zhang
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # GAIC-PyTorch
2 | This is an unofficial PyTorch implementation of [Grid Anchor based Image Cropping: A New Benchmark and An Efficient Model](https://arxiv.org/pdf/1909.08989.pdf?ref=https://githubhelp.com), which is the journal version and extension of [Reliable and Efficient Image Cropping: A Grid Anchor based Approach](https://arxiv.org/pdf/1904.04441.pdf).
3 | We provide demo code to produce the best cropping results with different aspect ratios (1:1, 4:3, and 16:9) for arbitrary test images.
4 | Moreover, this code is also able to generate crops with arbitrary specified aspect ratios.
5 |
6 |
7 |
8 |
10 |
11 |
13 |
14 |
2 | #include
3 | #include
4 | #include "roi_align.h"
5 |
6 | void ROIAlignForwardCpu(const float* bottom_data, const float spatial_scale, const int num_rois,
7 | const int height, const int width, const int channels,
8 | const int aligned_height, const int aligned_width, const float * bottom_rois,
9 | float* top_data);
10 |
11 | void ROIAlignBackwardCpu(const float* top_diff, const float spatial_scale, const int num_rois,
12 | const int height, const int width, const int channels,
13 | const int aligned_height, const int aligned_width, const float * bottom_rois,
14 | float* top_data);
15 |
16 | int roi_align_forward(int aligned_height, int aligned_width, float spatial_scale,
17 | torch::Tensor features, torch::Tensor rois, torch::Tensor output)
18 | {
19 | //Grab the input tensor
20 | //float * data_flat = THFloatTensor_data(features);
21 | //float * rois_flat = THFloatTensor_data(rois);
22 | auto data_flat = features.data();
23 | auto rois_flat = rois.data();
24 |
25 | //float * output_flat = THFloatTensor_data(output);
26 | auto output_flat = output.data();
27 |
28 | // Number of ROIs
29 | //int num_rois = THFloatTensor_size(rois, 0);
30 | //int size_rois = THFloatTensor_size(rois, 1);
31 |
32 | auto rois_sz = rois.sizes();
33 | int num_rois = rois_sz[0];
34 | int size_rois = rois_sz[1];
35 |
36 | if (size_rois != 5)
37 | {
38 | return 0;
39 | }
40 |
41 | // data height
42 | //int data_height = THFloatTensor_size(features, 2);
43 | // data width
44 | //int data_width = THFloatTensor_size(features, 3);
45 | // Number of channels
46 | //int num_channels = THFloatTensor_size(features, 1);
47 | auto feat_sz = features.sizes();
48 | int data_height = feat_sz[2];
49 | int data_width = feat_sz[3];
50 | int num_channels = feat_sz[1];
51 |
52 | // do ROIAlignForward
53 | ROIAlignForwardCpu(data_flat, spatial_scale, num_rois, data_height, data_width, num_channels,
54 | aligned_height, aligned_width, rois_flat, output_flat);
55 |
56 | return 1;
57 | }
58 |
59 | int roi_align_backward(int aligned_height, int aligned_width, float spatial_scale,
60 | torch::Tensor top_grad, torch::Tensor rois, torch::Tensor bottom_grad)
61 | {
62 | //Grab the input tensor
63 | //float * top_grad_flat = THFloatTensor_data(top_grad);
64 | //float * rois_flat = THFloatTensor_data(rois);
65 |
66 | //float * bottom_grad_flat = THFloatTensor_data(bottom_grad);
67 | auto top_grad_flat = top_grad.data();
68 | auto rois_flat = rois.data();
69 | auto bottom_grad_flat = bottom_grad.data();
70 |
71 | // Number of ROIs
72 | //int num_rois = THFloatTensor_size(rois, 0);
73 | //int size_rois = THFloatTensor_size(rois, 1);
74 | auto rois_sz = rois.sizes();
75 | int num_rois = rois_sz[0];
76 | int size_rois = rois_sz[1];
77 | if (size_rois != 5)
78 | {
79 | return 0;
80 | }
81 |
82 | // batch size
83 | // int batch_size = THFloatTensor_size(bottom_grad, 0);
84 | // data height
85 | //int data_height = THFloatTensor_size(bottom_grad, 2);
86 | // data width
87 | //int data_width = THFloatTensor_size(bottom_grad, 3);
88 | // Number of channels
89 | //int num_channels = THFloatTensor_size(bottom_grad, 1);
90 |
91 | auto grad_sz = bottom_grad.sizes();
92 | int data_height = grad_sz[2];
93 | int data_width = grad_sz[3];
94 | int num_channels = grad_sz[1];
95 |
96 | // do ROIAlignBackward
97 | ROIAlignBackwardCpu(top_grad_flat, spatial_scale, num_rois, data_height,
98 | data_width, num_channels, aligned_height, aligned_width, rois_flat, bottom_grad_flat);
99 |
100 | return 1;
101 | }
102 |
103 | void ROIAlignForwardCpu(const float* bottom_data, const float spatial_scale, const int num_rois,
104 | const int height, const int width, const int channels,
105 | const int aligned_height, const int aligned_width, const float * bottom_rois,
106 | float* top_data)
107 | {
108 | const int output_size = num_rois * aligned_height * aligned_width * channels;
109 |
110 | int idx = 0;
111 | for (idx = 0; idx < output_size; ++idx)
112 | {
113 | // (n, c, ph, pw) is an element in the aligned output
114 | int pw = idx % aligned_width;
115 | int ph = (idx / aligned_width) % aligned_height;
116 | int c = (idx / aligned_width / aligned_height) % channels;
117 | int n = idx / aligned_width / aligned_height / channels;
118 |
119 | float roi_batch_ind = bottom_rois[n * 5 + 0];
120 | float roi_start_w = bottom_rois[n * 5 + 1] * spatial_scale;
121 | float roi_start_h = bottom_rois[n * 5 + 2] * spatial_scale;
122 | float roi_end_w = bottom_rois[n * 5 + 3] * spatial_scale;
123 | float roi_end_h = bottom_rois[n * 5 + 4] * spatial_scale;
124 |
125 | // Force malformed ROI to be 1x1
126 | float roi_width = fmaxf(roi_end_w - roi_start_w + 1., 0.);
127 | float roi_height = fmaxf(roi_end_h - roi_start_h + 1., 0.);
128 | float bin_size_h = roi_height / (aligned_height - 1.);
129 | float bin_size_w = roi_width / (aligned_width - 1.);
130 |
131 | float h = (float)(ph) * bin_size_h + roi_start_h;
132 | float w = (float)(pw) * bin_size_w + roi_start_w;
133 |
134 | int hstart = fminf(floor(h), height - 2);
135 | int wstart = fminf(floor(w), width - 2);
136 |
137 | int img_start = roi_batch_ind * channels * height * width;
138 |
139 | // bilinear interpolation
140 | if (h < 0 || h >= height || w < 0 || w >= width)
141 | {
142 | top_data[idx] = 0.;
143 | }
144 | else
145 | {
146 | float h_ratio = h - (float)(hstart);
147 | float w_ratio = w - (float)(wstart);
148 | int upleft = img_start + (c * height + hstart) * width + wstart;
149 | int upright = upleft + 1;
150 | int downleft = upleft + width;
151 | int downright = downleft + 1;
152 |
153 | top_data[idx] = bottom_data[upleft] * (1. - h_ratio) * (1. - w_ratio)
154 | + bottom_data[upright] * (1. - h_ratio) * w_ratio
155 | + bottom_data[downleft] * h_ratio * (1. - w_ratio)
156 | + bottom_data[downright] * h_ratio * w_ratio;
157 | }
158 | }
159 | }
160 |
161 | void ROIAlignBackwardCpu(const float* top_diff, const float spatial_scale, const int num_rois,
162 | const int height, const int width, const int channels,
163 | const int aligned_height, const int aligned_width, const float * bottom_rois,
164 | float* bottom_diff)
165 | {
166 | const int output_size = num_rois * aligned_height * aligned_width * channels;
167 |
168 | int idx = 0;
169 | for (idx = 0; idx < output_size; ++idx)
170 | {
171 | // (n, c, ph, pw) is an element in the aligned output
172 | int pw = idx % aligned_width;
173 | int ph = (idx / aligned_width) % aligned_height;
174 | int c = (idx / aligned_width / aligned_height) % channels;
175 | int n = idx / aligned_width / aligned_height / channels;
176 |
177 | float roi_batch_ind = bottom_rois[n * 5 + 0];
178 | float roi_start_w = bottom_rois[n * 5 + 1] * spatial_scale;
179 | float roi_start_h = bottom_rois[n * 5 + 2] * spatial_scale;
180 | float roi_end_w = bottom_rois[n * 5 + 3] * spatial_scale;
181 | float roi_end_h = bottom_rois[n * 5 + 4] * spatial_scale;
182 |
183 | // Force malformed ROI to be 1x1
184 | float roi_width = fmaxf(roi_end_w - roi_start_w + 1., 0.);
185 | float roi_height = fmaxf(roi_end_h - roi_start_h + 1., 0.);
186 | float bin_size_h = roi_height / (aligned_height - 1.);
187 | float bin_size_w = roi_width / (aligned_width - 1.);
188 |
189 | float h = (float)(ph) * bin_size_h + roi_start_h;
190 | float w = (float)(pw) * bin_size_w + roi_start_w;
191 |
192 | int hstart = fminf(floor(h), height - 2);
193 | int wstart = fminf(floor(w), width - 2);
194 |
195 | int img_start = roi_batch_ind * channels * height * width;
196 |
197 | // bilinear interpolation
198 | if (h < 0 || h >= height || w < 0 || w >= width)
199 | {
200 | float h_ratio = h - (float)(hstart);
201 | float w_ratio = w - (float)(wstart);
202 | int upleft = img_start + (c * height + hstart) * width + wstart;
203 | int upright = upleft + 1;
204 | int downleft = upleft + width;
205 | int downright = downleft + 1;
206 |
207 | bottom_diff[upleft] += top_diff[idx] * (1. - h_ratio) * (1. - w_ratio);
208 | bottom_diff[upright] += top_diff[idx] * (1. - h_ratio) * w_ratio;
209 | bottom_diff[downleft] += top_diff[idx] * h_ratio * (1. - w_ratio);
210 | bottom_diff[downright] += top_diff[idx] * h_ratio * w_ratio;
211 | }
212 | }
213 | }
214 |
215 | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
216 | m.def("forward", &roi_align_forward, "roi_align forward");
217 | m.def("backward", &roi_align_backward, "roi_align backward");
218 | }
219 |
--------------------------------------------------------------------------------
/untils/roi_align/src/roi_align.h:
--------------------------------------------------------------------------------
1 | #ifndef ROI_ALIGN_H
2 | #define ROI_ALIGN_H
3 |
4 | #include
5 |
6 | int roi_align_forward(int aligned_height, int aligned_width, float spatial_scale,
7 | torch::Tensor features, torch::Tensor rois, torch::Tensor output);
8 |
9 | int roi_align_backward(int aligned_height, int aligned_width, float spatial_scale,
10 | torch::Tensor top_grad, torch::Tensor rois, torch::Tensor bottom_grad);
11 |
12 | #endif
13 |
--------------------------------------------------------------------------------
/untils/roi_align/src/roi_align_cuda.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 | #include "roi_align_kernel.h"
5 |
6 |
7 | int roi_align_forward_cuda(int aligned_height, int aligned_width, float spatial_scale,
8 | torch::Tensor features, torch::Tensor rois, torch::Tensor output)
9 | {
10 | // Grab the input tensor
11 | //float * data_flat = THCudaTensor_data(state, features);
12 | //float * rois_flat = THCudaTensor_data(state, rois);
13 |
14 | //float * output_flat = THCudaTensor_data(state, output);
15 |
16 | auto data_flat = features.data();
17 | auto rois_flat = rois.data();
18 | auto output_flat = output.data();
19 |
20 | // Number of ROIs
21 | //int num_rois = THCudaTensor_size(state, rois, 0);
22 | //int size_rois = THCudaTensor_size(state, rois, 1);
23 | auto rois_sz = rois.sizes();
24 | int num_rois = rois_sz[0];
25 | int size_rois = rois_sz[1];
26 | if (size_rois != 5)
27 | {
28 | return 0;
29 | }
30 |
31 | // data height
32 | //int data_height = THCudaTensor_size(state, features, 2);
33 | // data width
34 | //int data_width = THCudaTensor_size(state, features, 3);
35 | // Number of channels
36 | //int num_channels = THCudaTensor_size(state, features, 1);
37 | auto feat_sz = features.sizes();
38 | int data_height = feat_sz[2];
39 | int data_width = feat_sz[3];
40 | int num_channels = feat_sz[1];
41 |
42 |
43 | cudaStream_t stream = at::cuda::getCurrentCUDAStream();
44 |
45 | ROIAlignForwardLaucher(
46 | data_flat, spatial_scale, num_rois, data_height,
47 | data_width, num_channels, aligned_height,
48 | aligned_width, rois_flat,
49 | output_flat, stream);
50 |
51 | return 1;
52 | }
53 |
54 | int roi_align_backward_cuda(int aligned_height, int aligned_width, float spatial_scale,
55 | torch::Tensor top_grad, torch::Tensor rois, torch::Tensor bottom_grad)
56 | {
57 | // Grab the input tensor
58 | //float * top_grad_flat = THCudaTensor_data(state, top_grad);
59 | //float * rois_flat = THCudaTensor_data(state, rois);
60 |
61 | //float * bottom_grad_flat = THCudaTensor_data(state, bottom_grad);
62 | auto top_grad_flat = top_grad.data();
63 | auto rois_flat = rois.data();
64 | auto bottom_grad_flat = bottom_grad.data();
65 |
66 | // Number of ROIs
67 | //int num_rois = THCudaTensor_size(state, rois, 0);
68 | //int size_rois = THCudaTensor_size(state, rois, 1);
69 | auto rois_sz = rois.sizes();
70 | int num_rois = rois_sz[0];
71 | int size_rois = rois_sz[1];
72 |
73 | if (size_rois != 5)
74 | {
75 | return 0;
76 | }
77 |
78 | // batch size
79 | //int batch_size = THCudaTensor_size(state, bottom_grad, 0);
80 | // data height
81 | //int data_height = THCudaTensor_size(state, bottom_grad, 2);
82 | // data width
83 | //int data_width = THCudaTensor_size(state, bottom_grad, 3);
84 | // Number of channels
85 | //int num_channels = THCudaTensor_size(state, bottom_grad, 1);
86 | auto grad_sz = bottom_grad.sizes();
87 | int batch_size = grad_sz[0];
88 | int data_height = grad_sz[2];
89 | int data_width = grad_sz[3];
90 | int num_channels = grad_sz[1];
91 |
92 | cudaStream_t stream = at::cuda::getCurrentCUDAStream();
93 | ROIAlignBackwardLaucher(
94 | top_grad_flat, spatial_scale, batch_size, num_rois, data_height,
95 | data_width, num_channels, aligned_height,
96 | aligned_width, rois_flat,
97 | bottom_grad_flat, stream);
98 |
99 | return 1;
100 | }
101 |
102 | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
103 | m.def("forward", &roi_align_forward_cuda, "roi_align forward");
104 | m.def("backward", &roi_align_backward_cuda, "roi_align backward");
105 | }
106 |
--------------------------------------------------------------------------------
/untils/roi_align/src/roi_align_cuda.h:
--------------------------------------------------------------------------------
1 | #ifndef ROI_ALIGN_CUDA_H
2 | #define ROI_ALIGN_CUDA_H
3 |
4 | #include
5 |
6 | int roi_align_forward_cuda(int aligned_height, int aligned_width, float spatial_scale,
7 | torch::Tensor features, torch::Tensor rois, torch::Tensor output);
8 |
9 | int roi_align_backward_cuda(int aligned_height, int aligned_width, float spatial_scale,
10 | torch::Tensor top_grad, torch::Tensor rois, torch::Tensor bottom_grad);
11 |
12 | #endif
13 |
--------------------------------------------------------------------------------
/untils/roi_align/src/roi_align_kernel.cu:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 | #include "roi_align_kernel.h"
5 |
6 | #define CUDA_1D_KERNEL_LOOP(i, n) \
7 | for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n; \
8 | i += blockDim.x * gridDim.x)
9 |
10 |
11 | __global__ void ROIAlignForward(const int nthreads, const float* bottom_data, const float spatial_scale, const int height, const int width,
12 | const int channels, const int aligned_height, const int aligned_width, const float* bottom_rois, float* top_data) {
13 | CUDA_1D_KERNEL_LOOP(index, nthreads) {
14 | // (n, c, ph, pw) is an element in the aligned output
15 | // int n = index;
16 | // int pw = n % aligned_width;
17 | // n /= aligned_width;
18 | // int ph = n % aligned_height;
19 | // n /= aligned_height;
20 | // int c = n % channels;
21 | // n /= channels;
22 |
23 | int pw = index % aligned_width;
24 | int ph = (index / aligned_width) % aligned_height;
25 | int c = (index / aligned_width / aligned_height) % channels;
26 | int n = index / aligned_width / aligned_height / channels;
27 |
28 | // bottom_rois += n * 5;
29 | float roi_batch_ind = bottom_rois[n * 5 + 0];
30 | float roi_start_w = bottom_rois[n * 5 + 1] * spatial_scale;
31 | float roi_start_h = bottom_rois[n * 5 + 2] * spatial_scale;
32 | float roi_end_w = bottom_rois[n * 5 + 3] * spatial_scale;
33 | float roi_end_h = bottom_rois[n * 5 + 4] * spatial_scale;
34 |
35 | // Force malformed ROIs to be 1x1
36 | float roi_width = fmaxf(roi_end_w - roi_start_w + 1., 0.);
37 | float roi_height = fmaxf(roi_end_h - roi_start_h + 1., 0.);
38 | float bin_size_h = roi_height / (aligned_height - 1.);
39 | float bin_size_w = roi_width / (aligned_width - 1.);
40 |
41 | float h = (float)(ph) * bin_size_h + roi_start_h;
42 | float w = (float)(pw) * bin_size_w + roi_start_w;
43 |
44 | int hstart = fminf(floor(h), height - 2);
45 | int wstart = fminf(floor(w), width - 2);
46 |
47 | int img_start = roi_batch_ind * channels * height * width;
48 |
49 | // bilinear interpolation
50 | if (h < 0 || h >= height || w < 0 || w >= width) {
51 | top_data[index] = 0.;
52 | } else {
53 | float h_ratio = h - (float)(hstart);
54 | float w_ratio = w - (float)(wstart);
55 | int upleft = img_start + (c * height + hstart) * width + wstart;
56 | int upright = upleft + 1;
57 | int downleft = upleft + width;
58 | int downright = downleft + 1;
59 |
60 | top_data[index] = bottom_data[upleft] * (1. - h_ratio) * (1. - w_ratio)
61 | + bottom_data[upright] * (1. - h_ratio) * w_ratio
62 | + bottom_data[downleft] * h_ratio * (1. - w_ratio)
63 | + bottom_data[downright] * h_ratio * w_ratio;
64 | }
65 | }
66 | }
67 |
68 |
69 | int ROIAlignForwardLaucher(const float* bottom_data, const float spatial_scale, const int num_rois, const int height, const int width,
70 | const int channels, const int aligned_height, const int aligned_width, const float* bottom_rois, float* top_data, cudaStream_t stream) {
71 | const int kThreadsPerBlock = 1024;
72 | const int output_size = num_rois * aligned_height * aligned_width * channels;
73 | cudaError_t err;
74 |
75 |
76 | ROIAlignForward<<<(output_size + kThreadsPerBlock - 1) / kThreadsPerBlock, kThreadsPerBlock, 0, stream>>>(
77 | output_size, bottom_data, spatial_scale, height, width, channels,
78 | aligned_height, aligned_width, bottom_rois, top_data);
79 |
80 | err = cudaGetLastError();
81 | if(cudaSuccess != err) {
82 | fprintf( stderr, "cudaCheckError() failed : %s\n", cudaGetErrorString( err ) );
83 | exit( -1 );
84 | }
85 |
86 | return 1;
87 | }
88 |
89 |
90 | __global__ void ROIAlignBackward(const int nthreads, const float* top_diff, const float spatial_scale, const int height, const int width,
91 | const int channels, const int aligned_height, const int aligned_width, float* bottom_diff, const float* bottom_rois) {
92 | CUDA_1D_KERNEL_LOOP(index, nthreads) {
93 |
94 | // (n, c, ph, pw) is an element in the aligned output
95 | int pw = index % aligned_width;
96 | int ph = (index / aligned_width) % aligned_height;
97 | int c = (index / aligned_width / aligned_height) % channels;
98 | int n = index / aligned_width / aligned_height / channels;
99 |
100 | float roi_batch_ind = bottom_rois[n * 5 + 0];
101 | float roi_start_w = bottom_rois[n * 5 + 1] * spatial_scale;
102 | float roi_start_h = bottom_rois[n * 5 + 2] * spatial_scale;
103 | float roi_end_w = bottom_rois[n * 5 + 3] * spatial_scale;
104 | float roi_end_h = bottom_rois[n * 5 + 4] * spatial_scale;
105 | /* int roi_start_w = round(bottom_rois[1] * spatial_scale); */
106 | /* int roi_start_h = round(bottom_rois[2] * spatial_scale); */
107 | /* int roi_end_w = round(bottom_rois[3] * spatial_scale); */
108 | /* int roi_end_h = round(bottom_rois[4] * spatial_scale); */
109 |
110 | // Force malformed ROIs to be 1x1
111 | float roi_width = fmaxf(roi_end_w - roi_start_w + 1., 0.);
112 | float roi_height = fmaxf(roi_end_h - roi_start_h + 1., 0.);
113 | float bin_size_h = roi_height / (aligned_height - 1.);
114 | float bin_size_w = roi_width / (aligned_width - 1.);
115 |
116 | float h = (float)(ph) * bin_size_h + roi_start_h;
117 | float w = (float)(pw) * bin_size_w + roi_start_w;
118 |
119 | int hstart = fminf(floor(h), height - 2);
120 | int wstart = fminf(floor(w), width - 2);
121 |
122 | int img_start = roi_batch_ind * channels * height * width;
123 |
124 | // bilinear interpolation
125 | if (!(h < 0 || h >= height || w < 0 || w >= width)) {
126 | float h_ratio = h - (float)(hstart);
127 | float w_ratio = w - (float)(wstart);
128 | int upleft = img_start + (c * height + hstart) * width + wstart;
129 | int upright = upleft + 1;
130 | int downleft = upleft + width;
131 | int downright = downleft + 1;
132 |
133 | atomicAdd(bottom_diff + upleft, top_diff[index] * (1. - h_ratio) * (1 - w_ratio));
134 | atomicAdd(bottom_diff + upright, top_diff[index] * (1. - h_ratio) * w_ratio);
135 | atomicAdd(bottom_diff + downleft, top_diff[index] * h_ratio * (1 - w_ratio));
136 | atomicAdd(bottom_diff + downright, top_diff[index] * h_ratio * w_ratio);
137 | }
138 | }
139 | }
140 |
141 | int ROIAlignBackwardLaucher(const float* top_diff, const float spatial_scale, const int batch_size, const int num_rois, const int height, const int width,
142 | const int channels, const int aligned_height, const int aligned_width, const float* bottom_rois, float* bottom_diff, cudaStream_t stream) {
143 | const int kThreadsPerBlock = 1024;
144 | const int output_size = num_rois * aligned_height * aligned_width * channels;
145 | cudaError_t err;
146 |
147 | ROIAlignBackward<<<(output_size + kThreadsPerBlock - 1) / kThreadsPerBlock, kThreadsPerBlock, 0, stream>>>(
148 | output_size, top_diff, spatial_scale, height, width, channels,
149 | aligned_height, aligned_width, bottom_diff, bottom_rois);
150 |
151 | err = cudaGetLastError();
152 | if(cudaSuccess != err) {
153 | fprintf( stderr, "cudaCheckError() failed : %s\n", cudaGetErrorString( err ) );
154 | exit( -1 );
155 | }
156 |
157 | return 1;
158 | }
159 |
--------------------------------------------------------------------------------
/untils/roi_align/src/roi_align_kernel.h:
--------------------------------------------------------------------------------
1 | #ifndef _ROI_ALIGN_KERNEL
2 | #define _ROI_ALIGN_KERNEL
3 |
4 |
5 | __global__ void ROIAlignForward(const int nthreads, const float* bottom_data,
6 | const float spatial_scale, const int height, const int width,
7 | const int channels, const int aligned_height, const int aligned_width,
8 | const float* bottom_rois, float* top_data);
9 |
10 | int ROIAlignForwardLaucher(
11 | const float* bottom_data, const float spatial_scale, const int num_rois, const int height,
12 | const int width, const int channels, const int aligned_height,
13 | const int aligned_width, const float* bottom_rois,
14 | float* top_data, cudaStream_t stream);
15 |
16 | __global__ void ROIAlignBackward(const int nthreads, const float* top_diff,
17 | const float spatial_scale, const int height, const int width,
18 | const int channels, const int aligned_height, const int aligned_width,
19 | float* bottom_diff, const float* bottom_rois);
20 |
21 | int ROIAlignBackwardLaucher(const float* top_diff, const float spatial_scale, const int batch_size, const int num_rois,
22 | const int height, const int width, const int channels, const int aligned_height,
23 | const int aligned_width, const float* bottom_rois,
24 | float* bottom_diff, cudaStream_t stream);
25 |
26 | #endif
27 |
28 |
--------------------------------------------------------------------------------
|