mindspore 2.1.0__cp39-cp39-macosx_11_0_arm64.whl → 2.2.11__cp39-cp39-macosx_11_0_arm64.whl

mindspore/.commit_id

@@ -1 +1 @@
-__commit_id__ = ''[sha1]:5822529e,[branch]:(HEAD,origin/r2.1,r2.1)''
+__commit_id__ = ''[sha1]:8c390933,[branch]:(HEAD,origin/r2.2,r2.2)''

mindspore/__init__.py

@@ -20,7 +20,7 @@ from mindspore import common, dataset, mindrecord, train, log, amp
 from mindspore import profiler, communication, numpy, parallel
 from mindspore.common import *
 from mindspore.mindrecord import *
-from mindspore.ops import _op_impl, grad, value_and_grad, vjp, jvp, jacfwd, jacrev, vmap, get_grad
+from mindspore.ops import _op_impl, grad, value_and_grad, vjp, jvp, jacfwd, jacrev, vmap, get_grad, constexpr
 from mindspore.train import *
 from mindspore.log import *
 from mindspore.context import GRAPH_MODE, PYNATIVE_MODE, set_context, get_context, set_auto_parallel_context, \
@@ -31,8 +31,10 @@ from mindspore.profiler import Profiler, EnvProfiler
 from mindspore.parallel import set_algo_parameters, get_algo_parameters, reset_algo_parameters, \
     rank_list_for_transform, transform_checkpoint_by_rank, transform_checkpoints, merge_pipeline_strategys, shard
 from mindspore.rewrite import SymbolTree, ScopedValue, Node, NodeType, TreeNodeHelper
+from mindspore.safeguard import obfuscate_ckpt, load_obf_params_into_net
 from mindspore._check_jit_forbidden_api import get_obj_module_and_name_info, is_jit_forbidden_module, \
     is_invalid_or_jit_forbidden_method
+from mindspore import _install_custom
 
 
 __all__ = ["run_check"]
@@ -43,4 +45,5 @@ __all__.extend(log.__all__)
 __all__.extend(context.__all__)
 __all__.extend(parallel.__all__)
 __all__.extend(rewrite.__all__)
+__all__.extend(safeguard.__all__)
 __all__.append("Profiler")

mindspore/_check_jit_forbidden_api.py

@@ -96,9 +96,11 @@ def is_invalid_or_jit_forbidden_method(obj, obj_type, attr):
     if not hasattr(obj, attr):
         raise AttributeError(f"'{obj_type}' object has no attribute '{attr}'")
     method = getattr(obj, attr)
-    if not hasattr(method, "__module__"):
+    if not hasattr(method, "__module__") or method.__module__ is None:
         return False
     method_info = method.__module__ + '.' + method.__qualname__
     return method_info in _jit_forbidden_method
 
 add_jit_forbidden_module("mindspore.common.initializer")
+add_jit_forbidden_module("mindspore.context")
+add_jit_forbidden_module("mindspore.log")

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
 
@@ -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/graph_split.py

@@ -83,23 +83,23 @@ class CommonPattern:
     def reshape(dom):
         """fuse strategy for reshape dom"""
         if dom.pattern != PrimLib.RESHAPE:
-            return []
+            return [], False
         min_area, forward_fuse = None, False
         for a, _ in dom.out_relations.items():
-            if a.pattern <= PrimLib.BROADCAST and dom.check_acyclic(a) and \
-                    (min_area is None or a.pattern < min_area.pattern):
-                min_area = a
+            if a.pattern <= PrimLib.BROADCAST and dom.check_acyclic(a):
+                if min_area is None or a.pattern < min_area.pattern:
+                    min_area = a
         for a, _ in dom.in_relations.items():
-            if a.pattern <= PrimLib.BROADCAST and a.check_acyclic(dom) and \
-                    (min_area is None or a.pattern < min_area.pattern):
-                min_area, forward_fuse = a, True
-        return ([min_area], forward_fuse) if min_area else []
+            if a.pattern <= PrimLib.BROADCAST and a.check_acyclic(dom):
+                if min_area is None or a.pattern < min_area.pattern:
+                    min_area, forward_fuse = a, True
+        return ([min_area], forward_fuse) if min_area else ([], False)
 
     @staticmethod
     def isolate_reshape(dom):
         """fuse strategy for isolate reshape dom"""
         if dom.pattern != PrimLib.RESHAPE or len(dom.ops) != 1:
-            return []
+            return [], False
         for a, _ in dom.out_relations.items():
             if a.mode == GraphSplitByPattern.Area.MODE_COMPOSITE and dom.check_acyclic(a):
                 return [a], False
@@ -107,59 +107,61 @@ class CommonPattern:
             if a.mode == GraphSplitByPattern.Area.MODE_COMPOSITE and a.pattern <= PrimLib.BROADCAST and \
                     a.check_acyclic(dom):
                 return [a], True
-        return []
+        return [], False
 
     @staticmethod
     def elemwise_depth(dom):
         """fuse strategy in depth for elemwise dom"""
         if dom.pattern != PrimLib.ELEMWISE or len(dom.in_relations) != 1:
-            return []
+            return [], False
         a, r = list(dom.in_relations.items())[0]
-        if a.pattern > PrimLib.ELEMWISE or len(a.out_relations) != 1 or r > PrimLib.ELEMWISE or \
-                tensor_size(a.dom_op().output) != tensor_size(dom.dom_op().output):
-            return []
+        if a.pattern > PrimLib.ELEMWISE or len(a.out_relations) != 1 or r > PrimLib.ELEMWISE:
+            return [], False
+        if tensor_size(a.dom_op().output) != tensor_size(dom.dom_op().output):
+            return [], False
         return [a], True
 
     @staticmethod
     def elemwise_width(dom):
         """fuse strategy in width for elemwise dom"""
         if dom.pattern != PrimLib.ELEMWISE:
-            return []
+            return [], False
         fused = []
         for a, r in dom.in_relations.items():
-            if a.pattern <= PrimLib.ELEMWISE and r <= PrimLib.ELEMWISE and a.check_acyclic(dom) and \
-                    tensor_size(a.dom_op().output) == tensor_size(dom.dom_op().output):
-                fused.append(a)
+            if a.pattern <= PrimLib.ELEMWISE and r <= PrimLib.ELEMWISE and a.check_acyclic(dom):
+                if tensor_size(a.dom_op().output) == tensor_size(dom.dom_op().output):
+                    fused.append(a)
         return fused, True
 
     @staticmethod
     def broadcast_depth(dom):
         """fuse strategy in depth for broadcast dom"""
         if dom.pattern not in (PrimLib.ELEMWISE, PrimLib.BROADCAST) or len(dom.in_relations) != 1:
-            return []
+            return [], False
         a, r = list(dom.in_relations.items())[0]
-        if a.pattern > PrimLib.BROADCAST or len(a.out_relations) != 1 or r > PrimLib.ELEMWISE or \
-                tensor_size(a.dom_op().output) != tensor_size(dom.dom_op().output):
-            return []
+        if a.pattern > PrimLib.BROADCAST or len(a.out_relations) != 1 or r > PrimLib.ELEMWISE:
+            return [], False
+        if tensor_size(a.dom_op().output) != tensor_size(dom.dom_op().output):
+            return [], False
         return [a], True
 
     @staticmethod
     def broadcast_width(dom):
         """fuse strategy in width for broadcast dom"""
         if dom.pattern not in (PrimLib.ELEMWISE, PrimLib.BROADCAST):
-            return []
+            return [], False
         fused = []
         for a, r in dom.in_relations.items():
-            if a.pattern <= PrimLib.BROADCAST and r <= PrimLib.ELEMWISE and a.check_acyclic(dom) and \
-                    tensor_size(a.dom_op().output) == tensor_size(dom.dom_op().output):
-                fused.append(a)
+            if a.pattern <= PrimLib.BROADCAST and r <= PrimLib.ELEMWISE and a.check_acyclic(dom):
+                if tensor_size(a.dom_op().output) == tensor_size(dom.dom_op().output):
+                    fused.append(a)
         return fused, True
 
     @staticmethod
     def assign(dom):
         """fuse strategy for assign dom"""
         if len(dom.ops) != 1 or dom.dom_op().prim != "Assign":
-            return []
+            return [], False
         fused = []
         for a, _ in dom.in_relations.items():
             fused.append(a)
@@ -711,8 +713,9 @@ class GraphSplitByPattern:
             for i in range(len(areas) - 1):
                 dom = areas[i]
                 for a in areas[i + 1:]:
-                    if dom.check_acyclic(a) and a.check_acyclic(dom) and \
-                            selector(dom, a) and self.limit_area_size(dom, [a], 64) and dom.fuse_confirm(a):
+                    can_fuse = dom.check_acyclic(a) and a.check_acyclic(dom) and selector(dom, a) \
+                        and self.limit_area_size(dom, [a], 64) and dom.fuse_confirm(a)
+                    if can_fuse:
                         dom.fuse(a)
                         self.set_area_map(a.ops, dom)
                         self.areas.remove(a)
@@ -844,7 +847,7 @@ class GraphSplitByPattern:
             while stack:
                 op = stack.pop()
                 if len(op.inputs) > 1 or PrimLib.iter_type(op) > PrimLib.BROADCAST or len(ops) > max_weight:
-                    return []
+                    return [], []
                 ops.append(op)
                 for t in op.inputs:
                     if t.op in area.ops:
@@ -878,8 +881,8 @@ class GraphSplitByPattern:
                 return []
             result = []
             for op in borders:
-                if prods[op]:
-                    prod_ops, inputs = prods[op]
+                prod_ops, inputs = prods[op]
+                if prod_ops:
                     if sum([t.get_size() for t in inputs]) <= op.output.get_size():
                         pred = self.area_map.get(inputs[0].op) if inputs and inputs[0].op else None
                         result.append([pred, prod_ops[::-1]])
@@ -938,23 +941,25 @@ class GraphSplitGpu(GraphSplitByPattern):
             return a.pattern > PrimLib.REDUCE or r > PrimLib.BROADCAST
 
         def _broadcast_bwd_depth(dom):
-            if dom.pattern not in (PrimLib.ELEMWISE, PrimLib.BROADCAST) or len(dom.out_relations) != 1 or \
-                    dom.is_output or len(dom.ops) > self.BROADCAST_FUSE_DEPTH:
-                return []
+            if dom.pattern not in (PrimLib.ELEMWISE, PrimLib.BROADCAST) or len(dom.out_relations) != 1:
+                return [], False
+            if dom.is_output or len(dom.ops) > self.BROADCAST_FUSE_DEPTH:
+                return [], False
             a, r = list(dom.out_relations.items())[0]
             if _broadcast_pat_exclude(dom, a, r) or len(a.in_relations) != 1:
-                return []
+                return [], False
             return [a], False
 
         def _broadcast_bwd_width(dom):
             if dom.pattern not in (PrimLib.ELEMWISE, PrimLib.BROADCAST) or \
                     dom.is_output or len(dom.ops) > self.BROADCAST_FUSE_DEPTH:
-                return []
+                return [], False
             fused = []
             for a, r in dom.out_relations.items():
-                if _broadcast_pat_exclude(dom, a, r) or not dom.check_acyclic(a) or \
-                        (fused and tensor_size(fused[0].dom_op().output) != tensor_size(a.dom_op().output)):
-                    return []
+                if _broadcast_pat_exclude(dom, a, r) or not dom.check_acyclic(a):
+                    return [], False
+                if fused and tensor_size(fused[0].dom_op().output) != tensor_size(a.dom_op().output):
+                    return [], False
                 fused.append(a)
             return fused, False
 
@@ -965,25 +970,25 @@ class GraphSplitGpu(GraphSplitByPattern):
 
         def _reduce_depth(dom):
             if dom.pattern != PrimLib.REDUCE or len(dom.in_relations) != 1:
-                return []
+                return [], False
             a, r = list(dom.in_relations.items())[0]
-            if dom.ops[0].inputs[0].dtype == "float16" and a.is_output and len(a.ops) >= 10 and \
-                    _is_atomic_add_available(dom):
-                # to evade the precision problem.
-                return []
+            if dom.ops[0].inputs[0].dtype == "float16" and a.is_output:
+                if len(a.ops) >= 10 and _is_atomic_add_available(dom):
+                    # to evade the precision problem.
+                    return [], False
             if _reduce_pat_exclude(dom, a, r) or len(a.out_relations) != 1:
                 return []
             return [a], True
 
         def _reduce_width(dom):
             if dom.pattern != PrimLib.REDUCE:
-                return []
+                return [], False
             fused = []
             for a, r in dom.in_relations.items():
-                if dom.ops[0].inputs[0].dtype == "float16" and a.is_output and len(a.ops) >= 10 and \
-                        _is_atomic_add_available(dom):
-                    # to evade the precision problem.
-                    continue
+                if dom.ops[0].inputs[0].dtype == "float16" and a.is_output:
+                    if len(a.ops) >= 10 and _is_atomic_add_available(dom):
+                        # to evade the precision problem.
+                        continue
                 if not _reduce_pat_exclude(dom, a, r) and a.check_acyclic(dom):
                     fused.append(a)
             return fused, True
@@ -1016,15 +1021,15 @@ class GraphSplitGpu(GraphSplitByPattern):
 
         def _reduce_output(dom):
             if dom.pattern != PrimLib.REDUCE:
-                return []
+                return [], False
             if _may_multi_filter(dom.ops):
-                return []
+                return [], False
             if _is_atomic_add_available(dom):
-                return []
+                return [], False
             is_all_reduce = tensor_size(dom.ops[0].output) == 1
             # excluded large size all reduce
             if is_all_reduce and dom.ops[0].inputs and tensor_size(dom.ops[0].inputs[0]) > 1024 * 12:
-                return []
+                return [], False
 
             fused = []
             for a, r in dom.out_relations.items():
@@ -1034,11 +1039,11 @@ class GraphSplitGpu(GraphSplitByPattern):
 
         def _reduce_stitch(dom):
             if dom.pattern != PrimLib.REDUCE:
-                return []
+                return [], False
             if tensor_size(dom.ops[0].output) == 1:
-                return []
+                return [], False
             if tensor_size(dom.ops[0].inputs[0]) < 1024 * 12:
-                return []
+                return [], False
 
             fused = []
             for a, r in dom.out_relations.items():
@@ -1055,7 +1060,7 @@ class GraphSplitGpu(GraphSplitByPattern):
 
         def _transpose(dom):
             if len(dom.ops) != 1 or dom.ops[0].prim != "Transpose":
-                return []
+                return [], False
             fused = []
             for a, _ in dom.in_relations.items():
                 if a.pattern <= PrimLib.BROADCAST and a.check_acyclic(dom) and len(a.ops) <= self.TRANSPOSE_FUSE_DEPTH:
@@ -1064,7 +1069,7 @@ class GraphSplitGpu(GraphSplitByPattern):
 
         def _strided_slice(dom):
             if dom.dom_op().prim != "StridedSlice":
-                return []
+                return [], False
             fused = []
             for a, _ in dom.in_relations.items():
                 if a.pattern <= PrimLib.BROADCAST and a.check_acyclic(dom) and \
@@ -1075,7 +1080,7 @@ class GraphSplitGpu(GraphSplitByPattern):
         def _gather_output(dom, reduce_fusion=False):
             gather_prims = ("Gather", "GatherNd", "CSRGather")
             if not dom.dom_op().prim in gather_prims:
-                return []
+                return [], False
 
             def _reduce_exclude(op, axis_list):
                 """ Whether this operator should be excluded.
@@ -1173,7 +1178,7 @@ class GraphSplitGpu(GraphSplitByPattern):
             for a, _ in dom.out_relations.items():
                 if _shape_consistent(gather_prims, appected_areas, dom, a) and dom.check_acyclic(a):
                     return [a], False
-            return []
+            return [], False
 
         def _broadcast_tot(dom):
             """Fuse rule for TensorScatterAdd and UnsortedSegmentSum."""
@@ -1182,13 +1187,13 @@ class GraphSplitGpu(GraphSplitByPattern):
                 return bool(set(op1.inputs) & set(op2.inputs))
 
             if len(dom.ops) != 1:
-                return []
+                return [], False
 
             # Only fuse the first input for `TensorScatterAdd`` and the first and second input for `UnsortedSegmentSum`.
             fuse_arg = {"TensorScatterAdd": slice(1, None), "UnsortedSegmentSum": slice(0, 2)}
             arg_idx = fuse_arg.get(dom.dom_op().prim, -1)
             if arg_idx == -1:
-                return []
+                return [], False
             fuse_tensor = dom.dom_op().inputs[arg_idx]
 
             for a, _ in dom.in_relations.items():
@@ -1200,27 +1205,30 @@ class GraphSplitGpu(GraphSplitByPattern):
                 # Rule 2: Fuse op(reshape/elementwise/broadcast) in specified position inputs.
                 if a.pattern <= PrimLib.BROADCAST and any((op.output in fuse_tensor for op in a.ops)):
                     return [a], True
-            return []
+            return [], False
 
         def _broadcast_onehot(dom, fwd=True):
             """Fuse rule for OneHot."""
             if dom.dom_op().prim != "OneHot":
-                return []
+                return [], False
 
             fused = []
             neighbours = dom.in_relations.items() if fwd else dom.out_relations.items()
             for a, _ in neighbours:
                 if a.pattern <= PrimLib.BROADCAST:
-                    if (fwd and a.check_acyclic(dom) and len(a.out_relations) == 1 and not a.is_output) or \
-                            (not fwd and dom.check_acyclic(a)):
-                        fused.append(a)
+                    if fwd:
+                        if a.check_acyclic(dom) and len(a.out_relations) == 1 and not a.is_output:
+                            fused.append(a)
+                    else:
+                        if dom.check_acyclic(a):
+                            fused.append(a)
 
             return fused, fwd
 
         def _elemwise_elemany(dom):
             """Fuse rule for elemany."""
             if dom.dom_op().prim != "ElemAny":
-                return []
+                return [], False
 
             fused = []
             for a, r in dom.in_relations.items():
@@ -1233,21 +1241,21 @@ class GraphSplitGpu(GraphSplitByPattern):
             """Fuse rule for injective """
             injective_ops = {"Transpose", "StridedSlice"}
             if dom.dom_op().prim not in injective_ops:
-                return []
+                return [], False
             to_ops = dom.dom_op().output.to_ops
             if dom.is_output or len(to_ops) != 1 or len(dom.out_relations) != 1:
-                return []
+                return [], False
             to_area = list(dom.out_relations.keys())[0]
             if (to_area.pattern >= PrimLib.REDUCE and to_area.dom_op().prim not in injective_ops) or \
                     to_ops[0] not in to_area.ops:
-                return []
+                return [], False
             if len(to_area.ops) > self.TRANSPOSE_FUSE_DEPTH:
-                return []
+                return [], False
             return [to_area], False
 
         def _h_broadcast(dom, a):
             if dom.pattern > PrimLib.BROADCAST:
-                return []
+                return [], False
             return a.pattern <= PrimLib.BROADCAST and dom.ops[0].output.shape == a.ops[0].output.shape
 
         def _h_reduce(dom, a):
@@ -1274,7 +1282,7 @@ class GraphSplitGpu(GraphSplitByPattern):
             fuse_arg = {"CSRReduceSum": slice(1, 3), "CSRGather": slice(2, 3)}
             arg_idx = fuse_arg.get(dom.dom_op().prim, -1)
             if arg_idx == -1:
-                return []
+                return [], False
             fuse_tensor = dom.dom_op().inputs[arg_idx]
             for a, _ in dom.in_relations.items():
                 if (a.dom_op().prim == "CSRGather" and a.dom_op().prim == dom.dom_op().prim and
@@ -1283,7 +1291,7 @@ class GraphSplitGpu(GraphSplitByPattern):
                 if a.pattern <= PrimLib.BROADCAST and dom.check_acyclic(a) and \
                         any([op.output in fuse_tensor for op in a.ops]):
                     return [a], True
-            return []
+            return [], False
 
         def _fuse_loop():
             self.fuse(CommonPattern.reshape)