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

mindspore/context.py

@@ -34,7 +34,6 @@ from mindspore.parallel._auto_parallel_context import _set_auto_parallel_context
 from mindspore.parallel._ps_context import _set_ps_context, _get_ps_context, _reset_ps_context, \
     _need_reset_device_target_for_ps
 from mindspore.parallel._offload_context import _set_offload_context, _get_offload_context
-from mindspore.hal.device import is_initialized
 
 __all__ = ['GRAPH_MODE', 'PYNATIVE_MODE', 'STRICT', 'COMPATIBLE', 'LAX', 'set_context', 'get_context',
            'set_auto_parallel_context', 'get_auto_parallel_context', 'reset_auto_parallel_context', 'ParallelMode',
@@ -166,9 +165,7 @@ class _Context:
         self._context_switches = _ContextSwitchInfo(False)
         self._context_handle = MSContext.get_instance()
         self._support_binary = False
-        self.enable_compile_cache = None
         self._mode = PYNATIVE_MODE
-        self._jit_config = {}
 
     def __getattribute__(self, attr):
         value = object.__getattribute__(self, attr)
@@ -186,10 +183,6 @@ class _Context:
         """Get current mode."""
         return self._mode
 
-    def get_jit_config(self):
-        """Get current jit_config."""
-        return self._jit_config
-
     def set_mode(self, mode):
         """
         Switch between Graph mode and PyNative mode.
@@ -232,6 +225,7 @@ class _Context:
                              f"or context.DEBUG, but got {level}.")
         self.set_param(ms_ctx_param.debug_level, level)
 
+
     def set_memory_optimize_level(self, memory_optimize_level):
         """
         The memory optimize level, support "O0", "O1".
@@ -289,9 +283,6 @@ class _Context:
                 - jit_compile (bool): ``False`` and ``True``.
                 - atomic_clean_policy (int): ``0`` and ``1``. Default: ``1`` .
                 - op_precision_mode (str): precision mode config file path.
-                - op_debug_option (str): Enable debugging options for Ascend operators,
-                  default not enabled, only supports ``"oom"`` currently.
-                  ``"oom"``: Detect memory out of bounds.
                 - ge_options (dict): Global or session CANN options.
                 - exception_dump (str): Enable exception dump for Ascend operators. ``"0"`` , ``"1"`` and ``"2"``.
                   Default: ``"2"`` .
@@ -312,12 +303,7 @@ class _Context:
             'ge_options': (dict,),
             'parallel_speed_up_json_path': (str, None),
             'host_scheduling_max_threshold': (int,),
-            'cur_step_num': (int,),
-            'save_checkpoint_steps': (int,),
-            'need_ckpt': (bool,),
-            'last_triggered_step': (int,),
-            'topo_order': (dict,),
-            'op_debug_option': (str, None),
+            'topo_order': (dict,)
         }
         ascend_cfg_setters = {
             'precision_mode': self._get_ascend_config_setter('precision_mode'),
@@ -326,15 +312,10 @@ class _Context:
             'matmul_allow_hf32': self._get_ascend_config_setter('matmul_allow_hf32', lambda v: "1" if v else "0"),
             'conv_allow_hf32': self._get_ascend_config_setter('conv_allow_hf32', lambda v: "1" if v else "0"),
             'exception_dump': self._get_ascend_config_setter('exception_dump'),
-            'op_debug_option': self._set_op_debug_option,
             'op_precision_mode': self._set_op_precision_mode,
             'ge_options': self._set_ge_options,
             'parallel_speed_up_json_path': self._set_speedup_config_path,
             'host_scheduling_max_threshold': self._get_ascend_config_setter('host_scheduling_max_threshold', str),
-            'cur_step_num': self._set_cur_step_num,
-            'save_checkpoint_steps': self._set_save_checkpoint_steps,
-            'need_ckpt': self._set_need_ckpt,
-            'last_triggered_step': self._set_last_triggered_step,
             'topo_order': self._set_topo_order
         }
         ascend_cfg_set = tuple(ascend_cfg_modes.keys())
@@ -393,31 +374,6 @@ class _Context:
             if gpu_key == 'matmul_allow_tf32':
                 self.set_param(ms_ctx_param.matmul_allow_tf32, gpu_config[gpu_key])
 
-    def set_jit_config(self, jit_config):
-        """
-        Enable jit config.
-
-        Args:
-            jit_config (dict):
-
-                - jit_level (str): "O0", "O1" or "O2" to control the compilation optimization level.
-        """
-        jit_cfgs = {'jit_level': ["O0", "O1", "O2"], 'infer_boost': ["on", "off"]}
-        key_args_map = {'jit_level': ms_ctx_param.jit_level, 'infer_boost': ms_ctx_param.infer_boost}
-        for jit_key in jit_config:
-            if jit_key not in jit_cfgs:
-                raise ValueError(f"For 'context.set_context', the key of argument 'jit_config' must be one of "
-                                 f"{jit_cfgs}, but got {jit_key}.")
-            supported_value = jit_cfgs.get(jit_key)
-            if jit_config[jit_key] not in supported_value:
-                raise ValueError(f"For 'jit_cfgs', the value of argument {jit_key} must be one of "
-                                 f"{supported_value}, but got {jit_config[jit_key]}.")
-            self._jit_config = jit_config
-            self.set_param(key_args_map[jit_key], jit_config[jit_key])
-
-        if 'infer_boost' in jit_config and jit_config['infer_boost'] == "on" and jit_config['jit_level'] != "O0":
-            raise ValueError(f"Only jit_level set O0 can set infer_boost to on.")
-
     def set_backend_policy(self, policy):
         success = self._context_handle.set_backend_policy(policy)
         if not success:
@@ -539,13 +495,10 @@ class _Context:
 
     def set_mempool_block_size(self, mempool_block_size):
         """Set the block size of memory pool."""
-        global_jit_config = get_jit_config()
-        is_force_kbk = False
-        if global_jit_config:
-            is_force_kbk = global_jit_config.get('jit_level') == "O0" or global_jit_config.get('jit_level') == "O1"
-        if _get_mode() == GRAPH_MODE and not is_force_kbk:
+        is_force_kbk = os.getenv("GRAPH_OP_RUN")
+        if _get_mode() == GRAPH_MODE and is_force_kbk != "1":
             logger.warning("Graph mode doesn't support to set parameter 'mempool_block_size' of context currently, "
-                           "you can use context.set_context to set pynative mode or set jit_level=O0/O1.")
+                           "you can use context.set_context to set pynative mode or set env GRAPH_OP_RUN=1.")
             return
         if not Validator.check_str_by_regular(mempool_block_size, _RE_PATTERN):
             raise ValueError("For 'context.set_context', the argument 'mempool_block_size' should be in "
@@ -634,7 +587,6 @@ class _Context:
         'debug_level': set_debug_level,
         'gpu_config': set_gpu_config,
         'aoe_config': set_aoe_config,
-        'jit_config': set_jit_config,
     }
 
     @property
@@ -682,16 +634,6 @@ class _Context:
             trans_fn = lambda x: x
         return _config_setter
 
-    def _set_op_debug_option(self, option_value):
-        valid_order = {'oom'}
-        if not isinstance(option_value, str):
-            raise TypeError(f"For 'ascend_config', the type of 'op_debug_option' must be str, "
-                            f"but got {type(option_value)}.")
-        if option_value not in valid_order:
-            raise ValueError(f"For 'ascend_config', the 'op_debug_option' supports being set to 'oom' currently, "
-                             f"but got {option_value}.")
-        self.set_param(ms_ctx_param.op_debug_option, option_value)
-
     def _set_op_precision_mode(self, ascend_value):
         op_precision_path = ascend_value
         real_path = os.path.realpath(op_precision_path)
@@ -744,30 +686,6 @@ class _Context:
         options_str = json.dumps(topo_order)
         self.set_param(ms_ctx_param.topo_order, options_str)
 
-    def _set_need_ckpt(self, need_ckpt):
-        """Set need ckpt flag"""
-        if not isinstance(need_ckpt, bool):
-            raise TypeError(f"For step num, the value type should be int, but got {type(need_ckpt)}, {need_ckpt}")
-        self.set_param(ms_ctx_param.need_ckpt, need_ckpt)
-
-    def _set_cur_step_num(self, step_num):
-        """set current step num at every step begin"""
-        if not isinstance(step_num, int):
-            raise TypeError(f"For step num, the value type should be int, but got {type(step_num)}, {step_num}")
-        self.set_param(ms_ctx_param.cur_step_num, step_num)
-
-    def _set_save_checkpoint_steps(self, steps):
-        """set save checkpoint steps before run"""
-        if not isinstance(steps, int):
-            raise TypeError(f"For step num, the value type should be int, but got {type(steps)}, {steps}")
-        self.set_param(ms_ctx_param.save_checkpoint_steps, steps)
-
-    def _set_last_triggered_step(self, step):
-        """set last triggered save ckpt steps before run"""
-        if not isinstance(step, int):
-            raise TypeError(f"For step num, the value type should be int, but got {type(step)}, {step}")
-        self.set_param(ms_ctx_param.last_triggered_step, step)
-
     def _set_speedup_config_path(self, speedup_config_path):
         """"Check and set speedup config for auto parallel."""
         if speedup_config_path is None or speedup_config_path == "":
@@ -782,8 +700,6 @@ class _Context:
                             "matmul_grad_comm_overlap": (ms_ctx_param.matmul_grad_comm_overlap, bool),
                             "enable_task_opt": (ms_ctx_param.enable_task_opt, bool),
                             "enable_grad_comm_opt": (ms_ctx_param.enable_grad_comm_opt, bool),
-                            "recompute_allgather_overlap_fagrad":
-                                (ms_ctx_param.recompute_allgather_overlap_fagrad, bool),
                             "interleaved_matmul_comm": (ms_ctx_param.interleaved_matmul_comm, bool),
                             "bias_add_comm_swap": (ms_ctx_param.bias_add_comm_swap, bool),
                             "enable_opt_shard_comm_opt": (ms_ctx_param.enable_opt_shard_comm_opt, bool),
@@ -875,7 +791,6 @@ def set_auto_parallel_context(**kwargs):
                \                 comm_fusion
                \                 strategy_ckpt_config
                \                 group_ckpt_save_file
-               \                 auto_pipeline
     ===========================  ===========================
 
     Args:
@@ -1024,9 +939,6 @@ def set_auto_parallel_context(**kwargs):
                         - only_trainable_params (bool): Only save/load the strategy information for trainable parameter.
                           Default: ``True`` .
         group_ckpt_save_file (str): The path to save parallel group checkpoint.
-        auto_pipeline (bool): Set the pipeline stage number to automatic. Its value will be selected between 1 and the
-                        parameter `pipeline_stages`. This option requires the `parallel_mode` to be ``auto_parallel``
-                        and the `search_mode` to be ``recursive_programming``. Default: ``False`` .
 
     Raises:
         ValueError: If input key is not attribute in auto parallel context.
@@ -1102,7 +1014,6 @@ def reset_auto_parallel_context():
     - pipeline_stages: 1.
     - pipeline_result_broadcast: False.
     - fusion_threshold: 64.
-    - auto_pipeline: False.
 
     Examples:
         >>> import mindspore as ms
@@ -1192,23 +1103,6 @@ def _check_target_specific_cfgs(device, arg_key):
     return False
 
 
-def _check_ascend_device_context_initialized(device_target, settings):
-    if device_target == 'Ascend' and is_initialized(device_target):
-        for key, _ in settings.items():
-            if key in ('ascend_config', 'deterministic', 'jit_compile', 'exception_dump', 'device_id'):
-                logger.warning(f"For 'context.set_context' in Ascend backend, the backend is already initialized, "
-                               "please set it before the definition of any Tensor and Parameter, and the "
-                               "instantiation and execution of any operation and net, otherwise the settings may not "
-                               "take effect. ")
-                break
-
-
-def _check_key(key):
-    if key in ('precision_mode', 'jit_compile', 'atomic_clean_policy', 'matmul_allow_hf32', 'conv_allow_hf32',
-               'op_precision_mode', 'host_scheduling_max_threshold', 'ge_options', 'op_debug_option'):
-        raise ValueError(f"Please set '{key}' through parameter ascend_config")
-
-
 @args_type_check(mode=int, precompile_only=bool, device_target=str, device_id=int, save_graphs=(bool, int),
                  save_graphs_path=str, enable_dump=bool, aoe_tune_mode=str, aoe_config=dict,
                  save_dump_path=str, enable_reduce_precision=bool, variable_memory_max_size=str,
@@ -1218,7 +1112,7 @@ def _check_key(key):
                  graph_kernel_flags=str, save_compile_cache=bool, runtime_num_threads=int, load_compile_cache=bool,
                  grad_for_scalar=bool, pynative_synchronize=bool, mempool_block_size=str, disable_format_transform=bool,
                  op_timeout=int, deterministic=str, ascend_config=dict, jit_syntax_level=int, debug_level=int,
-                 jit_enable_inplace_ops=bool, gpu_config=dict, jit_config=dict, enable_compile_cache=bool)
+                 jit_enable_inplace_ops=bool, gpu_config=dict)
 def set_context(**kwargs):
     """
     Set context for running environment.
@@ -1309,8 +1203,6 @@ def set_context(**kwargs):
     |                         |  jit_syntax_level            |  CPU/GPU/Ascend            |
     |                         +------------------------------+----------------------------+
     |                         |  gpu_config                  |  GPU                       |
-    |                         +------------------------------+----------------------------+
-    |                         |  jit_config                  |  CPU/GPU/Ascend            |
     +-------------------------+------------------------------+----------------------------+
 
     Args:
@@ -1323,15 +1215,15 @@ def set_context(**kwargs):
             and max_device_memory. 'max_device_memory' should be set before the program runs.
         variable_memory_max_size (str): This parameter is deprecated, and will be removed in a future version.
             Please use parameter 'max_device_memory' instead.
-        mempool_block_size (str): Set the size of the memory pool block in PyNative mode or jit level is 'O0'/'O1'
-            for devices. The format is "xxGB". Default: ``"1GB"`` . Minimum size is "1G". The actual used memory block
-            size is the minimum of the available memory of the device and mempool_block_size.
+        mempool_block_size (str): Set the size of the memory pool block in PyNative mode or GRAPH_OP_RUN=1 for devices.
+            The format is "xxGB". Default: ``"1GB"`` . Minimum size is "1G". The actual used memory block size is the
+            minimum of the available memory of the device and mempool_block_size.
         op_timeout (int): Set the maximum duration of executing an operator in seconds.
             If the execution time exceeds this value, system will terminate the task.
             0 means endless wait. The defaults for AI Core and AICPU operators vary on different hardware.
             For more information,
-            please refer to `Ascend Community document about aclrtSetOpExecuteTimeOut
-            <https://www.hiascend.com/document/detail/en/CANNCommunityEdition/600alphaX/infacldevg/aclcppdevg/aclcppdevg_03_0069.html>`_.
+            please refer to `Ascend Community
+            <https://www.hiascend.com/>`_.
             Default: ``900`` .
         save_graphs (bool or int): Whether to save intermediate compilation graphs. Default: ``0`` .
             Available values are:
@@ -1341,9 +1233,6 @@ def set_context(**kwargs):
             - True or 2: Generate more ir files related to backend process.
             - 3: Generate visualization computing graphs and detailed frontend ir graphs.
 
-            When the network structure is complex, setting `save_graphs` attribute to ``2`` or ``3`` may take too long.
-            If you need quick problem locating, you can switch to ``1`` first.
-
             When the `save_graphs` attribute is set as ``True`` , ``1`` , ``2`` or ``3`` , attribute of
             `save_graphs_path` is used to set the intermediate compilation graph storage path. By default, the graphs
             are saved in the current directory.
@@ -1367,8 +1256,6 @@ def set_context(**kwargs):
             If the saved file already exists, the timestamp suffix will be added to the file. Saving data to a file
             solves the problem of data loss in screen printing when a large amount of data is generated.
             If it is not set, an error will be reported: prompt to set the upper absolute path.
-            When print data to file, the total output bytes of single print must be less then 2GB(limited by
-            protobuf).
         env_config_path (str): Config path for DFX.
             Through mindspore.set_context(env_config_path="./mindspore_config.json")
 
@@ -1544,17 +1431,10 @@ def set_context(**kwargs):
               For detailed information, please refer to `Ascend community <https://www.hiascend.com/>`_ .
             - exception_dump (str): Enable exception dump for Ascend operators, providing the input and output data for
               failing Ascend operators. The value can be ``"0"`` , ``"1"`` and ``"2"``. For ``"0"`` , exception dump is
-              turned off; for ``"1"``, all inputs and outputs will be dumped for AICore exception operators;
-              for ``"2"``, inputs will be dumped for AICore exception operators, reducing the saved information
-              but improving performance. Default: ``"2"`` .
+              turned off; for ``"1"``, all inputs and outputs will be dumped for AICore and AICPU exception operators;
+              for ``"2"``, inputs will be dumped for AICore exception operators. Default: ``"2"`` .
             - op_precision_mode (str): Path to config file of op precision mode. For detailed information, please refer
               to `Ascend community <https://www.hiascend.com/>`_ .
-            - op_debug_option (str): Enable debugging options for Ascend operators, default not enabled.
-              The value currently only supports being set to ``"oom"``.
-
-              - ``"oom"``: When there is a memory out of bounds during the execution of an operator,
-                AscendCL will return an error code of ``EZ9999``.
-
             - ge_options (dict): Set options for CANN. The options are divided into two categories: global and session.
               This is an experimental prototype that is subject to change and/or deletion.
               For detailed information, please refer to `Ascend community <https://www.hiascend.com/document/detail/zh/canncommercial/70RC1/inferapplicationdev/graphdevg/atlasgeapi_07_0119.html>`_ .
@@ -1574,10 +1454,7 @@ def set_context(**kwargs):
                 Default: False.
               - matmul_grad_comm_overlap (bool): Enable overlap between dw matmul and
                 tensor parallel communication ops if True. Default: False.
-              - recompute_allgather_overlap_fagrad (bool): Enable overlap between duplicated allgather by recomputing
-                in sequence parallel and flashattentionscoregrad ops if True. Default: False.
-              - enable_task_opt (bool): Enable communication fusion to optimize the number of communication operator
-                tasks if True.
+              - enable_task_opt (bool): Enable the optimization of the number of tasks for each communication if True.
                 Default: False.
               - enable_grad_comm_opt (bool): Enable overlap between dx ops and data parallel communication ops if True.
                 Currently, do not support
@@ -1597,8 +1474,6 @@ def set_context(**kwargs):
                 - 2: Apply fusion to backward nodes.
 
                 - 3: Apply fusion to all nodes.
-              - bias_add_comm_swap (bool): Enable node execution order swap communication operators and add operators
-                if ``True``. Only 1-dimension bias node is supported. Default: ``False``.
             - host_scheduling_max_threshold(int): The max threshold to control whether the dynamic shape process is
               used when run the static graph, the default value is 0. When the number of operations in the static graph
               is less than the max threshold, this graph will be executed in dynamic shape process. In large model
@@ -1691,26 +1566,6 @@ def set_context(**kwargs):
             - matmul_allow_tf32 (bool): The flag below controls to allow Tensor core TF32 computation on CUBLAS and the
               default value is ``False``.
 
-        jit_config (dict): Set the global jit config for compile, take effect in network defined in Cell or jit
-            decorators. It is not set by default.
-            The setting in context is the global jit config, while JitConfig is the local network's jit config.
-            When both exist simultaneously, the global jit config will not overwrite the local network's jit config.
-
-            - jit_level (str): Used to control the compilation optimization level. Default: ``""`` , The framework
-              automatically selects the execution method based on product, Altas training product is O2, and all other
-              products are O0. The value range is as follows:
-
-              - ``"O0"``: Except for optimizations that may affect functionality, all other optimizations are turned
-                off, adopt KernelByKernel execution mode.
-              - ``"O1"``: Using commonly used optimizations and automatic operator fusion optimizations,
-                adopt KernelByKernel execution mode.
-              - ``"O2"``: Ultimate performance optimization, adopt Sink execution mode.
-
-            - infer_boost (str): Used to control the infer mode. Default: ``"off"`` . The value range is as follows:
-
-              - ``"on"``: Enable infer mode, get better infer performance.
-              - ``"off"``: Disable infer mode, use forward to infer, performance is not good.
-
     Raises:
         ValueError: If input key is not an attribute in context.
 
@@ -1745,22 +1600,18 @@ def set_context(**kwargs):
         >>> ms.set_context(deterministic='ON')
         >>> ms.set_context(ascend_config={"precision_mode": "force_fp16", "jit_compile": True,
         ...                "atomic_clean_policy": 1, "op_precision_mode": "./op_precision_config_file",
-        ...                "op_debug_option": "oom",
         ...                "ge_options": {"global": {"ge.opSelectImplmode": "high_precision"},
         ...                               "session": {"ge.exec.atomicCleanPolicy": "0"}}})
         >>> ms.set_context(jit_syntax_level=ms.STRICT)
-        >>> ms.set_context(debug_level=ms.context.DEBUG)
+        >>> ms.set_context(debug_level=ms.DEBUG)
         >>> ms.set_context(gpu_config={"conv_fprop_algo": "performance", "conv_allow_tf32": True,
         ...                "matmul_allow_tf32": True})
-        >>> ms.set_context(jit_config={"jit_level": "O0"})
     """
     ctx = _context()
     # set device target first
     if 'device_target' in kwargs:
         ctx.set_device_target(kwargs['device_target'])
     device = ctx.get_param(ms_ctx_param.device_target)
-    _check_ascend_device_context_initialized(device, kwargs)
-
     for key, value in kwargs.items():
         if key in ('enable_sparse', 'auto_tune_mode'):
             logger.warning(f"For 'context.set_context', '{key}' parameter is deprecated, "
@@ -1770,7 +1621,9 @@ def set_context(**kwargs):
             logger.warning(f"For 'context.set_context', '{key}' parameter is deprecated. "
                            "For details, please see the interface parameter API comments")
             continue
-        _check_key(key)
+        if key in ('precision_mode', 'jit_compile', 'atomic_clean_policy', 'matmul_allow_hf32', 'conv_allow_hf32',
+                   'op_precision_mode', 'host_scheduling_max_threshold', 'ge_options'):
+            raise ValueError(f"Please set '{key}' through parameter ascend_config")
         if key == 'save_graphs':
             if value is True:
                 value = 2
@@ -1784,10 +1637,6 @@ def set_context(**kwargs):
         if key == 'debug_level' and value not in (RELEASE, DEBUG):
             raise ValueError(f"For 'debug_level', the value should be context.DEBUG"
                              f" or context.RELEASE, but got {value}.")
-        if key == 'enable_compile_cache':
-            setattr(ctx, key, value)
-            ctx.set_param(ms_ctx_param.__members__[key], int(value))
-            continue
         if not _check_target_specific_cfgs(device, key):
             continue
         if hasattr(ctx, key):
@@ -1845,17 +1694,6 @@ def _get_mode():
     return ctx.get_mode()
 
 
-def get_jit_config():
-    """
-    Get global jit config.
-
-    Returns:
-        Object: The Value of jit config.
-    """
-    ctx = _context()
-    return ctx.get_jit_config()
-
-
 class ParallelMode:
     """
     Parallel mode options.