mindspore 2.4.10__cp311-cp311-win_amd64.whl → 2.6.0__cp311-cp311-win_amd64.whl

mindspore/{ops_generate/gen_constants.py → device_context/cpu/__init__.py}

@@ -12,25 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
+
 """
-Generate constants
+The cpu device context interface.
 """
-import os
-
-# op_def
-OP_DEF_AUTO_GENERATE_PATH = "op_def/auto_generate"
-MS_OP_DEF_AUTO_GENERATE_PATH = "mindspore/ops/op_def/auto_generate"
-YAML_PATH = "op_def/yaml"
-MS_YAML_PATH = "mindspore/ops/" + YAML_PATH
-PY_AUTO_GEN_PATH = "mindspore/python/mindspore/ops/auto_generate"
-PY_OPS_GEN_PATH = "mindspore/python/mindspore/ops_generate"
 
-# infer
-MS_OPS_FUNC_IMPL_PATH = "mindspore/ops/infer/ops_func_impl"
+from mindspore.device_context.cpu.op_tuning import threads_num
+from mindspore.device_context.cpu.device import is_available, device_count
 
-# view
-MS_OPS_VIEW_PATH = "mindspore/ops/view"
+__all__ = ["threads_num", "is_available", "device_count"]
 
-# kernel
-MS_OPS_KERNEL_PATH = "mindspore/ops/kernel"
-MS_COMMON_PYBOOST_KERNEL_PATH = os.path.join(MS_OPS_KERNEL_PATH, "common/pyboost")
+__all__.sort()

mindspore/device_context/cpu/device.py

@@ -0,0 +1,62 @@
+# 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 CPU device interfaces."""
+from mindspore._c_expression import MSContext
+from mindspore import log as logger
+
+
+def is_available():
+    """
+    Return whether cpu backend is available.
+
+    Returns:
+        Bool, whether the cpu backend is available for this MindSpore package.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> print(ms.device_context.cpu.is_available())
+        True
+    """
+    # MindSpore will try to load plugins in "import mindspore", and availability status will be stored.
+    context = MSContext.get_instance()
+    if not context.is_pkg_support_device("CPU"):
+        logger.warning(f"The CPU device is not available.")
+        load_plugin_error = context.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 device_count():
+    """
+    Returns compute-capable device count of CPU.
+
+    Note:
+        - For CPU hardware, 1 is always returned.
+
+    Returns:
+        int, The number of compute-capable CPU devices.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> print(ms.device_context.cpu.device_count())
+        1
+    """
+    return 1

mindspore/device_context/cpu/op_tuning.py

@@ -0,0 +1,43 @@
+# 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."""
+
+from mindspore._c_expression import RuntimeConf
+from mindspore import _checkparam as Validator
+from mindspore._checkparam import args_type_check
+
+
+@args_type_check(num=int)
+def threads_num(num):
+    """
+    Set the threads number of CPU kernel used.
+
+    The framework set the threads number of CPU kernel used are ``25`` by default.
+
+    Args:
+        num (int): The threads number of CPU kernel used.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.set_device("Ascend", 1)
+        >>> ms.device_context.cpu.op_tuning.threads_num(10)
+    """
+    if RuntimeConf.get_instance().is_op_threads_num_configured():
+        raise RuntimeError("The 'threads_num' can not be set repeatedly.")
+
+    num = Validator.check_positive_int(num, "num")
+
+    return RuntimeConf.get_instance().set_op_threads_num(num)

mindspore/device_context/gpu/__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.
+# ============================================================================
+"""init file for GPU device context"""
+
+from .device import device_count, is_available
+from .op_precision import *
+from .op_tuning import *
+
+__all__ = ["device_count", "is_available"]

mindspore/device_context/gpu/device.py

@@ -0,0 +1,70 @@
+# 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 GPU interfaces"""
+import mindspore as ms
+from mindspore import log as logger
+from mindspore._c_expression import MSContext
+try:
+    from mindspore._c_expression import gpu_get_device_count
+except ImportError:
+    pass
+
+
+def device_count():
+    """
+    Return the number of GPUs available.
+
+    Returns:
+        Bool, the number of GPUs available.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.gpu.device.device_count()
+    """
+    if not MSContext.get_instance().is_pkg_support_device("GPU") or not is_available():
+        raise RuntimeError(f"Device_target GPU not exist.")
+
+    return gpu_get_device_count()
+
+
+def is_available():
+    """
+    Return a bool indicating if CUDA is currently available.
+
+    Returns:
+        Bool, indicating if CUDA is currently available.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.gpu.device.is_available()
+    """
+    # MindSpore will try to load plugins in "import mindspore", and availability status will be stored.
+    if not MSContext.get_instance().is_pkg_support_device("GPU"):
+        logger.warning(f"Device GPU 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 == 'Ascend':
+        logger.error(f"{device_target} device is not supported. Please use correct device")
+        return False
+    return True

mindspore/device_context/gpu/op_precision.py

@@ -0,0 +1,67 @@
+# 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."""
+
+from mindspore._checkparam import args_type_check
+from .device import _is_supported
+try:
+    from mindspore._c_expression import GPUOpPrecisionConf
+except ImportError:
+    pass
+
+function_status = {'matmul_allow_tf32': False, 'conv_allow_tf32': False}
+
+
+@args_type_check(value=bool)
+def matmul_allow_tf32(value):
+    """
+    Whether to convert FP32 to TF32 for Matmul operators.
+    For detailed information, please refer to `CUBLAS_COMPUTE_32F_FAST_TF32 <https://docs.nvidia.com/cuda/cublas/index.html>`_.
+
+    Args:
+        value (bool): Whether to convert FP32 to TF32 for Matmul operators. If not configured, the framework
+            defaults to ``False``.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.gpu.op_precision.matmul_allow_tf32(True)
+    """
+    if not function_status['matmul_allow_tf32']:
+        function_status['matmul_allow_tf32'] = True
+        if not _is_supported():
+            return
+    GPUOpPrecisionConf.get_instance().matmul_allow_tf32(value)
+
+
+@args_type_check(value=bool)
+def conv_allow_tf32(value):
+    """
+    Whether to convert FP32 to TF32 for Conv operators.
+    For detailed information, please refer to `CUBLAS_COMPUTE_32F_FAST_TF32 <https://docs.nvidia.com/cuda/cublas/index.html>`_.
+
+    Args:
+        value (bool): Whether to convert FP32 to HF32 for Conv operators. If not configured, the framework defaults
+            to ``True``.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.gpu.op_precision.conv_allow_tf32(False)
+    """
+    if not function_status['conv_allow_tf32']:
+        function_status['conv_allow_tf32'] = True
+        if not _is_supported():
+            return
+    GPUOpPrecisionConf.get_instance().conv_allow_tf32(value)

mindspore/device_context/gpu/op_tuning.py

@@ -0,0 +1,175 @@
+# 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 GPUOpTuningConf
+except ImportError:
+    pass
+from .device import _is_supported
+
+function_status = {'conv_fprop_algo': False, 'conv_wgrad_algo': False, 'conv_dgrad_algo': False}
+
+
+def conv_fprop_algo(mode):
+    """
+    Specifies convolution forward algorithm.
+    For detailed information, please refer to `NVIDA cuDNN about cudnnConvolutionForward <https://docs.nvidia.com/deeplearning/cudnn/latest/api/cudnn-cnn-library.html>`_.
+
+    Args:
+        mode (str): convolution forward algorithm. If not configured, the framework defaults to 'normal'.
+          The value range is as follows:
+
+          - normal: Use the cuDNN's heuristic search algorithm, the appropriate convolution algorithm will be quickly
+            selected based on the convolution shape and type. This parameter does not guarantee optimal performance.
+          - performance: Use the cuDNN's trial search algorithm, all convolution algorithms will be trial run based on
+            the convolution shape and type, and the optimal algorithm will be selected. This parameter ensures optimal
+            performance.
+          - implicit_gemm: This algorithm expresses the convolution as a matrix product without actually explicitly
+            forming the matrix that holds the input tensor data.
+          - precomp_gemm: This algorithm expresses convolution as a matrix product without actually explicitly
+            forming the matrix that holds the input tensor data, but still needs some memory workspace to precompute
+            some indices in order to facilitate the implicit construction of the matrix that holds the input tensor
+            data.
+          - gemm: This algorithm expresses the convolution as an explicit matrix product. A significant memory
+            workspace is needed to store the matrix that holds the input tensor data.
+          - direct: This algorithm expresses the convolution as a direct convolution, without implicitly or explicitly
+            doing a matrix multiplication.
+          - fft: This algorithm uses the Fast-Fourier Transform approach to compute the convolution. A significant
+            memory workspace is needed to store intermediate results.
+          - fft_tiling: This algorithm uses the Fast-Fourier Transform approach but splits the inputs into tiles. A
+            significant memory workspace is needed to store intermediate results but less than fft algorithm for large
+            size images.
+          - winograd: This algorithm uses the Winograd Transform approach to compute the convolution. A reasonably
+            sized workspace is needed to store intermediate results.
+          - winograd_nonfused: This algorithm uses the Winograd Transform approach to compute the convolution. A
+            significant workspace may be needed to store intermediate results.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.gpu.op_tuning.conv_fprop_algo("performance")
+    """
+    if not function_status['conv_fprop_algo']:
+        function_status['conv_fprop_algo'] = True
+        if not _is_supported():
+            return
+    conv_fprop_algo_mode = ["normal", "performance", "implicit_gemm", "precomp_gemm", "gemm", "direct",
+                            "fft", "fft_tiling", "winograd", "winograd_nonfused"]
+    if mode in conv_fprop_algo_mode:
+        GPUOpTuningConf.get_instance().set_conv_fprop_algo(mode)
+    else:
+        raise ValueError(
+            f"For 'mindspore.device_context.gpu.op_tuning.conv_fprop_algo', the argument must be in "
+            f"{conv_fprop_algo_mode} but got {mode}."
+        )
+
+
+def conv_wgrad_algo(mode):
+    """
+    Specifies convolution filter grad algorithm.
+    For detailed information, please refer to `NVIDA cuDNN <https://docs.nvidia.com/deeplearning/cudnn/latest/api/cudnn-cnn-library.html>`_.
+
+    Args:
+        mode (str): convolution filter grad algorithm. If not configured, the framework defaults to 'normal'.
+          The value range is as follows:
+
+          - normal: Use the cuDNN's heuristic search algorithm, the appropriate convolution algorithm will be quickly
+            selected based on the convolution shape and type. This parameter does not guarantee optimal performance.
+          - performance: Use the cuDNN's trial search algorithm, all convolution algorithms will be trial run based on
+            the convolution shape and type, and the optimal algorithm will be selected. This parameter ensures optimal
+            performance.
+          - algo_0: This algorithm expresses the convolution as a sum of matrix products without actually explicitly
+            forming the matrix that holds the input tensor data. The sum is done using the atomic add operation, thus
+            the results are non-deterministic.
+          - algo_1: This algorithm expresses the convolution as a matrix product without actually explicitly forming
+            the matrix that holds the input tensor data. The results are deterministic.
+          - algo_3: This algorithm is similar to algo_0 but uses some small workspace to precompute some indices. The
+            results are also non-deterministic.
+          - fft: This algorithm uses a Fast-Fourier Transform approach to compute the convolution. A significant memory
+            workspace is needed to store intermediate results. The results are deterministic.
+          - fft_tiling: This algorithm uses the Fast-Fourier Transform approach but splits the inputs into tiles. A
+            significant memory workspace is needed to store intermediate results but less than fft for large size
+            images. The results are deterministic.
+          - winograd_nonfused: This algorithm uses the Winograd Transform approach to compute the convolution. A
+            significant workspace may be needed to store intermediate results. The results are deterministic.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.gpu.op_tuning.conv_wgrad_algo("performance")
+    """
+    if not function_status['conv_wgrad_algo']:
+        function_status['conv_wgrad_algo'] = True
+        if not _is_supported():
+            return
+    conv_wgrad_algo_mode = ["normal", "performance", "algo_0", "algo_1", "fft", "algo_3",
+                            "fft_tiling", "winograd_nonfused"]
+
+    if mode in conv_wgrad_algo_mode:
+        GPUOpTuningConf.get_instance().set_conv_wgrad_algo(mode)
+    else:
+        raise ValueError(
+            f"For 'mindspore.device_context.gpu.op_tuning.conv_wgrad_algo', the argument must be in "
+            f"{conv_wgrad_algo_mode} but got {mode}."
+        )
+
+
+def conv_dgrad_algo(mode):
+    """
+    Specifies convolution data grad algorithm.
+    For detailed information, please refer to `NVIDA cuDNN <https://docs.nvidia.com/deeplearning/cudnn/latest/api/cudnn-cnn-library.html>`_.
+
+    Args:
+        mode (str): convolution data grad algorithm. If not configured, the framework defaults to 'normal'.
+          The value range is as follows:
+
+          - normal: Use the cuDNN's heuristic search algorithm, the appropriate convolution algorithm will be quickly
+            selected based on the convolution shape and type. This parameter does not guarantee optimal performance.
+          - performance: Use the cuDNN's trial search algorithm, all convolution algorithms will be trial run based on
+            the convolution shape and type, and the optimal algorithm will be selected. This parameter ensures optimal
+            performance.
+          - algo_0: This algorithm expresses the convolution as a sum of matrix products without actually explicitly
+            forming the matrix that holds the input tensor data. The sum is done using the atomic add operation, thus
+            the results are non-deterministic.
+          - algo_1: This algorithm expresses the convolution as a matrix product without actually explicitly forming
+            the matrix that holds the input tensor data. The results are deterministic.
+          - fft: This algorithm uses a Fast-Fourier Transform approach to compute the convolution. A significant memory
+            workspace is needed to store intermediate results. The results are deterministic.
+          - fft_tiling: This algorithm uses the Fast-Fourier Transform approach but splits the inputs into tiles. A
+            significant memory workspace is needed to store intermediate results but less than fft for large size
+            images. The results are deterministic.
+          - winograd: This algorithm uses the Winograd Transform approach to compute the convolution. A reasonably
+            sized workspace is needed to store intermediate results. The results are deterministic.
+          - winograd_nonfused: This algorithm uses the Winograd Transform approach to compute the convolution. A
+            significant workspace may be needed to store intermediate results. The results are deterministic.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.device_context.gpu.op_tuning.conv_dgrad_algo("performance")
+    """
+    if not function_status['conv_dgrad_algo']:
+        function_status['conv_dgrad_algo'] = True
+        if not _is_supported():
+            return
+    conv_dgrad_algo_mode = ["normal", "performance", "algo_0", "algo_1", "fft", "fft_tiling",
+                            "winograd", "winograd_nonfused"]
+
+    if mode in conv_dgrad_algo_mode:
+        GPUOpTuningConf.get_instance().set_conv_dgrad_algo(mode)
+    else:
+        raise ValueError(
+            f"For 'mindspore.device_context.gpu.op_tuning.conv_dgrad_algo', the argument must be in "
+            f"{conv_dgrad_algo_mode} but got {mode}."
+        )

mindspore/device_manager.py

@@ -0,0 +1,170 @@
+# 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 manager interfaces."""
+
+import os
+from mindspore import log as logger
+from mindspore._c_expression import DeviceManagerConf, DeviceContextManager, MSContext, CollectiveManager
+from mindspore._checkparam import args_type_check
+from mindspore.parallel._ps_context import _need_reset_device_target_for_ps
+
+
+__all__ = ['set_device', 'set_deterministic', 'get_current_device']
+
+
+class DeviceInfo(tuple):
+    """
+    DeviceInfo class. Store the current device target and the corresponding device id.
+    """
+    def __new__(cls, device_target, device_id):
+        return super().__new__(cls, (device_target, device_id))
+
+    @property
+    def device_target(self):
+        return self[0]
+
+    @property
+    def device_id(self):
+        return self[1]
+
+
+@args_type_check(device_target=str, device_id=int)
+def set_device(device_target, device_id=None):
+    """
+    Set device target and device id for running environment.
+
+    Note:
+        - The `device_target` must be set in the ["CPU", "GPU", "Ascend"], there is no default value.
+        - Suggest setting `device_target` and `device_id` before calling :func:`mindspore.communication.init`.
+
+    Args:
+        device_target (str): The target device to run, only support "Ascend", "GPU", and "CPU".
+        device_id (int, optional): ID of the target device, the value must be in [0, device_num_per_host-1],
+            where device_num_per_host refers to the total number of devices on the host. Default: ``None`` .
+            The frame will set different default behaviours according to the scenario:
+            if it is a single-card scenario, the frame will be set to 0.
+            In a distributed scenario where msrun is started, the framework will
+            automatically negotiate the available device_id values.
+            In a distributed scenario with other startup methods, the frame is set to 0.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.set_device("Ascend", 1)
+    """
+    valid_targets = ["CPU", "GPU", "Ascend"]
+    if device_target not in valid_targets:
+        raise ValueError(f"The argument 'device_target' must be one of {valid_targets}, but got {device_target}.")
+    # If in Parameter Server mode, Ascend card should not be used by server and scheduler.
+    if _need_reset_device_target_for_ps(device_target):
+        logger.info("Reset device target to CPU when set_device.")
+        device_target = "CPU"
+
+    is_default = False
+    if device_id is None:
+        device_id = 0
+        is_default = True
+    if device_id < 0:
+        raise ValueError("The device id must bigger than or equal to 0.")
+
+    MSContext.get_instance().set_device_target_inner(device_target)
+
+    if DeviceManagerConf.get_instance().is_device_enable():
+        old_device_target = DeviceManagerConf.get_instance().get_device_target()
+        old_device_id = DeviceManagerConf.get_instance().get_device_id()
+        if old_device_target != device_target or old_device_id != device_id:
+            raise RuntimeError("The 'mindspore.set_device' can not be modified.")
+        return
+
+    device_context = DeviceContextManager.get_instance().get_device_context(device_target)
+    if device_context is not None and device_context.initialized():
+        raise RuntimeError("The runtime has been initialized, please set it before the kernel is executed, "
+                           "or before calling 'mindspore.communication.init()'. "
+                           "Suggest setting it as early as possible.")
+    DeviceManagerConf.get_instance().set_device(device_target, device_id, is_default)
+
+
+def get_current_device():
+    """
+    Get device target and device id in the current running environment.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.set_device("Ascend", 1)
+        >>> ms.get_current_device()
+        ('Ascend', 1)
+        >>> ms.get_current_device().device_target
+        'Ascend'
+        >>> ms.get_current_device().device_id
+        1
+    """
+    device_target = DeviceManagerConf.get_instance().get_device_target()
+    device_id = DeviceManagerConf.get_instance().get_device_id()
+    return DeviceInfo(device_target, device_id)
+
+
+@args_type_check(deterministic=bool)
+def set_deterministic(deterministic):
+    """
+    Enables or disables deterministic computing.
+
+    When deterministic computing is enabled, the same output is generated if an operator is executed
+    for multiple times with the same hardware and input.This often slows down operator execution.
+    In distributed scenario, we suggest user to set deterministic mode before
+    calling :func:`mindspore.communication.init` to enable deterministic operation for
+    communication operators in the global communication group.
+
+    The framework not enabled deterministic computation by default.
+
+    Args:
+        deterministic (bool): Whether to enable deterministic computing.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.set_deterministic(True)
+    """
+    # Check the configuration environment whether valid.
+    if DeviceManagerConf.get_instance().is_deterministic_configured():
+        raise RuntimeError("The 'mindspore.set_deterministic' can not be set repeatedly.")
+
+    # Must wait for all async created groups to be initialized so that
+    # deterministic feature could be consistent between all processes.
+    CollectiveManager.get_instance().wait_all_comm_init()
+
+    # Check the hccl_deterministic and te_parallel_compiler.
+    hccl_deterministic = os.getenv("HCCL_DETERMINISTIC")
+    te_parallel_compiler = os.getenv("TE_PARALLEL_COMPILER")
+    if deterministic:
+        if hccl_deterministic and hccl_deterministic != "true":
+            logger.warning(f"Environment 'HCCL_DETERMINISTIC' should be 'true' when set deterministic='True', but "
+                           f"got '{hccl_deterministic}'. 'HCCL_DETERMINISTIC' will be set to 'true'.")
+        if te_parallel_compiler and te_parallel_compiler != "1":
+            logger.warning(f"Environment 'TE_PARALLEL_COMPILER' should be '1' when set deterministic='True', but "
+                           f"got '{te_parallel_compiler}'. 'TE_PARALLEL_COMPILER' will be set to '1'.")
+        os.environ["HCCL_DETERMINISTIC"] = "true"
+        os.environ["TE_PARALLEL_COMPILER"] = "1"
+    else:
+        if hccl_deterministic and hccl_deterministic != "false":
+            logger.warning(f"Environment 'HCCL_DETERMINISTIC' should not be set or be 'false' when set "
+                           f"deterministic='False', but got '{hccl_deterministic}'. 'HCCL_DETERMINISTIC' "
+                           f"will be unset.")
+            del os.environ["HCCL_DETERMINISTIC"]
+        if te_parallel_compiler and te_parallel_compiler != "0":
+            logger.warning(f"Environment 'TE_PARALLEL_COMPILER' should not be set or be '0' when set "
+                           f"deterministic='False', but got '{te_parallel_compiler}'. 'TE_PARALLEL_COMPILER' "
+                           f"will be unset.")
+            del os.environ["TE_PARALLEL_COMPILER"]
+
+    DeviceManagerConf.get_instance().set_deterministic(deterministic)