mindspore 2.4.10__cp311-none-any.whl → 2.5.0__cp311-none-any.whl

mindspore/dataset/engine/validators.py

@@ -16,9 +16,12 @@
 """
 Built-in validators.
 """
+
+import collections
 import inspect as ins
 import os
 from functools import wraps
+
 import numpy as np
 
 from mindspore._c_expression import typing
@@ -28,7 +31,6 @@ from ..core.validator_helpers import parse_user_args, type_check, type_check_lis
     validate_dataset_param_value, check_padding_options, \
     check_num_parallel_workers, check_columns, check_pos_int32, check_valid_str, check_dataset_num_shards_shard_id, \
     check_valid_list_tuple, check_int32, check_independent_mode
-
 from . import datasets
 from . import samplers
 from . import cache_client
@@ -976,7 +978,7 @@ def check_tuple_iterator(method):
     @wraps(method)
     def new_method(self, *args, **kwargs):
         [columns, num_epochs, _, _], param_dict = parse_user_args(method, *args, **kwargs)
-        nreq_param_bool = ['output_numpy']
+        nreq_param_bool = ['output_numpy', 'do_copy']
         validate_dataset_param_value(nreq_param_bool, param_dict, bool)
         if num_epochs is not None:
             type_check(num_epochs, (int,), "num_epochs")
@@ -996,7 +998,7 @@ def check_dict_iterator(method):
     @wraps(method)
     def new_method(self, *args, **kwargs):
         [num_epochs, _, _], param_dict = parse_user_args(method, *args, **kwargs)
-        nreq_param_bool = ['output_numpy']
+        nreq_param_bool = ['output_numpy', 'do_copy']
         validate_dataset_param_value(nreq_param_bool, param_dict, bool)
         if num_epochs is not None:
             type_check(num_epochs, (int,), "num_epochs")
@@ -1071,7 +1073,34 @@ def check_source_function(source):
     return str(var) + source_doc
 
 
-def check_generatordataset(method):
+def check_batch_sampler(batch_sampler, num_samples, shuffle, num_shards, shard_id, sampler, collate_fn):
+    """Check whether the params are valid with batch_sampler."""
+    if batch_sampler is not None:
+        if not all(param is None for param in [num_samples, shuffle, num_shards, shard_id, sampler]):
+            raise ValueError("batch_sampler is mutually exclusive with num_samples, shuffle, num_shards, "
+                             "shard_id and sampler.")
+        if not isinstance(batch_sampler, (samplers.BuiltinSampler, collections.abc.Iterable)):
+            raise TypeError("batch_sampler should have __getitem__ or __iter__ method.")
+
+    if collate_fn is not None:
+        if batch_sampler is None:
+            raise ValueError("collate_fn can be specified only when batch_sampler is set.")
+        if not isinstance(collate_fn, collections.abc.Callable):
+            raise TypeError("collate_fn should be callable.")
+
+
+def check_valid_map_style_dataset(source, sampler, batch_sampler, num_shards):
+    """Check whether the params are valid for map style dataset."""
+    if not hasattr(source, "__getitem__"):
+        if sampler is not None:
+            raise ValueError("sampler is not supported if source does not have attribute '__getitem__'.")
+        if batch_sampler is not None:
+            raise ValueError("batch_sampler is not supported if source does not have attribute '__getitem__'.")
+        if num_shards is not None:
+            raise ValueError("num_shards is not supported if source does not have attribute '__getitem__'.")
+
+
+def check_generator_dataset(method):
     """A wrapper that wraps a parameter checker around the original Dataset(GeneratorDataset)."""
 
     @wraps(method)
@@ -1133,10 +1162,13 @@ def check_generatordataset(method):
                 except TypeError:
                     raise TypeError("sampler should be either iterable or from mindspore.dataset.samplers.")
 
-        if sampler is not None and not hasattr(source, "__getitem__"):
-            raise ValueError("sampler is not supported if source does not have attribute '__getitem__'.")
-        if num_shards is not None and not hasattr(source, "__getitem__"):
-            raise ValueError("num_shards is not supported if source does not have attribute '__getitem__'.")
+        batch_sampler = param_dict.get("batch_sampler")
+        num_samples = param_dict.get("num_samples")
+        shuffle = param_dict.get("shuffle")
+        collate_fn = param_dict.get("collate_fn")
+        check_batch_sampler(batch_sampler, num_samples, shuffle, num_shards, shard_id, sampler, collate_fn)
+
+        check_valid_map_style_dataset(source, sampler, batch_sampler, num_shards)
 
         return method(self, *args, **kwargs)
 
@@ -1306,7 +1338,7 @@ def check_batch(method):
             sig = ins.signature(batch_size)
             if len(sig.parameters) != 1:
                 raise ValueError("callable batch_size should take one parameter (BatchInfo).")
-        else:
+        elif batch_size != -1:
             check_pos_int32(int(batch_size), "batch_size")
 
         if num_parallel_workers is not None:
@@ -1977,7 +2009,7 @@ def check_hostname(hostname):
     return all(allowed.match(x) for x in hostname.split("."))
 
 
-def check_numpyslicesdataset(method):
+def check_numpy_slices_dataset(method):
     """A wrapper that wraps a parameter checker around the original Dataset(NumpySlicesDataset)."""
 
     @wraps(method)
@@ -2018,7 +2050,7 @@ def check_numpyslicesdataset(method):
     return new_method
 
 
-def check_paddeddataset(method):
+def check_padded_dataset(method):
     """A wrapper that wraps a parameter checker around the original Dataset(PaddedDataset)."""
 
     @wraps(method)

mindspore/dataset/transforms/py_transforms_util.py

@@ -19,6 +19,8 @@ import json
 import random
 from enum import IntEnum
 from types import FunctionType, MethodType
+
+import dill
 import numpy as np
 
 from mindspore import log as logger
@@ -187,6 +189,7 @@ class FuncWrapper:
             raise ValueError("Input operations should be callable Python function, but got: " + str(transform))
         self.transform = transform
         self.implementation = Implementation.C
+        self.random = False
         try:
             if hasattr(self.transform, "random") and not self.transform.random:
                 self.random = False
@@ -211,6 +214,20 @@ class FuncWrapper:
                 logger.warning(warn_msg)
         return result
 
+    def __getstate__(self):
+        transform = dill.dumps(self.transform)
+        implementation = dill.dumps(self.implementation)
+        local_random = dill.dumps(self.random)
+        logged_list_mixed_type_warning = dill.dumps(self.logged_list_mixed_type_warning)
+        return (transform, implementation, local_random, logged_list_mixed_type_warning)
+
+    def __setstate__(self, state):
+        transform, implementation, local_random, logged_list_mixed_type_warning = state
+        self.transform = dill.loads(transform)
+        self.implementation = dill.loads(implementation)
+        self.random = dill.loads(local_random)
+        self.logged_list_mixed_type_warning = dill.loads(logged_list_mixed_type_warning)
+
     def to_json(self):
         """ Serialize to JSON format """
         # User-defined Python functions cannot be fully nor correctly serialized.

mindspore/dataset/transforms/transforms.py

@@ -95,18 +95,35 @@ class TensorOperation:
         # get or create the executor from EXECUTORS_LIST
         executor = None
         key = str(os.getpid()) + "_" + str(threading.currentThread().ident)
-        if key in EXECUTORS_LIST:
-            # get the executor by process id and thread id
-            executor = EXECUTORS_LIST[key]
-            # remove the old transform which in executor and update the new transform
-            executor.UpdateOperation(self.parse())
-        else:
-            # create a new executor by process id and thread_id
-            executor = cde.Execute(self.parse())
-            # add the executor the global EXECUTORS_LIST
-            EXECUTORS_LIST[key] = executor
-
-        output_tensor_list = executor(tensor_row)
+        try:
+            if key in EXECUTORS_LIST:
+                # get the executor by process id and thread id
+                executor = EXECUTORS_LIST[key]
+                # remove the old transform which in executor and update the new transform
+                executor.UpdateOperation(self.parse())
+            else:
+                # create a new executor by process id and thread_id
+                executor = cde.Execute(self.parse())
+                # add the executor the global EXECUTORS_LIST
+                EXECUTORS_LIST[key] = executor
+
+            output_tensor_list = executor(tensor_row)
+        except RuntimeError as e:
+            if "Create stream failed" in str(e):
+                raise RuntimeError("Cannot reset NPU device in forked subprocess.\n    "
+                                   "Note: the following sevral scenarios are not supported yet.\n"
+                                   "    1. GeneratorDataset with num_parallel_workers>1 and "
+                                   "python_multiprocessing=True.\n    2. Independent dataset mode (export "
+                                   "MS_INDEPENDENT_DATASET=True):\n        1) Use the eager mode of dvpp "
+                                   "in the main process, and then start the dataset independent process. "
+                                   "GeneratorDataset / map / batch performs dvpp operations in thread mode.\n"
+                                   "        2) Initialize the device in the main process, and then start the "
+                                   "dataset independent process. GeneratorDataset / map / batch executes the "
+                                   "dvpp operation in thread mode.\n    "
+                                   "Suggestion: except for the scenes above to use NPU with multiprocessing, "
+                                   "you can set ds.config.set_multiprocessing_start_method('spawn') in your "
+                                   "script and rerun.")
+            raise e
         output_numpy_list = [x.as_array() for x in output_tensor_list]
         return output_numpy_list[0] if len(output_numpy_list) == 1 else tuple(output_numpy_list)
 

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,94 @@
+# 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 AICPU 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)

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)