modify code format

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/core/fluid_code.py

@@ -46,8 +46,8 @@ 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 +71,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

@@ -34,8 +34,8 @@ class CaffeResolver(object):
             if not os.path.isfile(self.caffe_proto):
                 raise Exception(
                     "The .py file compiled by caffe.proto is not exist.")
-            (filepath,
-             tempfilename) = os.path.split(os.path.abspath(self.caffe_proto))
+            (filepath, tempfilename) = os.path.split(
+                os.path.abspath(self.caffe_proto))
             (filename, extension) = os.path.splitext(tempfilename)
             sys.path.append(filepath)
             out = __import__(filename)
@@ -49,13 +49,13 @@ 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 +268,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 = []
 

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

@@ -120,18 +120,19 @@ def convolutiondepthwise_layer(inputs,
             dila_len)
     c_in = input_shape[0][1]
     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)
+    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)
     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/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_shape.py

@@ -67,10 +67,10 @@ def get_strided_kernel_output_shape(params, input_shape, round_func):
     i_w = input_shape[3]
     dila_h, dila_w, pad_h, pad_w, kernel_h, kernel_w, stride_h, stride_w = get_kernel_parameters(
         params)
-    o_h = (i_h + 2 * pad_h - (dila_h *
-                              (kernel_h - 1) + 1)) / float(stride_h) + 1
-    o_w = (i_w + 2 * pad_w - (dila_w *
-                              (kernel_w - 1) + 1)) / float(stride_w) + 1
+    o_h = (i_h + 2 * pad_h -
+           (dila_h * (kernel_h - 1) + 1)) / float(stride_h) + 1
+    o_w = (i_w + 2 * pad_w -
+           (dila_w * (kernel_w - 1) + 1)) / float(stride_w) + 1
     o_h = int(round_func(o_h))
     o_w = int(round_func(o_w))
     has_c_o = hasattr(params, 'num_output')

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/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)
@@ -972,10 +973,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]
@@ -1055,29 +1054,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]