get rid of initializable_roles

Author: memimo

blocks/bricks/conv.py

@@ -72,7 +72,9 @@ class Convolutional(LinearLike):
     def __init__(self, filter_size, num_filters, num_channels, batch_size=None,
                  image_size=(None, None), step=(1, 1), border_mode='valid',
                  tied_biases=False, **kwargs):
-        super(Convolutional, self).__init__(**kwargs)
+        parameter_roles = set([FILTER, BIAS])
+        super(Convolutional, self).__init__(parameter_roles=parameter_roles,
+                                            **kwargs)
 
         self.filter_size = filter_size
         self.num_filters = num_filters

blocks/bricks/interfaces.py

@@ -1,12 +1,15 @@
 """Bricks that are interfaces and/or mixins."""
 import numpy
+import logging
 from six import add_metaclass
 from theano.sandbox.rng_mrg import MRG_RandomStreams
 
 from ..config import config
 from .base import _Brick, Brick, lazy
 from blocks.roles import WEIGHT, BIAS, FILTER, INITIAL_STATE
 
+logger = logging.getLogger(__name__)
+
 
 class ActivationDocumentation(_Brick):
     """Dynamically adds documentation to activations.
@@ -133,24 +136,37 @@ class Initializable(RNGMixin, Brick):
 
     """
 
-    initializable_roles = [WEIGHT, BIAS, FILTER, INITIAL_STATE]
-
     @lazy()
-    def __init__(self, initialization_schemes=None, use_bias=True,
-                 seed=None, **kwargs):
+    def __init__(self, initialization_schemes=None, parameter_roles=None,
+                 use_bias=True, seed=None, **kwargs):
         self.use_bias = use_bias
         self.seed = seed
         self.initialization_schemes = initialization_schemes
-        self.parameter_roles = set([])
         if self.initialization_schemes is None:
             self.initialization_schemes = {}
 
+        if parameter_roles:
+            self.parameter_roles = parameter_roles
+        else:
+            # logger.warning("The block has not received parameter_roles, "
+            #                "hence only the default WEIGHT and BIAS are set."
+            #                "It's a good idea to manually set the roles "
+            #                "of all the initlizable parameters inside "
+            #                "parameter_roles")
+            self.parameter_roles = set([WEIGHT])
+            if use_bias:
+                self.parameter_roles.update(set([BIAS]))
+
         initialization_to_role = {"weights_init": WEIGHT, 'biases_init': BIAS,
                                   'initial_state_init': INITIAL_STATE}
         for key in list(kwargs.keys()):
             if key[-5:] == "_init":
+                if key not in initialization_to_role:
+                    raise ValueError("The initlization scheme: {}".format(key),
+                                     "is not defined by default, pass it"
+                                     "via initialization_schemes")
                 if initialization_to_role[key] in \
-                                            self.initialization_schemes.keys():
+                        self.initialization_schemes.keys():
                     raise ValueError("All initializations are accepted either"
                                      "through initialization schemes or "
                                      "corresponding attribute but not both")
@@ -159,47 +175,47 @@ def __init__(self, initialization_schemes=None, use_bias=True,
                                                 key]] = kwargs[key]
                 kwargs.pop(key)
 
-        for key in self.initialization_schemes:
-            if key not in self.initializable_roles:
-                raise ValueError("{} is not member of ".format(key) +
-                                 "initializable_roles")
-
         super(Initializable, self).__init__(**kwargs)
+        self._collect_roles()
 
-    def _validate_roles_schmes(self):
+    def _validate_roles(self):
+        high_level_roles = []
         for role in self.parameter_roles:
             if role not in self.initialization_schemes.keys():
-                found = False
-                for init_role in list(self.initialization_schemes.keys()):
-                    if isinstance(role, type(init_role)):
+                for key in self.initialization_schemes.keys():
+                    if isinstance(role, type(key)):
                         self.initialization_schemes[role] = \
-                                        self.initialization_schemes[init_role]
-                        found = True
-                if not found:
-                    raise ValueError("There is no initialization_schemes"
-                                     " defined for {}".format(role))
+                                            self.initialization_schemes[key]
+                        high_level_roles.append(key)
+
+        for key in high_level_roles:
+            if key not in self.parameter_roles:
+                self.initialization_schemes.pop(key)
+
+        for key in self.initialization_schemes:
+            if key not in self.parameter_roles:
+                raise ValueError("{} is not member of ".format(key) +
+                                 "parameter_roles")
 
     def _push_initialization_config(self):
-        self._collect_roles()
-        self._validate_roles_schmes()
+        self._validate_roles()
         for child in self.children:
             if (isinstance(child, Initializable) and
                     hasattr(child, 'initialization_schemes')):
                 child.rng = self.rng
                 for role, scheme in self.initialization_schemes.items():
-                    child.initialization_schemes[role] = scheme
+                    if role in child.parameter_roles:
+                        child.initialization_schemes[role] = scheme
 
     def _collect_roles(self):
-        if hasattr(self, 'parameters'):
-            for param in self.parameters:
-                for role in param.tag.roles:
-                    if role in self.initializable_roles:
-                        self.parameter_roles.update(set([role]))
+        for child in self.children:
+            if isinstance(child, Initializable):
+                self.parameter_roles.update(child.parameter_roles)
 
     def _initialize(self):
         for param in self.parameters:
             for role in param.tag.roles:
-                if role in self.initializable_roles:
+                if role in self.parameter_roles:
                     self.initialization_schemes[role].initialize(param,
                                                                  self.rng)
 
@@ -210,7 +226,7 @@ def __getattr__(self, name):
         elif name == "biases_init":
             if BIAS in self.initialization_schemes:
                 return self.initialization_schemes[BIAS]
-        raise AttributeError("Attribute {} not found".format(name))
+        super(Initializable, self).__getattr__(name)
 
     def __setattr__(self, name, value):
         if name == 'weights_init':
@@ -235,6 +251,14 @@ class LinearLike(Initializable):
     first and biases (if ``use_bias`` is True) coming second.
 
     """
+
+    def __init__(self, **kwargs):
+        if 'parameter_roles' in kwargs:
+            kwargs['parameter_roles'].update(set([WEIGHT, BIAS]))
+        else:
+            kwargs['parameter_roles'] = set([WEIGHT, BIAS])
+        super(LinearLike, self).__init__(**kwargs)
+
     @property
     def W(self):
         return self.parameters[0]

blocks/bricks/recurrent.py

@@ -12,7 +12,7 @@
 from blocks.bricks import Initializable, Logistic, Tanh, Linear
 from blocks.bricks.base import Application, application, Brick, lazy
 from blocks.initialization import NdarrayInitialization, Constant
-from blocks.roles import add_role, WEIGHT, INITIAL_STATE
+from blocks.roles import add_role, WEIGHT, BIAS, INITIAL_STATE
 from blocks.utils import (pack, shared_floatx_nans, shared_floatx_zeros,
                           dict_union, dict_subset, is_shared_variable)
 from blocks.bricks.parallel import Fork
@@ -279,9 +279,12 @@ class SimpleRecurrent(BaseRecurrent, Initializable):
     def __init__(self, dim, activation, **kwargs):
         self.dim = dim
         children = [activation] + kwargs.get('children', [])
-        if not 'initial_state_init' in kwargs:
+        if 'initial_state_init' not in kwargs:
             kwargs['initial_state_init'] = Constant(0.)
-        super(SimpleRecurrent, self).__init__(children=children, **kwargs)
+        parameter_roles = set([WEIGHT, BIAS, INITIAL_STATE])
+        super(SimpleRecurrent, self).__init__(children=children,
+                                              parameter_roles=parameter_roles,
+                                              **kwargs)
 
     @property
     def W(self):
@@ -300,7 +303,7 @@ def _allocate(self):
                                                   name="W"))
         add_role(self.parameters[0], WEIGHT)
         self.parameters.append(shared_floatx_nans((self.dim,),
-                                                   name="initial_state"))
+                                                  name="initial_state"))
         add_role(self.parameters[1], INITIAL_STATE)
 
     @recurrent(sequences=['inputs', 'mask'], states=['states'],
@@ -386,9 +389,11 @@ def __init__(self, dim, activation=None, gate_activation=None, **kwargs):
         children = ([self.activation, self.gate_activation] +
                     kwargs.get('children', []))
 
-        if not 'initial_state_init' in kwargs:
+        if 'initial_state_init' not in kwargs:
             kwargs['initial_state_init'] = Constant(0.)
-        super(LSTM, self).__init__(children=children, **kwargs)
+        parameter_roles = set([WEIGHT, BIAS, INITIAL_STATE])
+        super(LSTM, self).__init__(children=children,
+                                   parameter_roles=parameter_roles, **kwargs)
 
     def get_dim(self, name):
         if name == 'inputs':
@@ -411,9 +416,9 @@ def _allocate(self):
         # The underscore is required to prevent collision with
         # the `initial_state` application method
         self.initial_state_ = shared_floatx_nans((self.dim,),
-                                                  name="initial_state")
+                                                 name="initial_state")
         self.initial_cells = shared_floatx_nans((self.dim,),
-                                                 name="initial_cells")
+                                                name="initial_cells")
         add_role(self.W_state, WEIGHT)
         add_role(self.W_cell_to_in, WEIGHT)
         add_role(self.W_cell_to_forget, WEIGHT)
@@ -532,9 +537,12 @@ def __init__(self, dim, activation=None, gate_activation=None,
 
         children = [activation, gate_activation] + kwargs.get('children', [])
 
-        if not 'initial_state_init' in kwargs:
+        if 'initial_state_init' not in kwargs:
             kwargs['initial_state_init'] = Constant(0.)
-        super(GatedRecurrent, self).__init__(children=children, **kwargs)
+        parameter_roles = set([WEIGHT, BIAS, INITIAL_STATE])
+        super(GatedRecurrent, self).__init__(children=children,
+                                             parameter_roles=parameter_roles,
+                                             **kwargs)
 
     @property
     def state_to_state(self):