add adapter of Erf, Expm1, Inv, etc. for graphengine.

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";

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<std::string>())}};
@@ -243,6 +255,42 @@ ATTR_MAP(ArgMinWithValue) = {{"axis", ATTR_DESC(dimension, AnyTraits<int64_t>())
 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;

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)
 

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<std::string>())}};
 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

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_

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<bool>()
 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<bool>())},
+                    {"transpose_x2", ATTR_DESC(transpose_x2, AnyTraits<bool>())}};
+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<bool>())},
@@ -48,6 +55,24 @@ ATTR_MAP(MatMulV2) = {{"transpose_a", ATTR_DESC(transpose_x1, AnyTraits<bool>())
 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;

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)
 

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<int64_t>())},
+                 {"bias", ATTR_DESC(bias, AnyTraits<float>())},
+                 {"alpha", ATTR_DESC(alpha, AnyTraits<float>())},
+                 {"beta", ATTR_DESC(beta, AnyTraits<float>())},
+                 {"norm_region", ATTR_DESC(norm_region, AnyTraits<string>())}};
+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<int64_t>())},
+                     {"bias", ATTR_DESC(bias, AnyTraits<float>())},
+                     {"alpha", ATTR_DESC(alpha, AnyTraits<float>())},
+                     {"beta", ATTR_DESC(beta, AnyTraits<float>())}};
+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;

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)
 

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<int64_t>()
 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<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+  {"strides", ATTR_DESC(strides, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+  {"pad_list", ATTR_DESC(pads, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+  {"format", ATTR_DESC(data_format, AnyTraits<std::string>())}};
+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<int64_t>(), AnyTraits<std::vector<int64_t>>())},
@@ -66,6 +76,15 @@ ATTR_MAP(MaxPoolGrad) = {{"kernel_size", ATTR_DESC(ksize, AnyTraits<int64_t>(),
 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<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+                             {"strides", ATTR_DESC(strides, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+                             {"pad_mode", ATTR_DESC(padding, AnyTraits<std::string>())},
+                             {"format", ATTR_DESC(data_format, AnyTraits<std::string>())}};
+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<int64_t>(), AnyTraits<std::vector<int64_t>>())},
@@ -92,4 +111,13 @@ ATTR_MAP(MaxPoolGradWithArgmax) = {
   {"pad_mode", ATTR_DESC(padding, AnyTraits<std::string>())}};
 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<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+  {"strides", ATTR_DESC(strides, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+  {"pad_mode", ATTR_DESC(padding, AnyTraits<std::string>())}};
+OUTPUT_MAP(MaxPoolGradGradWithArgmax) = {{0, OUTPUT_DESC(y)}};
+REG_ADPT_DESC(MaxPoolGradGradWithArgmax, kNameMaxPoolGradGradWithArgmax, ADPT_DESC(MaxPoolGradGradWithArgmax))
 }  // namespace mindspore::transform

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)
 

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;

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)
 

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<std::vector<int64_t>>())}};
+OUTPUT_MAP(FillD) = {{0, OUTPUT_DESC(y)}};
+REG_ADPT_DESC(FillD, kNameFillD, ADPT_DESC(FillD))
 }  // namespace mindspore::transform

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_

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<int64_t>())},
 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<int64_t>())},

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)
 

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 <vector>
 
 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<float>())}};
+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<float>())},
+                              {"epsilon", ATTR_DESC(epsilon, AnyTraits<float>())}};
+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<float>())}};
+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<std::vector<int64_t>>(), AnyTraits<std::vector<int64_t>>())}};
+ATTR_MAP(ReduceAnyD) = {{"keep_dims", ATTR_DESC(keep_dims, AnyTraits<bool>())}};
+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) = {

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)

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)},

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)
 

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<bool>())}};
 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<int64_t>(), AnyTraits<std::vector<int64_t>>())}};
@@ -94,6 +100,27 @@ ATTR_MAP(RangeD) = {{"start", ATTR_DESC(start, AnyTraits<float>())},
 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<std::vector<int64_t>>())}};
+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<std::vector<int64_t>>())}};
+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<std::vector<int64_t>>())}};
+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;

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)

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 <vector>
 
 namespace mindspore::transform {
 // SplitD
@@ -31,6 +32,16 @@ ATTR_MAP(Pack) = {{"num", ATTR_DESC(N, AnyTraits<int64_t>())}, {"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<std::vector<int64_t>>())},
+  {"N", ATTR_DESC(N, AnyTraits<int64_t>())},
+};
+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)}};

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)

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<std::vector<std::vector<int64_t>>>(), AnyTraits<std::vector<int64_t>>())}};
 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<std::vector<int64_t>>())},
+  {"crops", ATTR_DESC(crops, AnyTraits<std::vector<std::vector<int64_t>>>(), AnyTraits<std::vector<int64_t>>())}};
+OUTPUT_MAP(BatchToSpaceNDD) = {{0, OUTPUT_DESC(y)}};
+REG_ADPT_DESC(BatchToSpaceNDD, kNameBatchToSpaceNd, ADPT_DESC(BatchToSpaceNDD))
 }  // namespace mindspore::transform

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_