[Caffe Frontend] supporting group > 1 cases for Deconv op

python/tvm/relay/frontend/caffe.py

@@ -33,7 +33,7 @@
 
 
 class OperatorConverter(object):
-    """ Operator Converted for converting Caffe ops to Relay ops """
+    """Operator Converted for converting Caffe ops to Relay ops"""
 
     def __init__(self, init_layer_dict, predict_layer, exp_tab):
         self.init_layer_dict = init_layer_dict
@@ -66,7 +66,7 @@ def __init__(self, init_layer_dict, predict_layer, exp_tab):
         }
 
     def convert_flatten(self, op):
-        """ Convert Flatten layer """
+        """Convert Flatten layer"""
         inputs = op.bottom
         in_expr = self.exp_tab.get_expr(inputs[0])
 
@@ -77,7 +77,7 @@ def convert_flatten(self, op):
         return out
 
     def convert_eltwise(self, op):
-        """ Convert Eltwise layer """
+        """Convert Eltwise layer"""
         inputs = op.bottom
         assert len(inputs) == 2, "input tensors length should be 2"
 
@@ -115,7 +115,7 @@ def convert_eltwise(self, op):
         return out
 
     def _parse_conv_params(self, op):
-        """ Parse the parameters of Convolution and Deconvolution layer """
+        """Parse the parameters of Convolution and Deconvolution layer"""
         nonzone = lambda val, pos, dflt: val[pos] if pos < len(val) else dflt
 
         conv_params = op.convolution_param
@@ -160,7 +160,7 @@ def _parse_conv_params(self, op):
         return params
 
     def convert_batch_norm(self, op):
-        """ Convert BatchNorm layer """
+        """Convert BatchNorm layer"""
         inputs = op.bottom
         in_expr = self.exp_tab.get_expr(inputs[0])
         n, c, h, w = _infer_shape(in_expr)
@@ -215,7 +215,7 @@ def convert_batch_norm(self, op):
         return out[0]
 
     def convert_scale(self, op):
-        """ Convert Scale layer """
+        """Convert Scale layer"""
         inputs = op.bottom
         in_expr = self.exp_tab.get_expr(inputs[0])
         weight_bias_blobs = self.init_layer_dict[op.name].blobs
@@ -243,7 +243,7 @@ def convert_scale(self, op):
         return out
 
     def convert_concat(self, op):
-        """ Convert Concat layer """
+        """Convert Concat layer"""
         inputs = op.bottom
         in_expr = (self.exp_tab.get_expr(inputs[i]) for i in range(len(inputs)))
 
@@ -254,7 +254,7 @@ def convert_concat(self, op):
         return out
 
     def convert_reshape(self, op):
-        """ Convert Reshape layer """
+        """Convert Reshape layer"""
         inputs = op.bottom
         input_name = inputs[0]
 
@@ -294,7 +294,7 @@ def convert_reshape(self, op):
         return out
 
     def convert_softmax(self, op):
-        """ Convert Softmax layer """
+        """Convert Softmax layer"""
         inputs = op.bottom
         assert len(inputs) == 1, "input tensors length should be 1"
 
@@ -309,7 +309,7 @@ def convert_softmax(self, op):
         return out
 
     def convert_conv(self, op):
-        """ Convert Convolution layer """
+        """Convert Convolution layer"""
         params = self._parse_conv_params(op)
         weight_bias_blobs = self.init_layer_dict[op.name].blobs
         conv_params = op.convolution_param
@@ -339,7 +339,7 @@ def convert_conv(self, op):
         return out
 
     def convert_pooling(self, op):
-        """ Convert Pooling layer """
+        """Convert Pooling layer"""
         inputs = op.bottom
         input_name = inputs[0]
 
@@ -400,7 +400,7 @@ def convert_pooling(self, op):
         return out
 
     def convert_lrn(self, op):
-        """ Convert LRN layer """
+        """Convert LRN layer"""
         inputs = op.bottom
         input_name = inputs[0]
 
@@ -416,7 +416,7 @@ def convert_lrn(self, op):
         return out
 
     def convert_innerproduct(self, op):
-        """ Convert InnerProduct layer """
+        """Convert InnerProduct layer"""
         inputs = op.bottom
         weight_bias_blobs = self.init_layer_dict[op.name].blobs
         dense_params = op.inner_product_param
@@ -457,7 +457,7 @@ def convert_innerproduct(self, op):
         return out
 
     def convert_dropout(self, op):
-        """ Convert Dropout layer """
+        """Convert Dropout layer"""
         inputs = op.bottom
         input_name = inputs[0]
 
@@ -471,7 +471,7 @@ def convert_dropout(self, op):
         return out
 
     def convert_relu(self, op):
-        """ Convert ReLU layer """
+        """Convert ReLU layer"""
         inputs = op.bottom
         in_expr = self.exp_tab.get_expr(inputs[0])
         negative_slope = op.relu_param.negative_slope
@@ -483,7 +483,7 @@ def convert_relu(self, op):
         return out
 
     def convert_prelu(self, op):
-        """ Convert PReLU layer """
+        """Convert PReLU layer"""
         inputs = op.bottom
         in_expr = self.exp_tab.get_expr(inputs[0])
 
@@ -495,7 +495,7 @@ def convert_prelu(self, op):
         return out
 
     def convert_deconv(self, op):
-        """ Convert Deconvolution layer """
+        """Convert Deconvolution layer"""
         params = self._parse_conv_params(op)
         weight_bias_blobs = self.init_layer_dict[op.name].blobs
         conv_params = op.convolution_param
@@ -511,23 +511,76 @@ def convert_deconv(self, op):
         if weight:
             kh, kw = params["kernel_size"]
             weight_shape = [-1, conv_params.num_output, kh, kw]
-            weight_value = np.asarray(weight.data, np.float32)
+            if not weight.data:
+                if conv_params.weight_filler:
+                    _filler = conv_params.weight_filler.value
+                    weight_value = np.full(weight.shape.dim, _filler, np.float32)
+                else:
+                    raise tvm.error.OpAttributeInvalid("At least weight_filler must be given")
+            else:
+                weight_value = np.asarray(weight.data, np.float32)
             weight_value = np.reshape(weight_value, weight_shape)
         else:
-            raise Exception("No weight value of layer {} in caffemodel".format(op.name))
+            raise tvm.error.OpAttributeRequired(
+                "No weight value of layer {} in caffemodel".format(op.name)
+            )
 
         weight_expr = self.exp_tab.new_const(weight_value, dtype="float32")
         in_expr = self.exp_tab.get_expr(inputs[0])
-        out = _op.nn.conv2d_transpose(data=in_expr, weight=weight_expr, **params)
-        if bias:
 
+        groups = params["groups"]
+        channels = params["channels"]
+
+        if bias:
             bias_value = np.asarray(bias.data, np.float32)
             bias_expr = self.exp_tab.new_const(bias_value, dtype="float32")
-            out = _op.nn.bias_add(out, bias_expr)
+
+        if groups > channels:
+            raise tvm.error.OpAttributeInvalid(
+                "Groups cannot be larger than the number of input channels"
+            )
+
+        if groups == channels:
+            inputs_expr = _op.split(in_expr, groups, axis=1)
+            weights_expr = _op.split(weight_expr, groups, axis=1)
+            # Preventing to create Concat layer with too many tensors(> 16)
+            q = groups >> 4
+            r = groups % 16
+
+            params["groups"] = 1
+            params["channels"] = 1
+            out = []
+            for lc in range(q):
+                _outputs = []
+                _inputs = [inputs_expr[i] for i in range(lc << 4, (lc << 4) + 16)]
+                _weights = [weights_expr[i] for i in range(lc << 4, (lc << 4) + 16)]
+                for (i, w) in zip(_inputs, _weights):
+                    _out = _op.nn.conv2d_transpose(data=i, weight=w, **params)
+                    if bias:
+                        _out = _op.nn.bias_add(_out, bias_expr)
+                    _outputs.append(_out)
+                out.append(_op.concatenate(_outputs, axis=1))
+            if r != 0:
+                _outputs = []
+                _inputs = [inputs_expr[i] for i in range(groups - r, groups)]
+                _weights = [weights_expr[i] for i in range(groups - r, groups)]
+                for (i, w) in zip(_inputs, _weights):
+                    _out = _op.nn.conv2d_transpose(data=i, weight=w, **params)
+                    if bias:
+                        _out = _op.nn.bias_add(_out, bias_expr)
+                    _outputs.append(_out)
+                out.append(_op.concatenate(_outputs, axis=1))
+            out = _op.concatenate(out, axis=1)
+        elif groups == 1:
+            out = _op.nn.conv2d_transpose(data=in_expr, weight=weight_expr, **params)
+            if bias:
+                out = _op.nn.bias_add(out, bias_expr)
+        else:
+            raise tvm.error.OpAttributeInvalid("Unable to handle.")
         return out
 
     def convert_slice(self, op):
-        """ Convert Slice layer """
+        """Convert Slice layer"""
         inputs = op.bottom
         in_expr = self.exp_tab.get_expr(inputs[0])
 
@@ -545,21 +598,21 @@ def convert_slice(self, op):
         return out
 
     def convert_sigmoid(self, op):
-        """ Convert Sigmoid layer """
+        """Convert Sigmoid layer"""
         inputs = op.bottom
         in_expr = self.exp_tab.get_expr(inputs[0])
         out = _op.sigmoid(in_expr)
         return out
 
     def convert_tanh(self, op):
-        """ Convert TanH layer """
+        """Convert TanH layer"""
         inputs = op.bottom
         in_expr = self.exp_tab.get_expr(inputs[0])
         out = _op.tanh(in_expr)
         return out
 
     def convert_crop(self, op):
-        """ Convert Crop layer """
+        """Convert Crop layer"""
         inputs = op.bottom
         assert len(inputs) == 2, "Need two inputs of Crop layer"
         in_expr_a = self.exp_tab.get_expr(inputs[0])
@@ -615,7 +668,7 @@ def check_unsupported_ops(self):
             raise tvm.error.OpNotImplemented(msg.format(ops))
 
     def fuse_op(self, layers):
-        """ Fusing the BatchNorm and Scale layer """
+        """Fusing the BatchNorm and Scale layer"""
         bn, scale = layers["bn"], layers["scale"]
 
         # bn params
@@ -641,7 +694,7 @@ def fuse_op(self, layers):
         return bn
 
     def op_fuse(self):
-        """fuse bn and scale """
+        """fuse bn and scale"""
         new_layers = []
         temp_layers = {}
         changed_layers = {}

tests/python/frontend/caffe/test_forward.py

@@ -452,6 +452,33 @@ def test_forward_Deconvolution():
             bias_filler=dict(type="xavier"),
         ),
     )
+    _test_deconvolution(
+        data,
+        convolution_param=dict(
+            num_output=16,
+            bias_term=False,
+            pad=0,
+            kernel_size=2,
+            stride=2,
+            dilation=1,
+            group=16,
+            weight_filler=dict(type="xavier"),
+            bias_filler=dict(type="xavier"),
+        ),
+    )
+    data = np.random.rand(1, 100, 32, 32).astype(np.float32)
+    _test_deconvolution(
+        data,
+        convolution_param=dict(
+            num_output=100,
+            bias_term=False,
+            pad=0,
+            kernel_size=2,
+            stride=2,
+            dilation=1,
+            group=100,
+        ),
+    )
 
 
 #######################################################################