mindspore 2.0.0a0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/_extends/parallel_compile/akg_compiler/akg_process.py

@@ -21,7 +21,7 @@ from multiprocessing import Pool, cpu_count
 from mindspore import log as logger
 from mindspore._extends.parallel_compile.akg_compiler.get_file_path import get_akg_path
 from mindspore._extends.parallel_compile.akg_compiler.util import get_ascend_compile_dirs, create_compile_dirs, \
-    get_log_level, update_attr, select_best, print_compile_log, check_tbe_support
+    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):
@@ -35,6 +35,7 @@ def _compile_akg_task_default(json_strs, attrs):
     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:
         res = func(json_str, attrs)
@@ -66,7 +67,7 @@ def _compile_akg_task_ascend(json_strs, attrs):
         return
     log_level = get_log_level(attrs)
     compiler = os.path.join(os.path.split(os.path.realpath(__file__))[0], "compiler.py")
-    compile_dirs = get_ascend_compile_dirs()
+    compile_dirs = get_ascend_compile_dirs(attrs)
     kernel_meta_dir = compile_dirs.get("kernel_meta_dir")
     akg_compile_dir = compile_dirs.get("akg_compile_dir")
     tbe_compile_dir = compile_dirs.get("tbe_compile_dir")
@@ -151,7 +152,7 @@ class AkgProcess:
                              "not be zero.")
         args = list((arg, attrs) for arg in self.args)
         if self.platform == "ASCEND":
-            create_compile_dirs(get_ascend_compile_dirs())
+            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)

mindspore/_extends/parallel_compile/akg_compiler/tbe_topi.py

@@ -19,6 +19,8 @@ from enum import Enum
 
 
 class OpPattern(Enum):
+    """Pattern of operator."""
+
     ELEMWISE = "ELEMWISE"
     BROADCAST = "BROADCAST"
     REDUCE = "REDUCE"
@@ -58,24 +60,24 @@ def get_op_reg_info(op_name, key, strict=True):
 
 def _broadcast(lhs, rhs):
     """Broadcast inputs."""
-    from te import tvm
-    from te.utils import shape_util
-    import te.lang.cce as tbe
-    if isinstance(lhs, tvm.tensor.Tensor) and isinstance(rhs, tvm.expr.ConstExpr):
-        return lhs, tbe.broadcast(rhs, lhs.shape)
-    if isinstance(lhs, tvm.expr.ConstExpr) and isinstance(rhs, tvm.tensor.Tensor):
-        return tbe.broadcast(lhs, rhs.shape), rhs
+    import tbe
+    from tbe import tvm
+    from tbe.common.utils import shape_to_list, broadcast_shapes
+    if isinstance(lhs, tvm.Tensor) and isinstance(rhs, tvm.expr.ConstExpr):
+        return lhs, tbe.dsl.broadcast(rhs, lhs.shape)
+    if isinstance(lhs, tvm.expr.ConstExpr) and isinstance(rhs, tvm.Tensor):
+        return tbe.dsl.broadcast(lhs, rhs.shape), rhs
     if isinstance(lhs, tvm.expr.ConstExpr) and isinstance(rhs, tvm.expr.ConstExpr):
         shape = [1]
-        return tbe.broadcast(lhs, shape), tbe.broadcast(rhs, shape)
-    if isinstance(lhs, tvm.tensor.Tensor) and isinstance(rhs, tvm.tensor.Tensor):
-        shape1 = shape_util.shape_to_list(lhs.shape)
-        shape2 = shape_util.shape_to_list(rhs.shape)
+        return tbe.dsl.broadcast(lhs, shape), tbe.dsl.broadcast(rhs, shape)
+    if isinstance(lhs, tvm.Tensor) and isinstance(rhs, tvm.Tensor):
+        shape1 = shape_to_list(lhs.shape)
+        shape2 = shape_to_list(rhs.shape)
         if shape1 != shape2:
-            _, _, shape = shape_util.broadcast_shapes(shape1, shape2, param_name_input1="lhs", param_name_input2="rhs")
-            return tbe.broadcast(lhs, shape), tbe.broadcast(rhs, shape)
+            _, _, shape = broadcast_shapes(shape1, shape2, param_name_input1="lhs", param_name_input2="rhs")
+            return tbe.dsl.broadcast(lhs, shape), tbe.dsl.broadcast(rhs, shape)
         return lhs, rhs
-    raise TypeError("Broadcast only supports tvm.tensor.Tensor or tvm.expr.ConstExpr, but got {}, {}"
+    raise TypeError("Broadcast only supports tvm.Tensor or tvm.expr.ConstExpr, but got {}, {}"
                     .format(type(lhs), type(rhs)))
 
 
@@ -103,13 +105,13 @@ def _acosh(x, attrs=None):
 @reg_op("Add", pattern=OpPattern.ELEMWISE)
 def _add(x0, x1, attrs=None):
     """Add"""
-    from te import tvm
-    import te.lang.cce as tbe
+    import tbe
+    from tbe import tvm
     is_float = x0.dtype in ["float16", "float32"]
-    if is_float and isinstance(x0, tvm.tensor.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
-        return tbe.vadds(x0, x1)
-    if is_float and isinstance(x0, tvm.expr.ConstExpr) and isinstance(x1, tvm.tensor.Tensor):
-        return tbe.vadds(x1, x0)
+    if is_float and isinstance(x0, tvm.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
+        return tbe.dsl.vadds(x0, x1)
+    if is_float and isinstance(x0, tvm.expr.ConstExpr) and isinstance(x1, tvm.Tensor):
+        return tbe.dsl.vadds(x1, x0)
     x0, x1 = _broadcast(x0, x1)
     from impl.add import add_compute
     return add_compute(x0, x1, None, kernel_name=attrs["fusion_op_name"])
@@ -149,7 +151,7 @@ def _cast(x, attrs=None):
     src_type = x.dtype
     dst_type = attrs["dst_type"]
     if src_type == "int64":
-        from te import tvm
+        from tbe import tvm
         from impl.cast import _kernel_ir
         res = tvm.extern([x.shape], [x], lambda ins, outs: _kernel_ir(outs, ins, dst_type, "int64"), name="res",
                          dtype=dst_type)
@@ -338,13 +340,13 @@ def _mod(x0, x1, attrs=None):
 @reg_op("Mul", pattern=OpPattern.ELEMWISE)
 def _mul(x0, x1, attrs=None):
     """Mul"""
-    from te import tvm
-    import te.lang.cce as tbe
+    import tbe
+    from tbe import tvm
     is_float = x0.dtype in ["float16", "float32"]
-    if is_float and isinstance(x0, tvm.tensor.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
-        return tbe.vmuls(x0, x1)
-    if is_float and isinstance(x0, tvm.expr.ConstExpr) and isinstance(x1, tvm.tensor.Tensor):
-        return tbe.vmuls(x1, x0)
+    if is_float and isinstance(x0, tvm.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
+        return tbe.dsl.vmuls(x0, x1)
+    if is_float and isinstance(x0, tvm.expr.ConstExpr) and isinstance(x1, tvm.Tensor):
+        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"])
@@ -376,10 +378,10 @@ def _pow(x0, x1, attrs=None):
 @reg_op("RealDiv", "real_div", OpPattern.ELEMWISE)
 def _realdiv(x0, x1, attrs=None):
     """RealDiv"""
-    from te import tvm
-    import te.lang.cce as tbe
-    if x0.dtype in ["float16", "float32"] and isinstance(x0, tvm.tensor.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
-        return tbe.vmuls(x0, tvm.const(1.0 / x1.value, x0.dtype))
+    import tbe
+    from tbe import tvm
+    if x0.dtype in ["float16", "float32"] and isinstance(x0, tvm.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
+        return tbe.dsl.vmuls(x0, tvm.const(1.0 / x1.value, x0.dtype))
     x0, x1 = _broadcast(x0, x1)
     from impl.real_div import real_div_compute
     return real_div_compute(x0, x1, None, kernel_name=attrs["fusion_op_name"])
@@ -437,14 +439,14 @@ def _square(x, attrs=None):
 @reg_op("Sub", pattern=OpPattern.ELEMWISE)
 def _sub(x0, x1, attrs=None):
     """Sub"""
-    from te import tvm
-    import te.lang.cce as tbe
+    import tbe
+    from tbe import tvm
     is_float = x0.dtype in ["float16", "float32"]
-    if is_float and isinstance(x0, tvm.tensor.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
-        return tbe.vadds(x0, tvm.const(-1.0 * x1.value, x0.dtype))
-    if is_float and isinstance(x0, tvm.expr.ConstExpr) and isinstance(x1, tvm.tensor.Tensor):
-        tmp = tbe.vmuls(x1, tvm.const(-1, x1.dtype))
-        return tbe.vadds(tmp, tvm.const(x0.value, x0.dtype))
+    if is_float and isinstance(x0, tvm.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
+        return tbe.dsl.vadds(x0, tvm.const(-1.0 * x1.value, x0.dtype))
+    if is_float and isinstance(x0, tvm.expr.ConstExpr) and isinstance(x1, tvm.Tensor):
+        tmp = tbe.dsl.vmuls(x1, tvm.const(-1, x1.dtype))
+        return tbe.dsl.vadds(tmp, tvm.const(x0.value, x0.dtype))
     x0, x1 = _broadcast(x0, x1)
     from impl.sub import sub_compute
     return sub_compute(x0, x1, None, kernel_name=attrs["fusion_op_name"])
@@ -460,26 +462,26 @@ def _tanh(x, attrs=None):
 @reg_op("BroadcastTo", "broadcast", OpPattern.BROADCAST)
 def _broadcast_to(x, attrs=None):
     """BroadcastTo"""
-    from te import tvm
-    import te.lang.cce as tbe
+    import tbe
+    from tbe import tvm
     shape = attrs["shape"]
-    if isinstance(x, tvm.tensor.Tensor):
+    if isinstance(x, tvm.Tensor):
         from impl.broadcast_to_d import broadcast_to_compute
         return broadcast_to_compute(x, None, shape, kernel_name=attrs["fusion_op_name"])
-    return tbe.broadcast(x, shape, x.dtype)
+    return tbe.dsl.broadcast(x, shape, x.dtype)
 
 
 @reg_op("ReduceSum", "reduce_sum", OpPattern.REDUCE)
 def _reduce_sum(x, attrs=None):
     """ReduceSum"""
-    from te.utils import shape_util
+    from tbe.common.utils import axis_check
     axis = attrs["axis"]
     keep_dims = attrs["keep_dims"]
     if not axis:
         axis = [i for i in range(len(x.shape))]
     if not isinstance(axis, list):
         axis = [axis]
-    axis = shape_util.axis_check(len(x.shape), axis)
+    axis = axis_check(len(x.shape), axis)
     from impl.reduce_sum_d import reduce_sum_d_compute
     return reduce_sum_d_compute(x, None, axis, keep_dims, kernel_name=attrs["fusion_op_name"])
 
@@ -487,14 +489,14 @@ def _reduce_sum(x, attrs=None):
 @reg_op("ReduceMax", "reduce_max", OpPattern.REDUCE)
 def _reduce_max(x, attrs=None):
     """ReduceMax"""
-    from te.utils import shape_util
+    from tbe.common.utils import axis_check
     axis = attrs["axis"]
     keep_dims = attrs["keep_dims"]
     if not axis:
         axis = [i for i in range(len(x.shape))]
     if not isinstance(axis, list):
         axis = [axis]
-    axis = shape_util.axis_check(len(x.shape), axis)
+    axis = axis_check(len(x.shape), axis)
     from impl.reduce_max_d import reduce_max_d_compute
     return reduce_max_d_compute(x, None, axis, keep_dims, kernel_name=attrs["fusion_op_name"])
 
@@ -502,14 +504,14 @@ def _reduce_max(x, attrs=None):
 @reg_op("ReduceMin", "reduce_min", OpPattern.REDUCE)
 def _reduce_min(x, attrs=None):
     """ReduceMin"""
-    from te.utils import shape_util
+    from tbe.common.utils import axis_check
     axis = attrs["axis"]
     keep_dims = attrs["keep_dims"]
     if not axis:
         axis = [i for i in range(len(x.shape))]
     if not isinstance(axis, list):
         axis = [axis]
-    axis = shape_util.axis_check(len(x.shape), axis)
+    axis = axis_check(len(x.shape), axis)
     from impl.reduce_min_d import reduce_min_d_compute
     return reduce_min_d_compute(x, None, axis, keep_dims, kernel_name=attrs["fusion_op_name"])
 

mindspore/_extends/parallel_compile/akg_compiler/util.py

@@ -58,14 +58,19 @@ def print_compile_log(compile_log):
                     logger.info(log)
 
 
-def get_kernel_meta_parent_dir():
+def get_kernel_meta_parent_dir(attrs):
     """Get kernel_meta parent dir."""
-    return os.path.realpath(os.getenv('MS_COMPILER_CACHE_PATH', './'))
+    attrs_dict = {}
+    if isinstance(attrs, str):
+        attrs_dict = json.loads(attrs)
+    elif isinstance(attrs, dict):
+        attrs_dict = attrs
+    return os.path.realpath(attrs_dict.get("compile_cache"))
 
 
-def get_ascend_compile_dirs():
+def get_ascend_compile_dirs(attrs):
     """Get several Ascend compile dirs."""
-    kernel_meta_dir = os.path.join(get_kernel_meta_parent_dir(), "akg_kernel_meta")
+    kernel_meta_dir = os.path.join(get_kernel_meta_parent_dir(attrs), "akg_kernel_meta")
     compile_dirs = {"kernel_meta_dir": kernel_meta_dir,
                     "akg_compile_dir": os.path.join(kernel_meta_dir, "akg"),
                     "tbe_compile_dir": os.path.join(kernel_meta_dir, "tbe"),

mindspore/_extends/parallel_compile/tbe_compiler/tbe_adapter.py

@@ -310,10 +310,10 @@ def check_support(job: TbeJob):
     if op_func_name in ("resize_nearest_neighbor_v2_grad_d", "resize_bilinear_v2_grad"):
         attrs.pop(-2)
     op_module_name = get_module_name(compute_op_info)
-    py_module_path = compute_op_info["py_module_path"]
-    _normalize_module_name(op_module_name, py_module_path)
+    _normalize_module_name(op_module_name, compute_op_info["py_module_path"])
     func_name = "check_supported"
-    res = call_op_func((inputs, outputs, attrs), op_module_name, func_name)
+    op_type = compute_op_info["type"]
+    res = call_op_func((inputs, outputs, attrs), op_module_name, func_name, op_type, "high_performance")
     if isinstance(res, tuple):
         result, reason = res
         result_str = str(result)
@@ -510,7 +510,7 @@ def parallel_compile_fusion_op(job: TbeJob):
     relation = ""
     fixpipe_ub_cfg = ""
     dispatch_fusion_op_compile_task(job.source_id, job.id, l1_size, json.dumps(job.content), op_kernel_name, None, None,
-                                    options, None, job.pass_list, op_name, relation, fixpipe_ub_cfg)
+                                    options, None, job.pass_list, op_name, relation, fixpipe_ub_cfg, None)
     return True
 
 

mindspore/_extends/parallel_compile/tbe_compiler/tbe_helper.py

@@ -143,10 +143,12 @@ def get_soc_info(initialize_job_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"]
+    soc_param['te_version'] = initialize_job_info["SocInfo"]["te_version"]
     soc_param['op_bank_path'] = initialize_job_info["SocInfo"]["op_bank_path"]
     soc_param['kernel_meta_temp_dir'] = initialize_job_info["SocInfo"]["kernel_meta_temp_dir"]
 
@@ -247,7 +249,7 @@ def assemble_op_args(compute_op_info, is_single_op_build=False):
         attrs = []
         attrs_info = compute_op_info["attrs"] if "attrs" in compute_op_info.keys() else []
         for item in attrs_info:
-            if item["valid"] and item["name"] != "isRef":
+            if item["valid"]:
                 attrs.append(item)
     else:
         attrs = compute_op_info["attr_desc"] if "attr_desc" in compute_op_info.keys() else []
@@ -285,15 +287,18 @@ def get_options_info(job_content):
     options["l2Fusion"] = job_content["SocInfo"]["l2Fusion"]
     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["status_check"] = "false"
+    options["deterministic"] = job_content["SocInfo"]["deterministic"]
+    options["status_check"] = job_content["SocInfo"]["status_check"]
     return options
 
 
@@ -336,10 +341,10 @@ def get_module_name(compute_op_info):
     :param compute_op_info:
     :return:
     """
-    dynamic_compile_static = compute_op_info["dynamic_compile_static"]
+    is_dynamic_impl = compute_op_info["is_dynamic_impl"]
     unknown_shape = compute_op_info["unknown_shape"]
     op_module_name = compute_op_info["module_name"]
-    if dynamic_compile_static or unknown_shape:
+    if is_dynamic_impl or unknown_shape:
         d = ".dynamic."
         op_module_name = d.join((op_module_name.split(".")[0], op_module_name.split(".")[-1]))
     return op_module_name

mindspore/_extends/parse/__init__.py

@@ -1,4 +1,4 @@
-# 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.
@@ -26,7 +26,8 @@ from .parser import (Parser, create_instance, is_supported_create_instance_type,
                      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_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)
 
 __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'generate_scope',
            'get_bprop_method_of_class', 'get_class_instance_type', 'get_class_member_namespace_symbol',
@@ -37,4 +38,5 @@ __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'ge
            '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_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']

mindspore/_extends/parse/namespace.py

@@ -123,6 +123,13 @@ class ClassMemberNamespace(Namespace):
             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
+                if hasattr(d, private_member):
+                    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.")
             raise AttributeError(name)
 
@@ -147,4 +154,12 @@ class ClassAttrNamespace(Namespace):
         except ValueError:
             raise UnboundLocalError(name)
         except KeyError:
-            raise AttributeError(f"'{d.__class__.__name__ }' object has no attribute or method: '{name}'.")
+            # 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}'.")