mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/operations/__init__.py

@@ -21,7 +21,7 @@ A collection of operators to build neural networks or to compute functions.
 
 from ._embedding_cache_ops import (CacheSwapTable, UpdateCache, MapCacheIdx, SubAndFilter,
                                    MapUniform, DynamicAssign, PadAndShift)
-from ._inner_ops import (MatmulDDS, DSDMatmul, Cummin, ExtractImagePatches)
+from ._inner_ops import (MatmulDDS, DSDMatmul, Cummin, ExtractImagePatches, SelectView, CopyWithSlice)
 from ._quant_ops import *
 from ._thor_ops import (CusBatchMatMul, CusCholeskyTrsm, CusFusedAbsMax1, CusImg2Col, CusMatMulCubeDenseLeft,
                         CusMatMulCubeFraczRightMul, CusMatMulCube, CusMatrixCombine, CusTranspose02314,
@@ -29,26 +29,27 @@ from ._thor_ops import (CusBatchMatMul, CusCholeskyTrsm, CusFusedAbsMax1, CusImg
                         LoadIm2Col, UpdateThorGradient, CholeskyTrsm,
                         DetTriangle, ProdForceSeA)
 from ._ms_kernel import (ms_kernel, kernel)
-from .array_ops import (ArgMaxWithValue, ArgMinWithValue, Argmax, Argmin, BatchToSpace, BatchToSpaceND,
+from .array_ops import (ArgMaxWithValue, ArgMinWithValue, Argmax, Argmin, BatchToSpace,
                         BatchToSpaceNDV2, BroadcastTo, Cast, Coalesce, Concat, Cummax, DType, DepthToSpace, Diag,
-                        DiagPart, DynamicShape, EditDistance, EmbeddingLookup, ExpandDims, ExtractVolumePatches,
-                        Eye, Fill, Gather, GatherD, GatherNd, GatherV2, Identity, Im2Col, InvertPermutation,
+                        DiagPart, EditDistance, EmbeddingLookup, ExpandDims, ExtractVolumePatches,
+                        Eye, Fill, Gather, GatherD, GatherNd, Identity, Im2Col, InvertPermutation,
                         LowerBound, Lstsq, MaskedFill, MaskedSelect, Meshgrid, Mvlgamma, Ones, OnesLike,
-                        Pack, Padding, ParallelConcat, PopulationCount, Range, Rank, Reshape, ResizeNearestNeighbor,
-                        ReverseSequence, ReverseV2, Rint, ScalarToArray, ScalarToTensor, ScatterAdd,
+                        Padding, ParallelConcat, PopulationCount, Range, Rank, Reshape, ResizeNearestNeighbor,
+                        ReverseSequence, ReverseV2, Rint, ScalarToTensor, ScatterAdd,
                         ScatterDiv, ScatterMax, ScatterMin, ScatterMul, ScatterNd, ScatterNdAdd, ScatterNdDiv,
-                        ScatterNdMax, ScatterNdMin, ScatterNdSub, ScatterNdUpdate, ScatterNonAliasingAdd, ScatterSub,
+                        ScatterNdMax, ScatterNdMin, ScatterNdSub, ScatterNdUpdate, ScatterSub,
                         ScatterUpdate, SearchSorted, Select, Shape, Size, Slice, Sort, SpaceToBatch, SpaceToBatchND,
                         SpaceToDepth, SparseGatherV2, Split, SplitV, Squeeze, Stack, StridedSlice, TensorScatterAdd,
                         TensorScatterDiv, TensorScatterMax, TensorScatterMin, TensorScatterMul, TensorScatterSub,
                         TensorScatterUpdate, TensorShape, Tile, TopK, TransShape, Transpose, TupleToArray, Unique,
-                        UniqueWithPad, Unpack, UnsortedSegmentMax, UnsortedSegmentMin, UnsortedSegmentProd,
+                        UniqueWithPad, UnsortedSegmentMax, UnsortedSegmentMin, UnsortedSegmentProd,
                         UnsortedSegmentSum, Unstack, UpperBound, Zeros, ZerosLike, AffineGrid, Bincount, CheckNumerics,
                         HammingWindow, IdentityN, IndexFill, LeftShift, ListDiff, LogSpace, MatrixBandPart,
                         MatrixDiagPartV3, MatrixDiagV3, MatrixSetDiagV3, NonZero, Expand, Col2Im, ConjugateTranspose,
                         FillDiagonal, Fills, ResizeNearestNeighborV2, RightShift, ScatterAddWithAxis,
                         ScatterNdMul, SegmentMean, SegmentProd, SegmentSum, SegmentMax, SegmentMin, Tril, Triu,
-                        UniqueConsecutive, UnravelIndex, FillV2, CountNonZero, TensorScatterElements)
+                        UniqueConsecutive, UnravelIndex, FillV2, CountNonZero, TensorScatterElements, IndexPut,
+                        MaskedScatter)
 from .comm_ops import (AllGather, AllReduce, NeighborExchange, NeighborExchangeV2, AlltoAll, _AllSwap, ReduceScatter,
                        Broadcast,
                        _MirrorOperator, _MirrorMiniStepOperator, _MiniStepAllGather, ReduceOp, _VirtualDataset,
@@ -68,7 +69,7 @@ from .inner_ops import (ScalarCast, Randperm, NoRepeatNGram, LambApplyOptimizerA
 from .linalg_ops import (Svd, Geqrf)
 from .math_ops import (Abs, ACos, Asin, Asinh, AddN, AccumulateNV2, AssignAdd, AssignSub, Atan2, BatchMatMul,
                        BitwiseAnd, BitwiseOr, Ger, BitwiseXor, Inv, Invert, ApproximateEqual,
-                       InplaceAdd, InplaceSub, InplaceUpdate, InplaceUpdateV2,
+                       InplaceAdd, InplaceSub, InplaceUpdateV2,
                        ReduceMax, ReduceMin, ReduceMean, ReduceSum, ReduceAll, ReduceProd, CumProd, Cdist, ReduceAny,
                        Cos, Cross, Div, DivNoNan, Equal, EqualCount, Exp, Expm1, Erf, Erfc, Floor, FloorDiv, FloorMod,
                        Ceil, Acosh, Greater, GreaterEqual, Lerp, Less, LessEqual, Log, Log1p, LogicalAnd, Mod,
@@ -78,7 +79,7 @@ from .math_ops import (Abs, ACos, Asin, Asinh, AddN, AccumulateNV2, AssignAdd, A
                        NPUGetFloatStatus, Pow, RealDiv, IsNan, IsInf, IsFinite, FloatStatus,
                        Reciprocal, CumSum, HistogramFixedWidth, SquaredDifference, Xdivy, Xlogy,
                        Sin, Sqrt, Rsqrt, BesselI0e, BesselI1e, TruncateDiv, TruncateMod, Addcdiv,
-                       Addcmul, Square, Sub, TensorAdd, Add, Sign, Round, SquareSumAll, Atan, Atanh, Cosh, Sinh, Eps,
+                       Addcmul, Square, Sub, Add, Sign, Round, SquareSumAll, Atan, Atanh, Cosh, Sinh, Eps,
                        Tan, MatrixInverse, IndexAdd, Erfinv, Conj, Real, Imag, Complex, Trunc, IsClose, LuSolve,
                        CholeskyInverse, BesselJ0, BesselJ1, BesselK0, BesselK0e, BesselK1, BesselK1e, BesselY0,
                        BesselY1, Bucketize, Cauchy, Cholesky, CholeskySolve, Betainc,
@@ -87,18 +88,18 @@ from .math_ops import (Abs, ACos, Asin, Asinh, AddN, AccumulateNV2, AssignAdd, A
                        NextAfter, Orgqr, Qr, RaggedRange, Digamma, Eig, EuclideanNorm, CompareAndBitpack, ComplexAbs,
                        CumulativeLogsumexp, Gcd, Polygamma, Trace, TridiagonalMatMul, TrilIndices, TriuIndices, Zeta,
                        Roll, Lgamma, Logit, MatrixSolveLs, Polar, Fmax, Fmin, Quantile, Sinc, Angle, Bernoulli,
-                       NanToNum, Igamma, BesselI0, BesselI1, InplaceIndexAdd, Igammac)
+                       NanToNum, Igamma, BesselI0, BesselI1, InplaceIndexAdd, Igammac, Ormqr)
 from .nn_ops import (LSTM, SGD, Adam, AdamWeightDecay, FusedSparseAdam, FusedSparseLazyAdam, AdamNoUpdateParam,
                      ApplyMomentum, BatchNorm, BiasAdd, Conv2D, Conv3D, Conv2DTranspose, Conv3DTranspose,
                      DepthwiseConv2dNative,
-                     DropoutDoMask, Dropout, Dropout2D, Dropout3D, DropoutGenMask, Flatten,
-                     InstanceNorm, BNTrainingReduce, BNTrainingUpdate,
-                     GeLU, Gelu, FastGeLU, FastGelu, Elu, CeLU,
+                     Dropout, Dropout2D, Dropout3D, Flatten,
+                     InstanceNorm,
+                     GeLU, FastGeLU, Elu, CeLU,
                      GetNext, L2Normalize, LayerNorm, L2Loss, CTCLoss, CTCLossV2, CTCLossV2Grad, CTCGreedyDecoder,
                      LogSoftmax, MaxPool3D, AvgPool3D,
                      MaxPool, DataFormatDimMap,
                      AvgPool, Conv2DBackpropInput, ComputeAccidentalHits,
-                     MaxPoolWithArgmax, MaxPoolWithArgmaxV2, OneHot, Pad, MirrorPad, Mish, PReLU, ReLU, ReLU6, ReLUV2,
+                     MaxPoolWithArgmaxV2, OneHot, Pad, MirrorPad, Mish, PReLU, ReLU, ReLU6, ReLUV2,
                      HSwish, HSigmoid,
                      ResizeBilinear, Sigmoid, SeLU, HShrink, ApplyKerasMomentum,
                      SigmoidCrossEntropyWithLogits, NLLLoss, BCEWithLogitsLoss,
@@ -111,23 +112,30 @@ from .nn_ops import (LSTM, SGD, Adam, AdamWeightDecay, FusedSparseAdam, FusedSpa
                      ApplyAdaMax, ApplyAdadelta, ApplyAdagrad, ApplyAdagradV2, MultiMarginLoss, ApplyAdagradDA,
                      ApplyAddSign, ApplyPowerSign, ApplyGradientDescent, ApplyProximalGradientDescent,
                      ApplyRMSProp, ApplyCenteredRMSProp, BasicLSTMCell, InTopK, AdaptiveAvgPool2D, SoftShrink,
-                     ApplyAdamWithAmsgrad, AdaptiveAvgPool3D, AdaptiveMaxPool2D, AdaptiveMaxPool3D,
+                     ApplyAdamWithAmsgrad, ApplyAdamWithAmsgradV2, AdaptiveAvgPool3D, AdaptiveMaxPool2D,
+                     AdaptiveMaxPool3D,
                      GridSampler3D, MaxPool3DWithArgmax, MaxUnpool2D, NuclearNorm, NthElement, MultilabelMarginLoss,
-                     Dilation2D, DataFormatVecPermute, DeformableOffsets, FractionalAvgPool,
+                     Dilation2D, DataFormatVecPermute, DeformableOffsets, Dense, FractionalAvgPool,
                      FractionalMaxPool, FractionalMaxPool3DWithFixedKsize, FractionalMaxPoolWithFixedKsize,
                      GridSampler2D, TripletMarginLoss, UpsampleNearest3D, UpsampleTrilinear3D, PadV3, ChannelShuffle,
                      GLU, MaxUnpool3D, Pdist)
 from .other_ops import (Assign, IOU, BoundingBoxDecode, BoundingBoxEncode,
                         ConfusionMatrix, UpdateState, Load, StopGradient,
-                        CheckValid, Partial, Depend, identity, Push, Pull, PyExecute, PyFunc, _DynamicLossScale,
+                        CheckValid, Partial, Depend, Push, Pull, PyExecute, PyFunc, _DynamicLossScale,
                         SampleDistortedBoundingBoxV2)
 from .random_ops import (RandomChoiceWithMask, StandardNormal, Gamma, RandomGamma, Poisson, UniformInt, UniformReal,
                          RandomCategorical, StandardLaplace, Multinomial, UniformCandidateSampler,
                          LogUniformCandidateSampler, TruncatedNormal, LogNormalReverse, NonDeterministicInts,
-                         ParameterizedTruncatedNormal, RandomPoisson, MultinomialWithReplacement, RandomShuffle)
+                         ParameterizedTruncatedNormal, RandomPoisson, MultinomialWithReplacement, RandomShuffle,
+                         RandpermV2)
 from .rl_ops import (BufferAppend, BufferGetItem, BufferSample)
-from .sparse_ops import (SparseToDense, SparseTensorDenseMatmul, SparseTensorDenseAdd, SparseSlice)
+from .sparse_ops import (
+    SparseToDense, SparseTensorDenseMatmul, SparseTensorDenseAdd, SparseSlice)
 from .spectral_ops import (BartlettWindow, BlackmanWindow)
+from ..deprecated import (identity, DropoutDoMask, MaxPoolWithArgmax,
+                          BNTrainingReduce, BNTrainingUpdate, DropoutGenMask, Gelu, FastGelu,
+                          TensorAdd, InplaceUpdate, ScatterNonAliasingAdd,
+                          BatchToSpaceND, Unpack, GatherV2, DynamicShape, ScalarToArray, Pack)
 
 __all__ = [
     'HSVToRGB',
@@ -450,6 +458,7 @@ __all__ = [
     "ApplyAdagradV2",
     "ApplyAdagradDA",
     "ApplyAdamWithAmsgrad",
+    "ApplyAdamWithAmsgradV2",
     "ApplyAddSign",
     "ApplyPowerSign",
     "ApplyGradientDescent",
@@ -612,7 +621,10 @@ __all__ = [
     "CumulativeLogsumexp",
     "DataFormatVecPermute",
     "DeformableOffsets",
+    "Dense",
     "ExtractImagePatches",
+    "SelectView",
+    "CopyWithSlice",
     "FillDiagonal",
     "Fills",
     "Gcd",
@@ -675,7 +687,11 @@ __all__ = [
     "InplaceIndexAdd",
     "Igammac",
     "MaxUnpool3D",
-    "Pdist"
+    "Pdist",
+    "IndexPut",
+    "MaskedScatter",
+    "Ormqr",
+    "RandpermV2"
 ]
 
 __custom__ = [

mindspore/ops/operations/_grad_ops.py

@@ -390,7 +390,7 @@ class Conv2DBackpropFilter(Primitive):
         stride (tuple): The stride to be applied to the convolution filter. Default: (1, 1).
         dilation (tuple): Specifies the dilation rate to be used for the dilated convolution. Default: (1, 1, 1, 1).
         group (int): Splits input into groups. Default: 1.
-        data_format (str) - The format of input and output data. It should be 'NHWC' or 'NCHW'，\
+        data_format (str) - The format of input and output data. It should be 'NHWC' or 'NCHW', \
             default is 'NCHW'.
 
     Returns:
@@ -636,7 +636,7 @@ class EinsumGrad(PrimitiveWithInfer):
 
     @prim_attr_register
     def __init__(self, equation):
-        self.add_prim_attr('equation', equation)
+        pass
 
     def infer_shape(self, x_shapes, dout_shape):
         out_shape = ()
@@ -1521,9 +1521,11 @@ class LSTMGrad(Primitive):
     """Computes the data and weight gradients of LSTM."""
 
     @prim_attr_register
-    def __init__(self, input_size, hidden_size, num_layers, has_bias, bidirectional, dropout):
+    def __init__(self, input_size, hidden_size, num_layers, has_bias, bidirectional, dropout, proj_size=0):
         self.input_size = validator.check_positive_int(input_size, 'input_size', self.name)
         self.hidden_size = validator.check_positive_int(hidden_size, 'hidden_size', self.name)
+        self.proj_size = validator.check_int_range(proj_size, 0, hidden_size, validator.INC_LEFT,
+                                                   'proj_size', self.name)
         self.num_layers = validator.check_positive_int(num_layers, 'num_layers', self.name)
         self.has_bias = validator.check_value_type('has_bias', has_bias, (bool,), self.name)
         self.bidirectional = validator.check_value_type('bidirectional', bidirectional, (bool,), self.name)
@@ -1660,10 +1662,11 @@ class DynamicGRUV2Grad(Primitive):
         keep_prob (float): A float identifying the keep prob in the op. Default: 1.0.
         cell_clip (float): A float identifying the cell clip in the op. Default: -1.0.
         num_proj (int): An integer identifying the num proj in the op. Default: 0.
-        time_major (bool): A bool identifying the time major in the op. Default: True.
+        time_major (bool): A bool identifying the time major in the op. Default: ``True``.
         gate_order (str): An string identifying the gate order in weight and bias. Default: 'rzh.
             'zrh' is another option.
-        reset_after (bool): An bool identifying whether to apply reset gate after matrix multiplication. Default: True.
+        reset_after (bool): An bool identifying whether to apply reset gate after matrix multiplication.
+            Default: ``True``.
 
     Inputs:
         - **x** (Tensor) - Current words. Tensor of shape :math:`(num\_step, batch\_size, input\_size)`.
@@ -1887,7 +1890,7 @@ class ResizeNearestNeighborGrad(Primitive):
 
     Args:
         align_corners (bool): Whether the centers of the 4 corner pixels of the input
-            and output tensors are aligned. Default: False.
+            and output tensors are aligned. Default: ``False``.
     """
 
     @prim_attr_register
@@ -1925,77 +1928,50 @@ class ResizeNearestNeighborV2Grad(Primitive):
 
     Args:
         align_corners (bool): Whether the centers of the 4 corner pixels of the input
-            and output tensors are aligned. Default: False.
-        half_pixel_centers (bool): Default: False.
-        data_format: An optional `string` that describes the format of the input `x` Defaults to `NHWC`.
+            and output tensors are aligned. Default: ``False``.
+        half_pixel_centers (bool): Default: ``False``.
     """
 
     @prim_attr_register
-    def __init__(self, align_corners=False, half_pixel_centers=False, data_format='NHWC'):
+    def __init__(self, align_corners=False, half_pixel_centers=False):
         """Initialize ResizeNearestNeighborV2Grad"""
         self.init_prim_io_names(inputs=['grads', 'size'], outputs=['y'])
-
         validator.check_value_type('align_corners', align_corners, [bool], self.name)
         validator.check_value_type('half_pixel_centers', half_pixel_centers, [bool], self.name)
-        validator.check_value_type('data_format', data_format, [str], self.name)
-        self.format = validator.check_string(data_format, ['NHWC', 'NCHW'], 'data_format', self.name)
-        self.add_prim_attr('data_format', self.format)
 
 
 class UpsampleNearest3DGrad(Primitive):
     """
     Upsample the 3-D gradient data  with the nearest neighbor interpolation algorithm.
 
-    Args:
-        input_size (listInt): An required listInt. contain 5 elements: [min_batch, channels, depth, height, width].
-            Must: input_size[0] == grad_output_tensor_size[0], input_size[1] == grad_output_tensor_size[1].
-        output_size (listInt): An optional listInt. Defaults to none.
-            contain 3 elements: depth, height, width. The number of elements of 'output_size' should
-            be the same as the rank of input 'grad_output'. Only one of 'scales' and 'output_size' can be specified.
-            Must: grad_output_tensor_size[2] == floor(input_size[2] * scales[0]) == output_size[0]
-            grad_output_tensor_size[3] == floor(input_size[3] * scales[1]) == output_size[1]
-            grad_output_tensor_size[4] == floor(input_size[4] * scales[2]) == output_size[2].
-        scales (listFloat): An optional listFloat. Defaults to none.
-            The scale array along each dimension, contain 3 elements: scale_depth, scale_height, scale_width.
-            The number of elements of 'scales' should be the same as the rank of input 'grad_output'.
-            One of 'scales' and 'output_size' MUST be specified and it is an error if both are specified.
+    Note:
+        Only one of 'scales' and 'output_size' can be specified, and it is an error if both are specified.
 
     Inputs:
-        - **grad_output** (Tensor) - Tensor of shape [N, C, D, H, W], Must be one of the following types:
-          float16, float32, float64.
+        - **dy** (Tensor) - Tensor of shape [N, C, D, H, W], Must be one of the following types:
+            float16, float32, float64.
+        - **input_size** (listInt): An required listInt, which contain 5 elements:
+            [min_batch, channels, depth, height, width].
+            Must: input_size[0] == dy_tensor_size[0], input_size[1] == dy_tensor_size[1].
+        - **output_size** (listInt): An optional listInt. Default: ``None``.
+            It contains 3 elements: depth, height, width, whose elements should be the same as `dy`.
+            Must:
+            dy_tensor_size[2] == floor(input_size[2] * scales[0]) == output_size[0],
+            dy_tensor_size[3] == floor(input_size[3] * scales[1]) == output_size[1],
+            dy_tensor_size[4] == floor(input_size[4] * scales[2]) == output_size[2].
+        - **scales** (listFloat): An optional listFloat. Default: ``None``.
+            The scale array along each dimension, contain 3 elements: scale_depth, scale_height, scale_width.
+            The number of elements of 'scales' should be the same as the rank of `dy`.
 
     Outputs:
-        Tensor, A 5-D tensor. Has the same type as input grad_output, shape depends on x and output_size/scales.
-
-    Raises:
-        TypeError: If `input_size` is not listInt.
-        TypeError: When `output_size` is not none and `output_size` is not listInt.
-        TypeError: When `scales` is not none and `scales` is not listFloat.
-        TypeError: If dtype of `x` is not int [float16, float32, float64].
-        ValueError: If any value of `input_size` is negative.
-        ValueError: If any value of `output_size` is negative.
-        ValueError: If any value of `scales` is negative.
-        ValueError: If shape of `x` is not 5D.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        - **dx**- (Tensor) - A 5-D tensor. Has the same type as `dy`, shape depends on `input_size`.
     """
     @prim_attr_register
-    def __init__(self, input_size, output_size=None, scales=None):
+    def __init__(self):
         """Initialize UpsampleNearest3DGrad."""
-        self.init_prim_io_names(inputs=['grad_output'], outputs=['y'])
-        validator.check_value_type("input_size", input_size, [list, tuple], self.name)
-        validator.check_positive_int_sequence(input_size, "input_size", self.name)
-        if output_size is not None:
-            validator.check_value_type("output_size", output_size, [list, tuple], self.name)
-            validator.check_positive_int_sequence(output_size, "output_size", self.name)
-        else:
-            self.add_prim_attr("output_size", [])
-        if scales is not None:
-            validator.check_value_type("scales", scales, [list, tuple], self.name)
-            validator.check_positive_float_sequence(scales, "scales", self.name)
-        else:
-            self.add_prim_attr("scales", [])
+        self.init_prim_io_names(
+            inputs=['dy', 'input_size', 'output_size', 'scales'],
+            outputs=['dx'])
 
 
 class ROIAlignGrad(Primitive):
@@ -2130,11 +2106,13 @@ class NLLLossGrad(PrimitiveWithInfer):
     """Computes the gradients of `NLLLoss`."""
 
     @prim_attr_register
-    def __init__(self, reduction="mean"):
+    def __init__(self, reduction="mean", ignore_index=-100):
         """Initialize NLLLoss"""
         self.init_prim_io_names(inputs=['x', 'loss_grad', 'target', 'weight', 'total_weight'], outputs=['x_grad'])
         self.reduction = validator.check_string(reduction, ['none', 'sum', 'mean'], 'reduction', self.name)
+        self.ignore_index = ignore_index
         self.add_prim_attr('reduction', self.reduction)
+        self.add_prim_attr('ignore_index', self.ignore_index)
 
 
 class SmoothL1LossGrad(Primitive):
@@ -2182,7 +2160,6 @@ class StridedSliceV2Grad(Primitive):
                  new_axis_mask=0,
                  shrink_axis_mask=0):
         """Initialize StridedSliceV2Grad"""
-        self.set_const_input_indexes([0])
         self.init_prim_io_names(inputs=['shapex', 'begin', 'end', 'strides', 'dy'], outputs=['output'])
 
 
@@ -2240,7 +2217,6 @@ class MirrorPadGrad(Primitive):
     @prim_attr_register
     def __init__(self, mode="REFLECT"):
         """Initialize MirrorPad"""
-        self.set_const_input_indexes([1])
         self.init_prim_io_names(inputs=['dy', 'paddings'], outputs=['output'])
         validator.check_string(mode, ['REFLECT', 'SYMMETRIC'], 'mode', self.name)
         self.mode = mode
@@ -2256,7 +2232,6 @@ class PadV3Grad(Primitive):
         self.init_prim_io_names(inputs=['x', 'paddings'], outputs=['y'])
         validator.check_string(mode, ['reflect', 'edge', 'circular'], 'mode', self.name)
         validator.check_bool(paddings_contiguous, "paddings_contiguous", self.name)
-        self.set_const_input_indexes([1])
         self.mode = mode
         self.paddings_contiguous = paddings_contiguous
 
@@ -2371,14 +2346,14 @@ class BasicLSTMCellCStateGrad(PrimitiveWithInfer):
         return (dgate_shape, dct_1_shape)
 
     def infer_dtype(self, c_dtype, dht_dtype, dct_dtype, it_dtype, jt_dtype, ft_dtype, ot_dtype, tanhct_dtype):
-        validator.check_subclass("c", c_dtype, [mstype.tensor], self.name)
-        validator.check_subclass("dht", dht_dtype, [mstype.tensor], self.name)
-        validator.check_subclass("dct", dct_dtype, [mstype.tensor], self.name)
-        validator.check_subclass("it", it_dtype, [mstype.tensor], self.name)
-        validator.check_subclass("jt", jt_dtype, [mstype.tensor], self.name)
-        validator.check_subclass("ft", ft_dtype, [mstype.tensor], self.name)
-        validator.check_subclass("ot", ot_dtype, [mstype.tensor], self.name)
-        validator.check_subclass("tanhct", tanhct_dtype, [mstype.tensor], self.name)
+        validator.check_subclass("c", c_dtype, [mstype.tensor_type], self.name)
+        validator.check_subclass("dht", dht_dtype, [mstype.tensor_type], self.name)
+        validator.check_subclass("dct", dct_dtype, [mstype.tensor_type], self.name)
+        validator.check_subclass("it", it_dtype, [mstype.tensor_type], self.name)
+        validator.check_subclass("jt", jt_dtype, [mstype.tensor_type], self.name)
+        validator.check_subclass("ft", ft_dtype, [mstype.tensor_type], self.name)
+        validator.check_subclass("ot", ot_dtype, [mstype.tensor_type], self.name)
+        validator.check_subclass("tanhct", tanhct_dtype, [mstype.tensor_type], self.name)
         validator.check_type_name("c", c_dtype, [mstype.float16, mstype.float32], self.name)
         validator.check_type_name("dht", dht_dtype, [mstype.float16, mstype.float32], self.name)
         validator.check_type_name("dct", dct_dtype, [mstype.float16, mstype.float32], self.name)
@@ -2411,9 +2386,9 @@ class BasicLSTMCellWeightGrad(PrimitiveWithInfer):
         return (dw_shape, db_shape)
 
     def infer_dtype(self, x_dtype, h_dtype, dgate_dtype):
-        validator.check_subclass("x", x_dtype, mstype.tensor, self.name)
-        validator.check_subclass("h", h_dtype, mstype.tensor, self.name)
-        validator.check_subclass("dgate", dgate_dtype, mstype.tensor, self.name)
+        validator.check_subclass("x", x_dtype, mstype.tensor_type, self.name)
+        validator.check_subclass("h", h_dtype, mstype.tensor_type, self.name)
+        validator.check_subclass("dgate", dgate_dtype, mstype.tensor_type, self.name)
         validator.check_type_name("x", x_dtype, [mstype.float16, mstype.float32], self.name)
         validator.check_type_name("h", h_dtype, [mstype.float16, mstype.float32], self.name)
         validator.check_type_name("dgate", dgate_dtype, [mstype.float16, mstype.float32], self.name)
@@ -2440,8 +2415,8 @@ class BasicLSTMCellInputGrad(PrimitiveWithInfer):
         return (dxt_shape, dht_shape)
 
     def infer_dtype(self, dgate_dtype, w_dtype):
-        validator.check_subclass("dgate", dgate_dtype, mstype.tensor, self.name)
-        validator.check_subclass("w", w_dtype, mstype.tensor, self.name)
+        validator.check_subclass("dgate", dgate_dtype, mstype.tensor_type, self.name)
+        validator.check_subclass("w", w_dtype, mstype.tensor_type, self.name)
         validator.check_type_name("dgate", dgate_dtype, [mstype.float16, mstype.float32], self.name)
         validator.check_type_name("w", w_dtype, [mstype.float16, mstype.float32], self.name)
         return (dgate_dtype, dgate_dtype)
@@ -2600,7 +2575,12 @@ class MultilabelMarginLossGrad(Primitive):
     Compute the gradients of MultilabelMarginLoss operation.
 
     Args:
-        reduction (str): Apply specific reduction method to the output: 'none', 'mean', 'sum'. Default: "mean".
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **y_grad** (Tensor) - The gradients of loss to output of MultilabelMarginLoss function, with
@@ -2622,7 +2602,7 @@ class MultilabelMarginLossGrad(Primitive):
         TypeError: If dtype of `y_grad` is not the same as `x`.
         ValueError: If length of shape of `x` is neither 1 nor 2.
         ValueError: If shape of `x` is not the same as `target`.
-        ValueError: If `reduction` is not one of 'none', 'mean', 'sum'.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
         ValueError: If shape of `y_grad` is not the same as forward output `y`.
 
     Supported Platforms:
@@ -2889,7 +2869,9 @@ class Dilation2DBackpropFilter(Primitive):
         self.pad_mode = validator.check_string(self.pad_mode, ["SAME", "VALID", 'same', "valid"], "pad_mode", self.name)
         self.add_prim_attr("pad_mode", self.pad_mode.upper())
         self.stride = _check_format_stride_or_dilation("stride", stride, self.name, self.data_format)
-        if self.stride[2] < 1 or self.stride[2] > 255 or self.stride[3] < 1 or self.stride[3] > 255:
+        def is_in_range(x):
+            return 1 <= x <= 255
+        if not is_in_range(self.stride[2]) or not is_in_range(self.stride[3]):
             raise ValueError(f"For '{self.name}', size of stride is not supported, "
                              f'stride should be in the range of [1, 255], '
                              f'but got stride_h: `{self.stride[2]}`, stride_w: `{self.stride[3]}`.')
@@ -2944,7 +2926,12 @@ class MultiMarginLossGrad(Primitive):
     Args:
         p (int): Optional. The norm degree for pairwise distance.Should be 1 or 2. Default: 1.
         margin (float): Optional. A parameter to change pairwise distance. Default: 1.0.
-        reduction (str): Apply specific reduction method to the output: 'none', 'mean', 'sum'. Default: "mean".
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the weighted mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Inputs:
         - **y_grad** (Tensor) - If it's not a scalar, the shape of 'y_grad' :math:`(N, C)`.
@@ -2953,7 +2940,7 @@ class MultiMarginLossGrad(Primitive):
         - **target** (Tensor) - Ground truth labels, with shape :math:`(N,)`. Data type only support int64. The
           value of target should be non-negative, less than C.
         - **weight** (Tensor, optional) - The rescaling weight to each class with shape :math:`(C,)`. Data type only
-          support float32, float16 or float64. Default: None.
+          support float32, float16 or float64. Default: ``None``.
 
     Outputs:
         The shape of output :math:`(N, C)`. Data type only support float32 or float16, float64.
@@ -2990,77 +2977,38 @@ class UpsampleTrilinear3DGrad(Primitive):
     r"""
     Upsample the 3-D gradient data with trilinear interpolation algorithm.
 
+    Note:
+        One of 'scales' and 'output_size' must be specified. And it is an error if both are specified.
+
     Args:
-        input_size (Union[tuple[int], list[int]]): An required listInt.
-            contain 5 elements: [batch, channels, depth, height, width]. Must:
-            input_size[0] == grad_output_tensor_size[0]
-            input_size[1] == grad_output_tensor_size[1].
-        output_size (Union[tuple[int], list[int]]): An optional listInt. Defaults to none.
-            contain 3 elements: depth, height, width. The number of elements of 'output_size' should
-            be the same as the rank of input 'grad_output'.
-            Only one of 'scales' and 'output_size' can be specified. Must:
-            grad_output_tensor_size[2] == floor(input_size[2] * scales[0]) == output_size[0]
-            grad_output_tensor_size[3] == floor(input_size[3] * scales[1]) == output_size[1]
-            grad_output_tensor_size[4] == floor(input_size[4] * scales[2]) == output_size[2].
-        scales (Union[tuple[float], list[float]]): An optional listFloat. Defaults to none.
-            The scale array along each dimension, contain 3 elements: scale_depth, scale_height, scale_width.
-            The number of elements of 'scales' should be the same as the rank of input 'grad_output'.
-            One of 'scales' and 'output_size' MUST be specified and it is an error if both are specified.
-        align_corners (bool): An optional bool. Defaults to false.
+        align_corners (bool): An optional bool. Default: ``False``.
 
     Inputs:
-        - **grad_output** (Tensor) - A 5-D input tensor [N, C, D, H, W].
-          Must be one of the following types: [float16, float32, float64].
+        - **dy** (Tensor) - Tensor of shape [N, C, D, H, W]. Must be one of the following types:
+          float16, float32, float64.
+        - **input_size** (Union[tuple[int], list[int]]): An required listInt which contains 5 elements:
+          [batch, channels, depth, height, width]. Must:
+          input_size[0] == dy_tensor_size[0]
+          input_size[1] == dy_tensor_size[1].
+        - **output_size** (Union[tuple[int], list[int]]): An optional listInt. Default: ``None``.
+          It contains 3 elements: depth, height, width, whose elements should be the same as `dy`. Must:
+          dy_tensor_size[2] == floor(input_size[2] * scales[0]) == output_size[0]
+          dy_tensor_size[3] == floor(input_size[3] * scales[1]) == output_size[1]
+          dy_tensor_size[4] == floor(input_size[4] * scales[2]) == output_size[2].
+        - **scales** (Union[tuple[float], list[float]]): An optional listFloat. Default: ``None``.
+          The scale array along each dimension, contain 3 elements: scale_depth, scale_height, scale_width.
+          The number of elements of 'scales' should be the same as the rank of input `dy`.
 
     Outputs:
-        backprops Tensor - A Tensor with shape depends on intput_size and output_size/scales.
-            Must be one of the following types: [float16, float32, float64].
-
-    Raises:
-        TypeError: If dtype of `x` is not int [float16, float32, float64].
-        TypeError: If `input_size` is not list[int] or tuple[int].
-        TypeError: When `output_size` is not none and `output_size` is not list[int] or tuple[int].
-        TypeError: When `scales` is not none and `scales` is not list[float] or tuple[float].
-        TypeError: If type of `align_corners` is not bool.
-        ValueError: If any value of `output_size` is negative or zero when `output_size` is not empty.
-        ValueError: If any value of `scales` is negative or zero when `scales` is not empty.
-        ValueError: If shape of `x` is not 5D.
-        ValueError: If none of `scales` and `output_size` is specified or both specified.
-        ValueError: If size of `scales` is not equal 3 when `scales` is specified.
-        ValueError: If size of `output_size` is not equal 3 when `output_size` is specified.
-        TypeError: If `input_size` is not Union[tuple[int], list[int]].
-        ValueError: If any value of `input_size` is negative.
-        ValueError: If elements number of `input_size` is not 5.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        - **dx** (Tensor) - A Tensor with shape depending on intput_size, and its' dtype is the same as `dy`.
     """
     @prim_attr_register
-    def __init__(self, input_size, output_size=None, scales=None, align_corners=False):
+    def __init__(self, align_corners=False):
         """Initialize UpsampleTrilinear3DGrad."""
-        self.init_prim_io_names(inputs=['grad_output'], outputs=['y'])
-        self.input_size = input_size
-        self.output_size = [] if output_size is None else output_size
-        self.scales = [] if scales is None else scales
+        self.init_prim_io_names(
+            inputs=['dy', 'input_size', 'output_size', 'scales'],
+            outputs=['dx'])
         self.align_corners = align_corners
-
-        validator.check_value_type("input_size", self.input_size, [list, tuple], self.name)
-        validator.check_equal_int(len(self.input_size), 5, "the dimension of input_size", self.name)
-        validator.check_value_type("output_size", self.output_size, [list, tuple], self.name)
-        validator.check_value_type("scales", self.scales, [list, tuple], self.name)
-        validator.check_bool(self.align_corners, self.name)
-        if len(self.output_size) == 3:
-            validator.check_positive_int_sequence(self.output_size, "output_size", self.name)
-        if len(self.scales) == 3:
-            validator.check_positive_float_sequence(self.scales, "scales", self.name)
-        if self.output_size == []:
-            validator.check_equal_int(len(self.scales), 3, 'size of scales', self.name)
-        if self.scales == []:
-            validator.check_equal_int(len(self.output_size), 3, 'size of output_size', self.name)
-
-        self.add_prim_attr('input_size', self.input_size)
-        self.add_prim_attr('output_size', self.output_size)
-        self.add_prim_attr('scales', self.scales)
         self.add_prim_attr('align_corners', self.align_corners)
 
 
@@ -3341,7 +3289,7 @@ class DeformableOffsetsGrad(Primitive):
         data_format (str): An optional string from:"NCHW", "NHWC".Specify the data format of the input x. Default:
             "NCHW".
         deformable_groups (int): Specify the C-axis grouping number of input x. Default: 1.
-        modulated (bool): Specify version of DeformableOffsetsGrad, true means v2, false means v1. Default: true.
+        modulated (bool): Specify version of DeformableOffsetsGrad, true means v2, false means v1. Default: ``True``.
 
     Inputs:
         - **grad** (Tensor) - The input grad tensor. With float16 or float32 data type.
@@ -3576,8 +3524,8 @@ class ResizeBicubicGrad(Primitive):
 
     Args:
         align_corners (bool):If true, the centers of the 4 corner pixels of the input
-    and output tensors are aligned, preserving the values at the corner pixels.Default: False.
-        half_pixel_centers (bool): An optional bool. Default: False.
+    and output tensors are aligned, preserving the values at the corner pixels.Default: ``False``.
+        half_pixel_centers (bool): An optional bool. Default: ``False``.
 
     Inputs:
         - **grads** (Tensor) - A Tensor of type float. 4-D with shape
@@ -3611,11 +3559,13 @@ class ResizeBicubicGrad(Primitive):
         original_image_shape = list(original_image['shape'])
         # get value
         if grads['value'] is None:
-            raise ValueError(f"For '{self.name}', the 'grads' cannot be None,\
-                            but got {grads['value']}.")
+            raise ValueError(
+                f"For '{self.name}', the 'grads' cannot be None, but got {grads['value']}."
+            )
         if original_image['value'] is None:
-            raise ValueError(f"For '{self.name}', the 'original_image' cannot be None,\
-                                but got {original_image['value']}.")
+            raise ValueError(
+                f"For '{self.name}', the 'original_image' cannot be None, but got {original_image['value']}."
+            )
         # get dtype
         grads_dtype = grads['dtype']
         original_image_dtype = original_image['dtype']
@@ -3737,7 +3687,7 @@ class AffineGridGrad(Primitive):
 
     Args:
         align_corners (bool): if True, consider -1 and 1 to refer to the centers
-            of the corner pixels rather than the image corners. Default: False.
+            of the corner pixels rather than the image corners. Default: ``False``.
 
     Inputs:
         - **y_grad** (Tensor) - Data type must be float16 or float32.
@@ -3867,3 +3817,49 @@ class ResizeV2Grad(Primitive):
                                ["align_corners", "half_pixel"], "coordinate_transformation_mode", self.name)
         validator.check_value_type("mode", mode, [str], self.name)
         validator.check_string(mode, ["nearest", "linear", "cubic"], "mode", self.name)
+
+
+class WKVGrad(Primitive):
+    r"""
+    Calculates the gradient of WKV operation.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize WKVGrad."""
+        self.init_prim_io_names(inputs=["time_first", "time_decay", "key", "value", "gy"],
+                                outputs=["gw", "gu", "gk", "gv"])
+
+
+class FlashAttentionScoreGrad(Primitive):
+    r"""
+    Calculates the gradient of FlashAttentionScore operation.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    @prim_attr_register
+    def __init__(self, head_num, keep_prob=1.0, scale_value=1.0, pre_tokens=65536, next_tokens=65536, inner_precise=1,
+                 input_layout='BSH'):
+        """Initialize FlashAttentionScoreGrad."""
+        validator.check_value_type('head_num', head_num, [int], self.name)
+        validator.check_value_type('keep_prob', keep_prob, [int, float], self.name)
+        validator.check_float(keep_prob, 0.0, validator.GE, "keep_prob", self.name)
+        validator.check_float(keep_prob, 1.0, validator.LE, "keep_prob", self.name)
+        validator.check_value_type('scale_value', scale_value, [float], self.name)
+        validator.check_value_type('pre_tokens', pre_tokens, [int], self.name)
+        validator.check_value_type('next_tokens', next_tokens, [int], self.name)
+        validator.check_value_type('inner_precise', inner_precise, [int], self.name)
+        if inner_precise not in [0, 1]:
+            raise ValueError(f"Attribute 'inner_precise' must be either 0 or 1, but got {inner_precise}")
+        validator.check_value_type('input_layout', input_layout, [str], self.name)
+        if input_layout not in ["BSH"]:
+            raise ValueError(f"Attribute 'input_layout' must be either 'bsh' or 'sbh', but got {input_layout}")
+        self.init_prim_io_names(inputs=['query', 'key', 'value', 'attn_mask', 'attention_in', 'softmax_max',
+                                        'softmax_sum', 'dy', 'drop_mask', 'real_shift', "padding_mask", 'softmax_out'],
+                                outputs=['dq', 'dk', 'dv'])