mindspore 2.1.0__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/_checkparam.py

@@ -84,21 +84,21 @@ def _check_inc_rel(val, lower, upper, rel):
 def _format_str_one_value(value, rel):
     """format string"""
     if rel == EQ:
-        return "= {}".format(value)
+        return f"= {value}"
     if rel == NE:
-        return "!= {}".format(value)
+        return f"!= {value}"
     if rel == LT:
-        return "< {}".format(value)
+        return f"< {value}"
     if rel == LE:
-        return "<= {}".format(value)
+        return f"<= {value}"
     if rel == GT:
-        return "> {}".format(value)
+        return f"> {value}"
     if rel == GE:
-        return ">= {}".format(value)
+        return f">= {value}"
     if rel == IN:
-        return "in {}".format(value)
+        return f"in {value}"
     if rel == NOT_IN:
-        return "not in {}".format(value)
+        return f"not in {value}"
 
     return ""
 
@@ -106,13 +106,13 @@ def _format_str_one_value(value, rel):
 def _format_str_two_value(val1, val2, rel):
     """format string"""
     if rel == INC_NEITHER:
-        return "({}, {})".format(val1, val2)
+        return f"({val1}, {val2})"
     if rel == INC_LEFT:
-        return "[{}, {})".format(val1, val2)
+        return f"[{val1}, {val2})"
     if rel == INC_RIGHT:
-        return "({}, {}]".format(val1, val2)
+        return f"({val1}, {val2}]"
     if rel == INC_BOTH:
-        return "[{}, {}]".format(val1, val2)
+        return f"[{val1}, {val2}]"
 
     return ""
 
@@ -556,8 +556,7 @@ def check_str_by_regular(target, reg=None, flag=re.ASCII, prim_name=None):
         reg = r"^\w+[0-9a-zA-Z\_\.]*$"
     if re.match(reg, target, flag) is None:
         prim_name = f"For '{prim_name}', the" if prim_name else "The"
-        raise ValueError("{} '{}' is illegal, it must be match regular'{}' by flags'{}.'".format(
-            prim_name, target, reg, flag))
+        raise ValueError(f"{prim_name} '{target}' is illegal, it must be match regular'{reg}' by flags'{flag}.'")
     return True
 
 
@@ -565,11 +564,10 @@ def check_str_by_regular(target, reg=None, flag=re.ASCII, prim_name=None):
 def check_str_and_none_by_regular(target, reg=None, flag=re.ASCII, prim_name=None):
     if reg is None:
         # Named string regular expression
-        reg = r"^\w*[0-9a-zA-Z\_\.]*$"
+        reg = r"^\w*[0-9a-zA-Z\_\.\-]*$"
     if re.match(reg, target, flag) is None:
         prim_name = f"For '{prim_name}', the" if prim_name else "The"
-        raise ValueError("{} '{}' is illegal, it must be match regular'{}' by flags'{}.'".format(
-            prim_name, target, reg, flag))
+        raise ValueError(f"{prim_name} '{target}' is illegal, it must be match regular'{reg}' by flags'{flag}.'")
     return True
 
 
@@ -585,8 +583,7 @@ def check_file_name_by_regular(target, reg=None, prim_name=None):
         reg = r"^[0-9a-zA-Z@\_\-\.\:\/\\]+$"
     if re.match(reg, target) is None:
         prim_name = f"For '{prim_name}', the" if prim_name else "The"
-        raise ValueError("{} '{}' is illegal, it must be match regular '{}'.".format(
-            prim_name, target, reg))
+        raise ValueError(f"{prim_name} '{target}' is illegal, it must be match regular '{reg}'.")
 
     return True
 
@@ -723,9 +720,9 @@ def check_value_type(arg_name, arg_value, valid_types, prim_name=None):
         type_names = [t.__name__ if hasattr(t, '__name__') else str(t) for t in valid_types]
         num_types = len(valid_types)
         msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
-        raise TypeError(f'{msg_prefix} type of \'{arg_name}\' should be {"one of " if num_types > 1 else ""}' \
-                        f'\'{type_names if num_types > 1 else type_names[0]}\', ' \
-                        f'but got type \'{type(arg_value).__name__}\'.')
+        type_name_msg = f'{type_names if num_types > 1 else type_names[0]}'
+        msg = f'type of \'{arg_name}\' should be{"one of " if num_types > 1 else ""} \'{type_name_msg}\''
+        raise TypeError(f'{msg_prefix} {msg}, but got type \'{type(arg_value).__name__}\'.')
 
     # Notice: bool is subclass of int, so `check_value_type('x', True, [int])` will check fail, and
     #         `check_value_type('x', True, [bool, int])` will check pass
@@ -802,6 +799,9 @@ def check_transpose_axis(axes, ndim):
         # if only one argument provided, it must be tuple or list
         if isinstance(perm, list):
             perm = tuple(perm)
+        elif isinstance(perm, int):
+            perm = (perm,)
+            _check_dim()
         else:
             if not isinstance(perm, tuple):
                 raise TypeError(f"For Tensor.transpose, the parameter 'axes' must be a tuple/list, " \
@@ -959,11 +959,6 @@ def is_stub_tensor(tensor):
     return hasattr(tensor, "stub")
 
 
-def is_pack_tensor(tensor):
-    """Whether it is a PackTensor."""
-    return hasattr(tensor, "__pack__")
-
-
 def expanded_shape(ndim, axis_size, axis):
     """
     Returns a shape with size = 1 for all dimensions
@@ -984,8 +979,8 @@ def infer_out_shape(*shapes):
     def _check(items, max_size, shapes):
         for item in items:
             if item not in (1, max_size):
-                raise ValueError(f'For Tensor, the dimension on each axis must be 1 or the max on the axis' \
-                                 f'to support broadcast, but got shapes {shapes,}')
+                raise ValueError(f'For Tensor, the dimension on each axis must be 1 or the max value on the axis' \
+                                 f'to support broadcasting, but got shapes {shapes,}')
     shape_out = ()
     max_len = max([len(it) for it in shapes])
     for i in range(max_len):
@@ -1269,7 +1264,7 @@ def check_input_data(*data, data_class):
             if not ret:
                 data_class_str = tuple(i.__name__ if hasattr(i, '__name__') else i for i in data_class) if isinstance(
                     data_class, (tuple, list)) else (data_class if data_class is None else data_class.__name__)
-                raise TypeError(f'The type of input data must be in the Union({data_class_str}, ' \
+                raise TypeError(f'The types of input data must be in the Union({data_class_str}, ' \
                                 f'tuple[{data_class_str}], list[{data_class_str}], dict[{data_class_str}]), ' \
                                 f'but got type {item if item is None else type(item).__name__}.')
 
@@ -1314,8 +1309,7 @@ def args_type_check(*type_args, **type_kwargs):
             for name, value in argument_dict.items():
                 if name in bound_types:
                     if value is not None and not isinstance(value, bound_types[name]):
-                        raise TypeError("The parameter '{}' must be {}, but got {}"
-                                        .format(name, bound_types[name], type(value)))
+                        raise TypeError(f"The parameter '{name}' must be {bound_types[name]}, but got {type(value)}")
             return func(*args, **kwargs)
 
         return wrapper

mindspore/_extends/graph_kernel/__init__.py

@@ -14,5 +14,4 @@
 # ============================================================================
 """init"""
 from .splitter import split_with_json
-from .expander import get_op_expander, get_expander_op_list
 from .parallel_estimate import estimate_calculation_amount, estimate_ops

mindspore/_extends/graph_kernel/model/model_builder.py

@@ -13,9 +13,6 @@
 # limitations under the License.
 # ===========================================================================
 """GraphKernel model builder"""
-
-import copy
-from . import op_infer
 from .model import Tensor, Value, Operator, Graph, AlignShape
 
 
@@ -95,18 +92,6 @@ class GraphBuilder:
         node.all_inputs = inputs
         self.current.graph.add(node)
 
-    def emit(self, prim, inputs, name=None, attrs=None):
-        """Emit a new operation"""
-        if attrs is None:
-            attrs = {}
-        if isinstance(inputs, (Tensor, Value)):
-            inputs = [inputs]
-        tensor_inputs = [t for t in inputs if isinstance(t, (Tensor, Value))]
-        out_shape, out_dtype, out_format = op_infer.infer(prim, tensor_inputs, attrs)
-        output = self.tensor(out_shape, out_dtype, out_format, name)
-        self.op(prim, output, inputs, attrs)
-        return output
-
     def get(self):
         """Get graphs"""
         return self.graphs
@@ -169,15 +154,18 @@ class CompositeGraph:
             for op in desc['op_desc']:
                 inputs = [self.tensors.get(d['tensor_name'], None) for x in op['input_desc']
                           for d in x if 'value' not in d]
+                if op['name'] in ('ReduceSum', 'ReduceMax', 'ReduceMin'):
+                    axis = op['input_desc'][1][0]['value']
+                    if isinstance(axis, int):
+                        axis = [axis]
+                    if not op['attr']:
+                        attr = [{'name': 'axis', 'dtype': 'listInt', 'value': axis}]
+                        op['attr'] = attr
+                    else:
+                        op['attr'].append({'name': 'axis', 'dtype': 'listInt', 'value': axis})
                 out_desc = op['output_desc']
                 name, shape, dtype, data_format = out_desc[0]['tensor_name'], out_desc[
                     0]['shape'], out_desc[0]['data_type'], out_desc[0]['format']
-                if op['name'] == 'InplaceAssign':
-                    inputs[0].add_buddy(inputs[1])
-                    inputs[1].para_type = Tensor.PARA_OUTPUT
-                    output = inputs[2]
-                    self.tensors[name] = output
-                    continue
                 output = self.tensors.get(name, None)
                 if not output:
                     output = builder.tensor(shape, dtype, data_format, name=name)
@@ -186,46 +174,17 @@ class CompositeGraph:
         self.graph = builder.get()[0]
         self.desc = desc
 
-    def _pre_dump(self, outputs):
-        """restore name to before load"""
-        inplace_assign = {}  # y_name, output_name
-        inplace_assign_z = None
-        for op in self.desc['op_desc']:
-            if op['name'] == 'InplaceAssign':
-                inplace_assign[op['input_desc'][1][0]['tensor_name']] = op['output_desc'][0]['tensor_name']
-        if inplace_assign:
-            for t in outputs:
-                if t.name not in inplace_assign:
-                    inplace_assign_z = t
-        return inplace_assign, inplace_assign_z
 
     def dump(self, subgraph):
         """Dump Graph to json"""
         desc = {}
         inputs, outputs = subgraph.deduce_parameters()
         graph_ops = set(subgraph.ops)
-        inplace_assign, inplace_assign_z = self._pre_dump(outputs)
 
         def dump_output(t):
-            if t.name in inplace_assign:
-                z = inplace_assign_z if inplace_assign_z is not None else self.tensors.get(t.name, None)
-                return {'data_type': z.dtype, 'shape': z.shape, 'tensor_name': inplace_assign.get(t.name)}
             return {'data_type': t.dtype, 'shape': t.shape, 'tensor_name': t.name}
 
         def dump_op_desc(d):
-            if d['name'] == 'InplaceAssign':
-                y = d['input_desc'][1][0]['tensor_name']
-                if self.tensors[y].op in graph_ops:
-                    z, fake = (inplace_assign_z, False) if inplace_assign_z is not None else (self.tensors.get(y), True)
-                    inplace_desc = copy.deepcopy(d)
-                    inplace_desc['attr'] = {'name': 'fake_output', 'value': fake}
-                    z_desc, out_desc = inplace_desc['input_desc'][2][0], inplace_desc['output_desc'][0]
-                    z_desc['shape'] = z.shape
-                    z_desc['data_type'] = z.dtype
-                    z_desc['tensor_name'] = z.name
-                    out_desc['shape'] = z.shape
-                    out_desc['data_type'] = z.dtype
-                    return inplace_desc
             op = self.tensors[d['output_desc'][0]['tensor_name']].op
             if op in graph_ops or op in subgraph.recompute_ops:
                 return d

mindspore/_extends/graph_kernel/splitter.py

@@ -36,7 +36,6 @@ def split_with_json(json_str, flags_str):
         subgraphs, graph_mode = model.split(comp.graph, target, flags)
         is_multi_graph = len(subgraphs) > 1
         graph_list = list(map(comp.dump, subgraphs))
-        _reset_graphmode_for_inplaceassign(graph_list, graph_mode)
         result = {"multi_graph": is_multi_graph,
                   "graph_desc": graph_list,
                   "graph_mode": graph_mode}
@@ -114,19 +113,12 @@ def _load_repository(graph, flags):
     return result
 
 
-def _reset_graphmode_for_inplaceassign(graph_list, graph_mode):
-    """Operator with InplaceAssign should always be composite op"""
-    for i, g in enumerate(graph_list):
-        if any((op['name'] == 'InplaceAssign' for op in g['op_desc'])):
-            graph_mode[i] = 'composite'
-
-
 def _dump_split_info(use_repo, graph_str, graph, subgraphs, graph_mode, graph_list):
     """Dump split info as text"""
     graph_kernel_dump_path = "graph_kernel_dump"
     utils.create_dir(graph_kernel_dump_path)
     filename = os.path.join(graph_kernel_dump_path, "graph_kernel_split_mode.%d.txt" % os.getpid())
-    with os.fdopen(os.open(filename, os.O_WRONLY | os.O_CREAT), "a+") as f:
+    with os.fdopen(os.open(filename, os.O_WRONLY | os.O_CREAT, 0o600), "a+") as f:
         f.write("********** main graph: {} **********\n".format(graph.name))
         f.write("input json:\n{}\n".format(graph_str))
         f.write("graph desc:\n{}\n".format(str(graph)))

mindspore/_extends/parallel_compile/akg_compiler/akg_process.py

@@ -113,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
@@ -162,14 +247,36 @@ class AkgProcess:
                 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 2023 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.
@@ -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
 
 

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:

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

@@ -23,13 +23,12 @@ from .parser import (Parser, create_instance, is_supported_create_instance_type,
                      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_id_attrs, expand_expr_statement, is_class_member_of_self, parse_cb,
-                     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_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_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', 'get_attr_from_object',
            'get_bprop_method_of_class', 'get_class_instance_type', 'get_class_member_namespace_symbol',
@@ -37,11 +36,9 @@ __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'ge
            '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_id_attrs', 'expand_expr_statement', 'is_class_member_of_self', '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_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',]
+           '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',]