Remove old deprecated stuff.

theano/tensor/deprecated/rmodule.py

-"""Define RModule, a Module providing random number streams in Theano graphs."""
-__docformat__ = "restructuredtext en"
-import sys
-if sys.version_info[:2] >= (2,5):
-  from functools import partial
-else:
-  from theano.gof.python25 import partial
-
-import numpy
-from copy import copy
-
-from theano.compile import (SymbolicInputKit, SymbolicInput,
-        Module, module, Method, Member, In, Component)
-from theano.gof import Container
-from theano.gof.python25 import deque
-
-from theano.tensor import raw_random
-
-class KitComponent(Component):
-    """
-    Represents a SymbolicInputKit (see io.py).
-    """
-
-    def __init__(self, kit):
-        super(KitComponent, self).__init__()
-        self.kit = kit
-
-    def allocate(self, memo):
-        """
-        Allocates a Container for each input in the kit. Sets a key in
-        the memo that maps the SymbolicInputKit to the list of
-        Containers.
-        """
-        for input in self.kit.sinputs:
-            r = input.variable
-            if r not in memo:
-                input = copy(input)
-                input.value = Container(r, storage = [None])
-                memo[r] = input
-
-    def build(self, mode, memo):
-        return [memo[i.variable].value for i in self.kit.sinputs]
-
-
-class RandomKit(SymbolicInputKit):
-
-    def __init__(self, name, value = None):
-        super(RandomKit, self).__init__(name)
-        self.value = value
-
-    def gen(self, op, *args, **kwargs):
-        random_state_variable = raw_random.random_state_type()
-        new_r, out = op(random_state_variable, *args, **kwargs)
-        self.add_input(SymbolicInput(random_state_variable, update = new_r))
-        out.rng = new_r
-        out.auto = self
-        return out
-
-    def distribute(self, value, indices, containers):
-        rg = partial(numpy.random.RandomState(int(value)).randint, 2**30)
-        elems = deque(zip(indices, containers))
-        i = 0
-        while elems:
-            index, container = elems.popleft()
-            while i <= index:
-                curr = rg()
-                i += 1
-            rs = numpy.random.RandomState(int(curr))
-            container.data = rs
-
-    def binomial(self, *args, **kwargs):
-        return self.gen(raw_random.binomial, *args, **kwargs)
-
-    def uniform(self, *args, **kwargs):
-        return self.gen(raw_random.uniform, *args, **kwargs)
-
-    def normal(self, *args, **kwargs):
-        return self.gen(raw_random.normal, *args, **kwargs)
-
-    def random_integers(self, *args, **kwargs):
-        return self.gen(raw_random.random_integers, *args, **kwargs)
-
-
-
-rk = RandomKit('rk', 0xBAD5EED)
-
-
-class RModule(Module):
-    """Module providing random number streams in Theano graphs."""
-
-    def __init__(self, components=None, **kwcomponents):
-        if components is None:
-            components = {}
-        super(RModule, self).__init__(components, **kwcomponents)
-        self.random = RandomKit('rkit')
-        self._rkit = KitComponent(self.random)
-
-    def __wrapper__(self, x):
-        x = module.wrap(x)
-        if isinstance(x, Method):
-            x.kits += [self.random]
-        return x
-
-    def _instance_seed(self, inst, seed, recursive = True):
-        seedgen = numpy.random.RandomState(seed)
-        if recursive:
-            #Here, we recurse through all the components (inst2) contained in (inst)
-            #and seeds each subcomponent that is an RModule
-
-
-            for path, c in self.flat_components_map(True):
-                if isinstance(c, RModule):
-                    inst2 = inst
-                    for name in path:
-                        inst2 = inst2[name]
-                    # A Kit (c._rkit.kit) contains a list of io.SymbolicIn instances
-                    # and the distribute method takes a value (seed), a list of indices
-                    # and a list of corresponding Container instances. In this
-                    # situation it will reseed all the rngs using the containers
-                    # associated to them.
-                    c._rkit.kit.distribute(seedgen.random_integers(2**30),
-                                           xrange(len(inst2._rkit)), inst2._rkit)
-        else:
-            self._rkit.kit.distribute(seedgen.random_integers(2**30), xrange(len(inst._rkit)), inst._rkit)
-

theano/tensor/deprecated/test_rmodule.py

-__docformat__ = "restructuredtext en"
-
-import sys
-import unittest
-import numpy as N
-
-from theano.tensor.deprecated.rmodule import *
-
-from theano import tensor
-from theano import compile, gof
-
-
-if 0:
-    class T_test_module(unittest.TestCase):
-        def test_state_propagation(self):
-            if 1:
-                print >> sys.stderr, "RModule deprecated"
-            else:
-                x = tensor.vector()
-                rk = RandomKit('rk', 1000)
-                f = compile.function([x, (rk, [gof.Container(r = gof.generic, storage = [123], name='bla')])], rk.binomial(tensor.shape(x)))
-                print "RK", rk.value
-                f['rk'] = 9873456
-                print "RK", rk.value
-            
-                rvals = [f([1,2,3,4,6, 7, 8]) for i in xrange(5)]
-                print rvals
-                for i in xrange(5-1):
-                    for j in xrange(i+1, 5):
-                        assert not N.all(rvals[i] == rvals[j])
-
-        def test_B(self):
-            """Test that random numbers change from call to call!
-            
-            Also, make sure that the seeding strategy doesn't change without failing a test.
-            
-            Random numbers can't be too random or experiments aren't repeatable.  Email theano-dev
-            before updating the `rvals` in this test.
-            """
-            class B(RModule):
-                def __init__(self):
-                    super(B, self).__init__()
-                    
-                    self.x = compile.Member(tensor.dvector())
-                    self.r = self.random.uniform(tensor.shape(self.x))
-                    
-                    self.f = compile.Method([self.x], self.r)
-            class E(RModule):
-                def __init__(self):
-                    super(E, self).__init__()
-                    self.b = B()
-                    self.f = compile.Method([self.b.x], self.b.r)
-
-            b = E()
-            m = b.make()
-            
-            m.seed(1000)
-        #print m.f(N.ones(5))
-        #print m.f(N.ones(5))
-        #print m.f(N.ones(5))
-            rvals = ["0.74802375876 0.872308123517 0.294830748897 0.803123780003 0.6321109955",
-                     "0.00168744844365 0.278638315678 0.725436793755 0.7788480779 0.629885140994",
-                     "0.545561221664 0.0992011009108 0.847112593242 0.188015424144 0.158046201298",
-                     "0.054382248842 0.563459168529 0.192757276954 0.360455221883 0.174805216702",
-                     "0.961942907777 0.49657319422 0.0316111492826 0.0915054717012 0.195877184515"]
-
-            for i in xrange(5):
-                s = " ".join([str(n) for n in m.f(N.ones(5))])
-                print s
-                assert s == rvals[i]
-
-if __name__ == '__main__':
-    from theano.tests import main
-    main("test_rmodule")