update

paddle/fluid/eager/auto_code_generator/final_state_generator/codegen_utils.py

@@ -48,7 +48,6 @@
     'str[]' : 'std::vector<std::string>', 'float[]' : 'std::vector<float>', \
     'Place' : 'paddle::Place', 'DataLayout' : 'paddle::experimental::DataLayout', 'DataType' : 'paddle::experimental::DataType', \
     'int64_t[]' : 'std::vector<int64_t>', 'int[]' : 'std::vector<int>',
-    'float[]' : 'std::vector<float>', 'double[]' : 'std::vector<double>',
     'Tensor' : 'Tensor',
     'Tensor[]' : 'std::vector<Tensor>',
     'Tensor[Tensor[]]' : 'std::vector<std::vector<Tensor>>',

paddle/fluid/operators/detection/prior_box_op.cc

@@ -215,10 +215,6 @@ REGISTER_OPERATOR(
     paddle::framework::EmptyGradOpMaker<paddle::imperative::OpBase>,
     PriorBoxInferShapeFunctor);
 
-REGISTER_OP_CPU_KERNEL(prior_box,
-                       ops::PriorBoxOpKernel<float, float>,
-                       ops::PriorBoxOpKernel<double, double>);
-
 REGISTER_OP_KERNEL_WITH_CUSTOM_TYPE(prior_box,
                                     MKLDNN,
                                     ::paddle::platform::CPUPlace,

paddle/fluid/operators/detection/prior_box_op.cu

@@ -194,8 +194,3 @@ class PriorBoxOpCUDAKernel : public framework::OpKernel<T> {
 
 }  // namespace operators
 }  // namespace paddle
-
-namespace ops = paddle::operators;
-REGISTER_OP_CUDA_KERNEL(prior_box,
-                        ops::PriorBoxOpCUDAKernel<float>,
-                        ops::PriorBoxOpCUDAKernel<double>);

paddle/phi/api/yaml/generator/api_base.py

@@ -141,8 +141,6 @@ def parse_input_and_attr(self, api_name, args_config, optional_vars=[]):
             'DataType': 'DataType',
             'int64_t[]': 'const std::vector<int64_t>&',
             'int[]': 'const std::vector<int>&',
-            'float[]': 'const std::vector<float>&',
-            'double[]': 'const std::vector<double>&'
         }
         optional_types_trans = {
             'Tensor': 'const paddle::optional<Tensor>&',

paddle/phi/api/yaml/legacy_api.yaml

@@ -1751,7 +1751,7 @@
   backward : prelu_grad
 
 - api : prior_box
-  args : (Tensor x, Tensor y, float[] min_sizes, float[] max_sizes, float[] aspect_ratios, float[] variances, bool flip, bool clip, float step_w, float step_h, float offset, bool min_max_aspect_ratios_order, bool use_mkldnn, bool use_quantizer, str mkldnn_data_type)
+  args : (Tensor input, Tensor image, float[] min_sizes, float[] aspect_ratios, float[] variances, float[] max_sizes = {}, bool flip=true, bool clip=true, float step_w=0.0, float step_h=0.0, float offset=0.5, bool min_max_aspect_ratios_order=false)
   output : Tensor(out), Tensor(var)
   infer_meta :
     func : PriorBoxInferMeta

paddle/phi/infermeta/binary.cc

@@ -1833,25 +1833,22 @@ inline void ExpandAspectRatios(const std::vector<float>& input_aspect_ratior,
   }
 }
 
-void PriorBoxInferMeta(const MetaTensor& x,
-                       const MetaTensor& y,
+void PriorBoxInferMeta(const MetaTensor& input,
+                       const MetaTensor& image,
                        const std::vector<float>& min_sizes,
-                       const std::vector<float>& max_sizes,
                        const std::vector<float>& aspect_ratios,
                        const std::vector<float>& variances,
+                       const std::vector<float>& max_sizes,
                        bool flip,
                        bool clip,
                        float step_w,
                        float step_h,
                        float offset,
                        bool min_max_aspect_ratios_order,
-                       bool use_mkldnn,
-                       bool use_quantizer,
-                       const std::string& mkldnn_data_type,
                        MetaTensor* out,
                        MetaTensor* var) {
-  auto image_dims = y.dims();
-  auto input_dims = x.dims();
+  auto image_dims = image.dims();
+  auto input_dims = input.dims();
 
   PADDLE_ENFORCE_EQ(
       image_dims.size(),
@@ -1910,6 +1907,8 @@ void PriorBoxInferMeta(const MetaTensor& x,
   dim_vec[2] = num_priors;
   dim_vec[3] = 4;
 
+  out->set_dtype(input.dtype());
+  var->set_dtype(input.dtype());
   out->set_dims(phi::make_ddim(dim_vec));
   var->set_dims(phi::make_ddim(dim_vec));
 }

paddle/phi/infermeta/binary.h

@@ -256,21 +256,18 @@ void PReluInferMeta(const MetaTensor& x,
                     MetaTensor* out,
                     MetaConfig config = MetaConfig());
 
-void PriorBoxInferMeta(const MetaTensor& x,
-                       const MetaTensor& y,
+void PriorBoxInferMeta(const MetaTensor& input,
+                       const MetaTensor& image,
                        const std::vector<float>& min_sizes,
-                       const std::vector<float>& max_sizes,
                        const std::vector<float>& aspect_ratios,
                        const std::vector<float>& variances,
+                       const std::vector<float>& max_sizes,
                        bool flip,
                        bool clip,
                        float step_w,
                        float step_h,
                        float offset,
                        bool min_max_aspect_ratios_order,
-                       bool use_mkldnn,
-                       bool use_quantizer,
-                       const std::string& mkldnn_data_type,
                        MetaTensor* out,
                        MetaTensor* var);
 

paddle/phi/kernels/cpu/prior_box_kernel.cc

@@ -14,30 +14,25 @@
 
 #include "paddle/phi/kernels/prior_box_kernel.h"
 
-#include "paddle/phi/backends/cpu/cpu_context.h"
-#include "paddle/phi/common/complex.h"
 #include "paddle/phi/core/kernel_registry.h"
 #include "paddle/phi/kernels/funcs/eigen/common.h"
 
 namespace phi {
 
 template <typename T, typename Context>
 void PriorBoxKernel(const Context& ctx,
-                    const DenseTensor& x,
-                    const DenseTensor& y,
+                    const DenseTensor& input,
+                    const DenseTensor& image,
                     const std::vector<float>& min_sizes,
-                    const std::vector<float>& max_sizes,
                     const std::vector<float>& aspect_ratios,
                     const std::vector<float>& variances,
+                    const std::vector<float>& max_sizes,
                     bool flip,
                     bool clip,
                     float step_w,
                     float step_h,
                     float offset,
                     bool min_max_aspect_ratios_order,
-                    bool use_mkldnn,
-                    bool use_quantizer,
-                    const std::string& mkldnn_data_type,
                     DenseTensor* out,
                     DenseTensor* var) {
   std::vector<float> new_aspect_ratios;
@@ -47,11 +42,11 @@ void PriorBoxKernel(const Context& ctx,
   T new_step_h = static_cast<T>(step_h);
   T new_offset = static_cast<T>(offset);
 
-  auto img_width = y.dims()[3];
-  auto img_height = y.dims()[2];
+  auto img_width = image.dims()[3];
+  auto img_height = image.dims()[2];
 
-  auto feature_width = x.dims()[3];
-  auto feature_height = x.dims()[2];
+  auto feature_width = input.dims()[3];
+  auto feature_height = input.dims()[2];
 
   T step_width, step_height;
   if (new_step_w == 0 || new_step_h == 0) {

paddle/phi/kernels/gpu/prior_box_kernel.cu

@@ -108,21 +108,18 @@ __global__ void SetVariance(T* out,
 
 template <typename T, typename Context>
 void PriorBoxKernel(const Context& ctx,
-                    const DenseTensor& x,
-                    const DenseTensor& y,
+                    const DenseTensor& input,
+                    const DenseTensor& image,
                     const std::vector<float>& min_sizes,
-                    const std::vector<float>& max_sizes,
                     const std::vector<float>& aspect_ratios,
                     const std::vector<float>& variances,
+                    const std::vector<float>& max_sizes,
                     bool flip,
                     bool clip,
                     float step_w,
                     float step_h,
                     float offset,
                     bool min_max_aspect_ratios_order,
-                    bool use_mkldnn,
-                    bool use_quantizer,
-                    const std::string& mkldnn_data_type,
                     DenseTensor* out,
                     DenseTensor* var) {
   std::vector<float> new_aspect_ratios;
@@ -132,11 +129,11 @@ void PriorBoxKernel(const Context& ctx,
   T new_step_h = static_cast<T>(step_h);
   T new_offset = static_cast<T>(offset);
 
-  auto im_width = y.dims()[3];
-  auto im_height = y.dims()[2];
+  auto im_width = image.dims()[3];
+  auto im_height = image.dims()[2];
 
-  auto width = x.dims()[3];
-  auto height = x.dims()[2];
+  auto width = input.dims()[3];
+  auto height = input.dims()[2];
 
   T step_width, step_height;
   if (new_step_w == 0 || new_step_h == 0) {
@@ -159,8 +156,8 @@ void PriorBoxKernel(const Context& ctx,
 
   auto stream = ctx.stream();
 
-  out->mutable_data<T>(ctx.GetPlace());
-  var->mutable_data<T>(ctx.GetPlace());
+  ctx.template Alloc<T>(out);
+  ctx.template Alloc<T>(var);
 
   DenseTensor r;
   paddle::framework::TensorFromVector(new_aspect_ratios, ctx, &r);

paddle/phi/kernels/prior_box_kernel.h

@@ -15,27 +15,23 @@
 #pragma once
 
 #include "paddle/phi/core/dense_tensor.h"
-#include "paddle/phi/core/device_context.h"
 
 namespace phi {
 
 template <typename T, typename Context>
 void PriorBoxKernel(const Context& ctx,
-                    const DenseTensor& x,
-                    const DenseTensor& y,
+                    const DenseTensor& input,
+                    const DenseTensor& image,
                     const std::vector<float>& min_sizes,
-                    const std::vector<float>& max_sizes,
                     const std::vector<float>& aspect_ratios,
                     const std::vector<float>& variances,
+                    const std::vector<float>& max_sizes,
                     bool flip,
                     bool clip,
                     float step_w,
                     float step_h,
                     float offset,
                     bool min_max_aspect_ratios_order,
-                    bool use_mkldnn,
-                    bool use_quantizer,
-                    const std::string& mkldnn_data_type,
                     DenseTensor* out,
                     DenseTensor* var);
 

paddle/phi/ops/compat/prior_box_sig.cc

@@ -0,0 +1,37 @@
+// Copyright (c) 2022 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/phi/core/compat/op_utils.h"
+
+namespace phi {
+
+KernelSignature PriorBoxOpArgumentMapping(const ArgumentMappingContext& ctx) {
+  return KernelSignature("prior_box",
+                         {"Input", "Image"},
+                         {"min_sizes",
+                          "aspect_ratios",
+                          "variances",
+                          "max_sizes",
+                          "flip",
+                          "clip",
+                          "step_w",
+                          "step_h",
+                          "offset",
+                          "min_max_aspect_ratios_order"},
+                         {"Boxes", "Variances"});
+}
+
+}  // namespace phi
+
+PD_REGISTER_ARG_MAPPING_FN(prior_box, phi::PriorBoxOpArgumentMapping);

python/paddle/fluid/layers/detection.py

@@ -1794,18 +1794,20 @@ def __reshape_to_2d(var):
     return loss
 
 
-def prior_box(input,
-              image,
-              min_sizes,
-              max_sizes=None,
-              aspect_ratios=[1.],
-              variance=[0.1, 0.1, 0.2, 0.2],
-              flip=False,
-              clip=False,
-              steps=[0.0, 0.0],
-              offset=0.5,
-              name=None,
-              min_max_aspect_ratios_order=False):
+def prior_box(
+    input,
+    image,
+    min_sizes,
+    max_sizes=None,
+    aspect_ratios=[1.],
+    variance=[0.1, 0.1, 0.2, 0.2],
+    flip=False,
+    clip=False,
+    steps=[0.0, 0.0],
+    offset=0.5,
+    name=None,
+    min_max_aspect_ratios_order=False,
+):
     """
 
     This op generates prior boxes for SSD(Single Shot MultiBox Detector) algorithm.
@@ -1905,12 +1907,15 @@ def prior_box(input,
 		# [6L, 9L, 1L, 4L]
 
     """
+
     if in_dygraph_mode():
-        return _C_ops.core.final_state_prior_box(
-            input, image, "min_sizes", min_sizes, "max_sizes", max_sizes,
-            "aspect_ratios", aspect_ratios, "variances", variances, "flip",
-            flip, "clip", clip, "step_w", step_w, "step_h", step_h, "offset",
-            offset, "min_max_aspect_ratios_order", min_max_aspect_ratios_order)
+        step_w, step_h = steps
+        if max_sizes == None:
+            max_sizes = []
+        return _C_ops.final_state_prior_box(input, image, min_sizes,
+                                            aspect_ratios, variance, max_sizes,
+                                            flip, clip, step_w, step_h, offset,
+                                            min_max_aspect_ratios_order)
     helper = LayerHelper("prior_box", **locals())
     dtype = helper.input_dtype()
     check_variable_and_dtype(input, 'input',