Update depthwise parameters compatiable with multiple backends (#12)

Author: Laicheng0830

tensorlayerx/backend/ops/mindspore_nn.py

@@ -1000,21 +1000,25 @@ def pool(input, window_shape, pooling_type, strides=None, padding='VALID', data_
 
 class DepthwiseConv2d(Cell):
 
-    def __init__(self, strides, padding, data_format=None, dilations=None, ksize=None, channel_multiplier=1):
+    def __init__(self, strides, padding, data_format=None, dilations=None, ksize=None, channel_multiplier=1, in_channels=None):
         super(DepthwiseConv2d, self).__init__()
-        self.data_format, self.padding = preprocess_2d_format(data_format, padding)
-        self.ms_stride = strides[1]
-        self.ms_dilation = dilations[1]
-        self.depthwise_conv2d = P.DepthwiseConv2dNative(
-            channel_multiplier=channel_multiplier, kernel_size=ksize, stride=self.ms_stride, dilation=self.ms_dilation
-        )
+        self.data_format, self.pad_mode = preprocess_2d_format(data_format, padding)
+        self.ms_stride = strides
+        self.ms_dilation = dilations
+        self.padding = 0
+
+        if isinstance(self.pad_mode, int) or isinstance(self.pad_mode, tuple):
+            self.padding = preprocess_padding(self.pad_mode, '2d')
+            self.pad_mode = "pad"
+
+        self.depth_conv = P.Conv2D(stride=self.ms_stride, pad_mode=self.pad_mode, pad=self.padding, kernel_size=ksize,
+                                   data_format=self.data_format, dilation=self.ms_dilation, group=in_channels, out_channel=in_channels)
+        self.point_conv = P.Conv2D(pad_mode=self.pad_mode, pad=self.padding, dilation=self.ms_dilation, kernel_size=1,
+                                   out_channel=channel_multiplier*in_channels, data_format=self.data_format)
 
     def construct(self, input, filter, point_filter=None):
-        if self.data_format == 'NHWC':
-            input = nhwc_to_nchw(input)
-        outputs = self.depthwise_conv2d(input, filter)
-        if self.data_format == 'NHWC':
-            outputs = nchw_to_nhwc(outputs)
+        outputs = self.depth_conv(input, filter)
+        outputs = self.point_conv(outputs, point_filter)
         return outputs
 
 

tensorlayerx/backend/ops/paddle_nn.py

@@ -897,22 +897,15 @@ def pool(input, window_shape, pooling_type, strides=None, padding='VALID', data_
 
 class DepthwiseConv2d(object):
 
-    def __init__(self, strides, padding, data_format=None, dilations=None, ksize=None, channel_multiplier=1):
+    def __init__(self, strides, padding, data_format=None, dilations=None, ksize=None, channel_multiplier=1, in_channels=None):
         self.data_format, self.padding = preprocess_2d_format(data_format, padding)
-        if self.data_format == 'NHWC':
-            self._stride = (strides[1], strides[2])
-        if self.data_format == 'NCHW':
-            self._stride = (strides[2], strides[3])
+        self._stride = strides
         self.dilations = dilations
-        self.channel_multiplier = channel_multiplier
+        self.in_channel = in_channels
 
     def __call__(self, input, filter, point_filter=None):
-        if self.data_format == 'NHWC':
-            channel = input.shape[-1]
-        elif self.data_format == 'NCHW':
-            channel = input.shape[1]
         depthwise_conv = F.conv2d(
-            input, filter, data_format=self.data_format, groups=channel, dilation=self.dilations, stride=self._stride,
+            input, filter, data_format=self.data_format, groups=self.in_channel, dilation=self.dilations, stride=self._stride,
             padding=self.padding
         )
         pointwise_conv = F.conv2d(depthwise_conv, point_filter, data_format=self.data_format, padding=self.padding)

tensorlayerx/backend/ops/tensorflow_nn.py

@@ -1098,23 +1098,29 @@ def pool(input, window_shape, pooling_type, strides=None, padding='VALID', data_
 
 class DepthwiseConv2d(object):
 
-    def __init__(self, strides, padding, data_format=None, dilations=None, ksize=None, channel_multiplier=1):
+    def __init__(self, strides, padding, data_format=None, dilations=None, ksize=None, channel_multiplier=1, in_channels=None):
         self.data_format, self.padding = preprocess_2d_format(data_format, padding)
         self.strides = strides
         self.dilations = dilations
+        self.depthwise_conv = GroupConv2D(strides=self.strides, padding=self.padding, data_format=self.data_format,
+                                          out_channel=None, k_size=None, dilations=self.dilations, groups=in_channels)
 
     def __call__(self, input, filter, point_filter=None):
-        outputs = tf.nn.depthwise_conv2d(
-            input=input,
-            filter=filter,
-            strides=self.strides,
-            padding=self.padding,
-            data_format=self.data_format,
-            dilations=self.dilations,
-        )
+        depthwise = self.depthwise_conv(input, filter)
+        outputs = tf.nn.conv2d(depthwise, point_filter, strides=1, padding=self.padding,
+                                  data_format=self.data_format, dilations=self.dilations)
+        # outputs = tf.nn.depthwise_conv2d(
+        #     input=input,
+        #     filter=filter,
+        #     strides=self.strides,
+        #     padding=self.padding,
+        #     data_format=self.data_format,
+        #     dilations=self.dilations,
+        # )
         return outputs
 
 
+
 def depthwise_conv2d(input, filter, strides, padding, data_format=None, dilations=None, name=None):
     """
     Depthwise 2-D convolution.

tensorlayerx/backend/ops/torch_nn.py

@@ -1104,25 +1104,22 @@ def pool(input, window_shape, pooling_type, strides=None, padding='VALID', data_
 
 class DepthwiseConv2d(object):
 
-    def __init__(self, strides, padding, data_format=None, dilations=None, ksize=None, channel_multiplier=1):
+    def __init__(self, strides, padding, data_format=None, dilations=None, ksize=None, channel_multiplier=1, in_channels=None):
         self.data_format, self.padding = preprocess_2d_format(data_format, padding)
-        if self.data_format == 'NHWC':
-            self._stride = (strides[1], strides[2])
-        if self.data_format == 'NCHW':
-            self._stride = (strides[2], strides[3])
-        self.dilations = dilations
+        if self.data_format is 'NHWC':
+            self.strides = (1, strides[0], strides[1], 1)
+            self.dilations = (1, dilations[0], dilations[1], 1)
+        elif self.data_format is 'NCHW':
+            self.strides = (1, 1, strides[0], strides[1])
+            self.dilations = (1, 1, dilations[0], dilations[1])
+        self.depthwise = Conv2D(padding=self.padding, strides=self.strides, data_format=self.data_format,
+                                dilations=self.dilations, groups=in_channels)
+        self.pointwise = Conv2D(strides=(1, 1, 1, 1), padding=self.padding, data_format=self.data_format, dilations=self.dilations, k_size=1)
 
     def __call__(self, input, filter, point_filter=None):
-        if self.data_format == 'NHWC':
-            input = nhwc_to_nchw(input)
-        channel = input.shape[1]
+        depthwise_conv = self.depthwise(input, filter)
+        pointwise_conv = self.pointwise(depthwise_conv, point_filter)
 
-        depthwise_conv = F.conv2d(input, filter, bias=None, stride=self._stride, padding=self.padding,
-                                  dilation=self.dilations, groups=channel)
-        pointwise_conv = F.conv2d(depthwise_conv, point_filter, padding=self.padding)
-
-        if self.data_format == 'NHWC':
-            pointwise_conv = nchw_to_nhwc(pointwise_conv)
         return pointwise_conv
 
 

tensorlayerx/nn/layers/convolution/depthwise_conv.py

@@ -4,7 +4,6 @@
 import tensorlayerx as tlx
 from tensorlayerx import logging
 from tensorlayerx.nn.core import Module
-from tensorlayerx.backend import BACKEND
 
 __all__ = [
     'DepthwiseConv2d',
@@ -80,9 +79,9 @@ def __init__(
     ):
         super().__init__(name, act=act)
         self.kernel_size = self.check_param(kernel_size)
-        self.stride = self._strides = self.check_param(stride)
+        self.stride = self.check_param(stride)
         self.padding = padding
-        self.dilation = self._dilation = self.check_param(dilation)
+        self.dilation = self.check_param(dilation)
         self.data_format = data_format
         self.depth_multiplier = depth_multiplier
         self.W_init = self.str_to_init(W_init)
@@ -122,34 +121,21 @@ def build(self, inputs_shape):
         if self.data_format == 'channels_last':
             if self.in_channels is None:
                 self.in_channels = inputs_shape[-1]
-            self._strides = [1, self._strides[0], self._strides[1], 1]
         elif self.data_format == 'channels_first':
             if self.in_channels is None:
                 self.in_channels = inputs_shape[1]
-            self._strides = [1, 1, self._strides[0], self._strides[1]]
         else:
             raise Exception("data_format should be either channels_last or channels_first")
 
-        self.filter_shape = (self.kernel_size[0], self.kernel_size[1], self.in_channels, self.depth_multiplier)
+        self.filter_depthwise = (self.kernel_size[0], self.kernel_size[1], 1, self.in_channels)
+        self.filter_pointwise = (1, 1, self.in_channels, self.in_channels * self.depth_multiplier)
 
-        # Set the size of kernel as (K1,K2), then the shape is (K,Cin,K1,K2), K must be 1.
-        if BACKEND == 'mindspore':
-            self.filter_shape = (self.kernel_size[0], self.kernel_size[1], self.in_channels, 1)
-
-        if BACKEND in ['tensorflow', 'mindspore']:
-            self.filters = self._get_weights("filters", shape=self.filter_shape, init=self.W_init, transposed=True)
-            self.point_filter = None
-        # TODO The number of parameters on multiple backends is not equal.
-        # TODO It might be better to use deepwise convolution and pointwise convolution for other backends as well.
-        if BACKEND in ['paddle', 'torch']:
-            self.filter_depthwise = (self.in_channels, 1, self.kernel_size[0], self.kernel_size[1])
-            self.filter_pointwise = (self.in_channels * self.depth_multiplier, self.in_channels, 1, 1)
-            self.filters = self._get_weights("filters", shape=self.filter_depthwise, init=self.W_init, order=True)
-            self.point_filter = self._get_weights("point_filter", shape=self.filter_pointwise, init=self.W_init, order=True)
+        self.filters = self._get_weights("filters", shape=self.filter_depthwise, init=self.W_init)
+        self.point_filter = self._get_weights("point_filter", shape=self.filter_pointwise, init=self.W_init)
 
         self.depthwise_conv2d = tlx.ops.DepthwiseConv2d(
-            strides=self._strides, padding=self.padding, data_format=self.data_format, dilations=self._dilation,
-            ksize=self.kernel_size, channel_multiplier=self.depth_multiplier
+            strides=self.stride, padding=self.padding, data_format=self.data_format, dilations=self.dilation,
+            ksize=self.kernel_size, channel_multiplier=self.depth_multiplier, in_channels=self.in_channels
         )
 
         self.b_init_flag = False

tests/layers/test_layers_convolution.py

@@ -157,7 +157,7 @@ def test_layer_n4(self):
         self.assertEqual(tlx.get_tensor_shape(self.n4), [self.batch_size, 100, 100, 32])
 
     def test_layer_n5(self):
-        self.assertEqual(len(self.dwconv2dlayer.all_weights), 2)
+        self.assertEqual(len(self.dwconv2dlayer.all_weights), 3)
         self.assertEqual(tlx.get_tensor_shape(self.n5), [self.batch_size, 100, 100, 64])
 
     def test_layer_n6(self):