m53297601
/
Paddle
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update iou_similarity op to support non-normalized bbox (#21671)

Browse Source 
Update iou_similarity op to support non-normalized bbox
1.6.2
FDInSky 6 years ago committed by qingqing01
parent d053561d84
commit 6b9fbcf3ad
4 changed files with 71 additions and 16 deletions
Show Stats Download Patch File Download Diff File

5
paddle/fluid/operators/detection/iou_similarity_op.cc
Unescape View File

@ -61,7 +61,10 @@ class IOUSimilarityOpMaker : public framework::OpProtoAndCheckerMaker {
"[xmin, ymin] is the left top coordinate of the box if the "
"input is image feature map, and [xmax, ymax] is the right "
"bottom coordinate of the box.");
AddAttr<bool>("box_normalized",
"(bool, default true) "
"whether treat the priorbox as a noramlized box")
.SetDefault(true);
AddOutput("Out",
"(LoDTensor, the lod is same as input X) The output of "
"iou_similarity op, a tensor with shape [N, M] "

33
paddle/fluid/operators/detection/iou_similarity_op.h
Unescape View File

@ -18,16 +18,28 @@ limitations under the License. */
template <typename T>
inline HOSTDEVICE T IOUSimilarity(T xmin1, T ymin1, T xmax1, T ymax1, T xmin2,
T ymin2, T xmax2, T ymax2) {
T ymin2, T xmax2, T ymax2, bool normalized) {
constexpr T zero = static_cast<T>(0);
T area1 = (ymax1 - ymin1) * (xmax1 - xmin1);
T area2 = (ymax2 - ymin2) * (xmax2 - xmin2);
T area1;
T area2;
if (!normalized) {
area1 = (ymax1 - ymin1 + 1) * (xmax1 - xmin1 + 1);
area2 = (ymax2 - ymin2 + 1) * (xmax2 - xmin2 + 1);
} else {
area1 = (ymax1 - ymin1) * (xmax1 - xmin1);
area2 = (ymax2 - ymin2) * (xmax2 - xmin2);
}
T inter_xmax = xmax1 > xmax2 ? xmax2 : xmax1;
T inter_ymax = ymax1 > ymax2 ? ymax2 : ymax1;
T inter_xmin = xmin1 > xmin2 ? xmin1 : xmin2;
T inter_ymin = ymin1 > ymin2 ? ymin1 : ymin2;
T inter_height = inter_ymax - inter_ymin;
T inter_width = inter_xmax - inter_xmin;
if (!normalized) {
inter_height = inter_height + 1;
inter_width = inter_width + 1;
}
inter_height = inter_height > zero ? inter_height : zero;
inter_width = inter_width > zero ? inter_width : zero;
T inter_area = inter_width * inter_height;
@ -38,8 +50,12 @@ inline HOSTDEVICE T IOUSimilarity(T xmin1, T ymin1, T xmax1, T ymax1, T xmin2,
template <typename T>
struct IOUSimilarityFunctor {
IOUSimilarityFunctor(const T* x, const T* y, T* z, int cols)
: x_(x), y_(y), z_(z), cols_(static_cast<size_t>(cols)) {}
IOUSimilarityFunctor(const T* x, const T* y, T* z, int cols, bool normalized)
: x_(x),
y_(y),
z_(z),
cols_(static_cast<size_t>(cols)),
normalized_(normalized) {}
inline HOSTDEVICE void operator()(size_t tid) const {
size_t row_id = tid / cols_;
@ -56,7 +72,7 @@ struct IOUSimilarityFunctor {
T y_max2 = y_[col_id * 4 + 3];
T sim = IOUSimilarity(x_min1, y_min1, x_max1, y_max1, x_min2, y_min2,
x_max2, y_max2);
x_max2, y_max2, normalized_);
z_[row_id * cols_ + col_id] = sim;
}
@ -64,6 +80,7 @@ struct IOUSimilarityFunctor {
const T* y_;
T* z_;
const size_t cols_;
bool normalized_;
};
namespace paddle {
@ -75,12 +92,14 @@ class IOUSimilarityKernel : public framework::OpKernel<T> {
void Compute(const framework::ExecutionContext& ctx) const override {
const framework::LoDTensor* in_x = ctx.Input<framework::LoDTensor>("X");
const framework::Tensor* in_y = ctx.Input<framework::Tensor>("Y");
bool normalized = ctx.Attr<bool>("box_normalized");
framework::LoDTensor* out = ctx.Output<framework::LoDTensor>("Out");
int x_n = in_x->dims()[0];
int y_n = in_y->dims()[0];
IOUSimilarityFunctor<T> functor(in_x->data<T>(), in_y->data<T>(),
out->mutable_data<T>(ctx.GetPlace()), y_n);
out->mutable_data<T>(ctx.GetPlace()), y_n,
normalized);
platform::ForRange<DeviceContext> for_range(
static_cast<const DeviceContext&>(ctx.device_context()), x_n * y_n);

7
python/paddle/fluid/layers/detection.py
Unescape View File

@ -653,14 +653,15 @@ def detection_output(loc,
@templatedoc()
def iou_similarity(x, y, name=None):
def iou_similarity(x, y, box_normalized=True, name=None):
"""
${comment}
Args:
x (Variable): ${x_comment}.The data type is float32 or float64.
y (Variable): ${y_comment}.The data type is float32 or float64.
box_normalized(bool): Whether treat the priorbox as a noramlized box.
Set true by default.
Returns:
Variable: ${out_comment}.The data type is same with x.
@ -700,7 +701,7 @@ def iou_similarity(x, y, name=None):
type="iou_similarity",
inputs={"X": x,
"Y": y},
attrs={},
attrs={"box_normalized": box_normalized},
outputs={"Out": out})
return out

42
python/paddle/fluid/tests/unittests/test_iou_similarity_op.py
Unescape View File

@ -31,27 +31,40 @@ class TestIOUSimilarityOp(OpTest):
self.boxes1 = random.rand(2, 4).astype('float32')
self.boxes2 = random.rand(3, 4).astype('float32')
self.output = random.rand(2, 3).astype('float32')
self.box_normalized = False
# run python iou computation
self._compute_iou()
self.inputs = {'X': self.boxes1, 'Y': self.boxes2}
self.attrs = {"box_normalized": self.box_normalized}
self.outputs = {'Out': self.output}
def _compute_iou(self, ):
for row in range(self.boxes1.shape[0]):
for col in range(self.boxes2.shape[0]):
xmin1, ymin1, xmax1, ymax1 = self.boxes1[row]
xmin2, ymin2, xmax2, ymax2 = self.boxes2[col]
area1 = (ymax1 - ymin1) * (xmax1 - xmin1)
area2 = (ymax2 - ymin2) * (xmax2 - xmin2)
if not self.box_normalized:
area1 = (ymax1 - ymin1 + 1) * (xmax1 - xmin1 + 1)
area2 = (ymax2 - ymin2 + 1) * (xmax2 - xmin2 + 1)
else:
area1 = (ymax1 - ymin1) * (xmax1 - xmin1)
area2 = (ymax2 - ymin2) * (xmax2 - xmin2)
inter_xmax = min(xmax1, xmax2)
inter_ymax = min(ymax1, ymax2)
inter_xmin = max(xmin1, xmin2)
inter_ymin = max(ymin1, ymin2)
inter_height = inter_ymax - inter_ymin
inter_width = inter_xmax - inter_xmin
if not self.box_normalized:
inter_height += 1
inter_width += 1
inter_height = max(inter_height, 0)
inter_width = max(inter_width, 0)
inter_area = inter_width * inter_height
union_area = area1 + area2 - inter_area
sim_score = inter_area / union_area
self.output[row, col] = sim_score
self.inputs = {'X': self.boxes1, 'Y': self.boxes2}
self.outputs = {'Out': self.output}
class TestIOUSimilarityOpWithLoD(TestIOUSimilarityOp):
@ -62,8 +75,27 @@ class TestIOUSimilarityOpWithLoD(TestIOUSimilarityOp):
super(TestIOUSimilarityOpWithLoD, self).setUp()
self.boxes1_lod = [[1, 1]]
self.output_lod = [[1, 1]]
self.box_normalized = False
# run python iou computation
self._compute_iou()
self.inputs = {'X': (self.boxes1, self.boxes1_lod), 'Y': self.boxes2}
self.attrs = {"box_normalized": self.box_normalized}
self.outputs = {'Out': (self.output, self.output_lod)}
class TestIOUSimilarityOpWithBoxNormalized(TestIOUSimilarityOp):
def test_check_output(self):
self.check_output(check_dygraph=False)
def setUp(self):
super(TestIOUSimilarityOpWithBoxNormalized, self).setUp()
self.boxes1_lod = [[1, 1]]
self.output_lod = [[1, 1]]
self.box_normalized = True
# run python iou computation
self._compute_iou()
self.inputs = {'X': (self.boxes1, self.boxes1_lod), 'Y': self.boxes2}
self.attrs = {"box_normalized": self.box_normalized}
self.outputs = {'Out': (self.output, self.output_lod)}

Write Preview
Loading…
Cancel
Save