mindspore 2.1.0__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/operations/array_ops.py

@@ -28,7 +28,8 @@ from mindspore.ops._utils import get_broadcast_shape
 from mindspore.common._utils import is_shape_unknown, is_dim_unknown
 from mindspore.ops.primitive import Primitive, PrimitiveWithInfer, PrimitiveWithCheck, prim_attr_register, _run_op
 from mindspore import _checkparam as validator
-from mindspore._checkparam import _check_3d_int_or_tuple, is_pack_tensor
+from mindspore._checkparam import _check_3d_int_or_tuple
+from mindspore.ops._tracefunc import PackFunc
 from mindspore.common import dtype as mstype
 from mindspore.common._decorator import deprecated
 from mindspore.common.parameter import Parameter
@@ -174,39 +175,11 @@ def _check_infer_attr_reduce(axis, keep_dims, prim_name):
 
 class Expand(Primitive):
     """
-    Expands the Tensor along singleton dimensions(dim with size 1) to match given desired shape.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Refer to :func:`mindspore.ops.expand` for more details.
-
-    Inputs:
-        - **x** (Tensor) - The input tensor.
-        - **shape** (Tensor) - The new shape of x.
-
-    Outputs:
-        Tensor after expansion, it shape is determined by `shape`.
-
-    Supported Platforms:
-        ``Ascend`` ``CPU``
-
-    Examples:
-        >>> x = Tensor(np.array([[1], [2], [3]]), mindspore.float32)
-        >>> shape = Tensor(np.array([3,4]), mindspore.int32)
-        >>> expand = ops.Expand()
-        >>> y = expand(x, shape)
-        >>> print(y)
-        [[1. 1. 1. 1.]
-         [2. 2. 2. 2.]
-         [3. 3. 3. 3.]]
-        >>> input_x = Tensor(2, mindspore.int16)
-        >>> size = Tensor(np.array([1, 1]), mindspore.int32)
-        >>> y = ops.Expand()(input_x, size)
-        >>> print(y)
-        [[2]]
+    :class:`mindspore.ops.Expand` will be deprecated in the future.
+    Please use :class:`mindspore.ops.BroadcastTo` instead.
     """
 
+    @deprecated("2.1", "BroadcastTo", False)
     @prim_attr_register
     def __init__(self):
         """Initialize Expand."""
@@ -216,7 +189,8 @@ class Expand(Primitive):
 
 class ExpandDims(PrimitiveWithCheck):
     """
-    Adds an additional dimension to `input_x` at the given axis.
+    Adds an additional dimension to `input_x` at the given axis, the dimension of
+    `input_x` should be greater than or equal to 1.
 
     Refer to :func:`mindspore.ops.expand_dims` for more details.
 
@@ -243,11 +217,6 @@ class ExpandDims(PrimitiveWithCheck):
         >>> print(output)
         [[[2. 2.]
           [2. 2.]]]
-        >>> input_tensor = Tensor(2.1+2j, mindspore.complex64)
-        >>> expand_dims = ops.ExpandDims()
-        >>> output = expand_dims(input_tensor, 0)
-        >>> print(output)
-        [2.1+2.j]
     """
 
     @prim_attr_register
@@ -380,7 +349,7 @@ class Cast(PrimitiveWithCheck):
                 data = x.data
                 if data.dtype == dtype:
                     return (True, x)
-            if isinstance(x, Tensor) and x.dtype == dtype and not is_pack_tensor(x):
+            if isinstance(x, Tensor) and x.dtype == dtype and not PackFunc.is_tracing():
                 x = Tensor(x)
                 x.set_cast_dtype()
                 return (True, x)
@@ -404,9 +373,9 @@ class Cast(PrimitiveWithCheck):
         value = None
         np_dst_type = mstype.dtype_to_nptype(dst_type)
         if isinstance(x, (int, float)):
-            value = Tensor(np.array(x).astype(np_dst_type))
+            value = Tensor(np.array(x).astype(np_dst_type), dtype=dst_type)
         else:
-            value = Tensor(x.asnumpy().astype(np_dst_type))
+            value = Tensor(x.asnumpy().astype(np_dst_type), dtype=dst_type)
         return value
 
 
@@ -766,23 +735,6 @@ class Unsqueeze(PrimitiveWithCheck):
         self.axis = axis
 
 
-class DynamicShape(Primitive):
-    """
-    Same as operator TensorShape. DynamicShape will be deprecated in the future.
-    Please use TensorShape instead.
-
-    Supported Platforms:
-        Deprecated
-    """
-
-    @deprecated("1.7", "TensorShape", True)
-    @prim_attr_register
-    def __init__(self, dtype=9):
-        """init Shape"""
-        self.init_prim_io_names(inputs=['tensor'], outputs=['output'])
-        self.add_prim_attr('is_dynamic_shape', True)
-
-
 class Squeeze(Primitive):
     """
     Return the Tensor after deleting the dimension of size 1 in the specified `axis`.
@@ -1358,7 +1310,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/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
 
     Outputs:
         int. A scalar representing the elements' size of `input_x`, tensor is the number of elements
@@ -1479,10 +1431,20 @@ class MatrixDiagPartV3(Primitive):
     Refer to :func:`mindspore.ops.matrix_diag_part` for more details.
 
     Args:
-        align (str, optional): An optional string from: "RIGHT_LEFT"(default),
-            "LEFT_RIGHT", "LEFT_LEFT", "RIGHT_RIGHT".
-            It specifies how superdiagonals and subdiagonals should be aligned, respectively. "RIGHT_LEFT"
-            aligns superdiagonals to the right (left-pads the row) and subdiagonals to the left (right-pads the row).
+        align (str, optional): specifies how superdiagonals and subdiagonals should be aligned.
+            Supported values: ``"RIGHT_LEFT"`` , ``"LEFT_RIGHT"`` , ``"LEFT_LEFT"`` , ``"RIGHT_RIGHT"`` .
+            Default: ``"RIGHT_LEFT"`` .
+
+            - When set to ``"RIGHT_LEFT"`` , the alignment of superdiagonals will be towards the right side
+              (padding the row on the left), while subdiagonals will be towards the left side
+              (padding the row on the right)
+            - When set to ``"LEFT_RIGHT"`` , the alignment of superdiagonals will be towards the left side
+              (padding the row on the right), while subdiagonals will be towards the right side
+              (padding the row on the left)
+            - When set to ``"LEFT_LEFT"`` , the alignment of  both superdiagonals and subdiagonals will be towards
+              the left side(padding the row on the right).
+            - When set to ``"RIGHT_RIGHT"`` , the alignment of both superdiagonals and subdiagonals will be towards
+              the right side(padding the row on the left).
 
     Inputs:
         - **x** (Tensor) - Rank r, where r >= 2.
@@ -1721,7 +1683,7 @@ class Fill(PrimitiveWithCheck):
         if isinstance(x, Tensor):
             x = x.asnumpy()
         ret = np.full(dims, x, x_nptype)
-        return Tensor(ret)
+        return Tensor(ret, dtype=dtype)
 
     def infer_value(self, dtype, dims, x):
         x_nptype = mstype.dtype_to_nptype(dtype)
@@ -1731,7 +1693,7 @@ class Fill(PrimitiveWithCheck):
             if isinstance(x, Tensor):
                 x = x.asnumpy()
             ret = np.full(dims, x, x_nptype)
-            return Tensor(ret)
+            return Tensor(ret, dtype=dtype)
         return None
 
 
@@ -1800,15 +1762,19 @@ class FillV2(PrimitiveWithCheck):
         """Initialize FillV2"""
         self.init_prim_io_names(inputs=['shape', 'value'], outputs=['y'])
 
+    def check_elim(self, dims, x):
+        if x is None or (not isinstance(x, (Tensor, Tensor_))) or (x.shape != ()) or\
+            dims is None or (isinstance(dims, (tuple, list)) and dims) or\
+            isinstance(dims, (Tensor, Tensor_)):
+            return (False, None)
+        return (True, x)
+
     def infer_value(self, dims, x):
-        if isinstance(dims, (Tensor, Tensor_)):
-            dims = dims.asnumpy()
-        if isinstance(x, (Tensor, Tensor_)):
-            x = x.asnumpy()
-        if dims is not None and None not in dims and x is not None:
-            ret = np.full(dims, x)
-            return Tensor(ret)
-        return None
+        if x is None or dims is None or\
+            (isinstance(dims, (tuple, list)) and dims) or\
+            isinstance(dims, (Tensor, Tensor_)):
+            return None
+        return x
 
 
 class Ones(Primitive):
@@ -1997,7 +1963,8 @@ class TupleToArray(PrimitiveWithInfer):
             ret = np.array(x, np.float32)
         return Tensor(ret)
 
-    def __call__(self, x):
+    def __call__(self, *args):
+        x, = args
         args = list()
         if isinstance(x, range):
             args.append(tuple(x))
@@ -2006,24 +1973,6 @@ class TupleToArray(PrimitiveWithInfer):
         return _run_op(self, self.name, args)
 
 
-class ScalarToArray(PrimitiveWithInfer):
-    """
-    The `ScalarToArray` primitive  is deprecated. Please use the :class:`mindspore.ops.ScalarToTensor` instead.
-    """
-    @deprecated("2.0", "ops.scalar_to_tensor", False)
-    @prim_attr_register
-    def __init__(self):
-        pass
-
-    def infer_value(self, x):
-        validator.check_value_type("x", x, [int, float], self.name)
-        if isinstance(x, int):
-            ret = np.array(x, np.int32)
-        else:
-            ret = np.array(x, np.float32)
-        return Tensor(ret)
-
-
 class ScalarToTensor(PrimitiveWithInfer):
     """
     Converts a scalar to a `Tensor`, and converts the data type to the specified type.
@@ -2059,7 +2008,7 @@ class ScalarToTensor(PrimitiveWithInfer):
         validator.check_value_type("x", x, [bool, int, float], self.name)
         validator.check_subclass("dtype", dtype, mstype.number, self.name)
         data_type = mstype.dtype_to_nptype(dtype)
-        return Tensor(np.array(x, data_type))
+        return Tensor(np.array(x, data_type), dtype=dtype)
 
 
 class InvertPermutation(PrimitiveWithInfer):
@@ -2479,7 +2428,10 @@ class Tile(PrimitiveWithInfer):
         """Initialize Tile"""
         self.init_prim_io_names(inputs=['x', 'multiples'], outputs=['output'])
 
-    def check_elim(self, base_tensor, multiplier):
+    def check_elim(self, *args):
+        base_tensor, multiplier = args
+        if PackFunc.is_tracing() and not PackFunc.current.is_pynative_mode:
+            return (False, None)
         if not isinstance(base_tensor, Tensor):
             raise TypeError(f"For '{self.name}', the type of 'input_x' must be Tensor, "
                             f"but got {type(base_tensor).__name__}.")
@@ -2999,7 +2951,7 @@ def _get_stack_shape(value, x_shape, x_type, axis, prim_name):
     out_n = len(x_shape)
     for i in range(1, out_n):
         if x_type[i] != x_type[i-1]:
-            raise TypeError("For \'{}\', all types should be same, but got {}".format(prim_name, x_type))
+            raise TypeError(f"For {prim_name}, all types should be same, but got {x_type}")
 
     new_x_shape = []
     for i, shp in enumerate(x_shape):
@@ -3021,8 +2973,8 @@ def _get_stack_shape(value, x_shape, x_type, axis, prim_name):
         for j in range(0, rank_base):
             if new_x_shape[i]["shape"][j] != new_x_shape[0]["shape"][j] and \
                     new_x_shape[i]["shape"][j] != -1 and new_x_shape[0]["shape"][j] != -1:
-                raise ValueError("For \'{}\' element {} shape in input can not pack with first element".format(
-                    prim_name, new_x_shape[i]['id']))
+                raise ValueError(f"For {prim_name} element {new_x_shape[i]['id']} shape"
+                                 f"in input can not pack with first element")
 
     validator.check_int_range(axis, -rank_base - 1, rank_base, validator.INC_BOTH, 'axis', prim_name)
     if axis < 0:
@@ -3038,30 +2990,6 @@ def _get_stack_shape(value, x_shape, x_type, axis, prim_name):
     return out_shape
 
 
-class Pack(PrimitiveWithInfer):
-    """
-    Same as operator Stack. Pack will be deprecated in the future.
-    Please use Stack instead.
-    """
-
-    @deprecated("1.1", "Stack", True)
-    @prim_attr_register
-    def __init__(self, axis=0):
-        """Initialize Pack"""
-        validator.check_value_type("axis", axis, [int], self.name)
-        self.axis = axis
-
-    def __infer__(self, value):
-        x_shape = value['shape']
-        x_type = value['dtype']
-        self.add_prim_attr('num', len(x_shape))
-        all_shape = _get_stack_shape(value, x_shape, x_type, self.axis, self.name)
-        out = {'shape': all_shape,
-               'dtype': x_type[0],
-               'value': None}
-        return out
-
-
 class Stack(PrimitiveWithInfer):
     r"""
     Stacks a list of tensors in specified axis.
@@ -3138,47 +3066,6 @@ class Stack(PrimitiveWithInfer):
         return out
 
 
-class Unpack(PrimitiveWithInfer):
-    """
-    Same as operator Unstack. Unpack will be deprecated in the future.
-    Please use Unstack instead.
-    """
-
-    @deprecated("1.1", "Unstack", True)
-    @prim_attr_register
-    def __init__(self, axis=0):
-        """Initialize Unpack"""
-        validator.check_value_type("axis", axis, [int], self.name)
-        self.axis = axis
-
-    def __infer__(self, x):
-        validator.check_subclass("x", x['dtype'], mstype.tensor_type, self.name)
-        x_shape = list(x['shape'])
-        dim = len(x_shape)
-        validator.check_int_range(self.axis, -dim, dim, validator.INC_LEFT, 'axis value', self.name)
-        if self.axis < 0:
-            self.axis = self.axis + dim
-        output_num = x_shape[self.axis]
-        validator.check_value_type("num", output_num, [int], self.name)
-        validator.check_positive_int(output_num, "output_num", self.name)
-        self.add_prim_attr('num', output_num)
-        output_valid_check = x_shape[self.axis] - output_num
-        validator.check_int(output_valid_check, 0, validator.EQ,
-                            "The dimension which to unstack divides output_num", self.name)
-        out_shapes = []
-        out_dtypes = []
-        out_shape = x_shape[:self.axis] + x_shape[self.axis + 1:]
-        for _ in range(output_num):
-            out_shapes.append(tuple(out_shape))
-            out_dtypes.append(x['dtype'])
-        out_shapes = tuple(out_shapes)
-        out_dtypes = tuple(out_dtypes)
-        out = {'shape': out_shapes,
-               'dtype': out_dtypes,
-               'value': None}
-        return out
-
-
 class Unstack(Primitive):
     r"""
     Unstacks tensor in specified axis, this is the opposite of ops.Stack.
@@ -3377,6 +3264,9 @@ class ReverseV2(Primitive):
         for i, each in enumerate(axis):
             validator.check_value_type(f'axis[{i}]', each, [int], self.name)
         self.axis = axis
+        if isinstance(axis, list):
+            self.axis = tuple(axis)
+            self.add_prim_attr('axis', self.axis)
         self.init_prim_io_names(inputs=['x'], outputs=['output'])
 
 
@@ -3538,9 +3428,7 @@ class StridedSlice(PrimitiveWithInfer):
     Inputs:
         - **input_x** (Tensor) - The input Tensor to be extracted from.
         - **begin** (tuple[int]) - A tuple which represents the location where to start.
-          Only non-negative int is allowed.
         - **end** (tuple[int]) - A tuple or which represents the maximum location where to end.
-          Only non-negative int is allowed.
         - **strides** (tuple[int]) - A tuple which represents the strides is continuously added
           before reaching the maximum location. Only int is allowed, it can be negative
           which results in reversed slicing.
@@ -3655,10 +3543,10 @@ class StridedSlice(PrimitiveWithInfer):
         end_v, end_len = self._check_and_get_value(end, 'end')
         strides_v, strides_len = self._check_and_get_value(strides, 'strides')
 
-        is_dynamic_tuple = (self._is_none_in_tuple(begin_v['value'])
-                            or self._is_none_in_tuple(end_v['value'])
-                            or self._is_none_in_tuple(strides_v['value']))
-        is_dynamic = None in (begin_v['value'], end_v['value'], strides_v['value'])
+        is_dynamic_tuple = (self._is_none_in_tuple(begin_v.get('value'))
+                            or self._is_none_in_tuple(end_v.get('value'))
+                            or self._is_none_in_tuple(strides_v.get('value')))
+        is_dynamic = None in (begin_v.get('value'), end_v.get('value'), strides_v.get('value'))
 
         if not is_dynamic and (begin_len != strides_len or end_len != strides_len):
             raise ValueError(
@@ -4047,7 +3935,7 @@ class DiagPart(PrimitiveWithCheck):
 
     If the `input_x` is a Tensor of shape :math:`[D_1,..., D_k, D_1,..., D_k]`, then the
     output will be a Tensor of rank k of shape :math:`[D_1,..., D_k]` where:
-    :math:`output[i_1,..., i_k] = input_x[i_1,..., i_k, i_1,..., i_k]`.
+    :math:`output[i_1,..., i_k] = input\_x[i_1,..., i_k, i_1,..., i_k]`.
 
     Inputs:
         - **input_x** (Tensor) - The rank of input tensor is 2k(k > 0).
@@ -5626,67 +5514,6 @@ class ScatterNdMin(_ScatterNdOp):
         super().__init__(use_locking)
 
 
-class ScatterNonAliasingAdd(Primitive):
-    """
-    The ScatterNonAliasingAdd Interface is deprecated from version 2.1.
-    Please use :class:`mindspore.ops.TensorScatterAdd` instead.
-    This interface may has precision error on Ascend and will be removed in a future version.
-
-    Applies sparse addition to the input using individual values or slices.
-
-    Using given values to update tensor value through the add operation, along with the input indices.
-    This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value.
-
-    Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent.
-    If they have different data types, the lower priority data type will be converted to
-    the relatively highest priority data type.
-
-    Inputs:
-        - **input_x** (Parameter) - The target parameter. The data type must be float16, float32 or int32.
-        - **indices** (Tensor) - The index to perform the addition operation whose data type must be mindspore.int32.
-        - **updates** (Tensor) - The tensor that performs the addition operation with `input_x`,
-          the data type is the same as `input_x`, the shape is `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-
-    Outputs:
-        Parameter, the updated `input_x`.
-
-    Raises:
-        TypeError: If dtype of `indices` is not int32.
-        TypeError: If dtype of `input_x` is not one of float16, float32, int32.
-        ValueError: If the shape of `updates` is not equal to `indices.shape[:-1] + x.shape[indices.shape[-1]:]`.
-        RuntimeError: If the data type of `input_x` and `updates` conversion of Parameter
-                      is required when data type conversion of Parameter is not supported.
-
-    Supported Platforms:
-            Deprecated
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops, Parameter
-        >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
-        >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
-        >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
-        >>> scatter_non_aliasing_add = ops.ScatterNonAliasingAdd()
-        >>> output = scatter_non_aliasing_add(input_x, indices, updates)
-        >>> print(output)
-        [ 1. 10.  9.  4. 12.  6.  7. 17.]
-    """
-
-    __mindspore_signature__ = (
-        sig.make_sig('input_x', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
-        sig.make_sig('indices', dtype=sig.sig_dtype.T1),
-        sig.make_sig('updates', dtype=sig.sig_dtype.T)
-    )
-
-    @deprecated("2.1", "ops.ScatterNonAliasingAdd", False)
-    @prim_attr_register
-    def __init__(self):
-        """Initialize ScatterNonAliasingAdd"""
-        self.init_prim_io_names(inputs=['input_x', 'indices', 'updates'], outputs=['y'])
-        self.add_prim_attr('side_effect_mem', True)
-
-
 class SpaceToDepth(Primitive):
     r"""
     Rearrange blocks of spatial data into depth.
@@ -6049,54 +5876,6 @@ class SpaceToBatchND(Primitive):
         self.paddings = paddings
 
 
-class BatchToSpaceND(Primitive):
-    r"""
-    :class:`mindspore.ops.BatchToSpaceND` is deprecated from version 2.0 and will be removed in a future version,
-    use :func:`mindspore.ops.batch_to_space_nd` instead.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> block_size = 2
-        >>> crops = [[0, 0], [0, 0]]
-        >>> batch_to_space = ops.BatchToSpaceND(block_size, crops)
-        >>> input_x = Tensor(np.array([[[[1]]], [[[2]]], [[[3]]], [[[4]]]]), mindspore.float32)
-        >>> output = batch_to_space(input_x)
-        >>> print(output)
-        [[[[1.  2.]
-           [3.  4.]]]]
-    """
-
-    @deprecated("2.0", "ops.batch_to_space_nd", False)
-    @prim_attr_register
-    def __init__(self, block_shape, crops):
-        """Initialize BatchToSpaceND"""
-        if isinstance(block_shape, int):
-            block_shape = (block_shape,) * np.array(crops).shape[0]
-        self.add_prim_attr("block_shape", block_shape)
-        validator.check_value_type('block_shape type', block_shape, [list, tuple], self.name)
-        validator.check('block_shape shape', len(np.array(block_shape).shape), '', 1, validator.EQ, self.name)
-        block_rank = len(block_shape)
-        if context.get_context("device_target") == "Ascend":
-            validator.check('block_shape length', block_rank, '', 2, validator.EQ, self.name)
-        for elem in block_shape:
-            validator.check('block_shape element', elem, '', 1, validator.GE, self.name)
-            validator.check_value_type('block_shape element', elem, [int], self.name)
-        self.block_shape = block_shape
-
-        validator.check_value_type('crops type', crops, [list, tuple], self.name)
-        validator.check('crops length', len(crops), '', 1, validator.GE, self.name)
-        validator.check('crops shape', np.array(crops).shape, '', (block_rank, 2), validator.EQ, self.name)
-        for elem in itertools.chain(*crops):
-            validator.check_non_negative_int(elem, 'crops element', self.name)
-            validator.check_value_type('crops element', elem, [int], self.name)
-        self.crops = crops
-
-
 class BatchToSpaceNDV2(Primitive):
     r"""
     Divides batch dimension with blocks and interleaves these blocks back into spatial dimensions.
@@ -6300,7 +6079,7 @@ class Meshgrid(PrimitiveWithInfer):
 
 
 class ReverseSequence(PrimitiveWithInfer):
-    """
+    r"""
     Reverses variable length slices.
 
     Args:
@@ -6316,7 +6095,12 @@ class ReverseSequence(PrimitiveWithInfer):
 
     Raises:
         TypeError: If `seq_dim` or `batch_dim` is not an int.
-        ValueError: If value of `batch_dim` is equal to or greater than length of shape of `x` .
+        ValueError: If :math:`len(seq\_lengths) != x.shape[batch\_dim]`.
+        ValueError: If :math:`batch\_dim == seq\_dim`.
+        ValueError: If :math:`seq\_dim < 0` or :math:`seq\_dim >= len(x.shape)`.
+        ValueError: If :math:`batch\_dim < 0` or :math:`batch\_dim >= len(x.shape)`.
+        RuntimeError: If any value of `seq_lengths` is less than 0.
+        RuntimeError: If any value of `seq_lengths` is larger than `x.shape[seq_dim]`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``