diff --git a/paddle/fluid/eager/auto_code_generator/generator/codegen_utils.py b/paddle/fluid/eager/auto_code_generator/generator/codegen_utils.py index 98421cf35be70b7636b05d2eb80fdf7a33539afc..f51d270cc8a0c90213b58f30e79efb58f0f2a0ba 100644 --- a/paddle/fluid/eager/auto_code_generator/generator/codegen_utils.py +++ b/paddle/fluid/eager/auto_code_generator/generator/codegen_utils.py @@ -292,7 +292,9 @@ def ParseYamlArgs(string): # attrs_list = [ [arg_name, arg_type, default_value, orig_position], ...] attrs_list = [] - args = [x.strip() for x in string.strip().split(",")] + patten = re.compile(r',(?![^{]*\})') # support int[] a={1,3} + args = re.split(patten, string.strip()) + args = [x.strip() for x in args] atype = r'((const )?\S+) ' aname = r'(.*)' pattern = f'{atype}{aname}' diff --git a/paddle/fluid/operators/deformable_conv_op.cc b/paddle/fluid/operators/deformable_conv_op.cc deleted file mode 100644 index d6eff438e0bdb0439c680d2760006493aebdaca6..0000000000000000000000000000000000000000 --- a/paddle/fluid/operators/deformable_conv_op.cc +++ /dev/null @@ -1,196 +0,0 @@ -// 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 - -#include "paddle/fluid/framework/infershape_utils.h" -#include "paddle/fluid/framework/op_registry.h" -#include "paddle/phi/core/infermeta_utils.h" -#include "paddle/phi/infermeta/multiary.h" - -namespace paddle { -namespace operators { -class DeformableConvOpMaker : public framework::OpProtoAndCheckerMaker { - public: - void Make() override { - AddInput("Input", - "(Tensor) The input of deformable conv op. " - "The shape of input is " - "[N, channel_in, H, W]"); - AddInput("Offset", - "(Tensor) The input offset. " - "The shape of the offset is " - "[N, deformable_groups * kernel_w * kernel_h * 2, H, W"); - AddInput("Mask", - "(Tensor) The input mask. " - "The shape of the mask is " - "[N, deformable_groups * kernel_w * kernel_h, H, W]."); - AddInput("Filter", - "(Tensor) The Input Filter " - "The shape of the wight is " - "[num_filters, channel_in, kernel_h, kernel_w."); - AddOutput("Output", - "(Tensor) The output. " - "The shape of the output tensor is " - "[N, num_filters, out_height, out_width]]."); - AddAttr>("strides", - "(vector default:{1, 1}), the " - "strides(h_stride, w_stride) of " - "convolution operator.") - .SetDefault({1, 1}); - AddAttr>("paddings", - "(vector default:{0,0}), the " - "paddings(h_pad, w_pad) of " - "convolution operator. ") - .SetDefault({0, 0}); - AddAttr>("dilations", - "(vector default:{1, 1}), the " - "dilations(h_dilation, w_dilation) of " - "convolution operator.") - .SetDefault({1, 1}); - AddAttr( - "groups", - "(int default:1), the groups number of the convolution operator. " - "According to grouped convolution in Alex Krizhevsky's Deep CNN paper: " - "when group=2, the first half of the filters is only connected to the " - "first half of the input channels, while the second half of the " - "filters " - "is only connected to the second half of the input channels.") - .SetDefault(1); - AddAttr("deformable_groups", - "(int default:1), the number of the deformable groups.") - .SetDefault(1); - AddAttr("im2col_step", - "im2col maximum number of image per computation") - .SetDefault(64); - AddComment(R"DOC( -**Deformable Convolution Operator** - -Compute 2-D deformable convolution on 4-D input. - -Given input image x, output feature map y, the deformable convolution operation can be expressed as follow: - -$$ -y(p) = \\sum_{k=1}^{K}{w_k * x(p + p_k + \\Delta p_k) * \\Delta m_k} -$$ - -Where $$\\Delta p_k$$ and $$\Delta m_k$$ are the learnable offset and modulation scalar for the k-th location, respectively. - -Refer to 'Deformable ConvNets v2: More Deformable, Better Results -' - -Example: - Input: - Input shape: $(N, C_{in}, H_{in}, W_{in})$ - Filter shape: $(C_{out}, C_{in}, H_f, W_f)$ - Offset shape: $(N, 2 * deformable_groups, * H_f * W_f, H_{out}, W_{out})$ - Mask shape: $(N, deformable_groups * H_f * W_f, H_{out}, W_{out})$ - Output: - Output shape: $(N, C_{out}, H_{out}, W_{out})$ - where $H_{out}, W_{out}$ must be equal to $H_{in}, W_{in}$ respectively. - Where -$$ - H_{out}= \frac{(H_{in} + 2 * paddings[0] - (dilations[0] * (H_f - 1) + 1))}{strides[0]}+ 1 \\ - W_{out}= \frac{(W_{in} + 2 * paddings[1] - (dilations[1] * (W_f - 1) + 1))}{strides[1]}+ 1 -$$ -)DOC"); - } -}; - -class DeformableConvOp : public framework::OperatorWithKernel { - public: - using framework::OperatorWithKernel::OperatorWithKernel; - - protected: - phi::KernelKey GetExpectedKernelType( - const framework::ExecutionContext &ctx) const override { - return phi::KernelKey(OperatorWithKernel::IndicateVarDataType(ctx, "Input"), - ctx.device_context().GetPlace()); - } -}; - -template -class DeformableConvGradOpMaker : public framework::SingleGradOpMaker { - public: - using framework::SingleGradOpMaker::SingleGradOpMaker; - - protected: - void Apply(GradOpPtr op) const override { - op->SetType("deformable_conv_grad"); - op->SetInput("Input", this->Input("Input")); - op->SetInput("Filter", this->Input("Filter")); - op->SetInput("Offset", this->Input("Offset")); - op->SetInput("Mask", this->Input("Mask")); - op->SetInput(framework::GradVarName("Output"), this->OutputGrad("Output")); - - op->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input")); - op->SetOutput(framework::GradVarName("Filter"), this->InputGrad("Filter")); - op->SetOutput(framework::GradVarName("Offset"), this->InputGrad("Offset")); - op->SetOutput(framework::GradVarName("Mask"), this->InputGrad("Mask")); - - op->SetAttrMap(this->Attrs()); - } -}; - -class DeformableConvGradOp : public framework::OperatorWithKernel { - public: - using framework::OperatorWithKernel::OperatorWithKernel; - - void InferShape(framework::InferShapeContext *ctx) const override { - auto in_dims = ctx->GetInputDim("Input"); - auto filter_dims = ctx->GetInputDim("Filter"); - auto offset_dims = ctx->GetInputDim("Offset"); - auto mask_dims = ctx->GetInputDim("Mask"); - - OP_INOUT_CHECK(ctx->HasInput(framework::GradVarName("Output")), - "Input", - "Output@Grad", - "deformable_conv_grad"); - if (ctx->HasOutput(framework::GradVarName("Input"))) { - ctx->SetOutputDim(framework::GradVarName("Input"), in_dims); - } - if (ctx->HasOutput(framework::GradVarName("Filter"))) { - ctx->SetOutputDim(framework::GradVarName("Filter"), filter_dims); - } - if (ctx->HasOutput(framework::GradVarName("Offset"))) { - ctx->SetOutputDim(framework::GradVarName("Offset"), offset_dims); - } - if (ctx->HasOutput(framework::GradVarName("Mask"))) { - ctx->SetOutputDim(framework::GradVarName("Mask"), mask_dims); - } - } - - protected: - phi::KernelKey GetExpectedKernelType( - const framework::ExecutionContext &ctx) const override { - return phi::KernelKey(OperatorWithKernel::IndicateVarDataType(ctx, "Input"), - ctx.device_context().GetPlace()); - } -}; -} // namespace operators -} // namespace paddle - -namespace ops = paddle::operators; -DECLARE_INFER_SHAPE_FUNCTOR(deformable_conv, - DeformableConvInferShapeFunctor, - PD_INFER_META(phi::DeformableConvInferMeta)); - -REGISTER_OPERATOR(deformable_conv, - ops::DeformableConvOp, - ops::DeformableConvOpMaker, - ops::DeformableConvGradOpMaker, - ops::DeformableConvGradOpMaker, - DeformableConvInferShapeFunctor); - -REGISTER_OPERATOR(deformable_conv_grad, ops::DeformableConvGradOp); diff --git a/paddle/fluid/operators/generator/parse_utils.py b/paddle/fluid/operators/generator/parse_utils.py index d92fa8bd3e9db5375b80588f22217151f9e3472a..8a8f4935e1e7e2c56cb2cf9b36a2668865c877d8 100644 --- a/paddle/fluid/operators/generator/parse_utils.py +++ b/paddle/fluid/operators/generator/parse_utils.py @@ -167,8 +167,13 @@ def parse_candidates(s: str) -> Dict[str, Any]: def parse_plain_list(s: str, sep=",") -> List[str]: - items = [item.strip() for item in s.strip().split(sep)] - return items + if sep == ",": + patten = re.compile(r',(?![^{]*\})') # support "int[] a={1,2}" + items = re.split(patten, s.strip()) + items = [x.strip() for x in items] + return items + else: + return [item.strip() for item in s.strip().split(sep)] def parse_kernel(op_name: str, kernel_config: Dict[str, Any]) -> Dict[str, Any]: diff --git a/paddle/phi/api/yaml/generator/api_base.py b/paddle/phi/api/yaml/generator/api_base.py index 93ead4586e88ae9a055f50f2066e1754d25f0646..4d41bb522e0028bf1113d7c1ffae8d37ded7c90b 100644 --- a/paddle/phi/api/yaml/generator/api_base.py +++ b/paddle/phi/api/yaml/generator/api_base.py @@ -144,7 +144,9 @@ class BaseAPI: ')' ), f"Args declaration should start with '(' and end with ')', please check the args of {api_name} in yaml." args_str = args_str[1:-1] - args_list = args_str.split(',') + patten = re.compile(r',(?![^{]*\})') # support int[] a={1,3} + args_list = re.split(patten, args_str.strip()) + args_list = [x.strip() for x in args_list] input_types_map = { 'Tensor': 'const Tensor&', 'Tensor[]': 'const std::vector&', diff --git a/paddle/phi/api/yaml/op_compat.yaml b/paddle/phi/api/yaml/op_compat.yaml index 3aba1954f775be7437e8c109890311421c969561..38e39b6b25bbd4cc503727e3f8ad43fb728f9266 100644 --- a/paddle/phi/api/yaml/op_compat.yaml +++ b/paddle/phi/api/yaml/op_compat.yaml @@ -518,6 +518,13 @@ outputs : out : Out +- op : deformable_conv + backward : deformable_conv_grad + inputs : + {x : Input, offset : Offset, filter : Filter, mask : Mask} + outputs : + out : Output + - op : depthwise_conv2d backward : depthwise_conv2d_grad extra : diff --git a/paddle/phi/api/yaml/static_backward.yaml b/paddle/phi/api/yaml/static_backward.yaml index 431cccd1d167124d32c76e3d50d61bc231b7b62c..81aca0a2c57e7efaede5104c6bb7cdbe1ddd6953 100644 --- a/paddle/phi/api/yaml/static_backward.yaml +++ b/paddle/phi/api/yaml/static_backward.yaml @@ -7,6 +7,16 @@ composite: assign_grad(out_grad, x_grad) invoke : assign(out_grad) +- backward_op : deformable_conv_grad + forward : deformable_conv (Tensor x, Tensor offset, Tensor filter, Tensor mask, int[] strides={1, 1}, int[] paddings={0, 0}, int[] dilations={1, 1}, int deformable_groups=1, int groups=1, int im2col_step=64) -> Tensor(out) + args : (Tensor x, Tensor offset, Tensor filter, Tensor mask, Tensor out_grad, int[] strides, int[] paddings, int[] dilations, int deformable_groups, int groups, int im2col_step) + output : Tensor(x_grad), Tensor(offset_grad), Tensor(filter_grad), Tensor(mask_grad) + infer_meta : + func : DeformableConvGradInferMeta + kernel : + func : deformable_conv_grad + data_type : x + - backward_op : embedding_grad forward : embedding (Tensor x, Tensor weight, int64_t padding_idx=-1) -> Tensor(out) args : (Tensor x, Tensor weight, Tensor out_grad, int64_t padding_idx=-1) diff --git a/paddle/phi/api/yaml/static_ops.yaml b/paddle/phi/api/yaml/static_ops.yaml index 802c6b1d46df5415d01942d17efd89dd92c46bec..46c107ad2d64d5512afba07917172979326d08d7 100644 --- a/paddle/phi/api/yaml/static_ops.yaml +++ b/paddle/phi/api/yaml/static_ops.yaml @@ -78,6 +78,16 @@ func : decode_jpeg param : [x, mode] +- op : deformable_conv + args : (Tensor x, Tensor offset, Tensor filter, Tensor mask, int[] strides={1, 1}, int[] paddings={0, 0}, int[] dilations={1, 1}, int deformable_groups=1, int groups=1, int im2col_step=64) + output : Tensor(out) + infer_meta : + func : DeformableConvInferMeta + kernel : + func : deformable_conv + data_type : x + backward : deformable_conv_grad + - op : embedding args : (Tensor x, Tensor weight, int64_t padding_idx=-1) output : Tensor diff --git a/paddle/phi/ops/compat/deformable_conv_sig.cc b/paddle/phi/ops/compat/deformable_conv_sig.cc index aa2537aa10e138554f36d40cd4fbfdeb8b8f6b45..f7c5f4d6a34fe49e1521a2f102e057992e5aef04 100644 --- a/paddle/phi/ops/compat/deformable_conv_sig.cc +++ b/paddle/phi/ops/compat/deformable_conv_sig.cc @@ -16,7 +16,7 @@ namespace phi { -KernelSignature DeformableConvOpArgumentMapping( +KernelSignature DeformableConvOpV1ArgumentMapping( const ArgumentMappingContext& ctx) { return KernelSignature("deformable_conv", {"Input", "Offset", "Filter", "Mask"}, @@ -29,7 +29,7 @@ KernelSignature DeformableConvOpArgumentMapping( {"Output"}); } -KernelSignature DeformableConvGradOpArgumentMapping( +KernelSignature DeformableConvGradOpV1ArgumentMapping( const ArgumentMappingContext& ctx) { return KernelSignature( "deformable_conv_grad", @@ -48,12 +48,7 @@ KernelSignature DeformableConvGradOpArgumentMapping( PD_REGISTER_BASE_KERNEL_NAME(deformable_conv_v1, deformable_conv); PD_REGISTER_BASE_KERNEL_NAME(deformable_conv_v1_grad, deformable_conv_grad); -PD_REGISTER_ARG_MAPPING_FN(deformable_conv, - phi::DeformableConvOpArgumentMapping); -PD_REGISTER_ARG_MAPPING_FN(deformable_conv_grad, - phi::DeformableConvGradOpArgumentMapping); - PD_REGISTER_ARG_MAPPING_FN(deformable_conv_v1, - phi::DeformableConvOpArgumentMapping); + phi::DeformableConvOpV1ArgumentMapping); PD_REGISTER_ARG_MAPPING_FN(deformable_conv_v1_grad, - phi::DeformableConvGradOpArgumentMapping); + phi::DeformableConvGradOpV1ArgumentMapping);