Created unittests for Module

doc/basic_tutorial/module.txt

@@ -159,23 +159,7 @@ subclass of Module:
 
 .. code-block:: python
 
-   class Accumulator(Module):
-
-       def __init__(self):
-           super(Accumulator, self).__init__() # don't forget this
-           self.inc = T.dscalar()
-           self.state = T.dscalar()
-           self.new_state = self.inc + self.state
-           self.add = Method(inputs = self.inc,
-                             outputs = self.new_state,
-                             updates = {self.state: self.new_state})
-           self.sub = Method(inputs = self.inc,
-                             outputs = None,
-                             updates = {self.state: self.state - self.inc})
-
-   m = Accumulator()
-   acc = m.make(state = 0)
-
+.. literalinclude:: ../examples/module/accumulator.py
 
 This is just like the previous example except slightly fancier.
 
@@ -203,30 +187,7 @@ boilerplate code.
 All we need to do to use this mechanism is to give a method called
 ``_instance_print_state`` to our Module class.
 
-.. code-block:: python
-
-   class Accumulator(Module):
-
-       def __init__(self):
-           super(Accumulator, self).__init__() # don't forget this
-           self.inc = T.dscalar()
-           self.state = T.dscalar()
-           self.new_state = self.inc + self.state
-           self.add = Method(inputs = self.inc,
-                             outputs = self.new_state,
-                             updates = {self.state: self.new_state})
-           self.sub = Method(inputs = self.inc,
-                             outputs = None,
-                             updates = {self.state: self.state - self.inc})
-
-       def _instance_print_state(self, acc):
-           print '%s is: %s' % (self.state, acc.state)
-
-   m = Accumulator()
-   acc = m.make(state = 0)
-
-   acc.print_state() # --> prints "state is: 0.0"
-
+.. literalinclude:: ../examples/module/mechanism1.py
 
 Any method called like ``_instance_XXX`` will cause the object
 obtained through a call to ``make`` to have a method called ``XXX``.
@@ -246,37 +207,7 @@ If a number of instance methods are going to be defined, and especially if you
 will want to inherit from the kind of class that gets instantiated by make,
 you might prefer to consider using the InstanceType mechanism.
 
-.. code-block:: python
-
-   class AccumulatorInstance(ModuleInstance):
-       
-       def print_state(self):
-           #self.component points to the Module from which this was compiled.
-           print '%s is: %s' % (self.component.state, self.state)
-       
-   class Accumulator(Module):
-
-       # This line tells theano to instantiate an AccumulatorInstance 
-       # when make() is called.
-       InstanceType = AccumulatorInstance
-
-       def __init__(self):
-           super(Accumulator, self).__init__() # don't forget this
-           self.inc = T.dscalar()
-           self.state = T.dscalar()
-           self.new_state = self.inc + self.state
-           self.add = Method(inputs = self.inc,
-                             outputs = self.new_state,
-                             updates = {self.state: self.new_state})
-           self.sub = Method(inputs = self.inc,
-                             outputs = None,
-                             updates = {self.state: self.state - self.inc})
-
-   m = Accumulator()
-   acc = m.make(state = 0)
-
-   acc.print_state() # --> prints "state is: 0.0"
-
+.. literalinclude:: ../examples/module/mechanism2.py
 
 Adding custom initialization
 ============================
@@ -293,39 +224,7 @@ can override the default with your own method, which has to be called
 Here is an example where we take width and height arguments to
 initialize a state with a matrix of zeros:
 
-
-.. code-block:: python
-
-   import numpy
-
-   class MatrixAccumulator(Module):
-
-       def __init__(self):
-           super(MatrixAccumulator, self).__init__() # don't forget this
-           self.inc = T.dscalar()
-           self.state = T.dmatrix()
-           self.new_state = self.inc + self.state
-           self.add = Method(inputs = self.inc,
-                             outputs = self.new_state,
-                             updates = {self.state: self.new_state})
-           self.sub = Method(inputs = self.inc,
-                             outputs = None,
-                             updates = {self.state: self.state - self.inc})
-
-       def _instance_print_state(self, acc):
-           print '%s is: %s' % (self.state, acc.state)
-
-       def _instance_initialize(self, acc, nrows, ncols):
-           acc.state = numpy.zeros((nrows, ncols))
-
-   m = Accumulator()
-   acc = m.make(2, 5) # this calls m._instance_initialize(acc, 2, 5)
-
-   acc.print_state()
-
-   # OUTPUT:
-   # state is: [[ 0.  0.  0.  0.  0.]
-   #  [ 0.  0.  0.  0.  0.]]
+.. literalinclude:: ../examples/module/accumulator.py
 
 
 Nesting Modules
@@ -335,25 +234,7 @@ Probably the most powerful feature of theano's modules is that one can be
 included as an attribute to another so that the storage of each is available
 to both.
 
-.. code-block:: python
-
-   M = theano.Module()
-   M.a, M.b, M.c = [theano.dvector() for i in 1,2,3]
-
-   P = theano.Module()
-   P.m = M   #include a module by nesting
-   x = theano.dvector()
-   P.f = Method([x], None, {M.b: M.b + x})
-
-   p = P.make()  #this converts both M and P because M was nested within P
-   p.m.b = [4, 5, 6]
-   p.f(3)
-   print p.m.b 
-   #  prints  array([7.,8.,9.])
+.. literalinclude:: ../examples/module/nested.py
 
 As you read through examples of Theano code, you will probably see many
 instances of Modules being nested in this way.
-
-
-
-

doc/examples/module/accumulator.py

+from theano.compile import Module, Method
+import theano.tensor as T
+
+class Accumulator(Module):
+
+    def __init__(self):
+        super(Accumulator, self).__init__() # don't forget this
+        self.inc = T.dscalar()
+        self.state = T.dscalar()
+        self.new_state = self.inc + self.state
+        self.add = Method(inputs = self.inc,
+                          outputs = self.new_state,
+                          updates = {self.state: self.new_state})
+        self.sub = Method(inputs = self.inc,
+                          outputs = None,
+                          updates = {self.state: self.state - self.inc})
+
+if __name__ == '__main__':
+    m = Accumulator()
+    acc = m.make(state = 0)

doc/examples/module/custom_init.py

+import numpy
+from theano.compile import Module, Method
+import theano.tensor as T
+
+class MatrixAccumulator(Module):
+
+    def __init__(self):
+        super(MatrixAccumulator, self).__init__() # don't forget this
+        self.inc = T.dscalar()
+        self.state = T.dmatrix()
+        self.new_state = self.inc + self.state
+        self.add = Method(inputs = self.inc,
+                          outputs = self.new_state,
+                          updates = {self.state: self.new_state})
+        self.sub = Method(inputs = self.inc,
+                          outputs = None,
+                          updates = {self.state: self.state - self.inc})
+
+    def _instance_print_state(self, acc):
+        print '%s is: %s' % (self.state, acc.state)
+
+    def _instance_initialize(self, acc, nrows, ncols):
+        acc.state = numpy.zeros((nrows, ncols))
+
+if __name__ == '__main__':
+    m = Accumulator()
+    acc = m.make(2, 5) # this calls m._instance_initialize(acc, 2, 5)
+
+    acc.print_state()
+
+    # OUTPUT:
+    # state is: [[ 0.  0.  0.  0.  0.]
+    #  [ 0.  0.  0.  0.  0.]]

doc/examples/module/mechanism1.py

+from theano.compile import Module, Method
+import theano.tensor as T
+
+class Accumulator(Module):
+
+    def __init__(self):
+        super(Accumulator, self).__init__() # don't forget this
+        self.inc = T.dscalar()
+        self.state = T.dscalar()
+        self.new_state = self.inc + self.state
+        self.add = Method(inputs = self.inc,
+                          outputs = self.new_state,
+                          updates = {self.state: self.new_state})
+        self.sub = Method(inputs = self.inc,
+                          outputs = None,
+                          updates = {self.state: self.state - self.inc})
+
+    def _instance_print_state(self, acc):
+        print '%s is: %s' % (self.state, acc.state)
+
+if __name__ == '__main__':
+    m = Accumulator()
+    acc = m.make(state = 0)
+
+    acc.print_state() # --> prints "state is: 0.0"

doc/examples/module/mechanism2.py

+from theano.compile import Module, ModuleInstance, Method
+import theano.tensor as T
+
+class AccumulatorInstance(ModuleInstance):
+
+    def print_state(self):
+        #self.component points to the Module from which this was compiled.
+        print '%s is: %s' % (self.component.state, self.state)
+
+class Accumulator(Module):
+
+    # This line tells theano to instantiate an AccumulatorInstance
+    # when make() is called.
+    InstanceType = AccumulatorInstance
+
+    def __init__(self):
+        super(Accumulator, self).__init__() # don't forget this
+        self.inc = T.dscalar()
+        self.state = T.dscalar()
+        self.new_state = self.inc + self.state
+        self.add = Method(inputs = self.inc,
+                          outputs = self.new_state,
+                          updates = {self.state: self.new_state})
+        self.sub = Method(inputs = self.inc,
+                          outputs = None,
+                          updates = {self.state: self.state - self.inc})
+
+if __name__=='__main__':
+    m = Accumulator()
+    acc = m.make(state = 0)
+    acc.print_state() # --> prints "state is: 0.0"

doc/examples/module/nested.py

+import theano
+import theano.tensor as T
+
+M = theano.Module()
+M.a, M.b, M.c = [T.dvector() for i in 1,2,3]
+
+P = theano.Module()
+P.m = M   #include a module by nesting
+x = T.dvector()
+P.f = theano.Method([x], None, {M.b: M.b + x})
+
+p = P.make()  #this converts both M and P because M was nested within P
+p.m.b = [4, 5, 6]
+p.f(3)
+print p.m.b
+#  prints  array([7.,8.,9.])

doc/examples/module/test_module_doc.py

+import numpy
+import unittest
+import os
+
+def makeTester(fname):
+    
+    class Test(unittest.TestCase):
+        def test_example(self):
+            print 'Executing file', self.fname
+
+    Test.__name__ = fname
+    Test.fname = fname 
+    return Test
+
+def test_module_doc():
+    """
+    This test executes all of the Module code examples.
+    It goes through the directory and executes all .py files.
+    """
+
+    for fname in os.listdir('.'):
+        if fname.endswith('.py'):
+            f = fname.split('.')[0]
+            print 'Executing ', fname
+            execfile(fname, locals())
+