mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/nn/wrap/cell_wrapper.py

@@ -1,3 +1,4 @@
+
 # Copyright 2020 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,14 +21,13 @@ from types import FunctionType, MethodType
 
 from mindspore import log as logger
 from mindspore.parallel._utils import _get_device_num, _get_gradients_mean,\
-    _get_parallel_mode, _get_enable_parallel_optimizer
+    _get_parallel_mode, _get_enable_parallel_optimizer, _is_pynative_parallel
 from mindspore.context import ParallelMode
-from mindspore._checkparam import Validator as validator
+from mindspore import _checkparam as validator
 from mindspore import ops, nn
 from mindspore.common import dtype as mstype
-from mindspore.common.api import is_pynative_parallel
 from mindspore.common.parameter import Parameter, ParameterTuple
-from mindspore.ops.primitive import constexpr
+from mindspore.ops.primitive import _primexpr
 from mindspore.ops import composite as C
 from mindspore.ops import functional as F
 from mindspore.ops import operations as P
@@ -110,7 +110,7 @@ class WithLossCell(Cell):
         super(WithLossCell, self).__init__(auto_prefix=False)
         self._backbone = backbone
         self._loss_fn = loss_fn
-        if backbone.jit_config_dict:
+        if isinstance(backbone, Cell) and backbone.jit_config_dict:
             self._jit_config_dict = backbone.jit_config_dict
 
     def construct(self, data, label):
@@ -147,7 +147,7 @@ class WithGradCell(Cell):
             output value. Default: None.
 
     Inputs:
-        - **(\*inputs)** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
+        - **\*inputs** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
 
     Outputs:
         list, a list of Tensors with identical shapes as trainable weights.
@@ -182,6 +182,8 @@ class WithGradCell(Cell):
         else:
             self.network_with_loss = WithLossCell(self.network, self.loss_fn)
         self.network_with_loss.set_train()
+        if isinstance(network, Cell) and network.jit_config_dict:
+            self._jit_config_dict = network.jit_config_dict
 
     def construct(self, *inputs):
         weights = self.weights
@@ -216,8 +218,8 @@ class ForwardValueAndGrad(Cell):
             the input parameter.
 
     Inputs:
-        - **(\*inputs)** (Tuple(Tensor...)) - Tuple of inputs with shape :math:`(N, \ldots)`.
-        - **(sens)** - A sensitivity (gradient with respect to output) as the input of backpropagation.
+        - **\*inputs** (Tuple(Tensor...)) - Tuple of inputs with shape :math:`(N, \ldots)`.
+        - **sens** - A sensitivity (gradient with respect to output) as the input of backpropagation.
           If network has single output, the sens is a tensor.
           If network has multiple outputs, the sens is the tuple(tensor).
 
@@ -282,6 +284,8 @@ class ForwardValueAndGrad(Cell):
         self.get_by_list = get_by_list
         self.sens_param = sens_param
         self.grad = C.GradOperation(get_all=self.get_all, get_by_list=self.get_by_list, sens_param=self.sens_param)
+        if isinstance(network, Cell) and network.jit_config_dict:
+            self._jit_config_dict = network.jit_config_dict
 
     def construct(self, *inputs):
         grad_inputs = inputs
@@ -309,7 +313,7 @@ class TrainOneStepCell(Cell):
         sens (numbers.Number): The scaling number to be filled as the input of backpropagation. Default value is 1.0.
 
     Inputs:
-        - **(\*inputs)** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
+        - **\*inputs** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
 
     Outputs:
         Tensor, a tensor means the loss value, the shape of which is usually :math:`()`.
@@ -359,10 +363,12 @@ class TrainOneStepCell(Cell):
         self.grad_reducer = F.identity
         self.parallel_mode = _get_parallel_mode()
         self.reducer_flag = self.parallel_mode in (ParallelMode.DATA_PARALLEL, ParallelMode.HYBRID_PARALLEL) or \
-                            is_pynative_parallel()
+                            _is_pynative_parallel()
         if self.reducer_flag:
             self.mean = _get_gradients_mean()
             self.degree = _get_device_num()
+            from mindspore.communication.management import GlobalComm
+            group = GlobalComm.WORLD_COMM_GROUP
             if isinstance(self.optimizer, (nn.AdaSumByGradWrapCell, nn.AdaSumByDeltaWeightWrapCell)):
                 from mindspore.communication.management import get_group_size, create_group, get_rank
                 group_number = get_group_size() // 8
@@ -371,10 +377,10 @@ class TrainOneStepCell(Cell):
                 current_index = get_rank() // 8
                 server_group_name = "allreduce_" + str(current_index)
                 create_group(server_group_name, group_list[current_index])
-                self.grad_reducer = DistributedGradReducer(self.weights, self.mean, self.degree,
-                                                           group=server_group_name)
-            else:
-                self.grad_reducer = DistributedGradReducer(self.weights, self.mean, self.degree)
+                group = server_group_name
+            self.grad_reducer = DistributedGradReducer(self.weights, self.mean, self.degree, group=group)
+        if isinstance(network, Cell) and network.jit_config_dict:
+            self._jit_config_dict = network.jit_config_dict
 
     def construct(self, *inputs):
         loss = self.network(*inputs)
@@ -453,19 +459,19 @@ class _VirtualDatasetCell(Cell):
         super(_VirtualDatasetCell, self).__init__(auto_prefix=False)
         self._backbone = backbone
         self._virtual_dataset = _VirtualDataset()
+        if isinstance(backbone, Cell) and backbone.jit_config_dict:
+            self._jit_config_dict = backbone.jit_config_dict
 
     def construct(self, *inputs):
         output = self._virtual_dataset(*inputs)
         return self._backbone(*output)
 
 
-@constexpr
-def _check_shape_value_on_axis_divided_by_target_value(input_shape, dim, param_name, cls_name, target_value):
-    if input_shape[dim] % target_value != 0:
-        raise ValueError(f"For MicroBatchInterleaved initialization, "
-                         f"{cls_name} {param_name} at {dim} shape must be divided by {target_value},"
-                         f"but got {input_shape[dim]}")
-    return True
+@_primexpr
+def _check_shape_value_on_axis_divided_by_target_value(input_shape, micro_size):
+    if input_shape[0] % micro_size != 0:
+        raise ValueError(f"For micro batch initialization, the 0th dimension shape of input({input_shape[0]}) must be "
+                         f"divided by micro size({micro_size})")
 
 
 class _MicroBatch(Cell):
@@ -486,8 +492,7 @@ class _MicroBatch(Cell):
         micro_inputs = ()
         for each_input in inputs:
             input_shape = self.shape(each_input)
-            _check_shape_value_on_axis_divided_by_target_value(input_shape, 0, "inputs",
-                                                               self.cls_name, self.micro_size)
+            _check_shape_value_on_axis_divided_by_target_value(input_shape, self.micro_size)
             micro_batch_begin = i * input_shape[0] // self.micro_size
             micro_batch_end = (i + 1) * input_shape[0] // self.micro_size
             strided_slice_begin = (micro_batch_begin,)
@@ -504,18 +509,31 @@ class _MicroBatch(Cell):
 
 class MicroBatchInterleaved(Cell):
     """
-    Wrap the network with Batch Size.
+    This function splits the input at the 0th into interleave_num pieces and then performs
+    the computation of the wrapped cell. Application scenario: When there is model parallelism in semi-automatic mode
+    and network, if the first slice data is calculating forward, the second slice data will execute the
+    communication operators at the same time, to achieve the performance acceleration of communication and computing
+    concurrency.
+
+    Note:
+        The output of the input network must be a single tensor.
 
     Args:
         network (Cell): The target network to wrap.
-        interleave_num (int): split num of batch size. Default: 2.
+        interleave_num (int, optional): split num of batch size. Default: 2.
+
+    Inputs:
+        tuple[Tensor]. It's the same with the input of the `network` .
+
+    Outputs:
+        Tensor. The output of the input `network` .
 
     Supported Platforms:
         ``Ascend`` ``GPU``
 
     Examples:
         >>> net = Net()
-        >>> net = MicroBatchInterleaved(net, 4)
+        >>> net = MicroBatchInterleaved(net, 2)
     """
     def __init__(self, network, interleave_num=2):
         super(MicroBatchInterleaved, self).__init__(auto_prefix=False)
@@ -534,6 +552,8 @@ class MicroBatchInterleaved(Cell):
             interleave_data.strided_slice.add_prim_attr("strided_slice_flag", True)
             interleave_data.strided_slice.add_prim_attr("interleave_num", interleave_num)
             self.interleave_inputs.append(interleave_data)
+        if isinstance(network, Cell) and network.jit_config_dict:
+            self._jit_config_dict = network.jit_config_dict
 
     def construct(self, *inputs):
         output = 0.0
@@ -572,6 +592,8 @@ class PipelineCell(Cell):
             self.micro_inputs.append(micro_input)
             self.add = P.Add().add_prim_attr("pipeline_end", i)
             self.add_list.append(self.add)
+        if isinstance(network, Cell) and network.jit_config_dict:
+            self._jit_config_dict = network.jit_config_dict
 
     def construct(self, *inputs):
         ret = None
@@ -600,6 +622,8 @@ class _TrainPipelineAccuStepCell(TrainOneStepCell):
         self.accu_grads = self.weights.clone(prefix="accu_grads", init="zeros")
         self.hyper_map = ops.HyperMap()
         self.opt_shard = _get_enable_parallel_optimizer()
+        if isinstance(network, Cell) and network.jit_config_dict:
+            self._jit_config_dict = network.jit_config_dict
 
     def construct(self, *inputs):
         weights = self.weights
@@ -641,6 +665,8 @@ class VirtualDatasetCellTriple(Cell):
         super(VirtualDatasetCellTriple, self).__init__(auto_prefix=False)
         logger.warning("WARN_DEPRECATED: The usage of VirtualDatasetCellTriple is deprecated.")
         self._backbone = backbone
+        if isinstance(backbone, Cell) and backbone.jit_config_dict:
+            self._jit_config_dict = backbone.jit_config_dict
 
     def construct(self, a, b, c):
         return self._backbone(a, b, c)
@@ -683,6 +709,8 @@ class WithEvalCell(Cell):
         self._network = network
         self._loss_fn = loss_fn
         self.add_cast_fp32 = validator.check_value_type("add_cast_fp32", add_cast_fp32, [bool], self.cls_name)
+        if isinstance(network, Cell) and network.jit_config_dict:
+            self._jit_config_dict = network.jit_config_dict
 
     def construct(self, data, label):
         outputs = self._network(data)
@@ -706,7 +734,7 @@ class ParameterUpdate(Cell):
         - **x** (Tensor) - A tensor whose shape and type are the same with `param`.
 
     Outputs:
-        Tensor, the input `x`.
+        Tensor, the updated value.
 
     Raises:
         KeyError: If parameter with the specified name does not exist.

mindspore/nn/wrap/grad_reducer.py

@@ -19,13 +19,13 @@ from mindspore import context
 from mindspore import log as logger
 from mindspore.nn.cell import Cell
 from mindspore.communication.management import GlobalComm, get_group_size
-from mindspore.common.tensor import RowTensor
+from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.ops import functional as F, composite as C
 from mindspore.ops.operations.comm_ops import AllReduce, AllGather
 from mindspore.parallel._auto_parallel_context import auto_parallel_context
 import mindspore.common.dtype as mstype
-from mindspore.common.tensor import Tensor
-from mindspore.common.api import ms_function
+from mindspore.common.sparse_tensor import Tensor
+from mindspore.common.api import jit
 
 
 reduce_opt = C.MultitypeFuncGraph("reduce_opt")
@@ -188,7 +188,7 @@ def _tensors_allreduce_with_sparse(degree, mean, allgather, allreduce, allreduce
         dout = allgather(grad.values)
         if mean:
             dout = F.tensor_mul(dout, F.cast(degree, F.dtype(dout)))
-        grad = RowTensor(indices, dout, grad.dense_shape)
+        grad = RowTensorInner(indices, dout, grad.dense_shape)
     return grad
 
 
@@ -218,7 +218,7 @@ def _tensors_allreduce_with_sparse_ps(degree, mean, allgather, allreduce, allred
         dout = allgather(grad.values)
         if mean:
             dout = F.tensor_mul(dout, F.cast(degree, F.dtype(dout)))
-        grad = RowTensor(indices, dout, grad.dense_shape)
+        grad = RowTensorInner(indices, dout, grad.dense_shape)
     return grad
 
 
@@ -284,7 +284,7 @@ def _tensors_cast_datatype_with_sparse(datatype, grad):
         RowTensor, the gradient after operation.
     """
     dout = F.cast(grad.values, datatype)
-    return RowTensor(grad.indices, dout, grad.dense_shape)
+    return RowTensorInner(grad.indices, dout, grad.dense_shape)
 
 
 class DistributedGradReducer(Cell):
@@ -310,10 +310,19 @@ class DistributedGradReducer(Cell):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> # This example should be run with multiple processes.
-        >>> # Please refer to the Programming Guide > Distributed Training -> Distributed Parallel Usage Example
-        >>> # on mindspore.cn and focus on the contents of these three parts: Configuring Distributed Environment
-        >>> # Variables, Calling the Collective Communication Library, Running The Script.
+        .. note::
+            Before running the following examples, you need to configure the communication environment variables.
+
+            For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
+            Please see the `Ascend tutorial
+            <https://www.mindspore.cn/tutorials/experts/en/r2.0/parallel/train_ascend.html#preparations>`_
+            for more details.
+
+            For the GPU devices, users need to prepare the host file and mpi, please see the `GPU tutorial
+            <https://www.mindspore.cn/tutorials/experts/en/r2.0/parallel/train_gpu.html#preparation>`_ .
+
+            This example should be run with multiple devices.
+
         >>> import numpy as np
         >>> import mindspore as ms
         >>> from mindspore.communication import init
@@ -416,7 +425,7 @@ class DistributedGradReducer(Cell):
         self.mode = context.get_context("mode")
         self.enable_tuple_broaden = True
 
-    @ms_function
+    @jit
     def construct(self, grads):
         """
         Under certain circumstances, the data precision of grads could be mixed with float16 and float32. Thus, the

mindspore/nn/wrap/loss_scale.py

@@ -20,13 +20,15 @@ from mindspore.context import ParallelMode
 from mindspore.parallel._utils import _get_enable_parallel_optimizer
 from mindspore.nn.wrap.cell_wrapper import TrainOneStepCell
 from mindspore.nn.cell import Cell
-from mindspore.common import Tensor, RowTensor
+from mindspore.common import Tensor
+from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.common.parameter import Parameter
+from mindspore.ops.operations.math_ops import NPUGetFloatStatusV2, NPUClearFloatStatusV2
 from mindspore.ops import functional as F
 from mindspore.ops import composite as C
 from mindspore.ops import operations as P
 from mindspore.common import dtype as mstype
-from mindspore.common.api import ms_function
+from mindspore.common.api import jit
 
 _grad_scale = C.MultitypeFuncGraph("grad_scale")
 reciprocal = P.Reciprocal()
@@ -39,9 +41,9 @@ def tensor_grad_scale(scale, grad):
 
 @_grad_scale.register("Tensor", "RowTensor")
 def tensor_grad_scale_row_tensor(scale, grad):
-    return RowTensor(grad.indices,
-                     grad.values * F.cast(reciprocal(scale), F.dtype(grad.values)),
-                     grad.dense_shape)
+    return RowTensorInner(grad.indices,
+                          grad.values * F.cast(reciprocal(scale), F.dtype(grad.values)),
+                          grad.dense_shape)
 
 _grad_overflow = C.MultitypeFuncGraph("_grad_overflow")
 grad_overflow = P.FloatStatus()
@@ -243,7 +245,7 @@ class TrainOneStepWithLossScaleCell(TrainOneStepCell):
             the shape should be :math:`()` or :math:`(1,)`.
 
     Inputs:
-        - **(*inputs)** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
+        - **\*inputs** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
 
     Outputs:
         Tuple of 3 Tensor, the loss, overflow flag and current loss scale value.
@@ -254,7 +256,7 @@ class TrainOneStepWithLossScaleCell(TrainOneStepCell):
 
     Raises:
         TypeError: If `scale_sense` is neither Cell nor Tensor.
-        ValueError: If shape of `scale_sense` is neither (1,) nor ().
+        ValueError: If shape of `scale_sense` is neither :math:`(1,)` nor :math:`()`.
 
     Supported Platforms:
         ``Ascend`` ``GPU``
@@ -308,8 +310,11 @@ class TrainOneStepWithLossScaleCell(TrainOneStepCell):
         super(TrainOneStepWithLossScaleCell, self).__init__(network, optimizer, sens=None)
         self.hyper_map = C.HyperMap()
         self.base = Tensor(1, mstype.float32)
+        self.base0 = Tensor(0, mstype.int32)
         self.reduce_sum = P.ReduceSum(keep_dims=False)
+        self.reduce_any = P.ReduceAny(keep_dims=False)
         self.less_equal = P.LessEqual()
+        self.not_equal = P.NotEqual()
         self.allreduce = P.AllReduce()
         self.is_distributed = (self.parallel_mode != ParallelMode.STAND_ALONE)
         self.gpu_target = (context.get_context("device_target") == "GPU")
@@ -384,22 +389,21 @@ class TrainOneStepWithLossScaleCell(TrainOneStepCell):
               cleared before executing the computation.
 
         Returns:
-            Tuple[object, object], the first value is False for GPU backend, while it is an instance of
-            NPUAllocFloatStatus for other backend. The status is used to detect overflow during `get_overflow_status`.
-            The second value is the same as the input of `compute_input`, but contains some information about the
-            execution order.
+            Tuple[object, object], the first output is used to control the execution sequence. To ensure that the
+            `start_overflow_check` is executed before get_overflow_status after compilation optimization is performed.
+            This value should be used as the first input of get_overflow_status. The second output is the same as
+            the input of compute_input, used to control the execution sequence, and make ensure that the overflow flag
+            is cleaned up when the function returns.
         """
-        status = False
+        status = Tensor([0] * 8, mstype.int32)
         if not self.gpu_target:
-            # init overflow buffer
-            status = P.NPUAllocFloatStatus()()
             status = F.depend(status, pre_cond)
             # clear overflow buffer
-            clear_status = P.NPUClearFloatStatus()(status)
+            clear_status = NPUClearFloatStatusV2()(status)
             compute_input = F.depend(compute_input, clear_status)
         return status, compute_input
 
-    @ms_function
+    @jit
     def get_overflow_status(self, status, compute_output):
         """
         Get floating-point overflow status.
@@ -408,32 +412,45 @@ class TrainOneStepWithLossScaleCell(TrainOneStepCell):
         based on this class can also call this interface to process the overflow.
 
         Args:
-            status (object): A status instance used to detect the overflow.
-            compute_output: Overflow detection should be performed on a certain computation. Set `compute_output`
-              as the output of the computation, to ensure overflow `status` is acquired before executing the
-              computation.
+            status (object): To control the execution sequence with start_overflow_check, it should be set as the first
+              output of start_overflow_check.
+            compute_output: Overflow detection should be performed in a certain computation process. Set
+              `compute_output` as the output of the computation process.
 
         Returns:
             bool, whether the overflow occurs or not.
         """
         if not self.gpu_target:
             status = F.depend(status, compute_output)
-            get_status = P.NPUGetFloatStatus()(status)
-            status = F.depend(status, get_status)
-            # sum overflow buffer elements, 0:not overflow , >0:overflow
-            flag_sum = self.reduce_sum(status, (0,))
+            get_status = NPUGetFloatStatusV2()(status)
+
+            if self.is_distributed:
+                # sum overflow flag over devices
+                flag_reduce = self.allreduce(get_status)
+                # get_status not equal to [0]*8 means overflow
+                flag = self.not_equal(self.base0, flag_reduce)
+                status = F.depend(status, flag)
+                # distributed needs to skip allreduce to avoid its overflow affecting the next step
+                clear_status = NPUClearFloatStatusV2()(status)
+                flag = F.depend(flag, clear_status)
+            else:
+                status = F.depend(status, get_status)
+                clear_status = NPUClearFloatStatusV2()(status)
+                get_status = F.depend(get_status, clear_status)
+                flag = self.not_equal(self.base0, get_status)
+            overflow = self.reduce_any(flag)
         else:
             flag_sum = self.hyper_map(F.partial(_grad_overflow), compute_output)
             flag_sum = P.AddN()(flag_sum)
             # convert flag_sum to scalar
             flag_sum = P.Reshape()(flag_sum, (()))
 
-        if self.is_distributed:
-            # sum overflow flag over devices
-            flag_reduce = self.allreduce(flag_sum)
-            overflow = self.less_equal(self.base, flag_reduce)
-        else:
-            overflow = self.less_equal(self.base, flag_sum)
+            if self.is_distributed:
+                # sum overflow flag over devices
+                flag_reduce = self.allreduce(flag_sum)
+                overflow = self.less_equal(self.base, flag_reduce)
+            else:
+                overflow = self.less_equal(self.base, flag_sum)
         return overflow
 
     def process_loss_scale(self, overflow):

mindspore/numpy/array_creations.py

@@ -22,12 +22,14 @@ import operator
 import numpy as onp
 
 from mindspore import context
+from mindspore import ops
 from mindspore.common import Tensor
 from mindspore.common import dtype as mstype
 from mindspore.common.seed import get_seed
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
-from mindspore.ops.primitive import constexpr
+from mindspore.ops.primitive import constexpr, _primexpr
+from mindspore.ops.function.random_func import _get_seed
 from mindspore.nn.layer.basic import tril as nn_tril
 from mindspore.nn.layer.basic import triu as nn_triu
 from mindspore._c_expression import Tensor as Tensor_
@@ -454,7 +456,8 @@ def randn(*shape, dtype=mstype.float32):
     size = _generate_shapes(shape)
     seed = get_seed()
     if seed is not None:
-        stdnormal = P.StandardNormal(seed=seed)
+        seed1, seed2 = _get_seed(seed, "StandardNormal")
+        stdnormal = P.StandardNormal(seed=seed1, seed2=seed2)
     else:
         stdnormal = P.StandardNormal()
     return stdnormal(size).astype(dtype)
@@ -494,7 +497,8 @@ def rand(*shape, dtype=mstype.float32):
     size = _generate_shapes(shape)
     seed = get_seed()
     if seed is not None:
-        uniformreal = P.UniformReal(seed=seed)
+        seed1, seed2 = _get_seed(seed, "UniformReal")
+        uniformreal = P.UniformReal(seed=seed1, seed2=seed2)
     else:
         uniformreal = P.UniformReal()
     return uniformreal(size).astype(dtype)
@@ -563,7 +567,8 @@ def randint(minval, maxval=None, shape=None, dtype=mstype.int32):
         shape = _check_shape(shape)
     seed = get_seed()
     if seed is not None:
-        uniformint = P.UniformInt(seed=seed)
+        seed1, seed2 = _get_seed(seed, "UniformInt")
+        uniformint = P.UniformInt(seed=seed1, seed2=seed2)
     else:
         uniformint = P.UniformInt()
     t_min = _type_convert(Tensor, minval).astype(dtype)
@@ -971,12 +976,10 @@ def empty(shape, dtype=mstype.float32):
         >>> import mindspore.numpy as np
         >>> output = np.empty((2, 3))
         >>> print(output)
-        Tensor(shape=[2, 3], dtype=Float32, value=
-        <uninitialized>)
+        [[0. 0. 0.]
+         [0. 0. 0.]]
     """
-    shape = _check_shape(shape)
-    dtype = _check_dtype(dtype)
-    return empty_compile(dtype, shape)
+    return ops.zeros(shape, dtype)
 
 
 def _get_shape(array_like):
@@ -1042,8 +1045,10 @@ def empty_like(prototype, dtype=None, shape=None):
         >>> a = np.ones((4,1,2))
         >>> output = np.empty_like(a)
         >>> print(output)
-        Tensor(shape=[4, 1, 2], dtype=Float32, value=
-        <uninitialized>)
+        [[[0. 0.]]
+         [[0. 0.]]
+         [[0. 0.]]
+         [[0. 0.]]]
     """
     return _x_like(prototype, dtype, shape, empty)
 
@@ -1240,6 +1245,13 @@ def tril(m, k=0):
         m = asarray_const(m)
     dtype = m.dtype
     device_target = _device_target()
+    # check rank
+    rank = len(m.shape)
+    if rank < 1:
+        _raise_value_error("input m's rank should be larger than 0")
+    elif rank == 1:
+        mask = tri(m.shape[0], k=k, dtype=mstype.bool_)
+        return where(mask, m, zeros(1, m.dtype))
     # Only Ascend hardware will reduce accuracy
     if device_target == "Ascend":
         m = m.astype(mstype.float32)
@@ -1287,6 +1299,13 @@ def triu(m, k=0):
         m = asarray_const(m)
     dtype = m.dtype
     device_target = _device_target()
+    # check rank
+    rank = len(m.shape)
+    if rank < 1:
+        _raise_value_error("input m's rank should be larger than 0")
+    elif rank == 1:
+        mask = tri(m.shape[0], k=k-1, dtype=mstype.bool_)
+        return where(mask, zeros(1, m.dtype), m)
     # Only Ascend hardware will reduce accuracy
     if device_target == "Ascend":
         m = m.astype(mstype.float32)
@@ -1403,14 +1422,6 @@ def trace(a, offset=0, axis1=0, axis2=1, dtype=None):
         >>> output = np.trace(np.eye(3))
         >>> print(output)
         3.0
-        >>> a = np.arange(8).reshape((2,2,2))
-        >>> output = np.trace(a)
-        >>> print(output)
-        [6 8]
-        >>> a = np.arange(24).reshape((2,2,2,3))
-        >>> output = np.trace(a).shape
-        >>> print(output)
-        (2, 3)
     """
     return a.trace(offset=offset, axis1=axis1, axis2=axis2, dtype=dtype)
 
@@ -1565,7 +1576,7 @@ class NdGrid:
         if self.sparse:
             return grids
 
-        if isinstance(grids, Tensor_):
+        if isinstance(grids, (Tensor, Tensor_)):
             return grids
         expanded = []
         for grid in grids:
@@ -2564,13 +2575,13 @@ def _pad_func(arr, pad_width, func, **kwargs):
     return arr
 
 
-@constexpr
+@_primexpr
 def _make_stat_length(shape):
     """converts the stat_length values."""
     return tuple((shape[i], shape[i]) for i, _ in enumerate(shape))
 
 
-@constexpr
+@_primexpr
 def _limit_stat_length(stat_length, shape):
     """limits the stat_length to current array length along given dimension."""
     return tuple((min(stat_pair[0], shape[i]), min(stat_pair[1], shape[i])) for i, stat_pair in enumerate(stat_length))