Merge branch 'master' of https://github.com/MarcBS/keras

Author: MarcBS

keras/engine/topology.py

@@ -365,15 +365,15 @@ def non_trainable_weights(self, weights):
 
     @property
     def regularizers(self):
-        warnings.warn('The `regularizers` property of '
+        warnings.warn('Layer ' + self.name + ': The `regularizers` property of '
                       'layers/models is deprecated. '
                       'Regularization losses are now managed via the `losses` '
                       'layer/model property.')
         return []
 
     @regularizers.setter
     def regularizers(self, _):
-        warnings.warn('The `regularizers` property of layers/models '
+        warnings.warn('Layer ' + self.name + ': The `regularizers` property of layers/models '
                       'is deprecated. '
                       'Regularization losses are now managed via the `losses` '
                       'layer/model property.')

keras/initializations.py

@@ -102,7 +102,7 @@ def norm_weight(shape, scale=0.01, ortho=True, name=None):
     """
     Random weights drawn from a Gaussian
     """
-    assert len(shape)==2, 'shape must have length 2'
+    assert len(shape)>0, 'shape must have length > 0. Currently, it has length == ' + str(len(shape))
     if shape[0] == shape[1] and ortho:
         W = ortho_weight(shape)
     else:

keras/layers/core.py

@@ -410,6 +410,46 @@ def get_config(self):
         return dict(list(base_config.items()) + list(config.items()))
 
 
+
+class PermuteGeneral(Layer):
+    '''Permutes the dimensions of the input according to a given pattern.
+    This is just like the layer Permute, but DOES INCLUDE the batch dimension.
+
+    # Arguments
+        dims: Tuple of integers. Permutation pattern, INCLUDING the
+            samples dimension. Indexing starts at 0.
+            For instance, `(1, 0, 2)` permutes the batch and first dimension of the input.
+
+    # Input shape
+        Arbitrary. Use the keyword argument `input_shape`
+        (tuple of integers, does not include the samples axis)
+        when using this layer as the first layer in a model.
+
+    # Output shape
+        Same as the input shape, but with the dimensions re-ordered according
+        to the specified pattern.
+    '''
+    def __init__(self, dims, **kwargs):
+        self.dims = tuple(dims)
+        self.supports_masking = True
+        super(PermuteGeneral, self).__init__(**kwargs)
+
+    def get_output_shape_for(self, input_shape):
+        input_shape = list(input_shape)
+        output_shape = copy.copy(input_shape)
+        for i, dim in enumerate(self.dims):
+            output_shape[i] = input_shape[dim]
+        return tuple(output_shape)
+
+    def call(self, x, mask=None):
+        return K.permute_dimensions(x, self.dims)
+
+    def get_config(self):
+        config = {'dims': self.dims}
+        base_config = super(PermuteGeneral, self).get_config()
+        return dict(list(base_config.items()) + list(config.items()))
+
+
 class Flatten(Layer):
     '''Flattens the input. Does not affect the batch size.
 
@@ -581,7 +621,7 @@ def antirectifier_output_shape(input_shape):
     def __init__(self, function, output_shape=None, arguments=None, **kwargs):
         self.function = function
         self.arguments = arguments if arguments else {}
-        self.supports_masking = False
+        self.supports_masking = True
 
         if output_shape is None:
             self._output_shape = None
@@ -1303,6 +1343,28 @@ def get_config(self):
         base_config = super(MaskedMean, self).get_config()
         return dict(list(base_config.items()))
 
+
+class MaskLayer(Layer):
+    """
+    Applies to the input layer its mask
+    """
+    def __init__(self, **kwargs):
+        self.support_mask = True
+        super(MaskLayer, self).__init__(**kwargs)
+
+    def call(self, x, mask=None):
+        return mask[:, :, None] * x
+
+    def compute_mask(self, input_shape, input_mask=None):
+        return input_mask
+
+    def get_output_shape_for(self, input_shape):
+        return input_shape
+
+    def get_config(self):
+        base_config = super(MaskLayer, self).get_config()
+        return dict(list(base_config.items()))
+
 class WeightedSum(Layer):
     ''' Applies a weighted sum over a set of vectors input[0] and their respective weights input[1].
         First, the weights are tiled for matching the length of the input vectors on dim=1.
@@ -1530,4 +1592,4 @@ def compute_mask(self, input, input_mask=None):
         #def get_config(self):
         #base_config = super(LambdaRemoveMask, self).get_config()
         #return dict(list(base_config.items()))
-"""
+"""