From 26f03ea13d14a28c199185aa1fd5feda84d4eb6e Mon Sep 17 00:00:00 2001 From: wanghaox Date: Tue, 30 Jan 2018 19:49:50 +0800 Subject: [PATCH] update detection_map operator --- paddle/operators/detection_map_op.cc | 73 ++++- paddle/operators/detection_map_op.cu | 20 -- paddle/operators/detection_map_op.h | 249 +++++++++--------- paddle/operators/math/detection_util.cc | 22 -- paddle/operators/math/detection_util.cu | 23 -- paddle/operators/math/detection_util.h | 128 --------- .../v2/fluid/tests/test_detection_map_op.py | 71 ++--- 7 files changed, 231 insertions(+), 355 deletions(-) delete mode 100644 paddle/operators/detection_map_op.cu delete mode 100644 paddle/operators/math/detection_util.cc delete mode 100644 paddle/operators/math/detection_util.cu delete mode 100644 paddle/operators/math/detection_util.h diff --git a/paddle/operators/detection_map_op.cc b/paddle/operators/detection_map_op.cc index b59d3bfad9..aa47cb3c80 100644 --- a/paddle/operators/detection_map_op.cc +++ b/paddle/operators/detection_map_op.cc @@ -24,6 +24,29 @@ class DetectionMAPOp : public framework::OperatorWithKernel { using framework::OperatorWithKernel::OperatorWithKernel; void InferShape(framework::InferShapeContext* ctx) const override { + PADDLE_ENFORCE(ctx->HasInput("Detection"), + "Input(Detection) of DetectionMAPOp should not be null."); + PADDLE_ENFORCE(ctx->HasInput("Label"), + "Input(Label) of DetectionMAPOp should not be null."); + PADDLE_ENFORCE(ctx->HasOutput("MAP"), + "Output(MAP) of DetectionMAPOp should not be null."); + + auto det_dims = ctx->GetInputDim("Detection"); + PADDLE_ENFORCE_EQ(det_dims.size(), 2UL, + "The rank of Input(Detection) must be 2, " + "the shape is [N, 6]."); + PADDLE_ENFORCE_EQ(det_dims[1], 6UL, + "The shape is of Input(Detection) [N, 6]."); + auto label_dims = ctx->GetInputDim("Label"); + PADDLE_ENFORCE_EQ(label_dims.size(), 2UL, + "The rank of Input(Label) must be 2, " + "the shape is [N, 6]."); + PADDLE_ENFORCE_EQ(label_dims[1], 6UL, + "The shape is of Input(Label) [N, 6]."); + + auto ap_type = GetAPType(ctx->Attrs().Get("ap_type")); + PADDLE_ENFORCE_NE(ap_type, APType::kNone, + "The ap_type should be 'integral' or '11point."); auto map_dim = framework::make_ddim({1}); ctx->SetOutputDim("MAP", map_dim); } @@ -42,25 +65,49 @@ class DetectionMAPOpMaker : public framework::OpProtoAndCheckerMaker { DetectionMAPOpMaker(framework::OpProto* proto, framework::OpAttrChecker* op_checker) : OpProtoAndCheckerMaker(proto, op_checker) { - AddInput("Detect", "The detection output."); - AddInput("Label", "The label data."); - AddOutput("MAP", "The MAP evaluate result of the detection."); - - AddAttr("overlap_threshold", "The overlap threshold.") + AddInput("Label", + "(LoDTensor) A 2-D LoDTensor with shape[N, 6] represents the" + "Labeled ground-truth data. Each row has 6 values: " + "[label, is_difficult, xmin, ymin, xmax, ymax], N is the total " + "number of ground-truth data in this mini-batch. For each " + "instance, the offsets in first dimension are called LoD, " + "the number of offset is N + 1, if LoD[i + 1] - LoD[i] == 0, " + "means there is no ground-truth data."); + AddInput("Detection", + "(LoDTensor) A 2-D LoDTensor with shape [M, 6] represents the " + "detections. Each row has 6 values: " + "[label, confidence, xmin, ymin, xmax, ymax], M is the total " + "number of detections in this mini-batch. For each instance, " + "the offsets in first dimension are called LoD, the number of " + "offset is N + 1, if LoD[i + 1] - LoD[i] == 0, means there is " + "no detected data."); + AddOutput("MAP", + "(Tensor) A tensor with shape [1], store the mAP evaluate " + "result of the detection."); + + AddAttr("overlap_threshold", + "(float) " + "The jaccard overlap threshold of detection output and " + "ground-truth data.") .SetDefault(.3f); AddAttr("evaluate_difficult", + "(bool, default true) " "Switch to control whether the difficult data is evaluated.") .SetDefault(true); AddAttr("ap_type", - "The AP algorithm type, 'Integral' or '11point'.") - .SetDefault("Integral"); - + "(string, default 'integral') " + "The AP algorithm type, 'integral' or '11point'.") + .SetDefault("integral") + .InEnum({"integral", "11point"}); AddComment(R"DOC( -Detection MAP Operator. - -Detection MAP evaluator for SSD(Single Shot MultiBox Detector) algorithm. -Please get more information from the following papers: -https://arxiv.org/abs/1512.02325. +Detection mAP evaluate operator. +The general steps are as follows. First, calculate the true positive and + false positive according to the input of detection and labels, then + calculate the mAP evaluate value. + Supporting '11 point' and 'integral' mAP algorithm. Please get more information + from the following articles: + https://sanchom.wordpress.com/tag/average-precision/ + https://arxiv.org/abs/1512.02325 )DOC"); } diff --git a/paddle/operators/detection_map_op.cu b/paddle/operators/detection_map_op.cu deleted file mode 100644 index ab9a992c36..0000000000 --- a/paddle/operators/detection_map_op.cu +++ /dev/null @@ -1,20 +0,0 @@ -/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve. - -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/operators/detection_map_op.h" - -namespace ops = paddle::operators; -REGISTER_OP_CUDA_KERNEL( - detection_map, ops::DetectionMAPOpKernel, - ops::DetectionMAPOpKernel); diff --git a/paddle/operators/detection_map_op.h b/paddle/operators/detection_map_op.h index 3e862abda6..d29a6968e4 100644 --- a/paddle/operators/detection_map_op.h +++ b/paddle/operators/detection_map_op.h @@ -13,22 +13,37 @@ See the License for the specific language governing permissions and limitations under the License. */ #pragma once +#include "paddle/framework/eigen.h" #include "paddle/framework/op_registry.h" -#include "paddle/operators/math/detection_util.h" -#include "paddle/operators/math/math_function.h" namespace paddle { namespace operators { +enum APType { kNone = 0, kIntegral, k11point }; + +APType GetAPType(std::string str) { + if (str == "integral") { + return APType::kIntegral; + } else if (str == "11point") { + return APType::k11point; + } else { + return APType::kNone; + } +} + +template +inline bool SortScorePairDescend(const std::pair& pair1, + const std::pair& pair2) { + return pair1.first > pair2.first; +} + template inline void GetAccumulation(std::vector> in_pairs, std::vector* accu_vec) { - std::stable_sort(in_pairs.begin(), in_pairs.end(), - math::SortScorePairDescend); + std::stable_sort(in_pairs.begin(), in_pairs.end(), SortScorePairDescend); accu_vec->clear(); size_t sum = 0; for (size_t i = 0; i < in_pairs.size(); ++i) { - // auto score = in_pairs[i].first; auto count = in_pairs[i].second; sum += count; accu_vec->push_back(sum); @@ -39,126 +54,125 @@ template class DetectionMAPOpKernel : public framework::OpKernel { public: void Compute(const framework::ExecutionContext& ctx) const override { - auto* input_label = ctx.Input("Label"); - auto* input_detect = ctx.Input("Detect"); - auto* map_out = ctx.Output("MAP"); + auto* in_detect = ctx.Input("Detection"); + auto* in_label = ctx.Input("Label"); + auto* out_map = ctx.Output("MAP"); float overlap_threshold = ctx.Attr("overlap_threshold"); float evaluate_difficult = ctx.Attr("evaluate_difficult"); - std::string ap_type = ctx.Attr("ap_type"); + auto ap_type = GetAPType(ctx.Attr("ap_type")); - auto label_lod = input_label->lod(); + auto label_lod = in_label->lod(); + auto detect_lod = in_detect->lod(); PADDLE_ENFORCE_EQ(label_lod.size(), 1UL, "Only support one level sequence now."); - auto batch_size = label_lod[0].size() - 1; - - std::vector>>> gt_bboxes; - - std::vector< - std::map>>>> - detect_bboxes; - - if (platform::is_gpu_place(ctx.GetPlace())) { - framework::LoDTensor input_label_cpu; - framework::Tensor input_detect_cpu; - input_label_cpu.set_lod(input_label->lod()); - input_label_cpu.Resize(input_label->dims()); - input_detect_cpu.Resize(input_detect->dims()); - input_label_cpu.mutable_data(platform::CPUPlace()); - input_detect_cpu.mutable_data(platform::CPUPlace()); - framework::CopyFrom(*input_label, platform::CPUPlace(), - ctx.device_context(), &input_label_cpu); - framework::CopyFrom(*input_detect, platform::CPUPlace(), - ctx.device_context(), &input_detect_cpu); - GetBBoxes(input_label_cpu, input_detect_cpu, gt_bboxes, detect_bboxes); - } else { - GetBBoxes(*input_label, *input_detect, gt_bboxes, detect_bboxes); - } + PADDLE_ENFORCE_EQ(label_lod[0].size(), detect_lod[0].size(), + "The batch_size of input(Label) and input(Detection) " + "must be the same."); + + std::vector>> gt_boxes; + std::vector>>> detect_boxes; + + GetBoxes(*in_label, *in_detect, gt_boxes, detect_boxes); std::map label_pos_count; std::map>> true_pos; std::map>> false_pos; - CalcTrueAndFalsePositive(batch_size, evaluate_difficult, overlap_threshold, - gt_bboxes, detect_bboxes, label_pos_count, - true_pos, false_pos); + CalcTrueAndFalsePositive(gt_boxes, detect_boxes, evaluate_difficult, + overlap_threshold, label_pos_count, true_pos, + false_pos); T map = CalcMAP(ap_type, label_pos_count, true_pos, false_pos); - T* map_data = nullptr; - framework::Tensor map_cpu; - map_out->mutable_data(ctx.GetPlace()); - if (platform::is_gpu_place(ctx.GetPlace())) { - map_data = map_cpu.mutable_data(map_out->dims(), platform::CPUPlace()); - map_data[0] = map; - framework::CopyFrom(map_cpu, platform::CPUPlace(), ctx.device_context(), - map_out); + T* map_data = out_map->mutable_data(ctx.GetPlace()); + map_data[0] = map; + } + + protected: + struct Box { + Box(T xmin, T ymin, T xmax, T ymax) + : xmin(xmin), ymin(ymin), xmax(xmax), ymax(ymax), is_difficult(false) {} + + T xmin, ymin, xmax, ymax; + bool is_difficult; + }; + + inline T JaccardOverlap(const Box& box1, const Box& box2) const { + if (box2.xmin > box1.xmax || box2.xmax < box1.xmin || + box2.ymin > box1.ymax || box2.ymax < box1.ymin) { + return 0.0; } else { - map_data = map_out->mutable_data(ctx.GetPlace()); - map_data[0] = map; + T inter_xmin = std::max(box1.xmin, box2.xmin); + T inter_ymin = std::max(box1.ymin, box2.ymin); + T inter_xmax = std::min(box1.xmax, box2.xmax); + T inter_ymax = std::min(box1.ymax, box2.ymax); + + T inter_width = inter_xmax - inter_xmin; + T inter_height = inter_ymax - inter_ymin; + T inter_area = inter_width * inter_height; + + T bbox_area1 = (box1.xmax - box1.xmin) * (box1.ymax - box1.ymin); + T bbox_area2 = (box2.xmax - box2.xmin) * (box2.ymax - box2.ymin); + + return inter_area / (bbox_area1 + bbox_area2 - inter_area); } } - protected: - void GetBBoxes( - const framework::LoDTensor& input_label, - const framework::Tensor& input_detect, - std::vector>>>& - gt_bboxes, - std::vector< - std::map>>>>& - detect_bboxes) const { - const T* label_data = input_label.data(); - const T* detect_data = input_detect.data(); + void GetBoxes(const framework::LoDTensor& input_label, + const framework::LoDTensor& input_detect, + std::vector>>& gt_boxes, + std::vector>>>& + detect_boxes) const { + auto labels = framework::EigenTensor::From(input_label); + auto detect = framework::EigenTensor::From(input_detect); auto label_lod = input_label.lod(); - auto batch_size = label_lod[0].size() - 1; + auto detect_lod = input_detect.lod(); + + int batch_size = label_lod[0].size() - 1; auto label_index = label_lod[0]; - for (size_t n = 0; n < batch_size; ++n) { - std::map>> bboxes; + for (int n = 0; n < batch_size; ++n) { + std::map> boxes; for (int i = label_index[n]; i < label_index[n + 1]; ++i) { - std::vector> bbox; - math::GetBBoxFromLabelData(label_data + i * 6, 1, bbox); - int label = static_cast(label_data[i * 6]); - bboxes[label].push_back(bbox[0]); + Box box(labels(i, 2), labels(i, 3), labels(i, 4), labels(i, 5)); + int label = labels(i, 0); + auto is_difficult = labels(i, 1); + if (std::abs(is_difficult - 0.0) < 1e-6) + box.is_difficult = false; + else + box.is_difficult = true; + boxes[label].push_back(box); } - gt_bboxes.push_back(bboxes); + gt_boxes.push_back(boxes); } - size_t n = 0; - size_t detect_box_count = input_detect.dims()[0]; - for (size_t img_id = 0; img_id < batch_size; ++img_id) { - std::map>>> bboxes; - size_t cur_img_id = static_cast((detect_data + n * 7)[0]); - while (cur_img_id == img_id && n < detect_box_count) { - std::vector label; - std::vector score; - std::vector> bbox; - math::GetBBoxFromDetectData(detect_data + n * 7, 1, label, score, - bbox); - bboxes[label[0]].push_back(std::make_pair(score[0], bbox[0])); - ++n; - cur_img_id = static_cast((detect_data + n * 7)[0]); + auto detect_index = detect_lod[0]; + for (int n = 0; n < batch_size; ++n) { + std::map>> boxes; + for (int i = detect_index[n]; i < detect_index[n + 1]; ++i) { + Box box(detect(i, 2), detect(i, 3), detect(i, 4), detect(i, 5)); + int label = detect(i, 0); + auto score = detect(i, 1); + boxes[label].push_back(std::make_pair(score, box)); } - detect_bboxes.push_back(bboxes); + detect_boxes.push_back(boxes); } } void CalcTrueAndFalsePositive( - size_t batch_size, bool evaluate_difficult, float overlap_threshold, - const std::vector>>>& - gt_bboxes, - const std::vector< - std::map>>>>& - detect_bboxes, + const std::vector>>& gt_boxes, + const std::vector>>>& + detect_boxes, + bool evaluate_difficult, float overlap_threshold, std::map& label_pos_count, std::map>>& true_pos, std::map>>& false_pos) const { - for (size_t n = 0; n < batch_size; ++n) { - auto image_gt_bboxes = gt_bboxes[n]; - for (auto it = image_gt_bboxes.begin(); it != image_gt_bboxes.end(); - ++it) { + int batch_size = gt_boxes.size(); + for (int n = 0; n < batch_size; ++n) { + auto image_gt_boxes = gt_boxes[n]; + for (auto it = image_gt_boxes.begin(); it != image_gt_boxes.end(); ++it) { size_t count = 0; auto labeled_bboxes = it->second; if (evaluate_difficult) { @@ -179,16 +193,16 @@ class DetectionMAPOpKernel : public framework::OpKernel { } } - for (size_t n = 0; n < detect_bboxes.size(); ++n) { - auto image_gt_bboxes = gt_bboxes[n]; - auto detections = detect_bboxes[n]; + for (size_t n = 0; n < detect_boxes.size(); ++n) { + auto image_gt_boxes = gt_boxes[n]; + auto detections = detect_boxes[n]; - if (image_gt_bboxes.size() == 0) { + if (image_gt_boxes.size() == 0) { for (auto it = detections.begin(); it != detections.end(); ++it) { - auto pred_bboxes = it->second; + auto pred_boxes = it->second; int label = it->first; - for (size_t i = 0; i < pred_bboxes.size(); ++i) { - auto score = pred_bboxes[i].first; + for (size_t i = 0; i < pred_boxes.size(); ++i) { + auto score = pred_boxes[i].first; true_pos[label].push_back(std::make_pair(score, 0)); false_pos[label].push_back(std::make_pair(score, 1)); } @@ -198,28 +212,27 @@ class DetectionMAPOpKernel : public framework::OpKernel { for (auto it = detections.begin(); it != detections.end(); ++it) { int label = it->first; - auto pred_bboxes = it->second; - if (image_gt_bboxes.find(label) == image_gt_bboxes.end()) { - for (size_t i = 0; i < pred_bboxes.size(); ++i) { - auto score = pred_bboxes[i].first; + auto pred_boxes = it->second; + if (image_gt_boxes.find(label) == image_gt_boxes.end()) { + for (size_t i = 0; i < pred_boxes.size(); ++i) { + auto score = pred_boxes[i].first; true_pos[label].push_back(std::make_pair(score, 0)); false_pos[label].push_back(std::make_pair(score, 1)); } continue; } - auto matched_bboxes = image_gt_bboxes.find(label)->second; + auto matched_bboxes = image_gt_boxes.find(label)->second; std::vector visited(matched_bboxes.size(), false); // Sort detections in descend order based on scores - std::sort(pred_bboxes.begin(), pred_bboxes.end(), - math::SortScorePairDescend>); - for (size_t i = 0; i < pred_bboxes.size(); ++i) { - float max_overlap = -1.0; + std::sort(pred_boxes.begin(), pred_boxes.end(), + SortScorePairDescend); + for (size_t i = 0; i < pred_boxes.size(); ++i) { + T max_overlap = -1.0; size_t max_idx = 0; - auto score = pred_bboxes[i].first; + auto score = pred_boxes[i].first; for (size_t j = 0; j < matched_bboxes.size(); ++j) { - float overlap = - JaccardOverlap(pred_bboxes[i].second, matched_bboxes[j]); + T overlap = JaccardOverlap(pred_boxes[i].second, matched_bboxes[j]); if (overlap > max_overlap) { max_overlap = overlap; max_idx = j; @@ -249,7 +262,7 @@ class DetectionMAPOpKernel : public framework::OpKernel { } T CalcMAP( - std::string ap_type, const std::map& label_pos_count, + APType ap_type, const std::map& label_pos_count, const std::map>>& true_pos, const std::map>>& false_pos) const { T mAP = 0.0; @@ -266,18 +279,18 @@ class DetectionMAPOpKernel : public framework::OpKernel { GetAccumulation(label_true_pos, &tp_sum); std::vector fp_sum; GetAccumulation(label_false_pos, &fp_sum); - std::vector precision, recall; + std::vector precision, recall; size_t num = tp_sum.size(); // Compute Precision. for (size_t i = 0; i < num; ++i) { // CHECK_LE(tpCumSum[i], labelNumPos); - precision.push_back(static_cast(tp_sum[i]) / - static_cast(tp_sum[i] + fp_sum[i])); - recall.push_back(static_cast(tp_sum[i]) / label_num_pos); + precision.push_back(static_cast(tp_sum[i]) / + static_cast(tp_sum[i] + fp_sum[i])); + recall.push_back(static_cast(tp_sum[i]) / label_num_pos); } // VOC2007 style - if (ap_type == "11point") { - std::vector max_precisions(11, 0.0); + if (ap_type == APType::k11point) { + std::vector max_precisions(11, 0.0); int start_idx = num - 1; for (int j = 10; j >= 0; --j) for (int i = start_idx; i >= 0; --i) { @@ -292,7 +305,7 @@ class DetectionMAPOpKernel : public framework::OpKernel { } for (int j = 10; j >= 0; --j) mAP += max_precisions[j] / 11; ++count; - } else if (ap_type == "Integral") { + } else if (ap_type == APType::kIntegral) { // Nature integral float average_precisions = 0.; float prev_recall = 0.; diff --git a/paddle/operators/math/detection_util.cc b/paddle/operators/math/detection_util.cc deleted file mode 100644 index 4131a0cb0e..0000000000 --- a/paddle/operators/math/detection_util.cc +++ /dev/null @@ -1,22 +0,0 @@ -/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve. - -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/operators/math/detection_util.h" -#include "paddle/operators/math/math_function.h" - -namespace paddle { -namespace operators { -namespace math {} // namespace math -} // namespace operators -} // namespace paddle diff --git a/paddle/operators/math/detection_util.cu b/paddle/operators/math/detection_util.cu deleted file mode 100644 index d2bb992396..0000000000 --- a/paddle/operators/math/detection_util.cu +++ /dev/null @@ -1,23 +0,0 @@ -/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve. - -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/operators/math/detection_util.h" -#include "paddle/operators/math/math_function.h" -#include "paddle/platform/cuda_helper.h" - -namespace paddle { -namespace operators { -namespace math {} // namespace math -} // namespace operators -} // namespace paddle diff --git a/paddle/operators/math/detection_util.h b/paddle/operators/math/detection_util.h deleted file mode 100644 index 2a4dadc545..0000000000 --- a/paddle/operators/math/detection_util.h +++ /dev/null @@ -1,128 +0,0 @@ -/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve. - -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 "paddle/framework/selected_rows.h" -#include "paddle/platform/device_context.h" - -namespace paddle { -namespace operators { -namespace math { - -template -struct BBox { - BBox(T x_min, T y_min, T x_max, T y_max) - : x_min(x_min), - y_min(y_min), - x_max(x_max), - y_max(y_max), - is_difficult(false) {} - - BBox() {} - - T get_width() const { return x_max - x_min; } - - T get_height() const { return y_max - y_min; } - - T get_center_x() const { return (x_min + x_max) / 2; } - - T get_center_y() const { return (y_min + y_max) / 2; } - - T get_area() const { return get_width() * get_height(); } - - // coordinate of bounding box - T x_min; - T y_min; - T x_max; - T y_max; - // whether difficult object (e.g. object with heavy occlusion is difficult) - bool is_difficult; -}; - -template -void GetBBoxFromDetectData(const T* detect_data, const size_t num_bboxes, - std::vector& labels, std::vector& scores, - std::vector>& bboxes) { - size_t out_offset = bboxes.size(); - labels.resize(out_offset + num_bboxes); - scores.resize(out_offset + num_bboxes); - bboxes.resize(out_offset + num_bboxes); - for (size_t i = 0; i < num_bboxes; ++i) { - labels[out_offset + i] = *(detect_data + i * 7 + 1); - scores[out_offset + i] = *(detect_data + i * 7 + 2); - BBox bbox; - bbox.x_min = *(detect_data + i * 7 + 3); - bbox.y_min = *(detect_data + i * 7 + 4); - bbox.x_max = *(detect_data + i * 7 + 5); - bbox.y_max = *(detect_data + i * 7 + 6); - bboxes[out_offset + i] = bbox; - }; -} - -template -void GetBBoxFromLabelData(const T* label_data, const size_t num_bboxes, - std::vector>& bboxes) { - size_t out_offset = bboxes.size(); - bboxes.resize(bboxes.size() + num_bboxes); - for (size_t i = 0; i < num_bboxes; ++i) { - BBox bbox; - bbox.x_min = *(label_data + i * 6 + 1); - bbox.y_min = *(label_data + i * 6 + 2); - bbox.x_max = *(label_data + i * 6 + 3); - bbox.y_max = *(label_data + i * 6 + 4); - T is_difficult = *(label_data + i * 6 + 5); - if (std::abs(is_difficult - 0.0) < 1e-6) - bbox.is_difficult = false; - else - bbox.is_difficult = true; - bboxes[out_offset + i] = bbox; - } -} - -template -inline float JaccardOverlap(const BBox& bbox1, const BBox& bbox2) { - if (bbox2.x_min > bbox1.x_max || bbox2.x_max < bbox1.x_min || - bbox2.y_min > bbox1.y_max || bbox2.y_max < bbox1.y_min) { - return 0.0; - } else { - float inter_x_min = std::max(bbox1.x_min, bbox2.x_min); - float inter_y_min = std::max(bbox1.y_min, bbox2.y_min); - float inter_x_max = std::min(bbox1.x_max, bbox2.x_max); - float inter_y_max = std::min(bbox1.y_max, bbox2.y_max); - - float inter_width = inter_x_max - inter_x_min; - float inter_height = inter_y_max - inter_y_min; - float inter_area = inter_width * inter_height; - - float bbox_area1 = bbox1.get_area(); - float bbox_area2 = bbox2.get_area(); - - return inter_area / (bbox_area1 + bbox_area2 - inter_area); - } -} - -template -bool SortScorePairDescend(const std::pair& pair1, - const std::pair& pair2) { - return pair1.first > pair2.first; -} - -// template <> -// bool SortScorePairDescend(const std::pair& pair1, -// const std::pair& pair2) { -// return pair1.first > pair2.first; -// } - -} // namespace math -} // namespace operators -} // namespace paddle diff --git a/python/paddle/v2/fluid/tests/test_detection_map_op.py b/python/paddle/v2/fluid/tests/test_detection_map_op.py index 50ce3afbb9..bb545031ae 100644 --- a/python/paddle/v2/fluid/tests/test_detection_map_op.py +++ b/python/paddle/v2/fluid/tests/test_detection_map_op.py @@ -10,14 +10,14 @@ class TestDetectionMAPOp(OpTest): def set_data(self): self.init_test_case() - self.mAP = [self.calc_map(self.tf_pos)] + self.mAP = [self.calc_map(self.tf_pos, self.tf_pos_lod)] self.label = np.array(self.label).astype('float32') self.detect = np.array(self.detect).astype('float32') self.mAP = np.array(self.mAP).astype('float32') self.inputs = { 'Label': (self.label, self.label_lod), - 'Detect': self.detect + 'Detection': (self.detect, self.detect_lod) } self.attrs = { @@ -31,29 +31,29 @@ class TestDetectionMAPOp(OpTest): def init_test_case(self): self.overlap_threshold = 0.3 self.evaluate_difficult = True - self.ap_type = "Integral" + self.ap_type = "integral" self.label_lod = [[0, 2, 4]] - # label xmin ymin xmax ymax difficult - self.label = [[1, 0.1, 0.1, 0.3, 0.3, 0], [1, 0.6, 0.6, 0.8, 0.8, 1], - [2, 0.3, 0.3, 0.6, 0.5, 0], [1, 0.7, 0.1, 0.9, 0.3, 0]] + # label difficult xmin ymin xmax ymax + self.label = [[1, 0, 0.1, 0.1, 0.3, 0.3], [1, 1, 0.6, 0.6, 0.8, 0.8], + [2, 0, 0.3, 0.3, 0.6, 0.5], [1, 0, 0.7, 0.1, 0.9, 0.3]] - # image_id label score xmin ymin xmax ymax difficult + # label score xmin ymin xmax ymax difficult + self.detect_lod = [[0, 3, 7]] self.detect = [ - [0, 1, 0.3, 0.1, 0.0, 0.4, 0.3], [0, 1, 0.7, 0.0, 0.1, 0.2, 0.3], - [0, 1, 0.9, 0.7, 0.6, 0.8, 0.8], [1, 2, 0.8, 0.2, 0.1, 0.4, 0.4], - [1, 2, 0.1, 0.4, 0.3, 0.7, 0.5], [1, 1, 0.2, 0.8, 0.1, 1.0, 0.3], - [1, 3, 0.2, 0.8, 0.1, 1.0, 0.3] + [1, 0.3, 0.1, 0.0, 0.4, 0.3], [1, 0.7, 0.0, 0.1, 0.2, 0.3], + [1, 0.9, 0.7, 0.6, 0.8, 0.8], [2, 0.8, 0.2, 0.1, 0.4, 0.4], + [2, 0.1, 0.4, 0.3, 0.7, 0.5], [1, 0.2, 0.8, 0.1, 1.0, 0.3], + [3, 0.2, 0.8, 0.1, 1.0, 0.3] ] - # image_id label score false_pos false_pos - # [-1, 1, 3, -1, -1], - # [-1, 2, 1, -1, -1] - self.tf_pos = [[0, 1, 0.9, 1, 0], [0, 1, 0.7, 1, 0], [0, 1, 0.3, 0, 1], - [1, 1, 0.2, 1, 0], [1, 2, 0.8, 0, 1], [1, 2, 0.1, 1, 0], - [1, 3, 0.2, 0, 1]] + # label score true_pos false_pos + self.tf_pos_lod = [[0, 3, 7]] + self.tf_pos = [[1, 0.9, 1, 0], [1, 0.7, 1, 0], [1, 0.3, 0, 1], + [1, 0.2, 1, 0], [2, 0.8, 0, 1], [2, 0.1, 1, 0], + [3, 0.2, 0, 1]] - def calc_map(self, tf_pos): + def calc_map(self, tf_pos, tf_pos_lod): mAP = 0.0 count = 0 @@ -71,7 +71,7 @@ class TestDetectionMAPOp(OpTest): return accu_list label_count = collections.Counter() - for (label, xmin, ymin, xmax, ymax, difficult) in self.label: + for (label, difficult, xmin, ymin, xmax, ymax) in self.label: if self.evaluate_difficult: label_count[label] += 1 elif not difficult: @@ -79,7 +79,7 @@ class TestDetectionMAPOp(OpTest): true_pos = collections.defaultdict(list) false_pos = collections.defaultdict(list) - for (image_id, label, score, tp, fp) in tf_pos: + for (label, score, tp, fp) in tf_pos: true_pos[label].append([score, tp]) false_pos[label].append([score, fp]) @@ -103,22 +103,22 @@ class TestDetectionMAPOp(OpTest): recall.append(float(accu_tp_sum[i]) / label_pos_num) if self.ap_type == "11point": - max_precisions = [11.0, 0.0] + max_precisions = [0.0] * 11 start_idx = len(accu_tp_sum) - 1 - for j in range(10, 0, -1): - for i in range(start_idx, 0, -1): - if recall[i] < j / 10.0: + for j in range(10, -1, -1): + for i in range(start_idx, -1, -1): + if recall[i] < float(j) / 10.0: start_idx = i if j > 0: max_precisions[j - 1] = max_precisions[j] break - else: - if max_precisions[j] < accu_precision[i]: - max_precisions[j] = accu_precision[i] - for j in range(10, 0, -1): + else: + if max_precisions[j] < precision[i]: + max_precisions[j] = precision[i] + for j in range(10, -1, -1): mAP += max_precisions[j] / 11 count += 1 - elif self.ap_type == "Integral": + elif self.ap_type == "integral": average_precisions = 0.0 prev_recall = 0.0 for i in range(len(accu_tp_sum)): @@ -147,8 +147,17 @@ class TestDetectionMAPOpSkipDiff(TestDetectionMAPOp): self.evaluate_difficult = False - self.tf_pos = [[0, 1, 0.7, 1, 0], [0, 1, 0.3, 0, 1], [1, 1, 0.2, 1, 0], - [1, 2, 0.8, 0, 1], [1, 2, 0.1, 1, 0], [1, 3, 0.2, 0, 1]] + self.tf_pos_lod = [[0, 2, 6]] + # label score true_pos false_pos + self.tf_pos = [[1, 0.7, 1, 0], [1, 0.3, 0, 1], [1, 0.2, 1, 0], + [2, 0.8, 0, 1], [2, 0.1, 1, 0], [3, 0.2, 0, 1]] + + +class TestDetectionMAPOp11Point(TestDetectionMAPOp): + def init_test_case(self): + super(TestDetectionMAPOp11Point, self).init_test_case() + + self.ap_type = "11point" if __name__ == '__main__': -- GitLab