mindspore 2.1.0__cp38-none-any.whl → 2.2.10__cp38-none-any.whl

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)

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}
@@ -51,8 +50,9 @@ def split_with_json(json_str, flags_str):
 def _load_repository(graph, flags):
     """Load repository if exists"""
     def check_repo(op, best_split, op_desc):
-        if not isinstance(best_split, dict) or "group_num" not in best_split or "graph_mode" not in best_split \
-                or "split_result" not in best_split:
+        if not isinstance(best_split, dict):
+            return False
+        if "group_num" not in best_split or "graph_mode" not in best_split or "split_result" not in best_split:
             logger.warning("The graph split repository of {} should be a dict which contains 'group_num', 'graph_mode' "
                            "and 'split_result' field, but got {}".format(op, best_split))
             return False
@@ -114,19 +114,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)))