mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/ops/operations/custom_ops.py

@@ -174,7 +174,7 @@ class Custom(ops.PrimitiveWithInfer):
 
         - "hybrid": supports ["GPU", "CPU"].
         - "akg": supports ["GPU", "CPU"].
-        - "aot": supports ["GPU", "CPU", "ASCEDN"].
+        - "aot": supports ["GPU", "CPU"].
         - "pyfunc": supports ["CPU"].
         - "julia": supports ["CPU"].
 
@@ -193,7 +193,7 @@ class Custom(ops.PrimitiveWithInfer):
 
               1. for "aot":
 
-                 a) GPU/CPU platform.
+                 Currently "aot" supports GPU/CPU(linux only) platform.
                  "aot" means ahead of time, in which case Custom directly launches user defined "xxx.so" file as an
                  operator. Users need to compile a handwriting "xxx.cu"/"xxx.cc" file into "xxx.so" ahead of time,
                  and offer the path of the file along with a function name.
@@ -249,21 +249,6 @@ class Custom(ops.PrimitiveWithInfer):
                        (ex. Custom(func="./reorganize.so:CustomReorganize", out_shape=[1], out_dtype=mstype.float32,
                        "aot"))
 
-                 b) ASCEND platform
-                 Before using Custom operators on the ASCEND platform, users must first develop custom operators
-                 based on Ascend C and compile them. For operator development, you can refer to the tutorial on
-                 `Quick Start for End-to-End Operator Development
-                 <https://www.hiascend.com/document/detail/zh/canncommercial/70RC1/operatordev/Ascendcopdevg/atlas_ascendc_10_0022.html>`_,
-                 and for compiling custom operators, you can use the `Offline Compilation of Ascend C Custom Operators
-                 <https://www.mindspore.cn/tutorials/experts/en/master/operation/op_custom_ascendc.html>` tool.
-                 When passing the operator's name into the func parameter, taking AddCustom as an example for the
-                 name given in the custom operator implementation, there are several ways to use it:
-
-                 - Usin TBE: func="AddCustom"
-                 - Using AclNN: func="aclnnAddCustom"
-                 - Inferring the shape of the operator through C++ derivation: func="infer_shape.cc:aclnnAddCustom",
-                   where infer_shape.cc is the shape derivation implemented in C++.
-
               2. for "julia":
 
                  Currently "julia" supports CPU(linux only) platform.
@@ -338,7 +323,7 @@ class Custom(ops.PrimitiveWithInfer):
             or the attributes of `func` differs in different targets.
 
     Supported Platforms:
-        ``GPU`` ``CPU`` ``ASCEND``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -417,7 +402,6 @@ class Custom(ops.PrimitiveWithInfer):
         self.func_source_str = ""
         self._func_compile_attrs = {}
         self._is_ms_kernel = False
-        self.out_shape = out_shape
 
         self._check_platform()
         self._check_func()
@@ -433,6 +417,7 @@ class Custom(ops.PrimitiveWithInfer):
             add_pyfunc(func_id, self.func)
             self.add_prim_attr("fn_id", func_id)
 
+        self.out_shape = out_shape
         if self.out_shape is None and self.func_type == "aot":
             self.add_prim_attr("cpp_infer_shape", True)
         self.out_dtype = out_dtype
@@ -518,7 +503,6 @@ class Custom(ops.PrimitiveWithInfer):
         return out
 
     def get_bprop(self):
-        """return back propagation function"""
         return self.bprop
 
     def _set_akg_kernel_type(self):
@@ -547,37 +531,7 @@ class Custom(ops.PrimitiveWithInfer):
                 raise Exception("{}, function {} is not found in source file {}!"
                                 .format(self.log_prefix, func, source_file))
 
-    def _check_aot_func(self):
-        """Check the source code and bin lib for aot type custom op"""
-        if not isinstance(self.func, str):
-            raise TypeError("{}, 'func' must be of type str, but got {}".format(
-                self.log_prefix, type(self.func)))
-        file_name_list = self.func.split(":")
-        if len(file_name_list) != 2:
-            if callable(self.out_shape):
-                return
-            raise TypeError(
-                "{}, 'func' should be like 'file_name:func_name', but got {}".format(
-                    self.log_prefix, self.func))
-        file_path = os.path.abspath(file_name_list[0])
-        if os.environ.get('MS_CUSTOM_AOT_WHITE_LIST') is None:
-            if Custom.custom_aot_warning:
-                logger.info("{}, no white list is set and it might cause problems. "
-                            "Set the legal path of the file in MS_CUSTOM_AOT_WHITE_LIST"
-                            .format(self.log_prefix))
-                Custom.custom_aot_warning = False
-        else:
-            legal_path = os.path.abspath(os.environ.get('MS_CUSTOM_AOT_WHITE_LIST'))
-            if legal_path not in file_path:
-                raise TypeError(
-                    "{}, the legal path for the file is {}, but the file is {}".format(
-                        self.log_prefix, legal_path, file_path))
-        if file_path.endswith(("cu", "cpp", "cc")):
-            file_path = _compile_aot(file_path)
-            self.func = file_path + ":" + file_name_list[1]
-
     def _check_platform(self):
-        """check the platform"""
         if platform.system() != 'Linux':
             raise Exception("Custom op only supported on Linux platform currently.")
 
@@ -587,7 +541,30 @@ class Custom(ops.PrimitiveWithInfer):
             raise ValueError("{}, 'func_type' must be one of {}, but got {}"
                              .format(self.log_prefix, self.supported_func_type, self.func_type))
         if self.func_type == "aot":
-            self._check_aot_func()
+            if not isinstance(self.func, str):
+                raise TypeError("{}, 'func' must be of type str, but got {}".format(
+                    self.log_prefix, type(self.func)))
+            file_name_list = self.func.split(":")
+            if len(file_name_list) != 2:
+                raise TypeError(
+                    "{}, 'func' should be like 'file_name:func_name', but got {}".format(
+                        self.log_prefix, self.func))
+            file_path = os.path.abspath(file_name_list[0])
+            if os.environ.get('MS_CUSTOM_AOT_WHITE_LIST') is None:
+                if Custom.custom_aot_warning:
+                    logger.info("{}, no white list is set and it might cause problems. "
+                                "Set the legal path of the file in MS_CUSTOM_AOT_WHITE_LIST"
+                                .format(self.log_prefix))
+                    Custom.custom_aot_warning = False
+            else:
+                legal_path = os.path.abspath(os.environ.get('MS_CUSTOM_AOT_WHITE_LIST'))
+                if legal_path not in file_path:
+                    raise TypeError(
+                        "{}, the legal path for the file is {}, but the file is {}".format(
+                            self.log_prefix, legal_path, file_path))
+            if file_path.endswith(("cu", "cpp", "cc")):
+                file_path = _compile_aot(file_path)
+                self.func = file_path + ":" + file_name_list[1]
 
         elif self.func_type == "julia":
             self._check_julia_func()

mindspore/ops/operations/debug_ops.py

@@ -80,7 +80,7 @@ class ScalarSummary(Primitive):
     Examples:
         >>> import mindspore
         >>> import mindspore.nn as nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor, set_context
         >>>
         >>>
@@ -137,7 +137,7 @@ class ImageSummary(Primitive):
     Examples:
 
         >>> import mindspore.nn as nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>>
         >>>
         >>> class Net(nn.Cell):
@@ -189,7 +189,7 @@ class TensorSummary(Primitive):
     Examples:
         >>> import mindspore
         >>> import mindspore.nn as nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor, set_context
         >>>
         >>>
@@ -329,7 +329,7 @@ class HistogramSummary(Primitive):
     Examples:
         >>> import mindspore
         >>> import mindspore.nn as nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor, set_context
         >>>
         >>>

mindspore/ops/operations/inner_ops.py

@@ -412,7 +412,7 @@ class FusedCastAdamWeightDecay(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor, Parameter
         >>> from mindspore import dtype as mstype
         >>> class Net(nn.Cell):
@@ -542,7 +542,7 @@ class FusedAdaFactor(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor, Parameter
         >>> from mindspore import dtype as mstype
         >>> param_shape = [2, 3, 2]

mindspore/ops/operations/manually_defined/ops_def.py

@@ -1181,309 +1181,6 @@ class Cast(Primitive):
             return output
         return _convert_stub(pyboost_cast(self, [input_x, dtype_to_type_id('Cast', 'dtype', dtype)]))
 
-
-def to_sequence(val):
-    """
-    to_sequence
-    """
-    if isinstance(val, (tuple, list)):
-        return 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:
 #
@@ -1622,6 +1319,9 @@ def infer_value_for_Cast(x, dst_type_enum=None):
     if isinstance(x, (int, float)):
         value = Tensor(np.array(x).astype(np_dst_type), dtype=dst_type)
     else:
+        if x.dtype == mstype.bfloat16:
+            cpu_cast = Cast().set_device("CPU")
+            x = cpu_cast(x, mstype.float32)
         value = Tensor_(x.asnumpy().astype(np_dst_type), dtype=dst_type)
     return value
 
@@ -1877,7 +1577,7 @@ def flash_attention_score(query, key, value, head_num, real_shift=None, drop_mas
 
     .. math::
         \begin{array}{ll} \\
-            y = Dropout(Softmax(Mask(scale_value \mul (real_shift + query * key), attn_mask), -1), keep\_prob) \\
+            y = Dropout(Softmax(Mask(scale_value \mul (real_shift + query * key), attn_mask), -1), keep_prob) \\
             \mul value \\
         \end{array}
 

mindspore/ops/operations/math_ops.py

@@ -40,7 +40,7 @@ from ..auto_generate import (Add, Addcdiv, Addcmul, ReduceMean, ReduceSum, Reduc
                              LinSpace, MatrixDeterminant, LogMatrixDeterminant, Erfinv, Conj,
                              Real, Complex, Angle, MatrixExp, CholeskyInverse, Trace, Cholesky,
                              FFTWithSize, NextAfter, NanToNum, Eig, Qr, Roll, Maximum, Div, DivMod, CumProd,
-                             CumSum, Less, LessEqual, AssignAdd, IsFinite, IsClose, TanhGrad)
+                             CumSum, Less, LessEqual, AssignAdd, IsFinite, TanhGrad)
 
 
 def _infer_shape_reduce(x, axis, keep_dims, prim_name):
@@ -2664,7 +2664,7 @@ class SquareSumAll(Primitive):
     Examples:
         >>> import numpy as np
         >>> import mindspore
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> x = Tensor(np.array([0, 0, 2, 0]), mindspore.float32)
         >>> y = Tensor(np.array([0, 0, 2, 4]), mindspore.float32)
@@ -3881,6 +3881,53 @@ class Igammac(Primitive):
         self.init_prim_io_names(inputs=['a', 'x'], outputs=['z'])
 
 
+class IsClose(Primitive):
+    r"""
+    Returns a tensor of Boolean values indicating whether two input tensors
+    are element-wise equal within a given tolerance.
+
+    Refer to :func:`mindspore.ops.isclose` for more details.
+
+    Args:
+        rtol(float, optional): Relative tolerance. Default: ``1e-05`` .
+        atol(float, optional): Absolute tolerance. Default: ``1e-08`` .
+        equal_nan(bool, optional): If ``True`` , then two NaNs will be considered equal. Default: ``True`` .
+
+    Inputs:
+        - **input** (Tensor) - First tensor to compare, with data type belongs to float32, float16, int32.
+        - **other** (Tensor) - Second tensor to compare, with data type belongs to float32, float16, int32.
+
+    Outputs:
+        Tensor, with the same shape as `input` and `other` after broadcasting, its dtype is bool.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore.ops import IsClose
+        >>> input = Tensor(np.array([1.3, 2.1, 3.2, 4.1, 5.1]), mindspore.float16)
+        >>> other = Tensor(np.array([1.3, 3.3, 2.3, 3.1, 5.1]), mindspore.float16)
+        >>> isclose = IsClose()
+        >>> output = isclose(input, other)
+        >>> print(output)
+        [ True False False False  True]
+    """
+
+    @prim_attr_register
+    def __init__(self, rtol=1e-05, atol=1e-08, equal_nan=True):
+        """Initialize IsClose"""
+        validator.check_value_type('rtol', rtol, [float], self.name)
+        validator.check_value_type('atol', atol, [float], self.name)
+        validator.check_value_type('equal_nan', equal_nan, [bool], self.name)
+        if context.get_context("device_target") == "Ascend" and not equal_nan:
+            raise ValueError("For IsClose, the `equal_nan` must be True on Ascend, but got False.")
+        validator.check_non_negative_float(rtol, 'rtol', self.name)
+        validator.check_non_negative_float(atol, 'atol', self.name)
+
+
 class MatrixSolve(Primitive):
     """
     Solves systems of linear equations.
@@ -4322,7 +4369,7 @@ class Cross(Primitive):
         >>> import numpy as np
         >>> from mindspore import Tensor
         >>> from mindspore import dtype as mstype
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> cross = ops.Cross(dim = 0)
         >>> x1 = Tensor([1, 2, 3], mstype.int8)
         >>> x2 = Tensor([1, 2, 3], mstype.int8)