mindspore 2.6.0rc1__cp310-cp310-win_amd64.whl → 2.7.0rc1__cp310-cp310-win_amd64.whl

mindspore/context.py

@@ -207,7 +207,7 @@ class _Context:
             parallel_mode = _get_auto_parallel_context("parallel_mode")
             if parallel_mode not in (ParallelMode.DATA_PARALLEL, ParallelMode.STAND_ALONE, ParallelMode.AUTO_PARALLEL):
                 raise ValueError(f"Got {parallel_mode}, when the user enabled SEMI_AUTO_PARALELL, "
-                                 f"pynative mode dose not support, you should set either "
+                                 f"pynative mode does not support, you should set either "
                                  f"context.set_auto_parallel_context(parallel_mode='data_parallel'), "
                                  f"context.set_auto_parallel_context(parallel_mode='stand_alone') "
                                  f"or context.set_auto_parallel_context(parallel_mode='auto_parallel').")
@@ -290,6 +290,8 @@ class _Context:
             raise ValueError(f"For 'context.set_context', the argument 'deterministic' must be one of "
                              f"{deterministic_options}, but got {deterministic}.")
 
+        logger.info(f"Set deterministic setting to '{deterministic}'.")
+
         # 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()
@@ -838,6 +840,25 @@ class _Context:
             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)
 
+    @staticmethod
+    def _check_speedup_config_str_value(key, value):
+        """check speedup config str value"""
+        if key in ["pp_1f1b_overlap", "recompute_comm_overlap", "recomputation_communication_overlap"]:
+            if isinstance(value, str):
+                values = value.split(",")
+                for v in values:
+                    if v not in ['AlltoAll', 'AlltoAllV', 'MorphAllGather', 'AllReduce',
+                                 'AllGather', 'ReduceScatter', 'MorphReduceScatter', '']:
+                        raise ValueError("{} 's value should be subset of ['AlltoAll', 'AlltoAllV',"
+                                         " 'MorphAllGather', 'AllGather', 'ReduceScatter',"
+                                         " 'MorphReduceScatter', 'AllReduce'].".format(key))
+                return value
+            if value:
+                return "AlltoAll,AlltoAllV,AllGather,ReduceScatter,AllReduce"
+            return ""
+
+        return value
+
     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 == "":
@@ -848,8 +869,8 @@ class _Context:
                              f"{speedup_config_real_path} does not exist, please check whether the "
                              f"'parallel_speed_up_json_path' is correct.")
         try:
-            valid_option = {"recompute_comm_overlap": (ms_ctx_param.recompute_comm_overlap, bool),
-                            "recomputation_communication_overlap": (ms_ctx_param.recompute_comm_overlap, bool),
+            valid_option = {"recompute_comm_overlap": (ms_ctx_param.recompute_comm_overlap, str),
+                            "recomputation_communication_overlap": (ms_ctx_param.recompute_comm_overlap, str),
                             "matmul_grad_comm_overlap": (ms_ctx_param.matmul_grad_comm_overlap, bool),
                             "grad_matmul_communication_overlap": (ms_ctx_param.matmul_grad_comm_overlap, bool),
                             "enable_task_opt": (ms_ctx_param.enable_task_opt, bool),
@@ -908,17 +929,12 @@ class _Context:
                                        f"Please use '{name_replace.get(key)}' instead.")
                     set_func, valid_type = valid_option.get(key)
                     if not isinstance(value, valid_type):
-                        raise TypeError(f"The value type of {key} must be {valid_type}, "
-                                        f"but got value is {value} and type is {type(value)}.")
-                    if key == "pp_1f1b_overlap":
-                        values = value.split(",")
-                        for v in values:
-                            if v not in ['AlltoAll', 'AlltoAllV', 'MorphAllGather',
-                                         'AllGather', 'ReduceScatter', 'MorphReduceScatter']:
-                                raise ValueError("{} 's value should be subset of ['AlltoAll', 'AlltoAllV',"
-                                                 " 'MorphAllGather', 'AllGather', 'ReduceScatter',"
-                                                 " 'MorphReduceScatter'].".format(key))
-                    self.set_param(set_func, value)
+                        if not ((key == "recompute_comm_overlap" or key == "recomputation_communication_overlap")
+                                and isinstance(value, bool)):
+                            raise TypeError(f"The value type of {key} must be {valid_type}, "
+                                            f"but got value is {value} and type is {type(value)}.")
+                    value_new = self._check_speedup_config_str_value(key, value)
+                    self.set_param(set_func, value_new)
         except (TypeError, ValueError) as exo:
             raise ValueError(str(exo) + "\nFor 'context.set_context', "
                                         "open or load the 'speedup_config_path' file {} "
@@ -960,11 +976,11 @@ def _context():
                  comm_fusion=dict, strategy_ckpt_config=dict, force_fp32_communication=bool)
 def set_auto_parallel_context(**kwargs):
     r"""
-    Set auto parallel context, only data parallel supported on CPU.
+    Set auto parallel context, this api will be deprecated and removed in future versions, please use the api
+    :class:`mindspore.parallel.auto_parallel.AutoParallel` instead.
 
     Note:
-        Global parallel configuration. This interface will be deprecated in future versions, please use
-        the api :class:`mindspore.parallel.auto_parallel.AutoParallel` instead.
+        CPU only support data parallel.
 
     Some configurations are parallel mode specific, see the below table for details:
 
@@ -1201,10 +1217,8 @@ def set_auto_parallel_context(**kwargs):
 
 def get_auto_parallel_context(attr_key):
     """
-    Get auto parallel context attribute value according to the key.
-
-    Note:
-        This interface will be deprecated in future versions.
+    Get auto parallel context attribute value according to the key, this api will be deprecated and removed in future
+    versions.
 
     Args:
         attr_key (str): The key of the attribute.
@@ -1225,7 +1239,7 @@ def get_auto_parallel_context(attr_key):
 
 def reset_auto_parallel_context():
     """
-    Reset auto parallel context attributes to the default values. This interface will be deprecated in future
+    Reset auto parallel context attributes to the default values, this api will be deprecated and removed in future
     versions, please use the api :class:`mindspore.parallel.auto_parallel.AutoParallel` instead.
 
     - device_num: 1.
@@ -1261,8 +1275,8 @@ def reset_auto_parallel_context():
 @args_type_check(offload_config=dict)
 def set_offload_context(offload_config):
     r"""
-    Configure heterogeneous training detailed parameters to adjust the offload strategy. This function is deprecated and
-    will be removed in future versions.
+    Configure heterogeneous training detailed parameters to adjust the offload strategy, this api will be deprecated
+    and removed in future versions.
 
     Note:
         The offload configuration is only used if the memory offload feature is enabled
@@ -1302,9 +1316,10 @@ def set_offload_context(offload_config):
 
 def get_offload_context():
     """
-    Gets the offload configuration parameters. Configure through interface mindspore.set_offload_context().
-    If the user is not set, the default configuration is obtained. This function is deprecated and will be removed in
-    future versions.
+    Gets the offload configuration parameters, this api will be deprecated and removed in future versions.
+
+    Configure through interface mindspore.set_offload_context(). If the user is not set, the default configuration is
+    obtained.
 
     Returns:
         Dict, heterogeneous training offload detailed configuration parameters.
@@ -1558,7 +1573,8 @@ def set_context(**kwargs):
         check_bprop (bool): This parameter will be deprecated and removed in future versions.
         enable_reduce_precision (bool): This parameter will be deprecated and removed in a future versions.
         grad_for_scalar (bool): This parameter will be deprecated and removed in future versions.
-        support_binary (bool): Whether to support run .pyc or .so in graph mode.
+        support_binary (bool): Whether to support run .pyc or .so in graph mode. This parameter will be deprecated and
+            removed in a future version. Please use the environment variable `MS_SUPPORT_BINARY` instead.
 
     Examples:
         >>> import mindspore as ms
@@ -1668,7 +1684,9 @@ def set_context(**kwargs):
 def get_context(attr_key):
 
     """
-    Get context attribute value according to the input key.
+    Get context attribute value according to the input key, this api will be deprecated and removed in future versions,
+    please use :func:`mindspore.get_current_device` instead.
+
     If some attributes are not set, they will be automatically obtained.
 
     Args:
@@ -1745,7 +1763,7 @@ class ParallelMode:
 @args_type_check(enable_ps=bool)
 def set_ps_context(**kwargs):
     """
-    Set parameter server training mode context.
+    Set parameter server training mode context, this api will be deprecated and removed in future versions.
 
     Note:
         Parameter server mode is only supported in graph mode.
@@ -1768,8 +1786,9 @@ def set_ps_context(**kwargs):
                           Default: ``False`` .
         config_file_path (str): Configuration file path used by recovery, parameter server training mode only
                                    supports Server disaster recovery currently. Default: ``''`` .
-        scheduler_manage_port (int): Scheduler manage port used to scale out/in. Default: ``11202`` .
-        enable_ssl (bool): Set PS SSL mode enabled or disabled. Default: ``False`` .
+        enable_ssl (bool): Set PS SSL mode enabled or disabled. Default: ``False``.
+                           Turning it off by default may be a security risk,
+                           and users need to ensure the security of the network environment.
         client_password (str): Password to decrypt the secret key stored in the client certificate. Default: ``''`` .
         server_password (str): Password to decrypt the secret key stored in the server certificate. Default: ``''`` .
 
@@ -1778,14 +1797,15 @@ def set_ps_context(**kwargs):
 
     Examples:
         >>> import mindspore as ms
-        >>> ms.set_ps_context(enable_ps=True, enable_ssl=True, client_password='123456', server_password='123456')
+        >>> ms.set_ps_context(enable_ps=True, enable_ssl=True, client_password='', server_password='')
     """
     _set_ps_context(**kwargs)
 
 
 def get_ps_context(attr_key):
     """
-    Get parameter server training mode context attribute value according to the key.
+    Get parameter server training mode context attribute value according to the key, this api will be deprecated and
+    removed in future versions.
 
     Args:
         attr_key (str): The key of the attribute:
@@ -1794,12 +1814,9 @@ def get_ps_context(attr_key):
             - config_file_path (str, optional): Configuration file path used by recovery,
               parameter server training mode only
               supports Server disaster recovery currently. Default: ``''`` .
-            - scheduler_manage_port (int, optional): Scheduler manage port used to scale out/in. Default: ``11202`` .
             - enable_ssl (bool, optional): Set PS SSL mode enabled or disabled. Default: ``False`` .
-            - client_password (str, optional): Password to decrypt the secret key stored in the client certificate.
-              Default: ``''`` .
-            - server_password (str, optional): Password to decrypt the secret key stored in the server certificate.
-              Default: ``''`` .
+              Turning it off by default may be a security risk,
+              and users need to ensure the security of the network environment.
 
     Returns:
         Returns attribute value according to the key.
@@ -1816,7 +1833,8 @@ def get_ps_context(attr_key):
 
 def reset_ps_context():
     """
-    Reset parameter server training mode context attributes to the default values.
+    Reset parameter server training mode context attributes to the default values, this api will be deprecated and
+    removed in future versions.
 
     Meaning of each field and its default value refer to :func:`mindspore.set_ps_context`.
 

mindspore/dataset/core/config.py

@@ -1097,12 +1097,12 @@ def get_error_samples_mode():
     return _CDE_TO_PYTHON_ERROR_SAMPLES_MODE.get(_config.get_error_samples_mode())
 
 
-def set_iterator_mode(do_copy=True, parallel_convert=False):
+def set_iterator_mode(do_copy=False, parallel_convert=False):
     """
     Select dataset iterator optimization strategy.
 
     Args:
-        do_copy (bool): Whether dataset iterator creates a Tensor from numpy.ndarray without copy. Default: "True".
+        do_copy (bool): Whether dataset iterator creates a Tensor from numpy.ndarray without copy. Default: "False".
         parallel_convert (bool): Whether dataset iterator starts a thread to organize Tensors to output.
             Default: "False".
 
@@ -1122,7 +1122,7 @@ def set_iterator_mode(do_copy=True, parallel_convert=False):
 def get_iterator_mode():
     """
     Get dataset iterator mode indicate iterator optimization strategy.
-    If `set_iterator_mode` is never called before, `do_copy` default to "True", `parallel_convert` default to "False".
+    If `set_iterator_mode` is never called before, `do_copy` default to "False", `parallel_convert` default to "False".
 
     Returns:
         dict, iterator mode dictionary contains the value of `do_copy` and `parallel_convert`.

mindspore/dataset/engine/datasets.py

@@ -575,6 +575,12 @@ class Dataset:
                     create shared memory, and represents ``output_columns`` use the second element as the
                     unit to create shared memory.
 
+        .. warning::
+            `batch` uses `dill` module implicitly in multiprocessing `spawn` mode to serialize/deserialize
+            `per_batch_map`, which is known to be insecure. It is possible to construct malicious pickle data
+            which will execute arbitrary code during unpickling. Never load data that could have come from
+            untrusted sources, or has been tampered with.
+
         Returns:
             Dataset, a new dataset with the above operation applied.
 
@@ -886,6 +892,12 @@ class Dataset:
 
                 - offload (bool, optional): Flag to indicate whether offload is used. Default: ``None``.
 
+        .. warning::
+            `map` uses `dill` module implicitly in multiprocessing `spawn` mode to serialize/deserialize `operations`,
+            which is known to be insecure. It is possible to construct malicious pickle data which will
+            execute arbitrary code during unpickling. Never load data that could have come from untrusted sources,
+            or has been tampered with.
+
         Note:
             - Input `operations` accepts TensorOperations defined in mindspore.dataset part, plus user-defined
               Python functions (PyFuncs).
@@ -1557,7 +1569,7 @@ class Dataset:
         del api_tree
 
     @check_tuple_iterator
-    def create_tuple_iterator(self, columns=None, num_epochs=-1, output_numpy=False, do_copy=True):
+    def create_tuple_iterator(self, columns=None, num_epochs=-1, output_numpy=False, do_copy=False):
         """
         Create an iterator over the dataset that yields samples of type list, whose elements are
         the data for each column.
@@ -1571,7 +1583,7 @@ class Dataset:
                 convert it to Tensor. Default: ``False`` .
             do_copy (bool, optional): Whether to copy the data when converting output to Tensor,
                 or reuse the buffer for better performance, only works when `output_numpy` is ``False`` .
-                Default: ``True`` .
+                Default: ``False`` .
 
         Returns:
             Iterator, a dataset iterator that yields samples of type list.
@@ -1598,7 +1610,7 @@ class Dataset:
         return TupleIterator(self, columns, num_epochs, output_numpy, do_copy)
 
     @check_dict_iterator
-    def create_dict_iterator(self, num_epochs=-1, output_numpy=False, do_copy=True):
+    def create_dict_iterator(self, num_epochs=-1, output_numpy=False, do_copy=False):
         """
         Create an iterator over the dataset that yields samples of type dict,
         while the key is the column name and the value is the data.
@@ -1610,7 +1622,7 @@ class Dataset:
                 convert it to Tensor. Default: ``False`` .
             do_copy (bool, optional): Whether to copy the data when converting output to Tensor,
                 or reuse the buffer for better performance, only works when `output_numpy` is ``False`` .
-                Default: ``True`` .
+                Default: ``False`` .
 
         Returns:
             Iterator, a dataset iterator that yields samples of type dict.
@@ -3632,9 +3644,10 @@ class _PythonMultiprocessing(cde.PythonMultiprocessingRuntime):
                         "process(es): {}".format(self.cleaning_process.pid, self.get_pids()))
 
             if get_enable_watchdog():
-                worker_ids = [worker.pid for worker in self.workers]
+                worker_ids = [os.getpid()]
+                worker_ids.extend([worker.pid for worker in self.workers])
                 worker_ids.append(self.cleaning_process.pid)
-                cde.register_worker_pids(id(self), set(worker_ids))
+                cde.register_worker_pids(id(self), worker_ids)
 
     def _abort_monitor(self):
         """Deregister workers monitored by the watch dog and join clean process."""
@@ -4385,7 +4398,7 @@ class TransferDataset(Dataset):
     def create_dict_iterator(self, num_epochs=-1, output_numpy=False):
         raise RuntimeError("TransferDataset is not iterable.")
 
-    def create_tuple_iterator(self, columns=None, num_epochs=-1, output_numpy=False, do_copy=True):
+    def create_tuple_iterator(self, columns=None, num_epochs=-1, output_numpy=False, do_copy=False):
         raise RuntimeError("TransferDataset is not iterable.")
 
     def __iter__(self):

mindspore/dataset/engine/datasets_user_defined.py

@@ -220,6 +220,7 @@ class SamplerFn(cde.PythonMultiprocessingRuntime):
 
         self.ppid = os.getpid()
         self.pids = []
+        self.thread_ids = []
         self.check_interval = get_multiprocessing_timeout_interval()  # the interval of check queue's size
 
         if self.multi_process is True:
@@ -277,12 +278,32 @@ class SamplerFn(cde.PythonMultiprocessingRuntime):
                 worker = _GeneratorWorkerMt(self.dataset, self.eof, worker_id)
                 worker.daemon = True
                 self.need_join = True
+                worker.start()
+                self.thread_ids.append(worker.ident)
                 self.workers.append(worker)
 
         # Register a termination function using weakref to avoid the object from unable to properly destruct.
         atexit.register(lambda cleanup: cleanup()() if cleanup() is not None else None,
                         weakref.WeakMethod(self.terminate))
 
+    def get_worker_ids(self):
+        """
+        Get dict of worker's ids
+
+        Returns:
+            dict of strings
+        """
+        if not self.is_mp_enabled():
+            return {}
+        worker_ids = {}
+        if self.multi_process is True:
+            worker_ids["is_thread"] = False
+            worker_ids["worker_id"] = self.pids
+        else:
+            worker_ids["is_thread"] = True
+            worker_ids["worker_id"] = self.thread_ids
+        return worker_ids
+
     def terminate(self):
         self._stop_subprocess()
 
@@ -345,12 +366,12 @@ class SamplerFn(cde.PythonMultiprocessingRuntime):
                 start_time = int(time.time())
                 wait_count = 1
                 while self.workers[i % self.num_worker].res_queue.empty():
+                    time.sleep(0.1)
                     if self.eof.is_set():
                         logger.warning("Generator receives a termination signal, stop waiting for data "
                                        "from subprocess.")
                         self._stop_subprocess()
                         return
-                    time.sleep(0.1)
                     wait_count = self._interval_log(i, start_time, wait_count)
                 result = self.workers[i % self.num_worker].get()
                 if isinstance(result, ExceptionHandler):
@@ -421,9 +442,10 @@ class SamplerFn(cde.PythonMultiprocessingRuntime):
                     "process(es): {}".format(self.cleaning_process.pid, [worker.pid for worker in self.workers]))
 
         if get_enable_watchdog():
-            worker_ids = [worker.pid for worker in self.workers]
+            worker_ids = [os.getpid()]
+            worker_ids.extend([worker.pid for worker in self.workers])
             worker_ids.append(self.cleaning_process.pid)
-            cde.register_worker_pids(id(self), set(worker_ids))
+            cde.register_worker_pids(id(self), worker_ids)
 
     def _release_fd(self):
         """Release the file descriptor by subprocess"""
@@ -480,6 +502,8 @@ class SamplerFn(cde.PythonMultiprocessingRuntime):
                     except Exception:  # pylint: disable=W0703
                         # Block all errors when join
                         continue
+                elif not self.multi_process:
+                    w.join(timeout=5)
 
             if self.multi_process is True:
                 self._release_fd()
@@ -795,6 +819,12 @@ class GeneratorDataset(MappableDataset, UnionBaseDataset):
         - `Load & Process Data With Dataset Pipeline
           <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/dataset_gallery.html>`_
 
+    .. warning::
+        `GeneratorDataset` uses `dill` module implicitly in multiprocessing `spawn` mode to serialize/deserialize
+        `source`, which is known to be insecure. It is possible to construct malicious pickle data which will
+        execute arbitrary code during unpickling. Never load data that could have come from untrusted sources,
+        or has been tampered with.
+
     Note:
         - If you configure `python_multiprocessing=True` (Default: ``True`` ) and `num_parallel_workers>1`
           (default: ``1`` ) indicates that the multiprocessing mode is started for data load acceleration.

mindspore/dataset/engine/iterators.py

@@ -220,7 +220,7 @@ class Iterator:
         dataset: Dataset to be iterated over
     """
 
-    def __init__(self, dataset, num_epochs=-1, output_numpy=False, do_copy=True):
+    def __init__(self, dataset, num_epochs=-1, output_numpy=False, do_copy=False):
         self._col_names = None
 
         # create a copy of tree and work on it.
@@ -493,7 +493,7 @@ class TupleIterator(Iterator):
     The derived class of Iterator with list type.
     """
 
-    def __init__(self, dataset, columns=None, num_epochs=-1, output_numpy=False, do_copy=True):
+    def __init__(self, dataset, columns=None, num_epochs=-1, output_numpy=False, do_copy=False):
         if columns is not None:
             if not isinstance(columns, list):
                 columns = [columns]

mindspore/dataset/engine/obs/config_loader.py

@@ -57,12 +57,12 @@ class _Config:
 
     def _convert_type(self, key):
         if key not in self.config:
-            return  os.environ[key]
+            return os.environ[key]
         if isinstance(self.config[key], int):
             return int(os.environ[key])
         if isinstance(self.config[key], float):
             return float(os.environ[key])
-        return  os.environ[key]
+        return os.environ[key]
 
 
 config = _Config()

mindspore/dataset/engine/obs/obs_mindrecord_dataset.py

@@ -506,3 +506,11 @@ class MindRecordFromOBS:
         path = os.path.join(self._local_path, target_dataset)
         _iteration = MindDataset(dataset_files=[path], shuffle=False)
         return _iteration.get_col_names()
+
+    def close(self):
+        if self._pool:
+            self._pool.terminate()
+            self._pool = None
+
+    def __del__(self):
+        self.close()

mindspore/dataset/transforms/py_transforms.py

@@ -51,10 +51,14 @@ class PyTensorOperation:
         if "transforms" in json_obj.keys():
             # operations which have transforms as input, need to call _from_json() for each transform to deseriallize
             transforms = []
+            valid_module = ['mindspore.dataset.vision', 'mindspore.dataset.text',
+                            'mindspore.dataset.audio', 'mindspore.dataset.transforms']
             for json_op in json_obj["transforms"]:
-                transforms.append(getattr(
-                    sys.modules.get(json_op.get("python_module")),
-                    json_op.get("tensor_op_name")).from_json(json.dumps(json_op.get("tensor_op_params"))))
+                py_module = sys.modules.get(json_op.get("python_module"))
+                if py_module.__package__ not in valid_module:
+                    raise RuntimeError('Invalid json content, try to serialzie dataset again.')
+                transforms.append(getattr(py_module, json_op.get("tensor_op_name")).from_json(
+                    json.dumps(json_op.get("tensor_op_params"))))
             new_op.transforms = transforms
         if "output_type" in json_obj.keys():
             output_type = np.dtype(json_obj["output_type"])

mindspore/dataset/transforms/transforms.py

@@ -165,10 +165,14 @@ class PyTensorOperation:
         if "transforms" in json_obj.keys():
             # operations which have transforms as input, need to call _from_json() for each transform to deseriallize
             transforms = []
+            valid_module = ['mindspore.dataset.vision', 'mindspore.dataset.text',
+                            'mindspore.dataset.audio', 'mindspore.dataset.transforms']
             for json_op in json_obj["transforms"]:
-                transforms.append(getattr(
-                    sys.modules.get(json_op.get("python_module")),
-                    json_op["tensor_op_name"]).from_json(json.dumps(json_op["tensor_op_params"])))
+                py_module = sys.modules.get(json_op.get("python_module"))
+                if py_module.__package__ not in valid_module:
+                    raise RuntimeError('Invalid json content, try to serialzie dataset again.')
+                transforms.append(getattr(py_module, json_op["tensor_op_name"]).from_json(
+                    json.dumps(json_op["tensor_op_params"])))
             new_op.transforms = transforms
         if "output_type" in json_obj.keys():
             output_type = np.dtype(json_obj["output_type"])

mindspore/dataset/vision/validators.py

@@ -351,6 +351,7 @@ def check_resize_interpolation(method):
 
     return new_method
 
+
 def check_device_target(method):
     """A wrapper that wraps a parameter checker"""
 

mindspore/device_context/ascend/device.py

@@ -66,7 +66,7 @@ def is_available():
 
 def _is_supported():
     device_target = ms.context.get_context("device_target")
-    if device_target == 'CPU' or device_target == 'GPU':
+    if device_target in ['CPU', 'GPU']:
         logger.error(f"{device_target} device is not supported. Please use correct device")
         return False
     return True

mindspore/device_context/gpu/__init__.py

@@ -14,8 +14,8 @@
 # ============================================================================
 """init file for GPU device context"""
 
+__all__ = ['device_count', 'is_available']
+
 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

@@ -64,7 +64,7 @@ def is_available():
 
 def _is_supported():
     device_target = ms.context.get_context("device_target")
-    if device_target == 'CPU' or device_target == 'Ascend':
+    if device_target in ['CPU', '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

@@ -29,7 +29,8 @@ function_status = {'matmul_allow_tf32': False, 'conv_allow_tf32': False}
 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>`_.
+    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
@@ -50,7 +51,8 @@ def matmul_allow_tf32(value):
 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>`_.
+    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

mindspore/device_context/gpu/op_tuning.py

@@ -27,7 +27,8 @@ function_status = {'conv_fprop_algo': False, 'conv_wgrad_algo': False, 'conv_dgr
 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>`_.
+    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'.
@@ -80,7 +81,8 @@ def conv_fprop_algo(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>`_.
+    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'.
@@ -129,7 +131,8 @@ def conv_wgrad_algo(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>`_.
+    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'.