[ONNX]fix bug: ndarray assignment destination may be read-only

x2paddle/op_mapper/onnx_op_mapper.py

@@ -246,10 +246,8 @@ class ONNXOpMapper(OpMapper):
         assert len(val_inps) == 1, 'directly_map error with multi inputs'
         if fluid_op not in ['shape']:
             attr['name'] = string(node.layer_name)
-        node.fluid_code.add_layer(fluid_op,
-                                  inputs=val_inps[0],
-                                  output=val_outs[0],
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            fluid_op, inputs=val_inps[0], output=val_outs[0], param_attr=attr)
 
     def deal_custom_layer(self, node):
         op = node.layer_type
@@ -258,7 +256,8 @@ class ONNXOpMapper(OpMapper):
         params = get_params(node.layer, node.layer_type)
         arg_names, kwargs = set_args(func, params)
         kwargs['name'] = string(node.layer_name)
-        node.fluid_code.add_layer(func.__code__.co_name,
+        node.fluid_code.add_layer(
+            func.__code__.co_name,
             inputs=node.inputs,
             output=node,
             param_attr=kwargs,
@@ -299,21 +298,18 @@ class ONNXOpMapper(OpMapper):
                 'shape': val_y_reshaped,
                 'name': string(var_y_reshaped)
             }
-            node.fluid_code.add_layer('reshape',
+            node.fluid_code.add_layer(
+                'reshape',
                 inputs=val_y,
                 output=var_y_reshaped,
                 param_attr=attr_reshaped)
             inputs = {'x': val_x, 'y': var_y_reshaped}
-            node.fluid_code.add_layer(op_type,
-                                      inputs=inputs,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                op_type, inputs=inputs, output=node, param_attr=attr)
         else:
             inputs = {'x': val_x, 'y': val_y}
-            node.fluid_code.add_layer(op_type,
-                                      inputs=inputs,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                op_type, inputs=inputs, output=node, param_attr=attr)
 
     def place_holder(self, node):
         self.input_shapes.append(node.out_shapes[0])
@@ -331,10 +327,8 @@ class ONNXOpMapper(OpMapper):
             "append_batch_size": 'False'
         }
 
-        node.fluid_code.add_layer("data",
-                                  inputs=None,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "data", inputs=None, output=node, param_attr=attr)
 
     def create_parameter(self, node, parameter=None):
         if parameter is not None:
@@ -351,10 +345,8 @@ class ONNXOpMapper(OpMapper):
             'attr': string(node.layer_name),
             'default_initializer': 'Constant(0.0)'
         }
-        node.fluid_code.add_layer("create_parameter",
-                                  inputs=None,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "create_parameter", inputs=None, output=node, param_attr=attr)
 
     def _pad_if_asymmetric(self, node, pads, val_name):  # pads: SSEE
         assert len(pads) & 1 == 0
@@ -373,7 +365,6 @@ class ONNXOpMapper(OpMapper):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
         val_scales = self.graph.get_input_node(node, idx=1, copy=True)
         val_y = self.graph.get_node(node.layer.output[0], copy=True)
-
         out_shape = val_y.out_shapes[0]
         if out_shape is not None:
             assert len(out_shape) == 4, 'only 4-D Tensor as X and Y supported'
@@ -383,7 +374,6 @@ class ONNXOpMapper(OpMapper):
 
         if isinstance(val_scales, ONNXGraphNode):
             scales, _, _ = self.get_dynamic_shape(val_scales.layer_name)
-
         attr = {'name': string(node.layer_name)}
         use_scales = True
         if scales is not None:
@@ -420,10 +410,8 @@ class ONNXOpMapper(OpMapper):
         else:
             attr['out_shape'] = out_shape
 
-        node.fluid_code.add_layer(fluid_op,
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            fluid_op, inputs=val_x, output=node, param_attr=attr)
 
     def RoiAlign(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
@@ -439,7 +427,8 @@ class ONNXOpMapper(OpMapper):
             'spatial_scale': spatial_scale,
             'sampling_ratio': sampling_ratio,
         }
-        node.fluid_code.add_layer('roi_align',
+        node.fluid_code.add_layer(
+            'roi_align',
             inputs={
                 'input': val_x,
                 'rois': val_rois
@@ -458,7 +447,8 @@ class ONNXOpMapper(OpMapper):
             'pooled_width': pooled_width,
             'spatial_scale': spatial_scale,
         }
-        node.fluid_code.add_layer('roi_pool',
+        node.fluid_code.add_layer(
+            'roi_pool',
             inputs={
                 'input': val_x,
                 'rois': val_rois
@@ -501,13 +491,12 @@ class ONNXOpMapper(OpMapper):
         attr['paddings'] = paddings
         if op_independent:
             attr['name'] = string(node.layer_name)
-            node.fluid_code.add_layer(fluid_op,
-                                      inputs=val_x,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                fluid_op, inputs=val_x, output=node, param_attr=attr)
         else:
             attr['name'] = string(node.layer_name + '_paded')
-            node.fluid_code.add_layer(fluid_op,
+            node.fluid_code.add_layer(
+                fluid_op,
                 inputs=val_x,
                 output=node.layer_name + '_paded',
                 param_attr=attr)
@@ -517,16 +506,12 @@ class ONNXOpMapper(OpMapper):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
         axes = node.get_attr('axes')
         if len(val_x.out_shapes[0]) == 0:
-            node.fluid_code.add_layer('assign',
-                                      inputs=val_x,
-                                      output=node,
-                                      param_attr=None)
+            node.fluid_code.add_layer(
+                'assign', inputs=val_x, output=node, param_attr=None)
         else:
             attr = {'axes': axes, 'name': string(node.layer_name)}
-            node.fluid_code.add_layer('unsqueeze',
-                                      inputs=val_x,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                'unsqueeze', inputs=val_x, output=node, param_attr=attr)
 
     def Shrink(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
@@ -534,10 +519,8 @@ class ONNXOpMapper(OpMapper):
         lambd = node.get_attr('lambd')
         assert bias == 0.0, 'not support bias!=0'
         attr = {'threshold': lambd, 'name': node.layer_name}
-        node.fluid_code.add_layer('hard_shrink',
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            'hard_shrink', inputs=val_x, output=node, param_attr=attr)
 
     def Constant(self, node):
         val_output = self.graph.get_node(node.layer.output[0], copy=True)
@@ -567,10 +550,8 @@ class ONNXOpMapper(OpMapper):
             if dtype.name == 'int64':
                 dtype = 'int32'
             attr = {'shape': shape, 'dtype': string(dtype), 'value': value}
-            node.fluid_code.add_layer('fill_constant',
-                                      inputs=None,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                'fill_constant', inputs=None, output=node, param_attr=attr)
         else:
             value = np.reshape(value, shape)
             self.weights[node.layer_name] = value
@@ -581,10 +562,8 @@ class ONNXOpMapper(OpMapper):
                 'attr': string(node.layer_name),
                 'default_initializer': 'Constant(0.0)'
             }
-            node.fluid_code.add_layer("create_parameter",
-                                      inputs=None,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "create_parameter", inputs=None, output=node, param_attr=attr)
 
     def Resize(self, node):
         self._interpolate(node)
@@ -605,13 +584,12 @@ class ONNXOpMapper(OpMapper):
 
         name_ones = node.layer_name + '_ones'
         attr_ones = {'shape': out_shape, 'dtype': string(val_x_dtype)}
-        node.fluid_code.add_layer('ones',
-                                  inputs=None,
-                                  output=name_ones,
-                                  param_attr=attr_ones)
+        node.fluid_code.add_layer(
+            'ones', inputs=None, output=name_ones, param_attr=attr_ones)
         inputs = {'x': name_ones, 'y': val_x}
         attr = {'name': string(node.layer_name)}
-        node.fluid_code.add_layer('elementwise_mul',
+        node.fluid_code.add_layer(
+            'elementwise_mul',
             inputs=inputs,
             output=node.layer_name,
             param_attr=attr)
@@ -624,7 +602,8 @@ class ONNXOpMapper(OpMapper):
         assert len(
             indices_shape) <= 2, "Gather op don't support dim of indice >2 "
         if axis == 0 and len(indices_shape) <= 1:
-            node.fluid_code.add_layer('gather',
+            node.fluid_code.add_layer(
+                'gather',
                 inputs={
                     'input': val_x,
                     'index': indices
@@ -636,25 +615,26 @@ class ONNXOpMapper(OpMapper):
             perm = [axis] + perm[:axis] + perm[axis + 1:]
             attr_trans = {'perm': perm}
             name_trans = val_x.layer_name + '_trans'
-            node.fluid_code.add_layer('transpose',
+            node.fluid_code.add_layer(
+                'transpose',
                 inputs=val_x,
                 output=name_trans,
                 param_attr=attr_trans)
-            node.fluid_code.add_layer('gather',
+            node.fluid_code.add_layer(
+                'gather',
                 inputs={
                     'input': name_trans,
                     'index': indices
                 },
                 output=node,
                 param_attr=None)
-            node.fluid_code.add_layer('transpose',
-                                      inputs=node,
-                                      output=node,
-                                      param_attr=attr_trans)
+            node.fluid_code.add_layer(
+                'transpose', inputs=node, output=node, param_attr=attr_trans)
         elif len(indices_shape) > 1:
             from functools import reduce
             reshape_shape = reduce(lambda x, y: x * y, indices_shape)
-            node.fluid_code.add_layer('reshape',
+            node.fluid_code.add_layer(
+                'reshape',
                 inputs=indices,
                 output=indices,
                 param_attr={'shape': [
@@ -665,28 +645,29 @@ class ONNXOpMapper(OpMapper):
             perm = [axis] + perm[:axis] + perm[axis + 1:]
             attr_trans = {'perm': perm}
             name_trans = val_x.layer_name + '_trans'
-            node.fluid_code.add_layer('transpose',
+            node.fluid_code.add_layer(
+                'transpose',
                 inputs=val_x,
                 output=name_trans,
                 param_attr=attr_trans)
-            node.fluid_code.add_layer('gather',
+            node.fluid_code.add_layer(
+                'gather',
                 inputs={
                     'input': name_trans,
                     'index': indices
                 },
                 output=node,
                 param_attr=None)
-            node.fluid_code.add_layer('transpose',
-                                      inputs=node,
-                                      output=node,
-                                      param_attr=attr_trans)
+            node.fluid_code.add_layer(
+                'transpose', inputs=node, output=node, param_attr=attr_trans)
             val_x_shape = val_x.out_shapes[0]
             reshaped_shape = []
             for i in perm:
                 reshaped_shape.append(indices_shape[i])
             for i in val_x_shape[:axis] + val_x_shape[axis + 1:]:
                 reshaped_shape.append(i)
-            node.fluid_code.add_layer('reshape',
+            node.fluid_code.add_layer(
+                'reshape',
                 inputs=node,
                 output=node,
                 param_attr={'shape': reshaped_shape})
@@ -708,8 +689,8 @@ class ONNXOpMapper(OpMapper):
 
             self.omit_nodes.append(starts.layer_name)
             self.omit_nodes.append(ends.layer_name)
-            starts = _const_weight_or_none(starts)
-            ends = _const_weight_or_none(ends)
+            starts = _const_weight_or_none(starts).copy()
+            ends = _const_weight_or_none(ends).copy()
         else:
             starts = node.get_attr('starts')
             ends = node.get_attr('ends')
@@ -727,10 +708,8 @@ class ONNXOpMapper(OpMapper):
                 if value > shape[axes[idx]]:
                     ends[idx] = shape[axes[idx]]
         attr = {"axes": axes, "starts": starts, "ends": ends}
-        node.fluid_code.add_layer('slice',
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            'slice', inputs=val_x, output=node, param_attr=attr)
 
     def ConstantOfShape(self, node):
         val_shape = self.graph.get_input_node(node, idx=0, copy=True)
@@ -753,10 +732,8 @@ class ONNXOpMapper(OpMapper):
             if dtype.name == 'int64':
                 dtype = 'int32'
             attr = {'shape': shape, 'dtype': string(dtype), 'value': value}
-            node.fluid_code.add_layer('fill_constant',
-                                      inputs=None,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                'fill_constant', inputs=None, output=node, param_attr=attr)
 
     def Split(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
@@ -771,10 +748,8 @@ class ONNXOpMapper(OpMapper):
             'name': string(node.layer_name)
         }
 
-        node.fluid_code.add_layer('split',
-                                  inputs=val_x,
-                                  output=val_y,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            'split', inputs=val_x, output=val_y, param_attr=attr)
 
     def Reshape(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
@@ -791,7 +766,8 @@ class ONNXOpMapper(OpMapper):
             shape, _, _ = self.get_dynamic_shape(val_shape.layer_name)
             if val_shape.dtype == 'int64':
                 val_shape_cast = val_shape.layer_name + '_cast'
-                node.fluid_code.add_layer('cast',
+                node.fluid_code.add_layer(
+                    'cast',
                     inputs=val_shape,
                     output=val_shape_cast,
                     param_attr={'dtype': string('int32')})
@@ -812,10 +788,8 @@ class ONNXOpMapper(OpMapper):
                 val_x.layer_name, val_reshaped.layer_name)
 
         attr['shape'] = shape
-        node.fluid_code.add_layer('reshape',
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            'reshape', inputs=val_x, output=node, param_attr=attr)
 
     def Cast(self, node):
         val_input = self.graph.get_input_node(node, idx=0, copy=True)
@@ -829,10 +803,8 @@ class ONNXOpMapper(OpMapper):
         if output_dtype:
             assert dtype == output_dtype, 'dtype of to unmatches output'
         attr = {'dtype': string(dtype)}
-        node.fluid_code.add_layer('cast',
-                                  inputs=val_input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            'cast', inputs=val_input, output=node, param_attr=attr)
 
     def AveragePool(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
@@ -867,10 +839,8 @@ class ONNXOpMapper(OpMapper):
             "name": string(node.layer_name)
         }
 
-        node.fluid_code.add_layer(fluid_op,
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            fluid_op, inputs=val_x, output=node, param_attr=attr)
 
     def Concat(self, node):
         inputs = []
@@ -882,19 +852,15 @@ class ONNXOpMapper(OpMapper):
                 inputs.append(ipt.layer_name)
         axis = node.get_attr('axis')
         attr = {'axis': axis}
-        node.fluid_code.add_layer('concat',
-                                  inputs=inputs,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            'concat', inputs=inputs, output=node, param_attr=attr)
 
     def Flatten(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
         axis = node.get_attr('axis', 1)
         attr = {"axis": str(axis), "name": string(node.layer_name)}
-        node.fluid_code.add_layer('flatten',
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            'flatten', inputs=val_x, output=node, param_attr=attr)
 
     def Gemm(self, node):
         val_a = self.graph.get_input_node(node, idx=0, copy=True)
@@ -913,7 +879,8 @@ class ONNXOpMapper(OpMapper):
             "alpha": alpha,
             "name": string(val_mm)
         }
-        node.fluid_code.add_layer('matmul',
+        node.fluid_code.add_layer(
+            'matmul',
             inputs=matmul_inputs,
             output=val_mm,
             param_attr=attr_matmul)
@@ -922,21 +889,24 @@ class ONNXOpMapper(OpMapper):
             if beta == 1.:
                 add_inputs = {"x": val_mm, "y": val_c}
                 attr = {"name": string(node.layer_name)}
-                node.fluid_code.add_layer("elementwise_add",
+                node.fluid_code.add_layer(
+                    "elementwise_add",
                     inputs=add_inputs,
                     output=node,
                     param_attr=attr)
             else:
                 var_beta = node.layer_name + '_beta'
                 matmul_beta_inputs = {"x": val_c, "y": var_beta}
-                node.fluid_code.add_layer("Constant",
+                node.fluid_code.add_layer(
+                    "Constant",
                     inputs=matmul_beta_inputs,
                     output=var_beta,
                     param_attr={'value': beta})
 
                 add_inputs = {"x": val_mm, "y": var_beta}
                 attr = {"name": string(node.layer_name)}
-                node.fluid_code.add_layer("elementwise_add",
+                node.fluid_code.add_layer(
+                    "elementwise_add",
                     inputs=add_inputs,
                     output=node,
                     param_attr=attr)
@@ -955,19 +925,16 @@ class ONNXOpMapper(OpMapper):
                 "x": node.layer_name,
                 "y": y,
             }
-            node.fluid_code.add_layer("elementwise_add",
-                                      inputs=inputs,
-                                      output=node)
+            node.fluid_code.add_layer(
+                "elementwise_add", inputs=inputs, output=node)
 
     def MatMul(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
         val_y = self.graph.get_input_node(node, idx=1, copy=True)
         inputs = {"x": val_x, "y": val_y}
         attr = {"name": string(node.layer_name)}
-        node.fluid_code.add_layer("matmul",
-                                  inputs=inputs,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "matmul", inputs=inputs, output=node, param_attr=attr)
 
     def BatchNormalization(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
@@ -998,27 +965,21 @@ class ONNXOpMapper(OpMapper):
             "use_global_stats": spatial,
             "name": string(node.layer_name)
         }
-        node.fluid_code.add_layer("batch_norm",
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "batch_norm", inputs=val_x, output=node, param_attr=attr)
 
     def Transpose(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
         perm = node.get_attr('perm')
         attr = {'perm': perm, "name": string(node.layer_name)}
-        node.fluid_code.add_layer("transpose",
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "transpose", inputs=val_x, output=node, param_attr=attr)
 
     def Relu(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
         attr = {"name": string(node.layer_name)}
-        node.fluid_code.add_layer("relu",
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "relu", inputs=val_x, output=node, param_attr=attr)
 
     def PRelu(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
@@ -1034,24 +995,21 @@ class ONNXOpMapper(OpMapper):
             "param_attr": string(val_slope.layer_name),
             'mode': string(mode)
         }
-        node.fluid_code.add_layer("prelu",
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "prelu", inputs=val_x, output=node, param_attr=attr)
 
     def Squeeze(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
         axes = node.get_attr('axes')
         attr = {'axes': axes, "name": string(node.layer_name)}
-        node.fluid_code.add_layer("squeeze",
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "squeeze", inputs=val_x, output=node, param_attr=attr)
 
     def Equal(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
         val_y = self.graph.get_input_node(node, idx=1, copy=True)
-        node.fluid_code.add_layer("equal",
+        node.fluid_code.add_layer(
+            "equal",
             inputs={
                 'x': val_x,
                 'y': val_y
@@ -1065,22 +1023,26 @@ class ONNXOpMapper(OpMapper):
         val_y = self.graph.get_input_node(node, idx=2, copy=True)
 
         not_condition = condition.layer_name + '_not'
-        node.fluid_code.add_layer("logical_not",
+        node.fluid_code.add_layer(
+            "logical_not",
             inputs=condition,
             output=not_condition,
             param_attr=None)
         cast_not_condition = not_condition + '_cast'
-        node.fluid_code.add_layer("cast",
+        node.fluid_code.add_layer(
+            "cast",
             inputs=not_condition,
             output=cast_not_condition,
             param_attr={'dtype': string(val_x.dtype)})
         cast_condition = condition.layer_name + '_cast'
-        node.fluid_code.add_layer("cast",
+        node.fluid_code.add_layer(
+            "cast",
             inputs=condition,
             output=cast_condition,
             param_attr={'dtype': string(val_x.dtype)})
         mul_val_x = val_x.layer_name + '_mul'
-        node.fluid_code.add_layer("elementwise_mul",
+        node.fluid_code.add_layer(
+            "elementwise_mul",
             inputs={
                 'x': val_x,
                 'y': cast_condition
@@ -1089,7 +1051,8 @@ class ONNXOpMapper(OpMapper):
             param_attr=None)
 
         mul_val_y = val_y.layer_name + '_mul'
-        node.fluid_code.add_layer("elementwise_mul",
+        node.fluid_code.add_layer(
+            "elementwise_mul",
             inputs={
                 'x': val_y,
                 'y': cast_not_condition
@@ -1097,7 +1060,8 @@ class ONNXOpMapper(OpMapper):
             output=mul_val_y,
             param_attr=None)
 
-        node.fluid_code.add_layer("elementwise_add",
+        node.fluid_code.add_layer(
+            "elementwise_add",
             inputs={
                 'x': mul_val_x,
                 'y': mul_val_y
@@ -1108,9 +1072,8 @@ class ONNXOpMapper(OpMapper):
     def NonZero(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
         where_name = node.layer_name + '_where'
-        node.fluid_code.add_layer("where",
-                                  inputs=val_x.layer_name + '!=0',
-                                  output=where_name)
+        node.fluid_code.add_layer(
+            "where", inputs=val_x.layer_name + '!=0', output=where_name)
         dims = len(val_x.out_shapes[0])
         elements_count_val_x = reduce(lambda x, y: x * y, val_x.out_shapes[0])
         flatten_names = []
@@ -1123,18 +1086,15 @@ class ONNXOpMapper(OpMapper):
                 'starts': [0, dim],
                 'ends': [elements_count_val_x, dim + 1]
             }
-            node.fluid_code.add_layer("slice",
-                                      inputs=where_name,
-                                      output=slice_name,
-                                      param_attr=attr)
-            node.fluid_code.add_layer("flatten",
+            node.fluid_code.add_layer(
+                "slice", inputs=where_name, output=slice_name, param_attr=attr)
+            node.fluid_code.add_layer(
+                "flatten",
                 inputs=slice_name,
                 output=flatten_name,
                 param_attr={'axis': 0})
-        node.fluid_code.add_layer("concat",
-                                  inputs=flatten_names,
-                                  output=node,
-                                  param_attr={'axis': 0})
+        node.fluid_code.add_layer(
+            "concat", inputs=flatten_names, output=node, param_attr={'axis': 0})
 
     def Identity(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
@@ -1153,10 +1113,8 @@ class ONNXOpMapper(OpMapper):
             'expand_times': repeats,
             "name": string(node.layer_name),
         }
-        node.fluid_code.add_layer("expand",
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "expand", inputs=val_x, output=node, param_attr=attr)
 
     def MaxPool(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
@@ -1193,10 +1151,8 @@ class ONNXOpMapper(OpMapper):
             "name": string(node.layer_name),
             "exclusive": False
         }
-        node.fluid_code.add_layer(fluid_op,
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            fluid_op, inputs=val_x, output=node, param_attr=attr)
 
     def _global_pool(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
@@ -1222,10 +1178,8 @@ class ONNXOpMapper(OpMapper):
             "global_pooling": True,
             "name": string(node.layer_name)
         }
-        node.fluid_code.add_layer(fluid_op,
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            fluid_op, inputs=val_x, output=node, param_attr=attr)
 
     def GlobalMaxPool(self, node):
         self._global_pool(node)
@@ -1281,10 +1235,8 @@ class ONNXOpMapper(OpMapper):
             attr["bias_attr"] = string(val_b.layer_name)
         else:
             attr["bias_attr"] = False
-        node.fluid_code.add_layer(fluid_op,
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            fluid_op, inputs=val_x, output=node, param_attr=attr)
 
     def ConvTranspose(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
@@ -1334,10 +1286,8 @@ class ONNXOpMapper(OpMapper):
             'bias_attr': None if val_b is None else string(val_b.layer_name),
             'name': string(node.layer_name),
         }
-        node.fluid_code.add_layer(fluid_op,
-                                  inputs=val_x,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            fluid_op, inputs=val_x, output=node, param_attr=attr)
 
     def GRU(self, node):
         val_x = self.graph.get_input_node(node, idx=0, copy=True)
@@ -1354,15 +1304,13 @@ class ONNXOpMapper(OpMapper):
         else:
             miss_arg_num += 1
         if num_ipt > 4 and node.layer.input[4] != '':
-            val_len = self.graph.get_input_node(node,
-                                                idx=4 - miss_arg_num,
-                                                copy=True)
+            val_len = self.graph.get_input_node(
+                node, idx=4 - miss_arg_num, copy=True)
         else:
             miss_arg_num += 1
         if num_ipt > 5 and node.layer.input[5] != '':
-            val_xh = self.graph.get_input_node(node,
-                                               idx=5 - miss_arg_num,
-                                               copy=True)
+            val_xh = self.graph.get_input_node(
+                node, idx=5 - miss_arg_num, copy=True)
 
         data, dtype, shape = self.get_dynamic_shape(val_x.layer_name)
 
@@ -1403,7 +1351,8 @@ class ONNXOpMapper(OpMapper):
         is_reverse = direction == 'reverse'
 
         var_x0 = node.layer_name + '_x0'
-        node.fluid_code.add_layer('squeeze',
+        node.fluid_code.add_layer(
+            'squeeze',
             inputs=val_x,
             output=var_x0,
             param_attr={
@@ -1412,7 +1361,8 @@ class ONNXOpMapper(OpMapper):
             })
 
         var_w0 = node.layer_name + '_w0'
-        node.fluid_code.add_layer('squeeze',
+        node.fluid_code.add_layer(
+            'squeeze',
             inputs=val_w,
             output=var_w0,
             param_attr={
@@ -1422,7 +1372,8 @@ class ONNXOpMapper(OpMapper):
 
         var_fc = node.layer_name + '_fc'
         var_mm = (node.layer_name + '_mm') if val_b else var_fc
-        node.fluid_code.add_layer('matmul',
+        node.fluid_code.add_layer(
+            'matmul',
             inputs={
                 'x': var_x0,
                 'y': var_w0
@@ -1435,7 +1386,8 @@ class ONNXOpMapper(OpMapper):
             })
 
         var_r0 = node.layer_name + '_r0'
-        node.fluid_code.add_layer('squeeze',
+        node.fluid_code.add_layer(
+            'squeeze',
             inputs=val_r,
             output=var_r0,
             param_attr={
@@ -1445,7 +1397,8 @@ class ONNXOpMapper(OpMapper):
 
         var_r0t = node.layer_name + '_r0t'
 
-        node.fluid_code.add_layer('transpose',
+        node.fluid_code.add_layer(
+            'transpose',
             inputs=var_r0,
             output=var_r0t,
             param_attr={
@@ -1455,19 +1408,18 @@ class ONNXOpMapper(OpMapper):
         if val_b:
             var_bi = node.layer_name + '_bi'
             var_bh = node.layer_name + '_bh'
-            node.fluid_code.add_layer('split',
+            node.fluid_code.add_layer(
+                'split',
                 inputs=val_b,
                 output=var_bi + ',' + var_bh,
                 param_attr={
-                                          'axis':
-                                          1,
-                                          'split':
-                                          [hidden_size * 3, hidden_size * 3],
-                                          'name':
-                                          string(node.layer_name + '.b/split')
+                    'axis': 1,
+                    'split': [hidden_size * 3, hidden_size * 3],
+                    'name': string(node.layer_name + '.b/split')
                 })
             var_bi0 = node.layer_name + '_bi0'
-            node.fluid_code.add_layer('squeeze',
+            node.fluid_code.add_layer(
+                'squeeze',
                 inputs=var_bi,
                 output=var_bi0,
                 param_attr={
@@ -1475,19 +1427,19 @@ class ONNXOpMapper(OpMapper):
                     'name': string(var_bi0)
                 })
 
-            node.fluid_code.add_layer('elmentwise_add',
+            node.fluid_code.add_layer(
+                'elmentwise_add',
                 inputs=[var_mm, var_bi0],
                 output=var_fc,
                 param_attr={
-                                          'axes':
-                                          1,
-                                          'name':
-                                          string(node.layer_name + '.i/bias')
+                    'axes': 1,
+                    'name': string(node.layer_name + '.i/bias')
                 })
 
         if val_xh:
             var_xh0 = node.layer_name + '_xh0'
-            node.fluid_code.add_layer('squeeze',
+            node.fluid_code.add_layer(
+                'squeeze',
                 inputs=val_xh,
                 output=var_xh0,
                 param_attr={
@@ -1505,7 +1457,8 @@ class ONNXOpMapper(OpMapper):
             'param_attr': string(var_r0t),
             'bias_attr': string(var_bh) if val_b else False,
         }
-        node.fluid_code.add_layer('dynamic_gru',
+        node.fluid_code.add_layer(
+            'dynamic_gru',
             inputs=var_fc + ',' + str(hidden_size),
             output=var_y00,
             param_attr=attr)
@@ -1513,7 +1466,8 @@ class ONNXOpMapper(OpMapper):
         num_opt = len(node.layer.output)
 
         if num_opt > 0 and node.layer.output[0] != '':
-            node.fluid_code.add_layer('unsqueeze',
+            node.fluid_code.add_layer(
+                'unsqueeze',
                 inputs=var_y00,
                 output=node.layer.output[0],
                 param_attr={
@@ -1521,7 +1475,8 @@ class ONNXOpMapper(OpMapper):
                     'name': string(node.layer.output[0])
                 })
         if num_opt > 1 and node.layer.output[1] != '':
-            node.fluid_code.add_layer('unsqueeze',
+            node.fluid_code.add_layer(
+                'unsqueeze',
                 inputs=var_y00,
                 output=node.layer.output[1],
                 param_attr={