!14700 [GPU] index_add op indices tensor must be 1D and add adapter of Mod, MaxPool3D and BCEWithLogitsLoss operators for graphengine and fix the backword of matrixinverse.

From: @wangshuide2020
Reviewed-by: @liangchenghui,@oacjiewen
Signed-off-by: @liangchenghui

mindspore/ccsrc/transform/graph_ir/op_adapter_map.h

@@ -58,6 +58,8 @@ constexpr const char kNameEqual[] = "Equal";
 constexpr const char kNameNotEqual[] = "NotEqual";
 constexpr const char kNameFlattenGrad[] = "FlattenGrad";
 constexpr const char kNameConvolution[] = "Convolution";
+constexpr const char kNameMaxPool3D[] = "MaxPool3D";
+constexpr const char kNameMaxPool3DGrad[] = "MaxPool3DGrad";
 constexpr const char kNameBiasAdd[] = "BiasAdd";
 constexpr const char kNameMaxPoolGrad[] = "MaxPoolGrad";
 constexpr const char kNameRsqrtGrad[] = "RsqrtGrad";
@@ -101,6 +103,7 @@ constexpr const char kNameSmoothL1LossGrad[] = "SmoothL1LossGrad";
 constexpr const char kNameSGD[] = "SGD";
 constexpr const char kNameSigmoidCrossEntropyWithLogits[] = "SigmoidCrossEntropyWithLogits";
 constexpr const char kNameSigmoidCrossEntropyWithLogitsGrad[] = "SigmoidCrossEntropyWithLogitsGrad";
+constexpr const char kNameSigmoidCrossEntropyWithLogitsV2[] = "BCEWithLogitsLoss";
 constexpr const char kNameScatterNdD[] = "ScatterNd";
 constexpr const char kNamePadD[] = "Pad";
 constexpr const char kNameMirrorPad[] = "MirrorPad";
@@ -132,6 +135,7 @@ constexpr const char kNameBitwiseXor[] = "BitwiseXor";
 constexpr const char kNameCeil[] = "Ceil";
 constexpr const char kNameCosineEmbeddingLoss[] = "CosineEmbeddingLoss";
 constexpr const char kNameXdivy[] = "Xdivy";
+constexpr const char kNameMod[] = "Mod";
 constexpr const char kNameTile[] = "Tile";
 constexpr const char kNameCos[] = "Cos";
 constexpr const char kNameCosh[] = "Cosh";

mindspore/ccsrc/transform/graph_ir/op_declare/elewise_calculation_ops_declare.cc

@@ -185,6 +185,12 @@ ATTR_MAP(Xdivy) = EMPTY_ATTR_MAP;
 OUTPUT_MAP(Xdivy) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(Xdivy, kNameXdivy, ADPT_DESC(Xdivy))
 
+// Mod
+INPUT_MAP(Mod) = {{1, INPUT_DESC(x1)}, {2, INPUT_DESC(x2)}};
+ATTR_MAP(Mod) = EMPTY_ATTR_MAP;
+OUTPUT_MAP(Mod) = {{0, OUTPUT_DESC(y)}};
+REG_ADPT_DESC(Mod, kNameMod, ADPT_DESC(Mod))
+
 // Exp
 INPUT_MAP(Exp) = {{1, INPUT_DESC(x)}};
 ATTR_MAP(Exp) = EMPTY_ATTR_MAP;

mindspore/ccsrc/transform/graph_ir/op_declare/elewise_calculation_ops_declare.h

@@ -105,6 +105,9 @@ DECLARE_OP_USE_OUTPUT(CosineEmbeddingLoss)
 DECLARE_OP_ADAPTER(Xdivy)
 DECLARE_OP_USE_OUTPUT(Xdivy)
 
+DECLARE_OP_ADAPTER(Mod)
+DECLARE_OP_USE_OUTPUT(Mod)
+
 DECLARE_OP_ADAPTER(Cast)
 DECLARE_OP_USE_INPUT_ATTR(Cast)
 DECLARE_OP_USE_OUTPUT(Cast)

mindspore/ccsrc/transform/graph_ir/op_declare/nn_norm_ops_declare.cc

@@ -66,6 +66,14 @@ OUTPUT_MAP(SigmoidCrossEntropyWithLogitsGrad) = {{0, OUTPUT_DESC(gradient)}};
 REG_ADPT_DESC(SigmoidCrossEntropyWithLogitsGrad, kNameSigmoidCrossEntropyWithLogitsGrad,
               ADPT_DESC(SigmoidCrossEntropyWithLogitsGrad))
 
+// SigmoidCrossEntropyWithLogitsV2
+INPUT_MAP(SigmoidCrossEntropyWithLogitsV2) = {
+  {1, INPUT_DESC(predict)}, {2, INPUT_DESC(target)}, {3, INPUT_DESC(weight)}, {4, INPUT_DESC(pos_weight)}};
+ATTR_MAP(SigmoidCrossEntropyWithLogitsV2) = {{"reduction", ATTR_DESC(reduction, AnyTraits<std::string>())}};
+OUTPUT_MAP(SigmoidCrossEntropyWithLogitsV2) = {{0, OUTPUT_DESC(loss)}};
+REG_ADPT_DESC(SigmoidCrossEntropyWithLogitsV2, kNameSigmoidCrossEntropyWithLogitsV2,
+              ADPT_DESC(SigmoidCrossEntropyWithLogitsV2))
+
 // LogSoftmaxGrad
 INPUT_MAP(LogSoftmaxGrad) = {{1, INPUT_DESC(x)}, {2, INPUT_DESC(grad)}};
 ATTR_MAP(LogSoftmaxGrad) = {

mindspore/ccsrc/transform/graph_ir/op_declare/nn_norm_ops_declare.h

@@ -35,6 +35,9 @@ DECLARE_OP_USE_OUTPUT(SigmoidCrossEntropyWithLogits)
 DECLARE_OP_ADAPTER(SigmoidCrossEntropyWithLogitsGrad)
 DECLARE_OP_USE_OUTPUT(SigmoidCrossEntropyWithLogitsGrad)
 
+DECLARE_OP_ADAPTER(SigmoidCrossEntropyWithLogitsV2)
+DECLARE_OP_USE_OUTPUT(SigmoidCrossEntropyWithLogitsV2)
+
 DECLARE_OP_ADAPTER(LogSoftmaxGrad)
 DECLARE_OP_USE_OUTPUT(LogSoftmaxGrad)
 

mindspore/ccsrc/transform/graph_ir/op_declare/nn_pooling_ops_declare.cc

@@ -27,6 +27,27 @@ ATTR_MAP(MaxPool) = {{"kernel_size", ATTR_DESC(ksize, AnyTraits<int64_t>(), AnyT
 OUTPUT_MAP(MaxPool) = {{0, OUTPUT_DESC(y)}};
 REG_ADPT_DESC(MaxPool, kNameMaxPool, ADPT_DESC(MaxPool))
 
+// MaxPool3D
+INPUT_MAP(MaxPool3D) = {{1, INPUT_DESC(x)}};
+ATTR_MAP(MaxPool3D) = {{"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>())},
+                       {"pad_list", ATTR_DESC(pads, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+                       {"dilation", ATTR_DESC(dilation, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},
+                       {"ceil_mode", ATTR_DESC(ceil_mode, AnyTraits<int64_t>())},
+                       {"format", ATTR_DESC(data_format, AnyTraits<std::string>())}};
+OUTPUT_MAP(MaxPool3D) = {{0, OUTPUT_DESC(y)}};
+REG_ADPT_DESC(MaxPool3D, kNameMaxPool3D, ADPT_DESC(MaxPool3D))
+
+// MaxPool3DGrad
+INPUT_MAP(MaxPool3DGrad) = {{1, INPUT_DESC(orig_x)}, {2, INPUT_DESC(orig_y)}, {3, INPUT_DESC(grads)}};
+ATTR_MAP(MaxPool3DGrad) = {{"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(MaxPool3DGrad) = {{0, OUTPUT_DESC(y)}};
+REG_ADPT_DESC(MaxPool3DGrad, kNameMaxPool3DGrad, ADPT_DESC(MaxPool3DGrad))
+
 // AvgPool
 INPUT_MAP(AvgPool) = {{1, INPUT_DESC(x)}};
 ATTR_MAP(AvgPool) = {{"kernel_size", ATTR_DESC(ksize, AnyTraits<int64_t>(), AnyTraits<std::vector<int64_t>>())},

mindspore/ccsrc/transform/graph_ir/op_declare/nn_pooling_ops_declare.h

@@ -35,6 +35,12 @@ DECLARE_OP_USE_OUTPUT(MaxPool)
 DECLARE_OP_ADAPTER(MaxPoolGrad)
 DECLARE_OP_USE_OUTPUT(MaxPoolGrad)
 
+DECLARE_OP_ADAPTER(MaxPool3D)
+DECLARE_OP_USE_OUTPUT(MaxPool3D)
+
+DECLARE_OP_ADAPTER(MaxPool3DGrad)
+DECLARE_OP_USE_OUTPUT(MaxPool3DGrad)
+
 DECLARE_OP_ADAPTER(AvgPool)
 DECLARE_OP_USE_OUTPUT(AvgPool)
 

mindspore/ops/_grad/grad_math_ops.py

@@ -18,6 +18,7 @@
 from functools import reduce
 import numpy as np
 import mindspore as ms
+from mindspore import nn
 from mindspore.ops import _selected_grad_ops as SG
 from .. import functional as F
 from .. import operations as P
@@ -178,15 +179,15 @@ def get_bprop_tensor_add(self):
 @bprop_getters.register(P.MatrixInverse)
 def get_bprop_matrix_inverse(self):
     """Grad definition for `MatrixInverse` operation."""
-    batchmatmul_a = P.math_ops.BatchMatMul(transpose_a=True)
-    batchmatmul_b = P.math_ops.BatchMatMul(transpose_b=True)
+    matmul_x1 = nn.MatMul(transpose_x1=True)
+    matmul_x2 = nn.MatMul(transpose_x2=True)
     neg = P.Neg()
 
     def bprop(x, out, dout):
-        dx = batchmatmul_b(dout, out)
-        dx = batchmatmul_a(out, dx)
+        dx = matmul_x2(dout, out)
+        dx = matmul_x1(out, dx)
         dx = neg(dx)
-        return dx
+        return (dx,)
 
     return bprop
 

mindspore/ops/operations/math_ops.py

@@ -4616,6 +4616,7 @@ class IndexAdd(PrimitiveWithInfer):
         validator.check("x rank", len(x_shape), "y rank", len(y_shape), Rel.EQ, self.name)
         x_rank = len(x_shape)
         validator.check_int_range(self.axis, -x_rank - 1, x_rank, Rel.INC_NEITHER, 'axis', self.name)
+        validator.check_equal_int(len(idx_shape), 1, "rank of idx_shape", self.name)
         validator.check("size of indices", idx_shape[0], "dimension of y[axis]", y_shape[self.axis],
                         Rel.EQ, self.name)
         axis = self.axis if self.axis >= 0 else x_rank + self.axis