jerrywgz
7 years ago
parent
685a20ef56
commit
0f652f304c
@ -0,0 +1,93 @@
|
|||||||
|
/* Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
|
||||||
|
|
||||||
|
Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
you may not use this file except in compliance with the License.
|
||||||
|
You may obtain a copy of the License at
|
||||||
|
|
||||||
|
http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
|
||||||
|
Unless required by applicable law or agreed to in writing, software
|
||||||
|
distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
See the License for the specific language governing permissions and
|
||||||
|
limitations under the License. */
|
||||||
|
|
||||||
|
#include "paddle/fluid/operators/detection/distribute_fpn_proposals_op.h"
|
||||||
|
|
||||||
|
namespace paddle {
|
||||||
|
namespace operators {
|
||||||
|
|
||||||
|
class DistributeFpnProposalsOp : public framework::OperatorWithKernel {
|
||||||
|
public:
|
||||||
|
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||||
|
|
||||||
|
void InferShape(framework::InferShapeContext* ctx) const override {
|
||||||
|
PADDLE_ENFORCE(ctx->HasInput("FpnRois"),
|
||||||
|
"Input(FpnRois) shouldn't be null");
|
||||||
|
PADDLE_ENFORCE_GE(
|
||||||
|
ctx->Outputs("MultiFpnRois").size(), 1UL,
|
||||||
|
"Outputs(MultiFpnRois) of DistributeOp should not be empty");
|
||||||
|
size_t min_level = static_cast<size_t>(ctx->Attrs().Get<int>("min_level"));
|
||||||
|
size_t max_level = static_cast<size_t>(ctx->Attrs().Get<int>("max_level"));
|
||||||
|
PADDLE_ENFORCE_GE(max_level, min_level,
|
||||||
|
"max_level must not lower than min_level");
|
||||||
|
// Set the output shape
|
||||||
|
size_t num_out_rois = max_level - min_level + 1;
|
||||||
|
std::vector<framework::DDim> outs_dims;
|
||||||
|
outs_dims.reserve(num_out_rois);
|
||||||
|
for (size_t i = 0; i < num_out_rois; ++i) {
|
||||||
|
framework::DDim out_dim = {-1, 4};
|
||||||
|
outs_dims.push_back(out_dim);
|
||||||
|
}
|
||||||
|
ctx->SetOutputsDim("MultiFpnRois", outs_dims);
|
||||||
|
ctx->SetOutputDim("RestoreIndex", {1, -1});
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
framework::OpKernelType GetExpectedKernelType(
|
||||||
|
const framework::ExecutionContext& ctx) const override {
|
||||||
|
auto data_type = framework::GetDataTypeOfVar(ctx.InputVar("FpnRois"));
|
||||||
|
return framework::OpKernelType(data_type, platform::CPUPlace());
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
class DistributeFpnProposalsOpMaker : public framework::OpProtoAndCheckerMaker {
|
||||||
|
public:
|
||||||
|
void Make() override {
|
||||||
|
AddInput("FpnRois", "(LoDTensor) The rois at all levels in shape (-1, 4)");
|
||||||
|
AddOutput("MultiFpnRois", "(LoDTensor) Output with distribute operator")
|
||||||
|
.AsDuplicable();
|
||||||
|
AddOutput("RestoreIndex",
|
||||||
|
"(Tensor) An array of positive number which is "
|
||||||
|
"used to restore the order of FpnRois");
|
||||||
|
AddAttr<int>("min_level",
|
||||||
|
"The lowest level of FPN layer where the"
|
||||||
|
" proposals come from");
|
||||||
|
AddAttr<int>("max_level",
|
||||||
|
"The highest level of FPN layer where the"
|
||||||
|
" proposals come from");
|
||||||
|
AddAttr<int>("refer_level",
|
||||||
|
"The referring level of FPN layer with"
|
||||||
|
" specified scale");
|
||||||
|
AddAttr<int>("refer_scale",
|
||||||
|
"The referring scale of FPN layer with"
|
||||||
|
" specified level");
|
||||||
|
AddComment(R"DOC(
|
||||||
|
This operator distribute all proposals into different fpn level,
|
||||||
|
with respect to scale of the proposals, the referring scale and
|
||||||
|
the referring level. Besides, to restore the order of proposals,
|
||||||
|
we return an array which indicate the original index of rois in
|
||||||
|
current proposals.
|
||||||
|
)DOC");
|
||||||
|
}
|
||||||
|
};
|
||||||
|
} // namespace operators
|
||||||
|
} // namespace paddle
|
||||||
|
|
||||||
|
namespace ops = paddle::operators;
|
||||||
|
REGISTER_OPERATOR(distribute_fpn_proposals, ops::DistributeFpnProposalsOp,
|
||||||
|
ops::DistributeFpnProposalsOpMaker,
|
||||||
|
paddle::framework::EmptyGradOpMaker);
|
||||||
|
REGISTER_OP_CPU_KERNEL(distribute_fpn_proposals,
|
||||||
|
ops::DistributeFpnProposalsOpKernel<float>,
|
||||||
|
ops::DistributeFpnProposalsOpKernel<double>);
|
||||||
@ -0,0 +1,147 @@
|
|||||||
|
/* Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
|
||||||
|
|
||||||
|
Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
you may not use this file except in compliance with the License.
|
||||||
|
You may obtain a copy of the License at
|
||||||
|
|
||||||
|
http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
|
||||||
|
Unless required by applicable law or agreed to in writing, software
|
||||||
|
distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
See the License for the specific language governing permissions and
|
||||||
|
limitations under the License. */
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
#include <cmath>
|
||||||
|
#include <cstring>
|
||||||
|
#include <string>
|
||||||
|
#include <vector>
|
||||||
|
#include "paddle/fluid/framework/op_registry.h"
|
||||||
|
#include "paddle/fluid/operators/detail/safe_ref.h"
|
||||||
|
#include "paddle/fluid/operators/gather.h"
|
||||||
|
#include "paddle/fluid/operators/math/math_function.h"
|
||||||
|
|
||||||
|
namespace paddle {
|
||||||
|
namespace operators {
|
||||||
|
|
||||||
|
const int kBoxDim = 4;
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
static inline T BBoxArea(const T* box, bool normalized) {
|
||||||
|
if (box[2] < box[0] || box[3] < box[1]) {
|
||||||
|
// If coordinate values are is invalid
|
||||||
|
// (e.g. xmax < xmin or ymax < ymin), return 0.
|
||||||
|
return static_cast<T>(0.);
|
||||||
|
} else {
|
||||||
|
const T w = box[2] - box[0];
|
||||||
|
const T h = box[3] - box[1];
|
||||||
|
if (normalized) {
|
||||||
|
return w * h;
|
||||||
|
} else {
|
||||||
|
// If coordinate values are not within range [0, 1].
|
||||||
|
return (w + 1) * (h + 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
class DistributeFpnProposalsOpKernel : public framework::OpKernel<T> {
|
||||||
|
public:
|
||||||
|
void Compute(const framework::ExecutionContext& context) const override {
|
||||||
|
auto* fpn_rois = context.Input<paddle::framework::LoDTensor>("FpnRois");
|
||||||
|
|
||||||
|
auto multi_fpn_rois =
|
||||||
|
context.MultiOutput<paddle::framework::LoDTensor>("MultiFpnRois");
|
||||||
|
|
||||||
|
auto* restore_index =
|
||||||
|
context.Output<paddle::framework::Tensor>("RestoreIndex");
|
||||||
|
|
||||||
|
const int min_level = context.Attr<int>("min_level");
|
||||||
|
const int max_level = context.Attr<int>("max_level");
|
||||||
|
const int refer_level = context.Attr<int>("refer_level");
|
||||||
|
const int refer_scale = context.Attr<int>("refer_scale");
|
||||||
|
const int num_level = max_level - min_level + 1;
|
||||||
|
|
||||||
|
// check that the fpn_rois is not empty
|
||||||
|
PADDLE_ENFORCE_EQ(fpn_rois->lod().size(), 1UL,
|
||||||
|
"DistributeFpnProposalsOp need 1 level of LoD");
|
||||||
|
|
||||||
|
auto fpn_rois_lod = fpn_rois->lod().back();
|
||||||
|
int fpn_rois_num = fpn_rois_lod[fpn_rois_lod.size() - 1];
|
||||||
|
std::vector<int> target_level;
|
||||||
|
// std::vector<int> target_level(fpn_rois_num, -1);
|
||||||
|
// record the number of rois in each level
|
||||||
|
std::vector<int> num_rois_level(num_level, 0);
|
||||||
|
std::vector<int> num_rois_level_integral(num_level + 1, 0);
|
||||||
|
for (int i = 0; i < fpn_rois_lod.size() - 1; ++i) {
|
||||||
|
Tensor fpn_rois_slice =
|
||||||
|
fpn_rois->Slice(fpn_rois_lod[i], fpn_rois_lod[i + 1]);
|
||||||
|
const T* rois_data = fpn_rois_slice.data<T>();
|
||||||
|
for (int j = 0; j < fpn_rois_slice.dims()[0]; ++j) {
|
||||||
|
// get the target level of current rois
|
||||||
|
T roi_scale = std::sqrt(BBoxArea(rois_data, false));
|
||||||
|
int tgt_lvl =
|
||||||
|
std::floor(std::log2(roi_scale / refer_scale) + refer_level);
|
||||||
|
tgt_lvl = std::min(max_level, std::max(tgt_lvl, min_level));
|
||||||
|
target_level.push_back(tgt_lvl);
|
||||||
|
num_rois_level[tgt_lvl - min_level]++;
|
||||||
|
rois_data += kBoxDim;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// define the output rois
|
||||||
|
// pointer which point to each level fpn rois
|
||||||
|
T* multi_fpn_rois_data[num_level];
|
||||||
|
// lod0 which will record the offset information of each level rois
|
||||||
|
std::vector<std::vector<size_t>> multi_fpn_rois_lod0;
|
||||||
|
for (int i = 0; i < num_level; ++i) {
|
||||||
|
// allocate memory for each level rois
|
||||||
|
multi_fpn_rois[i]->mutable_data<T>({num_rois_level[i], kBoxDim},
|
||||||
|
context.GetPlace());
|
||||||
|
multi_fpn_rois_data[i] = multi_fpn_rois[i]->data<T>();
|
||||||
|
std::vector<size_t> lod0(1, 0);
|
||||||
|
multi_fpn_rois_lod0.push_back(lod0);
|
||||||
|
// statistic start point for each level rois
|
||||||
|
num_rois_level_integral[i + 1] =
|
||||||
|
num_rois_level_integral[i] + num_rois_level[i];
|
||||||
|
}
|
||||||
|
restore_index->mutable_data<int>({1, fpn_rois_num}, context.GetPlace());
|
||||||
|
int* restore_index_data = restore_index->data<int>();
|
||||||
|
std::vector<int> restore_index_inter(fpn_rois_num, -1);
|
||||||
|
// distribute the rois into different fpn level by target level
|
||||||
|
for (int i = 0; i < fpn_rois_lod.size() - 1; ++i) {
|
||||||
|
Tensor fpn_rois_slice =
|
||||||
|
fpn_rois->Slice(fpn_rois_lod[i], fpn_rois_lod[i + 1]);
|
||||||
|
const T* rois_data = fpn_rois_slice.data<T>();
|
||||||
|
size_t cur_offset = fpn_rois_lod[i];
|
||||||
|
// std::vector<size_t > lod_offset[num_level];
|
||||||
|
for (int j = 0; j < num_level; j++) {
|
||||||
|
multi_fpn_rois_lod0[j].push_back(multi_fpn_rois_lod0[j][i]);
|
||||||
|
}
|
||||||
|
for (int j = 0; j < fpn_rois_slice.dims()[0]; ++j) {
|
||||||
|
int lvl = target_level[cur_offset + j];
|
||||||
|
memcpy(multi_fpn_rois_data[lvl - min_level], rois_data,
|
||||||
|
kBoxDim * sizeof(T));
|
||||||
|
multi_fpn_rois_data[lvl - min_level] += kBoxDim;
|
||||||
|
int index_in_shuffle = num_rois_level_integral[lvl - min_level] +
|
||||||
|
multi_fpn_rois_lod0[lvl - min_level][i + 1];
|
||||||
|
restore_index_inter[index_in_shuffle] = cur_offset + j;
|
||||||
|
multi_fpn_rois_lod0[lvl - min_level][i + 1]++;
|
||||||
|
rois_data += kBoxDim;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for (int i = 0; i < fpn_rois_num; ++i) {
|
||||||
|
restore_index_data[restore_index_inter[i]] = i;
|
||||||
|
}
|
||||||
|
// merge lod information into LoDTensor
|
||||||
|
for (int i = 0; i < num_level; ++i) {
|
||||||
|
framework::LoD lod;
|
||||||
|
lod.emplace_back(multi_fpn_rois_lod0[i]);
|
||||||
|
multi_fpn_rois[i]->set_lod(lod);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
} // namespace operators
|
||||||
|
} // namespace paddle
|
||||||
@ -0,0 +1,117 @@
|
|||||||
|
# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
|
||||||
|
#
|
||||||
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
# you may not use this file except in compliance with the License.
|
||||||
|
# You may obtain a copy of the License at
|
||||||
|
#
|
||||||
|
# http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
#
|
||||||
|
# Unless required by applicable law or agreed to in writing, software
|
||||||
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
# See the License for the specific language governing permissions and
|
||||||
|
# limitations under the License.
|
||||||
|
|
||||||
|
from __future__ import print_function
|
||||||
|
|
||||||
|
import unittest
|
||||||
|
import numpy as np
|
||||||
|
import math
|
||||||
|
import sys
|
||||||
|
from op_test import OpTest
|
||||||
|
|
||||||
|
|
||||||
|
class TestDistributeFPNProposalsOp(OpTest):
|
||||||
|
def set_data(self):
|
||||||
|
self.init_test_case()
|
||||||
|
self.make_rois()
|
||||||
|
self.rois_fpn, self.rois_idx_restore = self.calc_rois_distribute()
|
||||||
|
self.inputs = {'FpnRois': (self.rois[:, 1:5], self.rois_lod)}
|
||||||
|
self.attrs = {
|
||||||
|
'max_level': self.roi_max_level,
|
||||||
|
'min_level': self.roi_min_level,
|
||||||
|
'refer_scale': self.canonical_scale,
|
||||||
|
'refer_level': self.canonical_level
|
||||||
|
}
|
||||||
|
output = [('out%d' % i, self.rois_fpn[i])
|
||||||
|
for i in range(len(self.rois_fpn))]
|
||||||
|
self.outputs = {
|
||||||
|
'MultiFpnRois': output,
|
||||||
|
'RestoreIndex': self.rois_idx_restore
|
||||||
|
}
|
||||||
|
|
||||||
|
def init_test_case(self):
|
||||||
|
self.roi_max_level = 5
|
||||||
|
self.roi_min_level = 2
|
||||||
|
self.canonical_scale = 224
|
||||||
|
self.canonical_level = 4
|
||||||
|
self.images_shape = [512, 512]
|
||||||
|
|
||||||
|
def boxes_area(self, boxes):
|
||||||
|
w = (boxes[:, 2] - boxes[:, 0] + 1)
|
||||||
|
h = (boxes[:, 3] - boxes[:, 1] + 1)
|
||||||
|
areas = w * h
|
||||||
|
assert np.all(areas >= 0), 'Negative areas founds'
|
||||||
|
return areas
|
||||||
|
|
||||||
|
def map_rois_to_fpn_levels(self, rois, lvl_min, lvl_max):
|
||||||
|
s = np.sqrt(self.boxes_area(rois))
|
||||||
|
s0 = self.canonical_scale
|
||||||
|
lvl0 = self.canonical_level
|
||||||
|
target_lvls = np.floor(lvl0 + np.log2(s / s0 + 1e-6))
|
||||||
|
target_lvls = np.clip(target_lvls, lvl_min, lvl_max)
|
||||||
|
return target_lvls
|
||||||
|
|
||||||
|
def get_sub_lod(self, sub_lvl):
|
||||||
|
sub_lod = []
|
||||||
|
max_batch_id = sub_lvl[-1]
|
||||||
|
for i in range(max_batch_id.astype(np.int32) + 1):
|
||||||
|
sub_lod.append(np.where(sub_lvl == i)[0].size)
|
||||||
|
return sub_lod
|
||||||
|
|
||||||
|
def add_multilevel_roi(self, rois, target_lvls, lvl_min, lvl_max):
|
||||||
|
rois_idx_order = np.empty((0, ))
|
||||||
|
rois_fpn = []
|
||||||
|
for lvl in range(lvl_min, lvl_max + 1):
|
||||||
|
idx_lvl = np.where(target_lvls == lvl)[0]
|
||||||
|
if len(idx_lvl) == 0:
|
||||||
|
rois_fpn.append((np.empty(shape=(0, 4)), [[0, 0]]))
|
||||||
|
continue
|
||||||
|
sub_lod = self.get_sub_lod(rois[idx_lvl, 0])
|
||||||
|
rois_fpn.append((rois[idx_lvl, 1:], [sub_lod]))
|
||||||
|
rois_idx_order = np.concatenate((rois_idx_order, idx_lvl))
|
||||||
|
rois_idx_restore = np.argsort(rois_idx_order).astype(
|
||||||
|
np.int32, copy=False)
|
||||||
|
return rois_fpn, rois_idx_restore
|
||||||
|
|
||||||
|
def calc_rois_distribute(self):
|
||||||
|
lvl_min = self.roi_min_level
|
||||||
|
lvl_max = self.roi_max_level
|
||||||
|
target_lvls = self.map_rois_to_fpn_levels(self.rois[:, 1:5], lvl_min,
|
||||||
|
lvl_max)
|
||||||
|
rois_fpn, rois_idx_restore = self.add_multilevel_roi(
|
||||||
|
self.rois, target_lvls, lvl_min, lvl_max)
|
||||||
|
return rois_fpn, rois_idx_restore
|
||||||
|
|
||||||
|
def make_rois(self):
|
||||||
|
self.rois_lod = [[100, 200]]
|
||||||
|
rois = []
|
||||||
|
lod = self.rois_lod[0]
|
||||||
|
bno = 0
|
||||||
|
for roi_num in lod:
|
||||||
|
for i in range(roi_num):
|
||||||
|
xywh = np.random.rand(4)
|
||||||
|
xy1 = xywh[0:2] * 20
|
||||||
|
wh = xywh[2:4] * (self.images_shape - xy1)
|
||||||
|
xy2 = xy1 + wh
|
||||||
|
roi = [bno, xy1[0], xy1[1], xy2[0], xy2[1]]
|
||||||
|
rois.append(roi)
|
||||||
|
bno += 1
|
||||||
|
self.rois = np.array(rois).astype("float32")
|
||||||
|
|
||||||
|
def setUp(self):
|
||||||
|
self.op_type = "distribute_fpn_proposals"
|
||||||
|
self.set_data()
|
||||||
|
|
||||||
|
def test_check_output(self):
|
||||||
|
self.check_output()
|
||||||
Loading…
Reference in new issue