diff --git a/mace/ops/prior_box.cc b/mace/ops/prior_box.cc index a9ac07732f29d38721997cec5db35b1de388f09b..3226d2be63f0380feac80f9ddd52cb7172da928f 100644 --- a/mace/ops/prior_box.cc +++ b/mace/ops/prior_box.cc @@ -31,7 +31,6 @@ class PriorBoxOp : public Operation { min_size_(Operation::GetRepeatedArgs("min_size")), max_size_(Operation::GetRepeatedArgs("max_size")), aspect_ratio_(Operation::GetRepeatedArgs("aspect_ratio")), - flip_(Operation::GetOptionalArg("flip", true)), clip_(Operation::GetOptionalArg("clip", false)), variance_(Operation::GetRepeatedArgs("variance")), offset_(Operation::GetOptionalArg("offset", 0.5)) {} @@ -43,28 +42,30 @@ class PriorBoxOp : public Operation { Tensor *output = this->Output(OUTPUT); const std::vector &input_shape = input->shape(); const std::vector &data_shape = data->shape(); - const index_t input_w = input_shape[3]; const index_t input_h = input_shape[2]; - const index_t image_w = data_shape[3]; + const index_t input_w = input_shape[3]; const index_t image_h = data_shape[2]; - float step_h = static_cast(image_h) / static_cast(input_h); - float step_w = static_cast(image_w) / static_cast(input_w); - if (Operation::GetOptionalArg("step_h", 0) != 0 && - Operation::GetOptionalArg("step_w", 0) != 0) { - step_h = Operation::GetOptionalArg("step_h", 0); - step_w = Operation::GetOptionalArg("step_w", 0); + const index_t image_w = data_shape[3]; + float step_h = Operation::GetOptionalArg("step_h", 0); + float step_w = Operation::GetOptionalArg("step_w", 0); + if (step_h <= 1e-6 || step_w <= 1e-6) { + step_h = static_cast(image_h) / static_cast(input_h); + step_w = static_cast(image_w) / static_cast(input_w); } - const index_t num_min_size = min_size_.size(); MACE_CHECK(num_min_size > 0, "min_size is required!"); const index_t num_max_size = max_size_.size(); const index_t num_aspect_ratio = aspect_ratio_.size(); - MACE_CHECK(num_aspect_ratio > 0, "aspect_ratio is required!"); - index_t num_prior = num_min_size * num_aspect_ratio + - num_min_size + num_max_size; - if (flip_) - num_prior += num_min_size * num_aspect_ratio; + index_t num_prior = num_min_size * num_aspect_ratio; + if (num_max_size > 0) { + MACE_CHECK(max_size_.size() == min_size_.size()); + for (size_t i = 0; i < max_size_.size(); ++i) { + MACE_CHECK(max_size_[i] > min_size_[i], + "max_size must be greater than min_size."); + num_prior += 1; + } + } index_t dim = 4 * input_w * input_h * num_prior; std::vector output_shape = {1, 2, dim}; @@ -79,7 +80,7 @@ class PriorBoxOp : public Operation { float center_x = (offset_ + j) * step_w; for (index_t k = 0; k < num_min_size; ++k) { float min_s = min_size_[k]; - box_w = box_h = min_s * 0.5; + box_w = box_h = min_s * 0.5f; output_data[idx + 0] = (center_x - box_w) / image_w; output_data[idx + 1] = (center_y - box_h) / image_h; output_data[idx + 2] = (center_x + box_w) / image_w; @@ -96,6 +97,9 @@ class PriorBoxOp : public Operation { } for (int l = 0; l < num_aspect_ratio; ++l) { float ar = aspect_ratio_[l]; + if (fabsf(ar - 1.f) < 1e-6) { + continue; + } box_w = min_s * sqrt(ar) * 0.5f; box_h = min_s / sqrt(ar) * 0.5f; output_data[idx + 0] = (center_x - box_w) / image_w; @@ -103,13 +107,6 @@ class PriorBoxOp : public Operation { output_data[idx + 2] = (center_x + box_w) / image_w; output_data[idx + 3] = (center_y + box_h) / image_h; idx += 4; - if (flip_) { - output_data[idx + 0] = (center_x - box_h) / image_w; - output_data[idx + 1] = (center_y - box_w) / image_h; - output_data[idx + 2] = (center_x + box_h) / image_w; - output_data[idx + 3] = (center_y + box_w) / image_h; - idx += 4; - } } } } @@ -140,7 +137,6 @@ class PriorBoxOp : public Operation { std::vector min_size_; std::vector max_size_; std::vector aspect_ratio_; - bool flip_; bool clip_; std::vector variance_; const float offset_; diff --git a/mace/ops/prior_box_benchmark.cc b/mace/ops/prior_box_benchmark.cc index 200c13b854bdd8a4bf5661e02a5dc62c59ec7523..f218e8ef9abb890adc07d4d2ccc4809a37ec098c 100644 --- a/mace/ops/prior_box_benchmark.cc +++ b/mace/ops/prior_box_benchmark.cc @@ -15,15 +15,14 @@ #include "mace/core/testing/test_benchmark.h" #include "mace/ops/ops_test_util.h" - namespace mace { namespace ops { namespace test { namespace { -template +template void PriorBox( - int iters, float min_size, float max_size, float aspect_ratio, int flip, + int iters, float min_size, float max_size, float aspect_ratio, int clip, float variance0, float variance1, float offset, int h) { mace::testing::StopTiming(); @@ -40,7 +39,6 @@ void PriorBox( .AddFloatsArg("min_size", {min_size}) .AddFloatsArg("max_size", {max_size}) .AddFloatsArg("aspect_ratio", {aspect_ratio}) - .AddIntArg("flip", flip) .AddIntArg("clip", clip) .AddFloatsArg("variance", {variance0, variance0, variance1, variance1}) .AddFloatArg("offset", offset) @@ -59,16 +57,16 @@ void PriorBox( } } // namespace -#define MACE_BM_PRIOR_BOX(MIN, MAX, AR, FLIP, CLIP, V0, V1, OFFSET, H) \ - static void MACE_BM_PRIOR_BOX_##MIN##_##MAX##_##AR##_##FLIP##_##CLIP##_##V0##\ - _##V1##_##OFFSET##_##H(int iters) { \ - PriorBox(iters, MIN, MAX, AR, FLIP, CLIP, V0, V1, \ - OFFSET, H); \ - } \ - MACE_BENCHMARK(MACE_BM_PRIOR_BOX_##MIN##_##MAX##_##AR##_##FLIP##_##CLIP##_## \ - V0##_##V1##_##OFFSET##_##H) +#define MACE_BM_PRIOR_BOX(MIN, MAX, AR, CLIP, V0, V1, OFFSET, H) \ + static void MACE_BM_PRIOR_BOX_##MIN##_##MAX##_##AR##_##CLIP##_##V0##_##V1##_\ + ##OFFSET##_##H(int iters) { \ + PriorBox(iters, MIN, MAX, AR, CLIP, V0, V1, \ + OFFSET, H); \ + } \ + MACE_BENCHMARK(MACE_BM_PRIOR_BOX_##MIN##_##MAX##_##AR##_##CLIP##_##V0##_ \ + ##V1##_##OFFSET##_##H) -MACE_BM_PRIOR_BOX(285, 300, 2, 1, 0, 1, 2, 1, 128); +MACE_BM_PRIOR_BOX(285, 300, 2, 0, 1, 2, 1, 128); } // namespace test } // namespace ops diff --git a/mace/ops/prior_box_test.cc b/mace/ops/prior_box_test.cc index c4d6978ce27c408488d30678fbf8d6d0f2d09963..5bdd4f87cf55deacc1faa750b1b505c4000f7634 100644 --- a/mace/ops/prior_box_test.cc +++ b/mace/ops/prior_box_test.cc @@ -32,8 +32,7 @@ TEST_F(PriorBoxOpTest, Simple) { .Output("OUTPUT") .AddFloatsArg("min_size", {285}) .AddFloatsArg("max_size", {300}) - .AddFloatsArg("aspect_ratio", {2, 3}) - .AddIntArg("flip", 1) + .AddFloatsArg("aspect_ratio", {1, 2, 0.5, 3, 0.33333333333}) .AddIntArg("clip", 0) .AddFloatsArg("variance", {0.1, 0.1, 0.2, 0.2}) .AddFloatArg("offset", 0.5) diff --git a/mace/ops/reshape.cc b/mace/ops/reshape.cc index da9b00bdfa509dad2f954f53489281904db47382..f082cf31a9dbf35aad4ce2ca65c5f4cb6d5679e7 100644 --- a/mace/ops/reshape.cc +++ b/mace/ops/reshape.cc @@ -103,27 +103,6 @@ void RegisterReshape(OpRegistryBase *op_registry) { DeviceType::CPU, float); MACE_REGISTER_OP(op_registry, "Reshape", ReshapeOp, DeviceType::CPU, int32_t); -#ifdef MACE_ENABLE_OPENCL - MACE_REGISTER_OP(op_registry, "Reshape", ReshapeOp, - DeviceType::GPU, float); - MACE_REGISTER_OP(op_registry, "Reshape", ReshapeOp, - DeviceType::GPU, half); -#endif // MACE_ENABLE_OPENCL - - MACE_REGISTER_OP_CONDITION( - op_registry, - OpConditionBuilder("Reshape") - .SetDevicePlacerFunc( - [](OpConstructContext *context) -> std::set { - auto op = context->operator_def(); - if (op->output_shape_size() != op->output_size()) { - return { DeviceType::CPU, DeviceType::GPU }; - } - if (op->output_shape(0).dims_size() != 4) { - return { DeviceType::CPU }; - } - return { DeviceType::CPU, DeviceType::GPU }; - })); } } // namespace ops diff --git a/mace/python/tools/converter_tool/caffe_converter.py b/mace/python/tools/converter_tool/caffe_converter.py index 6c46f35dd4a09aa3981240750f7c8ce1b5cfb854..3231ea9fa58b9f6e43470250c2997f37b3ed87c3 100644 --- a/mace/python/tools/converter_tool/caffe_converter.py +++ b/mace/python/tools/converter_tool/caffe_converter.py @@ -717,14 +717,25 @@ class CaffeConverter(base_converter.ConverterInterface): max_size_arg = op.arg.add() max_size_arg.name = MaceKeyword.mace_max_size_str max_size_arg.floats.extend(list(param.max_size)) - aspect_ratio_arg = op.arg.add() - aspect_ratio_arg.name = MaceKeyword.mace_aspect_ratio_str - aspect_ratio_arg.floats.extend(list(param.aspect_ratio)) flip_arg = op.arg.add() flip_arg.name = MaceKeyword.mace_flip_str flip_arg.i = 1 if param.HasField('flip'): flip_arg.i = int(param.flip) + aspect_ratio = [1.0] + for i in param.aspect_ratio: + already_exist = False + for ar in aspect_ratio: + if abs(i - ar) < 1e-6: + already_exist = True + break + if not already_exist: + aspect_ratio.append(i) + if flip_arg.i: + aspect_ratio.append(1.0 / i) + aspect_ratio_arg = op.arg.add() + aspect_ratio_arg.name = MaceKeyword.mace_aspect_ratio_str + aspect_ratio_arg.floats.extend(list(aspect_ratio)) clip_arg = op.arg.add() clip_arg.name = MaceKeyword.mace_clip_str clip_arg.i = 0 diff --git a/mace/python/tools/converter_tool/shape_inference.py b/mace/python/tools/converter_tool/shape_inference.py index 870412ae8d8ab4c50114592ae72ba1144d039362..3e472216efa3651a663a32ee2db729497d059ff2 100644 --- a/mace/python/tools/converter_tool/shape_inference.py +++ b/mace/python/tools/converter_tool/shape_inference.py @@ -246,11 +246,8 @@ class ShapeInference(object): min_size = ConverterUtil.get_arg(op, MaceKeyword.mace_min_size_str).floats # noqa max_size = ConverterUtil.get_arg(op, MaceKeyword.mace_max_size_str).floats # noqa aspect_ratio = ConverterUtil.get_arg(op, MaceKeyword.mace_aspect_ratio_str).floats # noqa - flip = ConverterUtil.get_arg(op, MaceKeyword.mace_flip_str).i # noqa - num_prior = (len(min_size) * len(aspect_ratio) + - len(min_size) + len(max_size)) - if flip: - num_prior = num_prior + len(min_size) * len(aspect_ratio) + num_prior = len(aspect_ratio) * len(min_size) + len(max_size) + output_shape[2] = num_prior * input_h * input_w * 4 self.add_output_shape(op, [output_shape])