From 9f058af6d88b98e8c82cd284dd48d3d9a3093517 Mon Sep 17 00:00:00 2001 From: wangshuide2020 Date: Thu, 22 Apr 2021 16:11:52 +0800 Subject: [PATCH] add adapter of Erf, Expm1, Inv, etc. for graphengine. --- .../ccsrc/transform/graph_ir/op_adapter_map.h | 40 +++++++++++- .../elewise_calculation_ops_declare.cc | 62 ++++++++++++++++++- .../elewise_calculation_ops_declare.h | 32 +++++++++- .../graph_ir/op_declare/math_ops_declare.cc | 12 ++++ .../graph_ir/op_declare/math_ops_declare.h | 7 +++ .../matrix_calculation_ops_declare.cc | 27 +++++++- .../matrix_calculation_ops_declare.h | 14 ++++- .../op_declare/nn_norm_ops_declare.cc | 21 ++++++- .../graph_ir/op_declare/nn_norm_ops_declare.h | 8 ++- .../op_declare/nn_pooling_ops_declare.cc | 30 ++++++++- .../op_declare/nn_pooling_ops_declare.h | 9 +++ .../op_declare/nonlinear_fuc_ops_declare.cc | 14 ++++- .../op_declare/nonlinear_fuc_ops_declare.h | 8 ++- .../graph_ir/op_declare/pad_ops_declare.cc | 8 ++- .../graph_ir/op_declare/pad_ops_declare.h | 5 +- .../graph_ir/op_declare/random_ops_declare.cc | 8 ++- .../graph_ir/op_declare/random_ops_declare.h | 5 +- .../graph_ir/op_declare/reduce_ops_declare.cc | 44 ++++++++++++- .../graph_ir/op_declare/reduce_ops_declare.h | 18 +++++- .../graph_ir/op_declare/rnn_declare.cc | 11 +++- .../graph_ir/op_declare/rnn_declare.h | 5 +- .../op_declare/selection_ops_declare.cc | 29 ++++++++- .../op_declare/selection_ops_declare.h | 17 ++++- .../split_combination_ops_declare.cc | 13 +++- .../split_combination_ops_declare.h | 6 +- .../op_declare/transformation_ops_declare.cc | 10 ++- .../op_declare/transformation_ops_declare.h | 5 +- 27 files changed, 443 insertions(+), 25 deletions(-) diff --git a/mindspore/ccsrc/transform/graph_ir/op_adapter_map.h b/mindspore/ccsrc/transform/graph_ir/op_adapter_map.h index 632fe4a8d0..5617c6572a 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_adapter_map.h +++ b/mindspore/ccsrc/transform/graph_ir/op_adapter_map.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -121,7 +121,7 @@ constexpr const char kNameReduceProd[] = "ReduceProd"; constexpr const char kNameCumProd[] = "CumProd"; constexpr const char kNameDiagpart[] = "Diagpart"; constexpr const char kNameSplitD[] = "Split"; -constexpr const char kNameBatchToSpaceNd[] = "BatchToSpaceNd"; +constexpr const char kNameBatchToSpaceNd[] = "BatchToSpaceND"; constexpr const char kNameFloor[] = "Floor"; constexpr const char kNameNPUGetFloatStatus[] = "NPUGetFloatStatus"; constexpr const char kNameAssign[] = "Assign"; @@ -132,10 +132,46 @@ constexpr const char kNameNPUClearFloatStatus[] = "NPUClearFloatStatus"; constexpr const char kNameReshape[] = "Reshape"; constexpr const char kNameTransShape[] = "TransShape"; constexpr const char kNameDiv[] = "Div"; +constexpr const char kNameDivNoNan[] = "DivNoNan"; constexpr const char kNameRealDiv[] = "RealDiv"; constexpr const char kNameBitwiseAnd[] = "BitwiseAnd"; constexpr const char kNameBitwiseOr[] = "BitwiseOr"; constexpr const char kNameBitwiseXor[] = "BitwiseXor"; +constexpr const char kNameBesselI0e[] = "BesselI0e"; +constexpr const char kNameBesselI1e[] = "BesselI1e"; +constexpr const char kNameBNTrainingReduce[] = "BNTrainingReduce"; +constexpr const char kNameBNTrainingReduceGrad[] = "BNTrainingReduceGrad"; +constexpr const char kNameBNTrainingUpdate[] = "BNTrainingUpdate"; +constexpr const char kNameBNTrainingUpdateGrad[] = "BNTrainingUpdateGrad"; +constexpr const char kNameErf[] = "Erf"; +constexpr const char kNameErfc[] = "Erfc"; +constexpr const char kNameExpm1[] = "Expm1"; +constexpr const char kNameFillD[] = "Fill"; +constexpr const char kNameInplaceAddD[] = "InplaceAdd"; +constexpr const char kNameInplaceSubD[] = "InplaceSub"; +constexpr const char kNameInplaceUpdateD[] = "InplaceUpdate"; +constexpr const char kNameInTopK[] = "InTopK"; +constexpr const char kNameInv[] = "Inv"; +constexpr const char kNameInvGrad[] = "InvGrad"; +constexpr const char kNameInvert[] = "Invert"; +constexpr const char kNameLinSpaceD[] = "LinSpace"; +constexpr const char kNameLog1p[] = "Log1p"; +constexpr const char kNameLRN[] = "LRN"; +constexpr const char kNameLRNGrad[] = "LRNGrad"; +constexpr const char kNameLSTMInputGrad[] = "LSTMInputGrad"; +constexpr const char kNameMatMul[] = "MatMul"; +constexpr const char kNameMatrixDiagD[] = "MatrixDiag"; +constexpr const char kNameMatrixDiagPartD[] = "MatrixDiagPart"; +constexpr const char kNameMatrixSetDiagD[] = "MatrixSetDiag"; +constexpr const char kNameMaxPool3DGradGrad[] = "MaxPool3DGradGrad"; +constexpr const char kNameMaxPoolGradGrad[] = "MaxPoolGradGrad"; +constexpr const char kNameMaxPoolGradGradWithArgmax[] = "MaxPoolGradGradWithArgmax"; +constexpr const char kNameMish[] = "Mish"; +constexpr const char kNameMulNoNan[] = "MulNoNan"; +constexpr const char kNameParallelConcat[] = "ParallelConcat"; +constexpr const char kNamePopulationCount[] = "PopulationCount"; +constexpr const char kNameReduceAnyD[] = "ReduceAny"; +constexpr const char kNameReluGradV2[] = "ReluGradV2"; constexpr const char kNameCeil[] = "Ceil"; constexpr const char kNameCosineEmbeddingLoss[] = "CosineEmbeddingLoss"; constexpr const char kNameXdivy[] = "Xdivy"; diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/elewise_calculation_ops_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/elewise_calculation_ops_declare.cc index acdb7ade02..8da5d012a8 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/elewise_calculation_ops_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/elewise_calculation_ops_declare.cc @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -94,6 +94,12 @@ ATTR_MAP(Div) = EMPTY_ATTR_MAP; OUTPUT_MAP(Div) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(Div, kNameDiv, ADPT_DESC(Div)) +// DivNoNan +INPUT_MAP(DivNoNan) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}}; +ATTR_MAP(DivNoNan) = EMPTY_ATTR_MAP; +OUTPUT_MAP(DivNoNan) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(DivNoNan, kNameDivNoNan, ADPT_DESC(DivNoNan)) + // Floor INPUT_MAP(Floor) = {{1, INPUT_DESC(x)}}; ATTR_MAP(Floor) = EMPTY_ATTR_MAP; @@ -197,6 +203,12 @@ ATTR_MAP(Exp) = EMPTY_ATTR_MAP; OUTPUT_MAP(Exp) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(Exp, kNameExp, ADPT_DESC(Exp)) +// Expm1 +INPUT_MAP(Expm1) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(Expm1) = EMPTY_ATTR_MAP; +OUTPUT_MAP(Expm1) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(Expm1, kNameExpm1, ADPT_DESC(Expm1)) + // BiasAdd INPUT_MAP(BiasAdd) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(bias)}}; ATTR_MAP(BiasAdd) = {{"format", ATTR_DESC(data_format, AnyTraits())}}; @@ -243,6 +255,42 @@ ATTR_MAP(ArgMinWithValue) = {{"axis", ATTR_DESC(dimension, AnyTraits()) OUTPUT_MAP(ArgMinWithValue) = {{0, OUTPUT_DESC(indice)}, {1, OUTPUT_DESC(values)}}; REG_ADPT_DESC(ArgMinWithValue, kNameArgMinWithValue, ADPT_DESC(ArgMinWithValue)) +// BesselI0e +INPUT_MAP(BesselI0e) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(BesselI0e) = EMPTY_ATTR_MAP; +OUTPUT_MAP(BesselI0e) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(BesselI0e, kNameBesselI0e, ADPT_DESC(BesselI0e)) + +// BesselI1e +INPUT_MAP(BesselI1e) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(BesselI1e) = EMPTY_ATTR_MAP; +OUTPUT_MAP(BesselI1e) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(BesselI1e, kNameBesselI1e, ADPT_DESC(BesselI1e)) + +// Inv +INPUT_MAP(Inv) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(Inv) = EMPTY_ATTR_MAP; +OUTPUT_MAP(Inv) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(Inv, kNameInv, ADPT_DESC(Inv)) + +// InvGrad +INPUT_MAP(InvGrad) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(grad)}}; +ATTR_MAP(InvGrad) = EMPTY_ATTR_MAP; +OUTPUT_MAP(InvGrad) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(InvGrad, kNameInvGrad, ADPT_DESC(InvGrad)) + +// Invert +INPUT_MAP(Invert) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(Invert) = EMPTY_ATTR_MAP; +OUTPUT_MAP(Invert) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(Invert, kNameInvert, ADPT_DESC(Invert)) + +// Log1p +INPUT_MAP(Log1p) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(Log1p) = EMPTY_ATTR_MAP; +OUTPUT_MAP(Log1p) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(Log1p, kNameLog1p, ADPT_DESC(Log1p)) + // RsqrtGrad INPUT_MAP(RsqrtGrad) = {{1, INPUT_DESC(y)}, {2, INPUT_DESC(dy)}}; ATTR_MAP(RsqrtGrad) = EMPTY_ATTR_MAP; @@ -274,6 +322,12 @@ ATTR_MAP(Mul) = EMPTY_ATTR_MAP; OUTPUT_MAP(Mul) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(Mul, prim::kPrimMul->name(), ADPT_DESC(Mul)) +// MulNoNan +INPUT_MAP(MulNoNan) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}}; +ATTR_MAP(MulNoNan) = EMPTY_ATTR_MAP; +OUTPUT_MAP(MulNoNan) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(MulNoNan, kNameMulNoNan, ADPT_DESC(MulNoNan)) + // RealDiv INPUT_MAP(RealDiv) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}}; ATTR_MAP(RealDiv) = EMPTY_ATTR_MAP; @@ -370,6 +424,12 @@ ATTR_MAP(Pow) = EMPTY_ATTR_MAP; OUTPUT_MAP(Pow) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(Pow, kNamePow, ADPT_DESC(Pow)) +// PopulationCount +INPUT_MAP(PopulationCount) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(PopulationCount) = EMPTY_ATTR_MAP; +OUTPUT_MAP(PopulationCount) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(PopulationCount, kNamePopulationCount, ADPT_DESC(PopulationCount)) + // Equal INPUT_MAP(Equal) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}}; ATTR_MAP(Equal) = EMPTY_ATTR_MAP; diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/elewise_calculation_ops_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/elewise_calculation_ops_declare.h index dd1b95cd19..017a4d3550 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/elewise_calculation_ops_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/elewise_calculation_ops_declare.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -53,6 +53,9 @@ DECLARE_OP_USE_OUTPUT(ArgMinWithValue) DECLARE_OP_ADAPTER(Mul) DECLARE_OP_USE_OUTPUT(Mul) +DECLARE_OP_ADAPTER(MulNoNan) +DECLARE_OP_USE_OUTPUT(MulNoNan) + DECLARE_OP_ADAPTER(AddN) DECLARE_OP_USE_DYN_INPUT(AddN) DECLARE_OP_USE_OUTPUT(AddN) @@ -96,6 +99,24 @@ DECLARE_OP_USE_OUTPUT(BitwiseOr) DECLARE_OP_ADAPTER(BitwiseXor) DECLARE_OP_USE_OUTPUT(BitwiseXor) +DECLARE_OP_ADAPTER(BesselI0e) +DECLARE_OP_USE_OUTPUT(BesselI0e) + +DECLARE_OP_ADAPTER(BesselI1e) +DECLARE_OP_USE_OUTPUT(BesselI1e) + +DECLARE_OP_ADAPTER(Inv) +DECLARE_OP_USE_OUTPUT(Inv) + +DECLARE_OP_ADAPTER(InvGrad) +DECLARE_OP_USE_OUTPUT(InvGrad) + +DECLARE_OP_ADAPTER(Invert) +DECLARE_OP_USE_OUTPUT(Invert) + +DECLARE_OP_ADAPTER(Log1p) +DECLARE_OP_USE_OUTPUT(Log1p) + DECLARE_OP_ADAPTER(Ceil) DECLARE_OP_USE_OUTPUT(Ceil) @@ -124,6 +145,9 @@ DECLARE_OP_USE_OUTPUT(Sub) DECLARE_OP_ADAPTER(Pow) DECLARE_OP_USE_OUTPUT(Pow) +DECLARE_OP_ADAPTER(PopulationCount) +DECLARE_OP_USE_OUTPUT(PopulationCount) + DECLARE_OP_ADAPTER(Equal) DECLARE_OP_USE_OUTPUT(Equal) @@ -175,6 +199,9 @@ DECLARE_OP_USE_OUTPUT(AcoshGrad) DECLARE_OP_ADAPTER(Div) DECLARE_OP_USE_OUTPUT(Div) +DECLARE_OP_ADAPTER(DivNoNan) +DECLARE_OP_USE_OUTPUT(DivNoNan) + DECLARE_OP_ADAPTER(Floor) DECLARE_OP_USE_OUTPUT(Floor) @@ -205,6 +232,9 @@ DECLARE_OP_USE_OUTPUT(AsinhGrad) DECLARE_OP_ADAPTER(Exp) DECLARE_OP_USE_OUTPUT(Exp) +DECLARE_OP_ADAPTER(Expm1) +DECLARE_OP_USE_OUTPUT(Expm1) + DECLARE_OP_ADAPTER(BiasAdd) DECLARE_OP_USE_OUTPUT(BiasAdd) diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/math_ops_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/math_ops_declare.cc index 129cca0c21..261ca98ae5 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/math_ops_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/math_ops_declare.cc @@ -32,4 +32,16 @@ INPUT_MAP(NLLLossGrad) = {{1, INPUT_DESC(x)}, ATTR_MAP(NLLLossGrad) = {{"reduction", ATTR_DESC(reduction, AnyTraits())}}; OUTPUT_MAP(NLLLossGrad) = {{0, OUTPUT_DESC(x_grad)}}; REG_ADPT_DESC(NLLLossGrad, kNameNLLLossGrad, ADPT_DESC(NLLLossGrad)) + +// Erf +INPUT_MAP(Erf) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(Erf) = EMPTY_ATTR_MAP; +OUTPUT_MAP(Erf) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(Erf, kNameErf, ADPT_DESC(Erf)) + +// Erfc +INPUT_MAP(Erfc) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(Erfc) = EMPTY_ATTR_MAP; +OUTPUT_MAP(Erfc) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(Erfc, kNameErfc, ADPT_DESC(Erfc)) } // namespace mindspore::transform diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/math_ops_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/math_ops_declare.h index dcd739413c..dc25ca7c7d 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/math_ops_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/math_ops_declare.h @@ -25,7 +25,14 @@ namespace mindspore::transform { DECLARE_OP_ADAPTER(NLLLoss) DECLARE_OP_USE_OUTPUT(NLLLoss) + DECLARE_OP_ADAPTER(NLLLossGrad) DECLARE_OP_USE_OUTPUT(NLLLossGrad) + +DECLARE_OP_ADAPTER(Erf) +DECLARE_OP_USE_OUTPUT(Erf) + +DECLARE_OP_ADAPTER(Erfc) +DECLARE_OP_USE_OUTPUT(Erfc) } // namespace mindspore::transform #endif // MINDSPORE_CCSRC_TRANSFORM_GRAPH_IR_OP_DECLARE_MATH_OPS_DECLARE_H_ diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/matrix_calculation_ops_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/matrix_calculation_ops_declare.cc index e376202520..748d858c88 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/matrix_calculation_ops_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/matrix_calculation_ops_declare.cc @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -41,6 +41,13 @@ ATTR_MAP(ScatterMax) = {{"use_locking", ATTR_DESC(use_locking, AnyTraits() OUTPUT_MAP(ScatterMax) = {{0, OUTPUT_DESC(var)}}; REG_ADPT_DESC(ScatterMax, kNameScatterMax, ADPT_DESC(ScatterMax)) +// MatMul +INPUT_MAP(MatMul) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}, {3, INPUT_DESC(bias)}}; +ATTR_MAP(MatMul) = {{"transpose_x1", ATTR_DESC(transpose_x1, AnyTraits())}, + {"transpose_x2", ATTR_DESC(transpose_x2, AnyTraits())}}; +OUTPUT_MAP(MatMul) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(MatMul, kNameMatMul, ADPT_DESC(MatMul)) + // MatMulV2 INPUT_MAP(MatMulV2) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}, {3, INPUT_DESC(bias)}}; ATTR_MAP(MatMulV2) = {{"transpose_a", ATTR_DESC(transpose_x1, AnyTraits())}, @@ -48,6 +55,24 @@ ATTR_MAP(MatMulV2) = {{"transpose_a", ATTR_DESC(transpose_x1, AnyTraits()) OUTPUT_MAP(MatMulV2) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(MatMulV2, prim::kPrimMatMul->name(), ADPT_DESC(MatMulV2)) +// MatrixDiagD +INPUT_MAP(MatrixDiagD) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(assist)}}; +ATTR_MAP(MatrixDiagD) = EMPTY_ATTR_MAP; +OUTPUT_MAP(MatrixDiagD) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(MatrixDiagD, kNameMatrixDiagD, ADPT_DESC(MatrixDiagD)) + +// MatrixDiagPartD +INPUT_MAP(MatrixDiagPartD) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(assist)}}; +ATTR_MAP(MatrixDiagPartD) = EMPTY_ATTR_MAP; +OUTPUT_MAP(MatrixDiagPartD) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(MatrixDiagPartD, kNameMatrixDiagPartD, ADPT_DESC(MatrixDiagPartD)) + +// MatrixSetDiagD +INPUT_MAP(MatrixSetDiagD) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(diagonal)}, {3, INPUT_DESC(assist)}}; +ATTR_MAP(MatrixSetDiagD) = EMPTY_ATTR_MAP; +OUTPUT_MAP(MatrixSetDiagD) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(MatrixSetDiagD, kNameMatrixSetDiagD, ADPT_DESC(MatrixSetDiagD)) + // DiagPart INPUT_MAP(DiagPart) = {{1, INPUT_DESC(x)}}; ATTR_MAP(DiagPart) = EMPTY_ATTR_MAP; diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/matrix_calculation_ops_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/matrix_calculation_ops_declare.h index 4b21f825e8..c60cef5fd0 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/matrix_calculation_ops_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/matrix_calculation_ops_declare.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -38,9 +38,21 @@ DECLARE_OP_USE_OUTPUT(ScatterMax) DECLARE_OP_ADAPTER(BatchMatMul) DECLARE_OP_USE_OUTPUT(BatchMatMul) +DECLARE_OP_ADAPTER(MatMul) +DECLARE_OP_USE_OUTPUT(MatMul) + DECLARE_OP_ADAPTER(MatMulV2) DECLARE_OP_USE_OUTPUT(MatMulV2) +DECLARE_OP_ADAPTER(MatrixDiagD) +DECLARE_OP_USE_OUTPUT(MatrixDiagD) + +DECLARE_OP_ADAPTER(MatrixDiagPartD) +DECLARE_OP_USE_OUTPUT(MatrixDiagPartD) + +DECLARE_OP_ADAPTER(MatrixSetDiagD) +DECLARE_OP_USE_OUTPUT(MatrixSetDiagD) + DECLARE_OP_ADAPTER(DiagPart) DECLARE_OP_USE_OUTPUT(DiagPart) diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/nn_norm_ops_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/nn_norm_ops_declare.cc index d00cde8e3c..a6bb16fbbc 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/nn_norm_ops_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/nn_norm_ops_declare.cc @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -103,6 +103,25 @@ ATTR_MAP(LayerNormGrad) = EMPTY_ATTR_MAP; OUTPUT_MAP(LayerNormGrad) = {{0, OUTPUT_DESC(pd_x)}, {1, OUTPUT_DESC(pd_gamma)}, {2, OUTPUT_DESC(pd_beta)}}; REG_ADPT_DESC(LayerNormGrad, prim::kPrimLayerNormGrad->name(), ADPT_DESC(LayerNormGrad)) +// LRN +INPUT_MAP(LRN) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(LRN) = {{"depth_radius", ATTR_DESC(depth_radius, AnyTraits())}, + {"bias", ATTR_DESC(bias, AnyTraits())}, + {"alpha", ATTR_DESC(alpha, AnyTraits())}, + {"beta", ATTR_DESC(beta, AnyTraits())}, + {"norm_region", ATTR_DESC(norm_region, AnyTraits())}}; +OUTPUT_MAP(LRN) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(LRN, kNameLRN, ADPT_DESC(LRN)) + +// LRNGrad +INPUT_MAP(LRNGrad) = {{1, INPUT_DESC(grads)}, {2, INPUT_DESC(x)}, {3, INPUT_DESC(y)}}; +ATTR_MAP(LRNGrad) = {{"depth_radius", ATTR_DESC(depth_radius, AnyTraits())}, + {"bias", ATTR_DESC(bias, AnyTraits())}, + {"alpha", ATTR_DESC(alpha, AnyTraits())}, + {"beta", ATTR_DESC(beta, AnyTraits())}}; +OUTPUT_MAP(LRNGrad) = {{0, OUTPUT_DESC(z)}}; +REG_ADPT_DESC(LRNGrad, kNameLRNGrad, ADPT_DESC(LRNGrad)) + // DropoutDoMask INPUT_MAP(DropOutDoMask) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(mask)}, {3, INPUT_DESC(keep_prob)}}; ATTR_MAP(DropOutDoMask) = EMPTY_ATTR_MAP; diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/nn_norm_ops_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/nn_norm_ops_declare.h index 1494b86f9e..6aa3eeb5a3 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/nn_norm_ops_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/nn_norm_ops_declare.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -50,6 +50,12 @@ DECLARE_OP_USE_OUTPUT(LayerNorm) DECLARE_OP_ADAPTER(LayerNormGrad) DECLARE_OP_USE_OUTPUT(LayerNormGrad) +DECLARE_OP_ADAPTER(LRN) +DECLARE_OP_USE_OUTPUT(LRN) + +DECLARE_OP_ADAPTER(LRNGrad) +DECLARE_OP_USE_OUTPUT(LRNGrad) + DECLARE_OP_ADAPTER(DropOutDoMask) DECLARE_OP_USE_OUTPUT(DropOutDoMask) diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/nn_pooling_ops_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/nn_pooling_ops_declare.cc index a3c0f57fec..9d0b64995f 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/nn_pooling_ops_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/nn_pooling_ops_declare.cc @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -48,6 +48,16 @@ ATTR_MAP(MaxPool3DGrad) = {{"kernel_size", ATTR_DESC(ksize, AnyTraits() OUTPUT_MAP(MaxPool3DGrad) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(MaxPool3DGrad, kNameMaxPool3DGrad, ADPT_DESC(MaxPool3DGrad)) +// MaxPool3DGradGrad +INPUT_MAP(MaxPool3DGradGrad) = {{1, INPUT_DESC(orig_x)}, {2, INPUT_DESC(orig_y)}, {3, INPUT_DESC(grads)}}; +ATTR_MAP(MaxPool3DGradGrad) = { + {"kernel_size", ATTR_DESC(ksize, AnyTraits(), AnyTraits>())}, + {"strides", ATTR_DESC(strides, AnyTraits(), AnyTraits>())}, + {"pad_list", ATTR_DESC(pads, AnyTraits(), AnyTraits>())}, + {"format", ATTR_DESC(data_format, AnyTraits())}}; +OUTPUT_MAP(MaxPool3DGradGrad) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(MaxPool3DGradGrad, kNameMaxPool3DGradGrad, ADPT_DESC(MaxPool3DGradGrad)) + // AvgPool INPUT_MAP(AvgPool) = {{1, INPUT_DESC(x)}}; ATTR_MAP(AvgPool) = {{"kernel_size", ATTR_DESC(ksize, AnyTraits(), AnyTraits>())}, @@ -66,6 +76,15 @@ ATTR_MAP(MaxPoolGrad) = {{"kernel_size", ATTR_DESC(ksize, AnyTraits(), OUTPUT_MAP(MaxPoolGrad) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(MaxPoolGrad, kNameMaxPoolGrad, ADPT_DESC(MaxPoolGrad)) +// MaxPoolGradGrad +INPUT_MAP(MaxPoolGradGrad) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}, {3, INPUT_DESC(grad)}}; +ATTR_MAP(MaxPoolGradGrad) = {{"kernel_size", ATTR_DESC(ksize, AnyTraits(), AnyTraits>())}, + {"strides", ATTR_DESC(strides, AnyTraits(), AnyTraits>())}, + {"pad_mode", ATTR_DESC(padding, AnyTraits())}, + {"format", ATTR_DESC(data_format, AnyTraits())}}; +OUTPUT_MAP(MaxPoolGradGrad) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(MaxPoolGradGrad, kNameMaxPoolGradGrad, ADPT_DESC(MaxPoolGradGrad)) + // avgpoolgrad INPUT_MAP(AvgPoolGrad) = {{1, INPUT_DESC(orig_input_shape)}, {2, INPUT_DESC(input_grad)}}; ATTR_MAP(AvgPoolGrad) = {{"kernel_size", ATTR_DESC(ksize, AnyTraits(), AnyTraits>())}, @@ -92,4 +111,13 @@ ATTR_MAP(MaxPoolGradWithArgmax) = { {"pad_mode", ATTR_DESC(padding, AnyTraits())}}; OUTPUT_MAP(MaxPoolGradWithArgmax) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(MaxPoolGradWithArgmax, kNameMaxPoolGradWithArgmax, ADPT_DESC(MaxPoolGradWithArgmax)) + +// MaxPoolGradGradWithArgmax +INPUT_MAP(MaxPoolGradGradWithArgmax) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(grad)}, {3, INPUT_DESC(argmax)}}; +ATTR_MAP(MaxPoolGradGradWithArgmax) = { + {"kernel_size", ATTR_DESC(ksize, AnyTraits(), AnyTraits>())}, + {"strides", ATTR_DESC(strides, AnyTraits(), AnyTraits>())}, + {"pad_mode", ATTR_DESC(padding, AnyTraits())}}; +OUTPUT_MAP(MaxPoolGradGradWithArgmax) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(MaxPoolGradGradWithArgmax, kNameMaxPoolGradGradWithArgmax, ADPT_DESC(MaxPoolGradGradWithArgmax)) } // namespace mindspore::transform diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/nn_pooling_ops_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/nn_pooling_ops_declare.h index 68576a5649..dc958b8b56 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/nn_pooling_ops_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/nn_pooling_ops_declare.h @@ -29,18 +29,27 @@ DECLARE_OP_USE_OUTPUT(MaxPoolWithArgmax) DECLARE_OP_ADAPTER(MaxPoolGradWithArgmax) DECLARE_OP_USE_OUTPUT(MaxPoolGradWithArgmax) +DECLARE_OP_ADAPTER(MaxPoolGradGradWithArgmax) +DECLARE_OP_USE_OUTPUT(MaxPoolGradGradWithArgmax) + DECLARE_OP_ADAPTER(MaxPool) DECLARE_OP_USE_OUTPUT(MaxPool) DECLARE_OP_ADAPTER(MaxPoolGrad) DECLARE_OP_USE_OUTPUT(MaxPoolGrad) +DECLARE_OP_ADAPTER(MaxPoolGradGrad) +DECLARE_OP_USE_OUTPUT(MaxPoolGradGrad) + DECLARE_OP_ADAPTER(MaxPool3D) DECLARE_OP_USE_OUTPUT(MaxPool3D) DECLARE_OP_ADAPTER(MaxPool3DGrad) DECLARE_OP_USE_OUTPUT(MaxPool3DGrad) +DECLARE_OP_ADAPTER(MaxPool3DGradGrad) +DECLARE_OP_USE_OUTPUT(MaxPool3DGradGrad) + DECLARE_OP_ADAPTER(AvgPool) DECLARE_OP_USE_OUTPUT(AvgPool) diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/nonlinear_fuc_ops_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/nonlinear_fuc_ops_declare.cc index 321e252316..f7015417c8 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/nonlinear_fuc_ops_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/nonlinear_fuc_ops_declare.cc @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -89,6 +89,12 @@ ATTR_MAP(ReluGrad) = EMPTY_ATTR_MAP; OUTPUT_MAP(ReluGrad) = {{0, OUTPUT_DESC(backprops)}}; REG_ADPT_DESC(ReluGrad, prim::kPrimReluGrad->name(), ADPT_DESC(ReluGrad)) +// ReluGradV2 +INPUT_MAP(ReluGradV2) = {{1, INPUT_DESC(gradients)}, {2, INPUT_DESC(mask)}}; +ATTR_MAP(ReluGradV2) = EMPTY_ATTR_MAP; +OUTPUT_MAP(ReluGradV2) = {{0, OUTPUT_DESC(backprops)}}; +REG_ADPT_DESC(ReluGradV2, kNameReluGradV2, ADPT_DESC(ReluGradV2)) + // Tanh INPUT_MAP(Tanh) = {{1, INPUT_DESC(x)}}; ATTR_MAP(Tanh) = EMPTY_ATTR_MAP; @@ -101,6 +107,12 @@ ATTR_MAP(TanhGrad) = EMPTY_ATTR_MAP; OUTPUT_MAP(TanhGrad) = {{0, OUTPUT_DESC(z)}}; REG_ADPT_DESC(TanhGrad, prim::kPrimTanhGrad->name(), ADPT_DESC(TanhGrad)) +// Mish +INPUT_MAP(Mish) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(Mish) = EMPTY_ATTR_MAP; +OUTPUT_MAP(Mish) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(Mish, kNameMish, ADPT_DESC(Mish)) + // GeLU INPUT_MAP(Gelu) = {{1, INPUT_DESC(x)}}; ATTR_MAP(Gelu) = EMPTY_ATTR_MAP; diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/nonlinear_fuc_ops_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/nonlinear_fuc_ops_declare.h index deda0fa58c..54c2973d99 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/nonlinear_fuc_ops_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/nonlinear_fuc_ops_declare.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,6 +26,9 @@ namespace mindspore::transform { DECLARE_OP_ADAPTER(ReluGrad) DECLARE_OP_USE_OUTPUT(ReluGrad) +DECLARE_OP_ADAPTER(ReluGradV2) +DECLARE_OP_USE_OUTPUT(ReluGradV2) + DECLARE_OP_ADAPTER(Relu6) DECLARE_OP_USE_OUTPUT(Relu6) @@ -44,6 +47,9 @@ DECLARE_OP_USE_OUTPUT(Tanh) DECLARE_OP_ADAPTER(TanhGrad) DECLARE_OP_USE_OUTPUT(TanhGrad) +DECLARE_OP_ADAPTER(Mish) +DECLARE_OP_USE_OUTPUT(Mish) + DECLARE_OP_ADAPTER(Gelu) DECLARE_OP_USE_OUTPUT(Gelu) diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/pad_ops_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/pad_ops_declare.cc index 5f1f5b9c88..fac4680b1f 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/pad_ops_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/pad_ops_declare.cc @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -35,4 +35,10 @@ INPUT_MAP(Diag) = {{1, INPUT_DESC(x)}}; ATTR_MAP(Diag) = EMPTY_ATTR_MAP; OUTPUT_MAP(Diag) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(Diag, kNameDiag, ADPT_DESC(Diag)) + +// FillD +INPUT_MAP(FillD) = {{1, INPUT_DESC(value)}}; +ATTR_MAP(FillD) = {{"dims", ATTR_DESC(dims, AnyTraits>())}}; +OUTPUT_MAP(FillD) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(FillD, kNameFillD, ADPT_DESC(FillD)) } // namespace mindspore::transform diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/pad_ops_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/pad_ops_declare.h index 7fd17432f5..1daa3916af 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/pad_ops_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/pad_ops_declare.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -31,5 +31,8 @@ DECLARE_OP_USE_OUTPUT(BroadcastToD) DECLARE_OP_ADAPTER(Diag) DECLARE_OP_USE_OUTPUT(Diag) + +DECLARE_OP_ADAPTER(FillD) +DECLARE_OP_USE_OUTPUT(FillD) } // namespace mindspore::transform #endif // MINDSPORE_CCSRC_TRANSFORM_GRAPH_IR_OP_DECLARE_PAD_OPS_DECLARE_H_ diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/random_ops_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/random_ops_declare.cc index a407d8c66a..55fa24dca5 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/random_ops_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/random_ops_declare.cc @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -24,6 +24,12 @@ ATTR_MAP(DropOutGenMask) = {{"Seed0", ATTR_DESC(seed, AnyTraits())}, OUTPUT_MAP(DropOutGenMask) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(DropOutGenMask, prim::kPrimDropoutGenMask->name(), ADPT_DESC(DropOutGenMask)) +// LinSpaceD +INPUT_MAP(LinSpaceD) = {{1, INPUT_DESC(assist)}, {2, INPUT_DESC(start)}, {3, INPUT_DESC(stop)}, {4, INPUT_DESC(num)}}; +ATTR_MAP(LinSpaceD) = EMPTY_ATTR_MAP; +OUTPUT_MAP(LinSpaceD) = {{0, OUTPUT_DESC(output)}}; +REG_ADPT_DESC(LinSpaceD, kNameLinSpaceD, ADPT_DESC(LinSpaceD)) + // RandomChoiceWithMask INPUT_MAP(RandomChoiceWithMask) = {{1, INPUT_DESC(x)}}; ATTR_MAP(RandomChoiceWithMask) = {{"count", ATTR_DESC(count, AnyTraits())}, diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/random_ops_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/random_ops_declare.h index 65f3f6b280..e4923e4acf 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/random_ops_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/random_ops_declare.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,6 +26,9 @@ namespace mindspore::transform { DECLARE_OP_ADAPTER(DropOutGenMask) DECLARE_OP_USE_OUTPUT(DropOutGenMask) +DECLARE_OP_ADAPTER(LinSpaceD) +DECLARE_OP_USE_OUTPUT(LinSpaceD) + DECLARE_OP_ADAPTER(RandomChoiceWithMask) DECLARE_OP_USE_OUTPUT(RandomChoiceWithMask) diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/reduce_ops_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/reduce_ops_declare.cc index e641b5d465..1c6e6b1931 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/reduce_ops_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/reduce_ops_declare.cc @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,6 +18,48 @@ #include namespace mindspore::transform { +// BNTrainingReduce +INPUT_MAP(BNTrainingReduce) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(BNTrainingReduce) = EMPTY_ATTR_MAP; +OUTPUT_MAP(BNTrainingReduce) = {{0, OUTPUT_DESC(sum)}, {1, OUTPUT_DESC(square_sum)}}; +REG_ADPT_DESC(BNTrainingReduce, kNameBNTrainingReduce, ADPT_DESC(BNTrainingReduce)) + +// BNTrainingReduceGrad +INPUT_MAP(BNTrainingReduceGrad) = {{1, INPUT_DESC(grads)}, {2, INPUT_DESC(x)}, {3, INPUT_DESC(diff_scale)}, + {4, INPUT_DESC(diff_offset)}, {5, INPUT_DESC(scale)}, {6, INPUT_DESC(batch_mean)}, + {7, INPUT_DESC(batch_variance)}}; +ATTR_MAP(BNTrainingReduceGrad) = {{"epsilon", ATTR_DESC(epsilon, AnyTraits())}}; +OUTPUT_MAP(BNTrainingReduceGrad) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(BNTrainingReduceGrad, kNameBNTrainingReduceGrad, ADPT_DESC(BNTrainingReduceGrad)) + +// BNTrainingUpdate +INPUT_MAP(BNTrainingUpdate) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(sum)}, {3, INPUT_DESC(square_sum)}, + {4, INPUT_DESC(scale)}, {5, INPUT_DESC(offset)}, {6, INPUT_DESC(mean)}, + {7, INPUT_DESC(variance)}}; +ATTR_MAP(BNTrainingUpdate) = {{"factor", ATTR_DESC(factor, AnyTraits())}, + {"epsilon", ATTR_DESC(epsilon, AnyTraits())}}; +OUTPUT_MAP(BNTrainingUpdate) = {{0, OUTPUT_DESC(y)}, + {1, OUTPUT_DESC(mean)}, + {2, OUTPUT_DESC(variance)}, + {3, OUTPUT_DESC(batch_mean)}, + {4, OUTPUT_DESC(batch_variance)}}; +REG_ADPT_DESC(BNTrainingUpdate, kNameBNTrainingUpdate, ADPT_DESC(BNTrainingUpdate)) + +// BNTrainingUpdateGrad +INPUT_MAP(BNTrainingUpdateGrad) = { + {1, INPUT_DESC(grads)}, {2, INPUT_DESC(x)}, {3, INPUT_DESC(batch_mean)}, {4, INPUT_DESC(batch_variance)}}; +ATTR_MAP(BNTrainingUpdateGrad) = {{"epsilon", ATTR_DESC(epsilon, AnyTraits())}}; +OUTPUT_MAP(BNTrainingUpdateGrad) = {{0, OUTPUT_DESC(diff_scale)}, {1, OUTPUT_DESC(diff_offset)}}; +REG_ADPT_DESC(BNTrainingUpdateGrad, kNameBNTrainingUpdateGrad, ADPT_DESC(BNTrainingUpdateGrad)) + +// ReduceAnyD +INPUT_MAP(ReduceAnyD) = {{1, INPUT_DESC(x)}}; +INPUT_ATTR_MAP(ReduceAnyD) = { + {2, ATTR_DESC(axes, AnyTraits>(), AnyTraits>())}}; +ATTR_MAP(ReduceAnyD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits())}}; +OUTPUT_MAP(ReduceAnyD) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(ReduceAnyD, kNameReduceAnyD, ADPT_DESC(ReduceAnyD)) + // ReduceSumD INPUT_MAP(ReduceSumD) = {{1, INPUT_DESC(x)}}; INPUT_ATTR_MAP(ReduceSumD) = { diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/reduce_ops_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/reduce_ops_declare.h index 6bb0e703ae..da609c24ba 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/reduce_ops_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/reduce_ops_declare.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -37,10 +37,26 @@ DECLARE_OP_ADAPTER(ReduceAllD) DECLARE_OP_USE_INPUT_ATTR(ReduceAllD) DECLARE_OP_USE_OUTPUT(ReduceAllD) +DECLARE_OP_ADAPTER(BNTrainingReduce) +DECLARE_OP_USE_OUTPUT(BNTrainingReduce) + +DECLARE_OP_ADAPTER(BNTrainingReduceGrad) +DECLARE_OP_USE_OUTPUT(BNTrainingReduceGrad) + +DECLARE_OP_ADAPTER(BNTrainingUpdate) +DECLARE_OP_USE_OUTPUT(BNTrainingUpdate) + +DECLARE_OP_ADAPTER(BNTrainingUpdateGrad) +DECLARE_OP_USE_OUTPUT(BNTrainingUpdateGrad) + DECLARE_OP_ADAPTER(ReduceSumD) DECLARE_OP_USE_INPUT_ATTR(ReduceSumD) DECLARE_OP_USE_OUTPUT(ReduceSumD) +DECLARE_OP_ADAPTER(ReduceAnyD) +DECLARE_OP_USE_INPUT_ATTR(ReduceAnyD) +DECLARE_OP_USE_OUTPUT(ReduceAnyD) + DECLARE_OP_ADAPTER(ReduceMeanD) DECLARE_OP_USE_INPUT_ATTR(ReduceMeanD) DECLARE_OP_USE_OUTPUT(ReduceMeanD) diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/rnn_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/rnn_declare.cc index f9ded5a9b2..ba8b7dde56 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/rnn_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/rnn_declare.cc @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -49,6 +49,15 @@ ATTR_MAP(BasicLSTMCellCStateGrad) = {{"forget_bias", ATTR_DESC(forget_bias, AnyT OUTPUT_MAP(BasicLSTMCellCStateGrad) = {{0, OUTPUT_DESC(dgate)}, {1, OUTPUT_DESC(dct_1)}}; REG_ADPT_DESC(BasicLSTMCellCStateGrad, kNameBasicLSTMCellCStateGrad, ADPT_DESC(BasicLSTMCellCStateGrad)) +// LSTMInputGrad +INPUT_MAP(LSTMInputGrad) = {{1, INPUT_DESC(w)}, {2, INPUT_DESC(init_c)}, {3, INPUT_DESC(c)}, {4, INPUT_DESC(dy)}, + {5, INPUT_DESC(dh)}, {6, INPUT_DESC(dc)}, {7, INPUT_DESC(i)}, {8, INPUT_DESC(j)}, + {9, INPUT_DESC(f)}, {10, INPUT_DESC(o)}, {11, INPUT_DESC(tanhct)}}; +ATTR_MAP(LSTMInputGrad) = EMPTY_ATTR_MAP; +OUTPUT_MAP(LSTMInputGrad) = { + {0, OUTPUT_DESC(dx)}, {1, OUTPUT_DESC(dh_prev)}, {2, OUTPUT_DESC(dc_prev)}, {4, OUTPUT_DESC(dgate)}}; +REG_ADPT_DESC(LSTMInputGrad, kNameLSTMInputGrad, ADPT_DESC(LSTMInputGrad)) + // DynamicRNN INPUT_MAP(DynamicRNN) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(w)}, {3, INPUT_DESC(b)}, {4, INPUT_DESC(seq_length)}, {5, INPUT_DESC(init_h)}, {6, INPUT_DESC(init_c)}, diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/rnn_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/rnn_declare.h index dc9f6c43d1..525725ff54 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/rnn_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/rnn_declare.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -35,6 +35,9 @@ DECLARE_OP_USE_OUTPUT(BasicLSTMCellWeightGrad) DECLARE_OP_ADAPTER(BasicLSTMCellCStateGrad) DECLARE_OP_USE_OUTPUT(BasicLSTMCellCStateGrad) +DECLARE_OP_ADAPTER(LSTMInputGrad) +DECLARE_OP_USE_OUTPUT(LSTMInputGrad) + DECLARE_OP_ADAPTER(DynamicRNN) DECLARE_OP_USE_OUTPUT(DynamicRNN) diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/selection_ops_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/selection_ops_declare.cc index 3e8aad8186..1702bd6829 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/selection_ops_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/selection_ops_declare.cc @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -52,6 +52,12 @@ ATTR_MAP(TopK) = {{"sorted", ATTR_DESC(sorted, AnyTraits())}}; OUTPUT_MAP(TopK) = {{0, OUTPUT_DESC(values)}, {1, OUTPUT_DESC(indices)}}; REG_ADPT_DESC(TopK, kNameTopK, ADPT_DESC(TopK)) +// InTopK +INPUT_MAP(InTopK) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}, {2, INPUT_DESC(k)}}; +ATTR_MAP(InTopK) = EMPTY_ATTR_MAP; +OUTPUT_MAP(InTopK) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(InTopK, kNameInTopK, ADPT_DESC(InTopK)) + // TileD INPUT_MAP(TileD) = {{1, INPUT_DESC(x)}}; INPUT_ATTR_MAP(TileD) = {{2, ATTR_DESC(multiples, AnyTraits(), AnyTraits>())}}; @@ -94,6 +100,27 @@ ATTR_MAP(RangeD) = {{"start", ATTR_DESC(start, AnyTraits())}, OUTPUT_MAP(RangeD) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(RangeD, kNameRange, ADPT_DESC(RangeD)) +// InplaceAddD +INPUT_MAP(InplaceAddD) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(v)}}; +INPUT_ATTR_MAP(InplaceAddD) = {{3, ATTR_DESC(indices, AnyTraits>())}}; +ATTR_MAP(InplaceAddD) = EMPTY_ATTR_MAP; +OUTPUT_MAP(InplaceAddD) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(InplaceAddD, kNameInplaceAddD, ADPT_DESC(InplaceAddD)) + +// InplaceSubD +INPUT_MAP(InplaceSubD) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(v)}}; +INPUT_ATTR_MAP(InplaceSubD) = {{3, ATTR_DESC(indices, AnyTraits>())}}; +ATTR_MAP(InplaceSubD) = EMPTY_ATTR_MAP; +OUTPUT_MAP(InplaceSubD) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(InplaceSubD, kNameInplaceSubD, ADPT_DESC(InplaceSubD)) + +// InplaceUpdateD +INPUT_MAP(InplaceUpdateD) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(v)}}; +INPUT_ATTR_MAP(InplaceUpdateD) = {{3, ATTR_DESC(indices, AnyTraits>())}}; +ATTR_MAP(InplaceUpdateD) = EMPTY_ATTR_MAP; +OUTPUT_MAP(InplaceUpdateD) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(InplaceUpdateD, kNameInplaceUpdateD, ADPT_DESC(InplaceUpdateD)) + // Select INPUT_MAP(Select) = {{1, INPUT_DESC(condition)}, {2, INPUT_DESC(x1)}, {3, INPUT_DESC(x2)}}; ATTR_MAP(Select) = EMPTY_ATTR_MAP; diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/selection_ops_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/selection_ops_declare.h index cd207c73f6..63496f7b1f 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/selection_ops_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/selection_ops_declare.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -37,6 +37,9 @@ DECLARE_OP_USE_OUTPUT(GatherNd) DECLARE_OP_ADAPTER(TopK) DECLARE_OP_USE_OUTPUT(TopK) +DECLARE_OP_ADAPTER(InTopK) +DECLARE_OP_USE_OUTPUT(InTopK) + DECLARE_OP_ADAPTER(Select) DECLARE_OP_USE_OUTPUT(Select) @@ -71,6 +74,18 @@ DECLARE_OP_USE_OUTPUT(GatherV2D) DECLARE_OP_ADAPTER(RangeD) DECLARE_OP_USE_OUTPUT(RangeD) +DECLARE_OP_ADAPTER(InplaceAddD) +DECLARE_OP_USE_INPUT_ATTR(InplaceAddD) +DECLARE_OP_USE_OUTPUT(InplaceAddD) + +DECLARE_OP_ADAPTER(InplaceSubD) +DECLARE_OP_USE_INPUT_ATTR(InplaceSubD) +DECLARE_OP_USE_OUTPUT(InplaceSubD) + +DECLARE_OP_ADAPTER(InplaceUpdateD) +DECLARE_OP_USE_INPUT_ATTR(InplaceUpdateD) +DECLARE_OP_USE_OUTPUT(InplaceUpdateD) + DECLARE_OP_ADAPTER(CumsumD) DECLARE_OP_USE_INPUT_ATTR(CumsumD) DECLARE_OP_USE_OUTPUT(CumsumD) diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/split_combination_ops_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/split_combination_ops_declare.cc index 8efe16bc28..375e7f15df 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/split_combination_ops_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/split_combination_ops_declare.cc @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,6 +15,7 @@ */ #include "transform/graph_ir/op_declare/split_combination_ops_declare.h" +#include namespace mindspore::transform { // SplitD @@ -31,6 +32,16 @@ ATTR_MAP(Pack) = {{"num", ATTR_DESC(N, AnyTraits())}, {"axis", ATTR_DES OUTPUT_MAP(Pack) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(Pack, prim::kStack, ADPT_DESC(Pack)) +// ParallelConcat +INPUT_MAP(ParallelConcat) = EMPTY_INPUT_MAP; +DYN_INPUT_MAP(ParallelConcat) = {{1, DYN_INPUT_DESC(values)}}; +ATTR_MAP(ParallelConcat) = { + {"shape", ATTR_DESC(shape, AnyTraits>())}, + {"N", ATTR_DESC(N, AnyTraits())}, +}; +OUTPUT_MAP(ParallelConcat) = {{0, OUTPUT_DESC(output_data)}}; +REG_ADPT_DESC(ParallelConcat, kNameParallelConcat, ADPT_DESC(ParallelConcat)) + // ConcatD INPUT_MAP(ConcatD) = EMPTY_INPUT_MAP; DYN_INPUT_MAP(ConcatD) = {{1, DYN_INPUT_DESC(x)}}; diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/split_combination_ops_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/split_combination_ops_declare.h index 79cad8093b..bf25d3866e 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/split_combination_ops_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/split_combination_ops_declare.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -30,6 +30,10 @@ DECLARE_OP_ADAPTER(ConcatD) DECLARE_OP_USE_DYN_INPUT(ConcatD) DECLARE_OP_USE_OUTPUT(ConcatD) +DECLARE_OP_ADAPTER(ParallelConcat) +DECLARE_OP_USE_DYN_INPUT(ParallelConcat) +DECLARE_OP_USE_OUTPUT(ParallelConcat) + DECLARE_OP_ADAPTER(Pack) DECLARE_OP_USE_DYN_INPUT(Pack) DECLARE_OP_USE_OUTPUT(Pack) diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/transformation_ops_declare.cc b/mindspore/ccsrc/transform/graph_ir/op_declare/transformation_ops_declare.cc index dbd757c871..d93dab2a88 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/transformation_ops_declare.cc +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/transformation_ops_declare.cc @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -74,4 +74,12 @@ ATTR_MAP(BatchToSpaceD) = { {"crops", ATTR_DESC(crops, AnyTraits>>(), AnyTraits>())}}; OUTPUT_MAP(BatchToSpaceD) = {{0, OUTPUT_DESC(y)}}; REG_ADPT_DESC(BatchToSpaceD, kNameBatchToSpace, ADPT_DESC(BatchToSpaceD)) + +// BatchToSpaceNDD +INPUT_MAP(BatchToSpaceNDD) = {{1, INPUT_DESC(x)}}; +ATTR_MAP(BatchToSpaceNDD) = { + {"block_shape", ATTR_DESC(block_shape, AnyTraits>())}, + {"crops", ATTR_DESC(crops, AnyTraits>>(), AnyTraits>())}}; +OUTPUT_MAP(BatchToSpaceNDD) = {{0, OUTPUT_DESC(y)}}; +REG_ADPT_DESC(BatchToSpaceNDD, kNameBatchToSpaceNd, ADPT_DESC(BatchToSpaceNDD)) } // namespace mindspore::transform diff --git a/mindspore/ccsrc/transform/graph_ir/op_declare/transformation_ops_declare.h b/mindspore/ccsrc/transform/graph_ir/op_declare/transformation_ops_declare.h index ea2571c425..0ec14ab1ac 100644 --- a/mindspore/ccsrc/transform/graph_ir/op_declare/transformation_ops_declare.h +++ b/mindspore/ccsrc/transform/graph_ir/op_declare/transformation_ops_declare.h @@ -1,5 +1,5 @@ /** - * Copyright 2019 Huawei Technologies Co., Ltd + * Copyright 2019-2021 Huawei Technologies Co., Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -46,5 +46,8 @@ DECLARE_OP_USE_OUTPUT(SpaceToBatchD) DECLARE_OP_ADAPTER(BatchToSpaceD) DECLARE_OP_USE_OUTPUT(BatchToSpaceD) + +DECLARE_OP_ADAPTER(BatchToSpaceNDD) +DECLARE_OP_USE_OUTPUT(BatchToSpaceNDD) } // namespace mindspore::transform #endif // MINDSPORE_CCSRC_TRANSFORM_GRAPH_IR_OP_DECLARE_TRANSFORMATION_OPS_DECLARE_H_