Update unit test

Author: Laicheng0830

tensorlayerx/nn/layers/Transformer.py

@@ -513,9 +513,9 @@ def __init__(
         self._config.pop("self")
         self._config.pop("__class__", None)
         self.self_attn = MultiheadAttention(d_model, nhead, dropout=dropout, batch_first=batch_first)
-        self.linear1 = tlx.nn.layers.Dense(in_channels=d_model, n_units=dim_feedforward)
+        self.linear1 = tlx.nn.layers.Linear(in_features=d_model, out_features=dim_feedforward)
         self.dropout1 = tlx.nn.layers.Dropout(float(1.0 - dropout))
-        self.linear2 = tlx.nn.layers.Dense(in_channels=dim_feedforward, n_units=d_model)
+        self.linear2 = tlx.nn.layers.Linear(in_features=dim_feedforward, out_features=d_model)
 
         self.norm1 = tlx.nn.layers.LayerNorm(d_model, epsilon=layer_norm_eps)
         self.norm2 = tlx.nn.layers.LayerNorm(d_model, epsilon=layer_norm_eps)
@@ -614,8 +614,8 @@ def __init__(
         self.norm1 = tlx.nn.layers.LayerNorm(d_model, epsilon=layer_norm_eps)
         self.norm2 = tlx.nn.layers.LayerNorm(d_model, epsilon=layer_norm_eps)
         self.norm3 = tlx.nn.layers.LayerNorm(d_model, epsilon=layer_norm_eps)
-        self.linear1 = tlx.nn.layers.Dense(in_channels=d_model, n_units=dim_feedforward)
-        self.linear2 = tlx.nn.layers.Dense(in_channels=dim_feedforward, n_units=d_model)
+        self.linear1 = tlx.nn.layers.Linear(in_features=d_model, out_features=dim_feedforward)
+        self.linear2 = tlx.nn.layers.Linear(in_features=dim_feedforward, out_features=d_model)
 
         if act == 'relu':
             self.act = tlx.relu

tests/layers/test_layers_convolution.py

@@ -21,27 +21,27 @@ def setUpClass(self):
         self.inputs_shape = [self.batch_size, 100, 1]
         self.input_layer = tlx.nn.Input(self.inputs_shape, name='input_layer')
 
-        self.conv1dlayer1 = tlx.nn.Conv1d(in_channels=1, n_filter=32, filter_size=5, stride=2)
+        self.conv1dlayer1 = tlx.nn.Conv1d(in_channels=1, out_channels=32, kernel_size=5, stride=2)
         self.n1 = self.conv1dlayer1(self.input_layer)
 
-        self.conv1dlayer2 = tlx.nn.Conv1d(in_channels=32, n_filter=32, filter_size=5, stride=2)
+        self.conv1dlayer2 = tlx.nn.Conv1d(in_channels=32, out_channels=32, kernel_size=5, stride=2)
         self.n2 = self.conv1dlayer2(self.n1)
 
         self.dconv1dlayer1 = tlx.nn.DeConv1d(
-            n_filter=64, in_channels=32, filter_size=5, name='deconv1dlayer'
+            out_channels=64, in_channels=32, kernel_size=5, name='deconv1dlayer'
         )
         self.n3 = self.dconv1dlayer1(self.n2)
 
-        self.separableconv1d1 = tlx.nn.SeparableConv1d(in_channels=1, n_filter=16, filter_size=3, stride=2)
+        self.separableconv1d1 = tlx.nn.SeparableConv1d(in_channels=1, out_channels=16, kernel_size=3, stride=2)
         self.n4 = self.separableconv1d1(self.input_layer)
 
         self.separableconv1d2 = tlx.nn.SeparableConv1d(
-            in_channels=1, n_filter=16, filter_size=3, stride=2, depth_multiplier=4
+            in_channels=1, out_channels=16, kernel_size=3, stride=2, depth_multiplier=4
         )
         self.n5 = self.separableconv1d2(self.input_layer)
 
         self.separableconv1d3 = tlx.nn.SeparableConv1d(
-            in_channels=1, n_filter=16, filter_size=3, stride=2, depth_multiplier=4, b_init=None
+            in_channels=1, out_channels=16, kernel_size=3, stride=2, depth_multiplier=4, b_init=None
         )
         self.n6 = self.separableconv1d3(self.input_layer)
 
@@ -84,53 +84,53 @@ def setUpClass(self):
         self.input_layer = tlx.nn.Input(self.inputs_shape, name='input_layer')
 
         self.conv2dlayer1 = tlx.nn.Conv2d(
-            n_filter=32, in_channels=3, strides=(2, 2), filter_size=(5, 5), padding='SAME',
+            out_channels=32, in_channels=3, strides=(2, 2), kernel_size=(5, 5), padding='SAME',
             b_init=tensorlayerx.nn.initializers.truncated_normal(0.01), name='conv2dlayer'
         )
         self.n1 = self.conv2dlayer1(self.input_layer)
 
         self.conv2dlayer2 = tlx.nn.Conv2d(
-            n_filter=32, in_channels=32, filter_size=(3, 3), strides=(2, 2), act=None, name='conv2d'
+            out_channels=32, in_channels=32, kernel_size=(3, 3), strides=(2, 2), act=None, name='conv2d'
         )
         self.n2 = self.conv2dlayer2(self.n1)
 
         self.conv2dlayer3 = tlx.nn.Conv2d(
-            in_channels=32, n_filter=32, filter_size=(3, 3), strides=(2, 2), act=tlx.ReLU, b_init=None,
+            in_channels=32, out_channels=32, kernel_size=(3, 3), strides=(2, 2), act=tlx.ReLU, b_init=None,
             name='conv2d_no_bias'
         )
         self.n3 = self.conv2dlayer3(self.n2)
 
         self.dconv2dlayer = tlx.nn.DeConv2d(
-            n_filter=32, in_channels=32, filter_size=(5, 5), strides=(2, 2), name='deconv2dlayer'
+            out_channels=32, in_channels=32, kernel_size=(5, 5), strides=(2, 2), name='deconv2dlayer'
         )
         self.n4 = self.dconv2dlayer(self.n3)
 
         self.dwconv2dlayer = tlx.nn.DepthwiseConv2d(
-            in_channels=32, filter_size=(3, 3), strides=(1, 1), dilation_rate=(2, 2), act=tlx.ReLU, depth_multiplier=2,
+            in_channels=32, kernel_size=(3, 3), strides=(1, 1), dilation_rate=(2, 2), act=tlx.ReLU, depth_multiplier=2,
             name='depthwise'
         )
         self.n5 = self.dwconv2dlayer(self.n4)
 
         self.separableconv2d = tlx.nn.SeparableConv2d(
-            in_channels=3, filter_size=(3, 3), strides=(2, 2), dilation_rate=(2, 2), act=tlx.ReLU, depth_multiplier=3,
+            in_channels=3, kernel_size=(3, 3), strides=(2, 2), dilation_rate=(2, 2), act=tlx.ReLU, depth_multiplier=3,
             name='separableconv2d'
         )
         self.n6 = self.separableconv2d(self.input_layer)
 
         self.groupconv2d = tlx.nn.GroupConv2d(
-            in_channels=3, n_filter=18, filter_size=(3, 3), strides=(2, 2), dilation_rate=(3, 3), n_group=3,
+            in_channels=3, out_channels=18, kernel_size=(3, 3), strides=(2, 2), dilation_rate=(3, 3), n_group=3,
             act=tlx.ReLU, name='groupconv2d'
         )
         self.n7 = self.groupconv2d(self.input_layer)
 
         self.binaryconv2d = tlx.nn.BinaryConv2d(
-            in_channels=3, n_filter=32, filter_size=(3, 3), strides=(2, 2), dilation_rate=(2, 2), act=tlx.ReLU,
+            in_channels=3, out_channels=32, kernel_size=(3, 3), strides=(2, 2), dilation_rate=(2, 2), act=tlx.ReLU,
             name='binaryconv2d'
         )
         self.n8 = self.binaryconv2d(self.input_layer)
 
         self.dorefaconv2d = tlx.nn.DorefaConv2d(
-            bitA=2, bitW=8, in_channels=3, n_filter=16, filter_size=(3, 3), strides=(2, 2), dilation_rate=(2, 2),
+            bitA=2, bitW=8, in_channels=3, out_channels=16, kernel_size=(3, 3), strides=(2, 2), dilation_rate=(2, 2),
             act=tlx.ReLU, name='dorefaconv2d'
         )
         self.n9 = self.dorefaconv2d(self.input_layer)
@@ -188,17 +188,17 @@ def setUpClass(self):
         self.input_layer = tlx.nn.Input(self.inputs_shape, name='input_layer')
 
         self.conv3dlayer1 = tlx.nn.Conv3d(
-            n_filter=32, in_channels=3, filter_size=(2, 2, 2), strides=(2, 2, 2)
+            out_channels=32, in_channels=3, kernel_size=(2, 2, 2), strides=(2, 2, 2)
         )
         self.n1 = self.conv3dlayer1(self.input_layer)
 
         self.deconv3dlayer = tlx.nn.DeConv3d(
-            n_filter=128, in_channels=32, filter_size=(2, 2, 2), strides=(2, 2, 2)
+            out_channels=128, in_channels=32, kernel_size=(2, 2, 2), strides=(2, 2, 2)
         )
         self.n2 = self.deconv3dlayer(self.n1)
 
         self.conv3dlayer2 = tlx.nn.Conv3d(
-            n_filter=64, in_channels=128, filter_size=(3, 3, 3), strides=(3, 3, 3), act=tlx.ReLU, b_init=None,
+            out_channels=64, in_channels=128, kernel_size=(3, 3, 3), strides=(3, 3, 3), act=tlx.ReLU, b_init=None,
             name='conv3d_no_bias'
         )
         self.n3 = self.conv3dlayer2(self.n2)

tests/layers/test_layers_core_act.py

@@ -19,53 +19,53 @@ def setUpClass(self):
         self.input_layer = tlx.nn.Input(self.inputs_shape, name='input_layer')
 
         self.conv2dlayer1 = tlx.nn.Conv2d(
-            n_filter=32, in_channels=3, act=tlx.ReLU, filter_size=(5, 5), strides=(2, 2), padding='SAME',
+            out_channels=32, in_channels=3, act=tlx.ReLU, kernel_size=(5, 5), strides=(2, 2), padding='SAME',
             b_init=tensorlayerx.nn.initializers.constant(value=0.0), name='conv2dlayer'
         )
         self.n1 = self.conv2dlayer1(self.input_layer)
 
         self.conv2dlayer2 = tlx.nn.Conv2d(
-            n_filter=32, in_channels=32, filter_size=(3, 3), strides=(2, 2), act="relu", name='conv2d'
+            out_channels=32, in_channels=32, kernel_size=(3, 3), strides=(2, 2), act="relu", name='conv2d'
         )
         self.n2 = self.conv2dlayer2(self.n1)
 
         self.conv2dlayer3 = tlx.nn.Conv2d(
-            n_filter=32, in_channels=32, filter_size=(3, 3), strides=(2, 2), act="leaky_relu", b_init=None
+            out_channels=32, in_channels=32, kernel_size=(3, 3), strides=(2, 2), act="leaky_relu", b_init=None
         )
         self.n3 = self.conv2dlayer3(self.n2)
 
         self.conv2dlayer4 = tlx.nn.Conv2d(
-            n_filter=32, in_channels=32, filter_size=(3, 3), strides=(2, 2), act="lrelu", b_init=None
+            out_channels=32, in_channels=32, kernel_size=(3, 3), strides=(2, 2), act="lrelu", b_init=None
         )
         self.n4 = self.conv2dlayer4(self.n3)
 
         self.conv2dlayer5 = tlx.nn.Conv2d(
-            n_filter=32, in_channels=32, filter_size=(3, 3), strides=(2, 2), act="sigmoid"
+            out_channels=32, in_channels=32, kernel_size=(3, 3), strides=(2, 2), act="sigmoid"
         )
         self.n5 = self.conv2dlayer5(self.n4)
 
         self.conv2dlayer6 = tlx.nn.Conv2d(
-            n_filter=32, in_channels=32, filter_size=(3, 3), strides=(2, 2), act="tanh"
+            out_channels=32, in_channels=32, kernel_size=(3, 3), strides=(2, 2), act="tanh"
         )
         self.n6 = self.conv2dlayer6(self.n5)
 
         self.conv2dlayer7 = tlx.nn.Conv2d(
-            n_filter=32, filter_size=(3, 3), strides=(2, 2), act="leaky_relu0.22", in_channels=32
+            out_channels=32, kernel_size=(3, 3), strides=(2, 2), act="leaky_relu0.22", in_channels=32
         )
         self.n7 = self.conv2dlayer7(self.n6)
 
         self.conv2dlayer8 = tlx.nn.Conv2d(
-            n_filter=32, filter_size=(3, 3), strides=(2, 2), act="lrelu0.22", in_channels=32
+            out_channels=32, kernel_size=(3, 3), strides=(2, 2), act="lrelu0.22", in_channels=32
         )
         self.n8 = self.conv2dlayer8(self.n7)
 
         self.conv2dlayer9 = tlx.nn.Conv2d(
-            n_filter=32, filter_size=(3, 3), strides=(2, 2), act="softplus", in_channels=32
+            out_channels=32, kernel_size=(3, 3), strides=(2, 2), act="softplus", in_channels=32
         )
         self.n9 = self.conv2dlayer9(self.n8)
 
         self.conv2dlayer10 = tlx.nn.Conv2d(
-            n_filter=32, filter_size=(3, 3), strides=(2, 2), act="relu6", in_channels=32
+            out_channels=32, kernel_size=(3, 3), strides=(2, 2), act="relu6", in_channels=32
         )
         self.n10 = self.conv2dlayer10(self.n9)
 

tests/layers/test_layers_core_basedense_dropout.py

@@ -20,16 +20,16 @@ def setUpClass(self):
 
         self.inputs_shape = [self.batch_size, 784]
         self.input = tlx.nn.Input(self.inputs_shape)
-        self.dense1 = tlx.nn.Dense(n_units=800, act=tlx.ReLU, in_channels=784, name='test_dense')
+        self.dense1 = tlx.nn.Linear(out_features=800, act=tlx.ReLU, in_features=784, name='test_dense')
         self.n1 = self.dense1(self.input)
 
-        self.dropout1 = tlx.nn.Dropout(keep=0.8)
+        self.dropout1 = tlx.nn.Dropout(p=0.2)
         self.n2 = self.dropout1(self.n1)
 
-        self.dense2 = tlx.nn.Dense(n_units=10, act='relu', b_init=None, in_channels=800)
+        self.dense2 = tlx.nn.Linear(out_features=10, act='relu', b_init=None, in_features=800)
         self.n3 = self.dense2(self.n2)
 
-        self.dense3 = tlx.nn.Dense(n_units=10, act='relu', b_init=None, in_channels=10)
+        self.dense3 = tlx.nn.Linear(out_features=10, act='relu', b_init=None, in_features=10)
         self.n4 = self.dense3(self.n3)
 
         self.concat = tlx.nn.Concat(concat_dim=-1)([self.n2, self.n3])
@@ -38,10 +38,10 @@ class get_model(tensorlayerx.nn.Module):
 
             def __init__(self):
                 super(get_model, self).__init__()
-                self.layer1 = tlx.nn.Dense(n_units=800, act=tlx.ReLU, in_channels=784, name='test_dense')
-                self.dp = tlx.nn.Dropout(keep=0.8)
-                self.layer2 = tlx.nn.Dense(n_units=10, act='relu', b_init=None, in_channels=800)
-                self.layer3 = tlx.nn.Dense(n_units=10, act='relu', b_init=None, in_channels=10)
+                self.layer1 = tlx.nn.Linear(out_features=800, act=tlx.ReLU, in_features=784, name='test_dense')
+                self.dp = tlx.nn.Dropout(p=0.2)
+                self.layer2 = tlx.nn.Linear(out_features=10, act='relu', b_init=None, in_features=800)
+                self.layer3 = tlx.nn.Linear(out_features=10, act='relu', b_init=None, in_features=10)
 
             def forward(self, inputs):
                 z = self.layer1(inputs)

tests/layers/test_layers_core_nested.py

@@ -27,7 +27,7 @@ class MyLayer(tensorlayerx.nn.Module):
 
             def __init__(self, name=None):
                 super(MyLayer, self).__init__(name=name)
-                self.input_layer = tlx.nn.Dense(in_channels=50, n_units=20)
+                self.input_layer = tlx.nn.Linear(in_features=50, out_features=20)
                 self.build(None)
                 self._built = True
 

tests/layers/test_layers_deformable_convolution.py

@@ -21,17 +21,17 @@ def setUpClass(self):
         self.input_layer = tlx.nn.Input(self.inputs_shape, name='input_layer')
 
         self.offset1 = tlx.nn.Conv2d(
-            n_filter=18, filter_size=(3, 3), strides=(1, 1), padding='SAME', name='offset1'
+            out_channels=18, kernel_size=(3, 3), strides=(1, 1), padding='SAME', name='offset1'
         )(self.input_layer)
         self.init_deformconv1 = tlx.nn.DeformableConv2d(
-            offset_layer=self.offset1, n_filter=32, filter_size=(3, 3), act='relu', name='deformable1'
+            offset_layer=self.offset1, out_channels=32, kernel_size=(3, 3), act='relu', name='deformable1'
         )
         self.deformconv1 = self.init_deformconv1(self.input_layer)
         self.offset2 = tlx.nn.Conv2d(
-            n_filter=18, filter_size=(3, 3), strides=(1, 1), padding='SAME', name='offset2'
+            out_channels=18, kernel_size=(3, 3), strides=(1, 1), padding='SAME', name='offset2'
         )(self.deformconv1)
         self.deformconv2 = tlx.nn.DeformableConv2d(
-            offset_layer=self.offset2, n_filter=64, filter_size=(3, 3), act='relu', name='deformable2'
+            offset_layer=self.offset2, out_channels=64, kernel_size=(3, 3), act='relu', name='deformable2'
         )(self.deformconv1)
 
     @classmethod

tests/layers/test_layers_dense.py

@@ -20,9 +20,9 @@ def setUpClass(self):
         self.inputs_shape = [self.batch_size, 10]
 
         self.ni = tlx.nn.Input(self.inputs_shape, name='input_layer')
-        self.layer1 = tlx.nn.BinaryDense(n_units=5)
+        self.layer1 = tlx.nn.BinaryDense(out_features=5)
 
-        self.layer2 = tlx.nn.BinaryDense(n_units=5, in_channels=10)
+        self.layer2 = tlx.nn.BinaryDense(out_features=5, in_features=10)
 
         self.n1 = self.layer1(self.ni)
         self.n2 = self.layer2(self.ni)
@@ -49,8 +49,8 @@ def setUpClass(self):
         self.inputs_shape = [self.batch_size, 10]
 
         self.ni = tlx.nn.Input(self.inputs_shape, name='input_layer')
-        self.layer1 = tlx.nn.DorefaDense(n_units=5)
-        self.layer2 = tlx.nn.DorefaDense(n_units=5, in_channels=10)
+        self.layer1 = tlx.nn.DorefaDense(out_features=5)
+        self.layer2 = tlx.nn.DorefaDense(out_features=5, in_features=10)
 
         self.n1 = self.layer1(self.ni)
         self.n2 = self.layer2(self.ni)
@@ -75,9 +75,9 @@ def setUpClass(self):
         self.inputs_shape = [self.batch_size, 10]
 
         self.ni = tlx.nn.Input(self.inputs_shape, name='input_layer')
-        self.layer1 = tlx.nn.DropconnectDense(n_units=5, keep=1.0)
+        self.layer1 = tlx.nn.DropconnectDense(out_features=5, keep=1.0)
 
-        self.layer2 = tlx.nn.DropconnectDense(n_units=5, in_channels=10, keep=0.01)
+        self.layer2 = tlx.nn.DropconnectDense(out_features=5, in_features=10, keep=0.01)
 
         self.n1 = self.layer1(self.ni)
         self.n2 = self.layer2(self.ni)
@@ -102,9 +102,9 @@ def setUpClass(self):
         self.inputs_shape = [self.batch_size, 10]
 
         self.ni = tlx.nn.Input(self.inputs_shape, name='input_layer')
-        self.layer1 = tlx.nn.QuanDense(n_units=5)
+        self.layer1 = tlx.nn.QuanDense(out_features=5)
 
-        self.layer2 = tlx.nn.QuanDense(n_units=5, in_channels=10)
+        self.layer2 = tlx.nn.QuanDense(out_features=5, in_features=10)
 
         self.n1 = self.layer1(self.ni)
         self.n2 = self.layer2(self.ni)
@@ -129,8 +129,8 @@ def setUpClass(self):
         self.inputs_shape = [self.batch_size, 10]
 
         self.inputs = tensorlayerx.nn.initializers.TruncatedNormal()(shape=self.inputs_shape)
-        self.layer1 = tlx.nn.QuanDenseWithBN(n_units=5)
-        self.layer2 = tlx.nn.QuanDenseWithBN(n_units=5, in_channels=10)
+        self.layer1 = tlx.nn.QuanDenseWithBN(out_features=5)
+        self.layer2 = tlx.nn.QuanDenseWithBN(out_features=5, in_features=10)
 
         self.n1 = self.layer1(self.inputs)
         self.n2 = self.layer2(self.inputs)
@@ -155,8 +155,8 @@ def setUpClass(self):
         self.inputs_shape = [self.batch_size, 10]
 
         self.inputs = tlx.nn.Input(self.inputs_shape, name='input_layer')
-        self.layer1 = tlx.nn.TernaryDense(n_units=5)
-        self.layer2 = tlx.nn.TernaryDense(n_units=5, in_channels=10)
+        self.layer1 = tlx.nn.TernaryDense(out_features=5)
+        self.layer2 = tlx.nn.TernaryDense(out_features=5, in_features=10)
 
         self.n1 = self.layer1(self.inputs)
         self.n2 = self.layer2(self.inputs)

tests/layers/test_layers_extend.py

@@ -5,7 +5,6 @@
 import unittest
 
 os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
-import tensorlayerx
 import tensorlayerx as tlx
 
 from tests.utils import CustomTestCase