support recurrent with no states.

blocks/bricks/recurrent/base.py

@@ -46,6 +46,9 @@ def initial_states(self, batch_size, *args, **kwargs):
             The keyword arguments of the application call.
 
         """
+        if not hasattr(self, 'apply') or not self.apply.states:
+            return
+
         result = []
         for state in self.apply.states:
             dim = self.get_dim(state)

blocks/graph/__init__.py

@@ -1,6 +1,6 @@
 """Annotated computation graph management."""
 import logging
-from collections import OrderedDict
+from collections import OrderedDict, deque
 from itertools import chain
 import warnings
 
@@ -103,8 +103,15 @@ def auxiliary_variables(self):
 
     @property
     def scan_variables(self):
-        """Variables of Scan ops."""
-        return list(chain(*[g.variables for g in self._scan_graphs]))
+        """Variables of Scan ops. Breadth-first search"""
+        sg_que = deque(self._scan_graphs)
+        var_list = []
+        while sg_que:
+            g = sg_que.popleft()
+            var_list.append(g.variables)
+            if g._scan_graphs:
+                sg_que.extend(g._scan_graphs)
+        return list(chain(*var_list))
 
     def _get_variables(self):
         """Collect variables, updates and auxiliary variables.

tests/bricks/test_recurrent.py

@@ -9,7 +9,7 @@
 
 from blocks.utils import is_shared_variable
 from blocks.bricks.base import application
-from blocks.bricks import Tanh
+from blocks.bricks import Brick, Tanh
 from blocks.bricks.recurrent import (
     recurrent, BaseRecurrent, GatedRecurrent,
     SimpleRecurrent, Bidirectional, LSTM,
@@ -71,6 +71,48 @@ def test(self):
         assert_allclose(h2 * 10, out_2_eval)
 
 
+class RecurrentWrapperNoStatesClass(BaseRecurrent):
+    def __init__(self, dim, ** kwargs):
+        super(RecurrentWrapperNoStatesClass, self).__init__(self, ** kwargs)
+        self.dim = dim
+
+    def get_dim(self, name):
+        if name in ['inputs', 'outputs', 'outputs_2']:
+            return self.dim
+        if name == 'mask':
+            return 0
+        return super(RecurrentWrapperNoStatesClass, self).get_dim(name)
+
+    @recurrent(sequences=['inputs', 'mask'], states=[],
+               outputs=['outputs', 'outputs_2'], contexts=[])
+    def apply(self, inputs=None, mask=None):
+        outputs = inputs * 10
+        outputs_2 = tensor.sqr(inputs)
+        if mask:
+            outputs *= mask
+            outputs_2 *= mask
+        return outputs, outputs_2
+
+
+class TestRecurrentWrapperNoStates(unittest.TestCase):
+    def setUp(self):
+        self.recurrent_examples = RecurrentWrapperNoStatesClass(dim=1)
+
+    def test(self):
+        X = tensor.tensor3('X')
+        out, out_2 = self.recurrent_examples.apply(
+            inputs=X, mask=None)
+
+        x_val = numpy.random.uniform(size=(5, 1, 1))
+        x_val = numpy.asarray(x_val, dtype=theano.config.floatX)
+
+        out_eval = out.eval({X: x_val})
+        out_2_eval = out_2.eval({X: x_val})
+
+        assert_allclose(x_val * 10, out_eval)
+        assert_allclose(numpy.square(x_val), out_2_eval)
+
+
 class RecurrentBrickWithBugInInitialStates(BaseRecurrent):
 
     @recurrent(sequences=[], contexts=[],

tests/test_graph.py

@@ -2,7 +2,7 @@
 import theano
 import warnings
 from numpy.testing import assert_allclose
-from theano import tensor
+from theano import function, tensor
 from theano.sandbox.rng_mrg import MRG_RandomStreams
 
 from blocks.bricks import MLP, Identity, Logistic, Tanh
@@ -74,6 +74,56 @@ def test_computation_graph():
     assert all(v in cg6.scan_variables for v in scan.inputs + scan.outputs)
 
 
+def test_computation_graph_nested_scan():
+    inner_x = tensor.matrix('inner_x')
+    outer_x = tensor.matrix('outer_x')
+    factor = tensor.matrix('factor')
+
+    def inner_scan(inner_x_, outer_x_one_step):
+        inner_o, _ = theano.scan(fn=lambda inp, ctx: inp + ctx,
+                                 sequences=inner_x_,
+                                 non_sequences=outer_x_one_step)
+        return inner_o.sum(axis=0)
+
+    outer_o, _ = theano.scan(fn=lambda inp, ctx: inner_scan(ctx, inp),
+                             sequences=outer_x,
+                             non_sequences=inner_x)
+
+    outs = outer_o * factor
+
+    nested_scan = outs.owner.inputs[0].owner.op
+    cg = ComputationGraph(outer_o)
+
+    assert cg.scans == [nested_scan]
+    assert all(var in cg.scan_variables
+               for var in nested_scan.inputs + nested_scan.outputs)
+
+    func = function(inputs=[inner_x, outer_x, factor], outputs=outs,
+                    allow_input_downcast=True)
+
+    in_len = 9
+    out_len = 7
+    dim = 3
+
+    floatX = theano.config.floatX
+    x_val = numpy.asarray(numpy.random.uniform(size=(in_len, dim)),
+                          dtype=floatX)
+    y_val = numpy.asarray(numpy.random.uniform(size=(out_len, dim)),
+                          dtype=floatX)
+    factor_val = numpy.asarray(numpy.random.uniform(size=(out_len, dim)),
+                               dtype=floatX)
+
+    results = func(x_val, y_val, factor_val)
+
+    results2 = numpy.zeros(shape=(out_len, dim))
+    for i, y in enumerate(y_val):
+        for x in x_val:
+            results2[i] += (x + y)
+    results2 = results2 * factor_val
+
+    assert_allclose(results, results2)
+
+
 def test_computation_graph_variable_duplicate():
     # Test if ComputationGraph.variables contains duplicates if some outputs
     # are part of the computation graph