Added Conv Pooling padding can be int tuple or str.

Author: Laicheng0830

tensorlayerx/backend/ops/mindspore_nn.py

@@ -44,11 +44,41 @@ def padding_format(padding):
         padding = "valid"
     elif padding == None:
         padding = None
+    elif isinstance(padding, tuple) or isinstance(padding, int):
+        return padding
     else:
         raise Exception("Unsupported padding: " + str(padding))
     return padding
 
 
+def preprocess_padding(padding, dim='2d'):
+    check_padding(padding, dim)
+    if dim == '1d':
+        out_padding = (0, 0, padding, padding)
+    elif dim == '2d':
+        if isinstance(padding, tuple):
+            out_padding = (padding[0], padding[0], padding[1], padding[1])
+        else:
+            out_padding = padding
+    elif dim == '3d':
+        if isinstance(padding, tuple):
+            out_padding = (padding[0], padding[0], padding[1], padding[1], padding[2], padding[2])
+        else:
+            out_padding = padding
+    else:
+        raise RuntimeError("Unsupported input dimensions.")
+    return out_padding
+
+
+def check_padding(padding, dim='2d'):
+    if dim == '1d' and isinstance(object, tuple):
+        raise RuntimeError("expected padding to be a single integer value or a list of 1 values to match the convolution dimensions.")
+    if dim == '2d' and isinstance(padding, tuple) and len(padding) > 2:
+        raise RuntimeError("expected padding to be a single integer value or a list of 2 values to match the convolution dimensions.")
+    if dim == '3d' and isinstance(padding, tuple) and len(padding) > 3:
+        raise RuntimeError("expected padding to be a single integer value or a list of 3 values to match the convolution dimensions.")
+
+
 def preprocess_1d_format(data_format, padding):
     """
     Checks that the 1-D dataformat format correspond format.
@@ -458,20 +488,24 @@ def bias_add(x, bias):
     """
     raise NotImplementedError
 
-
 class Conv1D(Cell):
 
     def __init__(self, stride, padding, data_format='NWC', dilations=None, out_channel=None, k_size=None):
         super(Conv1D, self).__init__()
-        self.data_format, self.padding = preprocess_1d_format(data_format, padding)
+        self.data_format, self.pad_mode = preprocess_1d_format(data_format, padding)
+        self.padding = 0
         self.stride = (1, stride)
         self.dilations = (1, dilations)
         self.k_size = (1, k_size)
         self.out_channel = out_channel
 
+        if isinstance(self.pad_mode, int):
+            self.padding = preprocess_padding(self.pad_mode, '1d')
+            self.pad_mode = "pad"
+
         self.conv2d = P.Conv2D(
-            out_channel=self.out_channel, kernel_size=self.k_size, pad_mode=self.padding, stride=self.stride,
-            dilation=self.dilations, mode=1, group=1
+            out_channel=self.out_channel, kernel_size=self.k_size, pad_mode=self.pad_mode, pad=self.padding,
+            stride=self.stride, dilation=self.dilations, mode=1, group=1
         )
 
         self.expand_dims = P.ExpandDims()
@@ -528,16 +562,21 @@ class Conv2D(Cell):
 
     def __init__(self, strides, padding, data_format='NHWC', dilations=None, out_channel=None, k_size=None):
         super(Conv2D, self).__init__()
-        self.data_format, self.padding = preprocess_2d_format(data_format, padding)
+        self.data_format, self.pad_mode = preprocess_2d_format(data_format, padding)
+        self.padding = 0
         if self.data_format is 'NHWC':
             self._stride = (strides[1], strides[2])
             self._dilation = (dilations[1], dilations[2])
         elif self.data_format is 'NCHW':
             self._stride = (strides[2], strides[3])
             self._dilation = (dilations[2], dilations[3])
 
+        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.conv2d = P.Conv2D(
-            out_channel=out_channel, kernel_size=k_size, pad_mode=self.padding, stride=self._stride,
+            out_channel=out_channel, kernel_size=k_size, pad_mode=self.pad_mode, pad=self.padding, stride=self._stride,
             dilation=self._dilation, mode=1, group=1, data_format=self.data_format
         )
 
@@ -578,8 +617,8 @@ class Conv3D(Cell):
 
     def __init__(self, strides, padding, data_format='NDHWC', dilations=None, out_channel=None, k_size=None):
         super(Conv3D, self).__init__()
-        self.data_format, self.padding = preprocess_3d_format(data_format, padding)
-
+        self.data_format, self.pad_mode = preprocess_3d_format(data_format, padding)
+        self.padding = 0
         if self.data_format is 'NDHWC':
             self.ms_stride = (strides[1], strides[2], strides[3])
             self.ms_dilation = (dilations[1], dilations[2], dilations[3])
@@ -588,9 +627,13 @@ def __init__(self, strides, padding, data_format='NDHWC', dilations=None, out_ch
             self.ms_stride = (strides[2], strides[3], strides[4])
             self.ms_dilation = (dilations[2], dilations[3], dilations[4])
 
+        if isinstance(self.pad_mode, int) or isinstance(self.pad_mode, tuple):
+            self.padding = preprocess_padding(self.pad_mode, '3d')
+            self.pad_mode = "pad"
+
         self.conv3d = P.Conv3D(
-            out_channel=out_channel, kernel_size=k_size, pad_mode=self.padding, stride=self.ms_stride,
-            dilation=self.ms_dilation, data_format=data_format
+            out_channel=out_channel, kernel_size=k_size, pad_mode=self.pad_mode, pad=self.padding, stride=self.ms_stride,
+            dilation=self.ms_dilation, data_format=self.data_format
         )
 
     def construct(self, input, filters):

tensorlayerx/backend/ops/paddle_nn.py

@@ -35,6 +35,8 @@ def padding_format(padding):
         padding = "VALID"
     elif padding == None:
         padding = None
+    elif isinstance(padding, tuple) or isinstance(padding, int):
+        return padding
     else:
         raise Exception("Unsupported padding: " + str(padding))
     return padding

tensorlayerx/backend/ops/tensorflow_nn.py

@@ -34,11 +34,62 @@ def padding_format(padding):
         padding = "VALID"
     elif padding == None:
         padding = None
+    elif isinstance(padding, tuple) or isinstance(padding, int):
+        return padding
     else:
         raise Exception("Unsupported padding: " + str(padding))
     return padding
 
 
+def preprocess_padding(padding, dim='2d', data_format='NHWC'):
+    # When explicit padding is used and data_format is "NHWC",
+    # this should be in the form [[0, 0], [pad_top, pad_bottom],[pad_left, pad_right], [0, 0]].
+    # When explicit padding used and data_format is "NCHW",
+    # this should be in the form [[0, 0], [0, 0],[pad_top, pad_bottom], [pad_left, pad_right]].
+    check_padding(padding, dim)
+    if dim == '1d':
+        if data_format == 'NWC':
+            out_padding = [[0, 0], [padding, padding], [0, 0]]
+        else:
+            out_padding = [[0, 0], [0, 0], [padding, padding]]
+    elif dim == '2d':
+        if isinstance(padding, int):
+            if data_format == 'NHWC':
+                out_padding = [[0, 0], [padding, padding], [padding, padding], [0, 0]]
+            else:
+                out_padding = [[0, 0], [0, 0],[padding, padding], [padding, padding]]
+        elif isinstance(padding, tuple):
+            if data_format == 'NHWC':
+                out_padding = [[0, 0], [padding[0], padding[0]], [padding[1], padding[1]], [0, 0]]
+            else:
+                out_padding = [[0, 0], [0, 0],[padding[0], padding[0]], [padding[1], padding[1]]]
+    elif dim == '3d':
+        if isinstance(padding, int):
+            if data_format == 'NDHWC':
+                out_padding = [[0, 0], [padding, padding], [padding, padding], [padding, padding], [0, 0]]
+            else:
+                out_padding = [[0, 0], [0, 0], [padding, padding], [padding, padding], [padding, padding]]
+        elif isinstance(padding, tuple):
+            if data_format == 'NDHWC':
+                out_padding = [[0, 0], [padding[0], padding[0]], [padding[1], padding[1]], [padding[2], padding[2]], [0, 0]]
+            else:
+                out_padding = [[0, 0], [0, 0], [padding[0], padding[0]], [padding[1], padding[1]], [padding[2], padding[2]]]
+    else:
+        raise RuntimeError("Unsupported input dimensions.")
+    return out_padding
+
+
+def check_padding(padding, dim='2d'):
+    if dim == '1d' and isinstance(object, tuple):
+        raise RuntimeError("expected padding to be a single integer value or a list of 1 values to match the convolution dimensions.")
+    if dim == '2d' and isinstance(object, tuple) and len(padding) > 2:
+        raise RuntimeError("expected padding to be a single integer value or a list of 2 values to match the convolution dimensions.")
+    if dim == '3d' and isinstance(object, tuple) and len(padding) > 3:
+        raise RuntimeError("expected padding to be a single integer value or a list of 3 values to match the convolution dimensions.")
+
+
+
+
 def preprocess_1d_format(data_format, padding):
     """
     Checks that the 1-D dataformat format correspond format.
@@ -438,8 +489,16 @@ def __init__(self, stride, padding, data_format='NWC', dilations=None, out_chann
         self.stride = stride
         self.dilations = dilations
         self.data_format, self.padding = preprocess_1d_format(data_format, padding)
+        self.pad_value = None
+
+        if isinstance(padding, int):
+            self.pad_value = preprocess_padding(self.padding, '1d', self.data_format)
+            self.padding = 'VALID'
+
 
     def __call__(self, input, filters):
+        if self.pad_value is not None:
+            input = tf.pad(input, paddings=self.pad_value)
         outputs = tf.nn.conv1d(
             input=input,
             filters=filters,
@@ -501,6 +560,9 @@ def __init__(self, strides, padding, data_format='NHWC', dilations=None, out_cha
         self.dilations = dilations
         self.data_format, self.padding = preprocess_2d_format(data_format, padding)
 
+        if isinstance(padding, int) or isinstance(padding, tuple):
+            self.padding = preprocess_padding(self.padding, '2d', self.data_format)
+
     def __call__(self, input, filters):
         outputs = tf.nn.conv2d(
             input=input,
@@ -559,8 +621,15 @@ def __init__(self, strides, padding, data_format='NDHWC', dilations=None, out_ch
         self.strides = strides
         self.dilations = dilations
         self.data_format, self.padding = preprocess_3d_format(data_format, padding)
+        self.pad_value = None
+
+        if isinstance(padding, int) or isinstance(padding, tuple):
+            self.pad_value = preprocess_padding(self.padding, '3d', self.data_format)
+            self.padding = 'VALID'
 
     def __call__(self, input, filters):
+        if self.pad_value is not None:
+            input = tf.pad(input, paddings=self.pad_value)
         outputs = tf.nn.conv3d(
             input=input,
             filters=filters,
@@ -676,8 +745,14 @@ def __init__(self, ksize, strides, padding, data_format=None):
         self.data_format, self.padding = preprocess_1d_format(data_format=data_format, padding=padding)
         self.ksize = ksize
         self.strides = strides
+        self.padding_value = None
+        if not isinstance(self.padding, str):
+            self.padding_value = preprocess_padding(self.padding, '1d', self.data_format)
+            self.padding = "VALID"
 
     def __call__(self, inputs):
+        if self.padding_value is not None:
+            inputs = tf.pad(inputs, self.padding_value)
         outputs = tf.nn.max_pool(
             input=inputs, ksize=self.ksize, strides=self.strides, padding=self.padding, data_format=self.data_format
         )
@@ -695,10 +770,22 @@ def __init__(self, ksize, strides, padding, data_format=None):
     def __call__(self, inputs):
         if len(inputs.shape) == 3:
             self.data_format, self.padding = preprocess_1d_format(data_format=self.data_format, padding=self.padding)
+            if not isinstance(self.padding, str):
+                self.padding_value = preprocess_padding(self.padding, '1d', self.data_format)
+                self.padding = "VALID"
+                inputs = tf.pad(inputs, self.padding_value)
         elif len(inputs.shape) == 4:
             self.data_format, self.padding = preprocess_2d_format(data_format=self.data_format, padding=self.padding)
+            if not isinstance(self.padding, str):
+                self.padding_value = preprocess_padding(self.padding, '2d', self.data_format)
+                self.padding = "VALID"
+                inputs = tf.pad(inputs, self.padding_value)
         elif len(inputs.shape) == 5:
             self.data_format, self.padding = preprocess_3d_format(data_format=self.data_format, padding=self.padding)
+            if not isinstance(self.padding, str):
+                self.padding_value = preprocess_padding(self.padding, '3d', self.data_format)
+                self.padding = "VALID"
+                inputs = tf.pad(inputs, self.padding_value)
 
         outputs = tf.nn.max_pool(
             input=inputs, ksize=self.ksize, strides=self.strides, padding=self.padding, data_format=self.data_format
@@ -749,8 +836,14 @@ def __init__(self, ksize, strides, padding, data_format=None):
         self.data_format, self.padding = preprocess_1d_format(data_format=data_format, padding=padding)
         self.ksize = ksize
         self.strides = strides
+        self.padding_value = None
+        if not isinstance(self.padding, str):
+            self.padding_value = preprocess_padding(self.padding, '1d', self.data_format)
+            self.padding = "VALID"
 
     def __call__(self, inputs):
+        if self.padding_value is not None:
+            inputs = tf.pad(inputs, self.padding_value)
         outputs = tf.nn.pool(
             input=inputs,
             window_shape=self.ksize,
@@ -769,8 +862,14 @@ def __init__(self, ksize, strides, padding, data_format=None):
         self.strides = strides
         self.data_format = data_format
         self.padding = padding_format(padding)
+        self.padding_value = None
+        if not isinstance(self.padding, str):
+            self.padding_value = preprocess_padding(self.padding, '2d', self.data_format)
+            self.padding = "VALID"
 
     def __call__(self, inputs):
+        if self.padding_value is not None:
+            inputs = tf.pad(inputs, self.padding_value)
         outputs = tf.nn.avg_pool(
             input=inputs, ksize=self.ksize, strides=self.strides, padding=self.padding, data_format=self.data_format
         )
@@ -819,8 +918,14 @@ def __init__(self, ksize, strides, padding, data_format=None):
         self.data_format, self.padding = preprocess_3d_format(data_format, padding)
         self.ksize = ksize
         self.strides = strides
+        self.padding_value = None
+        if not isinstance(self.padding, str):
+            self.padding_value = preprocess_padding(self.padding, '3d', self.data_format)
+            self.padding = "VALID"
 
     def __call__(self, inputs):
+        if self.padding_value is not None:
+            inputs = tf.pad(inputs, self.padding_value)
         outputs = tf.nn.max_pool3d(
             input=inputs,
             ksize=self.ksize,
@@ -876,8 +981,14 @@ def __init__(self, ksize, strides, padding, data_format=None):
         self.data_format, self.padding = preprocess_3d_format(data_format, padding)
         self.ksize = ksize
         self.strides = strides
+        self.padding_value = None
+        if not isinstance(self.padding, str):
+            self.padding_value = preprocess_padding(self.padding, '3d', self.data_format)
+            self.padding = "VALID"
 
     def __call__(self, inputs):
+        if self.padding_value is not None:
+            inputs = tf.pad(inputs, self.padding_value)
         outputs = tf.nn.avg_pool3d(
             input=inputs,
             ksize=self.ksize,

tensorlayerx/backend/ops/torch_nn.py

@@ -27,6 +27,8 @@ def padding_format(padding):
         padding = "valid"
     elif padding == None:
         padding = None
+    elif isinstance(padding, tuple) or isinstance(padding, int):
+        return padding
     else:
         raise Exception("Unsupported padding: " + str(padding))
     return padding
@@ -798,17 +800,17 @@ def __call__(self, inputs):
             if self.padding in ['SAME', 'same']:
                 out = self.maxpool1d_same_padding(inputs)
             else:
-                out = F.max_pool1d(inputs, self.ksize, self.strides)
+                out = F.max_pool1d(inputs, self.ksize, self.strides, padding=self.padding)
         if len(inputs.shape) == 4:
             if self.padding in ['SAME', 'same']:
                 out = self.maxpool2d_same_padding(inputs)
             else:
-                out = F.max_pool2d(inputs, self.ksize, (self.strides[1], self.strides[2]))
+                out = F.max_pool2d(inputs, self.ksize, (self.strides[1], self.strides[2]), padding=self.padding)
         if len(inputs.shape) == 5:
             if self.padding in ['SAME', 'same']:
                 out = self.maxpool3d_same_padding(inputs)
             else:
-                out = F.max_pool3d(inputs, self.ksize, (self.strides[1], self.strides[2], self.strides[3]))
+                out = F.max_pool3d(inputs, self.ksize, (self.strides[1], self.strides[2], self.strides[3]), padding=self.padding)
 
         if self.data_format == 'channels_last':
             return nchw_to_nhwc(out)
@@ -900,17 +902,17 @@ def __call__(self, inputs):
             if self.padding in ['SAME', 'same']:
                 out = self.avgpool1d_same_padding(inputs)
             else:
-                out = F.avg_pool1d(inputs, self.ksize, self.strides)
+                out = F.avg_pool1d(inputs, self.ksize, self.strides, padding=self.padding)
         if len(inputs.shape) == 4:
             if self.padding in ['SAME', 'same']:
                 out = self.avgpool2d_same_padding(inputs)
             else:
-                out = F.avg_pool2d(inputs, self.ksize, (self.strides[1], self.strides[2]))
+                out = F.avg_pool2d(inputs, self.ksize, (self.strides[1], self.strides[2]), padding=self.padding)
         if len(inputs.shape) == 5:
             if self.padding in ['SAME', 'same']:
                 out = self.avgpool3d_same_padding(inputs)
             else:
-                out = F.avg_pool3d(inputs, self.ksize, (self.strides[1], self.strides[2], self.strides[3]))
+                out = F.avg_pool3d(inputs, self.ksize, (self.strides[1], self.strides[2], self.strides[3]), padding=self.padding)
 
         if self.data_format == 'channels_last':
             return nchw_to_nhwc(out)

tensorlayerx/nn/core/common.py

@@ -526,7 +526,7 @@ def construct_graph(inputs, outputs):
 def select_attrs(obj):
     attrs_dict = obj.__dict__
     attrs = {}
-    _select_key = ['kernel_size', 'stride', 'act', 'padding', 'data_format', 'concat_dim']
+    _select_key = ['kernel_size', 'stride', 'act', 'padding', 'data_format', 'concat_dim', 'dilation', 'bias']
     for k in _select_key:
         if k in attrs_dict:
             if k == 'act':