fix the bug

x2paddle/decoder/caffe_decoder.py

@@ -171,6 +171,14 @@ class CaffeGraph(Graph):
         self.input2layers(input_layers)
         self.transform_input_layers(layers, input_layers)
         layers = input_layers + layers
+        for layer in layers:
+            if hasattr(layer, 'name'):
+                name = getattr(layer, 'name')
+                setattr(layer, 'name', name.replace('/', '_').replace('-', '_'))
+            for i, name in enumerate(layer.bottom):
+                layer.bottom[i] = name.replace('/', '_').replace('-', '_')
+            for i, name in enumerate(layer.top):
+                layer.top[i] = name.replace('/', '_').replace('-', '_')
 
         top_layer = {}
         for layer in layers:
@@ -232,10 +240,12 @@ class CaffeDecoder(object):
 
     def load_using_pb(self):
         data = self.resolver.NetParameter()
-
         data.MergeFromString(open(self.model_path, 'rb').read())
-        pair = lambda layer: (layer.name, self.normalize_pb_data(layer))
         layers = data.layers or data.layer
+        for layer in layers:
+            setattr(layer, 'name',
+                    layer.name.replace('/', '_').replace('-', '_'))
+        pair = lambda layer: (layer.name, self.normalize_pb_data(layer))
         self.params = [pair(layer) for layer in layers if layer.blobs]
 
     def normalize_pb_data(self, layer):
@@ -246,14 +256,13 @@ class CaffeDecoder(object):
                 if layer.type == 'PReLU':
                     c_o, c_i, h, w = map(int, [1] + \
                         list(dims) + [1]* (3 - len(dims)))
-                elif layer.type == 'Normalize':
+                elif layer.type == 'Normalize' and len(dims) == 4:
                     data = np.asarray(list(blob.data), dtype=np.float32)
                     transformed.append(data)
                     continue
                 else:
-                    c_o, c_i, h, w = map(int, [1] * (4 - len(dims)) \
-                        + list(dims))
-
+                    c_o, c_i, h, w = map(int,
+                                         [1] * (4 - len(dims)) + list(dims))
             else:
                 c_o = blob.num
                 c_i = blob.channels

x2paddle/op_mapper/caffe_custom_layer/detectionoutput.py

@@ -12,7 +12,6 @@ def detectionoutput_layer(inputs,
                           share_location=True,
                           keep_top_k=100,
                           confidence_threshold=0.1,
-                          num_classes=2,
                           input_shape=None,
                           name=None):
     nms_param_str = nms_param
@@ -37,9 +36,9 @@ def detectionoutput_layer(inputs,
     pb = fluid.layers.reshape(x=pb, shape=[-1, 4])
     pbv = fluid.layers.reshape(x=pbv, shape=[-1, 4])
     mbox_loc = inputs[0]
-    mbox_loc = fluid.layers.reshape(x=mbox_loc, shape=[0, -1, 4])
+    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, -1, num_classes])
+                                             shape=[0, pb.shape[0], -1])
 
     default = {"nms_threshold": 0.3, "top_k": 10, "eta": 1.0}
     fields = ['eta', 'top_k', 'nms_threshold']

x2paddle/op_mapper/caffe_shape.py

@@ -293,12 +293,15 @@ def shape_reshape(layer, input_shape):
             explicit_count *= count(l)
         for i in range(len(copy_axes)):
             explicit_count *= outshape[start_axis + copy_axes[i]]
-        outshape[start_axis + inferred_axis] = -1
-        outshape[0] = 0
-    else:
-        outshape[0] = -1
+        assert input_count % explicit_count == 0, "[Reshape]botom count[%d] "\
+                "must be divisible by product of the specified dimensions[%d] "\
+                % (input_count, explicit_count)
+        outshape[start_axis + inferred_axis] = int(input_count / explicit_count)
 
     output_count = count(outshape)
+    assert output_count == input_count, "[Reshape]output count[%d] must match input count[%d]" % (
+        output_count, input_count)
+    outshape[0] = -1
     return [outshape]
 
 
@@ -342,10 +345,9 @@ def shape_flatten(layer, input_shape):
     output_shape = inshape[0:start_axis]
     if len(inshape[start_axis:end_axis]) != 0:
         flat_sz = reduce(lambda a, b: a * b, inshape[start_axis:end_axis])
-        flat_sz = -1
-        output_shape[0] = 0
         output_shape += [flat_sz]
     output_shape += inshape[end_axis:len(inshape)]
+    output_shape[0] = -1
     return [output_shape]