Merge pull request #163 from PaddlePaddle/develop

pull

x2paddle/convert.py

@@ -129,9 +129,12 @@ def caffe2paddle(proto, weight, save_dir, caffe_proto):
     from x2paddle.op_mapper.caffe_op_mapper import CaffeOpMapper
     from x2paddle.optimizer.caffe_optimizer import CaffeOptimizer
     import google.protobuf as gpb
-    ver_str = gpb.__version__.replace('.', '')
-    ver_int = int(ver_str[0:2])
-    assert ver_int >= 36, 'The version of protobuf must be larger than 3.6.0!'
+    ver_part = gpb.__version__.split('.')
+    version_satisfy = False
+    if (int(ver_part[0]) == 3 and int(ver_part[1]) >= 6) \
+        or (int(ver_part[0]) > 3):
+        version_satisfy = True
+    assert version_satisfy, 'google.protobuf >= 3.6.0 is required'
     print("Now translating model from caffe to paddle.")
     model = CaffeDecoder(proto, weight, caffe_proto)
     mapper = CaffeOpMapper(model)

x2paddle/op_mapper/caffe_custom_layer/shufflechannel.py

@@ -8,13 +8,7 @@ def shufflechannel_shape(input_shape):
 
 def shufflechannel_layer(inputs, group=None, input_shape=None, name=None):
     input = inputs[0]
-    c_fm = fluid.layers.split(input, num_or_sections=input_shape[0][1], dim=1)
-    size = int(input_shape[0][1] / group)
-    new_c_fm = []
-    for i in range(size):
-        for j in range(group):
-            new_c_fm.append(c_fm[j * size + i])
-    out = fluid.layers.concat(new_c_fm, axis=1)
+    out = fluid.layers.shuffle_channel(x=input, group=group)
     return out
 
 

x2paddle/op_mapper/caffe_op_mapper.py

@@ -363,7 +363,7 @@ class CaffeOpMapper(OpMapper):
         input = self.graph.get_bottom_node(node, idx=0, copy=True)
         attr = {
             'n': params.local_size,
-            'k': 1.0,
+            'k': params.k,
             'alpha': alpha,
             'beta': params.beta,
             'name': string(node.layer_name)
@@ -450,35 +450,19 @@ class CaffeOpMapper(OpMapper):
         slice_dim = params.slice_dim
         if slice_dim != 1 and axis == 1:
             axis = slice_dim
-        points = list(params.slice_point)
-
-        if len(points) == 0:
-            dims = node.input_shape[0][axis]
-            assert dims % top_len == 0, "the parameter of Slice is wrong"
-            part = dims / top_len
-            t = part
-            while t < dims:
-                points.append(int(t))
-                t += part
-        maxint32 = 2147483647
-        points = [0] + points
-        points.append(maxint32)
-        i = 0
-        node.fluid_code.add_note('{} = []'.format(node.layer_name))
-        for i in range(len(points)):
-            attr = {
-                'axes': [axis],
-                'starts': [points[i]],
-                'ends': [points[i + 1]]
-            }
-            node.fluid_code.add_layer("slice",
-                                      inputs=input,
-                                      output=node.layer_name + '_' + str(i),
-                                      param_attr=attr)
-            node.fluid_code.add_note('{}.append({})'.format(
-                node.layer_name, node.layer_name + '_' + str(i)))
-            if i == len(points) - 2:
-                break
+        output_shape = node.output_shape
+        sections_list = []
+        for s in output_shape:
+            sections_list.append(s[axis])
+        attr = {
+            'num_or_sections': sections_list,
+            'dim': axis,
+            'name': string(node.layer_name)
+        }
+        node.fluid_code.add_layer("split",
+                                  inputs=input,
+                                  output=node.layer_name,
+                                  param_attr=attr)
 
     def Concat(self, node):
         assert len(
@@ -649,7 +633,8 @@ class CaffeOpMapper(OpMapper):
             ]).astype('float32')
             scale = 0
         else:
-            node.data = [np.squeeze(i) for i in node.data]
+
+            node.data = [np.squeeze(i).astype('float32') for i in node.data]
             mean, variance, scale = node.data
         # Prescale the stats
         scaling_factor = 1.0 / scale if scale != 0 else 0
@@ -684,8 +669,10 @@ class CaffeOpMapper(OpMapper):
                 input_c,
             ]).astype('float32')
         else:
-            self.weights[node.layer_name + '_scale'] = np.squeeze(node.data[0])
-            self.weights[node.layer_name + '_offset'] = np.squeeze(node.data[1])
+            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

x2paddle/op_mapper/tf_op_mapper.py

@@ -168,7 +168,11 @@ class TFOpMapper(OpMapper):
                 x_input = y
                 y_input = x
                 x_shape = y.out_shapes[0]
+                if len(x_shape) == 0:
+                    x_shape = [1]
                 y_shape = x.out_shapes[0]
+                if len(y_shape) == 0:
+                    y_shape = [1]
             else:
                 if len(x_shape) == 1 and len(y_shape) == 4 and x_shape[
                         0] == y_shape[-1] and y_shape.count(-1) < 1:

x2paddle/op_mapper/tf_op_mapper_nhwc.py

@@ -121,10 +121,29 @@ class TFOpMapperNHWC(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)
+
+        if len(input.out_shapes[0]) == 4 and op_info[0] != 'shape':
+            attr1 = {"perm": [0, 3, 1, 2]}
+            node.fluid_code.add_layer('transpose',
+                                      inputs=input,
+                                      output=node,
+                                      param_attr=attr1)
+            input = node
+            node.fluid_code.add_layer(op_info[0],
+                                      inputs=input,
+                                      output=node,
+                                      param_attr=attr)
+            input = node
+            attr2 = {"perm": [0, 2, 3, 1]}
+            node.fluid_code.add_layer('transpose',
+                                      inputs=input,
+                                      output=node,
+                                      param_attr=attr2)
+        else:
+            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
@@ -149,7 +168,11 @@ class TFOpMapperNHWC(OpMapper):
                 x_input = y
                 y_input = x
                 x_shape = y.out_shapes[0]
+                if len(x_shape) == 0:
+                    x_shape = [1]
                 y_shape = x.out_shapes[0]
+                if len(y_shape) == 0:
+                    y_shape = [1]
             else:
                 raise Exception("Unexpected situation happend")
 
@@ -193,11 +216,30 @@ class TFOpMapperNHWC(OpMapper):
                                           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)
+        if len(x_shape) == 4 and len(y_shape) == 4:
+            node.fluid_code.add_layer("transpose",
+                                      inputs=x_input,
+                                      output=x_input,
+                                      param_attr={'perm': [0, 3, 1, 2]})
+            node.fluid_code.add_layer("transpose",
+                                      inputs=y_input,
+                                      output=y_input,
+                                      param_attr={'perm': [0, 3, 1, 2]})
+            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("transpose",
+                                      inputs=node,
+                                      output=node,
+                                      param_attr={'perm': [0, 2, 3, 1]})
+        else:
+            inputs = {"x": x_input, "y": y_input}
+            node.fluid_code.add_layer(op_type,
+                                      inputs=inputs,
+                                      output=node,
+                                      param_attr=None)
 
     def Placeholder(self, node):
         shape = node.out_shapes[0]
@@ -978,9 +1020,7 @@ class TFOpMapperNHWC(OpMapper):
 
         if pad_mode == "SAME":
             if node.tf_data_format == "NHWC":
-                print(out_shape)
                 out_shape = [out_shape[i] for i in [0, 3, 1, 2]]
-                print(out_shape)
             for i in range(4):
                 if out_shape[i] < 0:
                     out_shape[i] = 999999