mindspore 2.3.0__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/ops/operations/_grad_ops.py

@@ -35,8 +35,8 @@ from ..auto_generate import (AbsGrad, ACosGrad, LogitGrad, AcoshGrad, AsinGrad,
                              SigmoidGrad, HSwishGrad, NLLLossGrad, AtanGrad, GridSampler3DGrad, GridSampler2DGrad,
                              ResizeBicubicGrad, HSigmoidGrad, CholeskyGrad, ResizeNearestNeighborGrad, LayerNormGrad,
                              HShrinkGrad, LayerNormGradGrad, SiLUGrad, MaximumGrad, MaximumGradGrad, RmsNormGrad,
-                             FlashAttentionScoreGrad, UpsampleTrilinear3DGrad, UpsampleNearest3DGrad,
-                             BinaryCrossEntropyGrad)
+                             FlashAttentionScoreGrad, UpsampleTrilinear3DGrad, UpsampleNearest3DGrad, MaskedSelectGrad,
+                             BinaryCrossEntropyGrad, SoftShrinkGrad, SeluGrad)
 
 
 class SparseFillEmptyRowsGrad(Primitive):
@@ -1658,35 +1658,6 @@ class SoftMarginLossGrad(Primitive):
         self.reduction = validator.check_string(reduction, ['none', 'sum', 'mean'], 'reduction', self.name)
 
 
-class StridedSliceV2Grad(Primitive):
-    """
-    Performs grad of StridedSliceV2 operation.
-
-    Inputs:
-        - **shapex** (Tensor) - StridedSliceV2 shape of input
-        - **begin** (tuple[int]) - A tuple which represents the location where to start. Only
-          constant value is allowed.
-        - **end** (tuple[int]) - A tuple or which represents the maximum location where to end.
-          Only constant value is allowed.
-        - **strides** (tuple[int]) - A tuple which represents the stride is continuously added
-          before reaching the maximum location. Only constant value is allowed.
-        - **dy** (Tensor) - The output of StridedSliceV2
-
-    Outputs:
-        Tensor, the shape same as the input of StridedSliceV2
-    """
-
-    @prim_attr_register
-    def __init__(self,
-                 begin_mask=0,
-                 end_mask=0,
-                 ellipsis_mask=0,
-                 new_axis_mask=0,
-                 shrink_axis_mask=0):
-        """Initialize StridedSliceV2Grad"""
-        self.init_prim_io_names(inputs=['shapex', 'begin', 'end', 'strides', 'dy'], outputs=['output'])
-
-
 class StridedSliceGrad(Primitive):
     """
     Performs grad of StridedSlice operation.
@@ -1991,51 +1962,6 @@ class MvlgammaGrad(Primitive):
         self.p = validator.check_value_type('p', p, [int], self.name)
 
 
-class MaskedSelectGrad(PrimitiveWithInfer):
-    """Computes gradient for MaskedSelect."""
-
-    @prim_attr_register
-    def __init__(self):
-        pass
-
-    def infer_shape(self, x, mask, grad):
-        return x
-
-    def infer_dtype(self, x, mask, grad):
-        return x
-
-
-class SoftShrinkGrad(Primitive):
-    r"""
-          Gradients for SoftShrink operation.
-
-          Args:
-              lambd – The \lambdaλ (must be no less than zero) value for the Softshrink formulation. Default: 0.5.
-
-          Inputs:
-              - **input_grad** (Tensor) - The input gradient.
-              - **input_x** (Tensor) - The input of SoftShrink with data type of float16 or float32.
-                Any number of additional dimensions.
-
-          Outputs:
-              output - Tensor, has the same shape and data type as input_x.
-
-          Raises:
-              TypeError: If lambd is not a float.
-              TypeError: If dtype of input_x is neither float16 nor float32.
-              ValueError: If lambd is less than to 0.
-
-          Supported Platforms:
-              ``Ascend``
-      """
-
-    @prim_attr_register
-    def __init__(self, lambd=0.5):
-        self.init_prim_io_names(inputs=['input_grad', 'input_x'], outputs=['output'])
-        validator.check_value_type("lambd", lambd, [float], self.name)
-        validator.check_number("lambd", lambd, 0, validator.GE, self.name)
-
-
 class CdistGrad(Primitive):
     """Computes gradient for Cdist."""
 

mindspore/ops/operations/_infer_ops.py

@@ -16,4 +16,4 @@
 """Operator of infer net"""
 # pylint: disable=unused-import
 from ..auto_generate import (QuantV2, DynamicQuantExt, QuantBatchMatmul, WeightQuantBatchMatmul, KVCacheScatterUpdate,
-                             FusedInferAttentionScore, GroupedMatmul, MoeFinalizeRouting)
+                             FusedInferAttentionScore, GroupedMatmul, MoeFinalizeRouting, QuantLinearSparse)

mindspore/ops/operations/_inner_ops.py

@@ -17,6 +17,7 @@
 from types import FunctionType, MethodType
 from collections.abc import Iterable
 import os
+import weakref
 import numpy as np
 
 from mindspore.common import Tensor
@@ -29,7 +30,7 @@ from mindspore.ops.operations.math_ops import _infer_shape_reduce
 from mindspore.ops.primitive import PrimitiveWithCheck, PrimitiveWithInfer, prim_attr_register, Primitive, \
     _run_op, _check_contains_variable
 from mindspore._c_expression import Tensor as Tensor_
-from mindspore._c_expression import typing
+from mindspore._c_expression import typing, HookType
 from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.common.parameter import Parameter
@@ -1535,7 +1536,7 @@ class CellBackwardHook(PrimitiveWithInfer):
         ...     print(grad)
         ...
         >>> hook = inner.CellBackwardHook()
-        >>> hook_fn_key = hook.register_backward_hook(hook_fn)
+        >>> hook_fn_key = hook.register_backward_hook()
         >>> def hook_test(x, y):
         ...     z = x * y
         ...     z = hook(z)
@@ -1556,16 +1557,19 @@ class CellBackwardHook(PrimitiveWithInfer):
         (Tensor(shape=[], dtype=Float32, value= 4), Tensor(shape=[], dtype=Float32, value= 4))
     """
 
-    def __init__(self, cell_id=""):
+    def __init__(self, cell_id="", cell=None, hook_dict=None):
         """Initialize CellBackwardHook"""
         super(CellBackwardHook, self).__init__(self.__class__.__name__)
         self.cell_id = cell_id
+        self.cell = cell
+        self.hook_dict = weakref.ref(hook_dict)
         self.add_prim_attr("cell_id", cell_id)
-        self.init_attrs["cell_id"] = cell_id
+        self.grad_output = None
 
-    def __call__(self, args):
-        if not isinstance(args, tuple):
-            args = (args,)
+    def __call__(self, *args):
+        # If args is empty, just return.
+        if not args:
+            return args
         return _run_op(self, self.name, args)
 
     def infer_shape(self, *inputs_shape):
@@ -1578,51 +1582,76 @@ class CellBackwardHook(PrimitiveWithInfer):
             return inputs_type[0]
         return inputs_type
 
-    def register_backward_hook(self, hook_fn):
-        r"""
-        This function is used to register backward hook function. Note that this function is only supported in pynative
-        mode.
-
-        Note:
-            The 'hook_fn' must be defined as the following code.
-            `cell_id` is the information of registered cell. `grad_input` is the gradient passed to the cell.
-            `grad_output` is the gradient computed and passed to the next cell or primitive, which may be modified by
-            returning a new output gradient.
-            The 'hook_fn' should have the following signature:
-            hook_fn(cell_id, grad_input, grad_output) -> New output gradient or none.
-            The 'hook_fn' is executed in the python environment.
+    def register_backward_hook(self):
+        """
+        Register the backward hook function.
 
         Args:
-            hook_fn (Function): Python function. Backward hook function.
+            None
 
         Returns:
-            - **key** (int) - The key of 'hook_fn'.
+            None
 
-        Raises:
-            TypeError: If the `hook_fn` is not a function of python.
+        Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
         """
-        if not isinstance(hook_fn, (FunctionType, MethodType)):
-            raise TypeError(f"When using 'register_backward_hook(hook_fn)', the type of 'hook_fn' must be python "
-                            f"function, but got {type(hook_fn)}.")
-        key = self.add_backward_hook_fn(hook_fn)
-        return key
 
-    def remove_backward_hook(self, key):
-        r"""
-        This function is used to remove backward hook function. Note that this operation is only supported in pynative
-        mode.
-
-        Note:
-            The 'key' is the object returned by 'register_backward_hook' function of the same CellBackwardHook
-            operator.
+        def hook_backward_grad(grad):
+            if self.grad_output is None:
+                self.grad_output = grad
+                # Indicates the first time of call backward hook, and need to wait for the second time call
+                return self.cell_id
+            backward_hook_grad_input = grad
+            if self.hook_dict():
+                backward_hooks = self.hook_dict().values()
+                for hook in backward_hooks:
+                    res = hook(self.cell, backward_hook_grad_input, self.grad_output)
+                    if res is None:
+                        continue
+                    if not isinstance(res, tuple):
+                        res = (res,)
+                    if len(res) != len(grad):
+                        raise TypeError(
+                            "The backward hook return value size is {} not equal to expect grad input size {}".format(
+                                len(res), len(grad)))
+                    backward_hook_grad_input = res
+            self.grad_output = None
+            return backward_hook_grad_input
+
+        self.set_hook_fn(hook_backward_grad, HookType.BackwardHook)
+
+    def register_backward_pre_hook(self):
+        """
+        Register the backward pre hook function.
 
         Args:
-            key (int): The key corresponding to the 'hook_fn'.
+            None
 
         Returns:
-            None.
+            None
+
+        Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
         """
-        self.remove_backward_hook_fn(key)
+
+        def hook_backward_pre_grad(grad):
+            backward_pre_hook_grad = grad
+            if self.hook_dict():
+                backward_pre_hooks = self.hook_dict().values()
+                for hook in backward_pre_hooks:
+                    res = hook(self.cell, backward_pre_hook_grad)
+                    if res is None:
+                        continue
+                    if not isinstance(res, tuple):
+                        res = (res,)
+                    if len(res) != len(grad):
+                        raise TypeError(
+                            "The backward pre hook return value size is {} not equal to expect output size {}".format(
+                                len(res), len(grad)))
+                    backward_pre_hook_grad = res
+            return backward_pre_hook_grad
+
+        self.set_hook_fn(hook_backward_pre_grad, HookType.BackwardPreHook)
 
 
 class Format(PrimitiveWithInfer):
@@ -2478,60 +2507,6 @@ class FFN(Primitive):
         validator.check_value_type("inner_precise", inner_precise, [int], cls_name)
 
 
-class _MirrorSilentCheck(PrimitiveWithInfer):
-    """
-    The operator _MirrorSilentCheck implements accuracy-sensitive detection on the tensor input in backpropagator.
-    Call _MirrorSilentCheck in method __call__ of derived class to implement accuracy-sensitive detection.
-
-    Inputs:
-        - **input** (Tensor) : The tensor used for detection.
-          Its data type must be mindspore.float16, mindspore.float32 or mindspore.bfloat16.
-        - **pre_val** (Parameter(Tensor)) : Support parameter in accuracy-sensitive detection.
-          Please only generated by method generate_params() of ASDBase.
-        - **min_val** (Parameter(Tensor)) : Support parameter in accuracy-sensitive detection.
-          Please only generated by method generate_params() of ASDBase.
-        - **max_val** (Parameter(Tensor)) : Support parameter in accuracy-sensitive detection.
-          Please only generated by method generate_params() of ASDBase.
-        - **cnt** (Parameter(Tensor)) : Support parameter in accuracy-sensitive detection.
-          Please only generated by method generate_params() of ASDBase.
-          After each invocation of _MirrorSilentCheck, increment the value of cnt by one.
-
-    Outputs:
-        - **output** (Tensor) - Same shape, type and value as `input`.
-    """
-    @prim_attr_register
-    def __init__(self, min_steps=8):
-        upper_thresh, sigma_thresh = self.get_thresh()
-        self.min_steps = min_steps
-        self.thresh_l1 = upper_thresh[0]
-        self.coeff_l1 = sigma_thresh[0]
-        self.thresh_l2 = upper_thresh[1]
-        self.coeff_l2 = sigma_thresh[1]
-        self.add_prim_attr('side_effect_mem', True)
-
-    def parse_thresh(self, env_var_name, default_value, min_value):
-        env_var = os.environ.get(env_var_name, default=default_value)
-        thresh = [value.strip() for value in env_var.split(",")]
-        if len(thresh) != 2 or not all(value.isdigit() for value in thresh):
-            thresh = default_value.split(",")
-        thresh = [float(max(int(value), min_value)) for value in thresh]
-        if thresh[0] <= thresh[1]:
-            thresh = [float(value) for value in default_value.split(",")]
-
-        return thresh
-
-    def get_thresh(self):
-        upper_thresh = self.parse_thresh("NPU_ASD_UPPER_THRESH", "1000000,10000", 3)
-        sigma_thresh = self.parse_thresh("NPU_ASD_SIGMA_THRESH", "100000,5000", 3)
-        return upper_thresh, sigma_thresh
-
-    def infer_shape(self, x_shape, pre_shape, min_shape, max_shape, n_step, loss_scale_shape):
-        return x_shape
-
-    def infer_dtype(self, x_dtype, pre_dtype, min_dtype, max_dtype, n_dtype, loss_scale_dtype):
-        return x_dtype
-
-
 class _VirtualConverterEnd(PrimitiveWithInfer):
     """
     Auto parallel virtual operator.
@@ -2560,6 +2535,8 @@ class _VirtualConverterBegin(PrimitiveWithInfer):
         self.output_nums = output_nums
 
     def infer_shape(self, arg):
+        if self.output_nums == 0:
+            return ValueError("output_nums can\'t be zero.")
         new_arg = (arg[0] / self.output_nums,) + tuple(arg[1:])
         return (new_arg,) * self.output_nums
 

mindspore/ops/operations/array_ops.py

@@ -39,11 +39,12 @@ from ..auto_generate import (ExpandDims, Reshape, TensorShape, Transpose, Gather
                              OnesLike, ZerosLike, Argmax, ArgMaxExt,
                              ReverseV2, Diag, Eye, ScatterNd, ResizeNearestNeighborV2,
                              GatherNd, GatherD, Range, MaskedFill, RightShift, NonZero,
-                             ResizeNearestNeighbor, Identity, Split, CumSum, CumProd,
+                             ResizeNearestNeighbor, Identity, Split, CumSum, CumProd, MaskedSelect,
                              Cummax, Cummin, Argmin, Concat, UnsortedSegmentSum, ScalarToTensor,
                              Triu, BroadcastTo, StridedSlice, Select, TopkExt, SearchSorted)
 from .manually_defined import Rank, Shape, Tile, Cast, Ones, Zeros
 from ..auto_generate import ArgMaxWithValue, ArgMinWithValue
+from ..auto_generate import TensorScatterElements as TensorScatterElementsExt
 
 class _ScatterOp(PrimitiveWithInfer):
     """
@@ -769,41 +770,13 @@ class Padding(Primitive):
 
 class UniqueWithPad(Primitive):
     """
-    Returns unique elements and relative indexes in 1-D tensor, filled with padding num.
-
-    The basic function is the same as the Unique operator, but the UniqueWithPad operator adds a Pad function.
-    The returned tuple(`y`, `idx`) after the input Tensor `x` is processed by the unique operator,
-    in which the shapes of `y` and `idx` are mostly not equal. Therefore, in order to solve the above situation,
-    the UniqueWithPad operator will fill the `y` Tensor with the `pad_num` specified by the user
-    to make it have the same shape as the Tensor `idx`.
-
-    Refer to :func:`mindspore.ops.unique_with_pad` for more details.
-
-    Inputs:
-        - **x** (Tensor) - The tensor need to be unique. Must be 1-D vector with types: int32, int64.
-        - **pad_num** (int) - Pad num. The data type is an int.
-
-    Outputs:
-        tuple(Tensor), tuple of 2 tensors, `y` and `idx`.
-
-        - y (Tensor) - The unique elements filled with pad_num, the shape and data type same as `x`.
-        - idx (Tensor) - The index of each value of `x` in the unique output `y`, the shape and data type same as `x`.
+    'ops.UniqueWithPad' is deprecated from version 2.4 and will be removed in a future version.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([1, 1, 2, 2, 3, 3, 4, 5]), mindspore.int32)
-        >>> pad_num = 8
-        >>> output = ops.UniqueWithPad()(x, pad_num)
-        >>> print(output)
-        (Tensor(shape=[8], dtype=Int32, value= [1, 2, 3, 4, 5, 8, 8, 8]),
-         Tensor(shape=[8], dtype=Int32, value= [0, 0, 1, 1, 2, 2, 3, 4]))
+        Deprecated
     """
 
+    @deprecated("2.4", "ops.Unique and ops.PadV3", False)
     @prim_attr_register
     def __init__(self):
         """init UniqueWithPad"""
@@ -819,7 +792,7 @@ class Size(Primitive):
 
     Inputs:
         - **input_x** (Tensor) - Input parameters, the shape of tensor is :math:`(x_1, x_2, ..., x_R)`. The data type is
-          `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Outputs:
         int. A scalar representing the elements' size of `input_x`, tensor is the number of elements
@@ -2112,60 +2085,6 @@ class Rint(Primitive):
         self.init_prim_io_names(inputs=['x'], outputs=['output'])
 
 
-class StridedSliceV2(Primitive):
-    r"""
-    StridedSliceV2 will be deprecated by StridedSlice in the future.
-    Extracts a strided slice of a tensor.
-    Refer to class StridedSlice for more details.
-
-    Args:
-        begin_mask (int): Starting index of the slice. Default: ``0`` .
-        end_mask (int): Ending index of the slice. Default: ``0`` .
-        ellipsis_mask (int): An int mask. Default: ``0`` .
-        new_axis_mask (int): An int mask. Default: ``0`` .
-        shrink_axis_mask (int): An int mask. Default: ``0`` .
-
-    Inputs:
-        - **input_x** (Tensor) - The input Tensor.
-        - **begin** (tuple[int]) - A tuple which represents the location where to start. Only
-          constant value is allowed.
-        - **end** (tuple[int]) - A tuple or which represents the maximum location where to end.
-          Only constant value is allowed.
-        - **strides** (tuple[int]) - A tuple which represents the stride is continuously added
-          before reaching the maximum location. Only constant value is allowed.
-
-    Outputs:
-        Tensor, The output is explained by following example.
-
-    Raises:
-        TypeError: If `begin_mask`, `end_mask`, `ellipsis_mask`, `new_axis_mask` or `shrink_axis_mask` is not an int.
-        TypeError: If `begin`, `end` or `strides` is not a tuple.
-        ValueError: If `begin_mask`, `end_mask`, `ellipsis_mask`, `new_axis_mask` or `shrink_axis_mask` is less than 0.
-
-    Supported Platforms:
-        ``Ascend`` ``CPU``
-
-    Examples:
-        >>> input_x = Tensor([[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]],
-        ...                   [[5, 5, 5], [6, 6, 6]]], mindspore.float32)
-        >>> strided_slice_v2 = ops.StridedSliceV2()
-        >>> output = strided_slice_v2(input_x, (1, 0, 2), (3, 1, 3), (1, 1, 1))
-        >>> print(output)
-        [[[3.]]
-         [[5.]]]
-    """
-
-    @prim_attr_register
-    def __init__(self,
-                 begin_mask=0,
-                 end_mask=0,
-                 ellipsis_mask=0,
-                 new_axis_mask=0,
-                 shrink_axis_mask=0):
-        """Initialize StridedSliceV2"""
-        self.init_prim_io_names(inputs=['x', 'begin', 'end', 'strides'], outputs=['output'])
-
-
 class DiagPart(PrimitiveWithCheck):
     r"""
 
@@ -4356,53 +4275,6 @@ class MaskedScatter(Primitive):
         self.init_prim_io_names(inputs=['x', 'mask', 'updates'], outputs=['y'])
 
 
-class MaskedSelect(PrimitiveWithCheck):
-    """
-    Returns a new 1-D Tensor which indexes the `x` tensor according to the boolean `mask`.
-    The shapes of the `mask` tensor and the `x` tensor don't need to match, but they must be broadcastable.
-
-    Inputs:
-        - **x** (Tensor) - Input Tensor of any dimension.
-        - **mask** (Tensor[bool]) - Boolean mask Tensor, has the same shape as `x`.
-
-    Outputs:
-        A 1-D Tensor, with the same type as x.
-
-    Raises:
-        TypeError: If `x` or `mask` is not a Tensor.
-        TypeError: If dtype of `mask` is not bool.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([1, 2, 3, 4]), mindspore.int32)
-        >>> mask = Tensor(np.array([1, 0, 1, 0]), mindspore.bool_)
-        >>> output = ops.MaskedSelect()(x, mask)
-        >>> print(output)
-        [1 3]
-        >>> x = Tensor(2.1, mindspore.float32)
-        >>> mask = Tensor(True, mindspore.bool_)
-        >>> output = ops.MaskedSelect()(x, mask)
-        >>> print(output)
-        [2.1]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        self.init_prim_io_names(inputs=['x', 'mask'], outputs=['output'])
-
-    def check_shape(self, x_shape, mask_shape):
-        get_broadcast_shape(x_shape, mask_shape, self.name, arg_name1="x", arg_name2="mask")
-
-    def check_dtype(self, x_dtype, mask_dtype):
-        validator.check_tensor_dtype_valid('mask', mask_dtype, [mstype.bool_], self.name)
-        validator.check_tensor_dtype_valid('x', x_dtype, (mstype.bool_,) + mstype.number_type, self.name)
-
-
 class _TensorScatterOp(PrimitiveWithInfer):
     """
     Defines TensorScatter Base Operators
@@ -4962,7 +4834,7 @@ class SplitV(Primitive):
         self.init_prim_io_names(inputs=['input_x'], outputs=['output'])
 
 
-class TensorScatterElements(Primitive):
+class TensorScatterElements(TensorScatterElementsExt):
     """
     Write all elements in `updates` to the index specified by `indices` in `input_x` according to the reduction
     operation specified by `reduction`.
@@ -4977,6 +4849,9 @@ class TensorScatterElements(Primitive):
     .. warning::
         This is an experimental API that is subject to change or deletion.
 
+    Note:
+        The backward is supported only for the case `updates.shape == indices.shape`.
+
     Args:
         axis (int, optional): Specify which axis to do scatter operation. Default: ``0`` .
         reduction (str, optional): Which reduction operation to scatter, default is ``"none"`` . Other option: "add".
@@ -4986,7 +4861,7 @@ class TensorScatterElements(Primitive):
         - **indices** (Tensor) - The index of `input_x` to do scatter operation whose data type must be int32 or
           int64. It has the same rank as `data`. And accepted range is [-s, s) where s is the size along axis.
         - **updates** (Tensor) - The tensor doing the scatter operation with `data`,
-          it has the same type as `data` and the same shape as `indices`.
+          it has the same type as `data`.
 
     Outputs:
         Tensor, has the same shape and type as `data`.
@@ -5021,16 +4896,7 @@ class TensorScatterElements(Primitive):
 
     @prim_attr_register
     def __init__(self, axis=0, reduction="none"):
-        """Initialize TensorScatterElements"""
-        validator.check_value_type("axis", axis, [int], self.name)
-        validator.check_value_type("reduction", reduction, [str], self.name)
-        validator.check_string(reduction, ["none", "add"], "reduction", self.name)
-        self.init_prim_io_names(inputs=['data', 'indices', 'updates'], outputs=['y'])
-        target = context.get_context("device_target")
-        if reduction != 'none' and target.lower() == "ascend":
-            raise ValueError(f"For '{self.name}', "
-                             f"Currently Ascend device_target only support `reduction`='none', "
-                             f"but got {reduction}")
+        super().__init__(axis, reduce=reduction)
 
 
 class ExtractVolumePatches(Primitive):