mindspore 2.7.0rc1__cp311-cp311-win_amd64.whl → 2.7.1__cp311-cp311-win_amd64.whl

mindspore/ops/operations/debug_ops.py

@@ -13,14 +13,11 @@
 # limitations under the License.
 # ============================================================================
 """debug_ops"""
-import stat
-from pathlib import Path
-
-import numpy as np
+import inspect
 from mindspore import log as logger
 from mindspore._c_expression import security, HookType
 from mindspore._c_expression import TensorPy as Tensor_
-from mindspore._c_expression import _tensordump_process_file
+from mindspore._c_expression import _tensordump_exec
 from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.common.parameter import Parameter
@@ -309,29 +306,17 @@ class TensorDump(Primitive):
         """Initialize TensorDump."""
         if security.enable_security():
             raise ValueError('The TensorDump is not supported, please without `-s on` and recompile source.')
+        if input_output not in ['in', 'out']:
+            raise ValueError(f"The 'input_output' argument should be one of ['in', 'out'], but got: {input_output}")
         self.add_prim_attr("side_effect_io", True)
         self.add_prim_attr("channel_name", "ms_tensor_dump")
 
-    def _save_file(self, file, data):
-        file = Path(file)
-        if file.exists():
-            file.chmod(stat.S_IWUSR)
-        np.save(file, data)
-        file.chmod(stat.S_IRUSR)
-
     def __call__(self, file, input_x):
         validator.check_value_type('file', file, [str], self.__class__.__name__)
         if not file:
             raise ValueError("For 'TensorDump', the input argument[file] cannot be an empty string.")
         validator.check_value_type('input_x', input_x, [Tensor], self.__class__.__name__)
-
-        dtype = input_x.dtype
-        file = _tensordump_process_file(file, str(dtype))
-        if not file:
-            return
-        if dtype == mstype.bfloat16:
-            input_x = P.Cast()(input_x, mstype.float32)
-        self._save_file(file, input_x.asnumpy())
+        _tensordump_exec(file, input_x)
 
 
 class HistogramSummary(Primitive):
@@ -501,13 +486,11 @@ class DumpGradient(Primitive):
     def __init__(self):
         pass
 
-    def _dump_hook(self, dout):
-        P.TensorDump()(self.bwd_dump_path, dout)
-        return dout
-
     def __call__(self, path, x, input_output):
-        self.bwd_dump_path = path
-        x = P.InsertGradientOf(self._dump_hook)(x)
+        def _dump_hook(dout):
+            P.TensorDump()(path, dout)
+            return dout
+        x = P.InsertGradientOf(_dump_hook)(x)
         return x
 
 
@@ -529,14 +512,15 @@ class Morph(PrimitiveWithInfer):
 
     .. note::
         - This primitive is only supported in GRAPH_MODE.
-        - `fn` must satisfy the syntax constraints of the graph mode.
-        - Users do not need to implement a custom backward function.
+        - A user-defined bprop (by argument: `bprop_fn`) is allowed for `Morph`.
+        - `fn` and `bprop_fn` must satisfy the syntax constraints of the graph mode.
         - `vararg`, `kwarg`, `kwonlyargs` and free variables are not supported in user-defined function.
 
     Args:
-        fn (Function): Mindspore's function, user-defined function.
-        infer_shape (Function): Mindspore's function, user-defined infer_shape function.
-        infer_dtype (Function): Mindspore's function, user-defined infer_dtype function.
+        fn (Function): MindSpore's function, user-defined function.
+        infer_shape (Function): MindSpore's function, user-defined infer_shape function.
+        infer_dtype (Function): MindSpore's function, user-defined infer_dtype function.
+        bprop_fn (Function, optional): MindSpore's function, user-defined bprop function, default: ``None``.
 
     Inputs:
         The inputs of user-defined `fn`.
@@ -590,21 +574,35 @@ class Morph(PrimitiveWithInfer):
         >>> weight0_grad = bwd_out[1][0].asnumpy()
         >>> weight1_grad = bwd_out[1][1].asnumpy()
         >>> print("x_grad", x_grad)
-        >>> print("weight0_grad", weight0_grad)
-        >>> print("weight1_grad", weight1_grad)
         x_grad [ 400. 1000. 1800.]
+        >>> print("weight0_grad", weight0_grad)
         weight0_grad [2800. 4000. 5400.]
+        >>> print("weight1_grad", weight1_grad)
         weight1_grad [ 700. 1600. 2700.]
     """
     @prim_attr_register
-    def __init__(self, fn, infer_shape, infer_dtype):
+    def __init__(self, fn, infer_shape, infer_dtype, bprop_fn=None):
         self.add_prim_attr('side_effect_backprop', True)
         self.add_prim_attr('side_effect_mem', True)
         self.add_prim_attr('side_effect_io', True)
-        self.add_prim_attr('__metamorphosis__', fn)
         self._infer_shape = infer_shape
         self._infer_dtype = infer_dtype
 
+        self.add_prim_attr('__metamorphosis__', True)
+        self.__morph_fn__ = fn
+        self.__morph_bprop_fn__ = None
+        if bprop_fn:
+            self._check_fn_supported(fn)
+            self.__morph_bprop_fn__ = bprop_fn
+
+    def _check_fn_supported(self, fn):
+        fn_sig = inspect.signature(fn)
+        for param in fn_sig.parameters.values():
+            if not (param.kind is inspect.Parameter.POSITIONAL_OR_KEYWORD and param.default is inspect.Parameter.empty):
+                raise ValueError(f"When use `bprop` in Morph, Morph `fn` only support positional or keyword parameters "
+                                 f"with default value is empty, but got param '{param.name}' "
+                                 f"of kind '{param.kind.name}' with default value '{param.default}'.")
+
     def infer_shape(self, *args):
         return self._infer_shape(*args)
 

mindspore/ops/operations/manually_defined/ops_def.py

@@ -977,7 +977,7 @@ class ScalarToTensor(PrimitiveWithInfer):
     def __call__(self, x, dtype=mstype.float32):
         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)
+        data_type = mstype._dtype_to_nptype(dtype)  # pylint:disable=protected-access
         return Tensor(np.array(x, data_type), dtype=dtype)
 
 
@@ -1149,7 +1149,7 @@ def scalar_cast(input_x, input_y):
     Args:
         input_x (scalar): The input scalar.
         input_y (mindspore.dtype): The type to be cast. Only constant value is allowed.
-            The value should only be mindspore.int64, mindspore.float64, or mindspore.bool\_.
+            The value should only be mindspore.int64, mindspore.float64, or mindspore.bool.
 
     Returns:
         Scalar, the type is the same as the python type corresponding to `input_y`.
@@ -1294,308 +1294,6 @@ class TypeAs(Primitive):
         return pyboost_type_as(self, [input, other])
 
 
-def to_sequence(val):
-    """
-    to_sequence
-    """
-    if isinstance(val, (tuple, list)):
-        return tuple(val)
-    return (val,)
-
-
-class EmbeddingTableExport(Primitive):
-    """
-    EmbeddingTableExport
-    """
-
-    @prim_attr_register
-    def __init__(self, embedding_dim, value_total_len, export_mode="all",
-                 only_var_flag=False, file_type="bin", table_name=(),
-                 filter_export_flag=False, steps_to_live_list=()):
-        """Initialize EmbeddingTableExport"""
-        self.add_prim_attr("_process_node_engine_id", "PS")
-
-
-class EmbeddingTableImport(Primitive):
-    """
-    EmbeddingTableImport
-    """
-
-    @prim_attr_register
-    def __init__(self, embedding_dim, value_total_len,
-                 only_var_flag=False, file_type="bin", table_name=()):
-        """Initialize EmbeddingTableImport"""
-        self.add_prim_attr("_process_node_engine_id", "PS")
-
-
-class EmbeddingComputeVarImport(Primitive):
-    """
-    EmbeddingComputeVarImport
-    """
-
-    @prim_attr_register
-    def __init__(self, table_name=()):
-        """Initialize EmbeddingComputeVarImport"""
-        self.add_prim_attr("_process_node_engine_id", "PS")
-
-
-class EmbeddingComputeVarExport(Primitive):
-    """
-    EmbeddingComputeVarExport
-    """
-
-    @prim_attr_register
-    def __init__(self, table_name=()):
-        """Initialize EmbeddingComputeVarExport"""
-        self.add_prim_attr("_process_node_engine_id", "PS")
-
-
-class InitEmbeddingHashmap(Primitive):
-    """
-    InitEmbeddingHashmap
-    """
-    @prim_attr_register
-    def __init__(self, value_total_len, embedding_dim, _table_id,
-                 bucket_size=0, dtype=mstype.float32, initializer_mode="",
-                 constant_valu=0., min=-2., max=2., mu=0., sigma=1., seed=0,
-                 seed2=0, filter_mode="no_filter", optimizer_mode="",
-                 optimizer_params=()):
-        self.add_prim_attr("_process_node_engine_id", "PS")
-
-
-def init_embedding_hashmap(table_id, value_total_len, embedding_dim, _table_id,
-                           bucket_size=0, dtype=mstype.float32, initializer_mode='',
-                           constant_value=0.0, min=-2.0, max=2.0, mu=0.0, sigma=1.0,
-                           seed=0, seed2=0, filter_mode='no_filter',
-                           optimizer_mode='', optimizer_params=()):
-    """
-    init_embedding_hashmap
-    """
-    op = _get_cache_prim(InitEmbeddingHashmap)(value_total_len, embedding_dim, _table_id,
-                                               bucket_size, dtype, initializer_mode,
-                                               constant_value, min, max, mu, sigma, seed,
-                                               seed2, filter_mode, optimizer_mode, optimizer_params)
-    return op(table_id)
-
-
-class InitPartitionMap(Primitive):
-    """
-    InitPartitionMap
-    """
-    @prim_attr_register
-    def __init__(self, _embedding_dim, _max_key_num,
-                 _ps_num=1, partition_num=65537):
-        self.add_prim_attr("_process_node_engine_id", "PS")
-
-
-def init_partition_map(ps_num, ps_ids, _embedding_dim, _max_key_num,
-                       _ps_num=1, partition_num=65537):
-    """
-    init_partition_map
-    """
-    op = _get_cache_prim(InitPartitionMap)(_embedding_dim, _max_key_num, _ps_num, partition_num)
-    return op(ps_num, ps_ids)
-
-
-class EmbeddingApplyAdam(Primitive):
-    """
-    EmbeddingApplyAdam
-    """
-    @prim_attr_register
-    def __init__(self, embedding_dim, _max_key_num, mask_zero=(0,),
-                 padding_key=(0,), padding_key_mask=(1,),
-                 completion_key=(0,), completion_key_mask=(1,)):
-        self.add_prim_attr("_process_node_engine_id", "PS")
-
-
-class EmbeddingApplyAdamW(Primitive):
-    """
-    EmbeddingApplyAdam
-    """
-    @prim_attr_register
-    def __init__(self, embedding_dim, _max_key_num, amsgrad=(0,),
-                 maximize=(0,), mask_zero=(0,), padding_key=(0,),
-                 padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,)):
-        self.add_prim_attr("_process_node_engine_id", "PS")
-
-
-class EmbeddingApplyAdaGrad(Primitive):
-    """
-    EmbeddingApplyAdaGrad
-    """
-    @prim_attr_register
-    def __init__(self, embedding_dim, _max_key_num, mask_zero=(0,),
-                 padding_key=(0,), padding_key_mask=(1,),
-                 completion_key=(0,), completion_key_mask=(1,)):
-        self.add_prim_attr("_process_node_engine_id", "PS")
-
-
-class EmbeddingApplyFtrl(Primitive):
-    """
-    EmbeddingApplyFtrl
-    """
-    @prim_attr_register
-    def __init__(self, embedding_dim, _max_key_num, mask_zero=(0,),
-                 padding_key=(0,), padding_key_mask=(1,),
-                 completion_key=(0,), completion_key_mask=(1,)):
-        self.add_prim_attr("_process_node_engine_id", "PS")
-
-
-class EmbeddingTableFind(Primitive):
-    """
-    EmbeddingTableFind
-    """
-    @prim_attr_register
-    def __init__(self, embedding_dim, _embedding_dim, _max_key_num,
-                 _table_id, default_value=(-1.), _use_counter_filter=0):
-        self.add_prim_attr("_process_node_engine_id", "PS")
-        self.add_prim_attr("_execute_times", 2)
-
-
-def embedding_table_find(table_id, keys, embedding_dim, _max_key_num,
-                         _table_id, default_value=(-1.0,), _use_counter_filter=0):
-    r"""
-    embedding_table_find
-    """
-    _embedding_dim = embedding_dim if isinstance(embedding_dim, int) else embedding_dim[_table_id]
-    op = _get_cache_prim(EmbeddingTableFind)(to_sequence(embedding_dim), _embedding_dim,
-                                             _max_key_num, _table_id,
-                                             to_sequence(default_value),
-                                             _use_counter_filter)
-    return op(table_id, keys)
-
-
-class EmbeddingTableFindAndInit(Primitive):
-    """
-    EmbeddingTableFindAndInit
-    """
-    @prim_attr_register
-    def __init__(self, embedding_dim, value_total_len, _embedding_dim, _table_id,
-                 _max_key_num, initializer_mode=("random_uniform",),
-                 constant_value=(0.,), min=(-2.,), max=(2.,), mu=(0.,),
-                 sigma=(1.,), seed=(0,), seed2=(0,),
-                 filter_mode=("no_filter",), filter_freq=(0,),
-                 default_key_or_value=(0,), default_key=(0,),
-                 default_value=(0.,), completion_key=(0,),
-                 completion_key_mask=(1,), optimizer_mode=(),
-                 optimizer_params=(), _use_counter_filter=0,
-                 backward_mode="adam",
-                 backward_int_params=((0,), (0,), (0,), (1,)),
-                 backward_float_params=(0.9, 0.99, 0.001, 0.9, 0.999, 1e-08)):
-        self.add_prim_attr("_process_node_engine_id", "PS")
-        self.add_prim_attr("_execute_times", 2)
-
-
-def embedding_table_find_and_init(table_id, keys, max_grad_norm, parameter, embedding_dim,
-                                  value_total_len, _table_id, _max_key_num,
-                                  initializer_mode=('random_uniform',), constant_value=(0.,),
-                                  min=(-2.,), max=(2.,), mu=(0.,), sigma=(1.,), seed=(0,),
-                                  seed2=(0,), filter_mode=("no_filter",),
-                                  filter_freq=(0,), default_key_or_value=(0,),
-                                  default_key=(0,), default_value=(0.,),
-                                  completion_key=(0,), completion_key_mask=(1,),
-                                  optimizer_mode=(), optimizer_params=(), _use_counter_filter=0,
-                                  backward_mode="adam", backward_int_params=((0,), (0,), (0,), (1,)),
-                                  backward_float_params=(0.9, 0.99, 0.001, 0.9, 0.999, 1e-08)):
-    """
-    embedding_table_find_and_init
-
-    backward_int_params (Union[tuple[tuple[int]], list[list[int]]]):
-        - when the backward_mode is 'adam', 'ftrl' or 'adagrad',
-          it means [[global_step], mask_zero, padding_key, padding_key_mask]
-        - when the backward_mode is 'adamw', it means:
-          [[global_step], amsgrad, maximize, mask_zero, padding_key, padding_key_mask]
-    backward_float_params (Union[tuple[float], list[float]]):
-        - when the backward_mode is 'adam', it means:
-          [beta1_power, beta2_power, lr, beta1, beta2, epsilon]
-        - when the backward_mode is 'ftrl', it means:
-          [lr, lr_power, lambda1, lambda2]
-        - when the backward_mode is 'adamw', it means:
-          [beta1_power, beta2_power, lr, weight_decay, beta1, beta2, epsilon]
-        - when the backward_mode is 'adagrad', it means [lr,]
-    """
-    _embedding_dim = embedding_dim if isinstance(embedding_dim, int) else embedding_dim[_table_id]
-    op = _get_cache_prim(EmbeddingTableFindAndInit)(to_sequence(embedding_dim), to_sequence(value_total_len),
-                                                    _embedding_dim, _table_id, _max_key_num,
-                                                    to_sequence(initializer_mode),
-                                                    to_sequence(constant_value), to_sequence(min),
-                                                    to_sequence(max), to_sequence(mu),
-                                                    to_sequence(sigma), to_sequence(seed),
-                                                    to_sequence(seed2), to_sequence(filter_mode),
-                                                    to_sequence(filter_freq), to_sequence(default_key_or_value),
-                                                    to_sequence(default_key), to_sequence(default_value),
-                                                    to_sequence(completion_key), to_sequence(completion_key_mask),
-                                                    to_sequence(optimizer_mode), to_sequence(optimizer_params),
-                                                    _use_counter_filter,
-                                                    backward_mode, backward_int_params, backward_float_params)
-    return op(table_id, keys, max_grad_norm, parameter)
-
-
-class FakeRemoteLookupUniqued(Primitive):
-
-    """
-    FakeRemoteLookupUniqued
-    """
-    @prim_attr_register
-    def __init__(self, embedding_dim, value_total_len, _embedding_dim, _table_id,
-                 _max_key_num, initializer_mode=('random_uniform',), constant_value=(0.,),
-                 min=(-2.,), max=(2.,), mu=(0.,), sigma=(1.,), seed=(0,), seed2=(0,),
-                 filter_mode=("no_filter",), filter_freq=(0,),
-                 default_key_or_value=(0,), default_key=(0,), default_value=(0.,),
-                 completion_key=(0,), completion_key_mask=(1,),
-                 optimizer_mode=(), optimizer_params=(), _use_counter_filter=0,
-                 backward_mode="adam", backward_int_params=((0,), (0,), (0,), (1,)),
-                 backward_float_params=(0.9, 0.99, 0.001, 0.9, 0.999, 1e-08)):
-        self.add_prim_attr("_process_node_engine_id", "PS")
-        self.add_prim_attr("_execute_times", 2)
-
-
-def fake_remote_lookup_uniqued(table_id, keys, actual_keys_num, unique_indices,
-                               key_count, max_grad_norm, parameter,
-                               embedding_dim, value_total_len, _table_id, _max_key_num,
-                               initializer_mode=('random_uniform',), constant_value=(0.,),
-                               min=(-2.,), max=(2.,), mu=(0.,), sigma=(1.,), seed=(0,),
-                               seed2=(0,), filter_mode=("no_filter",),
-                               filter_freq=(0,), default_key_or_value=(0,),
-                               default_key=(0,), default_value=(0.,),
-                               completion_key=(0,), completion_key_mask=(1,),
-                               optimizer_mode=(), optimizer_params=(), _use_counter_filter=0,
-                               backward_mode='adam', backward_int_params=((0,), (0,), (0,), (1,)),
-                               backward_float_params=(0.9, 0.99, 0.001, 0.9, 0.999, 1e-08)):
-    """
-    fake_remote_lookup_uniqued
-
-    backward_mode (str): determine the optimizer used by backpropagation,
-        valid values are ["adam", "adamw", "adagrad", "ftrl"]
-    backward_int_params (Union[tuple[tuple[int]], list[list[int]]]):
-        - when the backward_mode is 'adam', 'ftrl' or 'adagrad',
-          it means [[global_step], mask_zero, padding_key, padding_key_mask]
-        - when the backward_mode is 'adamw', it means:
-          [[global_step], amsgrad, maximize, mask_zero, padding_key, padding_key_mask]
-    backward_float_params (Union[tuple[float], list[float]]):
-        - when the backward_mode is 'adam', it means:
-          [beta1_power, beta2_power, lr, beta1, beta2, epsilon]
-        - when the backward_mode is 'ftrl', it means:
-          [lr, lr_power, lambda1, lambda2]
-        - when the backward_mode is 'adamw', it means:
-          [beta1_power, beta2_power, lr, weight_decay, beta1, beta2, epsilon]
-        - when the backward_mode is 'adagrad', it means [lr,]
-    """
-    _embedding_dim = embedding_dim if isinstance(embedding_dim, int) else embedding_dim[_table_id]
-    op = _get_cache_prim(FakeRemoteLookupUniqued)(to_sequence(embedding_dim), to_sequence(value_total_len),
-                                                  _embedding_dim, _table_id, _max_key_num,
-                                                  to_sequence(initializer_mode), to_sequence(constant_value),
-                                                  to_sequence(min), to_sequence(max), to_sequence(mu),
-                                                  to_sequence(sigma), to_sequence(seed), to_sequence(seed2),
-                                                  to_sequence(filter_mode), to_sequence(filter_freq),
-                                                  to_sequence(default_key_or_value), to_sequence(default_key),
-                                                  to_sequence(default_value), to_sequence(completion_key),
-                                                  to_sequence(completion_key_mask), to_sequence(optimizer_mode),
-                                                  to_sequence(optimizer_params), _use_counter_filter,
-                                                  backward_mode, backward_int_params, backward_float_params)
-    return op(table_id, keys, actual_keys_num, unique_indices, key_count, max_grad_norm, parameter)
-
-
 # Following is Python Infer Value.
 # A valid infer value function should be:
 #
@@ -1628,7 +1326,13 @@ def infer_value_for_Concat(tensors, axis):
         return None
 
     tensor_to_concat = [x.asnumpy() for x in tensors]
-    return Tensor(np.concatenate(tensor_to_concat, axis), dtype=tensors[0].dtype)
+    out = np.concatenate(tensor_to_concat, axis)
+    if out.dtype != np.float32:
+        return Tensor(out)
+    for x in tensors:
+        if x.dtype in [mstype.float16, mstype.float32]:
+            return Tensor(out)
+    return Tensor(out, dtype=mstype.bfloat16)
 
 
 def infer_value_for_GatherD(input, dim, index):
@@ -1714,7 +1418,7 @@ def infer_value_for_Arange(start, end, step, dtype=None):
         if has_float:
             np_dtype = np.float32
     else:
-        np_dtype = mstype.dtype_to_nptype(typing.type_id_to_type(dtype))
+        np_dtype = mstype._dtype_to_nptype(typing.type_id_to_type(dtype))  # pylint:disable=protected-access
     return Tensor(np.arange(start, end, step, dtype=np_dtype))
 
 
@@ -1738,7 +1442,7 @@ def _infer_value_for_ReduceExtand(input_x, axis, keep_dims, dtype, prim_name):
             else:
                 axis = tuple(range(len(value.shape)))
             if dtype is not None:
-                np_dtype = mstype.dtype_to_nptype(typing.type_id_to_type(dtype))
+                np_dtype = mstype._dtype_to_nptype(typing.type_id_to_type(dtype))  # pylint:disable=protected-access
                 value = np_reduce_extand_func(value, axis, dtype=np_dtype, keepdims=keep_dims)
             else:
                 value = np_reduce_extand_func(value, axis, keepdims=keep_dims)
@@ -1771,7 +1475,7 @@ def infer_value_for_Cast(x, dst_type_enum=None):
     if x is None or dst_type_enum is None:
         return None
     dst_type = typing.type_id_to_type(dst_type_enum)
-    src_type = mstype.get_py_obj_dtype(x)
+    src_type = mstype._get_py_obj_dtype(x)  # pylint:disable=protected-access
     validator.check_subclass("input_x", src_type, [mstype.tensor_type, mstype.number], "Cast")
     validator.check_subclass("type", dst_type, mstype.number, "Cast")
 
@@ -1781,7 +1485,7 @@ def infer_value_for_Cast(x, dst_type_enum=None):
         dst_type = dst_type.element_type()
 
     value = None
-    np_dst_type = mstype.dtype_to_nptype(dst_type)
+    np_dst_type = mstype._dtype_to_nptype(dst_type)  # pylint:disable=protected-access
     if isinstance(x, (int, float)):
         value = Tensor(np.array(x).astype(np_dst_type), dtype=dst_type)
     else:
@@ -1959,11 +1663,27 @@ def infer_value_for_BroadcastTo(x, shape):
         validator.check_value_type("shape", shape, [tuple], "BroadcastTo")
         shape = list(shape)
 
-    np_data = np.broadcast_to(x.asnumpy(), shape)
-    if 0 in shape:
+    # Resolve -1 entries and support input rank < target rank.
+    input_shape = list(x.shape)
+    target_shape = list(shape)
+    in_rank = len(input_shape)
+    out_rank = len(target_shape)
+    for k in range(1, out_rank + 1):
+        t = target_shape[-k]
+        if t == -1:
+            if k <= in_rank:
+                target_shape[-k] = input_shape[-k]
+            else:
+                pass
+
+    resolved_shape = target_shape
+
+    np_data = np.broadcast_to(x.asnumpy(), resolved_shape)
+    if 0 in resolved_shape:
         init_func = Zero()
         init_func.__enable_zero_dim__ = True
-        out = Tensor(shape=shape, dtype=x.dtype, init=init_func)
+        out = Tensor(shape=resolved_shape, dtype=x.dtype, init=init_func)
+        out.init_data()
         return out
     return Tensor(np_data)
 
@@ -2014,6 +1734,7 @@ def infer_value_for_Reshape(x, shape):
             init_func = Zero()
             init_func.__enable_zero_dim__ = True
             out = Tensor(shape=shape, dtype=x.dtype, init=init_func)
+            out.init_data()
         else:
             out = Tensor(x.asnumpy().reshape(shape))
     return out
@@ -2839,8 +2560,8 @@ class WhileLoop(Primitive):
             while cond_func(val):
                 val = loop_func(val)
         except Exception as e:
-            raise ValueError("Invalid loop_func, please check input arguments and \
-                             return value, error info: {}".format(e))
+            raise ValueError(f"Invalid loop_func, please check input arguments and "
+                             f"return value, error info: {e}")
         return val
 
 
@@ -2935,8 +2656,8 @@ class Scan(Primitive):
                 ys.append(y)
                 i = i + 1
         except Exception as e:
-            raise ValueError("Invalid loop_func, please check input arguments and \
-                             return value, error info: {}".format(e))
+            raise ValueError(f"Invalid loop_func, please check input arguments and "
+                             f"return value, error info: {e}")
         return carry, ys
 
 
@@ -3011,6 +2732,6 @@ class ForiLoop(Primitive):
             for i in range(lower, upper):
                 val = loop_func(i, val)
         except Exception as e:
-            raise ValueError("Invalid loop_func, please check input arguments and \
-                             return value, error info: {}".format(e))
+            raise ValueError(f"Invalid loop_func, please check input arguments and "
+                             f"return value, error info: {e}")
         return val

mindspore/ops/operations/math_ops.py

@@ -882,7 +882,7 @@ class Sub(_MathBinaryOp):
     Note:
         - When the two inputs have different shapes, they must be able to broadcast to a common shape.
         - The two inputs can not be bool type at the same time,
-          [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
+          [True, Tensor(True), Tensor(np.array([True]))] are all considered bool type.
         - The two inputs comply with the implicit type conversion rules to make the data types
           consistent.
 
@@ -890,7 +890,7 @@ class Sub(_MathBinaryOp):
         - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
           `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+          `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         - **y** (Union[Tensor, number.Number, bool]) - The second input, when the first input is a Tensor,
           the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool.
 
@@ -1289,10 +1289,10 @@ class DivNoNan(Primitive):
         - **x1** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
           `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+          `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         - **x2** (Union[Tensor, number.Number, bool]) - The second input is a number.Number or
-          a bool when the first input is a bool or a tensor whose data type is number or bool\_.
-          When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.
+          a bool when the first input is a bool or a tensor whose data type is number or bool.
+          When the first input is Scalar, the second input must be a Tensor whose data type is number or bool.
 
     Outputs:
         Tensor, the shape is the same as the one after broadcasting,

mindspore/ops/operations/nn_ops.py

@@ -41,7 +41,7 @@ from ..auto_generate import (CeLU, Flatten, LogSoftmax, LogSoftmaxExt, GLU, ReLU
                              UpsampleNearest3D, UpsampleTrilinear3D,
                              SoftMarginLoss, UpsampleBilinear2D, UpsampleLinear1D,
                              BinaryCrossEntropy, BCEWithLogitsLoss, SoftShrink, AdaptiveMaxPool2D,
-                             SmoothL1Loss)
+                             SmoothL1Loss, KvScaleCache)
 from .manually_defined import BatchNorm
 
 
@@ -6868,8 +6868,8 @@ class CTCLossV2(Primitive):
         >>> print(neg_log_hood)
         [-2.2986124]
         >>> print(log_alpha)
-        [[[0.3       0.3            -inf      -inf      -inf]
-          [1.2       1.8931472 1.2            -inf      -inf]]]
+        [[[0.3       0.3            -inf      -inf 1.8931472 1.2       0.   0.       ]
+          [0.        0.       0.        0.       0.        0.          0.   0.       ]]]
     """
 
     @prim_attr_register