mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/_extends/parallel_compile/akg_compiler/akg_process.py

@@ -24,17 +24,13 @@ from mindspore._extends.parallel_compile.akg_compiler.util import get_ascend_com
     get_log_level, update_attr, select_best, print_compile_log, check_tbe_support, get_kernel_meta_parent_dir
 
 
-def _compile_akg_task_default(json_strs, attrs):
+def _compile_akg_task_default(json_strs, attrs, func):
     """
     compile func called in single process
 
     Parameters:
         json_strs: list. List contains multiple kernel infos, suitable for json compile api.
     """
-
-    sys.path.insert(0, get_akg_path())
-    p = __import__("akg", globals(), locals(), ['ms'], 0)
-    func = getattr(p.ms, "compilewithjson")
     os.environ["MS_COMPILER_CACHE_PATH"] = get_kernel_meta_parent_dir(attrs)
 
     for json_str in json_strs:
@@ -117,30 +113,115 @@ def create_akg_parallel_process(process_num, wait_time, platform):
     return AkgProcess(process_num, wait_time, platform)
 
 
-class AkgProcess:
-    """akg kernel parallel process"""
+def _is_input_shape_dynamic(desc_d):
+    input_lists = desc_d.get("input_desc", [])
+    if input_lists is None:
+        return True
+    for input_desc in input_lists:
+        shape = input_desc[0].get("shape", ())
+        if -1 in shape or -2 in shape:
+            return True
+    return False
 
-    def __init__(self, process_num, wait_time, platform):
+
+def _compile_akg_v2_task_default(json_strs, attrs, driver):
+    """
+    compile func called in single process
+
+    Parameters:
+        json_strs: list. List contains multiple kernel infos, suitable for json compile api.
+    """
+    log_level = get_log_level(attrs)
+    kernel_meta_dir = os.path.join(get_kernel_meta_parent_dir(attrs), "akg_kernel_meta")
+    for json_str in json_strs:
+        json_desc = json.loads(json_str)
+        op_name = json_desc["op"]
+        info_path = os.path.join(kernel_meta_dir, op_name + ".info")
+        if not os.path.isfile(info_path):
+            raise FileNotFoundError(f"Can not compile non-existing file \"{info_path}\"")
+        # Compile json str with AKG
+        bisheng_cpp_path = os.getenv("BISHENG_CPP_PATH", default="")
+        compiler = driver(input_file=info_path, output_dir=kernel_meta_dir, bisheng_tools_dir=bisheng_cpp_path,
+                          dynamic_shape=_is_input_shape_dynamic(json_desc))
+        try:
+            compiler.compile()
+        except RuntimeError as exc:
+            if log_level == "ERROR":
+                raise ValueError(f"Compile error, json str: {json_str}! build attrs: {attrs}") from exc
+            logger.info(f"Will try to split, json str: {json_str}! build attrs: {attrs}")
+
+
+def create_akg_v2_parallel_process(process_num, wait_time, platform):
+    """
+    create Akg V2 Parallel Compiler object
+
+    Returns:
+        AKG V2 ParallelCompiler
+    """
+    return AkgV2Process(process_num, wait_time, platform)
+
+
+class AkgProcessBase:
+    """base class for akg kernel parallel process"""
+
+    def __init__(self, name, process_num, wait_time, platform):
         """
         Args:
             process_num: int. processes number
             wait_time: int. max time the function blocked
         """
         if not isinstance(process_num, int):
-            raise ValueError("AKG kernel compiling process number must be of type int, but got {} with type {}"
-                             .format(process_num, type(wait_time)))
+            raise ValueError(
+                f"{name} kernel compiling process number must be of type int"
+                ", but got {process_num} with type {type(wait_time)}")
         if not isinstance(wait_time, int):
-            raise ValueError("AKG kernel compiling wait time must be of type int, but got {} with type {}"
-                             .format(wait_time, type(wait_time)))
+            raise ValueError(
+                f"{name} kernel compiling wait time must be of type int,"
+                " but got {wait_time} with type {type(wait_time)}")
         if process_num == 0:
             process_num = 1
         max_proc_num = 16
+        self.name = name
         self.process_num = min([cpu_count(), max_proc_num, process_num])
         self.args = list([] for _ in range(self.process_num))
         self.wait_time = wait_time
         self.platform = platform
         self.argc = 0
 
+    def compile(self, attrs=None):
+        """
+        compile kernel by multi processes
+        Return:
+            True for all compile success, False for some failed.
+        """
+        del attrs
+        raise NotImplementedError
+
+    def accept_json(self, json_str):
+        """
+        accept json data before compile
+        Args:
+            json_str: str. kernel info.
+        """
+        if not isinstance(json_str, str):
+            raise ValueError(
+                f"In {self.name} kernel compiling, the kernel json must be of type str"
+                ", but got {json_str} with type { type(json_str)}")
+        self.args[self.argc % self.process_num].append(json_str)
+        self.argc += 1
+
+
+class AkgProcess(AkgProcessBase):
+    """akg kernel parallel process"""
+
+    def __init__(self, process_num, wait_time, platform):
+        """
+        Args:
+            process_num: int. processes number
+            wait_time: int. max time the function blocked
+        """
+        super(AkgProcess, self).__init__("AKG", process_num, wait_time, platform)
+
     def compile(self, attrs=None):
         """
         compile kernel by multi processes
@@ -150,26 +231,52 @@ class AkgProcess:
         if self.argc == 0:
             raise ValueError("In AKG kernel compiling, the number of kernel json that need to be compiled can "
                              "not be zero.")
-        args = list((arg, attrs) for arg in self.args)
         if self.platform == "ASCEND":
+            args = list((arg, attrs) for arg in self.args)
             create_compile_dirs(get_ascend_compile_dirs(attrs))
             with Pool(processes=self.process_num) as pool:
                 res = pool.starmap_async(_compile_akg_task_ascend, args)
                 res.get(timeout=self.wait_time)
         else:
+            sys.path.append(get_akg_path())
+            p = __import__("akg", globals(), locals(), ['ms'], 0)
+            func = getattr(p.ms, "compilewithjson")
+            args = list((arg, attrs, func) for arg in self.args)
             with Pool(processes=self.process_num) as pool:
                 res = pool.starmap_async(_compile_akg_task_default, args)
                 res.get(timeout=self.wait_time)
         return True
 
-    def accept_json(self, json_str):
+
+class AkgV2Process(AkgProcessBase):
+    """akg v2 kernel parallel process"""
+
+    def __init__(self, process_num, wait_time, platform):
         """
-        accept json data before compile
         Args:
-            json_str: str. kernel info.
+            process_num: int. processes number
+            wait_time: int. max time the function blocked
         """
-        if not isinstance(json_str, str):
-            raise ValueError("In AKG kernel compiling, the kernel json must be of type str, but got {} with type {}"
-                             .format(json, type(json)))
-        self.args[self.argc % self.process_num].append(json_str)
-        self.argc += 1
+        super(AkgV2Process, self).__init__("AKG V2", process_num, wait_time, platform)
+
+    def compile(self, attrs=None):
+        """
+        compile kernel by multi processes
+        Return:
+            True for all compile success, False for some failed.
+        """
+        if self.argc == 0:
+            raise ValueError("In AKG V2 kernel compiling, the number of kernel json that need to be compiled can "
+                             "not be zero.")
+        akg_v2_path = os.getenv("AKG_V2_PATH", default="")
+        if akg_v2_path == "":
+            raise ValueError(
+                "The path to akg v2 compiler is not specified. Set the path to the compiler in AKG_V2_PATH")
+        sys.path.append(akg_v2_path)
+        p = __import__("akg_v2", globals(), locals())
+        driver = getattr(p, "AkgV2Driver")
+        args = list((arg, attrs, driver) for arg in self.args)
+        with Pool(processes=self.process_num) as pool:
+            res = pool.starmap_async(_compile_akg_v2_task_default, args)
+            res.get(timeout=self.wait_time)
+        return True

mindspore/_extends/parallel_compile/akg_compiler/build_tbe_kernel.py

@@ -98,7 +98,7 @@ class TransShape:
             formats.append(v["format"])
             ori_formats.append(v["ori_format"])
         if len(shapes) == 2 and len(shapes[0]) != len(shapes[1]):
-            from impl.add import _add_check_format, _infer_shape
+            from impl.dynamic.add import _add_check_format, _infer_shape
             format_pattern = _add_check_format({"shape": shapes[0], "format": formats[0]},
                                                {"shape": shapes[1], "format": formats[1]})
             ori_shape0 = ori_shapes[0] if ori_shapes[0] is not None else infer_ori_shape(
@@ -410,7 +410,7 @@ def update_json(json_dict, inputs_name, outputs_name, inplace_names, kernel_meta
             pass
         # generate new .json
         try:
-            with os.fdopen(os.open(json_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o660), 'w') as fi:
+            with os.fdopen(os.open(json_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as fi:
                 json.dump(json_dict, fi, sort_keys=True, indent=4, separators=(',', ':'))
         except OSError:
             pass

mindspore/_extends/parallel_compile/akg_compiler/tbe_topi.py

@@ -310,7 +310,8 @@ def _log(x, attrs=None):
     if base <= 0 and not math.isclose(base, -1.0, rel_tol=1e-8, abs_tol=0.0):
         raise ValueError("base must be strictly positive or -1, but got {}".format(base))
     from impl.log import log_compute
-    return log_compute(x, None, base, scale, shift, kernel_name=attrs["fusion_op_name"])
+    outputDesc = {"dtype": x.dtype, "shape": x.shape}
+    return log_compute(x, outputDesc, base, scale, shift, kernel_name=attrs["fusion_op_name"])
 
 
 @reg_op("Maximum", pattern=OpPattern.ELEMWISE)
@@ -349,7 +350,8 @@ def _mul(x0, x1, attrs=None):
         return tbe.dsl.vmuls(x1, x0)
     x0, x1 = _broadcast(x0, x1)
     from impl.mul import mul_compute
-    return mul_compute(x0, x1, None, kernel_name=attrs["fusion_op_name"])
+    outputDesc = {"dtype": x0.dtype, "shape": x0.shape}
+    return mul_compute(x0, x1, outputDesc, kernel_name=attrs["fusion_op_name"])
 
 
 @reg_op("Neg", pattern=OpPattern.ELEMWISE)

mindspore/_extends/parallel_compile/tbe_compiler/tbe_adapter.py

@@ -1,4 +1,4 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
+# Copyright 2021-2023 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.
@@ -34,8 +34,8 @@ from te_fusion.fusion_util import dump_fusion_json
 from te_fusion.parallel_compilation import init_multi_process_env, start_ga_multi_process, deinit_multi_process_env, \
     get_finished_compilation_task
 
-from .tbe_helper import get_soc_info, assemble_op_args, get_compute_op_list, get_options_info, get_fuzz_build_info, \
-    adjust_custom_op_info, pack_op_args, get_module_name, get_real_op_debug_level, LocalLock
+from .tbe_helper import get_soc_info, assemble_op_args, get_compute_op_list, get_options_info, get_context_param, \
+    get_fuzz_build_info, adjust_custom_op_info, pack_op_args, get_module_name, get_real_op_debug_level, LocalLock
 from .tbe_job import TbeJob, JobStatus
 
 
@@ -116,7 +116,7 @@ def __directory_creation(path, concat_path):
     """
     path = os.path.join(path, concat_path)
     if not os.path.isdir(path):
-        os.makedirs(path, 0o750)
+        os.makedirs(path, 0o700)
     return path
 
 
@@ -275,7 +275,7 @@ def get_auto_tune_support_op_list(job: TbeJob):
     :param job:
     :return:
     """
-    from auto_tune_main import enable_auto_tune_support
+    from auto_tune.auto_tune_main import enable_auto_tune_support
     auto_tune_op_list = enable_auto_tune_support()
     job.info("auto tune GA support ops list:{}".format(auto_tune_op_list))
     return [x.lower() for x in auto_tune_op_list]
@@ -313,7 +313,8 @@ def check_support(job: TbeJob):
     _normalize_module_name(op_module_name, compute_op_info["py_module_path"])
     func_name = "check_supported"
     op_type = compute_op_info["type"]
-    res = call_op_func((inputs, outputs, attrs), op_module_name, func_name, op_type, "high_performance")
+    op_impl_mode = compute_op_info["op_impl_mode"]
+    res = call_op_func((inputs, outputs, attrs), op_module_name, func_name, op_type, op_impl_mode)
     if isinstance(res, tuple):
         result, reason = res
         result_str = str(result)
@@ -350,9 +351,10 @@ def select_op_format(job: TbeJob):
     inputs, outputs, attrs = assemble_op_args(compute_op_info)
     op_module_name = get_module_name(compute_op_info)
     py_module_path = compute_op_info["py_module_path"]
+    op_impl_mode = compute_op_info["op_impl_mode"]
     _normalize_module_name(op_module_name, py_module_path)
     op_func_name = "op_select_format"
-    res = call_op_func((inputs, outputs, attrs), op_module_name, op_func_name)
+    res = call_op_func((inputs, outputs, attrs), op_module_name, op_func_name, op_impl_mode)
     job.result = str(res)
     return True
 
@@ -397,19 +399,19 @@ def _pre_build_compute_op_info(compute_op, job):
     is_dynamic_impl = compute_op["is_dynamic_impl"]
     int64_mode = compute_op["int64mode"]
     res = check_op_impl_mode(op_module_name, op_func_name)
-    op_impl_mode = job.content["SocInfo"]["op_impl_mode"]
-    op_impl_mode_list = job.content["SocInfo"]["op_impl_mode_list"]
+    op_impl_mode = compute_op["op_impl_mode"]
     op_full_name = job.content["full_name"]
     if not res:
-        if op_impl_mode_list:
+        if op_impl_mode:
             job.warning("The op {} do NOT support op_impl_mode, current op_impl_mode:{}".format(op_type, op_impl_mode))
     else:
         job.info("OpType {} support op_impl_mode, current op_impl_mode:{}".format(op_type, op_impl_mode))
     options = get_options_info(job.content)
+    context_param = get_context_param()
     dispatch_prebuild_task(job.source_id, job.id, l1_size, op_module_name, op_full_name,
                            op_type, op_func_name, unknown_shape,
                            (inputs, outputs, attrs, options), int64_mode, is_dynamic_impl,
-                           None, job.pass_list)
+                           context_param, job.pass_list, op_impl_mode=op_impl_mode)
 
 
 def get_prebuild_output(op_name):
@@ -474,12 +476,13 @@ def build_single_pre_op(job: TbeJob):
     is_dynamic_impl = compute_op_info["is_dynamic_impl"]
     int64_mode = compute_op_info["int64mode"]
     op_pattern = compute_op_info["pattern"]
+    op_impl_mode = compute_op_info["op_impl_mode"]
     options = get_options_info(job.content)
     fuzz_build_info = get_fuzz_build_info(job.content)
     dispatch_single_op_compile_task(job.source_id, job.id, l1_size, op_module_name, op_name, op_type, op_func_name,
                                     op_kernel_name, unknown_shape, (inputs, outputs, attrs, options), int64_mode,
                                     None, None, is_dynamic_impl, op_pattern,
-                                    json.dumps(fuzz_build_info), None, job.pass_list)
+                                    json.dumps(fuzz_build_info), None, job.pass_list, op_impl_mode=op_impl_mode)
     return True
 
 
@@ -552,6 +555,7 @@ def rl_tune_single_op(job: TbeJob):
     unknown_shape = compute_op_info["unknown_shape"]
     int64_mode = compute_op_info["int64mode"]
     op_pattern = compute_op_info["pattern"]
+    op_impl_mode = compute_op_info["op_impl_mode"]
     fuzz_build_info = get_fuzz_build_info(job.content)
     auto_tiling_mode = job.content["SocInfo"]["autoTilingMode"]
     device_id = job.content["SocInfo"]["deviceId"]
@@ -559,7 +563,8 @@ def rl_tune_single_op(job: TbeJob):
     try:
         build_single_op_from_c(op_module_name, op_func_name, op_type, "build", unknown_shape,
                                (inputs, outputs, attrs), int64_mode, unknown_shape, options,
-                               op_pattern, auto_tiling_mode, device_id, json.dumps(fuzz_build_info))
+                               op_pattern, auto_tiling_mode, device_id, json.dumps(fuzz_build_info),
+                               op_impl_mode=op_impl_mode)
     # pylint: disable=broad-except
     except Exception:
         job.error(

mindspore/_extends/parallel_compile/tbe_compiler/tbe_helper.py

@@ -1,4 +1,4 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
+# Copyright 2021-2023 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.
@@ -32,7 +32,7 @@ def create_dir(dir_path):
     is_exists = os.path.exists(dir_path)
     if not is_exists:
         try:
-            os.makedirs(dir_path, 0o750, exist_ok=True)
+            os.makedirs(dir_path, 0o700, exist_ok=True)
         except (OSError, TypeError) as excep:
             raise excep
         finally:
@@ -53,7 +53,7 @@ def write_to_file(file_path, content=""):
         return False
 
     with os.fdopen(os.open(file_path, os.O_WRONLY | os.O_CREAT, \
-        stat.S_IWUSR | stat.S_IRUSR | stat.S_IRGRP), 'w') as file_handler:
+                           stat.S_IWUSR | stat.S_IRUSR), 'w') as file_handler:
         file_handler.write(content)
     return True
 
@@ -66,7 +66,7 @@ class LocalLock:
     def __init__(self, lock_file):
         if not os.path.exists(lock_file):
             write_to_file(lock_file)
-        self.lock_fd = os.open(lock_file, os.O_WRONLY | os.O_CREAT, stat.S_IWUSR | stat.S_IRUSR | stat.S_IRGRP)
+        self.lock_fd = os.open(lock_file, os.O_WRONLY | os.O_CREAT, stat.S_IWUSR | stat.S_IRUSR)
 
     def __del__(self):
         try:
@@ -141,10 +141,8 @@ def get_soc_info(initialize_job_info):
     :return: soc info
     """
     soc_param = dict()
-    soc_param["op_impl_mode"] = initialize_job_info["SocInfo"]["op_impl_mode"]
     soc_param["op_debug_level"] = reset_op_debug_level_in_soc_info(initialize_job_info["SocInfo"]["op_debug_level"])
     soc_param["op_debug_config"] = initialize_job_info["SocInfo"]["op_debug_config"]
-    soc_param["op_impl_mode_list"] = initialize_job_info["SocInfo"]["op_impl_mode_list"]
     soc_param["op_debug_dir"] = initialize_job_info["SocInfo"]["op_debug_dir"]
     soc_param["vector_fp_ceiling"] = initialize_job_info["SocInfo"]["vector_fp_ceiling"]
     soc_param['mdl_bank_path'] = initialize_job_info["SocInfo"]["mdl_bank_path"]
@@ -288,20 +286,26 @@ def get_options_info(job_content):
     options["l2Mode"] = job_content["SocInfo"]["l2Mode"]
     options["op_debug_level"] = reset_op_debug_level_in_soc_info(job_content["SocInfo"]["op_debug_level"])
     options["op_debug_config"] = job_content["SocInfo"]["op_debug_config"]
-    options["op_impl_mode"] = job_content["SocInfo"]["op_impl_mode"]
     options["op_debug_dir"] = job_content["SocInfo"]["op_debug_dir"]
     options["mdl_bank_path"] = job_content["SocInfo"]["mdl_bank_path"]
     options["te_version"] = job_content["SocInfo"]["te_version"]
     options["op_bank_path"] = job_content["SocInfo"]["op_bank_path"]
     options["deviceId"] = job_content["SocInfo"]["deviceId"]
     options["autoTilingMode"] = job_content["SocInfo"]["autoTilingMode"]
-    options["op_impl_mode_list"] = job_content["SocInfo"]["op_impl_mode_list"]
     options["kernel_meta_temp_dir"] = job_content["SocInfo"]["kernel_meta_temp_dir"]
-    options["deterministic"] = job_content["SocInfo"]["deterministic"]
+    options["deterministic"] = "true" if job_content["SocInfo"]["deterministic"] else "false"
     options["status_check"] = job_content["SocInfo"]["status_check"]
     return options
 
 
+def get_context_param():
+    """
+    Get context param
+    :return: context param
+    """
+    return {"prebuild_targets": ["pattern", "coreType"]}
+
+
 def get_fuzz_build_info(job_content):
     """
     Get fuzz build info from job content info

mindspore/_extends/parallel_compile/tbe_compiler/tbe_job.py

@@ -1,4 +1,4 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
+# Copyright 2021-2022 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.

mindspore/_extends/parallel_compile/tbe_compiler/tbe_job_manager.py

@@ -1,4 +1,4 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
+# Copyright 2021-2022 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.

mindspore/_extends/parse/__init__.py

@@ -16,27 +16,29 @@
 Interfaces for parser module in c++.
 """
 
-from __future__ import  absolute_import
-from .parser import (Parser, create_instance, is_supported_create_instance_type, generate_scope,
-                     get_bprop_method_of_class, get_class_instance_type, get_class_member_namespace_symbol,
-                     create_slice_obj, get_obj_id, get_module_namespace, get_obj_type, get_object_key,
+from __future__ import absolute_import
+from .parser import (Parser, create_instance, is_supported_create_instance_type, generate_scope, get_attr_from_object,
+                     get_bprop_method_of_class, get_class_instance_type, get_class_member_namespace_symbol, get_dtype,
+                     create_slice_obj, get_obj_id, get_module_namespace, get_obj_type, get_object_key, resolve_symbol,
                      get_ast_type, get_node_type, get_args, get_args_default_values, get_ast_namespace_symbol,
                      get_operation_symbol, get_operation_namespace_symbol, get_parse_method_of_class, get_scope_name,
-                     eval_script, get_script_ids, expand_expr_statement, is_class_member, parse_cb, resolve_symbol,
-                     convert_to_ms_tensor, get_object_description, get_class_attr_namespace_symbol, get_ms_class_name,
-                     is_class_type, check_obj_bool, python_isinstance, ms_isinstance, convert_to_ms_csrtensor,
-                     convert_to_ms_cootensor, convert_class_to_function, convert_cell_list_to_sequence, is_cell_list,
-                     get_obj_from_sequence, get_type, is_class_member_recursive, merge_global_params, get_global_params,
-                     get_adapter_tensor_attr, get_local_variable, set_local_variable, get_obj_defined_from_obj_type)
+                     eval_script, get_script_id_attrs, expand_expr_statement, is_class_member_of_self, parse_cb,
+                     convert_to_ms_tensor, get_object_description, get_ms_class_name, is_class_type, check_obj_bool,
+                     python_isinstance, ms_isinstance, convert_to_ms_csrtensor, convert_to_ms_cootensor,
+                     convert_class_to_function, convert_cell_list_to_sequence, is_cell_list, get_obj_from_sequence,
+                     get_type, is_class_member_recursive, get_global_params, get_adapter_tensor_attr,
+                     get_obj_defined_from_obj_type, is_from_third_party_library, get_const_abs, get_const_round,
+                     get_const_len, is_adapter_tensor_class, is_adapter_parameter_class, convert_to_namedtuple)
 
-__all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'generate_scope',
+__all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'generate_scope', 'get_attr_from_object',
            'get_bprop_method_of_class', 'get_class_instance_type', 'get_class_member_namespace_symbol',
            'create_slice_obj', 'get_obj_id', 'get_module_namespace', 'get_obj_type', 'get_object_key',
            'get_ast_type', 'get_node_type', 'get_args', 'get_args_default_values', 'get_ast_namespace_symbol',
            'get_operation_symbol', 'get_operation_namespace_symbol', 'get_parse_method_of_class', 'get_scope_name',
-           'eval_script', 'get_script_ids', 'expand_expr_statement', 'is_class_member', 'parse_cb', 'resolve_symbol',
-           'convert_to_ms_tensor', 'get_object_description', 'get_class_attr_namespace_symbol', 'get_ms_class_name',
-           'is_class_type', 'check_obj_bool', 'python_isinstance', 'ms_isinstance', 'convert_to_ms_csrtensor',
-           'convert_to_ms_cootensor', 'convert_class_to_function', 'convert_cell_list_to_sequence', 'is_cell_list',
-           'get_obj_from_sequence', 'get_type', 'is_class_member_recursive', 'get_adapter_tensor_attr',
-           'get_local_variable', 'set_local_variable', 'get_obj_defined_from_obj_type']
+           'eval_script', 'get_script_id_attrs', 'expand_expr_statement', 'is_class_member_of_self', 'parse_cb',
+           'resolve_symbol', 'convert_to_ms_tensor', 'get_object_description', 'get_ms_class_name', 'is_class_type',
+           'check_obj_bool', 'python_isinstance', 'ms_isinstance', 'convert_to_ms_csrtensor', 'convert_to_ms_cootensor',
+           'convert_class_to_function', 'convert_cell_list_to_sequence', 'is_cell_list', 'get_obj_from_sequence',
+           'get_type', 'is_class_member_recursive', 'get_adapter_tensor_attr', 'get_obj_defined_from_obj_type',
+           'is_from_third_party_library', 'get_const_abs', 'get_const_round', 'get_const_len',
+           'is_adapter_tensor_class', 'is_adapter_parameter_class', 'convert_to_namedtuple',]

mindspore/_extends/parse/namespace.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2022 Huawei Technologies Co., Ltd
+# Copyright 2020-2023 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.
@@ -30,6 +30,7 @@ class Namespace:
         name (str): The namespace's name.
         dicts (dict): A list of dict containing the namespace's variable.
     """
+
     def __init__(self, name, *dicts):
         self.name = name
         self.dicts = dicts
@@ -57,6 +58,7 @@ class CellNamespace(Namespace):
     Args:
         name (str): Valid module name, it can be imported.
     """
+
     def __init__(self, name):
         mod_dict = vars(__import__(name, fromlist=['_']))
         builtins_dict = vars(builtins)
@@ -79,6 +81,7 @@ class ClosureNamespace(Namespace):
     Args:
         fn (Function): A python function.
     """
+
     def __init__(self, fn):
         name = f'{fn.__module__}..<{fn.__name__}>'
         names = fn.__code__.co_freevars
@@ -101,6 +104,7 @@ class ClassMemberNamespace(Namespace):
     Args:
         obj (Object): A python class object.
     """
+
     def __init__(self, obj):
         self.__class_member_namespace__ = True
         label = f'{obj.__module__}..<{obj.__class__.__name__}::{id(obj)}>'
@@ -108,8 +112,6 @@ class ClassMemberNamespace(Namespace):
 
     def __getitem__(self, name):
         d, = self.dicts
-        if name == "self":
-            return d
         if name == "namespace":
             return self
         try:
@@ -119,10 +121,7 @@ class ClassMemberNamespace(Namespace):
         except ValueError:
             raise UnboundLocalError(name)
         except KeyError:
-            # Check if cls is user-defined class decorated with jit_class. If true, an exception will be thrown.
             cls = d.__class__
-            if hasattr(cls, '__ms_class__'):
-                raise NotImplementedError(f"'{cls.__name__ }' object has no attribute or method: '{name}'.")
             # Class private attribute.
             if name.startswith("__"):
                 private_member = "_" + cls.__name__ + name
@@ -130,36 +129,8 @@ class ClassMemberNamespace(Namespace):
                     logger.warning(f"The private attribute or method '{name}' is used in '{cls.__name__}'. " + \
                                    f"In graph mode, '{name}' will be adjusted to '{private_member}' for parsing.")
                     return getattr(d, private_member)
-            logger.info(f"'{cls.__name__ }' object has no attribute or method: '{name}', so will return None.")
+            logger.info(f"'{cls.__name__}' object has no attribute or method: '{name}', so will return None.")
             raise AttributeError(name)
 
-
-class ClassAttrNamespace(Namespace):
-    """
-    Namespace of a class.
-
-    Args:
-        obj (Object): A python class object.
-    """
-    def __init__(self, obj):
-        name = f'{obj.__module__}..<{obj.__class__.__name__}::{id(obj)}>'
-        super().__init__(name, obj)
-
     def __getattr__(self, name):
-        d, = self.dicts
-        try:
-            if hasattr(d, name):
-                return getattr(d, name)
-            return d.__dict__[name]
-        except ValueError:
-            raise UnboundLocalError(name)
-        except KeyError:
-            # Class private attribute.
-            cls = d.__class__
-            if name.startswith("__"):
-                private_attr = "_" + cls.__name__ + name
-                if hasattr(d, private_attr):
-                    logger.warning(f"The private attribute or method '{name}' is used in '{cls.__name__}'. " + \
-                                   f"In graph mode, '{name}' will be adjusted to '{private_attr}' for parsing.")
-                    return getattr(d, private_attr)
-            raise AttributeError(f"'{cls.__name__ }' object has no attribute or method: '{name}'.")
+        return self.__getitem__(name)