mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/ops/operations/manually_defined/ops_def.py

@@ -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):
@@ -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

mindspore/ops/operations/nn_ops.py

@@ -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

mindspore/ops/operations/sparse_ops.py

@@ -2606,89 +2606,6 @@ class RaggedTensorToTensor(Primitive):
         self.add_prim_attr("num_row_partition_tensors", self.num_row_partition_tensors)
 
 
-class SparseCross(Primitive):
-    """
-    Generates sparse cross from a list of sparse and dense tensors.
-
-    Args:
-        hashed_output (bool): If true, returns the hash of the cross instead of the string. This will allow us
-                              avoiding string manipulations.
-        num_buckets (int): An int that is >= 0. It is used if "hashed_output" is true.output = hashed_value%num_buckets
-                           if num_buckets > 0 else "hashed_value".
-        hash_key (int): Specify the hash_key that will be used by the "FingerprintCat64" function to combine the
-                        crosses fingerprints.
-        out_type (mindspore.dtype): The output data type. Defaults to "int64".
-        internal_type (mindspore.dtype): An type int64.
-
-    Inputs:
-        - **indices** (list(Tensor)) - A list of Tensor objects with type int64. 2-D.
-          Indices of each input SparseTensor.
-        - **values** (list(Tensor)) - A list of Tensor objects with types from: int64.
-          1-D. values of each SparseTensor.
-        - **shapes** (list(Tensor)) - A list with the same length as indices of Tensor objects with type int64.
-          1-D. Shapes of each SparseTensor.
-        - **dense_inputs** (list(Tensor)) - A list of Tensor objects with types from: int64.
-          2-D. Columns represented by dense Tensor.
-
-    Outputs:
-        - **output_indices** (Tensor) - A Tensor of type int64. 2-D. Indices of the concatenated SparseTensor.
-        - **output_values** (Tensor) - A Tensor of type "out_type". 1-D.
-          Non-empty values of the concatenated or hashed SparseTensor.
-        - **output_shape** (Tensor) - A Tensor of type int64. 1-D. Shape of the concatenated SparseTensor.
-
-    Raises:
-        TypeError: The indices shape rank is not equal to the shape rank.
-        TypeError: The indices element number is not equal to the value element number.
-        TypeError: The indices shape rank should be 2.
-        TypeError: The denses shape rank should be 2.
-        TypeError: The shapes rank should be 2.
-
-    Supported Platforms:
-        ``CPU``
-
-    Examples:
-        >>> from mindspore.ops.operations.sparse_ops import SparseCross
-        >>> indice1 = Tensor([[0,0],[1,0],[1,1]], dtype=mstype.int64)
-        >>> value1 = Tensor([1, 2, 3], dtype=mstype.int64)
-        >>> shape1 = Tensor([2, 2], dtype=mstype.int64)
-        >>> dense1 = Tensor([[1],[2]], dtype=mstype.int64)
-        >>> indice2 = Tensor([[0,0],[1,0],[1,1]], dtype=mstype.int64)
-        >>> value2 = Tensor([1, 2, 3], dtype=mstype.int64)
-        >>> shape2 = Tensor([2, 2], dtype=mstype.int64)
-        >>> dense2 = Tensor([[1],[2]], dtype=mstype.int64)
-        >>> indices = [indice1, indice2]
-        >>> values = [value1, value2]
-        >>> shapes = [shape1, shape2]
-        >>> dense_inputs = [dense1, dense2]
-        >>> hashed_output=True
-        >>> hash_key= 2
-        >>> out_type= mstype.int64
-        >>> internal_type = mstype.int64
-        >>> num_buckets=0
-        >>> sparse_cross = SparseCross(hashed_output, hash_key, out_type, internal_type, num_buckets)
-        >>> out = sparse_cross(indices, values, shapes, dense_inputs)
-        >>> print(out)
-        (Tensor(shape=[5, 2], dtype=Int64, value=
-        [[0, 0],
-        [1, 0],
-        [1, 1],
-        [1, 2],
-        [1, 3]]), Tensor(shape=[5], dtype=Int64, value= [1350190460805457680, 6319552725219729347,
-        4652439303631496997, 7670687697825594049,  174086171018132662]), Tensor(shape=[2], dtype=Int64, value= [2, 4]))
-    """
-
-    @prim_attr_register
-    def __init__(self, hashed_output, hash_key, out_type, internal_type, num_buckets=0):
-        """Initialize SparseCross."""
-        self.init_prim_io_names(inputs=["indices", "values", "shapes", "dense_inputs"],
-                                outputs=["output_indices", "output_values", "output_shape"])
-        validator.check_value_type("hashed_output", hashed_output, [bool], self.name)
-        validator.check_value_type("hash_key", hash_key, [int], self.name)
-        validator.check_value_type("out_type", out_type, [mstype.Type], self.name)
-        validator.check_value_type("internal_type", internal_type, [mstype.Type], self.name)
-        validator.check_value_type("num_buckets", num_buckets, [int], self.name)
-
-
 class RaggedTensorToSparse(Primitive):
     r"""
     Converts a RaggedTensor into a SparseTensor with the same values.

mindspore/ops/primitive.py

@@ -20,7 +20,7 @@ import copy
 import numpy as np
 from mindspore.common.api import _wrap_func
 from mindspore.log import _LogActionOnce
-from mindspore import context, log as logger
+from mindspore import log as logger
 from mindspore.parallel._utils import _is_in_auto_parallel_mode, _is_in_data_parallel_mode, \
     _is_in_hybrid_parallel_mode, SUPPORTED_TUPLE_IN_TUPLE_STRATEGY
 from mindspore.parallel._ps_context import _is_ps_mode, _is_role_sched
@@ -214,22 +214,6 @@ class Primitive(Primitive_):
         if in_strategy is None and out_strategy is not None:
             raise ValueError(f'The out_strategy of {self.name} is {out_strategy}, need to set in_strategy,'
                              f' but got none')
-        if not _is_in_auto_parallel_mode():
-            mode = context.get_auto_parallel_context("parallel_mode")
-            if in_strategy is not None:
-                logger.warning(f"The in_strategy/in_layout of the operator in your network "
-                               f"will not take effect in {mode} mode. "
-                               f"This means the the shard function called in the network is ignored. \n"
-                               f"If you want to enable it, please use semi auto or auto parallel mode by "
-                               f"context.set_auto_parallel_context(parallel_mode=ParallelMode.SEMI_AUTO_PARALLEL "
-                               f"or context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL)")
-            if out_strategy is not None:
-                logger.warning(f"The out_strategy/out_layout of the operator in your network "
-                               f"will not take effect in {mode} mode."
-                               f" This means the the shard function called in the network is ignored. \n"
-                               f"If you want to enable it, please use semi auto or auto parallel mode by "
-                               f"context.set_auto_parallel_context(parallel_mode=ParallelMode.SEMI_AUTO_PARALLEL "
-                               f"or context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL)")
 
     def del_prim_attr(self, name):
         """

mindspore/ops/tensor_method.py

@@ -239,6 +239,7 @@ from mindspore.ops.function.array_func import tensor_scatter_add
 from mindspore.ops.auto_generate import select, select_ext_view
 # 94 sigmoid
 from mindspore.ops.auto_generate import sigmoid
+from mindspore.ops.auto_generate import inplace_sigmoid as sigmoid_
 # 95 sin
 from mindspore.ops.auto_generate import sin
 # 96 size
@@ -366,7 +367,7 @@ from mindspore.ops.auto_generate import acos_ext, acosh_ext, asin_ext, asinh_ext
 from mindspore.ops.function.math_func import median
 
 # 156
-
+from mindspore.ops.function.math_func import permute
 # 157
 from mindspore.ops.auto_generate import xlogy_op
 
@@ -1040,6 +1041,10 @@ def tensor_sigmoid(input):
     return sigmoid(input)
 
 
+def tensor_sigmoid_(input):
+    return sigmoid_(input)
+
+
 # 95 sin
 def tensor_sin(input):
     return sin(input)
@@ -1137,6 +1142,7 @@ def deprecated_tensor_sum(input, axis=None, dtype=None, keepdims=False, initial=
 
 # 105 swapaxes
 
+
 # 106 t
 def tensor_t(input):
     return t(input)
@@ -1165,6 +1171,7 @@ def deprecated_tensor_tile(input, reps):
 
 # 109 tolist
 
+
 # 110 topk
 def tensor_topk(input, k, dim=-1, largest=True, sorted=True):
     return topk(input, k, dim, largest, sorted)
@@ -1184,6 +1191,11 @@ def deprecated_tensor_transpose(input, *axes):
     return transpose(input, perm)
 
 
+def deprecated_tensor_permute(input, *axis):
+    perm = validator.check_transpose_axis(axis, input.ndim)
+    return permute(input, perm)
+
+
 # 112 tril
 def deprecated_tensor_tril(input, diagonal=0):
     return tril(input, diagonal)
@@ -1196,6 +1208,7 @@ def tensor_trunc(input):
 
 # 114 type
 
+
 # 115 type_as
 def deprecated_tensor_type_as(input, other):
     return input.astype(other.dtype)
@@ -1511,12 +1524,18 @@ def deprecated_tensor_logaddexp2(input, other):
 
 
 # 157
-def tensor_empty(*size, dtype=None, device=None):
+def tensor_empty(*size, dtype=None, device=None, pin_memory=False):
+    r"""
+    For details, please refer to :func:`mindspore.mint.empty`.
+    """
     logger.error(
         "This is a function for empty not should be called. Please check the implementation.")
 
 
-def tensor_empty_like(input, *, dtype=None, device=None):
+def tensor_empty_like(input, *, dtype=None, device=None, pin_memory=False):
+    """
+    For details, please refer to :func:`mindspore.mint.empty_like`.
+    """
     raise NotImplementedError(
         "This is a function for empty_like should not be called. Please check the implementation.")
 
@@ -1811,10 +1830,19 @@ def deprecated_tensor_var(input, axis=None, ddof=0, keepdims=False):
     return _tensor_div(x_sum, nums - ddof)
 
 
+# 1222
+def tensor_index_fill_(input, dim, index, value):
+    raise NotImplementedError('Tensor.index_fill_ only supports Ascend.')
+
+
 def tensor_kthvalue(input, k, dim=-1, keepdim=False):
     raise ValueError("should not come here for kthvalue py_method.")
 
 
+def tensor_index_copy_(input, dim, index, tensor):
+    raise NotImplementedError('Tensor.index_copy_ only supports Ascend.')
+
+
 def tensor_sub_empty_(input, other, alpha=1):
     raise ValueError("should not come here for sub_ method.")
 
@@ -1824,9 +1852,11 @@ def tensor_inplace_sub(input, other, *, alpha=1):
         return sub(input, other)
     return sub_ext(input, other, alpha=alpha)
 
+
 def tensor_new_full(input, size, fill_value, *, dtype=None):
     raise NotImplementedError("new_full method support Ascend only")
 
+
 def tensor_div_empty_(input, other, rounding_mode=None):
     raise ValueError("should not come here for div_ method.")
 
@@ -1858,6 +1888,10 @@ def all_gather_matmul(
     raise NotImplementedError('all_gather_matmul only supports Ascend.')
 
 
+def conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
+    raise NotImplementedError('conv1d only supports Ascend.')
+
+
 def conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
     raise NotImplementedError('conv3d only supports Ascend.')
 
@@ -1926,11 +1960,46 @@ def tensor_quant_matmul(x1, x2, scale, *, offset=None, pertoken_scale=None, bias
     raise NotImplementedError('quant_matmul only supports Ascend.')
 
 
+def tensor_index(input, value):
+    raise NotImplementedError("index only supports Ascend.")
+
+
 def tensor_gmm(x, weight, *, bias=None, group_list=None, group_type=0, group_list_type=0):
     raise NotImplementedError("gmm has not been implemented by python.")
 
+
 def raise_func(*args, **kwargs):
     raise NotImplementedError("this func has not been implemented.")
 
+
 def tensor_masked_scatter(input, mask, source):
     return masked_scatter(input, mask, source)
+
+
+def tensor_inplace_masked_scatter(input, mask, source):
+    return F.inplace_masked_scatter(input, mask, source)
+
+
+def tensor_broadcast_to(x, shape):
+    return F.broadcast_to(x, shape)
+
+def tensor_squeeze(input, axis=None):
+    return F.squeeze(input, axis)
+
+
+def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
+    raise NotImplementedError('conv2d only supports Ascend.')
+
+
+def tensor_real(input):
+    r"""
+    For details, please refer to :func:`mindspore.ops.real`.
+    """
+    return ops.real(input)
+
+
+def tensor_imag(input):
+    r"""
+    For details, please refer to :func:`mindspore.ops.imag`.
+    """
+    return ops.imag(input)