add unit testing and fix quan_dense_bn

Author: Laicheng0830

tensorlayer/layers/convolution/quan_conv_bn.py

@@ -121,6 +121,10 @@ def __init__(
             )
         )
 
+        if self.in_channels:
+            self.build(None)
+            self._built = True
+
         if use_gemm:
             raise Exception("TODO. The current version use tf.matmul for inferencing.")
 

tensorlayer/layers/dense/__init__.py

@@ -24,5 +24,5 @@
     'DropconnectDense',
     'TernaryDense',
     'QuanDense',
-    'QuanDenseLayerWithBN',
+    'QuanDenseWithBN',
 ]

tensorlayer/layers/dense/quan_dense_bn.py

@@ -11,12 +11,12 @@
 from tensorlayer.layers.utils import (quantize_active_overflow, quantize_weight_overflow)
 
 __all__ = [
-    'QuanDenseLayerWithBN',
+    'QuanDenseWithBN',
 ]
 
 
-class QuanDenseLayerWithBN(Layer):
-    """The :class:`QuanDenseLayerWithBN` class is a quantized fully connected layer with BN, which weights are 'bitW' bits and the output of the previous layer
+class QuanDenseWithBN(Layer):
+    """The :class:`QuanDenseWithBN` class is a quantized fully connected layer with BN, which weights are 'bitW' bits and the output of the previous layer
     are 'bitA' bits while inferencing.
 
     Parameters
@@ -47,16 +47,19 @@ class QuanDenseLayerWithBN(Layer):
         The initializer for the the weight matrix.
     W_init_args : dictionary
         The arguments for the weight matrix initializer.
+    in_channels: int
+        The number of channels of the previous layer.
+        If None, it will be automatically detected when the layer is forwarded for the first time.
     name : a str
         A unique layer name.
 
     Examples
     ---------
     >>> import tensorlayer as tl
     >>> net = tl.layers.Input([50, 256])
-    >>> layer = tl.layers.QuanDenseLayerWithBN(128, act='relu', name='qdbn1')(net)
+    >>> layer = tl.layers.QuanDenseWithBN(128, act='relu', name='qdbn1')(net)
     >>> print(layer)
-    >>> net = tl.layers.QuanDenseLayerWithBN(256, act='relu', name='qdbn2')(net)
+    >>> net = tl.layers.QuanDenseWithBN(256, act='relu', name='qdbn2')(net)
     >>> print(net)
     """
 
@@ -74,9 +77,10 @@ def __init__(
         use_gemm=False,
         W_init=tl.initializers.truncated_normal(stddev=0.05),
         W_init_args=None,
+        in_channels=None,
         name=None,  # 'quan_dense_with_bn',
     ):
-        super(QuanDenseLayerWithBN, self).__init__(act=act, W_init_args=W_init_args, name=name)
+        super(QuanDenseWithBN, self).__init__(act=act, W_init_args=W_init_args, name=name)
         self.n_units = n_units
         self.decay = decay
         self.epsilon = epsilon
@@ -87,6 +91,11 @@ def __init__(
         self.beta_init = beta_init
         self.use_gemm = use_gemm
         self.W_init = W_init
+        self.in_channels = in_channels
+
+        if self.in_channels is not None:
+            self.build((None, self.in_channels))
+            self._built = True
 
         logging.info(
             "QuanDenseLayerWithBN  %s: %d %s" %
@@ -105,9 +114,12 @@ def __repr__(self):
         return s.format(classname=self.__class__.__name__, **self.__dict__)
 
     def build(self, inputs_shape):
-        if len(inputs_shape) != 2:
+        if self.in_channels is None and len(inputs_shape) != 2:
             raise Exception("The input dimension must be rank 2, please reshape or flatten it")
 
+        if self.in_channels is None:
+            self.in_channels = inputs_shape[1]
+
         if self.use_gemm:
             raise Exception("TODO. The current version use tf.matmul for inferencing.")
 

tensorlayer/layers/deprecated.py

@@ -91,6 +91,16 @@ def DropconnectDenseLayer(*args, **kwargs):
     raise NonExistingLayerError("DropconnectDenseLayer(net, name='a') --> DropconnectDense(name='a')(net)" + __log__)
 
 
+# dense/quan_dense_bn.py
+__all__ += [
+    'QuanDenseLayerWithBN',
+]
+
+
+def QuanDenseLayerWithBN(*args, **kwargs):
+    raise NonExistingLayerError("QuanDenseLayerWithBN(net, name='a') --> QuanDenseWithBN(name='a')(net)" + __log__)
+
+
 # dense/ternary_dense.py
 __all__ += [
     'TernaryDenseLayer',

tests/layers/test_layers_convolution.py

@@ -4,14 +4,14 @@
 import os
 import unittest
 
-import tensorflow as tf
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
 
+import tensorflow as tf
 import tensorlayer as tl
 from tensorlayer.layers import *
 from tensorlayer.models import *
-from tests.utils import CustomTestCase
 
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+from tests.utils import CustomTestCase
 
 
 class Layer_Convolution_1D_Test(CustomTestCase):
@@ -208,7 +208,11 @@ def setUpClass(cls):
 
         cls.n14 = tl.layers.SubpixelConv2d(scale=2, act=tf.nn.relu, name='subpixelconv2d')(cls.n13)
 
-        cls.model = Model(cls.input_layer, cls.n14)
+        cls.n15 = tl.layers.QuanConv2dWithBN(
+            n_filter=64, filter_size=(5, 5), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='quancnnbn2d'
+        )(cls.n14)
+
+        cls.model = Model(cls.input_layer, cls.n15)
         print("Testing Conv2d model: \n", cls.model)
 
         # cls.n12 = tl.layers.QuanConv2d(cls.n11, 64, (5, 5), (1, 1), act=tf.nn.relu, padding='SAME', name='quancnn')
@@ -321,6 +325,10 @@ def test_layer_n13(self):
     def test_layer_n14(self):
         self.assertEqual(self.n14.get_shape().as_list()[1:], [24, 24, 8])
 
+    def test_layer_n15(self):
+        self.assertEqual(len(self.n15._info[0].layer.all_weights), 5)
+        self.assertEqual(self.n15.get_shape().as_list()[1:], [24, 24, 64])
+
     # def test_layer_n8(self):
     #
     #     self.assertEqual(len(self.n8.all_layers), 9)

tests/layers/test_layers_dense.py

@@ -3,15 +3,15 @@
 import os
 import unittest
 
-import numpy as np
-import tensorflow as tf
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
 
+import tensorflow as tf
 import tensorlayer as tl
 from tensorlayer.layers import *
 from tensorlayer.models import *
-from tests.utils import CustomTestCase
 
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+from tests.utils import CustomTestCase
+import numpy as np
 
 
 class Layer_BinaryDense_Test(CustomTestCase):
@@ -243,6 +243,61 @@ def test_exception(self):
             print(e)
 
 
+class Layer_QuanDenseWithBN_Test(CustomTestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        print("-" * 20, "Layer_QuanDenseWithBN_Test", "-" * 20)
+        cls.batch_size = 4
+        cls.inputs_shape = [cls.batch_size, 10]
+
+        cls.ni = Input(cls.inputs_shape, name='input_layer')
+        cls.layer1 = QuanDenseWithBN(n_units=5)
+        nn = cls.layer1(cls.ni)
+        cls.layer1._nodes_fixed = True
+        cls.M = Model(inputs=cls.ni, outputs=nn)
+
+        cls.layer2 = QuanDenseWithBN(n_units=5, in_channels=10)
+        cls.layer2._nodes_fixed = True
+
+        cls.inputs = tf.random.uniform((cls.inputs_shape))
+        cls.n1 = cls.layer1(cls.inputs)
+        cls.n2 = cls.layer2(cls.inputs)
+        cls.n3 = cls.M(cls.inputs, is_train=True)
+
+        print(cls.layer1)
+        print(cls.layer2)
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def test_layer_n1(self):
+        print(self.n1[0])
+
+    def test_layer_n2(self):
+        print(self.n2[0])
+
+    def test_model_n3(self):
+        print(self.n3[0])
+
+    def test_exception(self):
+        try:
+            layer = QuanDenseWithBN(n_units=5)
+            inputs = Input([4, 10, 5], name='ill_inputs')
+            out = layer(inputs)
+            self.fail('ill inputs')
+        except Exception as e:
+            print(e)
+
+        try:
+            layer = QuanDenseWithBN(n_units=5, use_gemm=True)
+            out = layer(self.ni)
+            self.fail('use gemm')
+        except Exception as e:
+            print(e)
+
+
 class Layer_TernaryDense_Test(CustomTestCase):
 
     @classmethod