diff --git a/paddle/fluid/framework/ir/CMakeLists.txt b/paddle/fluid/framework/ir/CMakeLists.txt index 8130c91a31373455e90ce2e2bbc9a8a5a98774b8..f116255c17bb9ac2f17903bcdd35b61a4db1064c 100755 --- a/paddle/fluid/framework/ir/CMakeLists.txt +++ b/paddle/fluid/framework/ir/CMakeLists.txt @@ -180,7 +180,7 @@ if(WITH_MKLDNN) pass_library(softplus_activation_onednn_fuse_pass inference DIR mkldnn) pass_library(shuffle_channel_mkldnn_detect_pass inference DIR mkldnn) pass_library(fc_act_mkldnn_fuse_pass inference DIR mkldnn) - pass_library(elt_act_mkldnn_fuse_pass inference DIR mkldnn) + pass_library(elementwise_act_onednn_fuse_pass inference DIR mkldnn) pass_library(matmul_elementwise_add_mkldnn_fuse_pass inference DIR mkldnn) pass_library(matmul_activation_mkldnn_fuse_pass inference DIR mkldnn) pass_library(layer_norm_onednn_optimization_pass inference DIR mkldnn) diff --git a/paddle/fluid/framework/ir/graph_pattern_detector.cc b/paddle/fluid/framework/ir/graph_pattern_detector.cc index af23d69bd4be31e67c4b465078a47f92252fbb97..03f1d5bc404980b01b6308c191beed835c5068ef 100644 --- a/paddle/fluid/framework/ir/graph_pattern_detector.cc +++ b/paddle/fluid/framework/ir/graph_pattern_detector.cc @@ -2260,7 +2260,8 @@ PDNode *patterns::OpRequant::operator()() { auto any_op = pattern->NewNode(any_op_repr()) ->assert_is_op() ->assert_more([&](Node *node) { - return node->Op()->HasAttr("Scale_out") ? true : false; + return (node->Op()->HasAttr("Scale_out") || + node->Op()->HasAttr("scale_out")); }); auto requant_in = pattern->NewNode(requant_in_repr()) ->assert_is_op_input("requantize", "Input"); @@ -2288,7 +2289,10 @@ PDNode *patterns::RequantOp::operator()() { ->assert_more([&](Node *node) { return (node->Op()->HasAttr("Scale_in") || node->Op()->HasAttr("Scale_x") || - node->Op()->HasAttr("Scale_y")); + node->Op()->HasAttr("Scale_y") || + node->Op()->HasAttr("scale_in") || + node->Op()->HasAttr("scale_x") || + node->Op()->HasAttr("scale_y")); }); requant_op->LinksFrom({requant_in}).LinksTo({requant_out}); diff --git a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.cc b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.cc index 2c7d93278ab62698a552ed3ff8c9b5e05afe52ca..7376e87155187278c290b7f43bec50a6d6afce5d 100644 --- a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.cc +++ b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.cc @@ -1045,14 +1045,14 @@ void CPUQuantizePass::QuantizeElementwise( "X", input_x_scale, is_x_unsigned, - "Scale_x"); + "scale_x"); QuantizeInput(g, elementwise_op, elementwise_y, "Y", input_y_scale, is_y_unsigned, - "Scale_y"); + "scale_y"); bool is_output_unsigned{false}; auto output_scale = @@ -1064,7 +1064,7 @@ void CPUQuantizePass::QuantizeElementwise( "Out", output_scale, is_output_unsigned, - "Scale_out"); + "scale_out"); ++quantize_elementwise_count; }; @@ -1314,9 +1314,9 @@ void CPUQuantizePass::ApplyImpl(ir::Graph* graph) const { QuantizeImmutable(graph, "nearest_interp", "X"); QuantizeImmutable(graph, "nearest_interp_v2", "X"); QuantizeImmutable(graph, "split", "X"); - QuantizeElementwise(graph, "elementwise_add"); - QuantizeElementwise(graph, "elementwise_mul"); - QuantizeElementwise(graph, "elementwise_sub"); + QuantizeElementwise(graph, "fused_elementwise_add"); + QuantizeElementwise(graph, "fused_elementwise_mul"); + QuantizeElementwise(graph, "fused_elementwise_sub"); QuantizeFusionGru(graph); QuantizeMultiGru(graph); QuantizeFusionLSTM(graph); diff --git a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass_tester.cc b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass_tester.cc index 427b4278ceb0a749c2766fe4698c22c69cfafea0..5ffc2db337ada8eba83ad3ae55afd2afcac211a2 100644 --- a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass_tester.cc +++ b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass_tester.cc @@ -97,14 +97,15 @@ void SetOp(ProgramDesc* prog, op->SetAttr("Scale_x", 1.0f); op->SetAttr("Scale_y", 1.0f); op->SetAttr("Scale_out", 1.0f); - } else if (type == "elementwise_add" || type == "elementwise_mul" || - type == "elementwise_sub") { + } else if (type == "fused_elementwise_add" || + type == "fused_elementwise_sub" || + type == "fused_elementwise_mul") { op->SetInput("X", {inputs[0]}); if (inputs.size() > 1) op->SetInput("Y", {inputs[1]}); op->SetOutput("Out", {outputs[0]}); - op->SetAttr("Scale_x", 1.0f); - op->SetAttr("Scale_y", 1.0f); - op->SetAttr("Scale_out", 1.0f); + op->SetAttr("scale_x", 1.0f); + op->SetAttr("scale_y", 1.0f); + op->SetAttr("scale_out", 1.0f); } else if (type == "fusion_gru") { op->SetInput("X", {inputs[0]}); op->SetInput("Bias", {inputs[1]}); @@ -178,16 +179,19 @@ void CheckScales(const OpDesc* op, float scale, float shift) { scale); scale_names.push_back("Scale_in"); scale_names.push_back("Scale_out"); - } else if (type == "fused_matmul" || type == "elementwise_add" || - type == "elementwise_mul" || type == "elementwise_sub") { + } else if (type == "fused_matmul") { scale_names.push_back("Scale_x"); scale_names.push_back("Scale_y"); scale_names.push_back("Scale_out"); - if (type == "fused_matmul") { - auto const& names = op->InputNames(); - if (std::find(names.begin(), names.end(), "ResidualData") != names.end()) - scale_names.push_back("Scale_in_eltwise"); - } + auto const& names = op->InputNames(); + if (std::find(names.begin(), names.end(), "ResidualData") != names.end()) + scale_names.push_back("Scale_in_eltwise"); + } else if (type == "fused_elementwise_add" || + type == "fused_elementwise_sub" || + type == "fused_elementwise_mul") { + scale_names.push_back("scale_x"); + scale_names.push_back("scale_y"); + scale_names.push_back("scale_out"); } else if (type == "fusion_gru" || type == "fusion_lstm") { EXPECT_EQ(op->GetAttrIfExists("Shift_data"), shift); EXPECT_EQ(op->GetAttrIfExists>("Scale_weights")[0], @@ -710,9 +714,9 @@ void TestElementwiseUnsignedAndSignedInput( } const std::vector> elementwises = { - {"elementwise_add", "ElementwiseAdd"}, - {"elementwise_mul", "ElementwiseMul"}, - {"elementwise_sub", "ElementwiseSub"}}; + {"fused_elementwise_add", "FusedElementwiseAdd"}, + {"fused_elementwise_mul", "FusedElementwiseMul"}, + {"fused_elementwise_sub", "FusedElementwiseSub"}}; class TestElementwises : public testing::TestWithParam> {}; diff --git a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_placement_pass.cc b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_placement_pass.cc index 0fd1f13463c0dc372178cb3da4612f1edd8dd695..2071f284126b794844bc0bec26f88a95274990bd 100644 --- a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_placement_pass.cc +++ b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_placement_pass.cc @@ -32,6 +32,9 @@ void CPUQuantizePlacementPass::ApplyImpl(ir::Graph* graph) const { "fused_conv2d", "fused_conv3d", "fused_matmul", + "fused_elementwise_add", + "fused_elementwise_mul", + "fused_elementwise_sub", "elementwise_add", "elementwise_mul", "elementwise_sub", @@ -87,12 +90,7 @@ void CPUQuantizePlacementPass::ApplyImpl(ir::Graph* graph) const { return; } - // Remove this condition when all fused_elementwise ops are merged - if (!(op->Op()->Type() == "elementwise_add" || - op->Op()->Type() == "elementwise_sub" || - op->Op()->Type() == "elementwise_mul")) { - ConvertToFusedOp(op->Op()); - } + ConvertToFusedOp(op->Op()); op->Op()->SetAttr("mkldnn_data_type", std::string("int8")); }; gpd(graph, handler); diff --git a/paddle/fluid/framework/ir/mkldnn/elt_act_mkldnn_fuse_pass.cc b/paddle/fluid/framework/ir/mkldnn/elementwise_act_onednn_fuse_pass.cc similarity index 94% rename from paddle/fluid/framework/ir/mkldnn/elt_act_mkldnn_fuse_pass.cc rename to paddle/fluid/framework/ir/mkldnn/elementwise_act_onednn_fuse_pass.cc index 4b3f6a95d6dd17d67bb31b35551dfdbc3d965eca..b6e84145aebffdaaa6ec590f0c5f436a8eef8778 100644 --- a/paddle/fluid/framework/ir/mkldnn/elt_act_mkldnn_fuse_pass.cc +++ b/paddle/fluid/framework/ir/mkldnn/elementwise_act_onednn_fuse_pass.cc @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "paddle/fluid/framework/ir/mkldnn/elt_act_mkldnn_fuse_pass.h" +#include "paddle/fluid/framework/ir/mkldnn/elementwise_act_onednn_fuse_pass.h" #include "paddle/fluid/framework/ir/graph_pattern_detector.h" #include "paddle/fluid/framework/ir/mkldnn/activation_onednn_fuse_pass.h" @@ -62,6 +62,7 @@ void ElementwiseActivationOneDNNPass::FuseElementwiseAct( GET_IR_NODE_FROM_SUBGRAPH( activation_out, activation_out, elementwise_act_pattern); + ConvertToFusedOp(elementwise->Op()); SetActivationAttrs(elementwise->Op(), activation->Op(), act_type); elementwise->Op()->SetOutput("Out", {activation_out->Name()}); @@ -84,9 +85,9 @@ void ElementwiseActivationOneDNNPass::FuseElementwiseAct( } // namespace framework } // namespace paddle -REGISTER_PASS(elt_act_mkldnn_fuse_pass, +REGISTER_PASS(elementwise_act_onednn_fuse_pass, paddle::framework::ir::ElementwiseActivationOneDNNPass); -REGISTER_PASS_CAPABILITY(elt_act_mkldnn_fuse_pass) +REGISTER_PASS_CAPABILITY(elementwise_act_onednn_fuse_pass) .AddCombination( paddle::framework::compatible::OpVersionComparatorCombination() .LE("elementwise_add", 1) diff --git a/paddle/fluid/framework/ir/mkldnn/elt_act_mkldnn_fuse_pass.h b/paddle/fluid/framework/ir/mkldnn/elementwise_act_onednn_fuse_pass.h similarity index 100% rename from paddle/fluid/framework/ir/mkldnn/elt_act_mkldnn_fuse_pass.h rename to paddle/fluid/framework/ir/mkldnn/elementwise_act_onednn_fuse_pass.h diff --git a/paddle/fluid/framework/ir/mkldnn/mkldnn_pass_util.h b/paddle/fluid/framework/ir/mkldnn/mkldnn_pass_util.h index 8438bf79fd6c741e27e10b098fd67e3ecea7dc0f..a9c6d0e0b0bd16b7cd6d8ae4d66c854e685362d7 100644 --- a/paddle/fluid/framework/ir/mkldnn/mkldnn_pass_util.h +++ b/paddle/fluid/framework/ir/mkldnn/mkldnn_pass_util.h @@ -148,6 +148,8 @@ inline void ConvertToFusedOp(OpDesc* op) { const std::map fused_ops = { {"conv2d", "fused_conv2d"}, {"depthwise_conv2d", "fused_conv2d"}, + {"elementwise_add", "fused_elementwise_add"}, + {"elementwise_sub", "fused_elementwise_sub"}, {"elementwise_mul", "fused_elementwise_mul"}, {"elementwise_div", "fused_elementwise_div"}, {"matmul", "fused_matmul"}, diff --git a/paddle/fluid/framework/ir/mkldnn/operator_scale_onednn_fuse_pass.cc b/paddle/fluid/framework/ir/mkldnn/operator_scale_onednn_fuse_pass.cc index 7c42ae2551585e2ef1e33122d5950d4345dd6191..086de37ab429969d1dea7658b39901abed3f8c9b 100644 --- a/paddle/fluid/framework/ir/mkldnn/operator_scale_onednn_fuse_pass.cc +++ b/paddle/fluid/framework/ir/mkldnn/operator_scale_onednn_fuse_pass.cc @@ -31,6 +31,8 @@ void FuseOperatorScaleOneDNNPass::ApplyImpl(Graph *graph) const { "fused_matmul", "matmul", "matmul_v2", + "fused_elementwise_add", + "fused_elementwise_sub", "fused_elementwise_mul", "fused_elementwise_div", "elementwise_add", @@ -119,6 +121,8 @@ REGISTER_PASS_CAPABILITY(operator_scale_onednn_fuse_pass) .EQ("fused_matmul", 0) .LE("matmul", 1) .EQ("matmul_v2", 0) + .EQ("fused_elementwise_add", 0) + .EQ("fused_elementwise_sub", 0) .EQ("fused_elementwise_mul", 0) .EQ("fused_elementwise_div", 0) .LE("elementwise_add", 1) diff --git a/paddle/fluid/framework/ir/mkldnn/operator_unsqueeze2_onednn_fuse_pass.cc b/paddle/fluid/framework/ir/mkldnn/operator_unsqueeze2_onednn_fuse_pass.cc index 538a39374d8077b10feddc82236d04e0b069643d..7726206e84ea4141730aa032721d2b1c26c15df3 100644 --- a/paddle/fluid/framework/ir/mkldnn/operator_unsqueeze2_onednn_fuse_pass.cc +++ b/paddle/fluid/framework/ir/mkldnn/operator_unsqueeze2_onednn_fuse_pass.cc @@ -16,7 +16,6 @@ #include "paddle/fluid/framework/ir/mkldnn/mkldnn_pass_util.h" #include "paddle/fluid/framework/op_version_registry.h" -#include "paddle/phi/backends/onednn/onednn_reuse.h" #include "paddle/utils/string/pretty_log.h" namespace paddle { diff --git a/paddle/fluid/inference/api/paddle_pass_builder.cc b/paddle/fluid/inference/api/paddle_pass_builder.cc index f9123a111771f1dafd9b0221c37cb61a957bc07b..4cbbb0e23ed2c6c1ea1b4d83020890d534d3dd96 100644 --- a/paddle/fluid/inference/api/paddle_pass_builder.cc +++ b/paddle/fluid/inference/api/paddle_pass_builder.cc @@ -368,7 +368,7 @@ void CpuPassStrategy::EnableMKLDNN() { "batch_norm_act_fuse_pass", // "softplus_activation_onednn_fuse_pass", // "shuffle_channel_mkldnn_detect_pass", // - "elt_act_mkldnn_fuse_pass", // + "elementwise_act_onednn_fuse_pass", // "layer_norm_onednn_optimization_pass", // "operator_scale_onednn_fuse_pass", // "operator_unsqueeze2_onednn_fuse_pass", // diff --git a/paddle/fluid/operators/compat/elementwise_add.pbtxt b/paddle/fluid/operators/compat/elementwise_add.pbtxt index 5b55f3981c77daa5e81590ee499f3d252a34c122..ee2f1d7c6861e34c6808be364d91cc400934077f 100644 --- a/paddle/fluid/operators/compat/elementwise_add.pbtxt +++ b/paddle/fluid/operators/compat/elementwise_add.pbtxt @@ -22,14 +22,6 @@ extra { attrs { name: "Out0_threshold" type: FLOAT - } - attrs { - name: "x_data_format" - type: STRING - } - attrs { - name: "y_data_format" - type: STRING } attrs { name: "Scale_x" diff --git a/paddle/fluid/operators/compat/elementwise_div.pbtxt b/paddle/fluid/operators/compat/elementwise_div.pbtxt index a73d2072029a3a00c19f35dfd72adce739fc2f5e..0b46bfb7484013d211825e90798729a4a03f37c0 100644 --- a/paddle/fluid/operators/compat/elementwise_div.pbtxt +++ b/paddle/fluid/operators/compat/elementwise_div.pbtxt @@ -16,11 +16,7 @@ def { } extra { attrs { - name: "x_data_format" - type: STRING - } - attrs { - name: "y_data_format" + name: "act" type: STRING } attrs { @@ -35,8 +31,4 @@ extra { name: "Scale_out" type: FLOAT } - attrs { - name: "act" - type: STRING - } } diff --git a/paddle/fluid/operators/compat/elementwise_mul.pbtxt b/paddle/fluid/operators/compat/elementwise_mul.pbtxt index 22289e2689c10a7339a0e34a38f90b40c9453588..94cec09ace8f32fc1c19111bd8c0c33c045e3175 100644 --- a/paddle/fluid/operators/compat/elementwise_mul.pbtxt +++ b/paddle/fluid/operators/compat/elementwise_mul.pbtxt @@ -13,16 +13,6 @@ def { name: "axis" type: INT } -} -extra { - attrs { - name: "x_data_format" - type: STRING - } - attrs { - name: "y_data_format" - type: STRING - } attrs { name: "Scale_x" type: FLOAT diff --git a/paddle/fluid/operators/compat/elementwise_pow.pbtxt b/paddle/fluid/operators/compat/elementwise_pow.pbtxt index a2ab73f409b7801d375b25c90e24ed1f65ed82f0..e9427104dbfa7cbe68191f135863f25f73cff865 100644 --- a/paddle/fluid/operators/compat/elementwise_pow.pbtxt +++ b/paddle/fluid/operators/compat/elementwise_pow.pbtxt @@ -16,11 +16,7 @@ def { } extra { attrs { - name: "x_data_format" - type: STRING - } - attrs { - name: "y_data_format" + name: "act" type: STRING } attrs { @@ -35,8 +31,4 @@ extra { name: "Scale_out" type: FLOAT } - attrs { - name: "act" - type: STRING - } } diff --git a/paddle/fluid/operators/compat/elementwise_sub.pbtxt b/paddle/fluid/operators/compat/elementwise_sub.pbtxt index 9f38601f585ea8aabdf67fbd2fc9f9189a3f21a0..f73b92fb95f87cb16d7ba766fa909f60da5b8f13 100644 --- a/paddle/fluid/operators/compat/elementwise_sub.pbtxt +++ b/paddle/fluid/operators/compat/elementwise_sub.pbtxt @@ -16,11 +16,7 @@ def { } extra { attrs { - name: "x_data_format" - type: STRING - } - attrs { - name: "y_data_format" + name: "act" type: STRING } attrs { @@ -35,8 +31,4 @@ extra { name: "Scale_out" type: FLOAT } - attrs { - name: "act" - type: STRING - } } diff --git a/paddle/fluid/operators/compat/fused_elementwise_add.pbtxt b/paddle/fluid/operators/compat/fused_elementwise_add.pbtxt new file mode 100644 index 0000000000000000000000000000000000000000..6c589b7244ca47ebfaa78457c677931dbc9f04ad --- /dev/null +++ b/paddle/fluid/operators/compat/fused_elementwise_add.pbtxt @@ -0,0 +1,50 @@ +type: "fused_elementwise_add" +def { + inputs { + name: "X" + } + inputs { + name: "Y" + } + outputs { + name: "Out" + } + attrs { + name: "axis" + type: INT + } +} +extra { + attrs { + name: "fuse_activation" + type: STRING + } + attrs { + name: "fuse_alpha" + type: FLOAT + } + attrs { + name: "fuse_beta" + type: FLOAT + } + attrs { + name: "fused_output_scale" + type: FLOAT + } + attrs { + name: "fused_unsqueeze2_axes" + type: INTS + } + attrs { + name: "scale_x" + type: FLOAT + } + attrs { + name: "scale_y" + type: FLOAT + } + attrs { + name: "scale_out" + type: FLOAT + } +} diff --git a/paddle/fluid/operators/compat/fused_elementwise_sub.pbtxt b/paddle/fluid/operators/compat/fused_elementwise_sub.pbtxt new file mode 100644 index 0000000000000000000000000000000000000000..b9d4acad8cbc75c2fc3050e4ceeaba0562df0ed9 --- /dev/null +++ b/paddle/fluid/operators/compat/fused_elementwise_sub.pbtxt @@ -0,0 +1,50 @@ +type: "fused_elementwise_sub" +def { + inputs { + name: "X" + } + inputs { + name: "Y" + } + outputs { + name: "Out" + } + attrs { + name: "axis" + type: INT + } +} +extra { + attrs { + name: "fuse_activation" + type: STRING + } + attrs { + name: "fuse_alpha" + type: FLOAT + } + attrs { + name: "fuse_beta" + type: FLOAT + } + attrs { + name: "fused_output_scale" + type: FLOAT + } + attrs { + name: "fused_unsqueeze2_axes" + type: INTS + } + attrs { + name: "scale_x" + type: FLOAT + } + attrs { + name: "scale_y" + type: FLOAT + } + attrs { + name: "scale_out" + type: FLOAT + } +} diff --git a/paddle/fluid/operators/elementwise/elementwise_sub_op.cc b/paddle/fluid/operators/elementwise/elementwise_sub_op.cc index 87c4e4977258f6ba42ed3639e1e8312e38dc43ad..5860f7a4009db35d74d84171d6a3870bcf7f7dab 100644 --- a/paddle/fluid/operators/elementwise/elementwise_sub_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_sub_op.cc @@ -170,9 +170,9 @@ REGISTER_OPERATOR(elementwise_sub_grad_grad, REGISTER_OP_VERSION(elementwise_sub) .AddCheckpoint( - R"ROC(Register elementwise_sub for adding the attribute of Scale_y)ROC", + R"ROC(Register elementwise_sub for adding the attribute of scale_y)ROC", paddle::framework::compatible::OpVersionDesc().NewAttr( - "Scale_y", + "scale_y", "In order to support the function of scaling the input Y when " "using the operator of elementwise_sub.", 1.0f)); diff --git a/paddle/fluid/operators/fused/fused_elementwise_op.cc b/paddle/fluid/operators/fused/fused_elementwise_op.cc index 4b21ada97d07c1209a002c6118f17fc87a3d43f2..e6c2743e9385d2626719d4891b4f9bd4cdcd65f7 100644 --- a/paddle/fluid/operators/fused/fused_elementwise_op.cc +++ b/paddle/fluid/operators/fused/fused_elementwise_op.cc @@ -62,6 +62,21 @@ class FusedElementwiseOpMaker : public framework::OpProtoAndCheckerMaker { } // namespace paddle namespace ops = paddle::operators; +REGISTER_OPERATOR( + fused_elementwise_add, + ops::ElementwiseOp, + ops::FusedElementwiseOpMaker, + ops::ElementwiseOpInferVarType, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); + +REGISTER_OPERATOR( + fused_elementwise_sub, + ops::ElementwiseOp, + ops::FusedElementwiseOpMaker, + ops::ElementwiseOpInferVarType, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OPERATOR( fused_elementwise_mul, diff --git a/paddle/phi/api/yaml/op_compat.yaml b/paddle/phi/api/yaml/op_compat.yaml index edf08f5bb8fe5b5d64c52e37763eb1cde692667b..4c9ac1729b62da76f37062f3bfe1dee21d82b1df 100755 --- a/paddle/phi/api/yaml/op_compat.yaml +++ b/paddle/phi/api/yaml/op_compat.yaml @@ -92,7 +92,7 @@ - op : add (elementwise_add) backward : add_grad (elementwise_add_grad) extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : add_n (sum) @@ -661,7 +661,7 @@ outputs : out: Out extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : dot @@ -733,7 +733,7 @@ - op : elementwise_pow backward : elementwise_pow_grad extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : elu @@ -922,19 +922,19 @@ - op : floor_divide (elementwise_floordiv) extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : fmax (elementwise_fmax) backward : fmax_grad (elementwise_fmax_grad) extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : fmin (elementwise_fmin) backward : fmin_grad (elementwise_fmin_grad) extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : fold @@ -1036,7 +1036,7 @@ - op : grad_add extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : greater_equal @@ -1114,7 +1114,7 @@ - op : heaviside (elementwise_heaviside) backward : heaviside_grad (elementwise_heaviside_grad) extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : histogram @@ -1522,13 +1522,13 @@ - op : maximum (elementwise_max) backward : maximum_grad (elementwise_max_grad) extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : maximum (elementwise_min) backward : maximum_grad (elementwise_min_grad) extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : maxout @@ -1642,7 +1642,7 @@ outputs : out : Out extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : mv @@ -1897,7 +1897,7 @@ - op : remainder (elementwise_mod) extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : renorm @@ -2260,7 +2260,7 @@ outputs : out : Out extra : - attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", + attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f] - op : sum (reduce_sum) diff --git a/paddle/phi/kernels/fusion/onednn/fused_elementwise_kernel.cc b/paddle/phi/kernels/fusion/onednn/fused_elementwise_kernel.cc index b38485543e57842cbba69c9b93c4e2e70d459e7a..d19bca440fbbfd46fcc0b402f29ea9170a92ac96 100644 --- a/paddle/phi/kernels/fusion/onednn/fused_elementwise_kernel.cc +++ b/paddle/phi/kernels/fusion/onednn/fused_elementwise_kernel.cc @@ -151,12 +151,32 @@ void FusedElementwiseKernel(const OneDNNContext& dev_ctx, out); \ } +DEFINE_ONEDNN_ELEMENTWISE_KERNEL(FusedAdd, dnnl::algorithm::binary_add) +DEFINE_ONEDNN_ELEMENTWISE_KERNEL(FusedSubtract, dnnl::algorithm::binary_sub) DEFINE_ONEDNN_ELEMENTWISE_KERNEL(FusedMultiply, dnnl::algorithm::binary_mul) DEFINE_ONEDNN_ELEMENTWISE_KERNEL(FusedDivide, dnnl::algorithm::binary_div) } // namespace fusion } // namespace phi +PD_REGISTER_KERNEL(fused_elementwise_add, + OneDNN, + ONEDNN, + phi::fusion::FusedAddKernel, + float, + phi::dtype::bfloat16, + int8_t, + uint8_t) {} + +PD_REGISTER_KERNEL(fused_elementwise_sub, + OneDNN, + ONEDNN, + phi::fusion::FusedSubtractKernel, + float, + phi::dtype::bfloat16, + int8_t, + uint8_t) {} + PD_REGISTER_KERNEL(fused_elementwise_mul, OneDNN, ONEDNN, diff --git a/paddle/phi/kernels/onednn/elementwise_kernel.cc b/paddle/phi/kernels/onednn/elementwise_kernel.cc index d20fef81a2ebfb929c564a3cd67b0724867b9047..02b148e54f547b54da9f15b272f06e68773b4d2f 100644 --- a/paddle/phi/kernels/onednn/elementwise_kernel.cc +++ b/paddle/phi/kernels/onednn/elementwise_kernel.cc @@ -30,26 +30,6 @@ void ElementwiseKernel(const OneDNNContext& dev_ctx, DenseTensor* out) { const auto& onednn_engine = dev_ctx.GetEngine(); - float scale_x = dev_ctx.HasDnnAttr("Scale_x") - ? PADDLE_GET_CONST(float, dev_ctx.GetDnnAttr("Scale_x")) - : 1.0f; - float scale_y = dev_ctx.HasDnnAttr("Scale_y") - ? PADDLE_GET_CONST(float, dev_ctx.GetDnnAttr("Scale_y")) - : 1.0f; - float scale_out = - dev_ctx.HasDnnAttr("Scale_out") - ? PADDLE_GET_CONST(float, dev_ctx.GetDnnAttr("Scale_out")) - : 1.0f; - - dnnl::post_ops post_operations; - funcs::AppendActivation(dev_ctx, post_operations); - if (dev_ctx.HasDnnAttr("fused_output_scale")) { - float scale_alpha = - PADDLE_GET_CONST(float, dev_ctx.GetDnnAttr("fused_output_scale")); - post_operations.append_eltwise( - 1.0, dnnl::algorithm::eltwise_linear, scale_alpha, 0.0f); - } - auto* non_const_x = &x; auto* non_const_y = &y; @@ -60,11 +40,10 @@ void ElementwiseKernel(const OneDNNContext& dev_ctx, non_const_x, non_const_y, out, - scale_x, - scale_y, - scale_out, - true, - post_operations); + 1.0f, + 1.0f, + 1.0f, + true); // oneDNN's binary is optimized for broadcasting y into x, so in other case // we have to swap tensors to achieve optimal performance diff --git a/paddle/phi/ops/compat/fused_elementwise_sig.cc b/paddle/phi/ops/compat/fused_elementwise_sig.cc index a5b9da7dcfe38359af8660bb2a947b3451622234..5494546de9804f00e36222b65acf68094b1ea6e5 100644 --- a/paddle/phi/ops/compat/fused_elementwise_sig.cc +++ b/paddle/phi/ops/compat/fused_elementwise_sig.cc @@ -16,6 +16,38 @@ namespace phi { +KernelSignature FusedElementwiseAddOpArgumentMapping( + const ArgumentMappingContext& ctx) { + return KernelSignature("fused_elementwise_add", + {"X", "Y"}, + {"axis", + "fuse_activation", + "fuse_alpha", + "fuse_beta", + "fused_output_scale", + "fused_unsqueeze2_axes", + "scale_x", + "scale_y", + "scale_out"}, + {"Out"}); +} + +KernelSignature FusedElementwiseSubOpArgumentMapping( + const ArgumentMappingContext& ctx) { + return KernelSignature("fused_elementwise_sub", + {"X", "Y"}, + {"axis", + "fuse_activation", + "fuse_alpha", + "fuse_beta", + "fused_output_scale", + "fused_unsqueeze2_axes", + "scale_x", + "scale_y", + "scale_out"}, + {"Out"}); +} + KernelSignature FusedElementwiseMulOpArgumentMapping( const ArgumentMappingContext& ctx) { return KernelSignature("fused_elementwise_mul", @@ -50,6 +82,10 @@ KernelSignature FusedElementwiseDivOpArgumentMapping( } // namespace phi +PD_REGISTER_ARG_MAPPING_FN(fused_elementwise_add, + phi::FusedElementwiseAddOpArgumentMapping); +PD_REGISTER_ARG_MAPPING_FN(fused_elementwise_sub, + phi::FusedElementwiseSubOpArgumentMapping); PD_REGISTER_ARG_MAPPING_FN(fused_elementwise_mul, phi::FusedElementwiseMulOpArgumentMapping); PD_REGISTER_ARG_MAPPING_FN(fused_elementwise_div, diff --git a/python/paddle/incubate/autograd/primrules.py b/python/paddle/incubate/autograd/primrules.py index b6487c79305ec4f56955225f9e8c2073a45e9f33..0fd8a77dd7205ab195ee99736c8dc9cc25dbe422 100644 --- a/python/paddle/incubate/autograd/primrules.py +++ b/python/paddle/incubate/autograd/primrules.py @@ -132,69 +132,21 @@ p_norm def elementwise_add_orig2prim(op, x, y): if x.shape != y.shape: y = broadcast(y, shape=x.shape) - if op.attr('Scale_x') - 1.0 > 1e-5: - scale_x = fill_const( - shape=x.shape, dtype=x.dtype, value=op.attr('Scale_x') - ) - x = mul(x, scale_x) - if op.attr('Scale_y') - 1.0 > 1e-5: - scale_y = fill_const( - shape=y.shape, dtype=y.dtype, value=op.attr('Scale_y') - ) - y = mul(y, scale_y) - z = add(x, y) - if op.attr('Scale_out') - 1.0 > 1e-5: - scale_out = fill_const( - shape=z.shape, dtype=z.dtype, value=op.attr('Scale_out') - ) - z = mul(z, scale_out) - return z + return add(x, y) @REGISTER_ORIG2PRIM('elementwise_sub') def elementwise_sub_orig2prim(op, x, y): if x.shape != y.shape: y = broadcast(y, shape=x.shape) - if op.attr('Scale_x') - 1.0 > 1e-5: - scale_x = fill_const( - shape=x.shape, dtype=x.dtype, value=op.attr('Scale_x') - ) - x = mul(x, scale_x) - if op.attr('Scale_y') - 1.0 > 1e-5: - scale_y = fill_const( - shape=y.shape, dtype=y.dtype, value=op.attr('Scale_y') - ) - y = mul(y, scale_y) - z = sub(x, y) - if op.attr('Scale_out') - 1.0 > 1e-5: - scale_out = fill_const( - shape=z.shape, dtype=z.dtype, value=op.attr('Scale_out') - ) - z = mul(z, scale_out) - return z + return sub(x, y) @REGISTER_ORIG2PRIM('elementwise_mul') def elementwise_mul_orig2prim(op, x, y): if x.shape != y.shape: y = broadcast(y, shape=x.shape) - if op.attr('Scale_x') - 1.0 > 1e-5: - scale_x = fill_const( - shape=x.shape, dtype=x.dtype, value=op.attr('Scale_x') - ) - x = mul(x, scale_x) - if op.attr('Scale_y') - 1.0 > 1e-5: - scale_y = fill_const( - shape=y.shape, dtype=y.dtype, value=op.attr('Scale_y') - ) - y = mul(y, scale_y) - z = mul(x, y) - if op.attr('Scale_out') - 1.0 > 1e-5: - scale_out = fill_const( - shape=z.shape, dtype=z.dtype, value=op.attr('Scale_out') - ) - z = mul(z, scale_out) - return z + return mul(x, y) @REGISTER_ORIG2PRIM('elementwise_div') diff --git a/test/cpp/fluid/feed_forward_test.cu b/test/cpp/fluid/feed_forward_test.cu index 08d91d1bb2af3eddae372c8d353534191247de88..7febf20e771187ee0751540b5da0e378a169e2ba 100644 --- a/test/cpp/fluid/feed_forward_test.cu +++ b/test/cpp/fluid/feed_forward_test.cu @@ -233,21 +233,13 @@ void GetElementwiseAddOpGrad(const std::vector &dout_vec, dout_ptr, dout_vec.data(), size_z * sizeof(T), cudaMemcpyHostToDevice); int axis = -1; - bool use_mkldnn = false, use_quantizer = false; + bool use_mkldnn = false; std::string mkldnn_data_type = "float32"; - std::string x_data_format = "", y_data_format = ""; - float Scale_x = 1.0, Scale_y = 1.0, Scale_out = 1.0; framework::AttributeMap attrs; attrs.insert({"axis", axis}); attrs.insert({"use_mkldnn", use_mkldnn}); - attrs.insert({"x_data_format", x_data_format}); - attrs.insert({"y_data_format", y_data_format}); - attrs.insert({"use_quantizer", use_quantizer}); attrs.insert({"mkldnn_data_type", mkldnn_data_type}); - attrs.insert({"Scale_x", Scale_x}); - attrs.insert({"Scale_y", Scale_y}); - attrs.insert({"Scale_out", Scale_out}); auto op = framework::OpRegistry::CreateOp( "elementwise_add_grad", diff --git a/test/ir/inference/test_mkldnn_elt_act_fuse_pass.py b/test/ir/inference/test_mkldnn_elt_act_fuse_pass.py index a6ba318e81cba4657bd560ab605230e44329bd7f..582d3efec9d3f309769af75c9997041bd4cda0ae 100644 --- a/test/ir/inference/test_mkldnn_elt_act_fuse_pass.py +++ b/test/ir/inference/test_mkldnn_elt_act_fuse_pass.py @@ -23,10 +23,10 @@ from paddle import fluid from paddle.fluid.core import PassVersionChecker -class ElementwiseActivationMkldnnFusePassTest(InferencePassTest): +class ElementwiseActivationOneDNNFusePassTest(InferencePassTest): act_alpha = None act_beta = None - pass_name = 'elt_act_mkldnn_fuse_pass' + pass_name = 'elementwise_act_onednn_fuse_pass' def setUp(self): self.set_params() @@ -65,24 +65,24 @@ class ElementwiseActivationMkldnnFusePassTest(InferencePassTest): self.assertTrue(PassVersionChecker.IsCompatible(self.pass_name)) -class ElementwiseActivationMkldnnFusePassTest_Add_Relu( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Add_Relu( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add self.act = F.relu -class ElementwiseActivationMkldnnFusePassTest_Add_Tanh( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Add_Tanh( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add self.act = paddle.tanh -class ElementwiseActivationMkldnnFusePassTest_Add_LeakyRelu( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Add_LeakyRelu( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add @@ -90,40 +90,40 @@ class ElementwiseActivationMkldnnFusePassTest_Add_LeakyRelu( self.act = paddle.nn.functional.leaky_relu -class ElementwiseActivationMkldnnFusePassTest_Add_Swish( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Add_Swish( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add self.act = paddle.nn.functional.swish -class ElementwiseActivationMkldnnFusePassTest_Add_HardSwish( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Add_HardSwish( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add self.act = paddle.nn.functional.hardswish -class ElementwiseActivationMkldnnFusePassTest_Add_SQRT( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Add_SQRT( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add self.act = paddle.sqrt -class ElementwiseActivationMkldnnFusePassTest_Add_ABS( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Add_ABS( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add self.act = paddle.abs -class ElementwiseActivationMkldnnFusePassTest_Add_Clip( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Add_Clip( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add @@ -132,16 +132,16 @@ class ElementwiseActivationMkldnnFusePassTest_Add_Clip( self.act_beta = 10.0 -class ElementwiseActivationMkldnnFusePassTest_Add_Gelu( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Add_Gelu( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add self.act = paddle.nn.functional.gelu -class ElementwiseActivationMkldnnFusePassTest_Add_Gelu_Tanh( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Add_Gelu_Tanh( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add @@ -149,40 +149,40 @@ class ElementwiseActivationMkldnnFusePassTest_Add_Gelu_Tanh( self.act_alpha = True -class ElementwiseActivationMkldnnFusePassTest_Add_Relu6( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Add_Relu6( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add self.act = paddle.nn.functional.relu6 -class ElementwiseActivationMkldnnFusePassTest_Add_Sigmoid( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Add_Sigmoid( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add self.act = paddle.nn.functional.sigmoid -class ElementwiseActivationMkldnnFusePassTest_Sub_Relu( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Sub_Relu( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.subtract self.act = F.relu -class ElementwiseActivationMkldnnFusePassTest_Sub_Tanh( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Sub_Tanh( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.subtract self.act = paddle.tanh -class ElementwiseActivationMkldnnFusePassTest_Sub_LeakyRelu( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Sub_LeakyRelu( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.subtract @@ -190,32 +190,32 @@ class ElementwiseActivationMkldnnFusePassTest_Sub_LeakyRelu( self.act = paddle.nn.functional.leaky_relu -class ElementwiseActivationMkldnnFusePassTest_Sub_Swish( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Sub_Swish( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.subtract self.act = paddle.nn.functional.swish -class ElementwiseActivationMkldnnFusePassTest_Sub_HardSwish( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Sub_HardSwish( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.subtract self.act = paddle.nn.functional.hardswish -class ElementwiseActivationMkldnnFusePassTest_Sub_ABS( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Sub_ABS( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.subtract self.act = paddle.abs -class ElementwiseActivationMkldnnFusePassTest_Sub_Clip( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Sub_Clip( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.subtract @@ -224,16 +224,16 @@ class ElementwiseActivationMkldnnFusePassTest_Sub_Clip( self.act_beta = 10.0 -class ElementwiseActivationMkldnnFusePassTest_Sub_Gelu( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Sub_Gelu( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.subtract self.act = paddle.nn.functional.gelu -class ElementwiseActivationMkldnnFusePassTest_Sub_Gelu_Tanh( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Sub_Gelu_Tanh( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.subtract @@ -241,40 +241,40 @@ class ElementwiseActivationMkldnnFusePassTest_Sub_Gelu_Tanh( self.act_alpha = True -class ElementwiseActivationMkldnnFusePassTest_Sub_Relu6( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Sub_Relu6( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.subtract self.act = paddle.nn.functional.relu6 -class ElementwiseActivationMkldnnFusePassTest_Sub_Sigmoid( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Sub_Sigmoid( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.subtract self.act = paddle.nn.functional.sigmoid -class ElementwiseActivationMkldnnFusePassTest_Mul_Relu( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Mul_Relu( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply self.act = F.relu -class ElementwiseActivationMkldnnFusePassTest_Mul_Tanh( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Mul_Tanh( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply self.act = paddle.tanh -class ElementwiseActivationMkldnnFusePassTest_Mul_LeakyRelu( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Mul_LeakyRelu( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply @@ -282,40 +282,40 @@ class ElementwiseActivationMkldnnFusePassTest_Mul_LeakyRelu( self.act = paddle.nn.functional.leaky_relu -class ElementwiseActivationMkldnnFusePassTest_Mul_Swish( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Mul_Swish( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply self.act = paddle.nn.functional.swish -class ElementwiseActivationMkldnnFusePassTest_Mul_HardSwish( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Mul_HardSwish( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply self.act = paddle.nn.functional.hardswish -class ElementwiseActivationMkldnnFusePassTest_Mul_SQRT( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Mul_SQRT( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply self.act = paddle.sqrt -class ElementwiseActivationMkldnnFusePassTest_Mul_ABS( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Mul_ABS( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply self.act = paddle.abs -class ElementwiseActivationMkldnnFusePassTest_Mul_Clip( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Mul_Clip( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply @@ -324,16 +324,16 @@ class ElementwiseActivationMkldnnFusePassTest_Mul_Clip( self.act_beta = 10.0 -class ElementwiseActivationMkldnnFusePassTest_Mul_Gelu( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Mul_Gelu( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply self.act = paddle.nn.functional.gelu -class ElementwiseActivationMkldnnFusePassTest_Mul_Gelu_Tanh( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Mul_Gelu_Tanh( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply @@ -341,16 +341,16 @@ class ElementwiseActivationMkldnnFusePassTest_Mul_Gelu_Tanh( self.act_alpha = True -class ElementwiseActivationMkldnnFusePassTest_Mul_Relu6( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Mul_Relu6( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply self.act = paddle.nn.functional.relu6 -class ElementwiseActivationMkldnnFusePassTest_Mul_Sigmoid( - ElementwiseActivationMkldnnFusePassTest +class ElementwiseActivationOneDNNFusePassTest_Mul_Sigmoid( + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply @@ -358,7 +358,7 @@ class ElementwiseActivationMkldnnFusePassTest_Mul_Sigmoid( class ElementwiseScaleOneDNNFusePassTest_Add( - ElementwiseActivationMkldnnFusePassTest + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.add @@ -367,7 +367,7 @@ class ElementwiseScaleOneDNNFusePassTest_Add( class ElementwiseScaleOneDNNFusePassTest_Sub( - ElementwiseActivationMkldnnFusePassTest + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.subtract @@ -376,7 +376,7 @@ class ElementwiseScaleOneDNNFusePassTest_Sub( class ElementwiseScaleOneDNNFusePassTest_Mul( - ElementwiseActivationMkldnnFusePassTest + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.multiply @@ -385,7 +385,7 @@ class ElementwiseScaleOneDNNFusePassTest_Mul( class ElementwiseScaleOneDNNFusePassTest_Div( - ElementwiseActivationMkldnnFusePassTest + ElementwiseActivationOneDNNFusePassTest ): def set_params(self): self.operand = paddle.divide diff --git a/test/ir/inference/test_onednn_elementwise_add_activation_fuse_pass.py b/test/ir/inference/test_onednn_elementwise_add_activation_fuse_pass.py index 93165f829b1c8ab141c8905546a164bd5da98875..e4a4809971739a226d9c332d0b9c408c3a3abb0a 100644 --- a/test/ir/inference/test_onednn_elementwise_add_activation_fuse_pass.py +++ b/test/ir/inference/test_onednn_elementwise_add_activation_fuse_pass.py @@ -118,17 +118,17 @@ class TestElementwiseAddActivationOneDNNFusePass(PassAutoScanTest): config = self.create_inference_config( use_mkldnn=True, passes=[ - 'elt_act_mkldnn_fuse_pass', + 'elementwise_act_onednn_fuse_pass', 'operator_scale_onednn_fuse_pass', ], ) - yield config, ['elementwise_add'], (1e-5, 1e-5) + yield config, ['fused_elementwise_add'], (1e-5, 1e-5) def test(self): self.run_and_statis( quant=False, passes=[ - 'elt_act_mkldnn_fuse_pass', + 'elementwise_act_onednn_fuse_pass', 'operator_scale_onednn_fuse_pass', ], ) diff --git a/test/ir/inference/test_trt_convert_multihead_matmul.py b/test/ir/inference/test_trt_convert_multihead_matmul.py index dd64efa70311bd4fe23d7fa18ef096b423c6b136..4ef391f48abe305a7afd61cb35428c542b8677d7 100644 --- a/test/ir/inference/test_trt_convert_multihead_matmul.py +++ b/test/ir/inference/test_trt_convert_multihead_matmul.py @@ -763,9 +763,9 @@ class TrtConvertVitToMultiHeadMatmulTest(TrtLayerAutoScanTest): }, "op_outputs": {"Out": ["elementwise_add1_output"]}, "op_attrs": { - "Scale_out": 1.0, - "Scale_x": 1.0, - "Scale_y": 1.0, + "scale_out": 1.0, + "scale_x": 1.0, + "scale_y": 1.0, "axis": 2, "Out": 1.0, }, diff --git a/test/mkldnn/CMakeLists.txt b/test/mkldnn/CMakeLists.txt index d3da5f2897da39edee1fe2d634ca6a6addbad23d..16030200222e83bed6c94502902089a8cbcc4a4e 100644 --- a/test/mkldnn/CMakeLists.txt +++ b/test/mkldnn/CMakeLists.txt @@ -24,6 +24,8 @@ endif() set_tests_properties(test_concat_mkldnn_op PROPERTIES TIMEOUT 120) set_tests_properties(test_conv3d_mkldnn_op PROPERTIES TIMEOUT 120) +set_tests_properties(test_elementwise_mul_onednn_op PROPERTIES TIMEOUT 60) +set_tests_properties(test_elementwise_add_mkldnn_op PROPERTIES TIMEOUT 60) if(WITH_MKLDNN AND NOT WIN32) set_tests_properties(test_onnx_format_quantization_mobilenetv1 PROPERTIES TIMEOUT 300) diff --git a/test/mkldnn/test_elementwise_add_mkldnn_op.py b/test/mkldnn/test_elementwise_add_mkldnn_op.py index 6e190b3183125c45a5c8be9c49ecbad2f265677d..0ad1c40021d50801dc9eff05d17702adab458214 100644 --- a/test/mkldnn/test_elementwise_add_mkldnn_op.py +++ b/test/mkldnn/test_elementwise_add_mkldnn_op.py @@ -23,7 +23,7 @@ from paddle.fluid.tests.unittests.test_elementwise_add_op import ( ) -class TestMKLDNNElementwiseAddOp(TestElementwiseAddOp): +class TestOneDNNElementwiseAddOp(TestElementwiseAddOp): def init_kernel_type(self): self.use_mkldnn = True @@ -31,21 +31,21 @@ class TestMKLDNNElementwiseAddOp(TestElementwiseAddOp): self.dtype = np.float32 -class TestMKLDNNElementwiseAddOp2(TestMKLDNNElementwiseAddOp): +class TestOneDNNElementwiseAddOp2(TestOneDNNElementwiseAddOp): def init_input_output(self): self.x = np.random.random((100,)).astype(self.dtype) self.y = np.random.random((100,)).astype(self.dtype) self.out = np.add(self.x, self.y) -class TestMKLDNNElementwiseAddOp3(TestMKLDNNElementwiseAddOp): +class TestOneDNNElementwiseAddOp3(TestOneDNNElementwiseAddOp): def init_input_output(self): self.x = np.random.uniform(0.1, 1, [2, 3, 4, 5]).astype(self.dtype) self.y = np.random.uniform(0.1, 1, [2, 3, 4, 5]).astype(self.dtype) self.out = np.add(self.x, self.y) -class TestMKLDNNElementwiseAddOp4(TestMKLDNNElementwiseAddOp): +class TestOneDNNElementwiseAddOp4(TestOneDNNElementwiseAddOp): def init_input_output(self): self.x = np.random.uniform(1, 2, [2, 3, 4, 32]).astype(self.dtype) self.y = np.random.uniform(1, 2, [4, 32]).astype(self.dtype) @@ -59,21 +59,21 @@ class TestMKLDNNElementwiseAddOp4(TestMKLDNNElementwiseAddOp): pass -class TestMKLDNNElementwiseAddOp5(TestMKLDNNElementwiseAddOp): +class TestOneDNNElementwiseAddOp5(TestOneDNNElementwiseAddOp): def init_input_output(self): self.x = np.random.uniform(1, 2, [2, 3, 4, 100]).astype(self.dtype) self.y = np.random.uniform(1, 2, [100]).astype(self.dtype) self.out = np.add(self.x, self.y) -class TestMKLDNNElementwiseAddOpBroadcastXintoY(TestMKLDNNElementwiseAddOp): +class TestOneDNNElementwiseAddOpBroadcastXintoY(TestOneDNNElementwiseAddOp): def init_input_output(self): self.x = np.random.uniform(1, 2, [2, 50, 1]).astype(self.dtype) self.y = np.random.uniform(1, 2, [2, 50, 160]).astype(self.dtype) self.out = np.add(self.x, self.y) -class TestMKLDNNElementwiseAddOp_broadcast_3(TestMKLDNNElementwiseAddOp): +class TestOneDNNElementwiseAddOp_broadcast_3(TestOneDNNElementwiseAddOp): def init_input_output(self): self.x = np.random.rand(2, 10, 12, 3).astype(self.dtype) self.y = np.random.rand(10, 12).astype(self.dtype) @@ -83,7 +83,7 @@ class TestMKLDNNElementwiseAddOp_broadcast_3(TestMKLDNNElementwiseAddOp): self.axis = 1 -class TestElementwiseAddOp_xsize_lessthan_ysize_add(TestMKLDNNElementwiseAddOp): +class TestElementwiseAddOp_xsize_lessthan_ysize_add(TestOneDNNElementwiseAddOp): def init_input_output(self): self.x = np.random.rand(10, 12).astype(self.dtype) self.y = np.random.rand(2, 2, 10, 12).astype(self.dtype) @@ -103,21 +103,21 @@ class TestElementwiseAddOp_xsize_lessthan_ysize_add(TestMKLDNNElementwiseAddOp): pass -class TestMKLDNNElementwiseAddOpZeroDim(TestMKLDNNElementwiseAddOp): +class TestOneDNNlementwiseAddOpZeroDim(TestOneDNNElementwiseAddOp): def init_input_output(self): self.x = np.random.random((100,)).astype(self.dtype) self.y = np.array(3.0).astype(self.dtype) self.out = np.add(self.x, self.y) -class TestMKLDNNElementwiseAddOpZeroDim2(TestMKLDNNElementwiseAddOp): +class TestOneDNNlementwiseAddOpZeroDim2(TestOneDNNElementwiseAddOp): def init_input_output(self): self.x = np.array(3.0).astype(self.dtype) self.y = np.random.random((100,)).astype(self.dtype) self.out = np.add(self.x, self.y) -class TestMKLDNNElementwiseAddOpZeroDim3(TestMKLDNNElementwiseAddOp): +class TestOneDNNlementwiseAddOpZeroDim3(TestOneDNNElementwiseAddOp): def init_input_output(self): self.x = np.array(3.0).astype(self.dtype) self.y = np.array(3.0).astype(self.dtype) @@ -144,9 +144,9 @@ class TestInt8(TestElementwiseAddOp): self.out = np.add(self.x, self.y) def init_scales(self): - self.attrs['Scale_x'] = 1.0 - self.attrs['Scale_y'] = 1.0 - self.attrs['Scale_out'] = 1.0 + self.attrs['scale_x'] = 1.0 + self.attrs['scale_y'] = 1.0 + self.attrs['scale_out'] = 1.0 def test_check_output(self): # TODO(wangzhongpu): support mkldnn op in dygraph mode @@ -163,48 +163,6 @@ class TestInt8(TestElementwiseAddOp): pass -class TestInt8Scales(TestInt8): - def quantize(self, tensor, dt="int8"): - max_int = 127.0 if dt == "int8" else 255.0 - scale = max_int / np.abs(np.amax(tensor)) - quantized = np.round(scale * tensor).astype(dt) - return scale, quantized - - def init_input_output(self): - self.x_f = np.random.random((100,)).astype("float") - self.y_f = np.random.random((100,)).astype("float") - self.out_f = np.add(self.x_f, self.y_f) - - self.scale_x, self.x = self.quantize(self.x_f) - self.scale_y, self.y = self.quantize(self.y_f) - self.scale_o, self.out = self.quantize(self.out_f) - - def init_scales(self): - self.attrs['Scale_x'] = self.scale_x - self.attrs['Scale_y'] = self.scale_y - self.attrs['Scale_out'] = self.scale_o - - def test_check_output(self): - # TODO(wangzhongpu): support mkldnn op in dygraph mode - self.init_scales() - int_atol = 1 # different quantization techniques - self.check_output(check_dygraph=(not self.use_mkldnn), atol=int_atol) - - -class TestUint8Scales(TestInt8Scales): - def init_input_output(self): - self.x_f = np.random.random((100,)).astype("float") - self.y_f = np.random.random((100,)).astype("float") - self.out_f = np.add(self.x_f, self.y_f) - - self.scale_x, self.x = self.quantize(self.x_f, "uint8") - self.scale_y, self.y = self.quantize(self.y_f, "uint8") - self.scale_o, self.out = self.quantize(self.out_f, "uint8") - - def init_dtype(self): - self.dtype = np.uint8 - - if __name__ == '__main__': enable_static() unittest.main() diff --git a/test/mkldnn/test_elementwise_mul_mkldnn_op.py b/test/mkldnn/test_elementwise_mul_onednn_op.py similarity index 66% rename from test/mkldnn/test_elementwise_mul_mkldnn_op.py rename to test/mkldnn/test_elementwise_mul_onednn_op.py index 8d60282abcbdd08fcb9daedda71692d1fe1699d0..09ba96995d3f57b35a06547826a5d8204692d01e 100644 --- a/test/mkldnn/test_elementwise_mul_mkldnn_op.py +++ b/test/mkldnn/test_elementwise_mul_onednn_op.py @@ -23,7 +23,7 @@ from paddle.fluid.tests.unittests.test_elementwise_mul_op import ( ) -class TestMKLDNNElementwiseMulOp(ElementwiseMulOp): +class TestOneDNNElementwiseMulOp(ElementwiseMulOp): def init_kernel_type(self): self.use_mkldnn = True @@ -31,21 +31,21 @@ class TestMKLDNNElementwiseMulOp(ElementwiseMulOp): self.dtype = np.float32 -class TestMKLDNNElementwiseMulOp2(TestMKLDNNElementwiseMulOp): +class TestOneDNNElementwiseMulOp2(TestOneDNNElementwiseMulOp): def init_input_output(self): self.x = np.random.random((100,)).astype(self.dtype) self.y = np.random.random((100,)).astype(self.dtype) self.out = np.multiply(self.x, self.y) -class TestMKLDNNElementwiseMulOp3(TestMKLDNNElementwiseMulOp): +class TestOneDNNElementwiseMulOp3(TestOneDNNElementwiseMulOp): def init_input_output(self): self.x = np.random.uniform(0.1, 1, [2, 3, 4, 5]).astype(self.dtype) self.y = np.random.uniform(0.1, 1, [2, 3, 4, 5]).astype(self.dtype) self.out = np.multiply(self.x, self.y) -class TestMKLDNNElementwiseMulOp4(TestMKLDNNElementwiseMulOp): +class TestOneDNNElementwiseMulOp4(TestOneDNNElementwiseMulOp): def init_input_output(self): self.x = np.random.uniform(1, 2, [2, 3, 4, 32]).astype(self.dtype) self.y = np.random.uniform(1, 2, [4, 32]).astype(self.dtype) @@ -59,7 +59,7 @@ class TestMKLDNNElementwiseMulOp4(TestMKLDNNElementwiseMulOp): pass -class TestMKLDNNElementwiseMulOp5(TestMKLDNNElementwiseMulOp): +class TestOneDNNElementwiseMulOp5(TestOneDNNElementwiseMulOp): def init_input_output(self): self.x = np.random.uniform(1, 2, [2, 3, 4, 100]).astype(self.dtype) self.y = np.random.uniform(1, 2, [100]).astype(self.dtype) @@ -76,7 +76,7 @@ class TestMKLDNNElementwiseMulOp5(TestMKLDNNElementwiseMulOp): pass -class TestMKLDNNElementwiseMulOpZeroDim(TestMKLDNNElementwiseMulOp): +class TestOneDNNElementwiseMulOpZeroDim(TestOneDNNElementwiseMulOp): def init_input_output(self): self.x = np.random.random((100,)).astype(self.dtype) self.y = np.array(3.0).astype(self.dtype) @@ -92,7 +92,7 @@ class TestMKLDNNElementwiseMulOpZeroDim(TestMKLDNNElementwiseMulOp): pass -class TestMKLDNNElementwiseMulOpZeroDim2(TestMKLDNNElementwiseMulOp): +class TestOneDNNElementwiseMulOpZeroDim2(TestOneDNNElementwiseMulOp): def init_input_output(self): self.x = np.array(3.0).astype(self.dtype) self.y = np.random.random((100,)).astype(self.dtype) @@ -108,7 +108,7 @@ class TestMKLDNNElementwiseMulOpZeroDim2(TestMKLDNNElementwiseMulOp): pass -class TestMKLDNNElementwiseMulOpZeroDim3(TestMKLDNNElementwiseMulOp): +class TestOneDNNElementwiseMulOpZeroDim3(TestOneDNNElementwiseMulOp): def init_input_output(self): self.x = np.array(3.0).astype(self.dtype) self.y = np.array(3.0).astype(self.dtype) @@ -144,9 +144,9 @@ class TestInt8(ElementwiseMulOp): self.out = np.multiply(self.x, self.y) def init_scales(self): - self.attrs['Scale_x'] = 1.0 - self.attrs['Scale_y'] = 1.0 - self.attrs['Scale_out'] = 1.0 + self.attrs['scale_x'] = 1.0 + self.attrs['scale_y'] = 1.0 + self.attrs['scale_out'] = 1.0 def test_check_output(self): # TODO(wangzhongpu): support mkldnn op in dygraph mode @@ -163,48 +163,6 @@ class TestInt8(ElementwiseMulOp): pass -class TestInt8Scales(TestInt8): - def quantize(self, tensor, dt="int8"): - max_int = 127.0 if dt == "int8" else 255.0 - scale = max_int / np.abs(np.amax(tensor)) - quantized = np.round(scale * tensor).astype(dt) - return scale, quantized - - def init_input_output(self): - self.x_f = np.random.random((100,)).astype("float") - self.y_f = np.random.random((100,)).astype("float") - self.out_f = np.multiply(self.x_f, self.y_f) - - self.scale_x, self.x = self.quantize(self.x_f) - self.scale_y, self.y = self.quantize(self.y_f) - self.scale_o, self.out = self.quantize(self.out_f) - - def init_scales(self): - self.attrs['Scale_x'] = self.scale_x - self.attrs['Scale_y'] = self.scale_y - self.attrs['Scale_out'] = self.scale_o - - def test_check_output(self): - # TODO(wangzhongpu): support mkldnn op in dygraph mode - self.init_scales() - int_atol = 1 # different quantization techniques - self.check_output(check_dygraph=(not self.use_mkldnn), atol=int_atol) - - -class TestUint8Scales(TestInt8Scales): - def init_input_output(self): - self.x_f = np.random.random((100,)).astype("float") - self.y_f = np.random.random((100,)).astype("float") - self.out_f = np.multiply(self.x_f, self.y_f) - - self.scale_x, self.x = self.quantize(self.x_f, "uint8") - self.scale_y, self.y = self.quantize(self.y_f, "uint8") - self.scale_o, self.out = self.quantize(self.out_f, "uint8") - - def init_dtype(self): - self.dtype = np.uint8 - - if __name__ == '__main__': enable_static() unittest.main() diff --git a/test/mkldnn/test_elementwise_sub_mkldnn_op.py b/test/mkldnn/test_elementwise_sub_onednn_op.py similarity index 91% rename from test/mkldnn/test_elementwise_sub_mkldnn_op.py rename to test/mkldnn/test_elementwise_sub_onednn_op.py index 2f74c0da3180a621caf10ef2fff3b25eecfeedb2..35dac7b091ed01cefbf21b777ccb9829318e82f1 100644 --- a/test/mkldnn/test_elementwise_sub_mkldnn_op.py +++ b/test/mkldnn/test_elementwise_sub_onednn_op.py @@ -30,7 +30,7 @@ from paddle.fluid.tests.unittests.eager_op_test import ( not (isinstance(_current_expected_place(), core.CPUPlace)), "GPU is not supported", ) -class TestMKLDNNElementwiseSubOp(OpTest): +class TestOneDNNElementwiseSubOp(OpTest): def setUp(self): self.op_type = "elementwise_sub" self.init_dtype() @@ -71,49 +71,49 @@ class TestMKLDNNElementwiseSubOp(OpTest): self.check_output() -class TestMKLDNNElementwiseSubOp2(TestMKLDNNElementwiseSubOp): +class TestOneDNNElementwiseSubOp2(TestOneDNNElementwiseSubOp): def init_input_output(self): self.x = np.random.random((100,)).astype(self.dtype) self.y = np.random.random((100,)).astype(self.dtype) self.out = np.subtract(self.x, self.y) -class TestMKLDNNElementwiseSubOp3(TestMKLDNNElementwiseSubOp): +class TestOneDNNElementwiseSubOp3(TestOneDNNElementwiseSubOp): def init_input_output(self): self.x = np.random.uniform(0.1, 1, [2, 3, 4, 5]).astype(self.dtype) self.y = np.random.uniform(0.1, 1, [2, 3, 4, 5]).astype(self.dtype) self.out = np.subtract(self.x, self.y) -class TestMKLDNNElementwiseSubOp4(TestMKLDNNElementwiseSubOp): +class TestOneDNNElementwiseSubOp4(TestOneDNNElementwiseSubOp): def init_input_output(self): self.x = np.random.uniform(1, 2, [2, 3, 4, 32]).astype(self.dtype) self.y = np.random.uniform(1, 2, [4, 32]).astype(self.dtype) self.out = np.subtract(self.x, self.y) -class TestMKLDNNElementwiseSubOp5(TestMKLDNNElementwiseSubOp): +class TestOneDNNElementwiseSubOp5(TestOneDNNElementwiseSubOp): def init_input_output(self): self.x = np.random.uniform(1, 2, [2, 3, 4, 100]).astype(self.dtype) self.y = np.random.uniform(1, 2, [100]).astype(self.dtype) self.out = np.subtract(self.x, self.y) -class TestMKLDNNElementwiseSubOp6(TestMKLDNNElementwiseSubOp): +class TestOneDNNElementwiseSubOp6(TestOneDNNElementwiseSubOp): def init_input_output(self): self.x = np.random.uniform(0.1, 2, [180, 1]).astype(self.dtype) self.y = np.random.uniform(0.1, 1, [1, 256]).astype(self.dtype) self.out = np.subtract(self.x, self.y) -class TestMKLDNNElementwiseSubOp7(TestMKLDNNElementwiseSubOp): +class TestOneDNNElementwiseSubOp7(TestOneDNNElementwiseSubOp): def init_input_output(self): self.x = np.random.uniform(0.1, 2, [1, 180]).astype(self.dtype) self.y = np.random.uniform(0.1, 1, [256, 1]).astype(self.dtype) self.out = np.subtract(self.x, self.y) -class TestMKLDNNElementwiseSubOp_broadcast(TestMKLDNNElementwiseSubOp): +class TestOneDNNElementwiseSubOp_broadcast(TestOneDNNElementwiseSubOp): def init_input_output(self): self.x = np.random.rand(2, 10, 12, 3).astype(self.dtype) self.y = np.random.rand(10, 12).astype(self.dtype) @@ -123,7 +123,7 @@ class TestMKLDNNElementwiseSubOp_broadcast(TestMKLDNNElementwiseSubOp): self.axis = 1 -class TestElementwiseSubOp_xsize_lessthan_ysize_sub(TestMKLDNNElementwiseSubOp): +class TestElementwiseSubOp_xsize_lessthan_ysize_sub(TestOneDNNElementwiseSubOp): def init_input_output(self): self.x = np.random.rand(10, 12).astype(self.dtype) self.y = np.random.rand(2, 2, 10, 12).astype(self.dtype) @@ -133,7 +133,7 @@ class TestElementwiseSubOp_xsize_lessthan_ysize_sub(TestMKLDNNElementwiseSubOp): self.axis = 2 -class TestMKLDNNElementwiseSubOpZeroDim(TestMKLDNNElementwiseSubOp): +class TestOneDNNElementwiseSubOpZeroDim(TestOneDNNElementwiseSubOp): def init_input_output(self): self.x = np.random.random((100,)).astype(self.dtype) self.y = np.array(3.0).astype(self.dtype) @@ -149,7 +149,7 @@ class TestMKLDNNElementwiseSubOpZeroDim(TestMKLDNNElementwiseSubOp): pass -class TestMKLDNNElementwiseSubOpZeroDim2(TestMKLDNNElementwiseSubOp): +class TestOneDNNElementwiseSubOpZeroDim2(TestOneDNNElementwiseSubOp): def init_input_output(self): self.x = np.array(3.0).astype(self.dtype) self.y = np.random.random((100,)).astype(self.dtype) @@ -165,7 +165,7 @@ class TestMKLDNNElementwiseSubOpZeroDim2(TestMKLDNNElementwiseSubOp): pass -class TestMKLDNNElementwiseSubOpZeroDim3(TestMKLDNNElementwiseSubOp): +class TestOneDNNElementwiseSubOpZeroDim3(TestOneDNNElementwiseSubOp): def init_input_output(self): self.x = np.array(3.0).astype(self.dtype) self.y = np.array(3.0).astype(self.dtype) @@ -182,7 +182,7 @@ class TestMKLDNNElementwiseSubOpZeroDim3(TestMKLDNNElementwiseSubOp): @OpTestTool.skip_if_not_cpu_bf16() -class TestBf16(TestMKLDNNElementwiseSubOp): +class TestBf16(TestOneDNNElementwiseSubOp): def setUp(self): self.op_type = "elementwise_sub" self.init_dtype() @@ -271,7 +271,7 @@ class TestBf16Broadcasting(TestBf16): ) -class TestInt8(TestMKLDNNElementwiseSubOp): +class TestInt8(TestOneDNNElementwiseSubOp): def init_kernel_type(self): self.use_mkldnn = True self._cpu_only = True