Merge pull request #66 from buddhapuneeth/master

Unit tests for 'layers' module

tests/layers/test_abstract.py

@@ -0,0 +1,114 @@
+import unittest
+import numpy
+import theano
+from yann.layers.abstract import layer as l,_dropout,_activate
+from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams
+
+try:
+    from unittest.mock import Mock
+except ImportError:
+    from mock import Mock,patch
+
+
+class TestAbstract(unittest.TestCase):
+
+    def setUp(self):
+        numpy.random.seed(0)
+        self.verbose = 3
+        self.abstract_layer_name = "input"
+        self.dropout_rate = 1
+        self.rng = None
+        self.mean_subtract = False
+        self.input_shape = (1,1,10,10)
+        self.input_ndarray = numpy.random.rand(1,1,10,10)
+        self.output_dropout_ndarray= numpy.zeros((1,1,10,10))
+        self.input_tensor = theano.shared(self.input_ndarray)
+        self.exception_msg = "'NoneType' object is not iterable"
+        self.rng = numpy.random
+        self.rs = RandomStreams(self.rng.randint(1,2147462468))
+        self.sample_input = numpy.ones((1, 1, 3, 3))
+
+    def test1_abstract_layer(self):
+        self.layer = l(
+                id = self.abstract_layer_name,
+                type= "input",
+                verbose = self.verbose)
+        self.attributes = self.layer._graph_attributes()
+        self.assertEqual(self.attributes['id'], self.abstract_layer_name)
+
+    def test2_abstract_layer_exception(self):
+        try:
+            self.layer = l(
+                id = self.abstract_layer_name,
+                type= "input",
+                verbose = self.verbose)
+            self.params = self.layer.get_params()
+        except Exception,c:
+            self.assertEqual(c.message,self.exception_msg)
+
+    @patch('yann.layers.abstract.RandomStreams')
+    @patch('yann.layers.abstract.RandomStreams.binomial')
+    def test3_abstract_layer_dropout(self,mock_binomial,mock_random_streams):
+        mock_random_streams.return_value = self.rs
+        mock_binomial.return_value = self.sample_input
+        self.out = _dropout(rng = self.rng,
+                                   params = self.sample_input,
+                                   dropout_rate = self.dropout_rate)
+        self.assertTrue(numpy.allclose(self.out,self.sample_input))
+
+
+    @patch('yann.layers.abstract.activations.ReLU')
+    def test4_abstract_layer_activate_relu(self,mock_relu):
+        mock_relu.return_value = self.input_ndarray
+        self.out,self.out_shape = _activate(self.input_ndarray,"relu",self.input_shape,self.verbose)
+        self.assertTrue(numpy.allclose(self.out,self.input_ndarray))
+
+    @patch('yann.layers.abstract.activations.Abs')
+    def test5_abstract_layer_activate_abs(self,mock_abs):
+        mock_abs.return_value = self.input_ndarray
+        self.out,self.out_shape = _activate(self.input_ndarray,"abs",self.input_shape,self.verbose)
+        self.assertTrue(numpy.allclose(self.out,self.input_ndarray))
+
+    @patch('yann.layers.abstract.activations.Sigmoid')
+    def test6_abstract_layer_activate_sigmoid(self,mock_sigmoid):
+        mock_sigmoid.return_value = self.input_ndarray
+        self.out,self.out_shape = _activate(self.input_ndarray,"sigmoid",self.input_shape,self.verbose)
+        self.assertTrue(numpy.allclose(self.out,self.input_ndarray))
+
+
+    @patch('yann.layers.abstract.activations.Tanh')
+    def test7_abstract_layer_activate_tanh(self,mock_tanh):
+        mock_tanh.return_value = self.input_ndarray
+        self.out,self.out_shape = _activate(self.input_ndarray,"tanh",self.input_shape,self.verbose)
+        self.assertTrue(numpy.allclose(self.out,self.input_ndarray))
+
+    @patch('yann.layers.abstract.activations.Softmax')
+    def test8_abstract_layer_activate_softmax(self,mock_softmax):
+        mock_softmax.return_value = self.input_ndarray
+        self.out,self.out_shape = _activate(self.input_ndarray,"softmax",self.input_shape,self.verbose)
+        self.assertTrue(numpy.allclose(self.out,self.input_ndarray))
+
+    @patch('yann.layers.abstract.activations.Squared')
+    def test9_abstract_layer_activate_squared(self,mock_squared):
+        mock_squared.return_value = self.input_ndarray
+        self.out,self.out_shape = _activate(self.input_ndarray,"squared",self.input_shape,self.verbose)
+        self.assertTrue(numpy.allclose(self.out,self.input_ndarray))
+
+
+    @patch('yann.layers.abstract.activations.Maxout')
+    def test10_abstract_layer_activate_maxout_tuple(self,mock_maxout):
+        mock_maxout.return_value = (self.input_ndarray,self.input_shape)
+        self.out,self.out_shape = _activate(self.input_ndarray,("maxout","type",self.input_shape),self.input_shape,self.verbose,**{'dimension':(10,10)})
+        self.assertTrue(numpy.allclose(self.out,self.input_ndarray))
+
+    @patch('yann.layers.abstract.activations.ReLU')
+    def test11_abstract_layer_activate_relu_tuple(self,mock_relu):
+        mock_relu.return_value = self.input_ndarray
+        self.out,self.out_shape = _activate(self.input_ndarray,("relu",1),self.input_shape,self.verbose)
+        self.assertTrue(numpy.allclose(self.out,self.input_ndarray))
+
+    @patch('yann.layers.abstract.activations.Softmax')
+    def test12_abstract_layer_activate_softmax_tuple(self,mock_softmax):
+        mock_softmax.return_value = self.input_ndarray
+        self.out,self.out_shape = _activate(self.input_ndarray,("softmax",1),self.input_shape,self.verbose)
+        self.assertTrue(numpy.allclose(self.out,self.input_ndarray))

tests/layers/test_batch_norm.py

@@ -0,0 +1,168 @@
+# dropout_batch_norm_layer_2d and 1d has issue with borrow
+import unittest
+import numpy
+import theano
+from yann.layers.batch_norm import batch_norm_layer_2d as bn
+from yann.layers.batch_norm import dropout_batch_norm_layer_2d as dbn
+from yann.layers.batch_norm import batch_norm_layer_1d as bn1
+from yann.layers.batch_norm import dropout_batch_norm_layer_1d as dbn1
+try:
+    from unittest.mock import Mock
+except ImportError:
+    from mock import Mock,patch
+
+
+
+class TestBtachNorm2d(unittest.TestCase):
+    def setUp(self):
+        self.verbose = 3
+        self.channels = 1
+        self.mean_subtract = False
+        self.rng = None
+        self.borrow = True
+        self.input_shape = (1,1,10,10)
+        self.input_ndarray = numpy.random.rand(1,1,10,10)
+        self.output_dropout_ndarray= numpy.zeros((1,1,10,10))
+        self.output_test = numpy.zeros((1,1,10,10))
+        self.output_train = numpy.ones((1,1,10,10))
+        self.input_tensor = theano.shared(self.input_ndarray)
+        self.gamma = theano.shared(value=numpy.ones((self.channels,),dtype=theano.config.floatX), name = 'gamma', borrow = self.borrow)
+        self.beta = theano.shared(value=numpy.zeros((self.channels,),dtype=theano.config.floatX), name = 'beta', borrow=self.borrow)
+        self.running_mean = theano.shared(value=numpy.zeros((self.channels,), dtype=theano.config.floatX), name = 'population_mean', borrow = self.borrow)
+        self.running_var = theano.shared(value=numpy.ones((self.channels,),dtype=theano.config.floatX), name = 'population_var', borrow=self.borrow)
+        self.input_params = (self.gamma, self.beta, self.running_mean, self.running_var)
+        self.batch_norm_layer_name = "bn"
+        self.batch_norm_layer_name_val = "bnv"
+        self.dropout_batch_norm_layer_2 ="dbn"
+        self.batch_norm_layer_name_1 = "bn1"
+        self.batch_norm_layer_name_val_1 = "bnv1"
+        self.dropout_batch_norm_layer_1 ="dbn1"
+        self.dropout_rate = 1
+        self.default_param_value = [1.]
+        self.custom_param_value = [1., 1.,1.]
+
+    @patch('theano.tensor.unbroadcast')
+    @patch('yann.layers.batch_norm.batch_normalization_test')
+    @patch('yann.layers.batch_norm.batch_normalization_train')
+    def test1_batch_norm_layer_2d(self,mock_batch_normalization_train,mock_batch_normalization_test,mock_unbroadcast):
+        mock_unbroadcast.return_value = 1
+        mock_batch_normalization_train.return_value = (self.output_train,1,1,1,1)
+        mock_batch_normalization_test.return_value =self.output_test
+        self.batch_norm_layer_2d = bn(
+                            input = self.input_tensor,
+                            id = self.batch_norm_layer_name,
+                            input_shape = self.input_shape,
+                            rng = self.rng,
+                            borrow = self.borrow,
+                            input_params = None,
+                            verbose = self.verbose
+        )
+        self.assertEqual(self.batch_norm_layer_2d.id,self.batch_norm_layer_name)
+        self.assertEqual(self.batch_norm_layer_2d.input_shape,self.input_shape)
+        self.assertEqual(self.batch_norm_layer_2d.output_shape,self.input_shape)
+        self.assertTrue(numpy.allclose(self.batch_norm_layer_2d.output,self.output_train))
+        self.assertTrue(numpy.allclose(self.batch_norm_layer_2d.inference,self.output_test))
+
+    @patch('theano.tensor.unbroadcast')
+    @patch('yann.layers.batch_norm.batch_normalization_test')
+    @patch('yann.layers.batch_norm.batch_normalization_train')
+    def test2_batch_norm_layer_2d_with_values(self,mock_batch_normalization_train,mock_batch_normalization_test,mock_unbroadcast):
+        mock_unbroadcast.return_value = 1
+        mock_batch_normalization_train.return_value = (self.output_train,1,1,1,1)
+        mock_batch_normalization_test.return_value =self.output_test
+        self.batch_norm_layer_2d_val = bn(
+                            input = self.input_tensor,
+                            id = self.batch_norm_layer_name_val,
+                            input_shape = self.input_shape,
+                            rng = self.rng,
+                            borrow = self.borrow,
+                            input_params = self.input_params,
+                            verbose = self.verbose
+        )
+
+        self.assertEqual(self.batch_norm_layer_2d_val.id,self.batch_norm_layer_name_val)
+        self.assertEqual(self.batch_norm_layer_2d_val.input_shape,self.input_shape)
+        self.assertEqual(self.batch_norm_layer_2d_val.output_shape,self.input_shape)
+        self.assertTrue(numpy.allclose(self.batch_norm_layer_2d_val.output,self.output_train))
+        self.assertTrue(numpy.allclose(self.batch_norm_layer_2d_val.inference,self.output_test))
+
+    # @patch('yann.layers.batch_norm._dropout')
+    # def test3_dropout_batch_norm_layer_2d(self,mock_dropout):
+    #     mock_dropout.return_value = self.input_ndarray
+    #     self.dropout_batch_norm_layer_2d = dbn(
+    #                         input = self.input_tensor,
+    #                         id = self.dropout_batch_norm_layer_2,
+    #                         input_shape = self.input_shape,
+    #                         rng = self.rng,
+    #                         input_params = None,
+    #                         dropout_rate= self.dropout_rate,
+    #                         verbose = self.verbose
+    #     )
+    #     self.assertTrue(numpy.allclose(self.dropout_batch_norm_layer_2d.output, self.input_ndarray))
+    #     self.assertEqual(self.dropout_batch_norm_layer_2d.output_shape,self.input_ndarray.shape)
+    #     self.assertEqual(self.dropout_batch_norm_layer_2d.id,self.dropout_batch_norm_layer_2)
+
+    @patch('theano.tensor.unbroadcast')
+    @patch('yann.layers.batch_norm.batch_normalization_test')
+    @patch('yann.layers.batch_norm.batch_normalization_train')
+    def test4_batch_norm_layer_1d(self,mock_batch_normalization_train,mock_batch_normalization_test,mock_unbroadcast):
+        mock_unbroadcast.return_value = 1
+        mock_batch_normalization_train.return_value = (self.output_train,1,1,1,1)
+        mock_batch_normalization_test.return_value =self.output_test
+        self.batch_norm_layer_1d = bn1(
+                            input = self.input_tensor,
+                            id = self.batch_norm_layer_name_1,
+                            input_shape = self.input_shape,
+                            rng = self.rng,
+                            borrow = self.borrow,
+                            input_params = None,
+                            verbose = self.verbose
+        )
+        self.assertEqual(self.batch_norm_layer_1d.id,self.batch_norm_layer_name_1)
+        self.assertEqual(self.batch_norm_layer_1d.input_shape,self.input_shape)
+        self.assertEqual(self.batch_norm_layer_1d.output_shape,self.input_shape)
+        self.assertTrue(numpy.allclose(self.batch_norm_layer_1d.output,self.output_train))
+        self.assertTrue(numpy.allclose(self.batch_norm_layer_1d.inference,self.output_test))
+
+
+    @patch('theano.tensor.unbroadcast')
+    @patch('yann.layers.batch_norm.batch_normalization_test')
+    @patch('yann.layers.batch_norm.batch_normalization_train')
+    def test5_batch_norm_layer_1d_with_values(self,mock_batch_normalization_train,mock_batch_normalization_test,mock_unbroadcast):
+        mock_unbroadcast.return_value = 1
+        mock_batch_normalization_train.return_value = (self.output_train,1,1,1,1)
+        mock_batch_normalization_test.return_value =self.output_test
+        self.batch_norm_layer_1d = bn1(
+                            input = self.input_tensor,
+                            id = self.batch_norm_layer_name_val_1,
+                            input_shape = self.input_shape,
+                            rng = self.rng,
+                            borrow = self.borrow,
+                            input_params = self.input_params,
+                            verbose = self.verbose
+        )
+        self.assertEqual(self.batch_norm_layer_1d.id,self.batch_norm_layer_name_val_1)
+        self.assertEqual(self.batch_norm_layer_1d.input_shape,self.input_shape)
+        self.assertEqual(self.batch_norm_layer_1d.output_shape,self.input_shape)
+        self.assertTrue(numpy.allclose(self.batch_norm_layer_1d.output,self.output_train))
+        self.assertTrue(numpy.allclose(self.batch_norm_layer_1d.inference,self.output_test))
+
+
+    # @patch('yann.layers.batch_norm._dropout')
+    # def test6_dropout_batch_norm_layer_1d(self,mock_dropout):
+    #     mock_dropout.return_value = self.input_ndarray
+    #     self.dropout_batch_norm_layer_1d = dbn1(
+    #                         input = self.input_tensor,
+    #                         id = self.dropout_batch_norm_layer_1,
+    #                         input_shape = self.input_shape,
+    #                         rng = self.rng,
+    #                         input_params = None,
+    #                         dropout_rate= self.dropout_rate,
+    #                         verbose = self.verbose,
+    #                         borrow = self.borrow
+    #     )
+    #     self.assertTrue(numpy.allclose(self.dropout_batch_norm_layer_1d.output, self.input_ndarray))
+    #     self.assertEqual(self.dropout_batch_norm_layer_1d.output_shape,self.input_ndarray.shape)
+    #     self.assertEqual(self.dropout_batch_norm_layer_1d.id,self.dropout_batch_norm_layer_1)
+
+