added layer_test & fixed invalid get_config() response

Author: kirschte

keras_contrib/wrappers/cdropout.py

@@ -29,13 +29,16 @@ class ConcreteDropout(Wrapper):
 
     # Arguments
         layer: The to be wrapped layer.
-        n_data: int. Length of the dataset.
-        length_scale: float. Prior lengthscale.
-        model_precision: float. Model precision parameter is `1` for classification.
+        n_data: int. `n_data > 0`.
+                Length of the dataset.
+        length_scale: float. `length_scale > 0`.
+                      Prior lengthscale.
+        model_precision: float. `model_precision > 0`.
+                         Model precision parameter is `1` for classification.
                          Also known as inverse observation noise.
-        prob_init: Tuple[float, float].
+        prob_init: Tuple[float, float]. `prob_init > 0`
                    Probability lower / upper bounds of dropout rate initialization.
-        temp: float. Temperature.
+        temp: float. Temperature. `temp > 0`.
               Determines the speed of probability (i.e. dropout rate) adjustments.
         seed: Seed for random probability sampling.
 
@@ -53,13 +56,23 @@ def __init__(self,
                  seed=None,
                  **kwargs):
         assert 'kernel_regularizer' not in kwargs
+        assert n_data > 0 and isinstance(n_data, int)
+        assert length_scale > 0.
+        assert prob_init[0] <= prob_init[1] and prob_init[0] > 0.
+        assert temp > 0.
+        assert model_precision > 0.
         super(ConcreteDropout, self).__init__(layer, **kwargs)
-        self.weight_regularizer = length_scale**2 / (model_precision * n_data)
-        self.dropout_regularizer = 2 / (model_precision * n_data)
-        self.prob_init = tuple(np.log(prob_init))
-        self.temp = temp
-        self.seed = seed
 
+        self._n_data = n_data
+        self._length_scale = length_scale
+        self._model_precision = model_precision
+        self._prob_init = prob_init
+        self._temp = temp
+        self._seed = seed
+
+        eps = K.epsilon()
+        self.weight_regularizer = length_scale**2 / (model_precision * n_data + eps)
+        self.dropout_regularizer = 2 / (model_precision * n_data + eps)
         self.supports_masking = True
         self.p_logit = None
         self.p = None
@@ -84,15 +97,15 @@ def _concrete_dropout(self, inputs, layer_type):
             else:
                 noise_shape = (noise_shape[0], 1, 1, noise_shape[3])
         unif_noise = K.random_uniform(shape=noise_shape,
-                                      seed=self.seed,
+                                      seed=self._seed,
                                       dtype=inputs.dtype)
         drop_prob = (
             K.log(self.p + eps)
             - K.log(1. - self.p + eps)
             + K.log(unif_noise + eps)
             - K.log(1. - unif_noise + eps)
         )
-        drop_prob = K.sigmoid(drop_prob / self.temp)
+        drop_prob = K.sigmoid(drop_prob / self._temp)
 
         # apply dropout
         random_tensor = 1. - drop_prob
@@ -123,8 +136,8 @@ def build(self, input_shape=None):
         self.p_logit = self.layer.add_weight(name='p_logit',
                                              shape=(1,),
                                              initializer=RandomUniform(
-                                                 *self.prob_init,
-                                                 seed=self.seed
+                                                 *np.log(self._prob_init),
+                                                 seed=self._seed
                                              ),
                                              trainable=True)
         self.p = K.squeeze(K.sigmoid(self.p_logit), axis=0)
@@ -156,11 +169,12 @@ def relaxed_dropped_inputs():
                                 training=training)
 
     def get_config(self):
-        config = {'weight_regularizer': self.weight_regularizer,
-                  'dropout_regularizer': self.dropout_regularizer,
-                  'prob_init': tuple(np.round(self.prob_init, 8)),
-                  'temp': self.temp,
-                  'seed': self.seed}
+        config = {'n_data': self._n_data,
+                  'length_scale': self._length_scale,
+                  'model_precision': self._model_precision,
+                  'prob_init': self._prob_init,
+                  'temp': self._temp,
+                  'seed': self._seed}
         base_config = super(ConcreteDropout, self).get_config()
         return dict(list(base_config.items()) + list(config.items()))
 

tests/keras_contrib/wrappers/test_cdropout.py

@@ -8,6 +8,7 @@
 from keras import backend as K
 from keras.layers import Input, Dense, Conv1D, Conv2D, Conv3D
 from keras.models import Model
+from keras_contrib.utils.test_utils import layer_test
 from keras_contrib.wrappers import ConcreteDropout
 
 
@@ -202,30 +203,29 @@ def sigmoid(x):
     assert_approx_equal(eval_loss, loss)
 
 
-def test_cdropout_1d_layer():
+@pytest.mark.parametrize('n_data', [1, 60])
+@pytest.mark.parametrize('layer, shape', [(Conv1D(8, 3), (None, 20, 1)),
+                                          (Conv3D(16, 7), (1, 20, 20, 20, 1))])
+def test_cdropout_invalid_layer(layer, shape, n_data):
     """To be replaced with a real function test, if implemented.
     """
-    in_dim = 20
-    init_prop = .1
-
     with pytest.raises(ValueError):
-        inputs = Input(shape=(in_dim, 1,))
-        ConcreteDropout(Conv1D(1, 3),
-                        in_dim,
-                        prob_init=(init_prop, init_prop))(inputs)
+        layer_test(ConcreteDropout,
+                   kwargs={'layer': layer,
+                           'n_data': n_data},
+                   input_shape=shape)
 
 
-def test_cdropout_3d_layer():
-    """To be replaced with a real function test, if implemented.
+@pytest.mark.parametrize('n_data', [1, 60])
+@pytest.mark.parametrize('layer, shape', [(Conv2D(8, 3), (None, 12, 12, 3)),
+                                          (Conv2D(16, 7), (1, 12, 12, 3))])
+def test_cdropout_valid_layer(layer, shape, n_data):
+    """Original layer test with valid parameters.
     """
-    in_dim = 20
-    init_prop = .1
-
-    with pytest.raises(ValueError):
-        inputs = Input(shape=(in_dim, in_dim, in_dim, 1,))
-        ConcreteDropout(Conv3D(1, 3),
-                        in_dim,
-                        prob_init=(init_prop, init_prop))(inputs)
+    layer_test(ConcreteDropout,
+               kwargs={'layer': layer,
+                       'n_data': n_data},
+               input_shape=shape)
 
 
 if __name__ == '__main__':