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

mindspore/common/api.py

@@ -52,6 +52,7 @@ from mindspore.common._register_for_adapter import ms_adapter_registry
 from mindspore.common.auto_dynamic_shape import get_auto_dynamic_shape_args, update_auto_dynamic_shape_phase, \
     get_auto_dynamic_shape_args_with_check_input_signature, update_auto_dynamic_shape_phase_with_check_input_signature
 
+
 # Store ms_function class compiled pipeline cache.
 ms_compile_cache = set()
 # Store cell compiled pipeline cache.
@@ -62,67 +63,13 @@ function_phases = dict()
 BROADCAST_PHASE = "_broadcast_"
 _PYNATIVE_PARALLEL_FUNC_NAME = "after_shard"
 
-ARG_SPECIFIED = "arg_specified_infos"
-TOTAL_ARG_LEN = "total_arg_length"
-
-
-def _check_recompile_args(compile_args, kwargs):
-    """Check recompile of graph"""
-
-    def _check_constant_tensor_arg(arg):
-        if hasattr(arg, "__ms_mutable__"):
-            return False
-        if isinstance(arg, (list, tuple)):
-            return any(_check_constant_tensor_arg(x) for x in arg)
-        return isinstance(arg, Tensor)
-
-    for v in kwargs.values():
-        compile_args += (v,)
-    for arg in compile_args:
-        if not isinstance(arg, tuple) and not isinstance(arg, list):
-            continue
-        if _check_constant_tensor_arg(arg):
-            logger.warning(f"Constant value tensor are detected in tuple or list, which might cause recompiling "
-                           f"when tensor value changes. You can use mutable(Tensor) or mutable(tuple(Tensor)) "
-                           f"to set tensor's value as variable to to avoid recompiling. The tuple or list arg "
-                           f"is: {arg} .")
-            return
-
-
-def _check_recompile(obj, compile_args, kwargs, full_function_name, create_time, echo_function_name):
-    """Warning when the function has been compiled."""
-    ignore_dirs = ["mindspore/ops", "mindspore/nn"]
-    if any((lambda x: x in full_function_name)(x) for x in ignore_dirs):
-        return
-
-    if full_function_name in function_phases:
-        warning_times = 1
-        if len(function_phases[full_function_name]) >= warning_times \
-                and create_time not in function_phases[full_function_name]:
-            if isinstance(obj, ms.nn.Cell):
-                tips = f"Please try to create {echo_function_name} instance only once to avoid recompiling. "
-                logger.info(f"The {echo_function_name} has been compiled again. "
-                            f"{tips} ")
-            else:
-                tips = "Try to decorate the function with @jit(hash_args=...) " \
-                       "or @jit(compile_once=True) to reduce the compile time. " \
-                       "For more details, get instructions about `jit` at " \
-                       "https://www.mindspore.cn/search?inputValue=jit."
-                logger.warning(f"The {echo_function_name} has been compiled again. "
-                               f"{tips} ")
-        else:
-            _check_recompile_args(compile_args, kwargs)
-    else:
-        function_phases[full_function_name] = set()
-    function_phases[full_function_name].add(create_time)
-
 
 def _ms_adapter_tensor_as_parameter_output(data):
     """Check whether the data is an output from a parameter which is a ms_adapter tensor.
        Pylint: disable=unidiomatic-typecheck.
     """
     return ms_adapter_registry.is_registered and isinstance(data, ms_adapter_registry.tensor) \
-        and hasattr(data, "__ms_parameter_output__") and getattr(data, "__ms_parameter_output__")
+           and hasattr(data, "__ms_parameter_output__") and getattr(data, "__ms_parameter_output__")
 
 
 def _convert_python_data(data):
@@ -137,7 +84,7 @@ def _convert_python_data(data):
     """
     if isinstance(data, (Tensor, PythonTensor)) and data.adapter_flag:
         return ms_adapter_registry.tensor(data)
-    if _ms_adapter_tensor_as_parameter_output(data) and hasattr(data, "tensor"):
+    if _ms_adapter_tensor_as_parameter_output(data):
         return data.tensor
     if isinstance(data, Tensor) and not isinstance(data, PythonTensor):
         return PythonTensor(data, internal=True)
@@ -231,7 +178,6 @@ def _handle_func_args(func, *args, **kwargs):
 
 sys_path = list(sys.path)
 # Get the entry script path.
-entry_script_path = None
 if sys.argv and sys.argv[0] != '':
     entry_script_path = os.path.realpath(sys.argv[0])
     entry_script_path_dir = os.path.split(entry_script_path)[0]
@@ -401,118 +347,6 @@ def _get_args_for_run_predict(obj, args, kwargs, compile_args):
     return new_args
 
 
-def _is_args_fullmode(args, is_init=True):
-    """Check whether the arguments is for incremental-mode.
-
-    Args:
-        args (Union[list, tuple, dict, Tensor]): Given arguments.
-        is_init (bool): Is check in argument initialization phase.
-
-    Raises:
-        RuntimeError: loss necessary keys and values for incremental-mode.
-
-    Returns:
-        bool: Fullmode or not.
-    """
-    if not isinstance(args, dict):
-        return True
-    if not is_init and (args.get(ARG_SPECIFIED, None) is None or args.get(TOTAL_ARG_LEN, None) is None):
-        raise RuntimeError(
-            "The incremental inputs should be processed(with \"%s\" and \"%s\"), but got %s." %
-            (ARG_SPECIFIED, TOTAL_ARG_LEN, str(args)))
-    return False
-
-
-def _process_dyn_args(fn, dyn_args):
-    """Process the dynamic arguments, return the necessary data for latter processing.
-
-    Args:
-        fn (Function): The root function to compile.
-        dyn_args (Union[dict, list, tuple, None]): Given arguments for dynamic compilation.
-            None for nothing, list or tuple for fullmode setting, dict for incremental configuration.
-
-    Returns:
-        A dict which contains args for dynamic compilation. None for nothing dynamic.
-    """
-    if dyn_args is None:
-        # nothing should be done for None.
-        return dyn_args
-
-    if isinstance(dyn_args, dict) and ARG_SPECIFIED in dyn_args:
-        return dyn_args
-
-    args_sig = inspect.signature(fn)
-    if _is_args_fullmode(dyn_args):
-        if not isinstance(dyn_args, (list, tuple)):
-            temp_dyn_args = (dyn_args,)
-        else:
-            temp_dyn_args = dyn_args
-
-        # If dyn_args is fullmode, it should be apply directly.
-        args_sig_parameters = list(args_sig.parameters.values())
-        if not args_sig_parameters:
-            return ()
-
-        # fn may be Cell's construct while the first input is 'self'.
-        if args_sig_parameters[0].name == "self" and (len(temp_dyn_args) + 1) == len(args_sig_parameters):
-            bound_args = args_sig.bind(None, *temp_dyn_args)
-            bound_args.apply_defaults()
-            return bound_args.args[1:]
-
-        bound_args = args_sig.bind(*temp_dyn_args)
-        bound_args.apply_defaults()
-        return bound_args.args
-
-    # The dyn_args is not fullmode, a real compilation arguments should be assembled by latter procession...
-    arg_names = []
-    args_sig_parameters = list(args_sig.parameters.values())
-    for arg_p in args_sig_parameters:
-        if arg_p.kind in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD):
-            arg_names.append(arg_p.name)
-        else:
-            raise TypeError("Dynamic arguments is not accepted for VAR_POSITIONAL or VAR_KEYWORD parameters!")
-
-    offset = -1 if fn.__name__ == 'construct' and args_sig_parameters[0].name == "self" else 0
-    meet_index = set()
-
-    def _check_index_valid(index):
-        if index >= len(arg_names):
-            raise ValueError("For dict mode, valid index is \"0\"-\"%d\", but got %s!" % (len(arg_names) - 1, index))
-        if index in meet_index:
-            raise ValueError("For dict mode, there are more than one same specified key for real index: %d!" % index)
-        meet_index.add(index)
-
-    arg_handler_infos = []
-    for k, v in dyn_args.items():
-        if not isinstance(k, str):
-            raise TypeError("For dict mode, only string key is accepted, but got %s!" % k)
-        if k in arg_names:
-            cur_id = arg_names.index(k)
-            _check_index_valid(cur_id)
-            arg_handler_infos.append([cur_id + offset, v])
-        else:
-            raise ValueError("For dict mode, valid key is %s, but got %s!" % (arg_names, k))
-    return {ARG_SPECIFIED: arg_handler_infos, TOTAL_ARG_LEN: len(args_sig_parameters)}
-
-
-def _generate_dyn_compile_args(compile_args, dyn_args):
-    """Generate the dynamic compile arguments."""
-    if not dyn_args:
-        return compile_args
-    if _is_args_fullmode(dyn_args, False):
-        if not isinstance(dyn_args, (list, tuple)):
-            return (dyn_args,)
-        return dyn_args
-    arg_specified_infos = dyn_args.get(ARG_SPECIFIED, None)
-    if arg_specified_infos is None:
-        raise RuntimeError("For dict mode, a key with \"%s\" should exist, but got %s!" %
-                           (ARG_SPECIFIED, str(dyn_args)))
-    new_compile_args = list(compile_args)
-    for index, arg in arg_specified_infos:
-        new_compile_args[index] = arg
-    return tuple(new_compile_args)
-
-
 class _MindsporeFunctionExecutor:
     """
     Represents a function compiled by graph compiler.
@@ -530,7 +364,6 @@ class _MindsporeFunctionExecutor:
     Returns:
         The result of pipeline running in graph mode.
     """
-
     def __init__(self, fn, ms_create_time, input_signature=None, obj=None, jit_config=None):
         init_pipeline()
         if not isinstance(fn, (types.FunctionType, types.MethodType)):
@@ -548,6 +381,7 @@ class _MindsporeFunctionExecutor:
         self._compile_args = None
         self.jit_config_dict = jit_config.jit_config_dict if jit_config else None
 
+
     @_wrap_func
     def __call__(self, *args, **kwargs):
         args_list = args
@@ -575,6 +409,7 @@ class _MindsporeFunctionExecutor:
 
         return output
 
+
     def compile(self, method_name, *args, **kwargs):
         """Returns pipeline for the given args."""
         # Check whether hook function registered on Cell object.
@@ -635,7 +470,7 @@ class _MindsporeFunctionExecutor:
             self._graph_executor.clear_compile_arguments_resource()
             return phase
 
-        _check_recompile(self.obj, compile_args, kwargs, full_function_name, create_time, echo_function_name)
+        self._check_recompile(full_function_name, create_time, echo_function_name)
 
         # If enable compile cache, get the dependency files list and set to graph executor.
         self._set_compile_cache_dep_files()
@@ -667,6 +502,31 @@ class _MindsporeFunctionExecutor:
 
         return phase
 
+
+    @staticmethod
+    def _check_recompile(full_function_name, create_time, echo_function_name):
+        """Warning when the function has been compiled."""
+        ignore_dirs = ["mindspore/ops", "mindspore/nn"]
+        if any((lambda x: x in full_function_name)(x) for x in ignore_dirs):
+            return
+
+        if full_function_name in function_phases:
+            warning_times = 1
+            if len(function_phases[full_function_name]) >= warning_times \
+                    and create_time not in function_phases[full_function_name]:
+                tips = "Try to decorate the function with @jit(hash_args=...) " \
+                       "or @jit(compile_once=True) to reduce the compile time. " \
+                       "For more details, get instructions about `jit` at " \
+                       "https://www.mindspore.cn/search?inputValue=jit."
+
+                logger.warning(f"The {echo_function_name} has been compiled again. "
+                               f"{tips} ")
+        else:
+            function_phases[full_function_name] = set()
+
+        function_phases[full_function_name].add(create_time)
+
+
     @staticmethod
     def _optimizer_state_init(opt_states):
         """set data for all optimizer states in case it is executed in graph mode"""
@@ -677,6 +537,7 @@ class _MindsporeFunctionExecutor:
             if opt_param.has_init and (prefix in prefix_list or opt_param.name == "global_step"):
                 opt_param.init_data()
 
+
     def _get_key_id(self):
         """get key id."""
         if isinstance(self.obj, ms.nn.Cell):
@@ -688,6 +549,7 @@ class _MindsporeFunctionExecutor:
             key_id = key_id + ".grad"
         return key_id
 
+
     def _get_generate_name(self):
         """get generate name."""
         generate_name = self.fn.__module__ + "." + self.fn.__name__ + "." + self.fn.__code__.co_filename + "." + str(
@@ -700,47 +562,56 @@ class _MindsporeFunctionExecutor:
             generate_name = generate_name[:generate_name.rfind(str(id(self.fn)))] + str(id(self.shard_parent_obj))
         return generate_name, echo_function_name
 
+
     def _set_compile_cache_dep_files(self):
         # If enable compile cache, get the dependency files list
         enable_compile_cache = context.get_context("enable_compile_cache")
-        if enable_compile_cache is None:
+        if enable_compile_cache is not True and enable_compile_cache != "1":
             enable_compile_cache = os.getenv('MS_COMPILER_CACHE_ENABLE')
         if enable_compile_cache is True or enable_compile_cache == "1":
             self._graph_executor.set_compile_cache_dep_files(_get_compile_cache_dep_files())
 
+
     def _generate_compile_args(self, args_list):
         """Chose dynamic shape tensors or actual input tensors as compile args."""
         # Case: If the shape of input args is dynamic, get dynamic shape tensor from context and use it to compile.
         compile_args = _pynative_executor.get_dynamic_input(args_list)
         # Case: The `set_inputs()` of Cell object has been set, using these dynamic shape args as compile args.
         if self.fn.__name__ == 'construct' and isinstance(self.obj, ms.nn.Cell) and self.obj.get_inputs():
-            compile_args = _generate_dyn_compile_args(args_list, self.obj.get_inputs())
+            compile_args = self.obj.get_inputs()
             if len(compile_args) != len(args_list):
                 raise ValueError(f"The number of actual input tensors: {len(args_list)} is not equal to the number of "
                                  f"dynamic shape tensors: {len(compile_args)}.")
-            self._graph_executor.check_argument_consistency(compile_args, args_list, "input_signature")
+            for i, elem in enumerate(compile_args):
+                if isinstance(elem, PythonTensor):
+                    Validator.check_dynamic_shape(compile_args[i], args_list[i], i)
             Validator.check_symbolic_shape(compile_args, args_list)
 
         # Case: If dynamic shape tensors have been assigned to `input_signature`, they are preferred as compile args.
         if self.input_signature is not None:
-            compile_args = list(_generate_dyn_compile_args(args_list, self.input_signature))
-            dyn_shape = any([is_shape_unknown(elem.shape) for elem in compile_args if isinstance(elem, PythonTensor)])
+            if not isinstance(self.input_signature, (tuple, list)):
+                self.input_signature = (self.input_signature,)
+            self.input_signature = list(self.input_signature)
+            dyn_shape = False
+            for i, elem in enumerate(self.input_signature):
+                if isinstance(elem, PythonTensor) and is_shape_unknown(elem.shape):
+                    Validator.check_dynamic_shape(self.input_signature[i], args_list[i], i)
+                    dyn_shape = True
             Validator.check_symbolic_shape(self.input_signature, args_list)
             if dyn_shape:
                 # Checkout whether the `sens` has been added to args_list.
-                if len(compile_args) == len(args_list) - 1:
+                if len(self.input_signature) == len(args_list) - 1:
                     logger.warning(f"The number of actual input args '{len(args_list)}' is one more than the number "
-                                   f"of input_signature args '{len(compile_args)}'. The last actual args may "
+                                   f"of input_signature args '{len(self.input_signature)}'. The last actual args may "
                                    f"be 'sens' and added it to compile args.")
-                    compile_args.append(args_list[-1])
-                compile_args = tuple(compile_args)
-                self._graph_executor.check_argument_consistency(compile_args, args_list, "input_signature")
+                    self.input_signature.append(args_list[-1])
+                compile_args = tuple(self.input_signature)
                 if self.obj is not None:
                     _pynative_executor.set_dynamic_input(self.obj, *compile_args)
                 else:
                     _pynative_executor.set_dynamic_input(self.fn, *compile_args)
             else:
-                if not verify_inputs_signature(compile_args, args_list):
+                if not verify_inputs_signature(self.input_signature, args_list):
                     raise ValueError("The input args is incompatible with the args in `input_signature`!")
         return compile_args
 
@@ -783,18 +654,6 @@ def _get_jit_hash(hash_input):
     return _get_obj_id(hash_input)
 
 
-def _update_graph_executor_config(jit_config):
-    """Update GraphExecutor jit_config"""
-    if isinstance(jit_config, JitConfig):
-        jit_config = jit_config.jit_config_dict
-    if not isinstance(jit_config, dict):
-        return
-    valid_config = dict()
-    for k, v in jit_config.items():
-        valid_config[str(k)] = str(v)
-    GraphExecutor_.get_instance().set_jit_config(JitConfig(**valid_config).jit_config_dict)
-
-
 def jit(fn=None, mode="PSJit", input_signature=None, hash_args=None, jit_config=None, compile_once=False):
     """
     Create a callable MindSpore graph from a Python function.
@@ -805,23 +664,13 @@ def jit(fn=None, mode="PSJit", input_signature=None, hash_args=None, jit_config=
         fn (Function): The Python function that will be run as a graph. Default: ``None`` .
         mode (str): The type of jit used, the value of mode should be ``PIJit`` or ``PSJit``. Default: ``PSJit`` .
 
-            - `PSJit <https://www.mindspore.cn/docs/en/master/note/static_graph_syntax_support.html>`_ :
-              Parse python ast to build graph.
-            - `PIJit <https://www.mindspore.cn/docs/en/master/design/dynamic_graph_and_static_graph.html>`_ :
-              Parse python bytecode to build graph at runtime.
-
-        input_signature (Union[Tuple, List, Dict, Tensor]): The Tensor which describes the input arguments. The
-            shape and dtype of the Tensor will be supplied to this function. If `input_signature` is specified, the
-            input parameters of `fn` cannot accept `**kwargs`, and the shape and dtype of actual inputs should keep the
-            same as `input_signature`. Otherwise, TypeError will be raised. There are two mode for `input_signature`:
-
-            - Full mode: Arguments is a Tuple, List or a Tensor, and they will be used as all compile inputs
-              for graph-compiling.
-            - Incremental mode: Argument is a Dict, and they will set to some of the graph inputs, which will be
-              substituted into the input at the corresponding position for graph-compiling.
-
-            Default: ``None`` .
+            - `PSJit <https://www.mindspore.cn/docs/en/master/note/static_graph_syntax_support.html>`_ : MindSpore GRAPH_MODE.
+            - `PIJit <https://www.mindspore.cn/docs/en/master/design/dynamic_graph_and_static_graph.html>`_ : MindSpore PYNATIVE_MODE.
 
+        input_signature (Tensor): The Tensor which describes the input arguments. The shape and dtype of the Tensor
+            will be supplied to this function. If input_signature is specified, each input to `fn` must be a `Tensor`.
+            And the input parameters of `fn` cannot accept `**kwargs`. The shape and dtype of actual inputs should
+            keep the same as input_signature. Otherwise, TypeError will be raised. Default: ``None`` .
         hash_args (Union[Object, List or Tuple of Objects]): The local free variables used inside `fn`,
             like functions or objects of class defined outside `fn`. Calling `fn` again with change of `hash_args`
             will trigger recompilation. Default: ``None`` .
@@ -877,13 +726,6 @@ def jit(fn=None, mode="PSJit", input_signature=None, hash_args=None, jit_config=
         ...
         >>> out = tensor_add_with_sig(x, y)
         ...
-        >>> @jit(input_signature={"y": Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))})
-        ... def tensor_add_with_sig_1(x, y):
-        ...     z = x + y
-        ...     return z
-        ...
-        >>> out1 = tensor_add_with_sig_1(x, y)
-        ...
         ... # Set hash_args as fn, otherwise cache of compiled closure_fn will not be reused.
         ... # While fn differs during calling again, recompilation will be triggered.
         >>> def func(x):
@@ -923,8 +765,6 @@ def jit(fn=None, mode="PSJit", input_signature=None, hash_args=None, jit_config=
         else:
             hash_obj = int(time.time() * 1e9)
 
-        dyn_args = _process_dyn_args(func, input_signature)
-
         @wraps(func)
         def staging_specialize(*args, **kwargs):
             if os.getenv("MS_JIT") == '0':
@@ -938,7 +778,7 @@ def jit(fn=None, mode="PSJit", input_signature=None, hash_args=None, jit_config=
             # only the function or cell instance wrapped by shard will fall into this branch
             if _is_pynative_parallel() and func.__name__ == _PYNATIVE_PARALLEL_FUNC_NAME:
                 process_obj = hash_args
-            out = _MindsporeFunctionExecutor(func, hash_obj, dyn_args, process_obj, jit_config)(*args, **kwargs)
+            out = _MindsporeFunctionExecutor(func, hash_obj, input_signature, process_obj, jit_config)(*args, **kwargs)
             return out
 
         return staging_specialize
@@ -961,7 +801,6 @@ def jit(fn=None, mode="PSJit", input_signature=None, hash_args=None, jit_config=
         if func.__code__.co_flags & UNSUPPORTED_CODE_TYPE:
             return decorated
 
-        _update_graph_executor_config(jit_config)
         config = dict()
         if isinstance(jit_config, JitConfig):
             config.update(jit_config.jit_config_dict)
@@ -969,7 +808,7 @@ def jit(fn=None, mode="PSJit", input_signature=None, hash_args=None, jit_config=
             config.update(jit_config)
         jit_mode_pi_enable()
 
-        if jit_mode_pi_compile(func, config, input_signature) is False:
+        if jit_mode_pi_compile(func, config) is False:
             logger.warning('add fn {} to compile failed '.format(func))
 
         return decorated
@@ -1549,18 +1388,6 @@ class _PyNativeExecutor:
         """
         self._executor.set_grad_flag(flag)
 
-    def set_async_for_graph(self, flag):
-        """
-        Set the flag for graph async run.
-
-        Args:
-            flag (bool): Specifying whether enable graph async run.
-
-        Return:
-            None.
-        """
-        self._executor.set_async_for_graph(flag)
-
     def enable_grad(self):
         """
         The global flag whether needing to calculate gradient.
@@ -1754,7 +1581,7 @@ class _CellGraphExecutor:
     def _set_compile_cache_dep_files(self, phase):
         # If enable compile cache, get the dependency files list
         enable_compile_cache = context.get_context("enable_compile_cache")
-        if enable_compile_cache is None:
+        if enable_compile_cache is not True and enable_compile_cache != "1":
             enable_compile_cache = os.getenv('MS_COMPILER_CACHE_ENABLE')
         if enable_compile_cache is True or enable_compile_cache == "1":
             self._graph_executor.set_compile_cache_dep_files(_get_compile_cache_dep_files())
@@ -1793,7 +1620,7 @@ class _CellGraphExecutor:
         phase = phase + '.' + str(obj.create_time) + '.' + str(id(obj)) + '.' + obj.arguments_key
         obj.phase_cache[raw_phase] = phase
         update_auto_dynamic_shape_phase(args, key_id, phase)
-        obj.current_phase = phase
+
         if phase in obj.compile_cache and self.has_compiled(phase):
             logger.debug("%r graph has existed.", phase)
             # Release resource should be released when CompileInner won't be executed, such as cur_convert_input_
@@ -1801,10 +1628,6 @@ class _CellGraphExecutor:
             self._graph_executor.clear_compile_arguments_resource()
             return phase, False
 
-        full_function_name = obj.__class__.__name__ + '.' + str(obj.instance_count) + '.' + str(id(type(obj)))
-        echo_function_name = obj.__class__.__name__
-        _check_recompile(obj, args, kwargs, full_function_name, obj.create_time, echo_function_name)
-
         obj.check_names()
         _check_full_batch()
         self._set_dataset_mode(obj)
@@ -1832,6 +1655,7 @@ class _CellGraphExecutor:
         elif 'skip_auto_parallel_compile' not in obj.get_flags().keys():
             obj.parameter_layout_dict = self._graph_executor.get_parameter_layout(phase)
             obj.parallel_parameter_name_list = self._graph_executor.get_parallel_parameter_name_list(phase)
+
         if "export.air" in phase:
             self._build_data_graph(obj, phase)
         elif BROADCAST_PHASE not in phase and _get_parameter_broadcast():
@@ -1871,18 +1695,6 @@ class _CellGraphExecutor:
         """
         return self._graph_executor.has_compiled(phase)
 
-    def flops_collection(self, phase='train'):
-        """
-        Specify whether have been compiled.
-
-        Args:
-            phase (str): The phase name. Default: 'predict'.
-
-        Returns:
-            bool, specifies whether the specific graph has been compiled.
-        """
-        return self._graph_executor.flops_collection(phase)
-
     @_wrap_func
     def _exec_pip(self, obj, *args, phase=''):
         """Execute the generated pipeline."""
@@ -1915,14 +1727,6 @@ class _CellGraphExecutor:
         """Clear the memory resource of a network."""
         self._graph_executor.del_net_res(obj, net_id)
 
-    def inc_graph_cell_count(self):
-        """Increase the count of GraphCell instance."""
-        self._graph_executor.inc_graph_cell_count()
-
-    def dec_graph_cell_count(self):
-        """Decrease the count of GraphCell instance."""
-        self._graph_executor.dec_graph_cell_count()
-
     def _get_branch_control_input(self):
         if ('obf_ratio' not in self.obfuscate_config.keys()) or (
                 'obf_random_seed' not in self.obfuscate_config.keys()):
@@ -2029,21 +1833,7 @@ def _bind_device_context():
     _bind_device_ctx()
 
 
-def flops_collection(phase='train'):
-    """
-    Recycle memory used by MindSpore.
-    When train multi Neural network models in one process, memory used by MindSpore is very large,
-    this is because MindSpore cached runtime memory for every model.
-    To recycle these cached memory, users can call this function after training of one model.
-
-    Examples:
-        >>> import mindspore as ms
-        >>> ms.ms_memory_recycle()
-    """
-    return _cell_graph_executor.flops_collection(phase)
-
-
 _cell_graph_executor = _CellGraphExecutor()
 _pynative_executor = _PyNativeExecutor()
 
-__all__ = ['ms_function', 'ms_memory_recycle', 'ms_class', 'jit', 'jit_class', 'flops_collection']
+__all__ = ['ms_function', 'ms_memory_recycle', 'ms_class', 'jit', 'jit_class']

mindspore/common/dtype.py

@@ -22,9 +22,6 @@ from inspect import isfunction
 import numpy as np
 from mindspore._c_expression import typing
 from mindspore._c_expression.typing import Type
-from mindspore._c_expression.np_dtypes import np_version_valid
-if np_version_valid(False):
-    from mindspore._c_expression.np_dtypes import bfloat16 as np_bfloat16
 
 __dtype__ = [
     "int8", "byte",
@@ -263,7 +260,8 @@ def dtype_to_nptype(type_):
         >>> ms.dtype_to_nptype(ms.int8)
         <class 'numpy.int8'>
     """
-    _dtype_nptype_dict = {
+
+    return {
         bool_: np.bool_,
         int8: np.int8,
         int16: np.int16,
@@ -278,10 +276,8 @@ def dtype_to_nptype(type_):
         float64: np.float64,
         complex64: np.complex64,
         complex128: np.complex128,
-    }
-    if np_version_valid(False):
-        _dtype_nptype_dict.update({bfloat16: np_bfloat16})
-    return _dtype_nptype_dict[type_]
+        bfloat16: np.float32,
+    }[type_]
 
 
 def dtype_to_pytype(type_):

mindspore/common/dump.py

@@ -25,14 +25,17 @@ def set_dump(target, enabled=True):
     Enable or disable dump for the `target` and its contents.
 
     `target` should be an instance of :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` .
-    Please note that this API takes effect only when Synchronous Dump is enabled and the `dump_mode`
+    Please note that this API takes effect only when Asynchronous Dump is enabled and the `dump_mode`
     field in dump config file is ``"2"`` . See the `dump document
     <https://www.mindspore.cn/tutorials/experts/en/master/debug/dump.html>`_ for details.
     The default enabled status for
     a :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` is False.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion. It is not supported for 2.3 version.
+
     Note:
-        1. This API is only effective for GRAPH_MODE whose graph compilation level is O0/O1 with Ascend backend.
+        1. This API is only effective for GRAPH_MODE with Ascend backend.
         2. This API only supports being called before training starts.
            If you call this API during training, it may not be effective.
         3. After using `set_dump(Cell, True)` , operators in forward and backward

mindspore/common/jit_config.py

@@ -14,6 +14,7 @@
 # ============================================================================
 """JitConfig for compile."""
 
+
 class JitConfig:
     """
     Jit config for compile.
@@ -21,7 +22,6 @@ class JitConfig:
     Args:
         jit_level (str, optional): Used to control the compilation optimization level.
             Supports ["O0", "O1", "O2"]. Default: ``""`` , The framework automatically selects the execution method.
-            Not recommended, it is recommended to use the jit decorator.
 
             - ``"O0"``: Except for optimizations that may affect functionality, all other optimizations are turned off,
               adopt KernelByKernel execution mode.

mindspore/common/lazy_inline.py

@@ -20,25 +20,19 @@ from functools import wraps
 from mindspore import log as logger
 
 
-def lazy_inline(fn=None, attrs=None, policy=None):
+def lazy_inline(fn=None, attrs=None):
     """
-    Make the cell to be reusable. The corresponding sub graph will not be inline at first
-    and will be inline with the policy.
+    Make the cell to be reusable. The corresponding sub graph will not be inline at first.
     Registering the decorator of the built-in function `__init__` of a cell, the decorator
     will add the parameters of `__init__` according to the `attrs` as the attributes of this cell.
 
     .. warning::
         This feature is only supported on Ascend and is not supported on other hardwares.
         The construct parameters must be positional or key word arguments and have not default values.
-        The cell has not switch sub graph.
 
     Args:
         fn (function): `__init__` function of a cell.
         attrs (Union[list[string], string]): The attributes list to add for the cell.
-        policy (Union[None, "front"]): The policy of inline. Default is None.
-
-            - ``None``: The cell will be compiled to sub graph and will not be inline.
-            - ``"front"``: The cell will be compiled to sub graph first and will be inline at front end.
 
     Returns:
         function, original function.
@@ -210,12 +204,6 @@ def lazy_inline(fn=None, attrs=None, policy=None):
                 del new_args['self']
                 new_args = new_args.values()
             fn(self, *args, **kwargs)
-
-            if isinstance(policy, str) and policy == "front":
-                self.no_inline = False
-            elif policy is not None:
-                raise ValueError(f"policy must be None or 'front'")
-
             if attrs is None:
                 self.cell_init_args = "lazy_inline_" + type(self).__name__ + str(new_args)
                 return