mindspore 2.0.0a0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/run_check/_check_version.py

@@ -35,7 +35,7 @@ class EnvChecker(metaclass=ABCMeta):
 
     @abstractmethod
     def check_env(self):
-        pass
+        """check dependency"""
 
     @abstractmethod
     def set_env(self):
@@ -95,8 +95,8 @@ class GPUEnvChecker(EnvChecker):
             version_match = True
         if not version_match:
             if self.v == "0":
-                logger.warning("Can not found cuda libs, please confirm that the correct "
-                               "cuda version has been installed, you can refer to the "
+                logger.warning("Can not found cuda libs. Please confirm that the correct "
+                               "cuda version has been installed. Refer to the "
                                "installation guidelines: https://www.mindspore.cn/install")
             else:
                 logger.warning(f"MindSpore version {__version__} and cuda version {self.v} does not match, "
@@ -106,17 +106,17 @@ class GPUEnvChecker(EnvChecker):
         nvcc_version = self._get_nvcc_version(False)
         if nvcc_version and (nvcc_version not in self.version):
             logger.warning(f"MindSpore version {__version__} and nvcc(cuda bin) version {nvcc_version} "
-                           "does not match, please refer to the installation guide for version matching "
+                           "does not match. Please refer to the installation guide for version matching "
                            "information: https://www.mindspore.cn/install")
         cudnn_version = self._get_cudnn_version()
         if cudnn_version and int(cudnn_version) < 760:
             logger.warning(f"MindSpore version {__version__} and cudDNN version {cudnn_version} "
-                           "does not match, please refer to the installation guide for version matching "
+                           "does not match. Please refer to the installation guide for version matching "
                            "information: https://www.mindspore.cn/install. The recommended version is "
                            "CUDA10.1 with cuDNN7.6.x, CUDA11.1 with cuDNN8.0.x and CUDA11.6 with cuDNN8.5.x.")
         if cudnn_version and int(cudnn_version) < 800 and int(str(self.v).split('.')[0]) > 10:
             logger.warning(f"CUDA version {self.v} and cuDNN version {cudnn_version} "
-                           "does not match, please refer to the installation guide for version matching "
+                           "does not match. Please refer to the installation guide for version matching "
                            "information: https://www.mindspore.cn/install. The recommended version is "
                            "CUDA11.1 with cuDNN8.0.x or CUDA11.6 with cuDNN8.5.x.")
 
@@ -211,8 +211,8 @@ class GPUEnvChecker(EnvChecker):
         mindspore_path = os.path.join(current_path, "../lib/plugin")
         try:
             real_path = self.library_path
-            if real_path == []:
-                logger.error(f"{self.lib_key_to_lib_name[lib_name]} (need by mindspore-gpu) is not found, please "
+            if real_path is None or real_path == []:
+                logger.error(f"{self.lib_key_to_lib_name[lib_name]} (need by mindspore-gpu) is not found. Please "
                              f"confirm that libmindspore_gpu.so is in directory:{mindspore_path} and the correct cuda "
                              "version has been installed, you can refer to the installation "
                              "guidelines: https://www.mindspore.cn/install")
@@ -223,10 +223,10 @@ class GPUEnvChecker(EnvChecker):
             for i in result.split('\n'):
                 path = i.partition("=>")[2]
                 if path.lower().find("not found") > 0:
-                    logger.error(f"Cuda {self.version} version({lib_name}*.so need by mindspore-gpu) is not found, "
-                                 "please confirm that the path of cuda is set to the env LD_LIBRARY_PATH, or check "
+                    logger.error(f"Cuda {self.version} version({lib_name}*.so need by mindspore-gpu) is not found. "
+                                 "Please confirm that the path of cuda is set to the env LD_LIBRARY_PATH, or check "
                                  "whether the CUDA version in wheel package and the CUDA runtime in current device "
-                                 "matches, please refer to the installation guidelines: "
+                                 "matches. Please refer to the installation guidelines: "
                                  "https://www.mindspore.cn/install")
                     continue
                 path = path.partition(lib_name)[0]
@@ -234,8 +234,8 @@ class GPUEnvChecker(EnvChecker):
                     path_list.append(os.path.abspath(path.strip() + "../"))
             return np.unique(path_list)
         except subprocess.TimeoutExpired:
-            logger.warning("Failed to check cuda version due to the ldd command timeout, please confirm that "
-                           "the correct cuda version has been installed, you can refer to the "
+            logger.warning("Failed to check cuda version due to the ldd command timeout. Please confirm that "
+                           "the correct cuda version has been installed. For details, refer to the "
                            "installation guidelines: https://www.mindspore.cn/install")
             return path_list
 
@@ -255,14 +255,14 @@ class AscendEnvChecker(EnvChecker):
 
     def __init__(self, library_path):
         self.library_path = library_path
-        self.version = ["1.83"]
+        self.version = ["6.11", "6.3"]
         atlas_nnae_version = "/usr/local/Ascend/nnae/latest/compiler/version.info"
         atlas_toolkit_version = "/usr/local/Ascend/ascend-toolkit/latest/compiler/version.info"
         hisi_fwk_version = "/usr/local/Ascend/latest/compiler/version.info"
         if os.path.exists(atlas_nnae_version):
             # atlas default path
             self.fwk_path = "/usr/local/Ascend/nnae/latest"
-            self.op_impl_path = "/usr/local/Ascend/nnae/latest/opp/op_impl/built-in/ai_core/tbe"
+            self.op_impl_path = "/usr/local/Ascend/nnae/latest/opp/built-in/op_impl/ai_core/tbe"
             self.tbe_path = self.fwk_path + "/lib64"
             self.cce_path = self.fwk_path + "/compiler/ccec_compiler/bin"
             self.fwk_version = atlas_nnae_version
@@ -271,7 +271,7 @@ class AscendEnvChecker(EnvChecker):
         elif os.path.exists(atlas_toolkit_version):
             # atlas default path
             self.fwk_path = "/usr/local/Ascend/ascend-toolkit/latest"
-            self.op_impl_path = "/usr/local/Ascend/ascend-toolkit/latest/opp/op_impl/built-in/ai_core/tbe"
+            self.op_impl_path = "/usr/local/Ascend/ascend-toolkit/latest/opp/built-in/op_impl/ai_core/tbe"
             self.tbe_path = self.fwk_path + "/lib64"
             self.cce_path = self.fwk_path + "/compiler/ccec_compiler/bin"
             self.fwk_version = atlas_toolkit_version
@@ -280,7 +280,7 @@ class AscendEnvChecker(EnvChecker):
         elif os.path.exists(hisi_fwk_version):
             # hisi default path
             self.fwk_path = "/usr/local/Ascend/latest"
-            self.op_impl_path = "/usr/local/Ascend/latest/opp/op_impl/built-in/ai_core/tbe"
+            self.op_impl_path = "/usr/local/Ascend/latest/opp/built-in/op_impl/ai_core/tbe"
             self.tbe_path = self.fwk_path + "/lib64"
             self.cce_path = self.fwk_path + "/compiler/ccec_compiler/bin"
             self.fwk_version = hisi_fwk_version
@@ -305,7 +305,7 @@ class AscendEnvChecker(EnvChecker):
 
         # check content
         self.path_check = "/compiler/ccec_compiler/bin"
-        self.python_path_check = "opp/op_impl/built-in/ai_core/tbe"
+        self.python_path_check = "opp/built-in/op_impl/ai_core/tbe"
         self.ld_lib_path_check_fwk = "/lib64"
         self.ld_lib_path_check_addons = "/add-ons"
         self.ascend_opp_path_check = "/op"
@@ -317,8 +317,8 @@ class AscendEnvChecker(EnvChecker):
     def check_version(self):
         if not Path(self.fwk_version).is_file():
             logger.warning("Using custom Ascend AI software package (Ascend Data Center Solution) path, package "
-                           "version checking is skipped, please make sure Ascend AI software package (Ascend Data "
-                           "Center Solution) version is supported, you can reference to the installation guidelines "
+                           "version checking is skipped. Please make sure Ascend AI software package (Ascend Data "
+                           "Center Solution) version is supported. For details, refer to the installation guidelines "
                            "https://www.mindspore.cn/install")
             return
 
@@ -327,11 +327,11 @@ class AscendEnvChecker(EnvChecker):
             v_list = str([x for x in self.version])
             logger.warning(f"MindSpore version {__version__} and Ascend AI software package (Ascend Data Center "
                            f"Solution)version {v} does not match, the version of software package expect one of "
-                           f"{v_list}, please reference to the match info on: https://www.mindspore.cn/install")
+                           f"{v_list}. Please refer to the match info on: https://www.mindspore.cn/install")
 
     def check_deps_version(self):
         """
-            te, topi, hccl wheel package version check
+            te and hccl wheel package version check
             in order to update the change of 'LD_LIBRARY_PATH' env, run a sub process
         """
 
@@ -344,24 +344,22 @@ class AscendEnvChecker(EnvChecker):
             if v not in supported_version:
                 attention_warning = True
                 logger.warning(f"MindSpore version {mindspore_version} and \"te\" wheel package version {v} does not "
-                               "match, reference to the match info on: https://www.mindspore.cn/install")
-            from topi import version as topiver
-            v = '.'.join(topiver.version.split('.')[0:2])
-            if v not in supported_version:
-                attention_warning = True
-                logger.warning(f"MindSpore version {mindspore_version} and \"topi\" wheel package version {v} does not "
-                               "match, reference to the match info on: https://www.mindspore.cn/install")
+                               "match. For details, refer to the installation guidelines: "
+                               "https://www.mindspore.cn/install")
             from hccl import sys_version as hccl_version
             v = '.'.join(hccl_version.__sys_version__.split('.')[0:2])
             if v not in supported_version:
                 attention_warning = True
                 logger.warning(f"MindSpore version {mindspore_version} and \"hccl\" wheel package version {v} does not "
-                               "match, reference to the match info on: https://www.mindspore.cn/install")
-        except ImportError as e:
+                               "match. For details, refer to the installation guidelines: "
+                               "https://www.mindspore.cn/install")
+        # DO NOT modify exception type to any other, you DO NOT know what kind of exceptions the te will throw.
+        # pylint: disable=broad-except
+        except Exception as e:
             logger.error("CheckFailed:", e.args)
-            logger.error("MindSpore relies on the 3 whl packages of \"te\", \"topi\" and \"hccl\" in the \"latest\" "
-                         "folder of the Ascend AI software package (Ascend Data Center Solution), please check whether"
-                         " they are installed correctly or not, reference to the match info on: "
+            logger.error("MindSpore relies on whl packages of \"te\" and \"hccl\" in the \"latest\" "
+                         "folder of the Ascend AI software package (Ascend Data Center Solution). Please check whether"
+                         " they are installed correctly or not, refer to the match info on: "
                          "https://www.mindspore.cn/install")
         if attention_warning:
             warning_countdown = 3
@@ -390,9 +388,10 @@ class AscendEnvChecker(EnvChecker):
             if Path(self.tbe_path).is_dir():
                 os.environ['LD_LIBRARY_PATH'] = self.tbe_path + ":" + os.environ['LD_LIBRARY_PATH']
             else:
-                raise EnvironmentError(
-                    f"No such directory: {self.tbe_path}, Please check if Ascend AI software package (Ascend Data "
+                logger.error(
+                    f"No such directory: {self.tbe_path}. Please check if Ascend AI software package (Ascend Data "
                     "Center Solution) is installed correctly.")
+                return
 
         # check te version after set te env
         self.check_deps_version()
@@ -408,57 +407,63 @@ class AscendEnvChecker(EnvChecker):
 
             os.environ['TBE_IMPL_PATH'] = self.op_impl_path
         else:
-            raise EnvironmentError(
-                f"No such directory: {self.op_impl_path}, Please check if Ascend AI software package (Ascend Data "
+            logger.error(
+                f"No such directory: {self.op_impl_path}. Please check if Ascend AI software package (Ascend Data "
                 "Center Solution) is installed correctly.")
+            return
 
         if Path(self.cce_path).is_dir():
             os.environ['PATH'] = self.cce_path + ":" + os.environ['PATH']
         else:
-            raise EnvironmentError(
-                f"No such directory: {self.cce_path}, Please check if Ascend AI software package (Ascend Data Center "
+            logger.error(
+                f"No such directory: {self.cce_path}. Please check if Ascend AI software package (Ascend Data Center "
                 "Solution) is installed correctly.")
+            return
 
         if self.op_path is None:
             pass
         elif Path(self.op_path).is_dir():
             os.environ['ASCEND_OPP_PATH'] = self.op_path
         else:
-            raise EnvironmentError(
-                f"No such directory: {self.op_path}, Please check if Ascend AI software package (Ascend Data Center "
+            logger.error(
+                f"No such directory: {self.op_path}. Please check if Ascend AI software package (Ascend Data Center "
                 "Solution) is installed correctly.")
+            return
 
         if self.aicpu_path is None:
             pass
         elif Path(self.aicpu_path).is_dir():
             os.environ['ASCEND_AICPU_PATH'] = self.aicpu_path
         else:
-            raise EnvironmentError(
-                f"No such directory: {self.aicpu_path}, Please check if Ascend AI software package (Ascend Data Center"
+            logger.error(
+                f"No such directory: {self.aicpu_path}. Please check if Ascend AI software package (Ascend Data Center"
                 " Solution) is installed correctly.")
+            return
 
     def _check_env(self):
         """ascend dependence path check"""
         if self.path is None or self.path_check not in self.path:
-            logger.warning("Can not find ccec_compiler(need by mindspore-ascend), please check if you have set env "
-                           "PATH, you can reference to the installation guidelines https://www.mindspore.cn/install")
+            logger.warning("Can not find ccec_compiler(need by mindspore-ascend). Please check whether the Environment "
+                           "Variable PATH is set. For details, refer to the installation guidelines: "
+                           "https://www.mindspore.cn/install")
 
         if self.python_path is None or self.python_path_check not in self.python_path:
             logger.warning(
-                "Can not find tbe op implement(need by mindspore-ascend), please check if you have set env "
-                "PYTHONPATH, you can reference to the installation guidelines "
+                "Can not find the tbe operator implementation(need by mindspore-ascend). Please check whether the "
+                "Environment Variable PYTHONPATH is set. For details, refer to the installation guidelines: "
                 "https://www.mindspore.cn/install")
 
         if self.ld_lib_path is None or not (self.ld_lib_path_check_fwk in self.ld_lib_path and
                                             self.ld_lib_path_check_addons in self.ld_lib_path):
-            logger.warning("Can not find driver so(need by mindspore-ascend), please check if you have set env "
-                           "LD_LIBRARY_PATH, you can reference to the installation guidelines "
-                           "https://www.mindspore.cn/install")
+            logger.warning("Can not find driver so(need by mindspore-ascend). Please check whether the "
+                           "Environment Variable LD_LIBRARY_PATH is set. For details, refer to the installation "
+                           "guidelines: https://www.mindspore.cn/install")
 
         if self.ascend_opp_path is None or self.ascend_opp_path_check not in self.ascend_opp_path:
             logger.warning(
-                "Can not find opp path (need by mindspore-ascend), please check if you have set env ASCEND_OPP_PATH, "
-                "you can reference to the installation guidelines https://www.mindspore.cn/install")
+                "Can not find opp path (need by mindspore-ascend). Please check whether the Environment Variable "
+                "ASCEND_OPP_PATH is set. For details, refer to the installation guidelines: "
+                "https://www.mindspore.cn/install")
 
     def _read_version(self, file_path):
         """get ascend version info"""
@@ -476,6 +481,7 @@ def check_env(device, _):
     """callback function for checking environment variables"""
     if device.lower() == "ascend":
         env_checker = AscendEnvChecker(None)
+        env_checker.check_version()
     elif device.lower() == "gpu":
         env_checker = GPUEnvChecker(None)
     else:
@@ -515,15 +521,15 @@ def check_version_and_env_config():
             import ctypes
             ctypes.cdll.LoadLibrary("libgomp.so.1")
         except OSError:
-            logger.warning(
-                "Pre-Load Lirary libgomp.so.1 failed, this might cause cannot allocate TLS memory problem, "
-                "if so find solution in FAQ in https://www.mindspore.cn/docs/en/r2.0.0-alpha/faq/installation.html.")
-    if not os.getenv("MS_DEV_CLOSE_VERSION_CHECK") is None:
-        return
-    MSContext.get_instance().register_check_env_callback(check_env)
-    MSContext.get_instance().register_set_env_callback(set_env)
-    MSContext.get_instance().set_param(ms_ctx_param.device_target,
-                                       MSContext.get_instance().get_param(ms_ctx_param.device_target))
+            logger.warning("Pre-Load Library libgomp.so.1 failed, which might cause TLS memory allocation failure. If "
+                           "the failure occurs, please refer to the FAQ for a solution: "
+                           "https://www.mindspore.cn/docs/en/r2.0/faq/installation.html.")
+        if not os.getenv("MS_DEV_CLOSE_VERSION_CHECK") is None:
+            return
+        MSContext.get_instance().register_check_env_callback(check_env)
+        MSContext.get_instance().register_set_env_callback(set_env)
+        MSContext.get_instance().set_param(ms_ctx_param.device_target,
+                                           MSContext.get_instance().get_param(ms_ctx_param.device_target))
 
 
 def _set_pb_env():
@@ -532,7 +538,7 @@ def _set_pb_env():
         logger.info("Current env variable `PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=cpp`. "
                     "When the checkpoint file is too large, "
                     "it may cause memory limit error during load checkpoint file. "
-                    "This can be solved by set env `PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python`.")
+                    "This can be solved by setting env `PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python`.")
     elif os.getenv("PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION") is None:
         logger.info("Setting the env `PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=python` to prevent memory overflow "
                     "during save or load checkpoint file.")

mindspore/run_check/run_check.py

@@ -40,7 +40,8 @@ def _check_mul():
     input_y = ms.Tensor(np.array([4.0, 5.0, 6.0]), ms.float32)
     mul = ms.ops.Mul()
     mul(input_x, input_y)
-    print(f"The result of multiplication calculation is correct, MindSpore has been installed successfully!")
+    print("The result of multiplication calculation is correct, MindSpore has been installed on platform "
+          f"[{ms.get_context('device_target')}] successfully!")
 
 
 def run_check():

mindspore/train/__init__.py

@@ -35,7 +35,7 @@ from mindspore.train.train_thor import ConvertNetUtils, ConvertModelUtils
 from mindspore.train.metrics import *
 from mindspore.train.data_sink import data_sink
 
-__all__ = ["Model", "DatasetHelper", "amp", "connect_network_with_dataset", "build_train_network", "LossScaleManager",
+__all__ = ["Model", "DatasetHelper", "connect_network_with_dataset", "build_train_network", "LossScaleManager",
            "FixedLossScaleManager", "DynamicLossScaleManager", "save_checkpoint", "load_checkpoint",
            "load_param_into_net", "export", "load", "parse_print", "build_searched_strategy", "merge_sliced_parameter",
            "load_distributed_checkpoint", "async_ckpt_thread_status", "restore_group_info_list", "convert_model",

mindspore/train/_utils.py

@@ -20,16 +20,18 @@ from collections.abc import Iterable
 import numpy as np
 
 from mindspore.common.tensor import Tensor
+from mindspore._c_expression import Tensor as Tensor_
 from mindspore.common.dtype import dtype_to_nptype, pytype_to_dtype
 from mindspore.common import dtype as mstype
 from mindspore import log as logger
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from mindspore.common.api import _cell_graph_executor
 from mindspore.train.mind_ir_pb2 import ModelProto as mindir_model
 from mindspore.train.checkpoint_pb2 import Checkpoint
 from mindspore.train.node_strategy_pb2 import ParallelStrategyMap as ckpt_strategy
 from mindspore.train.lineage_pb2 import DatasetGraph, TrainLineage, EvaluationLineage, UserDefinedInfo
 from mindspore.parallel._parallel_serialization import _make_dir
+from mindspore.ops.operations import debug_ops
 
 
 def _convert_type(types):
@@ -135,27 +137,48 @@ def _construct_input_tensors(dataset_types, dataset_shapes, device_number=1):
     return tensor_list_run, tensor_list_compile
 
 
-def _check_to_numpy(plugin, tensor):
+def _check_to_numpy(plugin, tensor, prim=None):
     """Check the tensor and return a numpy.ndarray."""
     np_value = tensor.asnumpy()
     np_value = np_value.copy()
+    summary_name = plugin.capitalize() + "Summary" if prim else "SummaryRecord"
     if plugin == 'scalar':
         if np_value.size == 1:
             return np_value
-        raise ValueError('The tensor holds more than one value, but the scalar plugin expects on value.')
+        raise ValueError(
+            f'For "{summary_name}", the v rank must be less than or equal to 1, but got {len(np_value)}.')
     if plugin == 'image':
         if np_value.ndim == 4:
             return np_value
-        raise ValueError('The tensor seems not to hold a valid image.')
+        raise ValueError(f'For "{summary_name}", The tensor seems not to hold a valid image.')
     if plugin in ('tensor', 'histogram'):
         if np_value.ndim > 0:
             return np_value
-        raise ValueError('The tensor should not be empty.')
+        raise ValueError(f'For "{summary_name}", The value should not be empty.')
     return np_value
 
 
+def check_summary_param(summary_name, tag, tensor):
+    """Checks the tag is valid for summary."""
+    plugin = summary_name.split('Summary')[0].lower()
+    try:
+        if not isinstance(tag, str) or not tag:
+            raise TypeError(f'For "{summary_name}", the name must be valid string, but got "{tag}".')
+        if not isinstance(tensor, (Tensor, Tensor_)):
+            raise TypeError(f'For "{summary_name}", the parameter "value" expect to be Tensor, '
+                            f'but got {type(tensor).__name__}')
+        _check_to_numpy(plugin, tensor, prim=True)
+    except TypeError as err:
+        raise TypeError(err)
+    except ValueError as err:
+        raise ValueError(err)
+    finally:
+        debug_ops.SUMMARY_TENSOR_CACHE = []
+
+
 def _check_lineage_value(plugin, value):
     """Check the lineage value."""
+
     def raises(plugin, prototype):
         raise TypeError(f'Plugin {repr(plugin)} expects a {prototype.__name__} value.')