Merge pull request #291 from PaddlePaddle/develop_code-format

code format

.pre-commit-config.yaml

--   repo: local
+-   repo: https://github.com/PaddlePaddle/mirrors-yapf.git
+    sha: 0d79c0c469bab64f7229c9aca2b1186ef47f0e37
     hooks:
     -   id: yapf
-        name: yapf
-        entry: yapf
-        language: system
-        args: [-i, --style .style.yapf]
         files: \.py$
-
 -   repo: https://github.com/pre-commit/pre-commit-hooks
     sha: a11d9314b22d8f8c7556443875b731ef05965464
     hooks:
@@ -18,6 +14,7 @@
     -   id: check-symlinks
     -   id: check-added-large-files
 -   repo: local
+
     hooks:
     -   id: copyright_checker
         name: copyright_checker

.travis.yml

 language: python
 
 python:
-  - '2.7'
   - '3.5'
-  - '3.6'
 
 script:
   - if [[ $TRAVIS_PYTHON_VERSION != 2.7 ]]; then /bin/bash ./tools/check_code_style.sh; fi

setup.py

@@ -11,8 +11,7 @@ setuptools.setup(
     version=x2paddle.__version__,
     author="dltp-sz",
     author_email="dltp-sz@baidu.com",
-    description=
-    "a toolkit for converting trained model to PaddlePaddle from other deep learning frameworks.",
+    description="a toolkit for converting trained model to PaddlePaddle from other deep learning frameworks.",
     long_description=long_description,
     long_description_content_type="text/plain",
     url="https://github.com/PaddlePaddle/x2paddle",
@@ -23,6 +22,4 @@ setuptools.setup(
         "Operating System :: OS Independent",
     ],
     license='Apache 2.0',
-    entry_points={'console_scripts': [
-        'x2paddle=x2paddle.convert:main',
-    ]})
+    entry_points={'console_scripts': ['x2paddle=x2paddle.convert:main', ]})

tools/merge_params.py

@@ -5,12 +5,14 @@ model_dir = sys.argv[1]
 new_model_dir = sys.argv[2]
 exe = fluid.Executor(fluid.CPUPlace())
 [inference_program, feed_target_names,
- fetch_targets] = fluid.io.load_inference_model(dirname=model_dir, executor=exe)
+ fetch_targets] = fluid.io.load_inference_model(
+     dirname=model_dir, executor=exe)
 
 print(feed_target_names)
-fluid.io.save_inference_model(dirname=new_model_dir,
-                              feeded_var_names=feed_target_names,
-                              target_vars=fetch_targets,
-                              executor=exe,
-                              main_program=inference_program,
-                              params_filename="__params__")
+fluid.io.save_inference_model(
+    dirname=new_model_dir,
+    feeded_var_names=feed_target_names,
+    target_vars=fetch_targets,
+    executor=exe,
+    main_program=inference_program,
+    params_filename="__params__")

x2paddle/convert.py

@@ -48,8 +48,7 @@ def arg_parser():
         "-f",
         type=_text_type,
         default=None,
-        help=
-        "define which deeplearning framework(tensorflow/caffe/onnx/paddle2onnx)"
+        help="define which deeplearning framework(tensorflow/caffe/onnx/paddle2onnx)"
     )
     parser.add_argument(
         "--caffe_proto",
@@ -126,7 +125,6 @@ def tf2paddle(model_path,
         optimizer.merge_bias()
         optimizer.optimize_sub_graph()
 
-
 #        optimizer.merge_batch_norm()
 #        optimizer.merge_prelu()
     else:

x2paddle/core/fluid_code.py

@@ -46,8 +46,9 @@ class Layer(object):
             for input in self.inputs:
                 if isinstance(input, GraphNode):
                     if hasattr(input, "index"):
-                        in_list += (input.layer_name +
-                                    "[{}]".format(input.index) + ", ")
+                        in_list += (
+                            input.layer_name + "[{}]".format(input.index) + ", "
+                        )
                     else:
                         in_list += (input.layer_name + ", ")
                 elif isinstance(input, six.string_types):
@@ -71,8 +72,8 @@ class Layer(object):
                     layer_code = layer_code + key + "={}, ".format(input)
         elif isinstance(self.inputs, GraphNode):
             if hasattr(self.inputs, "index"):
-                layer_code += (self.inputs.layer_name +
-                               "[{}]".format(self.inputs.index))
+                layer_code += (
+                    self.inputs.layer_name + "[{}]".format(self.inputs.index))
             else:
                 layer_code += (self.inputs.layer_name)
             if self.op != "=":

x2paddle/core/op_mapper.py

@@ -64,10 +64,8 @@ def run_net(param_dir="./"):
         b = os.path.exists(os.path.join(param_dir, var.name))
         return b
 
-    fluid.io.load_vars(exe,
-                       param_dir,
-                       fluid.default_main_program(),
-                       predicate=if_exist)
+    fluid.io.load_vars(
+        exe, param_dir, fluid.default_main_program(), predicate=if_exist)
 
 
 class OpMapper(object):
@@ -98,8 +96,8 @@ class OpMapper(object):
     def add_codes(self, codes, indent=0):
         if isinstance(codes, list):
             for code in codes:
-                self.paddle_codes += (self.tab * indent + code.strip('\n') +
-                                      '\n')
+                self.paddle_codes += (
+                    self.tab * indent + code.strip('\n') + '\n')
         elif isinstance(codes, str):
             self.paddle_codes += (self.tab * indent + codes.strip('\n') + '\n')
         else:
@@ -135,24 +133,25 @@ class OpMapper(object):
                     os.path.join(os.path.join(py_code_dir, var.name)))
                 return b
 
-            fluid.io.load_vars(exe,
-                               py_code_dir,
-                               fluid.default_main_program(),
-                               predicate=if_exist)
+            fluid.io.load_vars(
+                exe,
+                py_code_dir,
+                fluid.default_main_program(),
+                predicate=if_exist)
             if params_merge:
-                fluid.io.save_inference_model(dirname=os.path.join(
-                    save_dir, "inference_model"),
-                                              feeded_var_names=input_names,
-                                              target_vars=outputs,
-                                              executor=exe,
-                                              params_filename="__params__")
+                fluid.io.save_inference_model(
+                    dirname=os.path.join(save_dir, "inference_model"),
+                    feeded_var_names=input_names,
+                    target_vars=outputs,
+                    executor=exe,
+                    params_filename="__params__")
             else:
-                fluid.io.save_inference_model(dirname=os.path.join(
-                    save_dir, "inference_model"),
-                                              feeded_var_names=input_names,
-                                              target_vars=outputs,
-                                              executor=exe,
-                                              params_filename=None)
+                fluid.io.save_inference_model(
+                    dirname=os.path.join(save_dir, "inference_model"),
+                    feeded_var_names=input_names,
+                    target_vars=outputs,
+                    executor=exe,
+                    params_filename=None)
         except:
             raise Exception(
                 "Paddle code was saved in {}/model.py, but seems there's wrong exist, please check model.py manually."

x2paddle/decoder/caffe_decoder.py

@@ -49,13 +49,11 @@ class CaffeResolver(object):
 class CaffeGraphNode(GraphNode):
     def __init__(self, layer, type_str, layer_name=None):
         if layer_name is None:
-            super(CaffeGraphNode,
-                  self).__init__(layer,
-                                 layer.name.replace('/', '_').replace('-', '_'))
+            super(CaffeGraphNode, self).__init__(
+                layer, layer.name.replace('/', '_').replace('-', '_'))
         else:
-            super(CaffeGraphNode,
-                  self).__init__(layer,
-                                 layer_name.replace('/', '_').replace('-', '_'))
+            super(CaffeGraphNode, self).__init__(
+                layer, layer_name.replace('/', '_').replace('-', '_'))
         self.layer_type = type_str
         self.fluid_code = FluidCode()
         self.data = None
@@ -268,8 +266,8 @@ class CaffeDecoder(object):
                 c_i = blob.channels
                 h = blob.height
                 w = blob.width
-            data = np.asarray(list(blob.data),
-                              dtype=np.float32).reshape(c_o, c_i, h, w)
+            data = np.asarray(
+                list(blob.data), dtype=np.float32).reshape(c_o, c_i, h, w)
 
             transformed.append(data)
         return transformed

x2paddle/decoder/onnx_decoder.py

@@ -71,9 +71,8 @@ class ONNXGraphNode(GraphNode):
         if attr.type == onnx.AttributeProto.TENSOR:
             dtype = np.dtype(TENSOR_TYPE_TO_NP_TYPE[attr.t.data_type])
             data = attr.t.raw_data
-            value = np.frombuffer(data,
-                                  dtype=dtype,
-                                  count=(len(data) // dtype.itemsize))
+            value = np.frombuffer(
+                data, dtype=dtype, count=(len(data) // dtype.itemsize))
         elif attr.type == onnx.AttributeProto.STRING:
             value = attr.s
             value = value.decode() if isinstance(value, bytes) else value
@@ -205,9 +204,8 @@ class ONNXGraph(Graph):
                     self.node_map[name].weight = weight
                     self.node_map[name].embeded_as = []
             else:
-                self.node_map[name] = ONNXGraphDataNode(initializer,
-                                                        layer_name=name,
-                                                        is_global_input=False)
+                self.node_map[name] = ONNXGraphDataNode(
+                    initializer, layer_name=name, is_global_input=False)
                 self.node_map[name].weight = weight
                 self.node_map[name].embeded_as = []
 
@@ -494,8 +492,8 @@ class ONNXDecoder(object):
             sess = rt.InferenceSession(model_path)
             for ipt in sess.get_inputs():
                 datatype = datatype_map[ipt.type]
-                input_dict[ipt.name] = np.random.random(
-                    ipt.shape).astype(datatype)
+                input_dict[ipt.name] = np.random.random(ipt.shape).astype(
+                    datatype)
 
             res = sess.run(None, input_feed=input_dict)
         except:

x2paddle/decoder/tf_decoder.py

@@ -120,13 +120,13 @@ class TFGraph(Graph):
     def build(self):
         for layer in self.model.node:
             self.node_map[layer.name.replace('/', '_').replace(
-                '-', '_')] = TFGraphNode(layer, data_format=self.tf_data_format)
+                '-', '_')] = TFGraphNode(
+                    layer, data_format=self.tf_data_format)
 
         for layer_name, node in self.node_map.items():
             for in_node in node.layer.input:
-                in_node = in_node.replace('/',
-                                          '_').replace('-',
-                                                       '_').replace('^', '')
+                in_node = in_node.replace('/', '_').replace('-', '_').replace(
+                    '^', '')
                 if in_node not in self.node_map:
                     if in_node.strip().split(':')[0] in self.node_map:
                         self.connect(in_node.strip().split(':')[0], layer_name)
@@ -390,10 +390,10 @@ class TFDecoder(object):
                         shape=shape,
                         name="x2paddle_{}".format(layer.name))
                 except:
-                    x2paddle_input = tf.placeholder(dtype=dtype,
-                                                    shape=shape,
-                                                    name="x2paddle_{}".format(
-                                                        layer.name))
+                    x2paddle_input = tf.placeholder(
+                        dtype=dtype,
+                        shape=shape,
+                        name="x2paddle_{}".format(layer.name))
 
                 input_map["{}:0".format(layer.name)] = x2paddle_input
                 if shape.count(None) > 0:

x2paddle/op_mapper/caffe_custom_layer/convolutiondepthwise.py

@@ -122,16 +122,17 @@ def convolutiondepthwise_layer(inputs,
     c_out = num_output if num_output is not None else input_shape[0][1]
     group = int(c_in / (c_in / c_out)) if c_in > c_out else int(c_in /
                                                                 (c_out / c_in))
-    out = fluid.layers.conv2d(input,
-                              dilation=[dila_h, dila_w],
-                              filter_size=[k_h, k_w],
-                              stride=[s_h, s_w],
-                              padding=[p_h, p_w],
-                              groups=group,
-                              num_filters=c_out,
-                              param_attr=name + '_weights',
-                              bias_attr=name + '_bias',
-                              name=name)
+    out = fluid.layers.conv2d(
+        input,
+        dilation=[dila_h, dila_w],
+        filter_size=[k_h, k_w],
+        stride=[s_h, s_w],
+        padding=[p_h, p_w],
+        groups=group,
+        num_filters=c_out,
+        param_attr=name + '_weights',
+        bias_attr=name + '_bias',
+        name=name)
     return out
 
 
@@ -142,7 +143,8 @@ def convolutiondepthwise_weights(name, data=None):
     return weights_name
 
 
-register(kind='ConvolutionDepthwise',
-         shape=convolutiondepthwise_shape,
-         layer=convolutiondepthwise_layer,
-         weights=convolutiondepthwise_weights)
+register(
+    kind='ConvolutionDepthwise',
+    shape=convolutiondepthwise_shape,
+    layer=convolutiondepthwise_layer,
+    weights=convolutiondepthwise_weights)

x2paddle/op_mapper/caffe_custom_layer/detectionoutput.py

@@ -37,8 +37,8 @@ def detectionoutput_layer(inputs,
     pbv = fluid.layers.reshape(x=pbv, shape=[-1, 4])
     mbox_loc = inputs[0]
     mbox_loc = fluid.layers.reshape(x=mbox_loc, shape=[-1, pb.shape[0], 4])
-    mbox_conf_flatten = fluid.layers.reshape(x=mbox_conf_flatten,
-                                             shape=[0, pb.shape[0], -1])
+    mbox_conf_flatten = fluid.layers.reshape(
+        x=mbox_conf_flatten, shape=[0, pb.shape[0], -1])
 
     default = {"nms_threshold": 0.3, "top_k": 10, "eta": 1.0}
     fields = ['eta', 'top_k', 'nms_threshold']
@@ -64,7 +64,8 @@ def detectionoutput_weights(name, data=None):
     return weights_name
 
 
-register(kind='DetectionOutput',
-         shape=detectionoutput_shape,
-         layer=detectionoutput_layer,
-         weights=detectionoutput_weights)
+register(
+    kind='DetectionOutput',
+    shape=detectionoutput_shape,
+    layer=detectionoutput_layer,
+    weights=detectionoutput_weights)

x2paddle/op_mapper/caffe_custom_layer/normalize.py

@@ -20,9 +20,8 @@ def normalize_layer(inputs,
         attr=name + '_scale')
     scale_param = fluid.layers.reshape(x=scale_param, \
                   shape=[1] if channel_shared else [input_shape[0][1]])
-    out = fluid.layers.elementwise_mul(x=l2_norm,
-                                       y=scale_param,
-                                       axis=-1 if channel_shared else 1)
+    out = fluid.layers.elementwise_mul(
+        x=l2_norm, y=scale_param, axis=-1 if channel_shared else 1)
     return out
 
 
@@ -31,7 +30,8 @@ def normalize_weights(name, data=None):
     return weights_name
 
 
-register(kind='Normalize',
-         shape=normalize_shape,
-         layer=normalize_layer,
-         weights=normalize_weights)
+register(
+    kind='Normalize',
+    shape=normalize_shape,
+    layer=normalize_layer,
+    weights=normalize_weights)

x2paddle/op_mapper/caffe_custom_layer/permute.py

@@ -23,7 +23,8 @@ def permute_weights(name, data=None):
     return weights_name
 
 
-register(kind='Permute',
-         shape=permute_shape,
-         layer=permute_layer,
-         weights=permute_weights)
+register(
+    kind='Permute',
+    shape=permute_shape,
+    layer=permute_layer,
+    weights=permute_weights)

x2paddle/op_mapper/caffe_custom_layer/priorbox.py

@@ -30,18 +30,19 @@ def priorbox_layer(inputs,
     steps = tuple(step) if type(step) is list or type(step) is tuple else (step,
                                                                            step)
 
-    box, variance_ = fluid.layers.prior_box(input,
-                                            image,
-                                            min_sizes=min_size,
-                                            max_sizes=max_size,
-                                            aspect_ratios=aspect_ratio,
-                                            variance=variance,
-                                            flip=flip,
-                                            clip=clip,
-                                            steps=steps,
-                                            offset=offset,
-                                            name=name,
-                                            min_max_aspect_ratios_order=True)
+    box, variance_ = fluid.layers.prior_box(
+        input,
+        image,
+        min_sizes=min_size,
+        max_sizes=max_size,
+        aspect_ratios=aspect_ratio,
+        variance=variance,
+        flip=flip,
+        clip=clip,
+        steps=steps,
+        offset=offset,
+        name=name,
+        min_max_aspect_ratios_order=True)
     box = fluid.layers.reshape(box, [1, 1, -1])
     variance_ = fluid.layers.reshape(variance_, [1, 1, -1])
     out = fluid.layers.concat([box, variance_], axis=1)
@@ -53,7 +54,8 @@ def priorbox_weights(name, data=None):
     return weights_name
 
 
-register(kind='PriorBox',
-         shape=priorbox_shape,
-         layer=priorbox_layer,
-         weights=priorbox_weights)
+register(
+    kind='PriorBox',
+    shape=priorbox_shape,
+    layer=priorbox_layer,
+    weights=priorbox_weights)

x2paddle/op_mapper/caffe_custom_layer/register.py

@@ -23,8 +23,7 @@ def register(kind, shape, layer, weights):
         kind = [kind]
     else:
         assert type(
-            kind
-        ) is list, 'invalid param "kind" for register, not a list or str'
+            kind) is list, 'invalid param "kind" for register, not a list or str'
 
     for k in kind:
         assert type(

x2paddle/op_mapper/caffe_custom_layer/roipooling.py

@@ -21,11 +21,12 @@ def roipooling_layer(inputs,
     input = inputs[0]
     roi = inputs[1]
     roi = fluid.layers.slice(roi, axes=[1], starts=[1], ends=[5])
-    out = fluid.layers.roi_pool(input,
-                                roi,
-                                pooled_height=pooled_h,
-                                pooled_width=pooled_w,
-                                spatial_scale=spatial_scale)
+    out = fluid.layers.roi_pool(
+        input,
+        roi,
+        pooled_height=pooled_h,
+        pooled_width=pooled_w,
+        spatial_scale=spatial_scale)
     return out
 
 
@@ -34,7 +35,8 @@ def roipooling_weights(name, data=None):
     return weights_name
 
 
-register(kind='ROIPooling',
-         shape=roipooling_shape,
-         layer=roipooling_layer,
-         weights=roipooling_weights)
+register(
+    kind='ROIPooling',
+    shape=roipooling_shape,
+    layer=roipooling_layer,
+    weights=roipooling_weights)

x2paddle/op_mapper/caffe_custom_layer/select.py

@@ -30,11 +30,12 @@ def select_layer(inputs,
     out = []
     for i in range(len(slice_point)):
         out.append(
-            fluid.layers.slice(input,
-                               axes=[axis],
-                               starts=[slice_point[i]],
-                               ends=[slice_point[i + 1]],
-                               name=name + '_' + str(i)))
+            fluid.layers.slice(
+                input,
+                axes=[axis],
+                starts=[slice_point[i]],
+                ends=[slice_point[i + 1]],
+                name=name + '_' + str(i)))
         if i == len(slice_point) - 2:
             break
     return out
@@ -45,7 +46,8 @@ def select_weights(name, data=None):
     return weights_name
 
 
-register(kind='Select',
-         shape=select_shape,
-         layer=select_layer,
-         weights=select_weights)
+register(
+    kind='Select',
+    shape=select_shape,
+    layer=select_layer,
+    weights=select_weights)

x2paddle/op_mapper/caffe_custom_layer/shufflechannel.py

@@ -17,7 +17,8 @@ def shufflechannel_weights(name, data=None):
     return weights_name
 
 
-register(kind='ShuffleChannel',
-         shape=shufflechannel_shape,
-         layer=shufflechannel_layer,
-         weights=shufflechannel_weights)
+register(
+    kind='ShuffleChannel',
+    shape=shufflechannel_shape,
+    layer=shufflechannel_layer,
+    weights=shufflechannel_weights)

x2paddle/op_mapper/caffe_op_mapper.py

@@ -144,8 +144,8 @@ class CaffeOpMapper(OpMapper):
             [s_h, s_w] = [params.stride] * 2
         elif len(params.stride) > 0:
             s_h = params.stride_h if params.stride_h > 0 else params.stride[0]
-            s_w = params.stride_w if params.stride_w > 0 else params.stride[
-                len(params.stride) - 1]
+            s_w = params.stride_w if params.stride_w > 0 else params.stride[len(
+                params.stride) - 1]
         elif params.stride_h > 0 or params.stride_w > 0:
             s_h = params.stride_h
             s_w = params.stride_w
@@ -154,8 +154,8 @@ class CaffeOpMapper(OpMapper):
             [p_h, p_w] = [params.pad] * 2
         elif len(params.pad) > 0:
             p_h = params.pad_h if params.pad_h > 0 else params.pad[0]
-            p_w = params.pad_w if params.pad_w > 0 else params.pad[
-                len(params.pad) - 1]
+            p_w = params.pad_w if params.pad_w > 0 else params.pad[len(
+                params.pad) - 1]
         elif params.pad_h > 0 or params.pad_w > 0:
             p_h = params.pad_h
             p_w = params.pad_w
@@ -195,10 +195,8 @@ class CaffeOpMapper(OpMapper):
             'shape': shape,
             'name': string(node.layer_name)
         }
-        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 MemoryData(self, node):
         # TODO(syf): Paddlepaddle can't fully support
@@ -209,10 +207,8 @@ class CaffeOpMapper(OpMapper):
             'shape': shape,
             'name': string(node.layer_name)
         }
-        node.fluid_code.add_layer("data",
-                                  inputs=None,
-                                  output=node.layer_name + '0',
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "data", inputs=None, output=node.layer_name + '0', param_attr=attr)
         node.fluid_code.add_note('{} = [{}]'.format(node.layer_name,
                                                     node.layer_name + '0'))
 
@@ -229,11 +225,9 @@ class CaffeOpMapper(OpMapper):
             input_c = node.input_shape[0][1]
             output_c = channel
             data.append(
-                np.zeros([output_c, input_c, kernel[0],
-                          kernel[1]]).astype('float32'))
-            data.append(np.zeros([
-                output_c,
-            ])).astype('float32')
+                np.zeros([output_c, input_c, kernel[0], kernel[1]]).astype(
+                    'float32'))
+            data.append(np.zeros([output_c, ])).astype('float32')
         else:
             data = self.adjust_parameters(node)
         self.weights[node.layer_name + '_weights'] = data[0]
@@ -244,29 +238,19 @@ class CaffeOpMapper(OpMapper):
         input = self.graph.get_bottom_node(node, idx=0, copy=True)
 
         attr = {
-            'filter_size':
-            kernel,
-            'num_filters':
-            channel,
-            'stride':
-            stride,
-            'padding':
-            pad,
-            'dilation':
-            dilation,
-            'groups':
-            group,
-            'name':
-            string(node.layer_name),
-            'param_attr':
-            string(node.layer_name + '_weights'),
-            'bias_attr':
-            False if len(data) == 1 else string(node.layer_name + '_bias'),
+            'filter_size': kernel,
+            'num_filters': channel,
+            'stride': stride,
+            'padding': pad,
+            'dilation': dilation,
+            'groups': group,
+            'name': string(node.layer_name),
+            'param_attr': string(node.layer_name + '_weights'),
+            'bias_attr': False
+            if len(data) == 1 else string(node.layer_name + '_bias'),
         }
-        node.fluid_code.add_layer("conv2d",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "conv2d", inputs=input, output=node, param_attr=attr)
 
     def Deconvolution(self, node):
         data = node.data
@@ -281,11 +265,9 @@ class CaffeOpMapper(OpMapper):
             input_c = node.input_shape[0][1]
             output_c = channel
             data.append(
-                np.zeros([output_c, input_c, kernel[0],
-                          kernel[1]]).astype('float32'))
-            data.append(np.zeros([
-                output_c,
-            ]).astype('float32'))
+                np.zeros([output_c, input_c, kernel[0], kernel[1]]).astype(
+                    'float32'))
+            data.append(np.zeros([output_c, ]).astype('float32'))
         else:
             data = self.adjust_parameters(node)
         self.weights[node.layer_name + '_weights'] = data[0]
@@ -295,31 +277,20 @@ class CaffeOpMapper(OpMapper):
                    ) == 1, 'The count of Deconvolution node\'s input is not 1.'
         input = self.graph.get_bottom_node(node, idx=0, copy=True)
         attr = {
-            'output_size':
-            None,
-            'filter_size':
-            kernel,
-            'num_filters':
-            channel,
-            'stride':
-            stride,
-            'padding':
-            pad,
-            'dilation':
-            dilation,
-            'groups':
-            group,
-            'name':
-            string(node.layer_name),
-            'param_attr':
-            string(node.layer_name + '_weights'),
-            'bias_attr':
-            False if len(data) == 1 else string(node.layer_name + '_bias')
+            'output_size': None,
+            'filter_size': kernel,
+            'num_filters': channel,
+            'stride': stride,
+            'padding': pad,
+            'dilation': dilation,
+            'groups': group,
+            'name': string(node.layer_name),
+            'param_attr': string(node.layer_name + '_weights'),
+            'bias_attr': False
+            if len(data) == 1 else string(node.layer_name + '_bias')
         }
-        node.fluid_code.add_layer("conv2d_transpose",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "conv2d_transpose", inputs=input, output=node, param_attr=attr)
 
     def Pooling(self, node):
         params = node.layer.pooling_param
@@ -345,10 +316,8 @@ class CaffeOpMapper(OpMapper):
             'global_pooling': global_pool,
             'name': string(node.layer_name)
         }
-        node.fluid_code.add_layer("pool2d",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "pool2d", inputs=input, output=node, param_attr=attr)
 
     def LRN(self, node):
         assert len(node.inputs) == 1, 'The count of LRN node\'s input is not 1.'
@@ -368,10 +337,8 @@ class CaffeOpMapper(OpMapper):
             'beta': params.beta,
             'name': string(node.layer_name)
         }
-        node.fluid_code.add_layer("lrn",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "lrn", inputs=input, output=node, param_attr=attr)
 
     def InnerProduct(self, node):
         data = node.data
@@ -384,8 +351,8 @@ class CaffeOpMapper(OpMapper):
             output_c = params.num_output
             data = []
             data.append(
-                np.zeros([input_c,
-                          output_c]).astype('float32').astype('float32'))
+                np.zeros([input_c, output_c]).astype('float32').astype(
+                    'float32'))
             data.append(
                 np.zeros([output_c]).astype('float32').astype('float32'))
         else:
@@ -409,21 +376,15 @@ class CaffeOpMapper(OpMapper):
         assert params.bias_term == True
         input = self.graph.get_bottom_node(node, idx=0, copy=True)
         attr = {
-            'size':
-            params.num_output,
-            'name':
-            string(node.layer_name),
-            'act':
-            None,
-            'param_attr':
-            string(node.layer_name + '_weights'),
-            'bias_attr':
-            False if len(data) == 1 else string(node.layer_name + '_bias')
+            'size': params.num_output,
+            'name': string(node.layer_name),
+            'act': None,
+            'param_attr': string(node.layer_name + '_weights'),
+            'bias_attr': False
+            if len(data) == 1 else string(node.layer_name + '_bias')
         }
-        node.fluid_code.add_layer("fc",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "fc", inputs=input, output=node, param_attr=attr)
 
     def Softmax(self, node):
         assert len(
@@ -435,10 +396,8 @@ class CaffeOpMapper(OpMapper):
         dims = len(shape)
         axis = axis + dims if axis < 0 else axis
         attr = {'axis': axis, 'name': string(node.layer_name + '_softmax')}
-        node.fluid_code.add_layer("softmax",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "softmax", inputs=input, output=node, param_attr=attr)
 
     def Slice(self, node):
         assert len(
@@ -459,10 +418,8 @@ class CaffeOpMapper(OpMapper):
             'dim': axis,
             'name': string(node.layer_name)
         }
-        node.fluid_code.add_layer("split",
-                                  inputs=input,
-                                  output=node.layer_name,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "split", inputs=input, output=node.layer_name, param_attr=attr)
 
     def Concat(self, node):
         assert len(
@@ -475,10 +432,8 @@ class CaffeOpMapper(OpMapper):
         params = node.layer.concat_param
         axis = params.axis
         attr = {'axis': axis, 'name': string(node.layer_name)}
-        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 PReLU(self, node):
         assert len(
@@ -499,10 +454,8 @@ class CaffeOpMapper(OpMapper):
             'param_attr': string(node.layer_name + '_weights'),
             'name': string(node.layer_name)
         }
-        node.fluid_code.add_layer("prelu",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "prelu", inputs=input, output=node, param_attr=attr)
 
     def Accuracy(self, node):
         assert len(
@@ -526,10 +479,8 @@ class CaffeOpMapper(OpMapper):
         assert axis == 1, 'PaddlePaddle can not support the situation when the axis is not 1.'
         assert not ignore_label >= 0, 'PaddlePaddle can not support the situation when the model has ignore label.'
         attr = {'k': top_k}
-        node.fluid_code.add_layer("accuracy",
-                                  inputs=inputs,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "accuracy", inputs=inputs, output=node, param_attr=attr)
 
     def Eltwise(self, node):
         assert len(
@@ -546,10 +497,11 @@ class CaffeOpMapper(OpMapper):
             inputs_dict['x'] = inputs[0]
             inputs_dict['y'] = inputs[1]
             attr = {'act': None, 'name': string(node.layer_name)}
-            node.fluid_code.add_layer("elementwise_mul",
-                                      inputs=inputs_dict,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "elementwise_mul",
+                inputs=inputs_dict,
+                output=node,
+                param_attr=attr)
         elif mode == 1:
             if hasattr(params, 'coeff') and len(params.coeff) == 2:
                 coeff = params.coeff
@@ -559,57 +511,62 @@ class CaffeOpMapper(OpMapper):
                     'value': coeff[0],
                     'dtype': '{}.dtype'.format(input1_name)
                 }
-                node.fluid_code.add_layer("fill_constant",
-                                          inputs=None,
-                                          output=node.layer_name + '_const1',
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "fill_constant",
+                    inputs=None,
+                    output=node.layer_name + '_const1',
+                    param_attr=attr)
                 attr = {'act': None, 'name': string(node.layer_name + '_mul1')}
-                node.fluid_code.add_layer("elementwise_mul",
-                                          inputs=input1_name + ', ' +
-                                          node.layer_name + '_const1',
-                                          output=node.layer_name + '_mul1',
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "elementwise_mul",
+                    inputs=input1_name + ', ' + node.layer_name + '_const1',
+                    output=node.layer_name + '_mul1',
+                    param_attr=attr)
                 input2_name = self.get_input_name(inputs[1])
                 attr = {
                     'shape': [1],
                     'value': coeff[1],
                     'dtype': '{}.dtype'.format(input2_name)
                 }
-                node.fluid_code.add_layer("fill_constant",
-                                          inputs=None,
-                                          output=node.layer_name + '_const2',
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "fill_constant",
+                    inputs=None,
+                    output=node.layer_name + '_const2',
+                    param_attr=attr)
                 attr = {'act': None, 'name': string(node.layer_name + '_mul2')}
-                node.fluid_code.add_layer("elementwise_mul",
-                                          inputs=input2_name + ', ' +
-                                          node.layer_name + '_const2',
-                                          output=node.layer_name + '_mul2',
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "elementwise_mul",
+                    inputs=input2_name + ', ' + node.layer_name + '_const2',
+                    output=node.layer_name + '_mul2',
+                    param_attr=attr)
 
                 attr = {'act': None, 'name': string(node.layer_name)}
-                node.fluid_code.add_layer("elementwise_add",
-                                          inputs='{}_mul1, {}_mul2'.format(
-                                              node.layer_name, node.layer_name),
-                                          output=node,
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "elementwise_add",
+                    inputs='{}_mul1, {}_mul2'.format(node.layer_name,
+                                                     node.layer_name),
+                    output=node,
+                    param_attr=attr)
             else:
                 inputs_dict = {}
                 inputs_dict['x'] = inputs[0]
                 inputs_dict['y'] = inputs[1]
                 attr = {'act': None, 'name': string(node.layer_name)}
-                node.fluid_code.add_layer("elementwise_add",
-                                          inputs=inputs_dict,
-                                          output=node,
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "elementwise_add",
+                    inputs=inputs_dict,
+                    output=node,
+                    param_attr=attr)
         else:
             inputs_dict = {}
             inputs_dict['x'] = inputs[0]
             inputs_dict['y'] = inputs[1]
             attr = {'act': None, 'name': string(node.layer_name)}
-            node.fluid_code.add_layer("elementwise_max",
-                                      inputs=inputs_dict,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "elementwise_max",
+                inputs=inputs_dict,
+                output=node,
+                param_attr=attr)
 
     def BatchNorm(self, node):
         assert len(
@@ -625,12 +582,8 @@ class CaffeOpMapper(OpMapper):
                 'The parameter of {} (type is {}) is not set. So we set the parameters as 0'
                 .format(node.layer_name, node.layer_type))
             input_c = node.input_shape[0][1]
-            mean = np.zeros([
-                input_c,
-            ]).astype('float32')
-            variance = np.zeros([
-                input_c,
-            ]).astype('float32')
+            mean = np.zeros([input_c, ]).astype('float32')
+            variance = np.zeros([input_c, ]).astype('float32')
             scale = 0
         else:
 
@@ -651,10 +604,8 @@ class CaffeOpMapper(OpMapper):
             'epsilon': eps,
             'name': string(node.layer_name)
         }
-        node.fluid_code.add_layer("batch_norm",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "batch_norm", inputs=input, output=node, param_attr=attr)
 
     def Scale(self, node):
         if node.data is None:
@@ -669,10 +620,10 @@ class CaffeOpMapper(OpMapper):
                 input_c,
             ]).astype('float32')
         else:
-            self.weights[node.layer_name + '_scale'] = np.squeeze(
-                node.data[0]).astype('float32')
-            self.weights[node.layer_name + '_offset'] = np.squeeze(
-                node.data[1]).astype('float32')
+            self.weights[node.layer_name + '_scale'] = np.squeeze(node.data[
+                0]).astype('float32')
+            self.weights[node.layer_name + '_offset'] = np.squeeze(node.data[
+                1]).astype('float32')
         params = node.layer.scale_param
         axis = params.axis
         num_axes = params.num_axes
@@ -687,10 +638,11 @@ class CaffeOpMapper(OpMapper):
             inputs_dict['x'] = input0
             inputs_dict['y'] = input1
             attr = {'axis': axis, 'name': string(node.layer_name + '_mul')}
-            node.fluid_code.add_layer("elementwise_mul",
-                                      inputs=inputs_dict,
-                                      output=node.layer_name + '_mul',
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "elementwise_mul",
+                inputs=inputs_dict,
+                output=node.layer_name + '_mul',
+                param_attr=attr)
         else:
             bias_shape = node.input_shape[0][axis:axis + num_axes]
             input0 = self.graph.get_bottom_node(node, idx=0, copy=True)
@@ -703,18 +655,17 @@ class CaffeOpMapper(OpMapper):
                 'is_bias': True,
                 'default_initializer': 'Constant(value=1.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)
             inputs_dict = {}
             inputs_dict['x'] = input0
             inputs_dict['y'] = node
             attr = {'axis': axis, 'name': string(node.layer_name + '_mul')}
-            node.fluid_code.add_layer("elementwise_mul",
-                                      inputs=inputs_dict,
-                                      output=node.layer_name + '_mul',
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "elementwise_mul",
+                inputs=inputs_dict,
+                output=node.layer_name + '_mul',
+                param_attr=attr)
         scale_shape = bias_shape
         input0_name = self.get_input_name(input0)
         attr = {
@@ -725,16 +676,18 @@ class CaffeOpMapper(OpMapper):
             'is_bias': True,
             'default_initializer': 'Constant(value=1.0)'
         }
-        node.fluid_code.add_layer("create_parameter",
-                                  inputs=None,
-                                  output=node.layer_name + '_offset_param',
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "create_parameter",
+            inputs=None,
+            output=node.layer_name + '_offset_param',
+            param_attr=attr)
         attr = {'axis': axis, 'name': string(node.layer_name + '_add')}
-        node.fluid_code.add_layer("elementwise_add",
-                                  inputs='{}_mul, {}_offset_param'.format(
-                                      node.layer_name, node.layer_name),
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "elementwise_add",
+            inputs='{}_mul, {}_offset_param'.format(node.layer_name,
+                                                    node.layer_name),
+            output=node,
+            param_attr=attr)
 
     def Reshape(self, node):
         input = self.graph.get_bottom_node(node, idx=0, copy=True)
@@ -747,10 +700,8 @@ class CaffeOpMapper(OpMapper):
             'act': None,
             'name': string(node.layer_name)
         }
-        node.fluid_code.add_layer("reshape",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "reshape", inputs=input, output=node, param_attr=attr)
 
     def ArgMax(self, node):
         assert len(node.inputs) == 1 and len(
@@ -767,11 +718,12 @@ class CaffeOpMapper(OpMapper):
             axis += len(input_shape)
         if out_max_val is True:
             attr = {'k': top_k, 'name': string(node.layer_name + '_topk')}
-            node.fluid_code.add_layer("topk",
-                                      inputs=input,
-                                      output='{}_topk_var, {}_index_var'.format(
-                                          node.layer_name, node.layer_name),
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "topk",
+                inputs=input,
+                output='{}_topk_var, {}_index_var'.format(node.layer_name,
+                                                          node.layer_name),
+                param_attr=attr)
             attr = {'dtype': '{}_topk_var.dtype'.format(node.layer_name)}
             node.fluid_code.add_layer(
                 "cast",
@@ -779,17 +731,19 @@ class CaffeOpMapper(OpMapper):
                 output='{}_index_var'.format(node.layer_name),
                 param_attr=attr)
             attr = {'axis': axis, 'name': string(node.layer_name)}
-            node.fluid_code.add_layer("concat",
-                                      inputs='{}_topk_var, {}_index_var'.format(
-                                          node.layer_name, node.layer_name),
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "concat",
+                inputs='{}_topk_var, {}_index_var'.format(node.layer_name,
+                                                          node.layer_name),
+                output=node,
+                param_attr=attr)
         else:
             attr = {'k': top_k, 'name': string(node.layer_name)}
-            node.fluid_code.add_layer("topk",
-                                      inputs=input,
-                                      output='_, {}'.format(node.layer_name),
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "topk",
+                inputs=input,
+                output='_, {}'.format(node.layer_name),
+                param_attr=attr)
 
     def Crop(self, node):
         assert len(
@@ -804,29 +758,27 @@ class CaffeOpMapper(OpMapper):
         offset_real = [0] * len(input_shape)
         if hasattr(params, "offset") and len(params.offset) > 0:
             offset = list(params.offset)
-            assert (len(input_shape) - axis) == len(
-                offset), "invalid offset[%s] in crop layer" % (str(offset))
+            assert (len(input_shape) - axis
+                    ) == len(offset), "invalid offset[%s] in crop layer" % (
+                        str(offset))
             offset_real = [0] * axis + offset
         attr = {'offsets': list(offset_real), 'name': string(node.layer_name)}
-        node.fluid_code.add_layer("crop",
-                                  inputs={
-                                      'x': input,
-                                      'shape': node.input_shape[1]
-                                  },
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "crop",
+            inputs={'x': input,
+                    'shape': node.input_shape[1]},
+            output=node,
+            param_attr=attr)
 
     def Flatten(self, node):
         assert len(
-            node.inputs
-        ) == 1, 'The count of DetectionOutput node\'s input is not 1.'
+            node.
+            inputs) == 1, 'The count of DetectionOutput node\'s input is not 1.'
         input = self.graph.get_bottom_node(node, idx=0, copy=True)
         shape = node.output_shape[0]
         attr = {'shape': shape, 'name': string(node.layer_name)}
-        node.fluid_code.add_layer("reshape",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "reshape", inputs=input, output=node, param_attr=attr)
 
     def Power(self, node):
         assert len(
@@ -842,15 +794,11 @@ class CaffeOpMapper(OpMapper):
             'bias_after_scale': True,
             'name': string(node.layer_name + '_scale')
         }
-        node.fluid_code.add_layer("scale",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "scale", inputs=input, output=node, param_attr=attr)
         attr = {'factor': power, 'name': string(node.layer_name)}
-        node.fluid_code.add_layer("pow",
-                                  inputs=node,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "pow", inputs=node, output=node, param_attr=attr)
 
     def Reduction(self, node):
         assert len(
@@ -872,55 +820,41 @@ class CaffeOpMapper(OpMapper):
                 'keep_dim': False,
                 'name': string(node.layer_name)
             }
-            node.fluid_code.add_layer("reduce_sum",
-                                      inputs=input,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "reduce_sum", inputs=input, output=node, param_attr=attr)
         elif operation == 2:  ## operation = ASUM
             attr = {'name': string(node.layer_name + '_abs')}
-            node.fluid_code.add_layer("abs",
-                                      inputs=input,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "abs", inputs=input, output=node, param_attr=attr)
             attr = {
                 'dim': dim[axis:],
                 'keep_dim': False,
                 'name': string(node.layer_name)
             }
-            node.fluid_code.add_layer("reduce_sum",
-                                      inputs=node,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "reduce_sum", inputs=node, output=node, param_attr=attr)
         elif operation == 3:  ## operation = SUMSQ
             attr = {'factor': 2.0, 'name': string(node.layer_name + '_pow')}
-            node.fluid_code.add_layer("pow",
-                                      inputs=input,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "pow", inputs=input, output=node, param_attr=attr)
             attr = {
                 'dim': dim[axis:],
                 'keep_dim': False,
                 'name': string(node.layer_name)
             }
-            node.fluid_code.add_layer("reduce_sum",
-                                      inputs=node,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "reduce_sum", inputs=node, output=node, param_attr=attr)
         else:  ## operation = MEAN
             attr = {
                 'dim': dim[axis:],
                 'keep_dim': False,
                 'name': string(node.layer_name)
             }
-            node.fluid_code.add_layer("reduce_mean",
-                                      inputs=node,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "reduce_mean", inputs=node, output=node, param_attr=attr)
         attr = {'scale': coeff}
-        node.fluid_code.add_layer("scale",
-                                  inputs=node,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "scale", inputs=node, output=node, param_attr=attr)
 
     def deal_custom_layer(self, node):
         op = node.layer_type
@@ -947,11 +881,12 @@ class CaffeOpMapper(OpMapper):
                 assert input is not None, 'This kind of DetectionOutput is not supported!'
                 input = self.graph.get_bottom_node(input, idx=0, copy=True)
             inputs_node.append(input)
-        node.fluid_code.add_layer(func.__code__.co_name,
-                                  inputs=inputs_node,
-                                  output=node,
-                                  param_attr=kwargs,
-                                  is_custom_layer=True)
+        node.fluid_code.add_layer(
+            func.__code__.co_name,
+            inputs=inputs_node,
+            output=node,
+            param_attr=kwargs,
+            is_custom_layer=True)
         if op not in self.used_custom_layers:
             self.used_custom_layers[op] = custom_code
 
@@ -960,7 +895,5 @@ class CaffeOpMapper(OpMapper):
         op_info = self.directly_map_ops[node.layer_type]
         input = self.graph.get_bottom_node(node, idx=0, copy=True)
         attr = {'name': string(node.layer_name)}
-        node.fluid_code.add_layer(op_info,
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            op_info, inputs=input, output=node, param_attr=attr)

x2paddle/op_mapper/caffe_shape.py

@@ -33,8 +33,8 @@ def get_kernel_parameters(params):
         [s_h, s_w] = [params.stride] * 2
     elif len(params.stride) > 0:
         s_h = params.stride_h if params.stride_h > 0 else params.stride[0]
-        s_w = params.stride_w if params.stride_w > 0 else params.stride[
-            len(params.stride) - 1]
+        s_w = params.stride_w if params.stride_w > 0 else params.stride[len(
+            params.stride) - 1]
     elif params.stride_h > 0 or params.stride_w > 0:
         s_h = params.stride_h
         s_w = params.stride_w

x2paddle/op_mapper/onnx_custom_layer/InstanceNormalization.py

@@ -24,21 +24,18 @@ def InstanceNormalization_layer(inputs, name=None):
     epsilon = 1e-5
     input_ = inputs[0]
     mean = fluid.layers.reduce_mean(input_, dim=[2, 3], keep_dim=True)
-    var = fluid.layers.reduce_mean(fluid.layers.square(input_ - mean),
-                                   dim=[2, 3],
-                                   keep_dim=True)
+    var = fluid.layers.reduce_mean(
+        fluid.layers.square(input_ - mean), dim=[2, 3], keep_dim=True)
     if name is not None:
         scale_name = name + "_scale"
         offset_name = name + "_offset"
 
     scale_param = inputs[1]
     offset_param = inputs[2]
-    scale = fluid.layers.create_parameter(name=scale_param.name,
-                                          shape=input_.shape[1:2],
-                                          dtype="float32")
-    offset = fluid.layers.create_parameter(name=offset_param.name,
-                                           shape=input_.shape[1:2],
-                                           dtype="float32")
+    scale = fluid.layers.create_parameter(
+        name=scale_param.name, shape=input_.shape[1:2], dtype="float32")
+    offset = fluid.layers.create_parameter(
+        name=offset_param.name, shape=input_.shape[1:2], dtype="float32")
 
     tmp = fluid.layers.elementwise_mul(x=(input_ - mean), y=scale, axis=1)
     tmp = tmp / fluid.layers.sqrt(var + epsilon)
@@ -51,8 +48,9 @@ def InstanceNormalization_weights(name, data=None):
     return weights_name
 
 
-register(kind='InstanceNormalization',
-         shape=InstanceNormalization_shape,
-         layer=InstanceNormalization_layer,
-         child_func=None,
-         weights=InstanceNormalization_weights)
+register(
+    kind='InstanceNormalization',
+    shape=InstanceNormalization_shape,
+    layer=InstanceNormalization_layer,
+    child_func=None,
+    weights=InstanceNormalization_weights)

x2paddle/op_mapper/onnx_custom_layer/register.py

@@ -36,8 +36,7 @@ def register(kind, shape, layer, child_func, weights):
         kind = [kind]
     else:
         assert type(
-            kind
-        ) is list, 'invalid param "kind" for register, not a list or str'
+            kind) is list, 'invalid param "kind" for register, not a list or str'
 
     for k in kind:
         assert type(

x2paddle/op_mapper/onnx_directly_map.py

@@ -28,60 +28,49 @@ default_op_mapping_field_values['FILL_NAME_FIELD'] = True
 default_op_mapping = {
     'Shape': ['shape', ['X'], ['Out']],
     'Clip': [
-        'clip', ['X'], ['Out'],
-        dict(),
-        dict(
-            min=(_np.asarray([255, 255, 127, 255],
-                             dtype=_np.uint8).view(_np.float32)[0]),
-            max=(_np.asarray([255, 255, 127, 127],
-                             dtype=_np.uint8).view(_np.float32)[0]),
-        )
+        'clip', ['X'], ['Out'], dict(), dict(
+            min=(_np.asarray(
+                [255, 255, 127, 255], dtype=_np.uint8).view(_np.float32)[0]),
+            max=(_np.asarray(
+                [255, 255, 127, 127], dtype=_np.uint8).view(_np.float32)[0]), )
     ],
     'Erf': ['erf', ['X'], ['Out']],
     'Ceil': ['ceil', ['X'], ['Out']],
     'ReduceMean': [
-        'reduce_mean', ['X'], ['Out'],
-        dict(axes='dim', keepdims='keep_dim'),
-        dict(keep_dim=1)
+        'reduce_mean', ['X'], ['Out'], dict(
+            axes='dim', keepdims='keep_dim'), dict(keep_dim=1)
     ],
     'ReduceSum': [
-        'reduce_sum', ['X'], ['Out'],
-        dict(axes='dim', keepdims='keep_dim'),
-        dict(keep_dim=1)
+        'reduce_sum', ['X'], ['Out'], dict(
+            axes='dim', keepdims='keep_dim'), dict(keep_dim=1)
     ],
     'ReduceMin': [
-        'reduce_min', ['X'], ['Out'],
-        dict(axes='dim', keepdims='keep_dim'),
-        dict(keep_dim=1)
+        'reduce_min', ['X'], ['Out'], dict(
+            axes='dim', keepdims='keep_dim'), dict(keep_dim=1)
     ],
     'ReduceMax': [
-        'reduce_max', ['X'], ['Out'],
-        dict(axes='dim', keepdims='keep_dim'),
-        dict(keep_dim=1)
+        'reduce_max', ['X'], ['Out'], dict(
+            axes='dim', keepdims='keep_dim'), dict(keep_dim=1)
     ],
     #active function
     'Relu': ['relu', ['X'], ['Out']],
-    'LeakyRelu': ['leaky_relu', ['X'], ['Out'],
-                  dict(), dict(alpha=.01)],
-    'Elu': ['elu', ['X'], ['Out'],
-            dict(), dict(alpha=1.)],
+    'LeakyRelu': ['leaky_relu', ['X'], ['Out'], dict(), dict(alpha=.01)],
+    'Elu': ['elu', ['X'], ['Out'], dict(), dict(alpha=1.)],
     'ThresholdedRelu': [
-        'thresholded_relu', ['X'], ['Out'],
-        dict(alpha='threshold'),
+        'thresholded_relu', ['X'], ['Out'], dict(alpha='threshold'),
         dict(alpha=1.)
     ],
     'Tanh': ['tanh', ['X'], ['Out']],
     'Sigmoid': ['sigmoid', ['X'], ['Out']],
     'HardSigmoid': [
-        'hard_sigmoid', ['X'], ['Out'],
-        dict(alpha='slope', beta='offset'),
-        dict(slope=.2, offset=.5)
+        'hard_sigmoid', ['X'], ['Out'], dict(
+            alpha='slope', beta='offset'), dict(
+                slope=.2, offset=.5)
     ],
     'Softsign': ['softsign', ['X'], ['Out']],
     'Softplus': ['softplus', ['X'], ['Out']],
     'Exp': ['exp', ['X'], ['Out']],
-    'Softmax': ['softmax', ['X'], ['Out'],
-                dict(), dict(axis=1)],
+    'Softmax': ['softmax', ['X'], ['Out'], dict(), dict(axis=1)],
     'Sqrt': ['sqrt', ['X'], ['Out']],
     'Floor': ['floor', ['X'], ['Out']],
     'Abs': ['abs', ['X'], ['Out']],

x2paddle/op_mapper/onnx_op_mapper.py

@@ -140,8 +140,8 @@ class ONNXOpMapper(OpMapper):
 
         model.graph.ClearField('output')
         model.graph.output.MergeFrom(model.graph.value_info)
-        onnx.save(model, os.path.join(self.tmp_data_dir,
-                                      'onnx_model_infer.onnx'))
+        onnx.save(model,
+                  os.path.join(self.tmp_data_dir, 'onnx_model_infer.onnx'))
         sess = rt.InferenceSession(
             os.path.join(self.tmp_data_dir, 'onnx_model_infer.onnx'))
         res = sess.run(None, input_feed=inputs_dict)
@@ -217,8 +217,7 @@ class ONNXOpMapper(OpMapper):
             default_attrs,
             input_perm,
             output_perm,
-            fill_name_field,
-        ) = info
+            fill_name_field, ) = info
 
         if fluid_op in default_ioa_constraint:
             for predicate, message in default_ioa_constraint[fluid_op]:
@@ -429,10 +428,8 @@ class ONNXOpMapper(OpMapper):
         }
         node.fluid_code.add_layer(
             'roi_align',
-            inputs={
-                'input': val_x,
-                'rois': val_rois
-            },
+            inputs={'input': val_x,
+                    'rois': val_rois},
             output=node,
             param_attr=attr)
 
@@ -449,10 +446,8 @@ class ONNXOpMapper(OpMapper):
         }
         node.fluid_code.add_layer(
             'roi_pool',
-            inputs={
-                'input': val_x,
-                'rois': val_rois
-            },
+            inputs={'input': val_x,
+                    'rois': val_rois},
             output=node,
             param_attr=attr)
 
@@ -527,10 +522,8 @@ class ONNXOpMapper(OpMapper):
         val_y = self.graph.get_input_node(node, idx=1, copy=True)
         node.fluid_code.add_layer(
             'greater_than',
-            inputs={
-                'x': val_x,
-                'y': val_y
-            },
+            inputs={'x': val_x,
+                    'y': val_y},
             output=node,
             param_attr=None)
 
@@ -549,11 +542,10 @@ class ONNXOpMapper(OpMapper):
             shape = val_output.out_shapes[0]
         if shape is None:
             shape = list(value.shape)
-            _logger.warning(
-                'in (Constant -> %s): '
-                'attribute "shape" of %s not inferred, '
-                'using value as 1-D tensor may lead to fails',
-                val_output.layer_name, val_output.layer_name)
+            _logger.warning('in (Constant -> %s): '
+                            'attribute "shape" of %s not inferred, '
+                            'using value as 1-D tensor may lead to fails',
+                            val_output.layer_name, val_output.layer_name)
 
         if len(value) == 1:
             value = value.tolist()
@@ -616,10 +608,8 @@ class ONNXOpMapper(OpMapper):
         if axis == 0 and len(indices_shape) <= 1:
             node.fluid_code.add_layer(
                 'gather',
-                inputs={
-                    'input': val_x,
-                    'index': indices
-                },
+                inputs={'input': val_x,
+                        'index': indices},
                 output=node,
                 param_attr=None)
         elif axis > 0 and len(indices_shape) <= 1:
@@ -634,10 +624,8 @@ class ONNXOpMapper(OpMapper):
                 param_attr=attr_trans)
             node.fluid_code.add_layer(
                 'gather',
-                inputs={
-                    'input': name_trans,
-                    'index': indices
-                },
+                inputs={'input': name_trans,
+                        'index': indices},
                 output=node,
                 param_attr=None)
             node.fluid_code.add_layer(
@@ -649,9 +637,7 @@ class ONNXOpMapper(OpMapper):
                 'reshape',
                 inputs=indices,
                 output=indices,
-                param_attr={'shape': [
-                    reshape_shape,
-                ]})
+                param_attr={'shape': [reshape_shape, ]})
 
             perm = list(range(len(val_x.out_shapes[0])))
             perm = [axis] + perm[:axis] + perm[axis + 1:]
@@ -664,10 +650,8 @@ class ONNXOpMapper(OpMapper):
                 param_attr=attr_trans)
             node.fluid_code.add_layer(
                 'gather',
-                inputs={
-                    'input': name_trans,
-                    'index': indices
-                },
+                inputs={'input': name_trans,
+                        'index': indices},
                 output=node,
                 param_attr=None)
             node.fluid_code.add_layer(
@@ -926,8 +910,10 @@ class ONNXOpMapper(OpMapper):
     def Sum(self, node):
         val_inps = node.layer.input
         inputs = {
-            "x": self.graph.get_input_node(node, idx=0, copy=True),
-            "y": self.graph.get_input_node(node, idx=1, copy=True),
+            "x": self.graph.get_input_node(
+                node, idx=0, copy=True),
+            "y": self.graph.get_input_node(
+                node, idx=1, copy=True),
         }
         node.fluid_code.add_layer("elementwise_add", inputs=inputs, output=node)
 
@@ -1022,10 +1008,8 @@ class ONNXOpMapper(OpMapper):
         val_y = self.graph.get_input_node(node, idx=1, copy=True)
         node.fluid_code.add_layer(
             "equal",
-            inputs={
-                'x': val_x,
-                'y': val_y
-            },
+            inputs={'x': val_x,
+                    'y': val_y},
             output=node,
             param_attr=None)
 
@@ -1055,29 +1039,23 @@ class ONNXOpMapper(OpMapper):
         mul_val_x = val_x.layer_name + '_mul'
         node.fluid_code.add_layer(
             "elementwise_mul",
-            inputs={
-                'x': val_x,
-                'y': cast_condition
-            },
+            inputs={'x': val_x,
+                    'y': cast_condition},
             output=mul_val_x,
             param_attr=None)
 
         mul_val_y = val_y.layer_name + '_mul'
         node.fluid_code.add_layer(
             "elementwise_mul",
-            inputs={
-                'x': val_y,
-                'y': cast_not_condition
-            },
+            inputs={'x': val_y,
+                    'y': cast_not_condition},
             output=mul_val_y,
             param_attr=None)
 
         node.fluid_code.add_layer(
             "elementwise_add",
-            inputs={
-                'x': mul_val_x,
-                'y': mul_val_y
-            },
+            inputs={'x': mul_val_x,
+                    'y': mul_val_y},
             output=node,
             param_attr=None)
 
@@ -1106,7 +1084,8 @@ class ONNXOpMapper(OpMapper):
                 output=flatten_name,
                 param_attr={'axis': 0})
         node.fluid_code.add_layer(
-            "concat", inputs=flatten_names, output=node, param_attr={'axis': 0})
+            "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)
@@ -1280,11 +1259,11 @@ class ONNXOpMapper(OpMapper):
 
         output_size = [0, 0]
 
-        output_size[0] = (val_x.out_shapes[0][2] -
-                          1) * strides[0] - 2 * paddings[0] + dilations[0] * (
+        output_size[0] = (val_x.out_shapes[0][2] - 1
+                          ) * strides[0] - 2 * paddings[0] + dilations[0] * (
                               kernel_shape[0] - 1) + 1 + out_padding[0]
-        output_size[1] = (val_x.out_shapes[0][3] -
-                          1) * strides[1] - 2 * paddings[1] + dilations[1] * (
+        output_size[1] = (val_x.out_shapes[0][3] - 1
+                          ) * strides[1] - 2 * paddings[1] + dilations[1] * (
                               kernel_shape[1] - 1) + 1 + out_padding[1]
         attr = {
             'num_filters': num_out_channels,
@@ -1367,29 +1346,23 @@ class ONNXOpMapper(OpMapper):
             'squeeze',
             inputs=val_x,
             output=var_x0,
-            param_attr={
-                'axes': [1],
-                'name': string(var_x0)
-            })
+            param_attr={'axes': [1],
+                        'name': string(var_x0)})
 
         var_w0 = node.layer_name + '_w0'
         node.fluid_code.add_layer(
             'squeeze',
             inputs=val_w,
             output=var_w0,
-            param_attr={
-                'axes': [0],
-                'name': string(var_w0)
-            })
+            param_attr={'axes': [0],
+                        'name': string(var_w0)})
 
         var_fc = node.layer_name + '_fc'
         var_mm = (node.layer_name + '_mm') if val_b else var_fc
         node.fluid_code.add_layer(
             'matmul',
-            inputs={
-                'x': var_x0,
-                'y': var_w0
-            },
+            inputs={'x': var_x0,
+                    'y': var_w0},
             output=var_mm,
             param_attr={
                 'transpose_x': 0,
@@ -1402,10 +1375,8 @@ class ONNXOpMapper(OpMapper):
             'squeeze',
             inputs=val_r,
             output=var_r0,
-            param_attr={
-                'axes': [0],
-                'name': string(var_r0)
-            })
+            param_attr={'axes': [0],
+                        'name': string(var_r0)})
 
         var_r0t = node.layer_name + '_r0t'
 
@@ -1413,10 +1384,8 @@ class ONNXOpMapper(OpMapper):
             'transpose',
             inputs=var_r0,
             output=var_r0t,
-            param_attr={
-                'perm': [1, 0],
-                'name': string(var_r0t)
-            })
+            param_attr={'perm': [1, 0],
+                        'name': string(var_r0t)})
         if val_b:
             var_bi = node.layer_name + '_bi'
             var_bh = node.layer_name + '_bh'
@@ -1434,10 +1403,8 @@ class ONNXOpMapper(OpMapper):
                 'squeeze',
                 inputs=var_bi,
                 output=var_bi0,
-                param_attr={
-                    'axes': [0],
-                    'name': string(var_bi0)
-                })
+                param_attr={'axes': [0],
+                            'name': string(var_bi0)})
 
             node.fluid_code.add_layer(
                 'elmentwise_add',
@@ -1454,10 +1421,8 @@ class ONNXOpMapper(OpMapper):
                 'squeeze',
                 inputs=val_xh,
                 output=var_xh0,
-                param_attr={
-                    'axes': [1],
-                    'name': string(var_xh0)
-                })
+                param_attr={'axes': [1],
+                            'name': string(var_xh0)})
         var_y00 = node.layer_name + '_y00'
 
         attr = {

x2paddle/op_mapper/paddle_custom_layer/im2sequence.py

@@ -30,8 +30,8 @@ def im2sequence(op, block):
     slice_blocks = list()
     for i in range(out_h):
         for j in range(out_w):
-            starts_name = "im2sequence.starts.{}.{}.{}".format(
-                im2seq_counter, i, j)
+            starts_name = "im2sequence.starts.{}.{}.{}".format(im2seq_counter,
+                                                               i, j)
             starts_tensor = helper.make_tensor(
                 name=starts_name,
                 data_type=onnx_pb.TensorProto.INT64,

x2paddle/op_mapper/paddle_custom_layer/multiclass_nms.py

@@ -44,8 +44,7 @@ def multiclass_nms(op, block):
     if normalized == False:
         warnings.warn(
             'The parameter normalized of multiclass_nms OP of Paddle is False, which has diff with ONNX. \
-                         Please set normalized=True in multiclass_nms of Paddle'
-        )
+                         Please set normalized=True in multiclass_nms of Paddle')
 
     #convert the paddle attribute to onnx tensor
     name_score_threshold = [outputs['Out'][0] + "@score_threshold"]
@@ -353,7 +352,8 @@ def multiclass_nms(op, block):
     outputs_gather_topk_class = [result_name + "@gather_topk_class"]
     node_gather_topk_class = onnx.helper.make_node(
         'Gather',
-        inputs=outputs_gather_1_nonzero + [outputs_topk_select_topk_indices[1]],
+        inputs=outputs_gather_1_nonzero +
+        [outputs_topk_select_topk_indices[1]],
         outputs=outputs_gather_topk_class,
         axis=1)
     node_list.append(node_gather_topk_class)
@@ -362,7 +362,8 @@ def multiclass_nms(op, block):
     outputs_gather_topk_boxes_id = [result_name + "@gather_topk_boxes_id"]
     node_gather_topk_boxes_id = onnx.helper.make_node(
         'Gather',
-        inputs=outputs_gather_2_nonzero + [outputs_topk_select_topk_indices[1]],
+        inputs=outputs_gather_2_nonzero +
+        [outputs_topk_select_topk_indices[1]],
         outputs=outputs_gather_topk_boxes_id,
         axis=1)
     node_list.append(node_gather_topk_boxes_id)

x2paddle/op_mapper/paddle_custom_layer/yolo_box.py

@@ -4,8 +4,6 @@ from onnx import onnx_pb, helper
 
 
 def get_old_name(arg, name_prefix=''):
-    """Get the old rame for a possible renamed argument
-    """
     prefix_index = arg.find(name_prefix)
 
     if prefix_index != -1:
@@ -40,8 +38,8 @@ def yolo_box(op, block):
     downsample_ratio = attrs['downsample_ratio']
     input_size = input_height * downsample_ratio
     conf_thresh = attrs['conf_thresh']
-    conf_thresh_mat = np.ones([num_anchors * input_height * input_width
-                               ]) * conf_thresh
+    conf_thresh_mat = np.ones([num_anchors * input_height *
+                               input_width]) * conf_thresh
 
     node_list = []
     im_outputs = []

x2paddle/op_mapper/paddle_op_mapper.py

@@ -250,8 +250,7 @@ class PaddleOpMapper(object):
             node = helper.make_node(
                 pool_type[op.attr('pooling_type')][1],
                 inputs=op.input('X'),
-                outputs=op.output('Out'),
-            )
+                outputs=op.output('Out'), )
         else:
             input_shape = block.var(op.input('X')[0]).shape
             k_size = op.attr('ksize')
@@ -407,8 +406,7 @@ class PaddleOpMapper(object):
         node = helper.make_node(
             'Clip',
             inputs=[op.input('X')[0], min_name, max_name],
-            outputs=op.output('Out'),
-        )
+            outputs=op.output('Out'), )
         return [min_node, max_node, node]
 
     def shape(self, op, block):
@@ -450,8 +448,7 @@ class PaddleOpMapper(object):
         node = helper.make_node(
             "Slice",
             inputs=[op.input('Input')[0], starts_name, ends_name, axes_name],
-            outputs=op.output('Out'),
-        )
+            outputs=op.output('Out'), )
         return [starts_node, ends_node, axes_node, node]
 
     def fill_constant(self, op, block):
@@ -551,8 +548,8 @@ class PaddleOpMapper(object):
         if op.attr('align_corners'):
             coordinate_transformation_mode = 'align_corners'
         if ('OutSize' in input_names and len(op.input('OutSize')) > 0) or (
-                'SizeTensor' in input_names
-                and len(op.input('SizeTensor')) > 0):
+                'SizeTensor' in input_names and
+                len(op.input('SizeTensor')) > 0):
             node_list = list()
             roi_node = self.make_constant_node(
                 self.get_name(op.type, 'roi'), onnx_pb.TensorProto.FLOAT,
@@ -631,8 +628,7 @@ class PaddleOpMapper(object):
         elif 'Scale' in input_names and len(op.input('Scale')) > 0:
             node = helper.make_node(
                 'Resize',
-                inputs=[op.input('X')[0],
-                        op.input('Scale')[0]],
+                inputs=[op.input('X')[0], op.input('Scale')[0]],
                 outputs=op.output('Out'),
                 mode='linear',
                 coordinate_transformation_mode=coordinate_transformation_mode)
@@ -641,8 +637,9 @@ class PaddleOpMapper(object):
             scale = op.attr('scale')
             if out_shape.count(-1) > 0:
                 scale_name = self.get_name(op.type, 'scale')
-                scale_node = self.make_constant_node(
-                    scale_name, onnx_pb.TensorProto.FLOAT, [1, 1, scale, scale])
+                scale_node = self.make_constant_node(scale_name,
+                                                     onnx_pb.TensorProto.FLOAT,
+                                                     [1, 1, scale, scale])
                 roi_name = self.get_name(op.type, 'roi')
                 roi_node = self.make_constant_node(roi_name,
                                                    onnx_pb.TensorProto.FLOAT,
@@ -667,16 +664,14 @@ class PaddleOpMapper(object):
         if 'OutSize' in input_names and len(op.input('OutSize')) > 0:
             node = helper.make_node(
                 'Resize',
-                inputs=[op.input('X')[0], '',
-                        op.input('OutSize')[0]],
+                inputs=[op.input('X')[0], '', op.input('OutSize')[0]],
                 outputs=op.output('Out'),
                 mode='nearest',
                 coordinate_transformation_mode=coordinate_transformation_mode)
         elif 'Scale' in input_names and len(op.input('Scale')) > 0:
             node = helper.make_node(
                 'Resize',
-                inputs=[op.input('X')[0],
-                        op.input('Scale')[0]],
+                inputs=[op.input('X')[0], op.input('Scale')[0]],
                 outputs=op.output('Out'),
                 mode='nearest',
                 coordinate_transformation_mode=coordinate_transformation_mode)
@@ -685,8 +680,9 @@ class PaddleOpMapper(object):
             scale = op.attr('scale')
             if out_shape.count(-1) > 0:
                 scale_name = self.get_name(op.type, 'scale')
-                scale_node = self.make_constant_node(
-                    scale_name, onnx_pb.TensorProto.FLOAT, [1, 1, scale, scale])
+                scale_node = self.make_constant_node(scale_name,
+                                                     onnx_pb.TensorProto.FLOAT,
+                                                     [1, 1, scale, scale])
                 roi_name = self.get_name(op.type, 'roi')
                 roi_node = self.make_constant_node(roi_name,
                                                    onnx_pb.TensorProto.FLOAT,
@@ -737,8 +733,7 @@ class PaddleOpMapper(object):
         node1 = helper.make_node(
             'Clip',
             inputs=[name0, min_name, max_name],
-            outputs=[name1],
-        )
+            outputs=[name1], )
         name2 = self.get_name(op.type, 'mul')
         node2 = helper.make_node(
             'Mul', inputs=[op.input('X')[0], name1], outputs=[name2])
@@ -814,14 +809,6 @@ class PaddleOpMapper(object):
             keepdims=0)
         return node
 
-    def yolo_box(self, op, block):
-        from .paddle_custom_layer.yolo_box import yolo_box
-        return yolo_box(op, block)
-
-    def multiclass_nms(self, op, block):
-        from .paddle_custom_layer.multiclass_nms import multiclass_nms
-        return multiclass_nms(op, block)
-
     def reciprocal(self, op, block):
         inputs = op.input(op.input_names[0])
         outputs = op.output(op.output_names[0])

x2paddle/op_mapper/tf_op_mapper.py

@@ -114,9 +114,8 @@ class TFOpMapper(OpMapper):
             else:
                 unsupported_ops.add(op)
         if len(unsupported_ops) > 0:
-            sys.stderr.write(
-                "=========={} Ops are not supported yet======\n".format(
-                    len(unsupported_ops)))
+            sys.stderr.write("=========={} Ops are not supported yet======\n".
+                             format(len(unsupported_ops)))
             for op in unsupported_ops:
                 sys.stderr.write("========== {} ==========\n".format(op))
             sys.exit(-1)
@@ -141,10 +140,8 @@ class TFOpMapper(OpMapper):
             pd_param_name = list(param.values())[0]
             tf_param = node.get_attr(tf_param_name)
             attr[pd_param_name] = tf_param
-        node.fluid_code.add_layer(op_info[0],
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            op_info[0], inputs=input, output=node, param_attr=attr)
 
     def elementwise_map(self, node):
         assert node.layer_type in self.elementwise_ops
@@ -179,21 +176,21 @@ class TFOpMapper(OpMapper):
                         0] == y_shape[-1] and y_shape.count(-1) < 1:
                     shape = [1, x_shape[0], 1, 1]
                     attr = {"shape": shape}
-                    node.fluid_code.add_layer("reshape",
-                                              inputs=x_input,
-                                              output="reshape_x",
-                                              param_attr=attr)
+                    node.fluid_code.add_layer(
+                        "reshape",
+                        inputs=x_input,
+                        output="reshape_x",
+                        param_attr=attr)
                     if y_shape[0] != 1:
                         attr = {"expand_times": [y_shape[0], 1, 1, 1]}
-                        node.fluid_code.add_layer("expand",
-                                                  inputs="reshape_x",
-                                                  output="reshape_x",
-                                                  param_attr=attr)
+                        node.fluid_code.add_layer(
+                            "expand",
+                            inputs="reshape_x",
+                            output="reshape_x",
+                            param_attr=attr)
                     inputs = {"x": "reshape_x", "y": y_input}
-                    node.fluid_code.add_layer(op_type,
-                                              inputs=inputs,
-                                              output=node,
-                                              param_attr=None)
+                    node.fluid_code.add_layer(
+                        op_type, inputs=inputs, output=node, param_attr=None)
                     return
                 else:
                     raise Exception("Unexpected situation happend")
@@ -205,10 +202,8 @@ class TFOpMapper(OpMapper):
                 axis = -1
             attr = {"axis": axis}
             inputs = {"x": x_input, "y": y_input}
-            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)
             return
 
         is_sub_seq = True
@@ -242,10 +237,8 @@ class TFOpMapper(OpMapper):
                 if len(x_expand_times) == 4 and x.tf_data_format == "NHWC":
                     x_expand_times = [x_expand_times[i] for i in [0, 3, 1, 2]]
                 attr = {"expand_times": x_expand_times}
-                node.fluid_code.add_layer("expand",
-                                          inputs=x_input,
-                                          output="x_tmp",
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "expand", inputs=x_input, output="x_tmp", param_attr=attr)
                 x_input = "x_tmp"
             if y_need_expand:
                 if len(y_expand_times) == 3 and y.tf_data_format == "NHWC":
@@ -253,16 +246,12 @@ class TFOpMapper(OpMapper):
                 if len(y_expand_times) == 4 and y.tf_data_format == "NHWC":
                     y_expand_times = [y_expand_times[i] for i in [0, 3, 1, 2]]
                 attr = {"expand_times": y_expand_times}
-                node.fluid_code.add_layer("expand",
-                                          inputs=y_input,
-                                          output="y_tmp",
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "expand", inputs=y_input, output="y_tmp", param_attr=attr)
                 y_input = "y_tmp"
         inputs = {"x": x_input, "y": y_input}
-        node.fluid_code.add_layer(op_type,
-                                  inputs=inputs,
-                                  output=node,
-                                  param_attr=None)
+        node.fluid_code.add_layer(
+            op_type, inputs=inputs, output=node, param_attr=None)
 
     def Placeholder(self, node):
         shape = node.out_shapes[0]
@@ -283,10 +272,8 @@ class TFOpMapper(OpMapper):
         if shape[0] < 0:
             self.batch_node = node
 
-        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 OneShotIterator(self, node):
         return self.Placeholder(node)
@@ -308,8 +295,8 @@ class TFOpMapper(OpMapper):
                 shape = [shape[i] for i in [0, 3, 1, 2]]
             if len(shape) == 3:
                 shape = [shape[i] for i in [2, 0, 1]]
-                self.weights[node.layer_name] = numpy.transpose(
-                    node.value, (2, 0, 1))
+                self.weights[node.layer_name] = numpy.transpose(node.value,
+                                                                (2, 0, 1))
         elif node.tf_data_format == "NCHW":
             if len(shape) == 4:
                 self.graph.data_format_propagation(node)
@@ -320,10 +307,8 @@ class TFOpMapper(OpMapper):
             'name': string(node.layer_name),
             'default_initializer': initializer
         }
-        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 Transpose(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -362,16 +347,12 @@ class TFOpMapper(OpMapper):
             node.tf_data_format = [tf_data_format[i] for i in perm]
             node.pd_data_format = [pd_data_format[i] for i in perm]
             attr = {'perm': new_perm}
-            node.fluid_code.add_layer("transpose",
-                                      inputs=input,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "transpose", inputs=input, output=node, param_attr=attr)
         elif len(node.out_shapes[0]) != 4:
             attr = {'perm': perm}
-            node.fluid_code.add_layer("transpose",
-                                      inputs=input,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "transpose", inputs=input, output=node, param_attr=attr)
         else:
             raise Exception("Unexpected situation happend in Transpose OP")
 
@@ -401,10 +382,8 @@ class TFOpMapper(OpMapper):
             "pool_padding": string(pad_mode),
             "pool_stride": strides[2:4]
         }
-        node.fluid_code.add_layer("pool2d",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "pool2d", inputs=input, output=node, param_attr=attr)
 
     def Conv2D(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -444,10 +423,8 @@ class TFOpMapper(OpMapper):
             "dilation": dilations[2:4],
             "padding": string(pad_mode)
         }
-        node.fluid_code.add_layer("conv2d",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "conv2d", inputs=input, output=node, param_attr=attr)
 
     def BiasAdd(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -457,10 +434,8 @@ class TFOpMapper(OpMapper):
             axis = 1
         inputs = {"x": input, "y": bias}
         attr = {"axis": axis}
-        node.fluid_code.add_layer("elementwise_add",
-                                  inputs=inputs,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "elementwise_add", inputs=inputs, output=node, param_attr=attr)
 
     def FusedBatchNorm(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -491,10 +466,8 @@ class TFOpMapper(OpMapper):
             "is_test": True
         }
 
-        node.fluid_code.add_layer("batch_norm",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "batch_norm", inputs=input, output=node, param_attr=attr)
 
     def FusedBatchNormV3(self, node):
         return self.FusedBatchNorm(node)
@@ -539,10 +512,8 @@ class TFOpMapper(OpMapper):
             "use_cudnn": False,
             "padding": string(pad_mode)
         }
-        node.fluid_code.add_layer("conv2d",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "conv2d", inputs=input, output=node, param_attr=attr)
 
     def Reshape(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -562,18 +533,17 @@ class TFOpMapper(OpMapper):
                 attr = {"shape": shape}
                 self.add_omit_nodes(param.layer_name, node.layer_name)
             else:
-                assert len(param.out_shapes[0]
-                           ) == 1, "Unexpected situation of shape parameter"
+                assert len(param.out_shapes[
+                    0]) == 1, "Unexpected situation of shape parameter"
                 attr = {"shape": [-1]}
-                node.fluid_code.add_layer("reshape",
-                                          inputs=param,
-                                          output="shape_param",
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "reshape",
+                    inputs=param,
+                    output="shape_param",
+                    param_attr=attr)
                 attr = {"num_or_sections": param.out_shapes[0][0], "dim": 0}
-                node.fluid_code.add_layer("split",
-                                          inputs="shape_param",
-                                          output=node,
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "split", inputs="shape_param", output=node, param_attr=attr)
                 new_param = "["
                 for i in range(param.out_shapes[0][0]):
                     new_param += (node.layer_name + "[{}]".format(i) + ", ")
@@ -601,14 +571,10 @@ class TFOpMapper(OpMapper):
         if len(input.out_shapes[0]) == 4 and node.tf_data_format == "NHWC":
             if len(attr["shape"]) < 3:
                 perm = {"perm": [0, 2, 3, 1]}
-                node.fluid_code.add_layer("transpose",
-                                          inputs=input,
-                                          output=node,
-                                          param_attr=perm)
-                node.fluid_code.add_layer("reshape",
-                                          inputs=node,
-                                          output=node,
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "transpose", inputs=input, output=node, param_attr=perm)
+                node.fluid_code.add_layer(
+                    "reshape", inputs=node, output=node, param_attr=attr)
                 return
 
         if len(attr["shape"]) == 4 and node.tf_data_format == "NHWC":
@@ -617,27 +583,19 @@ class TFOpMapper(OpMapper):
                 attr["shape"] = [attr["shape"][i] for i in [0, 3, 1, 2]]
             else:
                 perm = {"perm": [0, 2, 3, 1]}
-                node.fluid_code.add_layer("transpose",
-                                          inputs=input,
-                                          output=node,
-                                          param_attr=perm)
-                node.fluid_code.add_layer("reshape",
-                                          inputs=node,
-                                          output=node,
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "transpose", inputs=input, output=node, param_attr=perm)
+                node.fluid_code.add_layer(
+                    "reshape", inputs=node, output=node, param_attr=attr)
                 perm = {"perm": [0, 3, 1, 2]}
-                node.fluid_code.add_layer("transpose",
-                                          inputs=node,
-                                          output=node,
-                                          param_attr=perm)
+                node.fluid_code.add_layer(
+                    "transpose", inputs=node, output=node, param_attr=perm)
                 return
         if len(attr["shape"]) == 5:
             attr["shape"] = [attr["shape"][i] for i in [0, 1, 4, 2, 3]]
 
-        node.fluid_code.add_layer("reshape",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "reshape", inputs=input, output=node, param_attr=attr)
 
     def AvgPool(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -665,10 +623,8 @@ class TFOpMapper(OpMapper):
             "pool_stride": strides[2:4],
             "pool_padding": string(pad_mode)
         }
-        node.fluid_code.add_layer("pool2d",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "pool2d", inputs=input, output=node, param_attr=attr)
 
     def SplitV(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -685,28 +641,24 @@ class TFOpMapper(OpMapper):
             "num_or_sections": num_sections.value.tolist(),
             "dim": dim.value
         }
-        node.fluid_code.add_layer("split",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "split", inputs=input, output=node, param_attr=attr)
 
     def ConcatV2(self, node):
         inputs = [
-            self.graph.get_node(name, copy=True)
-            for name in node.layer.input[:-1]
+            self.graph.get_node(
+                name, copy=True) for name in node.layer.input[:-1]
         ]
         axis = self.graph.get_node(node.layer.input[-1], copy=True)
         assert axis.layer_type == "Const"
         self.add_omit_nodes(axis.layer_name, node.layer_name)
         axis = axis.value
-        if inputs[0].tf_data_format == "NHWC" and len(
-                inputs[0].out_shapes[0]) == 4:
+        if inputs[0].tf_data_format == "NHWC" and len(inputs[0].out_shapes[
+                0]) == 4:
             axis = nhwc_dim_to_nchw(inputs[0], 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 Tile(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -726,18 +678,17 @@ class TFOpMapper(OpMapper):
                 expand_times[i] = 1
 
         attr = {"expand_times": expand_times}
-        node.fluid_code.add_layer("expand",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "expand", inputs=input, output=node, param_attr=attr)
 
     def Pack(self, node):
         inputs = [
-            self.graph.get_node(name, copy=True) for name in node.layer.input
+            self.graph.get_node(
+                name, copy=True) for name in node.layer.input
         ]
         axis = node.get_attr("axis")
-        if inputs[0].tf_data_format == "NHWC" and len(
-                inputs[0].out_shapes[0]) == 4:
+        if inputs[0].tf_data_format == "NHWC" and len(inputs[0].out_shapes[
+                0]) == 4:
             tf_data_format = list(inputs[0].tf_data_format)
             tf_data_format.insert(axis, str(len(tf_data_format)))
             axis = nhwc_dim_to_nchw(inputs[0], axis)
@@ -747,10 +698,8 @@ class TFOpMapper(OpMapper):
             node.pd_data_format = "".join(pd_data_format)
 
         attr = {"axis": axis}
-        node.fluid_code.add_layer("stack",
-                                  inputs=inputs,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "stack", inputs=inputs, output=node, param_attr=attr)
 
     def Pad(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -767,10 +716,8 @@ class TFOpMapper(OpMapper):
                 paddings = paddings[4:]
                 pad_op = "pad2d"
         attr = {"paddings": paddings}
-        node.fluid_code.add_layer(pad_op,
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            pad_op, inputs=input, output=node, param_attr=attr)
 
     def MirrorPad(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -789,10 +736,8 @@ class TFOpMapper(OpMapper):
                 paddings = paddings[4:]
                 pad_op = "pad2d"
         attr = {"paddings": paddings, "mode": string("reflect")}
-        node.fluid_code.add_layer(pad_op,
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            pad_op, inputs=input, output=node, param_attr=attr)
 
     def Range(self, node):
         start = self.graph.get_node(node.layer.input[0], copy=True)
@@ -816,10 +761,8 @@ class TFOpMapper(OpMapper):
 
         inputs = {"start": start, "end": limit, "step": delta}
         attr = {"dtype": string(node.dtype)}
-        node.fluid_code.add_layer("range",
-                                  inputs=inputs,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "range", inputs=inputs, output=node, param_attr=attr)
 
     def Mean(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -833,10 +776,8 @@ class TFOpMapper(OpMapper):
                 dims[i] = nhwc_dim_to_nchw(input, dims[i])
 
         attr = {"dim": dims, "keep_dim": keep_dims}
-        node.fluid_code.add_layer("reduce_mean",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "reduce_mean", inputs=input, output=node, param_attr=attr)
 
     def MatMul(self, node):
         x = self.graph.get_node(node.layer.input[0], copy=True)
@@ -850,15 +791,11 @@ class TFOpMapper(OpMapper):
             shape = x.out_shapes[0]
             shape[-1] = y.out_shapes[0][0]
             attr = {"shape": shape}
-            node.fluid_code.add_layer("reshape",
-                                      inputs=x,
-                                      output=x,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "reshape", inputs=x, output=x, param_attr=attr)
         attr = {"transpose_x": transpose_a, "transpose_y": transpose_b}
-        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 ArgMax(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -869,10 +806,8 @@ class TFOpMapper(OpMapper):
         if input.tf_data_format == "NHWC" and len(input.out_shapes[0]) == 4:
             axis = nhwc_dim_to_nchw(input, axis)
         attr = {"axis": axis}
-        node.fluid_code.add_layer("argmax",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "argmax", inputs=input, output=node, param_attr=attr)
 
     def StridedSlice(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -910,16 +845,12 @@ class TFOpMapper(OpMapper):
             x = shrink_axis_mask >> i & 1
             if x == 1:
                 squeeze_dims.append(i)
-        node.fluid_code.add_layer("slice",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "slice", inputs=input, output=node, param_attr=attr)
         if shrink_axis_mask > 0 and len(input.out_shapes[0]) == 5:
             attr = {"axes": squeeze_dims}
-            node.fluid_code.add_layer("squeeze",
-                                      inputs=node,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "squeeze", inputs=node, output=node, param_attr=attr)
 
     def Slice(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -951,10 +882,8 @@ class TFOpMapper(OpMapper):
             "starts": begin,
             "ends": size
         }
-        node.fluid_code.add_layer("slice",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "slice", inputs=input, output=node, param_attr=attr)
 
     def Conv2DBackpropInput(self, node):
         out_shape = self.graph.get_node(node.layer.input[0], copy=True)
@@ -1004,10 +933,8 @@ class TFOpMapper(OpMapper):
             "padding": string(pad_mode),
             "output_size": out_shape[1:3]
         }
-        node.fluid_code.add_layer("conv2d_transpose",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "conv2d_transpose", inputs=input, output=node, param_attr=attr)
 
     def Max(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -1019,10 +946,8 @@ class TFOpMapper(OpMapper):
             dim = nhwc_dim_to_nchw(input, dim)
 
         attr = {"dim": dim, "keep_dim": keep_dims}
-        node.fluid_code.add_layer("reduce_max",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "reduce_max", inputs=input, output=node, param_attr=attr)
 
     def Sum(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -1034,19 +959,15 @@ class TFOpMapper(OpMapper):
             dim = nhwc_dim_to_nchw(input, dim)
 
         attr = {"dim": dim, "keep_dim": keep_dims}
-        node.fluid_code.add_layer("reduce_sum",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "reduce_sum", inputs=input, output=node, param_attr=attr)
 
     def Cast(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
         dtype = node.dtype_map[node.get_attr('DstT')]
         attr = {"dtype": string(dtype)}
-        node.fluid_code.add_layer("cast",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "cast", inputs=input, output=node, param_attr=attr)
 
     def Split(self, node):
         dim = self.graph.get_node(node.layer.input[0], copy=True)
@@ -1058,10 +979,8 @@ class TFOpMapper(OpMapper):
             dim = nhwc_dim_to_nchw(input, dim)
 
         attr = {"num_or_sections": num_split, "dim": dim}
-        node.fluid_code.add_layer("split",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "split", inputs=input, output=node, param_attr=attr)
 
     def Squeeze(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -1070,10 +989,8 @@ class TFOpMapper(OpMapper):
             for i in range(len(squeeze_dims)):
                 squeeze_dims[i] = nhwc_dim_to_nchw(input, squeeze_dims[i])
         attr = {"axes": squeeze_dims}
-        node.fluid_code.add_layer("squeeze",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "squeeze", inputs=input, output=node, param_attr=attr)
 
     def Softmax(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -1083,10 +1000,8 @@ class TFOpMapper(OpMapper):
         if input.tf_data_format == "NHWC" and len(input.out_shapes[0]) == 4:
             axis = nhwc_dim_to_nchw(input, axis)
         attr = {"axis": axis}
-        node.fluid_code.add_layer("softmax",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "softmax", inputs=input, output=node, param_attr=attr)
 
     def ResizeNearestNeighbor(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -1095,14 +1010,12 @@ class TFOpMapper(OpMapper):
         if resize_shape.layer_type == "Const":
             resize_shape = resize_shape.value.tolist()
         else:
-            resize_shape = self.decoder.infer_shape_tensor(
-                resize_shape, node.out_shapes[0])
+            resize_shape = self.decoder.infer_shape_tensor(resize_shape,
+                                                           node.out_shapes[0])
         align_corners = node.get_attr("align_corners")
         attr = {"align_corners": align_corners, "out_shape": resize_shape}
-        node.fluid_code.add_layer("resize_nearest",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "resize_nearest", inputs=input, output=node, param_attr=attr)
 
     def ResizeBilinear(self, node):
         input = self.graph.get_node(node.layer.input[0], copy=True)
@@ -1111,27 +1024,23 @@ class TFOpMapper(OpMapper):
         if resize_shape.layer_type == "Const":
             resize_shape = resize_shape.value.tolist()
         else:
-            resize_shape = self.decoder.infer_shape_tensor(
-                resize_shape, node.out_shapes[0])
+            resize_shape = self.decoder.infer_shape_tensor(resize_shape,
+                                                           node.out_shapes[0])
         align_corners = node.get_attr("align_corners")
         attr = {
             "align_corners": align_corners,
             "out_shape": resize_shape,
             "align_mode": 1
         }
-        node.fluid_code.add_layer("resize_bilinear",
-                                  inputs=input,
-                                  output=node,
-                                  param_attr=attr)
+        node.fluid_code.add_layer(
+            "resize_bilinear", inputs=input, output=node, param_attr=attr)
 
     def GreaterEqual(self, node):
         x = self.graph.get_node(node.layer.input[0], copy=True)
         y = self.graph.get_node(node.layer.input[1], copy=True)
         inputs = {"x": x, "y": y}
-        node.fluid_code.add_layer("greater_equal",
-                                  inputs=inputs,
-                                  output=node,
-                                  param_attr=None)
+        node.fluid_code.add_layer(
+            "greater_equal", inputs=inputs, output=node, param_attr=None)
 
     def RandomUniform(self, node):
         shape = self.graph.get_node(node.layer.input[0], copy=True)
@@ -1145,26 +1054,21 @@ class TFOpMapper(OpMapper):
         attr = {"shape": shape, "min": 0.0, "max": 0.9999}
         if shape[0] < 0:
             input = self.batch_node
-            node.fluid_code.add_layer("uniform_random_batch_size_like",
-                                      inputs=input,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "uniform_random_batch_size_like",
+                inputs=input,
+                output=node,
+                param_attr=attr)
         else:
-            node.fluid_code.add_layer("uniform_random",
-                                      inputs=None,
-                                      output=node,
-                                      param_attr=attr)
+            node.fluid_code.add_layer(
+                "uniform_random", inputs=None, output=node, param_attr=attr)
 
     def SquaredDifference(self, node):
         x = self.graph.get_node(node.layer.input[0], copy=True)
         y = self.graph.get_node(node.layer.input[1], copy=True)
         inputs = {"x": x, "y": y}
-        node.fluid_code.add_layer("elementwise_sub",
-                                  inputs=inputs,
-                                  output=node,
-                                  param_attr=None)
+        node.fluid_code.add_layer(
+            "elementwise_sub", inputs=inputs, output=node, param_attr=None)
         inputs = {"x": node, "y": node}
-        node.fluid_code.add_layer("elementwise_mul",
-                                  inputs=inputs,
-                                  output=node,
-                                  param_attr=None)
+        node.fluid_code.add_layer(
+            "elementwise_mul", inputs=inputs, output=node, param_attr=None)

x2paddle/op_mapper/tf_op_mapper_nhwc.py

@@ -486,8 +486,8 @@ class TFOpMapperNHWC(OpMapper):
                 attr = {"shape": shape}
                 self.add_omit_nodes(param.layer_name, node.layer_name)
             else:
-                assert len(param.out_shapes[0]
-                           ) == 1, "Unexpected situation of shape parameter"
+                assert len(param.out_shapes[
+                    0]) == 1, "Unexpected situation of shape parameter"
                 attr = {"shape": [-1]}
                 node.fluid_code.add_layer(
                     "reshape",
@@ -577,8 +577,8 @@ class TFOpMapperNHWC(OpMapper):
 
     def ConcatV2(self, node):
         inputs = [
-            self.graph.get_node(name, copy=True)
-            for name in node.layer.input[:-1]
+            self.graph.get_node(
+                name, copy=True) for name in node.layer.input[:-1]
         ]
         axis = self.graph.get_node(node.layer.input[-1], copy=True)
         assert axis.layer_type == "Const"
@@ -608,7 +608,8 @@ class TFOpMapperNHWC(OpMapper):
 
     def Pack(self, node):
         inputs = [
-            self.graph.get_node(name, copy=True) for name in node.layer.input
+            self.graph.get_node(
+                name, copy=True) for name in node.layer.input
         ]
         axis = node.get_attr("axis")
         attr = {"axis": axis}
@@ -949,8 +950,8 @@ class TFOpMapperNHWC(OpMapper):
         if resize_shape.layer_type == "Const":
             resize_shape = resize_shape.value.tolist()
         else:
-            resize_shape = self.decoder.infer_shape_tensor(
-                resize_shape, node.out_shapes[0])
+            resize_shape = self.decoder.infer_shape_tensor(resize_shape,
+                                                           node.out_shapes[0])
         align_corners = node.get_attr("align_corners")
         attr = {"perm": [0, 3, 1, 2]}
         node.fluid_code.add_layer(
@@ -969,8 +970,8 @@ class TFOpMapperNHWC(OpMapper):
         if resize_shape.layer_type == "Const":
             resize_shape = resize_shape.value.tolist()
         else:
-            resize_shape = self.decoder.infer_shape_tensor(
-                resize_shape, node.out_shapes[0])
+            resize_shape = self.decoder.infer_shape_tensor(resize_shape,
+                                                           node.out_shapes[0])
         align_corners = node.get_attr("align_corners")
         attr = {"perm": [0, 3, 1, 2]}
         node.fluid_code.add_layer(

x2paddle/optimizer/caffe_optimizer.py

@@ -41,10 +41,11 @@ class CaffeOptimizer(object):
                     if is_delete_node:
                         parent_node.fluid_code.clear()
                     node.fluid_code.clear()
-                    node.fluid_code.add_layer("batch_norm",
-                                              inputs=input,
-                                              output=node,
-                                              param_attr=parent_param_attr)
+                    node.fluid_code.add_layer(
+                        "batch_norm",
+                        inputs=input,
+                        output=node,
+                        param_attr=parent_param_attr)
 
     def merge_op_activation(self):
         for node_name in self.graph.topo_sort:
@@ -62,7 +63,8 @@ class CaffeOptimizer(object):
                     if is_delete_node:
                         parent_node.fluid_code.clear()
                     node.fluid_code.clear()
-                    node.fluid_code.add_layer(op,
-                                              inputs=input,
-                                              output=node,
-                                              param_attr=parent_param_attr)
+                    node.fluid_code.add_layer(
+                        op,
+                        inputs=input,
+                        output=node,
+                        param_attr=parent_param_attr)

x2paddle/optimizer/tf_optimizer.py

@@ -554,10 +554,11 @@ class TFOptimizer(object):
                 node.fluid_code.layers[0].param_attr["shape"] = shape
                 node.fluid_code.layers[0].output = "nhwc_" + name
                 attr = {"perm": [0, 2, 3, 1]}
-                node.fluid_code.add_layer("transpose",
-                                          inputs="nhwc_" + name,
-                                          output=node,
-                                          param_attr=attr)
+                node.fluid_code.add_layer(
+                    "transpose",
+                    inputs="nhwc_" + name,
+                    output=node,
+                    param_attr=attr)
                 self.graph.input_nodes[i] = "nhwc_" + name
         for i, name in enumerate(self.graph.output_nodes):
             node = self.graph.get_node(name)
@@ -767,8 +768,8 @@ class TFOptimizer(object):
                     is_prelu = False
                     continue
 
-                if len(in_nodes0[0].outputs) != 1 or len(
-                        in_nodes0[1].outputs) != 1:
+                if len(in_nodes0[0].outputs) != 1 or len(in_nodes0[1]
+                                                         .outputs) != 1:
                     is_prelu = False
                     continue
 
@@ -777,8 +778,8 @@ class TFOptimizer(object):
                     self.graph.get_node(in_name)
                     for in_name in in_nodes0[1].inputs
                 ]
-                if in_nodes2[1].layer_type != "Const" or numpy.fabs(
-                        in_nodes2[1].value - 0.5) > 1e-06:
+                if in_nodes2[1].layer_type != "Const" or numpy.fabs(in_nodes2[
+                        1].value - 0.5) > 1e-06:
                     is_prelu = False
                     continue
                 if in_nodes2[0].layer_type != "Mul":
@@ -787,8 +788,8 @@ class TFOptimizer(object):
                 if exist_act(in_nodes2[0]):
                     is_prelu = False
                     continue
-                if len(in_nodes2[1].outputs) != 1 or len(
-                        in_nodes2[0].outputs) != 1:
+                if len(in_nodes2[1].outputs) != 1 or len(in_nodes2[0]
+                                                         .outputs) != 1:
                     is_prelu = False
                     continue
 
@@ -803,8 +804,8 @@ class TFOptimizer(object):
                 if exist_act(in_nodes3[1]):
                     is_prelu = False
                     continue
-                if len(in_nodes3[0].outputs) != 1 or len(
-                        in_nodes3[1].outputs) != 1:
+                if len(in_nodes3[0].outputs) != 1 or len(in_nodes3[1]
+                                                         .outputs) != 1:
                     is_prelu = False
                     continue
 
@@ -856,12 +857,12 @@ class TFOptimizer(object):
                     mode = "element"
                 elif len(in_nodes3[0].value.shape) == 0:
                     mode = "all"
-                elif len(in_nodes3[0].value.shape
-                         ) == 1 and in_nodes3[0].value.shape[0] == 1:
+                elif len(in_nodes3[0].value.shape) == 1 and in_nodes3[
+                        0].value.shape[0] == 1:
                     mode = "all"
-                elif len(in_shape) == 4 and len(
-                        in_nodes3[0].value.shape
-                ) == 1 and in_nodes3[0].value.shape[0] == in_shape[-1]:
+                elif len(in_shape) == 4 and len(in_nodes3[
+                        0].value.shape) == 1 and in_nodes3[0].value.shape[
+                            0] == in_shape[-1]:
                     mode = "channel"
                     weight = self.op_mapper.weights[in_nodes3[0].layer_name]
                     weight = numpy.expand_dims(weight, 0)
@@ -916,14 +917,15 @@ class TFOptimizer(object):
                     self.graph.get_node(in_name) for in_name in node.inputs
                 ]
                 if in_nodes0[0].layer_type != "Mul" or in_nodes0[
-                        1].layer_type != "Const" or in_nodes0[1].value.size != 1:
+                        1].layer_type != "Const" or in_nodes0[
+                            1].value.size != 1:
                     is_scale = False
                     continue
                 if exist_act(in_nodes0[0]):
                     is_scale = False
                     continue
-                if len(in_nodes0[0].outputs) != 1 or len(
-                        in_nodes0[1].outputs) != 1:
+                if len(in_nodes0[0].outputs) != 1 or len(in_nodes0[1]
+                                                         .outputs) != 1:
                     is_scale = False
                     continue
 
@@ -939,8 +941,8 @@ class TFOptimizer(object):
                 if exist_act(in_nodes1[1]):
                     is_scale = False
                     continue
-                if len(in_nodes1[0].outputs) != 1 or len(
-                        in_nodes1[1].outputs) != 1:
+                if len(in_nodes1[0].outputs) != 1 or len(in_nodes1[1]
+                                                         .outputs) != 1:
                     is_scale = False
                     continue
 
@@ -962,8 +964,8 @@ class TFOptimizer(object):
                     scale = 1.0 / in_nodes2[1].value * in_nodes1[0].value
                     act = None
                     if node.fluid_code.layers[0].param_attr is not None:
-                        act = node.fluid_code.layers[0].param_attr.get(
-                            "act", None)
+                        act = node.fluid_code.layers[0].param_attr.get("act",
+                                                                       None)
                     node.fluid_code.clear()
 
                     attr = {
@@ -972,10 +974,8 @@ class TFOptimizer(object):
                         "bias_after_scale": True,
                         "act": act
                     }
-                    node.fluid_code.add_layer("scale",
-                                              inputs=in_node,
-                                              output=node,
-                                              param_attr=attr)
+                    node.fluid_code.add_layer(
+                        "scale", inputs=in_node, output=node, param_attr=attr)
 
                     del self.graph.node_map[in_nodes0[0].layer_name]
                     del self.graph.node_map[in_nodes0[1].layer_name]
@@ -1004,17 +1004,17 @@ class TFOptimizer(object):
                 if exist_act(in_nodes0[0]):
                     is_affine_channel = False
                     continue
-                if len(in_nodes0[0].outputs) != 1 or len(
-                        in_nodes0[1].outputs) != 1:
+                if len(in_nodes0[0].outputs) != 1 or len(in_nodes0[1]
+                                                         .outputs) != 1:
                     is_affine_channel = False
                     continue
                 in_nodes1 = [
                     self.graph.get_node(in_name)
                     for in_name in in_nodes0[0].inputs
                 ]
-                if len(in_nodes1[0].out_shapes[0]
-                       ) != 4 or in_nodes1[1].layer_type != "Const" or len(
-                           in_nodes1[1].value.shape) != 3:
+                if len(in_nodes1[0].out_shapes[0]) != 4 or in_nodes1[
+                        1].layer_type != "Const" or len(in_nodes1[1]
+                                                        .value.shape) != 3:
                     is_affine_channel = False
                     continue
                 if len(in_nodes1[1].outputs) != 1:
@@ -1037,8 +1037,8 @@ class TFOptimizer(object):
                     node.layer_type = "AffineChannel"
                     node.inputs = [in_node.layer_name]
                     scale = 1.0 / in_nodes0[1].value.flatten()
-                    bias = in_nodes1[1].value.flatten(
-                    ) / in_nodes0[1].value.flatten()
+                    bias = in_nodes1[1].value.flatten() / in_nodes0[
+                        1].value.flatten()
                     if not bias_add:
                         bias *= -1.0
                     self.op_mapper.weights[node.layer_name + "_scale"] = scale
@@ -1046,8 +1046,8 @@ class TFOptimizer(object):
 
                     act = None
                     if node.fluid_code.layers[0].param_attr is not None:
-                        act = node.fluid_code.layers[0].param_attr.get(
-                            "act", None)
+                        act = node.fluid_code.layers[0].param_attr.get("act",
+                                                                       None)
                     node.fluid_code.clear()
 
                     attr = {
@@ -1055,29 +1055,32 @@ class TFOptimizer(object):
                         "shape": [channel],
                         "name": string(node.layer_name + "_scale")
                     }
-                    node.fluid_code.add_layer("create_parameter",
-                                              inputs=None,
-                                              output=node.layer_name + "_scale",
-                                              param_attr=attr)
+                    node.fluid_code.add_layer(
+                        "create_parameter",
+                        inputs=None,
+                        output=node.layer_name + "_scale",
+                        param_attr=attr)
                     attr = {
                         "dtype": string(scale.dtype),
                         "shape": [channel],
                         "name": string(node.layer_name + "_bias")
                     }
-                    node.fluid_code.add_layer("create_parameter",
-                                              inputs=None,
-                                              output=node.layer_name + "_bias",
-                                              param_attr=attr)
+                    node.fluid_code.add_layer(
+                        "create_parameter",
+                        inputs=None,
+                        output=node.layer_name + "_bias",
+                        param_attr=attr)
                     inputs = {
                         "x": in_node,
                         "scale": node.layer_name + "_scale",
                         "bias": node.layer_name + "_bias"
                     }
                     attr = {"act": act}
-                    node.fluid_code.add_layer("affine_channel",
-                                              inputs=inputs,
-                                              output=node,
-                                              param_attr=attr)
+                    node.fluid_code.add_layer(
+                        "affine_channel",
+                        inputs=inputs,
+                        output=node,
+                        param_attr=attr)
 
                     del self.graph.node_map[in_nodes0[0].layer_name]
                     del self.graph.node_map[in_nodes0[1].layer_name]