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

mindspore/__init__.py

@@ -20,7 +20,7 @@ from mindspore import common, dataset, mindrecord, train, log, amp
 from mindspore import profiler, communication, numpy, parallel, hal
 from mindspore.common import *
 from mindspore.mindrecord import *
-from mindspore.ops import _op_impl, grad, value_and_grad, vjp, jvp, jacfwd, jacrev, vmap, get_grad, constexpr, reshard
+from mindspore.ops import _op_impl, grad, value_and_grad, vjp, jvp, jacfwd, jacrev, vmap, get_grad, constexpr
 from mindspore.train import *
 from mindspore.log import *
 from mindspore.context import GRAPH_MODE, PYNATIVE_MODE, set_context, get_context, set_auto_parallel_context, \
@@ -36,7 +36,6 @@ from mindspore.safeguard import obfuscate_ckpt, load_obf_params_into_net
 from mindspore._check_jit_forbidden_api import get_obj_module_and_name_info, is_jit_forbidden_module, \
     is_invalid_or_jit_forbidden_method
 from mindspore import _install_custom
-from mindspore import mint
 from mindspore.ops_generate import arg_dtype_cast, arg_handler
 
 __all__ = ["run_check"]

mindspore/_checkparam.py

@@ -1145,8 +1145,21 @@ def check_coo_tensor_dtype(indices_dtype):
                         f"{indices_dtype}.")
 
 
+def check_dynamic_shape(dyn_elem, actual_input, i):
+    """Check the consistency of dynamic shape tensors and actual input tensors."""
+    if dyn_elem.dtype != actual_input.dtype:
+        raise TypeError(f"The data type of '{i}'th args in actual input tensors should be '{dyn_elem.dtype}', " \
+                        f"but got '{actual_input.dtype}'.")
+    if -2 in dyn_elem.shape:
+        return
+    if dyn_elem.ndim != actual_input.ndim:
+        raise ValueError(f"The dimension of '{i}'th args in actual input tensors should be '{dyn_elem.ndim}', " \
+                         f"but got '{actual_input.ndim}'.")
+    check_dyn_shape_value_equal(i, dyn_elem.shape, actual_input.shape)
+
+
 def check_element_type_of_iterable(arg_name, arg_value, valid_types, prim_name=None):
-    """Check type of the element of a iterabel object, except dict."""
+    """Check type of the element of a iterabel object, execpt dict."""
     check_value_type(arg_name, arg_value, [list, tuple], prim_name)
     type_names = [t.__name__ if hasattr(t, '__name__') else str(t) for t in valid_types]
     num_types = len(valid_types)
@@ -1186,6 +1199,14 @@ def check_size_and_element_type_of_tuple(arg_name, arg_value, expect_size, expec
     check_element_type_of_iterable('arg_name', arg_value, [expect_element_type], prim_name)
 
 
+def check_dyn_shape_value_equal(index, dyn_shape, actual_shape):
+    """Check the consistency of dynamic shape and actual input shape."""
+    for i, x in enumerate(dyn_shape):
+        if x not in (-1, actual_shape[i]):
+            raise ValueError(f"The {i}th shape value of `{index}`th actual input args should be `{x}`, but got " \
+                             f"`{actual_shape[i]}`.")
+
+
 def _check_symbol(dyn_input, net_input, index, symbolic_shape_data):
     """Check symbolic shape values."""
     actual_shape = net_input.shape
@@ -1196,10 +1217,9 @@ def _check_symbol(dyn_input, net_input, index, symbolic_shape_data):
         # the value of symbols with same "id" should be equal.
         if "id" in sym:
             sym_id = sym["id"]
-            k_idval = "unique_id_value_map"
-            if k_idval not in symbolic_shape_data:
-                symbolic_shape_data[k_idval] = {}
-            unique_id_value = symbolic_shape_data[k_idval]
+            if "unique_id_value" not in symbolic_shape_data:
+                symbolic_shape_data["unique_id_value"] = {}
+            unique_id_value = symbolic_shape_data["unique_id_value"]
             if sym_id not in unique_id_value:
                 unique_id_value[sym_id] = actual_shape[i]
             elif unique_id_value[sym_id] != actual_shape[i]:

mindspore/_extends/graph_kernel/model/graph_parallel.py

@@ -292,7 +292,7 @@ def block_parallel_estimate(graphs):
 
 def block_parallel_estimate_dvm(graphs):
     """estimate block parallel gain when on Ascend platform"""
-    max_ops = 96
+    max_ops = 100
     total_ops = 0
     bottleneck = 1000
     gain = 1000

mindspore/_extends/parse/__init__.py

@@ -23,7 +23,7 @@ from .parser import (Parser, create_instance, is_supported_create_instance_type,
                      get_ast_type, get_node_type, get_args, get_args_default_values, get_ast_namespace_symbol,
                      get_operation_symbol, get_operation_namespace_symbol, get_parse_method_of_class, get_scope_name,
                      eval_script, get_script_id_attrs, expand_expr_statement, is_class_member_of_self, parse_cb,
-                     convert_to_ms_tensor, get_object_description, get_ms_class_name, get_arg_spec_and_default_values,
+                     convert_to_ms_tensor, get_object_description, get_ms_class_name,
                      is_class_type, check_obj_bool, python_isinstance, ms_isinstance, convert_to_ms_csrtensor,
                      convert_to_ms_cootensor, convert_class_to_function, convert_cell_list_to_sequence, is_cell_list,
                      get_obj_from_sequence, get_type, is_class_member_recursive, get_global_params,
@@ -38,7 +38,7 @@ __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'ge
            'get_ast_type', 'get_node_type', 'get_args', 'get_args_default_values', 'get_ast_namespace_symbol',
            'get_operation_symbol', 'get_operation_namespace_symbol', 'get_parse_method_of_class', 'get_scope_name',
            'eval_script', 'get_script_id_attrs', 'expand_expr_statement', 'is_class_member_of_self', 'parse_cb',
-           'resolve_symbol', 'convert_to_ms_tensor', 'get_object_description', 'get_arg_spec_and_default_values',
+           'resolve_symbol', 'convert_to_ms_tensor', 'get_object_description',
            'get_ms_class_name', 'is_class_type', 'check_obj_bool', 'python_isinstance', 'ms_isinstance',
            'convert_to_ms_csrtensor', 'convert_to_ms_cootensor', 'convert_class_to_function',
            'convert_cell_list_to_sequence', 'is_cell_list', 'get_obj_from_sequence', 'get_type',

mindspore/_extends/parse/compile_config.py

@@ -203,32 +203,6 @@ Value Range:
 """
 TRACE_LABEL_WITH_UNIQUE_ID = ''
 
-"""
-Name: DUMP_IR_DDE_DETAIL
-Function: When generating IR files, whether to print DDE node detail.
-Value Range:
-    1: Print DDE node detail.
-    Default: Only print used flags.
-"""
-DUMP_IR_DDE_DETAIL = ''
-
-"""
-Name: COMBINE_LIKE_GRAPHS
-Function: Whether to combine the func_graphs which have the same object key according to the @cell_attr_register.
-Value Range:
-    0: Disable
-    Default: Enable.
-"""
-COMBINE_LIKE_GRAPHS = ''
-
-"""
-Name: DUMP_VALIDATE_BEFORE_RESET_ID
-Function: Whether to dump validate ir before reset id.
-Value Range:
-    1: Enable
-    Default: Disable.
-"""
-DUMP_VALIDATE_BEFORE_RESET_ID = ''
 
 __all__ = [
     "COMPILE_PROFILE",
@@ -252,7 +226,4 @@ __all__ = [
     "ENABLE_FIX_CODE_LINE",
     "RECORD_MEMORY",
     "TRACE_LABEL_WITH_UNIQUE_ID",
-    "DUMP_IR_DDE_DETAIL",
-    "COMBINE_LIKE_GRAPHS",
-    "DUMP_VALIDATE_BEFORE_RESET_ID",
 ]

mindspore/_extends/parse/namespace.py

@@ -51,9 +51,9 @@ class Namespace:
         return f'Namespace:{self.name}'
 
 
-class ModuleNamespace(Namespace):
+class CellNamespace(Namespace):
     """
-    Namespace for global object.
+    Namespace for Cell object.
 
     Args:
         name (str): Valid module name, it can be imported.

mindspore/_extends/parse/parser.py

@@ -45,7 +45,7 @@ from mindspore.common.parameter import Parameter
 from mindspore.common import mutable
 from mindspore.common._register_for_adapter import ms_adapter_registry
 from mindspore._checkparam import is_stub_tensor
-from .namespace import Namespace, ModuleNamespace, ClosureNamespace, ClassMemberNamespace
+from .namespace import Namespace, CellNamespace, ClosureNamespace, ClassMemberNamespace
 from .resources import parse_object_map, ops_symbol_map, convert_object_map, convert_class_to_function_map, trope_ns
 from .resources import SYMBOL_UNDEFINE, constant_fold_functions
 from ...common.api import _convert_python_data
@@ -546,7 +546,7 @@ def get_module_namespace(obj):
     logger.debug("get module namespace, module: %r", obj)
     mod_namespace = None
     if isinstance(obj, types.ModuleType):
-        mod_namespace = ModuleNamespace(obj.__name__)
+        mod_namespace = CellNamespace(obj.__name__)
     else:
         logger.warning("Module(%r) is invalid, get namespace failure!", obj)
     return mod_namespace
@@ -795,21 +795,6 @@ def get_args(node):
     return args
 
 
-def get_arg_spec_and_default_values(func):
-    """Get the full arg specification and the default arg values of a function"""
-    arg_spec = inspect.getfullargspec(func)
-    defaults = {}
-    args_len = len(arg_spec.args)
-    if arg_spec.defaults:
-        defaults_len = len(arg_spec.defaults)
-        for i in range(defaults_len):
-            defaults[arg_spec.args[args_len - i - 1]] = arg_spec.defaults[defaults_len - i - 1]
-    if arg_spec.kwonlydefaults:
-        for k, v in arg_spec.kwonlydefaults.items():
-            defaults[k] = v
-    return arg_spec, defaults
-
-
 def _convert_stub_tensor(data):
     """Convert stub tensor output to tensor"""
     if is_stub_tensor(data):
@@ -1072,10 +1057,9 @@ def get_method_info(obj):
 
 def is_ms_tensor_method(obj):
     """Check if the obj is a method of MindSpore Tensor"""
-    if not hasattr(obj, '__name__') or not hasattr(Tensor, obj.__name__):
+    if not hasattr(obj, "__self__"):
         return False
-    fn = inspect.unwrap(obj.__func__ if isinstance(obj, types.MethodType) else obj)
-    return fn == getattr(Tensor, obj.__name__)
+    return type(obj.__self__) == Tensor
 
 
 def can_constant_fold(obj):
@@ -1101,7 +1085,7 @@ class Parser:
         self.filename: str = self.fn.__code__.co_filename
 
         # Used to resolve the function's globals namespace.
-        self.global_namespace = ModuleNamespace(self.fn.__module__)
+        self.global_namespace = CellNamespace(self.fn.__module__)
         self.global_namespace.dicts[0]["__ms_tensor_func__"] = tensor
 
         self.function_module = self.fn.__module__

mindspore/_extends/parse/resources.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2024 Huawei Technologies Co., Ltd
+# Copyright 2020-2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -28,12 +28,12 @@ from mindspore.ops.composite import multitype_ops
 from mindspore._c_expression import security
 from . import standard_method as M
 from . import trope as T
-from .namespace import ModuleNamespace
+from .namespace import CellNamespace
 
 # namespace define
-functional_ns = ModuleNamespace('mindspore.ops.functional')
-composite_ns = ModuleNamespace('mindspore.ops.composite')
-trope_ns = ModuleNamespace('mindspore._extends.parse.trope')
+functional_ns = CellNamespace('mindspore.ops.functional')
+composite_ns = CellNamespace('mindspore.ops.composite')
+trope_ns = CellNamespace('mindspore._extends.parse.trope')
 
 SYMBOL_UNDEFINE = 0xFF      # Undefined var and function
 
@@ -171,6 +171,8 @@ if not security.enable_security():
 
 # Convert class object to callable function
 convert_class_to_function_map = {
+    "class 'list'":  M.list_func,
+    "class 'tuple'": M.tuple_func,
     "class 'int'":   M.int_func,
     "class 'float'": M.float_func,
     "class 'bool'":  M.bool_func,

mindspore/_extends/parse/standard_method.py

@@ -20,12 +20,12 @@ from __future__ import absolute_import
 from mindspore import Tensor, CSRTensor, COOTensor
 from mindspore import dtype as mstype
 from mindspore._c_expression import Tensor as Tensor_
-from mindspore.common import mutable
 import mindspore.common._monad as monad
 from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.ops.composite.base import _append, _insert, _pop, _list_clear, _reverse, \
     _extend, _dict_setitem, _dict_clear, _haskey, _update, _fromkeys
 from mindspore.ops.operations._sequence_ops import TensorToTuple
+from mindspore.ops_generate.gen_ops_inner_prim import ListToTuple, TupleToList
 
 from ... import _checkparam as validator
 from ..._checkparam import check_is_number, check_reshape_shp, check_axis_in_range, \
@@ -1812,24 +1812,39 @@ def searchsorted(x, v, side='left', sorter=None):
         2
     """
 
+    def get_log2_size(size):
+        """Get log2 size"""
+        log2_res = F.log2(F.cast(size, mstype.float32))
+        ceil_res = F.ceil(log2_res)
+        cast_res = F.cast(ceil_res, mstype.int64)
+        return cast_res
+
     if side not in ('left', 'right'):
-        raise ValueError(f"For 'Tensor.searchsorted', the argument 'side' should be one of in "
-                            f"['left', 'right'], but got {side}.")
-    if not isinstance(v, Tensor):
+        const_utils.raise_value_error('invalid value for keyword "side"')
+    a = x.astype(mstype.float32)
+    if not check_is_tensor(F.typeof(v)):
         v = const_utils.make_tensor(v)
+    shape = v.shape
     if sorter is not None:
-        if not isinstance(sorter, (int, list, tuple, Tensor)):
-            raise TypeError("For Tensor.searchsorted, the type of the argument 'sorter' must be one of 'int', "
-                            "'list', 'tuple', 'Tensor', but got {}.".format(type(sorter)))
-        if not isinstance(sorter, Tensor):
-            sorter = const_utils.make_tensor(sorter)
-        if sorter.size != x.size:
-            raise ValueError('The size of sorter must be the same as the Tensor')
-
-    dtype = mstype.int32
-    right = (side == 'right')
-    search_sorted_ = P.SearchSorted(dtype, right)
-    return search_sorted_(x, v, sorter)
+        if sorter.ndim != 1 or sorter.size != a.size:
+            const_utils.raise_value_error(
+                'sorter must be 1-D array with the same size as `a`')
+        sorter = const_utils.make_tensor(sorter)
+        sorter = sorter.reshape(sorter.shape + (1,))
+        a = F.gather_nd(a, sorter)
+    less_op = F.tensor_le if side == 'left' else F.tensor_lt
+    i = F.fill(mstype.int32, shape, 0)
+    j = F.fill(mstype.int32, shape, a.size)
+
+    loop_num = get_log2_size(F.shape_mul(a.shape) + 1)
+    index = Tensor([0])
+    while index < loop_num:
+        mid = (i - F.neg(j)) // 2
+        mask = less_op(v, F.gather_nd(a, mid.reshape(mid.shape + (1,))))
+        i = F.select(mask, i, mid)
+        j = F.select(mask, mid, j)
+        index += 1
+    return j
 
 
 def fill(x, value):
@@ -2418,35 +2433,46 @@ def float_func(*data):
     return cast_to_float(data)
 
 
-def list_func(data):
+def list_func(*data):
     """Implementation of `list`."""
+    data_len = len(data)
+    if data_len >= 2:
+        const_utils.raise_type_error("list() requires 0 or 1 arguments.")
+    if data_len == 0:
+        return F.make_list()
+    data = data[0]
+    if isinstance(data, list):
+        return data
+    if isinstance(data, tuple):
+        return TupleToList()(data)
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
-        raise TypeError(
+        const_utils.raise_type_error(
             "list() does not support single sparse tensor input.")
     if isinstance(data, dict):
         data = data.keys()
-    if isinstance(data, (tuple, list)) and F.is_sequence_shape_unknown(data):
-        ret = mutable([], True)
-        if F.is_dynamic_sequence_element_unknown(data):
-            return ret
-    else:
-        ret = F.make_list()
+    ret = F.make_list()
     for i in data:
         ret = ret + F.make_list(i)
     return ret
 
-def tuple_func(data):
+
+def tuple_func(*data):
     """Implementation of `tuple`."""
+    data_len = len(data)
+    if data_len >= 2:
+        raise TypeError("tuple() requires 0 or 1 arguments.")
+    if data_len == 0:
+        return F.make_tuple()
+    data = data[0]
+    if isinstance(data, tuple):
+        return data
+    if isinstance(data, list):
+        return ListToTuple()(data)
     if isinstance(data, (CSRTensor, COOTensor, RowTensorInner)):
         raise TypeError("tuple() does not support single sparse tensor input.")
     if isinstance(data, dict):
         data = data.keys()
-    if isinstance(data, (tuple, list)) and F.is_sequence_shape_unknown(data):
-        ret = mutable((), True)
-        if F.is_dynamic_sequence_element_unknown(data):
-            return ret
-    else:
-        ret = F.make_tuple()
+    ret = F.make_tuple()
     for i in data:
         ret = ret + F.make_tuple(i)
     return ret
@@ -3052,11 +3078,11 @@ def negative(input):
     return F.neg(input)
 
 
-def nonzero(input, as_tuple=False):
+def nonzero(input):
     """
     Return a Tensor of the positions of all non-zero values.
     """
-    return F.nonzero(input, as_tuple)
+    return F.nonzero(input)
 
 
 def new_zeros(x, size, *, dtype=None):
@@ -4353,13 +4379,6 @@ def amax(input, axis=None, keep_dims=False):
     return F.amax(input, axis, keep_dims)
 
 
-def uniform(input, from_=0., to=1., generator=None):
-    r"""
-    Generates random numbers in the half-open interval [from_, to).
-    """
-    return F.uniform_ext(input, from_, to, generator)
-
-
 def amin(input, axis=None, keep_dims=False):
     r"""
     For details, please refer to :func:`mindspore.ops.amin`.

mindspore/amp.py

@@ -20,7 +20,6 @@ from abc import ABC, abstractmethod
 from mindspore.common import mutable
 from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore.ops.operations.math_ops import NPUGetFloatStatusV2, NPUClearFloatStatusV2
-from mindspore.ops.operations.nn_ops import AllFinite
 from mindspore import _checkparam as validator
 from mindspore._c_expression import MSContext
 from .common import dtype as mstype
@@ -59,22 +58,6 @@ def _gpu_target():
     return context.get_context("device_target") == "GPU"
 
 
-@constexpr
-def _enable_all_finite():
-    """check whether enable all finite"""
-    runtime_conf = os.environ.get('MS_DEV_RUNTIME_CONF')
-    global_jit_config = context.get_jit_config()
-    if runtime_conf is not None and ("all_finite:True" in runtime_conf or "all_finite:true" in runtime_conf):
-        return True
-
-    if runtime_conf is not None and ("all_finite:False" in runtime_conf or "all_finite:false" in runtime_conf):
-        return False
-
-    if global_jit_config:
-        return global_jit_config["jit_level"] == "O0" or global_jit_config["jit_level"] == "O1"
-    return False
-
-
 def _grad_unscale(scale, grad):
     return grad * ops.Reciprocal()(scale).astype(grad.dtype)
 
@@ -101,7 +84,7 @@ def _overflow(inputs):
 
 
 @jit
-def _all_finite(inputs, check_overflow_mode, enable_allfinite):
+def _all_finite(inputs, check_overflow_mode):
     """all finite check"""
     if _ascend_target():
         if (_ascend_910a_target()) or \
@@ -115,13 +98,9 @@ def _all_finite(inputs, check_overflow_mode, enable_allfinite):
             status_finite = get_status.equal(Tensor(0, mstype.int32)).all()
             return status_finite
 
-    status_finite = False
-    if enable_allfinite:
-        status_finite = ~AllFinite()(inputs)  # pylint: disable=invalid-unary-operand-type
-    else:
-        outputs = _hypermap(_partial(_overflow), inputs)
-        flag_sum = ops.addn(outputs).reshape(())
-        status_finite = ops.less(flag_sum, 1)
+    outputs = _hypermap(_partial(_overflow), inputs)
+    flag_sum = ops.addn(outputs).reshape(())
+    status_finite = ops.less(flag_sum, 1)
     return status_finite
 
 
@@ -157,7 +136,7 @@ def all_finite(inputs):
     """
     inputs = mutable(inputs)
     _check_overflow_mode = os.environ.get('MS_ASCEND_CHECK_OVERFLOW_MODE')
-    return _all_finite(inputs, _check_overflow_mode, _enable_all_finite())
+    return _all_finite(inputs, _check_overflow_mode)
 
 
 @jit_class

mindspore/boost/adasum.py

@@ -23,7 +23,7 @@ from mindspore.communication.management import create_group
 from mindspore.ops import composite as C
 from mindspore.ops import functional as F
 from mindspore.ops import operations as P
-from mindspore.ops import Send, Receive
+from mindspore.ops.operations._inner_ops import Send, Receive
 
 
 __all__ = ["AdaSum"]

mindspore/boost/base.py

@@ -183,7 +183,7 @@ class ParameterProcess:
     Examples:
         >>> import numpy as np
         >>> from mindspore import Tensor, Parameter, nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore.boost import ParameterProcess
         >>>
         >>> class Net(nn.Cell):

mindspore/boost/boost_cell_wrapper.py

@@ -435,7 +435,7 @@ class BoostTrainOneStepWithLossScaleCell(BoostTrainOneStepCell):
     Examples:
         >>> import numpy as np
         >>> from mindspore import Tensor, Parameter, nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore.nn import WithLossCell
         >>> from mindspore import dtype as mstype
         >>> from mindspore import boost

mindspore/boost/grad_freeze.py

@@ -206,7 +206,7 @@ class GradientFreeze:
     Examples:
         >>> import numpy as np
         >>> from mindspore import Tensor, Parameter, nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore.nn import WithLossCell
         >>> from mindspore import dtype as mstype
         >>> from mindspore import boost
@@ -347,7 +347,7 @@ def freeze_cell(reducer_flag, network, optimizer, sens, grad, use_grad_accumulat
     Examples:
         >>> import numpy as np
         >>> from mindspore import Tensor, Parameter, nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore.boost.grad_freeze import freeze_cell, FreezeOpt
         >>>
         >>> class Net(nn.Cell):

mindspore/boost/less_batch_normalization.py

@@ -96,7 +96,7 @@ class LessBN(Cell):
     Examples:
         >>> import numpy as np
         >>> from mindspore import Tensor, Parameter, nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore.nn import WithLossCell
         >>> from mindspore import dtype as mstype
         >>> from mindspore import boost
@@ -125,14 +125,11 @@ class LessBN(Cell):
     def __init__(self, network, fn_flag=False):
         super(LessBN, self).__init__()
         self.network = network
-        if "less_bn" not in self.network.get_flags():
-            self.network.set_boost("less_bn")
-            self.network.update_cell_prefix()
-            if fn_flag:
-                self._convert_to_less_bn_net(self.network)
-            # Please use this interface with caution as it may cause uncontrollable problem.
-            # The purpose here is to prevent the "less_bn" flag from disappearing.
-            self.network.add_flags(defer_inline=True)
+        self.network.set_boost("less_bn")
+        self.network.update_cell_prefix()
+        if fn_flag:
+            self._convert_to_less_bn_net(self.network)
+        self.network.add_flags(defer_inline=True)
 
     @staticmethod
     def _convert_dense(subcell):

mindspore/common/__init__.py

@@ -15,7 +15,7 @@
 """Top-level reference to dtype of common module."""
 from __future__ import absolute_import
 from mindspore.common import dtype
-from mindspore.common.api import ms_function, ms_memory_recycle, ms_class, jit, jit_class, _no_grad, flops_collection
+from mindspore.common.api import ms_function, ms_memory_recycle, ms_class, jit, jit_class, _no_grad
 from mindspore.common.dtype import Type, int8, byte, int16, short, int32, intc, int64, intp, \
     uint8, ubyte, uint16, ushort, uint32, uintc, uint64, uintp, float16, half, \
     float32, single, float64, bfloat16, double, bool_, float_, list_, tuple_, int_, \
@@ -30,13 +30,9 @@ from mindspore.common.sparse_tensor import RowTensor, RowTensorInner, SparseTens
 from mindspore.common.mutable import mutable
 from mindspore.common.jit_config import JitConfig
 from mindspore.common.lazy_inline import lazy_inline
-from mindspore.common.no_inline import no_inline
 from mindspore.common.mindir_util import load_mindir, save_mindir
 from mindspore.common.symbol import Symbol
 from mindspore.common.recompute import recompute
-from mindspore.common import generator
-from mindspore.common.generator import (
-    Generator, default_generator, seed, manual_seed, initial_seed, get_rng_state, set_rng_state)
 
 # symbols from dtype
 __all__ = [
@@ -75,10 +71,7 @@ __all__.extend([
     "set_dump",
     "ms_memory_recycle",
     "mutable", "JitConfig",
-    "flops_collection",
     "lazy_inline", "load_mindir", "save_mindir",
-    "no_inline",
     "Symbol",
     "recompute"
 ])
-__all__.extend(generator.__all__)

mindspore/common/_register_for_tensor.py

@@ -16,29 +16,30 @@
 """Registry the relation."""
 
 from __future__ import absolute_import
+from collections import UserDict
 from mindspore._c_expression import Tensor as Tensor_
 
 
-class Registry:
-    """Used for tensor operator registration"""
+class Registry(UserDict):
+    """Registry class for registry functions for tensor call primitive ops function."""
 
-    def __init__(self):
-        pass
+    def register(self, obj_str, obj):
+        if isinstance(obj_str, str):
+            self[obj_str] = obj
 
     def get(self, obj_str):
-        """Get property if obj is not vm_compare"""
-
+        """Get the value by str."""
         if not isinstance(obj_str, str):
             raise TypeError("key for tensor registry must be string.")
         if Tensor_._is_test_stub() is True:  # pylint: disable=W0212
             def wrap(*args):
                 new_args = list(args)
                 new_args.append(obj_str)
-                return getattr(self, "vm_compare")(*new_args)
+                return self["vm_compare"](*new_args)
 
             obj = wrap
         else:
-            obj = getattr(self, obj_str)
+            obj = self[obj_str]
         return obj