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

mindspore/_check_jit_forbidden_api.py

@@ -94,9 +94,13 @@ def is_jit_forbidden_module(obj_module):
 def is_invalid_or_jit_forbidden_method(obj, obj_type, attr):
     """Check obj has attribute or method."""
     if not hasattr(obj, attr):
-        raise AttributeError(f"{obj_type} object has no attribute: {attr}")
+        raise AttributeError(f"'{obj_type}' object has no attribute '{attr}'")
     method = getattr(obj, attr)
+    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 ""
 
@@ -125,14 +125,13 @@ def _check_3d_int_or_tuple(arg_name, arg_value, prim_name, allow_five=False, ret
 
     def _raise_message(third_one_flag=False, three_input_flag=False):
         if third_one_flag:
-            raise ValueError("For '{}', the depth of parameter '{}' must be 1, but got {}." \
-                .format(prim_name, arg_name, ret_value[-3]))
+            raise ValueError(f"For '{prim_name}', the depth of parameter '{arg_name}' must be 1, " \
+                             f"but got {ret_value[-3]}.")
         if three_input_flag:
-            raise ValueError("For '{}', the parameter '{}' must be an positive integer " \
-                "or a tuple of three positive integer, but got {}.".format(prim_name, arg_name, arg_value))
-        raise ValueError("For '{}', the parameter '{}' must be an positive integer " \
-            "or a tuple of three {}positive integer, but got {}" \
-            .format(prim_name, arg_name, 'or five ' if allow_five else '', arg_value))
+            raise ValueError(f"For '{prim_name}', the parameter '{arg_name}' must be an positive integer " \
+                             f"or a tuple of three positive integer, but got {arg_value}.")
+        raise ValueError(f"For '{prim_name}', the parameter '{arg_name}' must be an positive integer or " \
+                         f"a tuple of three {'or five ' if allow_five else ''}positive integer, but got {arg_value}")
 
     def _get_return_value():
         def _check():
@@ -238,8 +237,8 @@ def check_is_number(arg_value, arg_type, arg_name=None, prim_name=None):
             if math.isinf(arg_value) or math.isnan(arg_value) or np.isinf(arg_value) or np.isnan(arg_value):
                 raise ValueError(f"{prim_name} {arg_name} must be a legal float, but got '{arg_value}'.")
         else:
-            raise TypeError("{} type of {} must be {}, but got '{}'".format(
-                prim_name, arg_name, arg_type.__name__, type(arg_value).__name__))
+            raise TypeError(f"{prim_name} type of {arg_name} must be '{arg_type.__name__}', " \
+                            f"but got '{type(arg_value).__name__}'.")
     _check_param()
     return arg_value
 
@@ -258,21 +257,17 @@ def check_number_range(arg_value, lower_limit, upper_limit, rel, value_type, arg
     def _check_param():
         type_mismatch = not isinstance(arg_value, (np.ndarray, np.generic, value_type)) or isinstance(arg_value, bool)
         if type_mismatch:
-            raise TypeError("{} {} must be '{}',  but got '{}'.".format(
-                prim_name, arg_name, value_type.__name__, type(arg_value).__name__))
+            raise TypeError(f"{prim_name} {arg_name} must be '{value_type.__name__}',  " \
+                            f"but got '{type(arg_value).__name__}'.")
 
         if not _check_inc_rel(arg_value, lower_limit, upper_limit, rel):
             rel_str = _format_str_two_value(lower_limit, upper_limit, rel)
-            raise ValueError("{} {} must be in range of {}, but got {} with type '{}'.".format(
-                prim_name, arg_name, rel_str, arg_value, type(arg_value).__name__))
+            raise ValueError(f"{prim_name} {arg_name} must be in range of {rel_str}, " \
+                             f"but got {arg_value} with type '{type(arg_value).__name__}'.")
     _check_param()
     return arg_value
 
 
-def is_stub_tensor(tensor):
-    return hasattr(tensor, "stub")
-
-
 def check(arg_name, arg_value, value_name, value, rel=EQ, prim_name=None, excp_cls=ValueError):
     """
     Method for judging relation between two int values or list/tuple made up of ints.
@@ -284,6 +279,7 @@ def check(arg_name, arg_value, value_name, value, rel=EQ, prim_name=None, excp_c
             msg_prefix = f'For \'{prim_name}\', the' if prim_name else "The"
             msg_subject = f"{msg_prefix} \'{arg_name}\'" if " " not in arg_name else f"{msg_prefix} {arg_name}"
             raise excp_cls(f'{msg_subject} should be {rel_str}, but got {arg_value}.')
+
     _check()
     return arg_value
 
@@ -315,7 +311,7 @@ def check_equal_int(arg_value, value, arg_name=None, prim_name=None):
     Checks input integer value `arg_value` compare to `value`.
 
     Usage:
-    - number = check_int(number, 0, GE, "number", None) # number >= 0
+    - number = check_equal_int(number, 0, "number", None) # number == 0
     """
     return _check_number(arg_value, value, EQ, int, arg_name, prim_name)
 
@@ -339,8 +335,9 @@ def check_positive_int_sequence(sequence, arg_name=None, prim_name=None):
     - sequence = check_positive_int_sequence(sequence)
     - sequence = check_positive_int_sequence(sequence, "dims")
     """
-    for idx, element in enumerate(sequence):
-        arg_idx = '{}[{}]'.format(arg_name if arg_name else 'arg_name', idx)
+    for idx in range(len(sequence)):
+        element = sequence[idx]
+        arg_idx = f"{arg_name if arg_name else 'arg_name'}[{idx}]"
         _check_number(element, 0, GT, int, arg_idx, prim_name)
     return sequence
 
@@ -386,8 +383,9 @@ def check_non_negative_int_sequence(sequence, arg_name=None, prim_name=None):
     - sequence = check_non_negative_int_sequence(sequence)
     - sequence = check_non_negative_int_sequence(sequence, "dims")
     """
-    for idx, element in enumerate(sequence):
-        arg_idx = '{}[{}]'.format(arg_name if arg_name else 'arg_name', idx)
+    for idx in range(len(sequence)):
+        element = sequence[idx]
+        arg_idx = f"{arg_name if arg_name else 'arg_name'}[{idx}]"
         _check_number(element, 0, GE, int, arg_idx, prim_name)
     return sequence
 
@@ -434,8 +432,9 @@ def check_positive_float_sequence(sequence, arg_name=None, prim_name=None):
     - sequence = check_positive_float_sequence(sequence)
     - sequence = check_positive_float_sequence(sequence, "dims")
     """
-    for idx, element in enumerate(sequence):
-        arg_idx = '{}[{}]'.format(arg_name if arg_name else 'arg_name', idx)
+    for idx in range(len(sequence)):
+        element = sequence[idx]
+        arg_idx = f"{arg_name if arg_name else 'arg_name'}[{idx}]"
         _check_number(element, 0, GT, float, arg_idx, prim_name)
     return sequence
 
@@ -557,8 +556,18 @@ 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
+
+
+# pylint: disable=missing-docstring
+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\_\.\-]*$"
+    if re.match(reg, target, flag) is None:
+        prim_name = f"For '{prim_name}', the" if prim_name else "The"
+        raise ValueError(f"{prim_name} '{target}' is illegal, it must be match regular'{reg}' by flags'{flag}.'")
     return True
 
 
@@ -566,7 +575,7 @@ def check_file_name_by_regular(target, reg=None, prim_name=None):
     """Check whether file name is legitimate."""
     if not isinstance(target, str):
         prim_name = f"For '{prim_name}', the" if prim_name else "The"
-        raise TypeError("{} '{}' must be string, but got {}.".format(prim_name, target, type(target)))
+        raise TypeError(f"{prim_name} '{target}' must be string, but got {type(target)}.")
     if target.endswith("\\") or target.endswith("/"):
         prim_name = f"For '{prim_name}', the" if prim_name else "The"
         raise ValueError(f"{prim_name} '{target}' cannot be a directory path.")
@@ -574,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
 
@@ -650,14 +658,14 @@ def check_types_same_and_valid(args, valid_values, prim_name):
 def check_tensors_dtypes_same_and_valid(args, valid_dtypes, prim_name):
     """Checks whether the element types of input tensors are the same and valid."""
     valid_dtypes = valid_dtypes if isinstance(valid_dtypes, Iterable) else [valid_dtypes]
-    tensor_types = [mstype.tensor_type(t) for t in valid_dtypes]
+    tensor_types = [mstype.TensorType(t) for t in valid_dtypes]
     check_types_same_and_valid(args, tensor_types, prim_name)
 
 
 def check_tensor_dtype_valid(arg_name, arg_type, valid_dtypes, prim_name):
     """Checks whether the element types of input tensors are valid."""
     valid_dtypes = valid_dtypes if isinstance(valid_dtypes, Iterable) else [valid_dtypes]
-    tensor_types = [mstype.tensor_type(t) for t in valid_dtypes]
+    tensor_types = [mstype.TensorType(t) for t in valid_dtypes]
     check_subclass(arg_name, arg_type, tensor_types, prim_name)
 
 
@@ -669,7 +677,7 @@ def check_scalar_or_tensor_types_same(args, valid_values, prim_name, allow_mix=F
 
     def _check_argument_type(arg):
         arg_key, arg_val = arg
-        if isinstance(arg_val, type(mstype.tensor)):
+        if isinstance(arg_val, type(mstype.tensor_type)):
             arg_val = arg_val.element_type()
         if arg_val not in valid_values:
             raise TypeError(f'For \'{prim_name}\', the type of \'{arg_key}\' must be in {valid_values},' \
@@ -680,14 +688,14 @@ def check_scalar_or_tensor_types_same(args, valid_values, prim_name, allow_mix=F
         arg1_name, arg1_type = arg1
         arg2_name, arg2_type = arg2
         except_flag = False
-        if isinstance(arg1_type, type(mstype.tensor)) and isinstance(arg2_type, type(mstype.tensor)):
+        if isinstance(arg1_type, type(mstype.tensor_type)) and isinstance(arg2_type, type(mstype.tensor_type)):
             arg1_type = arg1_type.element_type()
             arg2_type = arg2_type.element_type()
-        elif not (isinstance(arg1_type, type(mstype.tensor)) or isinstance(arg2_type, type(mstype.tensor))):
+        elif not (isinstance(arg1_type, type(mstype.tensor_type)) or isinstance(arg2_type, type(mstype.tensor_type))):
             pass
         elif allow_mix:
-            arg1_type = arg1_type.element_type() if isinstance(arg1_type, type(mstype.tensor)) else arg1_type
-            arg2_type = arg2_type.element_type() if isinstance(arg2_type, type(mstype.tensor)) else arg2_type
+            arg1_type = arg1_type.element_type() if isinstance(arg1_type, type(mstype.tensor_type)) else arg1_type
+            arg2_type = arg2_type.element_type() if isinstance(arg2_type, type(mstype.tensor_type)) else arg2_type
         else:
             except_flag = True
 
@@ -712,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
@@ -742,7 +750,7 @@ def check_type_name(arg_name, arg_type, valid_types, prim_name):
                         f"{type_names if num_types > 1 else type_names[0]}, " \
                         f"but got '{arg_type.__name__ if hasattr(arg_type, '__name__') else repr(arg_type)}'.")
 
-    if isinstance(arg_type, type(mstype.tensor)):
+    if isinstance(arg_type, type(mstype.tensor_type)):
         arg_type = arg_type.element_type()
     cond = arg_type not in valid_types
     raise_error_msg(cond, arg_type)
@@ -791,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, " \
@@ -863,8 +874,8 @@ def prepare_shape_for_squeeze(shape, axes):
 
     def _check(axes, ndim):
         if axes >= ndim or axes < -ndim:
-            raise ValueError("For Tensor.squeeze, the 'axis' must be in the range of [-{0}, {0}), but got {1}." \
-                .format(ndim, axes))
+            raise ValueError(f"For Tensor.squeeze, the 'axis' must be in the range of [-{ndim}, {ndim}), " \
+                             f"but got {axes}.")
 
     def _check_for(axes, ndim):
         for axis in axes:
@@ -881,15 +892,16 @@ def prepare_shape_for_squeeze(shape, axes):
                 new_axes += (item,)
         axes = new_axes
     else:
-        raise TypeError("For Tensor.squeeze, the parameter 'axes' must be one of [int, tuple, list], but got {}" \
-            .format(type(axes)))
+        raise TypeError(f"For Tensor.squeeze, the parameter 'axes' must be one of [int, tuple, list], " \
+                        f"but got {type(axes)}")
 
     def _check_axis(s, idx, axes, ndim):
         # if an axis is selected with shape entry greater than one, an error is raised.
         if s != 1 and ((idx in axes) or (idx - ndim in axes)):
             raise ValueError(f"For Tensor.squeeze, the shape of parameter 'axis' {axes} must be 1, but got {s}.")
 
-    for idx, s in enumerate(shape):
+    for idx in range(ndim):
+        s = shape[idx]
         _check_axis(s, idx, axes, ndim)
         if s != 1 or (idx not in axes) and (idx - ndim not in axes):
             new_shape = new_shape + (s,)
@@ -934,13 +946,19 @@ def check_axis_valid(axes, ndim):
 
 
 def max_(*args):
+    """Return the maximum value of the input parameter."""
     return max(*args)
 
 
 def min_(*args):
+    """Return the minimum value of the input parameter."""
     return min(*args)
 
 
+def is_stub_tensor(tensor):
+    return hasattr(tensor, "stub")
+
+
 def expanded_shape(ndim, axis_size, axis):
     """
     Returns a shape with size = 1 for all dimensions
@@ -961,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):
@@ -1246,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__}.')
 
@@ -1291,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

@@ -924,6 +924,8 @@ class GraphSplitGpu(GraphSplitByPattern):
         if op.prim == "MatMul":
             return self.Area.MODE_COMPOSITE if op.inputs[0].dtype == "float16" and op.attrs['Akg'] else \
                 self.Area.MODE_BASIC
+        if op.prim == "Assign":
+            return self.Area.MODE_BASIC
         pattern = PrimLib.iter_type(op)
         return self.Area.MODE_BASIC if pattern == PrimLib.RESHAPE else self.Area.MODE_COMPOSITE
 

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)))