mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0__cp39-cp39-win_amd64.whl

mindspore/dataset/vision/utils.py

@@ -495,7 +495,7 @@ def get_image_num_channels(image):
 
     Raises:
         RuntimeError: If the dimension of `image` is less than 2.
-        TypeError: If `image` is not of type <class 'numpy.ndarray'> or <class 'PIL.Image.Image'>.
+        TypeError: If `image` is not of type numpy.ndarray or PIL Image.
 
     Examples:
         >>> import mindspore.dataset.vision as vision
@@ -528,7 +528,7 @@ def get_image_size(image):
 
     Raises:
         RuntimeError: If the dimension of `image` is less than 2.
-        TypeError: If `image` is not of type <class 'numpy.ndarray'> or <class 'PIL.Image.Image'>.
+        TypeError: If `image` is not of type type numpy.ndarray or PIL Image.
 
     Examples:
         >>> import mindspore.dataset.vision as vision
@@ -635,10 +635,12 @@ def read_video(filename, start_pts=0, end_pts=None, pts_unit="pts"):
 
     Args:
         filename(str): The path to the video file to be read.
-        start_pts(Union[float, Fraction, int], optional): The start presentation timestamp of the video. Default: 0.
-        end_pts(Union[float, Fraction, int], optional): The end presentation timestamp of the video. Default: None.
+        start_pts(Union[float, Fraction, int], optional): The start presentation timestamp of the video.
+            Default: ``0``.
+        end_pts(Union[float, Fraction, int], optional): The end presentation timestamp of the video.
+            Default: ``None``.
             The None is represented by 2147483647.
-        pts_unit(str, optional): The unit of the timestamps. It can be any of ["pts", "sec"]. Default: "pts".
+        pts_unit(str, optional): The unit of the timestamps. It can be any of ["pts", "sec"]. Default: ``"pts"``.
 
     Returns:
         - numpy.ndarray, four dimensions uint8 data for video. The format is [T, H, W, C]. `T` is the number of frames,

mindspore/dataset/vision/validators.py

@@ -24,7 +24,7 @@ from mindspore.dataset.core.validator_helpers import check_value, check_uint8, F
     check_pos_float32, check_float32, check_2tuple, check_range, check_positive, INT32_MAX, INT32_MIN, \
     parse_user_args, type_check, type_check_list, check_c_tensor_op, UINT8_MAX, UINT8_MIN, check_value_normalize_std, \
     check_value_cutoff, check_value_ratio, check_odd, check_non_negative_float32, check_non_negative_int32, \
-    check_pos_int32, check_int32, check_tensor_op, deprecator_factory, check_valid_str, check_independent_mode
+    check_pos_int32, check_int32, check_tensor_op, deprecator_factory, check_valid_str
 from mindspore.dataset.transforms.validators import check_transform_op_type
 from .utils import Inter, Border, ImageBatchFormat, ConvertMode, SliceMode, AutoAugmentPolicy
 
@@ -358,7 +358,6 @@ def check_device_target(method):
     def new_method(self, *args, **kwargs):
         [device_target], _ = parse_user_args(method, *args, **kwargs)
         check_valid_str(device_target, ["CPU", "Ascend"], "device_target")
-        check_independent_mode("Transform in Ascend mode", (device_target == "Ascend"))
         return method(self, *args, **kwargs)
     return new_method
 

mindspore/device_context/__init__.py

@@ -0,0 +1,21 @@
+# Copyright 2024 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""
+The device context interface.
+"""
+import mindspore.device_context.gpu
+import mindspore.device_context.cpu
+import mindspore.device_context.ascend

mindspore/device_context/ascend/__init__.py

@@ -0,0 +1,25 @@
+# Copyright 2024 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Ascend interfaces"""
+
+from .device import device_count, is_available
+from .op_debug import *
+from .op_precision import *
+from .op_tuning import *
+
+__all__ = [
+    "device_count", "is_available"
+]

mindspore/device_context/ascend/device.py

@@ -0,0 +1,72 @@
+# Copyright 2024 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Device context ascend interfaces"""
+import mindspore as ms
+from mindspore._c_expression import MSContext
+from mindspore import log as logger
+
+try:
+    from mindspore._c_expression import ascend_get_device_count
+except ImportError:
+    pass
+
+
+def device_count():
+    """
+    Return compute-capable device count of Ascend.
+
+    Returns:
+        int, the number of compute-capable Ascend devices.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> print(ms.device_context.ascend.device_count())
+        8
+    """
+    if not MSContext.get_instance().is_pkg_support_device("Ascend") or not is_available():
+        raise RuntimeError(f"Device Ascend not exist.")
+    return ascend_get_device_count()
+
+
+def is_available():
+    """
+    Returns whether ascend backend is available.
+
+    Returns:
+        Bool, whether the ascend backend is available for this MindSpore package.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> print(ms.device_context.ascend.is_available())
+        True
+    """
+    # MindSpore will try to load plugins in "import mindspore", and availability status will be stored.
+    if not MSContext.get_instance().is_pkg_support_device("Ascend"):
+        logger.warning(f"Device Ascend is not available.")
+        load_plugin_error = MSContext.get_instance().load_plugin_error()
+        if load_plugin_error != "":
+            logger.warning(f"Here's error when loading plugin for MindSpore package."
+                           f"Error message: {load_plugin_error}")
+        return False
+    return True
+
+
+def _is_supported():
+    device_target = ms.context.get_context("device_target")
+    if device_target == 'CPU' or device_target == 'GPU':
+        logger.error(f"{device_target} device is not supported. Please use correct device")
+        return False
+    return True

mindspore/device_context/ascend/op_debug.py

@@ -0,0 +1,153 @@
+# Copyright 2024 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Op debug interfaces."""
+from mindspore._checkparam import args_type_check
+from .device import _is_supported
+try:
+    from mindspore._c_expression import AscendOpDebugConf
+except ImportError:
+    pass
+
+function_status = {'execute_timeout': False, 'debug_option': False}
+
+
+@args_type_check(op_timeout=int)
+def execute_timeout(op_timeout):
+    """
+    Set the maximum duration of executing an operator in seconds. The framework operator execution timeout time
+    is ``900`` by default.
+    please refer to `Ascend Community document about aclrtSetOpExecuteTimeOut
+    <https://www.hiascend.com/document/detail/en/CANNCommunityEdition/600alphaX/infacldevg/aclcppdevg/aclcppdevg_03_0069.html>`_.
+
+    Args:
+        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 AI CPU operators vary on different hardware.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.ascend.op_debug.execute_timeout(100)
+    """
+    if not function_status['execute_timeout']:
+        function_status['execute_timeout'] = True
+        if not _is_supported():
+            return
+    if op_timeout == AscendOpDebugConf.get_instance().execute_timeout():
+        return
+    # Check the configuration environment whether valid
+    if AscendOpDebugConf.get_instance().is_execute_timeout_configured():
+        raise RuntimeError("The 'execute_timeout' can not be set repeatedly.")
+    if op_timeout < 0:
+        raise ValueError("The num of execute_timeout must bigger than or equal to 0.")
+    AscendOpDebugConf.get_instance().set_execute_timeout(op_timeout)
+
+
+def debug_option(option_value):
+    """
+    Enable debugging options for Ascend operators, default not enabled.
+
+    Args:
+        option_value(str): Ascend operators debugging configuration. Currently, only memory
+            access violation detection is supported.
+            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``.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.ascend.op_debug.debug_option("oom")
+    """
+    if not function_status['debug_option']:
+        function_status['debug_option'] = True
+        if not _is_supported():
+            return
+    if option_value == AscendOpDebugConf.get_instance().debug_option():
+        return
+    # Check the configuration environment whether valid
+    if AscendOpDebugConf.get_instance().is_debug_option_configured():
+        raise RuntimeError("The 'debug_option' can not be set repeatedly.")
+    valid_order = {"oom"}
+    if not isinstance(option_value, str):
+        raise TypeError(
+            f"For 'device_context.ascend.op_debug.debug_option(option_value)', the type of 'option_value' must be str, "
+            f"but got {type(option_value)}."
+        )
+    if option_value not in valid_order:
+        raise ValueError(
+            f"For 'device_context.ascend.op_debug.debug_option(option_value)', the 'option_value' supports being set "
+            f"to 'oom' currently, but got {option_value}."
+        )
+    AscendOpDebugConf.get_instance().set_debug_option(option_value)
+
+
+def aclinit_config(config):
+    """
+    Configure the configuration items for the aclInit interface.
+    please refer to `Ascend Community document about aclInit.
+    <https://www.hiascend.com/document/detail/zh/CANNCommunityEdition/800alpha003/apiref/appdevgapi/aclcppdevg_03_0022.html>`_.
+
+    Args:
+        config(dict): When initializing AscendCL, you can enable or configure the
+            following features through this configuration interface.
+
+            - ``"max_opqueue_num"``: When executing using the single-operator model method, to save memory and balance
+              the performance of calls, you can configure the maximum length of the single-operator model mapping
+              queue through the max_opqueue_num parameter. If the length reaches the maximum, the system will first
+              delete the mapping information that has not been used for a long time and the cached single-operator
+              model, and then load the latest mapping information and the corresponding single-operator model.
+              If the maximum length of the mapping queue is not configured, the default maximum length is 20,000.
+            - ``"err_msg_mode"``: This parameter is used to control the level at which error information is retrieved,
+              either by process or by thread. The default level is by process. "0" indicating that error information
+              is retrieved by thread.
+              "1" is the default value, indicates that error information is retrieved by process.
+            - ``"dump"``: This parameter is used to enable exception dump for Ascend operators. The value can be set to
+              {"dump_scene": "lite_exception"}, {"dump_scene": "lite_exception:disable"}.
+              {"dump_scene": "lite_exception"} indicates that the exception dump is enabled.
+              {"dump_scene": "lite_exception:disable"} indicates that the exception dump is disabled.
+              {"dump_scene": "lite_exception"} is the default value, indicates that the exception dump is enabled.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.set_device("Ascend", 0)
+        >>> ms.device_context.ascend.op_debug.aclinit_config({"max_opqueue_num": "20000", "err_msg_mode": "1",
+        ...                                                   "dump": {"dump_scene": "lite_exception"}})
+    """
+    aclinit_cfg_modes = {
+        "max_opqueue_num": (str,),
+        "err_msg_mode": ['0', '1'],
+        "dump": [{"dump_scene": "lite_exception"}, {"dump_scene": "lite_exception:disable"}],
+    }
+    instance = AscendOpDebugConf.get_instance()
+    aclinit_cfg_setters = {
+        "max_opqueue_num": instance.set_max_opqueue_num,
+        "err_msg_mode": instance.set_err_msg_mode,
+        "dump": instance.set_lite_exception_dump
+    }
+    aclinit_cfg_set = tuple(aclinit_cfg_modes.keys())
+    for key, value in config.items():
+        if key not in aclinit_cfg_set:
+            raise ValueError(f"For 'ms.device_context.ascend.op_debug.aclinit_config', the key must be one of "
+                             f"{aclinit_cfg_set}, but got {key}.")
+        supported_modes = aclinit_cfg_modes.get(key)
+        if isinstance(supported_modes, list) and value not in supported_modes:
+            raise ValueError(f"For 'ms.device_context.ascend.op_debug.aclinit_config', the value of argument {key} "
+                             f"must be one of {supported_modes}, but got {value}.")
+        if isinstance(supported_modes, tuple) and not isinstance(value, supported_modes):
+            raise TypeError(f"For 'ms.device_context.ascend.op_debug.aclinit_config', the type of argument {key} "
+                            f"must be one of {supported_modes}, but got {type(value)}.")
+        cfg_setter = aclinit_cfg_setters.get(key)
+        cfg_setter(value)

mindspore/device_context/ascend/op_precision.py

@@ -0,0 +1,193 @@
+# Copyright 2024 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Op precision interfaces."""
+import os
+from mindspore._checkparam import args_type_check
+from .device import _is_supported
+
+try:
+    from mindspore._c_expression import AscendOpPrecisionConf
+except ImportError:
+    pass
+
+function_status = {'precision_mode': False, 'op_precision_mode': False,
+                   'matmul_allow_hf32': False, 'conv_allow_hf32': False}
+
+
+def precision_mode(mode):
+    """
+    Configure mixed precision mode setting. The framework set the configuration of Atlas training series
+    products to "force_fp16" by default, and set the configuration for other products such as the Atlas A2
+    training series products to "must_keep_origin_dtype" by default.
+    For detailed information, please refer to `Ascend community
+    <https://www.hiascend.com/document/detail/zh/canncommercial/80RC3/apiref/appdevgapi/aclcppdevg_03_1371.html/>`_ .
+
+    Note:
+        - The default value of `precision_mode` is experimental parameter, may change in the future.
+
+    Args:
+        mode (str): The operator precision mode setting.
+            The value range is as follows:
+
+            - force_fp16: When the operator supports both float16 and float32, directly choose float16.
+            - allow_fp32_to_fp16: For matrix-type operators, use float16. For vector-type operators, prioritize
+              the original precision. If the operator in the network model supports float32, retain the original
+              precision float32. If the operator in the network model does not support float32, directly reduce
+              the precision to float16.
+            - allow_mix_precision: Automatic mixed precision, for all operators in the network, according to the
+              built-in optimization strategy, automatically reduce the precision of some operators to float16 or
+              bfloat16.
+            - must_keep_origin_dtype: Maintain the original precision.
+            - force_fp32: When the input of the matrix calculation operator is float16, and the output supports both
+              float16 and float32, force the output to be converted to float32.
+            - allow_fp32_to_bf16: For matrix-type operators, use bfloat16. For vector-type operators, prioritize the
+              original precision. If the operator in the network model supports float32, retain the original precision
+              float32. If the operator in the network model does not support float32, directly reduce the precision
+              to bfloat16.
+            - allow_mix_precision_fp16: Automatic mixed precision, for all operators in the network, according to
+              the built-in optimization strategy, automatically reduce the precision of some operators to float16.
+            - allow_mix_precision_bf16: Automatic mixed precision, for all operators in the network, according to
+              the built-in optimization strategy, automatically reduce the precision of some operators to bfloat16.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.ascend.op_precision.precision_mode("force_fp16")
+    """
+    if not function_status['precision_mode']:
+        function_status['precision_mode'] = True
+        if not _is_supported():
+            return
+    if mode == AscendOpPrecisionConf.get_instance().precision_mode():
+        return
+    # Check the configuration environment whether valid
+    if AscendOpPrecisionConf.get_instance().is_precision_mode_configured():
+        raise RuntimeError("The 'precision_mode' can not be set repeatedly.")
+    supported_modes = [
+        "force_fp16",
+        "allow_fp32_to_fp16",
+        "allow_mix_precision",
+        "must_keep_origin_dtype",
+        "force_fp32",
+        "allow_fp32_to_bf16",
+        "allow_mix_precision_fp16",
+        "allow_mix_precision_bf16",
+    ]
+    if mode not in supported_modes:
+        raise ValueError(f"For 'precision_mode', the value of mode {mode} must be one of "
+                         f"{supported_modes}, but got {mode}.")
+    AscendOpPrecisionConf.get_instance().set_precision_mode(mode)
+
+
+@args_type_check(path=str)
+def op_precision_mode(path):
+    """
+    Path to config file of op precision mode.
+    For detailed information, please refer to `Ascend community
+    <https://www.hiascend.com/document/detail/zh/canncommercial/80RC3/apiref/appdevgapi/aclcppdevg_03_1371.html/>`_ .
+
+    Args:
+        path (str): Directory of the configuration file (.ini format) for setting the operator precision mode.
+          The directory can contain letters, digits, underscores (_), hyphens (-), and periods (.).
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.ascend.op_precision.op_precision_mode("./op_precision_config_file")
+    """
+    if not function_status['op_precision_mode']:
+        function_status['op_precision_mode'] = True
+        if not _is_supported():
+            return
+    if path == AscendOpPrecisionConf.get_instance().op_precision_mode():
+        return
+    # Check the configuration environment whether valid
+    if AscendOpPrecisionConf.get_instance().is_op_precision_mode_configured():
+        raise RuntimeError("The 'op_precision_mode' can not be set repeatedly.")
+    op_precision_path = path
+    real_path = os.path.realpath(op_precision_path)
+    if not os.path.exists(real_path):
+        raise ValueError(
+            f"For 'op_precision_mode', the 'path' is invalid, "
+            f"got '{op_precision_path}'."
+        )
+    AscendOpPrecisionConf.get_instance().set_op_precision_mode(path)
+
+
+def matmul_allow_hf32(value):
+    """
+    Whether to convert FP32 to HF32 for Matmul operators. CANN disables FP32 to HF32
+    for Matmul operators by default.
+    For detailed information, please refer to `Ascend community
+    <https://www.hiascend.com/document/detail/zh/canncommercial/80RC3/apiref/appdevgapi/aclcppdevg_03_1371.html/>`_ .
+
+    Note:
+        - This is an experimental prototype that is subject to change and/or deletion.
+
+    Args:
+        value (bool): Whether to convert FP32 to HF32 for Matmul operators
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.ascend.op_precision.matmul_allow_hf32(True)
+    """
+    if not function_status['matmul_allow_hf32']:
+        function_status['matmul_allow_hf32'] = True
+        if not _is_supported():
+            return
+    supported_modes = [True, False]
+    if value not in supported_modes:
+        raise ValueError(f"For 'matmul_allow_hf32', the type of input value must be one of "
+                         f"{supported_modes}, but got {value}.")
+    is_enable = "1" if value else "0"
+    if is_enable == AscendOpPrecisionConf.get_instance().matmul_allow_hf32():
+        return
+    # Check the configuration environment whether valid
+    if AscendOpPrecisionConf.get_instance().is_matmul_allow_hf32_configured():
+        raise RuntimeError("The 'matmul_allow_hf32' can not be set repeatedly.")
+    AscendOpPrecisionConf.get_instance().set_matmul_allow_hf32(is_enable)
+
+
+def conv_allow_hf32(value):
+    """
+    Whether to convert FP32 to HF32 for Conv operators. CANN enables FP32 to HF32
+    for Conv operators by default.
+    For detailed information, please refer to `Ascend community
+    <https://www.hiascend.com/document/detail/zh/canncommercial/80RC3/apiref/appdevgapi/aclcppdevg_03_1371.html/>`_ .
+
+    Note:
+        - This is an experimental prototype that is subject to change and/or deletion.
+
+    Args:
+        value (bool): Whether to convert FP32 to HF32 for Conv operators.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.ascend.op_precision.conv_allow_hf32(True)
+    """
+    if not function_status['conv_allow_hf32']:
+        function_status['conv_allow_hf32'] = True
+        if not _is_supported():
+            return
+    supported_modes = [True, False]
+    if value not in supported_modes:
+        raise ValueError(f"For 'conv_allow_hf32', the type of input value must be one of "
+                         f"{supported_modes}, but got {value}.")
+    is_enable = "1" if value else "0"
+    if is_enable == AscendOpPrecisionConf.get_instance().conv_allow_hf32():
+        return
+    # Check the configuration environment whether valid
+    if AscendOpPrecisionConf.get_instance().is_conv_allow_hf32_configured():
+        raise RuntimeError("The 'conv_allow_hf32' can not be set repeatedly.")
+    AscendOpPrecisionConf.get_instance().set_conv_allow_hf32(is_enable)

mindspore/device_context/ascend/op_tuning.py

@@ -0,0 +1,123 @@
+# Copyright 2024 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Op tuning interfaces."""
+try:
+    from mindspore._c_expression import AscendOpTuningConf
+except ImportError:
+    pass
+from .device import _is_supported
+
+function_status = {'op_compile': False, 'aoe_tune_mode': False,
+                   'aoe_job_type': False}
+
+
+def op_compile(value):
+    """
+    Whether to select online compilation.The default settings by the framework are online compilation for static
+    shape, and compiled operator binary files for dynamic shape. The default settings may change in the future.
+    For detailed information, please refer to `Ascend community
+    <https://www.hiascend.com/document/detail/zh/canncommercial/80RC3/apiref/appdevgapi/aclcppdevg_03_1371.html/>`_ .
+
+    Args:
+        value (bool): Whether to select online compilation or not.
+
+            - ``True``: online compilation is prioritized.
+            - ``False``: compiled operator binary files are prioritized to improve compilation performance.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.ascend.op_tuning.op_compile(True)
+    """
+    if not function_status['op_compile']:
+        function_status['op_compile'] = True
+        if not _is_supported():
+            return
+    if value == AscendOpTuningConf.get_instance().jit_compile():
+        return
+    # Check the configuration environment whether valid
+    if AscendOpTuningConf.get_instance().is_jit_compile_configured():
+        raise RuntimeError("The 'op_compile' can not be set repeatedly.")
+    supported_modes = [True, False]
+    if value not in supported_modes:
+        raise TypeError(f"For 'op_compile', the type of input value must be one of "
+                        f"{supported_modes}, but got {value}.")
+    is_enable = "1" if value else "0"
+    AscendOpTuningConf.get_instance().set_jit_compile(is_enable)
+
+
+def aoe_tune_mode(tune_mode):
+    """
+    AOE tuning mode setting, which is not set by default.
+
+    Args:
+        tune_mode (str): AOE tuning mode setting.
+
+          - ``"online"``: the online tuning function is turned on.
+          - ``"offline"``: ge graph will be saved for offline tuning.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.ascend.op_tuning.aoe_tune_mode("online")
+    """
+    if not function_status['aoe_tune_mode']:
+        function_status['aoe_tune_mode'] = True
+        if not _is_supported():
+            return
+    if tune_mode == AscendOpTuningConf.get_instance().aoe_tune_mode():
+        return
+    # Check the configuration environment whether valid
+    if AscendOpTuningConf.get_instance().is_aoe_tune_mode_configured():
+        raise RuntimeError("The 'aoe_tune_mode' can not be set repeatedly.")
+    candidate = ["online", "offline"]
+    if tune_mode not in candidate:
+        raise ValueError(
+            f"For 'device_context.ascend.op_tuning.aoe_tune_mode', the argument 'tune_mode' must be in "
+            f"['online', 'offline'], but got {tune_mode}."
+        )
+    AscendOpTuningConf.get_instance().set_aoe_tune_mode(tune_mode)
+
+
+def aoe_job_type(config):
+    """
+    Set the parameters specific to Ascend Optimization Engine.It needs to be used in
+    conjunction with mindspore.device_context.op_tuning.aoe_tune_mode(tune_mode).
+    The framework set to "2" by default.
+
+    Args:
+        config (str): Choose the tuning type.
+
+            - ``"1"``: Set to subgraph tuning.
+            - ``"2"``: Set to operator tuning.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.ascend.op_tuning.aoe_job_type("1")
+    """
+    if not function_status['aoe_job_type']:
+        function_status['aoe_job_type'] = True
+        if not _is_supported():
+            return
+    if config == AscendOpTuningConf.get_instance().aoe_job_type():
+        return
+    # Check the configuration environment whether valid
+    if AscendOpTuningConf.get_instance().is_aoe_job_type_configured():
+        raise RuntimeError("The 'aoe_job_type' can not be set repeatedly.")
+    aoe_cfgs = ["1", "2"]
+    if config not in aoe_cfgs:
+        raise ValueError(
+            f"For 'aoe_job_type', the config must be one of {aoe_cfgs}, but got {config}."
+        )
+    AscendOpTuningConf.get_instance().set_aoe_job_type(config)