mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/rewrite/{symbol_tree_builder.py → symbol_tree/symbol_tree_builder.py}

@@ -16,12 +16,12 @@
 from typing import Optional
 import ast
 import inspect
+from textwrap import dedent
 
 from mindspore.nn import Cell
 from .symbol_tree import SymbolTree
-from .parsers.parser_register import ParserRegister
-from .parsers.parser import Parser
-from .ast_transformers import FlattenRecursiveStmt
+from ..parsers import Parser, ParserRegister
+from ..ast_helpers import AstFlattener
 
 
 class SymbolTreeBuilder:
@@ -33,14 +33,14 @@ class SymbolTreeBuilder:
     """
 
     # Entry function of the forward computation process
-    entry_function = "construct"
+    entry_functions = ["construct"]
 
     def __init__(self, network: Cell):
         if not isinstance(network, Cell):
-            raise RuntimeError("Only support network with Cell type now, ", network)
+            raise TypeError("Type of network should be Cell, but got ", network)
         self._origin_net = network
         network_str = inspect.getsource(type(network))
-        self._ast_root: ast.Module = ast.parse(network_str)
+        self._ast_root: ast.Module = ast.parse(dedent(network_str))
         self._root_tree: Optional[SymbolTree] = None
 
     @staticmethod
@@ -54,7 +54,7 @@ class SymbolTreeBuilder:
         Returns:
              An instance of ast been optimized.
         """
-        ast_root = FlattenRecursiveStmt().transform(ast_root, [SymbolTreeBuilder.entry_function])
+        ast_root = AstFlattener().transform(ast_root, SymbolTreeBuilder.entry_functions)
         return ast_root
 
     def build(self) -> SymbolTree:
@@ -67,7 +67,7 @@ class SymbolTreeBuilder:
 
         self._ast_root = SymbolTreeBuilder.ast_transform(self._ast_root)
         if not isinstance(self._ast_root, ast.Module):
-            raise RuntimeError("ast_root should be a ast.Module")
+            raise TypeError("Type of ast_root should be ast.Module, but got ", self._ast_root)
         self._root_tree: SymbolTree = SymbolTree(self._origin_net, self._ast_root)
         parser: Parser = ParserRegister.instance().get_parser(ast.Module)
         parser.process(self._root_tree, self._ast_root, None)

mindspore/rewrite/{symbol_tree_dumper.py → symbol_tree/symbol_tree_dumper.py}

@@ -15,9 +15,9 @@
 """SymbolTree dumper."""
 import inspect
 
-from .node.node import Node
-from .api.node_type import NodeType
-from .api.scoped_value import ScopedValue, ValueType
+from ..node import Node
+from ..api.node_type import NodeType
+from ..api.scoped_value import ScopedValue, ValueType
 
 
 class SymbolTreeDumper:
@@ -45,7 +45,7 @@ class SymbolTreeDumper:
 
     def _dump_inputs(self):
         """Dump inputs of SymbolTree."""
-        inputs = self._symbol_tree.get_inputs()
+        inputs = self._symbol_tree.get_input_nodes()
         self._dump_buffer += f"#Inputs num     : {len(inputs)}\n"
         for single_input in inputs:
             targets = single_input.get_targets()

mindspore/run_check/_check_version.py

@@ -20,7 +20,6 @@ import sys
 import time
 import subprocess
 import glob
-from copy import deepcopy
 from pathlib import Path
 from abc import abstractmethod, ABCMeta
 from packaging import version
@@ -159,7 +158,7 @@ class GPUEnvChecker(EnvChecker):
         """Get cuda bin path by lib path."""
         path_list = []
         for path in self.cuda_lib_path:
-            path = os.path.abspath(path.strip() + "/bin/")
+            path = os.path.realpath(path.strip() + "/bin/")
             if Path(path).is_dir():
                 path_list.append(path)
         return np.unique(path_list)
@@ -235,7 +234,7 @@ class GPUEnvChecker(EnvChecker):
                     continue
                 path = path.partition(lib_name)[0]
                 if path:
-                    path_list.append(os.path.abspath(path.strip() + "../"))
+                    path_list.append(os.path.realpath(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 "
@@ -259,46 +258,7 @@ class AscendEnvChecker(EnvChecker):
 
     def __init__(self, library_path):
         self.library_path = library_path
-        self.version = ["7.1"]
-        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/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
-            self.op_path = "/usr/local/Ascend/nnae/latest/opp"
-            self.aicpu_path = "/usr/local/Ascend/nnae/latest"
-        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/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
-            self.op_path = "/usr/local/Ascend/ascend-toolkit/latest/opp"
-            self.aicpu_path = "/usr/local/Ascend/ascend-toolkit/latest"
-        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/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
-            self.op_path = "/usr/local/Ascend/latest/opp"
-            self.aicpu_path = "/usr/local/Ascend/latest"
-        else:
-            # custom or unknown environment
-            self.fwk_path = ""
-            self.op_impl_path = ""
-            self.tbe_path = ""
-            self.cce_path = ""
-            self.fwk_version = ""
-            self.op_path = ""
-            self.aicpu_path = ""
+        self.version = ["7.3", "7.5"]
 
         # env
         self.path = os.getenv("PATH")
@@ -306,12 +266,12 @@ class AscendEnvChecker(EnvChecker):
         self.ld_lib_path = os.getenv("LD_LIBRARY_PATH")
         self.ascend_opp_path = os.getenv("ASCEND_OPP_PATH")
         self.ascend_aicpu_path = os.getenv("ASCEND_AICPU_PATH")
+        self.compiler_version = self.ascend_opp_path.split("opp")[0] + "compiler/version.info"
 
         # check content
         self.path_check = "/compiler/ccec_compiler/bin"
         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"
         self.v = ""
 
@@ -322,36 +282,46 @@ class AscendEnvChecker(EnvChecker):
         else:
             os.environ[env_name] = env_value + ":" + os.environ[env_name]
 
-    @staticmethod
-    def _check_and_set_env(env_name, env_value, is_append=False):
-        """check and set environment variable by its name"""
-        if env_value is None:
+    def check_custom_version(self):
+        """custom op version check"""
+        custom_ascendc_soc_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                                              "../lib/plugin/ascend/custom_ascendc_ops/op_impl/ai_core/tbe/kernel",
+                                              MSContext.get_instance().get_ascend_soc_version())
+        if not os.path.exists(custom_ascendc_soc_dir):
+            logger.debug(f"The path {custom_ascendc_soc_dir} of the custom ascend c operator does not exist.")
+            return False
+
+        if not Path(self.compiler_version).is_file():
             return True
 
-        if not Path(env_value).is_dir():
-            logger.error(
-                f"No such directory: {env_value}. Please check if Ascend AI software package (Ascend Data Center"
-                " Solution) is installed correctly.")
-            return False
+        cur_version = self._read_version(self.compiler_version)
+        custom_version_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                                           "../lib/plugin/ascend/custom_ascendc_ops/version.info")
+        with open(custom_version_path, 'r') as f:
+            all_info = f.readlines()
+            for line in all_info:
+                full_version = line.strip().split("=")[1]
+                compile_version = '.'.join(full_version.split('.')[0:2])
+        if cur_version == compile_version:
+            return True
 
-        if is_append:
-            AscendEnvChecker._concat_variable(env_name, env_value)
-        else:
-            os.environ[env_name] = env_value
-        return True
+        logger.warning(
+            f"The version {compile_version} used for compiling the custom operator does not match "
+            f"Ascend AI software package version {cur_version} in the current environment.")
+        return False
 
     def check_env(self):
         self._check_env()
 
     def check_version(self):
-        if not Path(self.fwk_version).is_file():
+        if not Path(self.compiler_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. For details, refer to the installation guidelines "
                            "https://www.mindspore.cn/install")
             return
 
-        v = self._read_version(self.fwk_version)
+        v = self._read_version(self.compiler_version)
         if v not in self.version:
             v_list = str([x for x in self.version])
             logger.warning(f"MindSpore version {__version__} and Ascend AI software package (Ascend Data Center "
@@ -397,59 +367,24 @@ class AscendEnvChecker(EnvChecker):
                 time.sleep(1)
 
     def set_env(self):
-        curr_path = os.path.abspath(os.path.dirname(__file__))
-        cust_aicpu_path = os.path.abspath(os.path.join(curr_path, "../lib/plugin/ascend/custom_aicpu_ops"))
-        cust_aicore_path = os.path.abspath(os.path.join(curr_path, "../lib/plugin/ascend/custom_aicore_ops"))
+        curr_path = os.path.realpath(os.path.dirname(__file__))
+        cust_aicpu_path = os.path.realpath(os.path.join(curr_path, "../lib/plugin/ascend/custom_aicpu_ops"))
+        cust_aicore_path = os.path.realpath(os.path.join(curr_path, "../lib/plugin/ascend/custom_aicore_ops"))
+        cust_ascendc_path = os.path.realpath(os.path.join(curr_path, "../lib/plugin/ascend/custom_ascendc_ops"))
         if os.getenv('ASCEND_CUSTOM_OPP_PATH'):
             os.environ['ASCEND_CUSTOM_OPP_PATH'] = os.environ['ASCEND_CUSTOM_OPP_PATH'] + ":" + \
-                                                   cust_aicore_path + ":" + cust_aicpu_path
+                                                   cust_ascendc_path + ":" + cust_aicore_path + ":" + cust_aicpu_path
         else:
-            os.environ['ASCEND_CUSTOM_OPP_PATH'] = cust_aicore_path + ":" + cust_aicpu_path
+            os.environ['ASCEND_CUSTOM_OPP_PATH'] = cust_ascendc_path + ":" + cust_aicore_path + ":" + cust_aicpu_path
         plugin_dir = os.path.dirname(self.library_path)
         akg_dir = os.path.join(plugin_dir, "ascend")
         AscendEnvChecker._concat_variable('LD_LIBRARY_PATH', akg_dir)
 
-        if not self.tbe_path:
-            self._check_env()
-            return
-
-        try:
-            origin_path = deepcopy(sys.path)
-            import te  # pylint: disable=unused-import
-        # pylint: disable=broad-except
-        except Exception:
-            sys.path = deepcopy(origin_path)
-            if Path(self.tbe_path).is_dir():
-                os.environ['LD_LIBRARY_PATH'] = self.tbe_path + ":" + os.environ['LD_LIBRARY_PATH']
-            else:
-                logger.error(
-                    f"No such directory: {self.tbe_path}. Please check if Ascend AI software package (Ascend Data "
-                    "Center Solution) is installed correctly.")
-                return
+        self._check_env()
 
         # check te version after set te env
         self.check_deps_version()
 
-        if Path(self.op_impl_path).is_dir():
-            # python path for sub process
-            AscendEnvChecker._concat_variable('PYTHONPATH', self.op_impl_path)
-            # sys path for this process
-            sys.path.append(self.op_impl_path)
-
-            os.environ['TBE_IMPL_PATH'] = self.op_impl_path
-        else:
-            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 not AscendEnvChecker._check_and_set_env('PATH', self.cce_path, True):
-            return
-        if not AscendEnvChecker._check_and_set_env('ASCEND_OPP_PATH', self.op_path):
-            return
-        if not AscendEnvChecker._check_and_set_env('ASCEND_AICPU_PATH', self.aicpu_path):
-            return
-
     def _check_env(self):
         """ascend dependence path check"""
         if self.path is None or self.path_check not in self.path:
@@ -463,8 +398,7 @@ class AscendEnvChecker(EnvChecker):
                 "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):
+        if self.ld_lib_path is None or not self.ld_lib_path_check_fwk in self.ld_lib_path:
             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")
@@ -502,13 +436,6 @@ def check_env(device, _):
 
 def set_env(device, library_path):
     """callback function for setting environment variables"""
-    if not os.getenv("MS_DEV_CLOSE_VERSION_CHECK") is None:
-        if device in os.environ["MS_DEV_CLOSE_VERSION_CHECK"]:
-            return
-        os.environ["MS_DEV_CLOSE_VERSION_CHECK"] = os.environ["MS_DEV_CLOSE_VERSION_CHECK"] + ":" + device
-    else:
-        os.environ["MS_DEV_CLOSE_VERSION_CHECK"] = device
-
     if device.lower() == "ascend":
         env_checker = AscendEnvChecker(library_path)
     elif device.lower() == "gpu":
@@ -533,9 +460,7 @@ def check_version_and_env_config():
         except OSError:
             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.2/faq/installation.html.")
-        if not os.getenv("MS_DEV_CLOSE_VERSION_CHECK") is None:
-            return
+                           "https://www.mindspore.cn/docs/en/master/faq/installation.html.")
         MSContext.get_instance().register_check_env_callback(check_env)
         MSContext.get_instance().register_set_env_callback(set_env)
         MSContext.get_instance().set_device_target_inner(MSContext.get_instance().get_param(ms_ctx_param.device_target))
@@ -577,6 +502,6 @@ def _add_cuda_path():
                 os.environ['PATH'] += os.pathsep + cuda_home_bin_path
 
 
-check_version_and_env_config()
 _set_pb_env()
+check_version_and_env_config()
 _add_cuda_path()

mindspore/run_check/run_check.py

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