merge

__init__.py

@@ -9,7 +9,10 @@ from gof import \
      Type, Generic, generic, \
      object2, utils
 
-from compile import FunctionMaker, function, OpFromGraph #, eval_outputs, fast_compute
+from compile import \
+    Mode, \
+    predefined_modes, predefined_linkers, predefined_optimizers, \
+    FunctionMaker, function, OpFromGraph #, eval_outputs, fast_compute
 
 import tensor
 import tensor_random

_test_compile.py

@@ -146,41 +146,41 @@ import tensor as T
 import random
 import numpy as N
 
-# class T_OpFromGraph(unittest.TestCase):
-
-#     def test_straightforward(self):
-#         x, y, z = T.matrices('xyz')
-#         e = x + y * z
-#         op = OpFromGraph([x, y, z], [e], linker='c|py')
-#         f = op(x, y, z) - op(y, z, x)
-#         fn = function([x, y, z], [f])
-#         xv, yv, zv = N.ones((2, 2)), N.ones((2, 2))*3, N.ones((2, 2))*5
-#         assert numpy.all(8.0 == fn(xv, yv, zv))
-#         assert numpy.all(8.0 == fn(xv, yv, zv))
-    
-#     def test_size_changes(self):
-#         x, y, z = T.matrices('xyz')
-#         e = T.dot(x, y)
-#         op = OpFromGraph([x, y], [e], linker='c|py')
-#         f = op(x, op(y, z))
-#         fn = function([x, y, z], [f])
-#         xv, yv, zv = N.ones((2, 3)), N.ones((3, 4))*3, N.ones((4, 5))*5
-#         res = fn(xv, yv, zv)
-#         assert res.shape == (2, 5)
-#         assert numpy.all(180.0 == res)
-#         res = fn(xv, yv, zv)
-#         assert res.shape == (2, 5)
-#         assert numpy.all(180.0 == res)
-    
-#     def test_grad(self):
-#         x, y, z = T.matrices('xyz')
-#         e = x + y * z
-#         op = OpFromGraph([x, y, z], [e], linker='c|py', grad_depth = 2)
-#         f = op(x, y, z)
-#         f = f - T.grad(f, y)
-#         fn = function([x, y, z], [f])
-#         xv, yv, zv = N.ones((2, 2)), N.ones((2, 2))*3, N.ones((2, 2))*5
-#         assert numpy.all(11.0 == fn(xv, yv, zv))
+class T_OpFromGraph(unittest.TestCase):
+
+    def test_straightforward(self):
+        x, y, z = T.matrices('xyz')
+        e = x + y * z
+        op = OpFromGraph([x, y, z], [e], mode='FAST_RUN')
+        f = op(x, y, z) - op(y, z, x)
+        fn = function([x, y, z], f)
+        xv, yv, zv = N.ones((2, 2)), N.ones((2, 2))*3, N.ones((2, 2))*5
+        assert numpy.all(8.0 == fn(xv, yv, zv))
+        assert numpy.all(8.0 == fn(xv, yv, zv))
+    
+    def test_size_changes(self):
+        x, y, z = T.matrices('xyz')
+        e = T.dot(x, y)
+        op = OpFromGraph([x, y], [e], mode='FAST_RUN')
+        f = op(x, op(y, z))
+        fn = function([x, y, z], f)
+        xv, yv, zv = N.ones((2, 3)), N.ones((3, 4))*3, N.ones((4, 5))*5
+        res = fn(xv, yv, zv)
+        assert res.shape == (2, 5)
+        assert numpy.all(180.0 == res)
+        res = fn(xv, yv, zv)
+        assert res.shape == (2, 5)
+        assert numpy.all(180.0 == res)
+    
+    def test_grad(self):
+        x, y, z = T.matrices('xyz')
+        e = x + y * z
+        op = OpFromGraph([x, y, z], [e], mode='FAST_RUN', grad_depth = 2)
+        f = op(x, y, z)
+        f = f - T.grad(f, y)
+        fn = function([x, y, z], f)
+        xv, yv, zv = N.ones((2, 2)), N.ones((2, 2))*3, N.ones((2, 2))*5
+        assert numpy.all(11.0 == fn(xv, yv, zv))
 
 
 class T_function(unittest.TestCase):
@@ -303,24 +303,19 @@ class T_function(unittest.TestCase):
 
         f = function([x, In(a, value=1.0,name='a'), In(s, value=0.0, update=s+a*x)], s+a*x)
 
-        self.failUnless(f.a == 1.0)
-        self.failUnless(f.value[a] is f.a)
-
-        self.failUnless(f.s == 0.0)
-        self.failUnless(f.value[s] is f.s)
+        self.failUnless(f[a] == 1.0)
+        self.failUnless(f[s] == 0.0)
 
         self.failUnless(f(3.0) == 3.0)
         self.failUnless(f(3.0,a=2.0) == 9.0) #3.0 + 2*3.0
 
-        self.failUnless(f.a == 1.0) #state hasn't changed permanently, we just overrode it last line
-        self.failUnless(f.s == 9.0)
+        self.failUnless(f[a] == 1.0) #state hasn't changed permanently, we just overrode it last line
+        self.failUnless(f[s] == 9.0)
 
-        f.a = 5.0
-        self.failUnless(f.a == 5.0)
-        self.failUnless(f.value[a] is f.a)
+        f[a] = 5.0
+        self.failUnless(f[a] == 5.0)
         self.failUnless(f(3.0) == 24.0) #9 + 3*5
-        self.failUnless(f.s == 24.0)
-        self.failUnless(f.value[s] is f.s)
+        self.failUnless(f[s] == 24.0)
 
     def test_same_names(self):
         a,x,s = T.scalars('xxx')
@@ -370,112 +365,112 @@ class T_function(unittest.TestCase):
         g = function([x, In(a, value=1.0,name='a'), In(s, value=f.container[s], update=s-a*x, mutable=True)], s+a*x)
 
         f(1, 2)
-        self.failUnless(f.s == 2)
-        self.failUnless(g.s == 2)
+        self.failUnless(f[s] == 2)
+        self.failUnless(g[s] == 2)
         g(1, 2)
-        self.failUnless(f.s == 0)
-        self.failUnless(g.s == 0)
+        self.failUnless(f[s] == 0)
+        self.failUnless(g[s] == 0)
 
 
-class T_function_examples(unittest.TestCase):
-    def test_accumulator(self):
-        """Test low-level interface with state."""
-        x = T.scalar('x')
-        s = T.scalar('s')
+# class T_function_examples(unittest.TestCase):
+#     def test_accumulator(self):
+#         """Test low-level interface with state."""
+#         x = T.scalar('x')
+#         s = T.scalar('s')
 
-        fn, states = program_states(inputs = [x], outputs = [], states = [(s, 0, s+x)])
+#         fn, states = program_states(inputs = [x], outputs = [], states = [(s, 0, s+x)])
 
-        sum = 0
-        for inc in [1, 4, 5,23, -324]:
-            sum += inc
-            fn.run([inc], states)
-            assert sum == states[0].value
+#         sum = 0
+#         for inc in [1, 4, 5,23, -324]:
+#             sum += inc
+#             fn.run([inc], states)
+#             assert sum == states[0].value
 
 
-    def test_misc0(self):
+#     def test_misc0(self):
 
-        fn_inc, states_inc = function_states(\
-                inputs = [x], outputs = [], states = [(s, 0, s+x)])
+#         fn_inc, states_inc = function_states(\
+#                 inputs = [x], outputs = [], states = [(s, 0, s+x)])
 
-        fn_inc2, states_inc2 = function_states(\
-                inputs = [x], outputs = [], states = [(s, 0, s+x)])
+#         fn_inc2, states_inc2 = function_states(\
+#                 inputs = [x], outputs = [], states = [(s, 0, s+x)])
 
-        fn_inc_copy = copy.copy(fn_inc) #USE fn copy
+#         fn_inc_copy = copy.copy(fn_inc) #USE fn copy
 
-        # run() is like __call__, but requires an explicit state argument
+#         # run() is like __call__, but requires an explicit state argument
 
-        fn_inc.run([5], states_inc) #run on own state object
-        fn_inc2.run([3], states_inc) #run on compatible state object
-        assert states_inc[0].value == 8
+#         fn_inc.run([5], states_inc) #run on own state object
+#         fn_inc2.run([3], states_inc) #run on compatible state object
+#         assert states_inc[0].value == 8
 
-        states_inc_copy = copy.copy(states_inc) #USE state copy
-        fn_inc_copy.run([2], states_inc_copy)
-        assert states_inc[0].value == 10   #compatible
+#         states_inc_copy = copy.copy(states_inc) #USE state copy
+#         fn_inc_copy.run([2], states_inc_copy)
+#         assert states_inc[0].value == 10   #compatible
 
-        fn_dec, states_dec = function_states(\
-                inputs = [x], outputs = [], states = [((s, s-x), states_inc[0])])
+#         fn_dec, states_dec = function_states(\
+#                 inputs = [x], outputs = [], states = [((s, s-x), states_inc[0])])
 
-        try:
-            fn_inc.run([5], states_dec) # wrong kind of state for given program
-            self.fail("fn accepted an invalid state argument")
-        except SpecificException:
-            raise NotImplementedError() #TODO
-        except Exception:
-            self.fail("fn accepted an invalid state argument")
+#         try:
+#             fn_inc.run([5], states_dec) # wrong kind of state for given program
+#             self.fail("fn accepted an invalid state argument")
+#         except SpecificException:
+#             raise NotImplementedError() #TODO
+#         except Exception:
+#             self.fail("fn accepted an invalid state argument")
 
-    def test_perceptron(self):
-        """Test high-level state interface."""
+#     def test_perceptron(self):
+#         """Test high-level state interface."""
 
-        mu0 = numpy.array([1.0,0.0])
-        mu1 = numpy.array([0.0,0.1])
-        si0 = numpy.ones_like(mu0) #unit variance
-        si1 = numpy.ones_like(mu1) #unit variance
+#         mu0 = numpy.array([1.0,0.0])
+#         mu1 = numpy.array([0.0,0.1])
+#         si0 = numpy.ones_like(mu0) #unit variance
+#         si1 = numpy.ones_like(mu1) #unit variance
 
-        #implicit internal state
-        r_state = random.random_state()
-        label = r_state.bernoulli(0.5) 
+#         #implicit internal state
+#         r_state = random.random_state()
+#         label = r_state.bernoulli(0.5) 
 
-        #implicit internal state for each DiagGaussian
-        x = label * DiagGaussian(mu0, si0, state=r_state) \
-                + (1 - label) * random.DiagGaussian(mu1, si1, state=r_state)
+#         #implicit internal state for each DiagGaussian
+#         x = label * DiagGaussian(mu0, si0, state=r_state) \
+#                 + (1 - label) * random.DiagGaussian(mu1, si1, state=r_state)
 
-        w = T.tensor.dvector()
-        b = T.tensor.dscalar()
-        lr = 0.01
+#         w = T.tensor.dvector()
+#         b = T.tensor.dscalar()
+#         lr = 0.01
 
-        decision = dot(x,w) + b > 0
-        new_w = w + neq(label, decision) * lr * x
-        new_b = b + neq(label, decision) * (label * (-lr) + (1-label)*lr)
+#         decision = dot(x,w) + b > 0
+#         new_w = w + neq(label, decision) * lr * x
+#         new_b = b + neq(label, decision) * (label * (-lr) + (1-label)*lr)
 
-        init_w = numpy.array([0.0, 0.0])
-        init_b = 0.0
+#         init_w = numpy.array([0.0, 0.0])
+#         init_b = 0.0
 
-        io_stream = T.function([], [label, x], state={'seed':(r_state, 42)})
+#         io_stream = T.function([], [label, x], state={'seed':(r_state, 42)})
 
-        perceptron_learn = T.function([x, label], [decision], 
-                state={
-                    'w':((w, update_w), init_w),
-                    'b':((b, update_b), init_b),
-                    'lr':(lr, 0.01)})
+#         perceptron_learn = T.function([x, label], [decision], 
+#                 state={
+#                     'w':((w, update_w), init_w),
+#                     'b':((b, update_b), init_b),
+#                     'lr':(lr, 0.01)})
 
-        perceptron_use = T.function([x], [decision],
-                state={
-                    'w':(w, perceptron_learn.shared['w']),
-                    'b':(b, perceptron_learn.shared['b'])})
+#         perceptron_use = T.function([x], [decision],
+#                 state={
+#                     'w':(w, perceptron_learn.shared['w']),
+#                     'b':(b, perceptron_learn.shared['b'])})
 
-        errs = 0
-        for i in xrange(100):
-            il, ix = io_stream()
+#         errs = 0
+#         for i in xrange(100):
+#             il, ix = io_stream()
 
-            d0 = perceptron_use(ix)
-            d1 = perceptron_learn(ix, il)
+#             d0 = perceptron_use(ix)
+#             d1 = perceptron_learn(ix, il)
 
-            assert d0 == d1
+#             assert d0 == d1
 
-            errs += (d0 != d1)
+#             errs += (d0 != d1)
 
-            print d0
-        print 'errs =', errs 
+#             print d0
+#         print 'errs =', errs 
 
 
 # class T_dict_interface(unittest.TestCase):
@@ -540,7 +535,7 @@ class T_function_examples(unittest.TestCase):
 
 if __name__ == '__main__':
 
-    if 0:
+    if 1:
         unittest.main()
     else:
         testcases = []

_test_sparse.py

@@ -8,6 +8,10 @@ from sparse import _is_dense, _is_sparse, _is_dense_result, _is_sparse_result
 from sparse import _mtypes, _mtype_to_str
 
 import random
+import gof
+
+def eval_outputs(outputs):
+    return compile.function([], outputs)()[0]
 
 class T_transpose(unittest.TestCase):
     def setUp(self):
@@ -23,7 +27,7 @@ class T_transpose(unittest.TestCase):
         self.failUnless(ta.type.dtype == 'float64', ta.type.dtype)
         self.failUnless(ta.type.format == 'csr', ta.type.format)
 
-        vta = compile.eval_outputs([ta])
+        vta = eval_outputs([ta])
         self.failUnless(vta.shape == (3,5))
     def test_transpose_csr(self):
         a = as_sparse(sparse.csr_matrix(sparse.speye(5,3)))
@@ -34,7 +38,7 @@ class T_transpose(unittest.TestCase):
         self.failUnless(ta.type.dtype == 'float64', ta.type.dtype)
         self.failUnless(ta.type.format == 'csc', ta.type.format)
 
-        vta = compile.eval_outputs([ta])
+        vta = eval_outputs([ta])
         self.failUnless(vta.shape == (3,5))
 
 class T_Add(unittest.TestCase):
@@ -60,7 +64,7 @@ class T_Add(unittest.TestCase):
             self.failUnless(apb.type.format == aR.type.format, apb.type.format)
             self.failUnless(apb.type.format == bR.type.format, apb.type.format)
 
-            val = compile.eval_outputs([apb])
+            val = eval_outputs([apb])
             self.failUnless(val.shape == (3,2))
             self.failUnless(numpy.all(val.todense() == (a + b).todense()))
             self.failUnless(numpy.all(val.todense() == numpy.array([[1., 2], [3, 4], [5, 6]])))
@@ -85,7 +89,7 @@ class T_Add(unittest.TestCase):
             self.failUnless(apb.type.dtype == aR.type.dtype, apb.type.dtype)
             self.failUnless(apb.type.dtype == bR.type.dtype, apb.type.dtype)
 
-            val = compile.eval_outputs([apb])
+            val = eval_outputs([apb])
             self.failUnless(val.shape == (3, 2))
             self.failUnless(numpy.all(val == (a + b)))
             self.failUnless(numpy.all(val == numpy.array([[1., 2], [3, 4], [5, 6]])))
@@ -110,7 +114,7 @@ class T_Add(unittest.TestCase):
             self.failUnless(apb.type.dtype == aR.type.dtype, apb.type.dtype)
             self.failUnless(apb.type.dtype == bR.type.dtype, apb.type.dtype)
 
-            val = compile.eval_outputs([apb])
+            val = eval_outputs([apb])
             self.failUnless(val.shape == (3, 2))
             self.failUnless(numpy.all(val == (a + b)))
             self.failUnless(numpy.all(val == numpy.array([[1., 2], [3, 4], [5, 6]])))
@@ -122,14 +126,14 @@ class T_conversion(unittest.TestCase):
     def test0(self):
         a = tensor.as_tensor(numpy.random.rand(5))
         s = csc_from_dense(a)
-        val = compile.eval_outputs([s])
+        val = eval_outputs([s])
         self.failUnless(str(val.dtype)=='float64')
         self.failUnless(val.format == 'csc')
 
     def test1(self):
         a = tensor.as_tensor(numpy.random.rand(5))
         s = csr_from_dense(a)
-        val = compile.eval_outputs([s])
+        val = eval_outputs([s])
         self.failUnless(str(val.dtype)=='float64')
         self.failUnless(val.format == 'csr')
 
@@ -138,7 +142,7 @@ class T_conversion(unittest.TestCase):
             s = t((2,5))
             d = dense_from_sparse(s)
             s[0,0] = 1.0
-            val = compile.eval_outputs([d])
+            val = eval_outputs([d])
             self.failUnless(str(val.dtype)=='float64')
             self.failUnless(numpy.all(val[0] == [1,0,0,0,0]))
 
@@ -159,7 +163,7 @@ class _testCase_dot(unittest.TestCase):
 
             zop = dot(x,xT)
             self.failUnless(_is_sparse_result(zop))
-            z = compile.eval_outputs([zop])
+            z = eval_outputs([zop])
             self.failUnless(_is_sparse(z))
             self.failUnless(z.shape == (500,500))
             self.failUnless(type(z) is mtype)
@@ -190,7 +194,7 @@ class _testCase_dot(unittest.TestCase):
 
             zop = dot(x,y)
             self.failUnless(_is_sparse_result(zop))
-            z = compile.eval_outputs([zop])
+            z = eval_outputs([zop])
             self.failUnless(_is_sparse(z))
             self.failUnless(z.shape == (500,2))
             self.failUnless(type(z) is mtype)
@@ -227,7 +231,7 @@ class _testCase_dot(unittest.TestCase):
 #            zop = dot(y, x)
             zop = transpose(dot(y, x))
             self.failUnless(_is_sparse_result(zop))
-            z = compile.eval_outputs([zop])
+            z = eval_outputs([zop])
             self.failUnless(_is_sparse(z))
             self.failUnless(z.shape == (500,2))
 #            self.failUnless(type(z) is mtype)

_test_tensor.py

@@ -6,7 +6,7 @@ import tensor # for hidden symbols
 
 import unittest
 from copy import copy
-from compile import function, FunctionFactory, eval_outputs
+import compile
 import gradient
 import gof, gof.graph
 from gof.python25 import any
@@ -15,6 +15,21 @@ from gof.utils import AbstractFunctionError
 
 from elemwise import DimShuffle
 
+
+default_mode = compile.Mode(optimizer = None,
+                            linker = 'c&py')
+
+def function(inputs, outputs, mode = default_mode):
+    return compile.function(inputs, outputs, mode = mode, accept_inplace = True)
+
+
+def eval_outputs(outputs, mode = default_mode):
+    results = function([], outputs, mode = mode)()
+    if len(results) == 1:
+        return results[0]
+    return results
+
+
 def _numpy_checker(x, y):
     """
     Checks if x.data and y.data have the same contents.
@@ -56,9 +71,8 @@ def make_tester(name, op, expected, checks = {}, good = {}, bad_build = {}, bad_
 
                 try:
                     f = function(inputrs, node.outputs,
-                                 linker = 'c&py', ##lambda env, **kwargs: gof.DualLinker(env, checker = _numpy_checker, **kwargs),
-                                 unpack_single = False,
-                                 optimizer = None)
+                                 mode = default_mode, ##lambda env, **kwargs: gof.DualLinker(env, checker = _numpy_checker, **kwargs),
+                                 )
                 except:
                     type, exc_value, traceback = sys.exc_info()
                     err_msg = "Test %s::%s: Error occurred while trying to make a Function" \
@@ -115,9 +129,8 @@ def make_tester(name, op, expected, checks = {}, good = {}, bad_build = {}, bad_
 
                 try:
                     f = function(inputrs, node.outputs,
-                                 linker = 'c&py', #lambda env, **kwargs: gof.DualLinker(env, checker = _numpy_checker, **kwargs),
-                                 unpack_single = False,
-                                 optimizer = None)
+                                 mode = default_mode, #lambda env, **kwargs: gof.DualLinker(env, checker = _numpy_checker, **kwargs),
+                                 )
                 except:
                     type, exc_value, traceback = sys.exc_info()
                     err_msg = "Test %s::%s: Error occurred while trying to make a Function" \
@@ -530,14 +543,14 @@ def verify_grad(testcase, op, pt, n_tests=1, rng=numpy.random, eps=0.0000001, to
             # we could make loop over outputs making random projections R for each,
             # but this doesn't handle the case where not all the outputs are
             # differentiable... so I leave this as TODO for now -JB.
-        o_fn = function(tensor_pt, o_outputs, linker=linker)
+        o_fn = function(tensor_pt, o_outputs[0], mode=compile.Mode(optimizer = None, linker = linker))
         o_fn_out = o_fn(*pt)
         random_projection = rng.rand(*o_fn_out.shape)
         t_r = as_tensor(random_projection)
 
         #random projection of o onto t_r
         cost = sum(t_r * o_outputs[0])
-        cost_fn = function(tensor_pt, [cost], linker=linker)
+        cost_fn = function(tensor_pt, cost, mode=compile.Mode(optimizer = None, linker = linker))
 
         num_grad = gradient.numeric_grad(cost_fn, pt)
 
@@ -549,7 +562,7 @@ def verify_grad(testcase, op, pt, n_tests=1, rng=numpy.random, eps=0.0000001, to
             for op in gof.graph.io_toposort(tensor_pt, symbolic_grad):
                 print op
 
-        grad_fn = function(tensor_pt, symbolic_grad,linker=linker)
+        grad_fn = function(tensor_pt, symbolic_grad, mode=compile.Mode(optimizer = None, linker = linker))
 
         analytic_grad = grad_fn(*pt)
         if not isinstance(analytic_grad, (list, tuple)):
@@ -584,24 +597,24 @@ def _approx_eq(a,b,eps=1.0e-9):
     return  True
 _approx_eq.debug = 0
 
-def check_eq(self, node_in, node_out, arg_in, arg_out):
-    fn = Function([node_in], [node_out])
-    self.failUnless( numpy.all(fn(arg_in) == arg_out), (arg_in, arg_out))
+# def check_eq(self, node_in, node_out, arg_in, arg_out):
+#     fn = Function([node_in], node_out)
+#     self.failUnless( numpy.all(fn(arg_in) == arg_out), (arg_in, arg_out))
 
-def check_eq2(self, inputs, output, args_in, arg_out):
-    fn = Function(inputs, [output])
-    val = fn(*args_in)
-    self.failUnless( numpy.all(val == arg_out), (val, arg_out))
+# def check_eq2(self, inputs, output, args_in, arg_out):
+#     fn = Function(inputs, output)
+#     val = fn(*args_in)
+#     self.failUnless( numpy.all(val == arg_out), (val, arg_out))
 
-def check_eq2_c(self, inputs, output, args_in, arg_out):
-    fn = Function(inputs, [output], linker_cls = gof.CLinker)
-    val = fn(*args_in)
-    self.failUnless( numpy.all(val == arg_out), (val, arg_out))
+# def check_eq2_c(self, inputs, output, args_in, arg_out):
+#     fn = Function(inputs, [output], linker_cls = gof.CLinker)
+#     val = fn(*args_in)
+#     self.failUnless( numpy.all(val == arg_out), (val, arg_out))
 
-def check_eq2_both(self, inputs, output, args_in, arg_out):
-    fn = Function(inputs, [output], linker_cls = lambda env: gof.DualLinker(env, _numpy_checker))
-    val = fn(*args_in)
-    self.failUnless( numpy.all(val == arg_out), (val, arg_out))
+# def check_eq2_both(self, inputs, output, args_in, arg_out):
+#     fn = Function(inputs, [output], linker_cls = lambda env: gof.DualLinker(env, _numpy_checker))
+#     val = fn(*args_in)
+#     self.failUnless( numpy.all(val == arg_out), (val, arg_out))
 
 class T_Shape(unittest.TestCase):
     def test_basic0(self):
@@ -622,7 +635,7 @@ class T_Cast(unittest.TestCase):
                                         [convert_to_int8, convert_to_int16, convert_to_int32, convert_to_int64,
                                          convert_to_float32, convert_to_float64]):
                 y = converter(x)
-                f = function([x], [y], strict = True, linker = 'c&py')
+                f = function([x], y, strict = True, mode = default_mode)
                 a = numpy.arange(10, dtype = type1)
                 b = f(a)
                 self.failUnless(numpy.all(b == numpy.arange(10, dtype = type2)))
@@ -690,7 +703,7 @@ class T_transpose(unittest.TestCase):
         n = as_tensor(numpy.ones(()))
         t = transpose(n)
         self.failUnless(t.owner.op == transpose_inplace)
-        f = function([n], [t])
+        f = function([n], t)
         tval = f(n.data)
         self.failUnless(tval.shape == n.data.shape)
 
@@ -702,7 +715,7 @@ class T_transpose(unittest.TestCase):
         n = as_tensor(numpy.ones(5))
         t = transpose(n)
         self.failUnless(t.owner.op == transpose_inplace)
-        f = function([n], [t])
+        f = function([n], t)
         tval = f(n.data)
         self.failUnless(tval.shape == n.data.shape)
         #test aliasing
@@ -713,7 +726,7 @@ class T_transpose(unittest.TestCase):
         n = as_tensor(numpy.ones((5,3)))
         t = transpose(n)
         self.failUnless(t.owner.op == transpose_inplace)
-        f = function([n], [t])
+        f = function([n], t)
         tval = f(n.data)
         self.failUnless(tval.shape == (3,5))
         #test aliasing
@@ -725,7 +738,7 @@ class T_transpose(unittest.TestCase):
         n = as_tensor(numpy.ones((5,3,2)))
         t = transpose_inplace(n)
         self.failUnless(t.owner.op == transpose_inplace)
-        f = function([n], [t])
+        f = function([n], t)
         tval = f(n.data)
         self.failUnless(tval.shape == (2,3,5))
         #test aliasing
@@ -949,7 +962,7 @@ class T_Stack(unittest.TestCase):
 class _test_comparison(unittest.TestCase):
     def test_gt(self):
         x, y = fvector(), fvector()
-        fn = function([x,y], [x > y])
+        fn = function([x,y], x > y)
         l = numpy.asarray([0.,-1.,1.])
         r = numpy.asarray([0.,1.,-1.])
         v = fn(l, r)
@@ -957,7 +970,7 @@ class _test_comparison(unittest.TestCase):
 
     def test_lt(self):
         x, y = fvector(), fvector()
-        fn = function([x,y], [x < y])
+        fn = function([x,y], x < y)
         l = numpy.asarray([0.,-1.,1.])
         r = numpy.asarray([0.,1.,-1.])
         v = fn(l, r)
@@ -965,7 +978,7 @@ class _test_comparison(unittest.TestCase):
 
     def test_le(self):
         x, y = fvector(), fvector()
-        fn = function([x,y], [x <= y])
+        fn = function([x,y], x <= y)
         l = numpy.asarray([0.,-1.,1.])
         r = numpy.asarray([0.,1.,-1.])
         v = fn(l, r)
@@ -973,7 +986,7 @@ class _test_comparison(unittest.TestCase):
 
     def test_ge(self):
         x, y = fvector(), fvector()
-        fn = function([x,y], [x >= y])
+        fn = function([x,y], x >= y)
         l = numpy.asarray([0.,-1.,1.])
         r = numpy.asarray([0.,1.,-1.])
         v = fn(l, r)
@@ -981,7 +994,7 @@ class _test_comparison(unittest.TestCase):
 
     def test_eq(self):
         x, y = fvector(), fvector()
-        fn = function([x,y], [eq(x,y)])
+        fn = function([x,y], eq(x,y))
         l = numpy.asarray([0.,-1.,1.])
         r = numpy.asarray([0.,1.,-1.])
         v = fn(l, r)
@@ -989,7 +1002,7 @@ class _test_comparison(unittest.TestCase):
 
     def test_neq(self):
         x, y = fvector(), fvector()
-        fn = function([x,y], [neq(x, y)])
+        fn = function([x,y], neq(x, y))
         l = numpy.asarray([0.,-1.,1.])
         r = numpy.asarray([0.,1.,-1.])
         v = fn(l, r)
@@ -998,7 +1011,7 @@ class _test_comparison(unittest.TestCase):
 class _test_bitwise(unittest.TestCase):
     def test_or(self):
         x, y = bvector(), bvector()
-        fn = function([x,y], [x|y])
+        fn = function([x,y], x|y)
         l = numpy.asarray([0,0,1,1], dtype = 'int8')
         r = numpy.asarray([0,1,0,1], dtype = 'int8')
         v = fn(l, r)
@@ -1006,10 +1019,10 @@ class _test_bitwise(unittest.TestCase):
 
     def test_xor(self):
         x, y = bvector(), bvector()
-        fn = function([x,y], [x^y])
+        fn = function([x,y], x^y)
         ix = x
         ix ^= y
-        gn = function([x,y], [ix])
+        gn = function([x,y], ix)
         l = numpy.asarray([0,0,1,1], dtype = 'int8')
         r = numpy.asarray([0,1,0,1], dtype = 'int8')
         v = fn(l, r)
@@ -1020,7 +1033,7 @@ class _test_bitwise(unittest.TestCase):
 
     def test_and(self):
         x, y = bvector(), bvector()
-        fn = function([x,y], [x&y])
+        fn = function([x,y], x&y)
         l = numpy.asarray([0,0,1,1], dtype = 'int8')
         r = numpy.asarray([0,1,0,1], dtype = 'int8')
         v = fn(l, r)
@@ -1028,7 +1041,7 @@ class _test_bitwise(unittest.TestCase):
 
     def test_inv(self):
         x, y = bvector(), bvector()
-        fn = function([x,y], [~x])
+        fn = function([x,y], ~x)
         l = numpy.asarray([0,0,1,1], dtype = 'int8')
         r = numpy.asarray([0,1,0,1], dtype = 'int8')
         v = fn(l, r)
@@ -1047,7 +1060,7 @@ class T_add(unittest.TestCase):
                      ("*", lambda x,y: x*y),
                      ("/", lambda x,y: x/y))
             for s, fn in tests:
-                f = function([a,b], [fn(a, b)], linker = 'c')
+                f = function([a,b], fn(a, b), mode = compile.Mode(optimizer = None, linker = 'c'))
                 self.failUnless(numpy.all(fn(a.data, b.data) == f(a.data, b.data)))
 
     def test_grad_scalar_l(self):
@@ -1313,7 +1326,7 @@ class t_dot(unittest.TestCase):
     def not_aligned(self, x, y):
         z = dot(x,y)
         try:
-            tz = eval_outputs([z])
+            tz = eval_outputs([z], mode = compile.Mode(optimizer = None, linker = 'py'))
         except ValueError, e:
             self.failUnless(e[0].split()[1:4] == ['are', 'not', 'aligned'], e)
             return
@@ -1359,7 +1372,7 @@ class t_gemm(unittest.TestCase):
             z_orig = z.copy()
             tz,ta,tx,ty,tb = [as_tensor(p).type() for p in z,a,x,y,b]
 
-            f = function([tz,ta,tx,ty,tb], [gemm(tz,ta,tx,ty,tb)], linker=l)
+            f = function([tz,ta,tx,ty,tb], gemm(tz,ta,tx,ty,tb), mode=compile.Mode(optimizer = None, linker = l))
             new_z = f(z,a,x,y,b)
             z_after = self._gemm(z_orig, a, x, y, b)
 
@@ -1481,7 +1494,7 @@ class t_gemm(unittest.TestCase):
 
             tz,ta,tx,ty,tb = [value(p) for p in z,a,x,y,b]
 
-            f = function([tz,ta,tx,ty,tb], [gemm(tz,ta,tx,ty,tb)], linker=l)
+            f = function([tz,ta,tx,ty,tb], gemm(tz,ta,tx,ty,tb), mode = compile.Mode(optimizer = None, linker=l))
             f(z, a, x, y, b)
             self.failUnless(_approx_eq(z_after, z), (z_orig, z_after, z))
             f(z.T, a, y.T, x.T, b)
@@ -1730,8 +1743,8 @@ class T_op_cache(unittest.TestCase):
         v = matrix()
         v.name = 'v'
         gv = fill(v/v, 1.0)/v - (fill(v/v, 1.0) * v) / (v*v)
-        fn_py = function([v], [gv], linker = 'py')
-        fn_c_or_py = function([v], [gv], linker = 'c|py')
+        fn_py = function([v], gv, mode = compile.Mode(optimizer = None, linker = 'py'))
+        fn_c_or_py = function([v], gv, compile.Mode(optimizer = None, linker = 'c|py'))
 
         a = numpy.random.rand(5,2)
         self.failUnless(numpy.all(fn_py(a) == fn_c_or_py(a)))

compile.py

@@ -64,7 +64,9 @@ default_linker = 'c|py'
 predefined_optimizers = {
     None    : lambda env: None,
     'merge' : gof.MergeOptimizer(),
-    'math'  : gof.MergeOptMerge(tensor_opt.math_optimizer)
+    'math'  : gof.MergeOptMerge(
+        gof.PureThenInplaceOptimizer(tensor_opt.math_optimizer,
+                                     tensor_opt.inplace_optimizer))
     }
 
 default_optimizer = 'merge'
@@ -87,6 +89,12 @@ class Mode(object):
     """
     
     def __init__(self, linker = default_linker, optimizer = default_optimizer):
+        self.__setstate__((linker, optimizer))
+
+    def __getstate__(self):
+        return (self.provided_linker, self.provided_optimizer)
+
+    def __setstate__(self, (linker, optimizer)):
         self.provided_linker = linker
         self.provided_optimizer = optimizer
         if isinstance(linker, str) or linker is None:
@@ -104,9 +112,9 @@ class Mode(object):
 # string as the key
 predefined_modes = {
     'SANITY_CHECK'            : Mode('c&py', 'math'),
-    'FAST_COMPILE'            : Mode('py', None),
+    'FAST_COMPILE'            : Mode('py', 'merge'),
     'FAST_RUN'                : Mode('c|py', 'math'),
-    'EXPENSIVE_OPTIMIZATIONS' : Mode('c|py', 'math')
+    'EXPENSIVE_OPTIMIZATIONS' : Mode('c|py', 'math'),
     }
 
 default_mode = 'FAST_RUN'
@@ -134,17 +142,22 @@ class SymbolicInput(object):
         True: permit the compiled function to modify the python object being passed as the input
         False: do not permit the compiled function to modify the python object being passed as the input.
 
+    strict: Bool (default: False)
+        True: means that the value you pass for this input must have exactly the right type
+        False: the value you pass for this input may be casted automatically to the proper type
+
     autoname: Bool (default: True)
         See the name option.
     """
 
-    def __init__(self, result, name=None, update=None, mutable=None, autoname=True):
+    def __init__(self, result, name=None, update=None, mutable=None, strict=False, autoname=True):
         self.result = result
         self.name = result.name if (autoname and name is None) else name
         if self.name is not None and not isinstance(self.name, str):
             raise TypeError("name must be a string! (got: %s)" % self.name)
         self.update = update
         self.mutable = mutable if (mutable is not None) else (update is not None)
+        self.strict = strict
 
     def __str__(self):
         if self.update:
@@ -168,6 +181,8 @@ class SymbolicInputKit(object):
     """
 
     def __init__(self, name):
+        if not isinstance(name, str):
+            raise TypeError('naem must be a string (got: %s)' % name)
         self.name = name
         self.sinputs = []
         self.results = []
@@ -234,11 +249,15 @@ class In(SymbolicInput):
         True: permit the compiled function to modify the python object being passed as the input
         False: do not permit the compiled function to modify the python object being passed as the input.
 
+    strict: Bool (default: False)
+        True: means that the value you pass for this input must have exactly the right type
+        False: the value you pass for this input may be casted automatically to the proper type
+
     autoname: Bool (default: True)
         See the name option.
     """
-    def __init__(self, result, name=None, value=None, update=None, mutable=None, autoname=True):
-        super(In, self).__init__(result, name, update, mutable, autoname)
+    def __init__(self, result, name=None, value=None, update=None, mutable=None, strict=False, autoname=True):
+        super(In, self).__init__(result, name, update, mutable, strict, autoname)
         self.value = value
 
 
@@ -352,7 +371,7 @@ class FunctionMaker(object):
         else:
             raise TypeError("Unknown output type:", type(output), output)
 
-    def __init__(self, inputs, outputs, mode = 'FAST_RUN', accept_inplace = True):
+    def __init__(self, inputs, outputs, mode = 'FAST_RUN', accept_inplace = False):
         """
         Create a FunctionMaker for the specified inputs, outputs and mode.
 
@@ -407,6 +426,8 @@ class FunctionMaker(object):
         self.expanded_inputs = expanded_inputs
         self.outputs = outputs
         self.unpack_single = unpack_single
+        self.mode = mode
+        self.accept_inplace = accept_inplace
 
     def create(self, defaults = None, trustme = False):
         """
@@ -427,12 +448,12 @@ class FunctionMaker(object):
         for (input, indices, subinputs), default in zip(self.indices, defaults):
             __default = default
 
-            # If the default is a gof.Filter, this means we want to share
+            # If the default is a gof.Container, this means we want to share
             # the same storage. This is done by appending default.storage
             # to input_storage
-            if isinstance(default, gof.Filter):
+            if isinstance(default, gof.Container):
                 if indices is not None:
-                    raise TypeError("Cannot take a Filter instance as default for a SymbolicInputKit.")
+                    raise TypeError("Cannot take a Container instance as default for a SymbolicInputKit.")
                 input_storage.append(default.storage)
                 default = None
             # If the input is a SymbolicInputKit, it represents more than
@@ -464,7 +485,7 @@ class FunctionMaker(object):
                 # back into the storage as it would defeat the point of updating it. We
                 # always do this policy.
                 if default is None:
-                    if trustme or isinstance(__default, gof.Filter):
+                    if trustme or isinstance(__default, gof.Container):
                         _defaults.append((False, False, default))
                     else:
                         # This might catch some bugs early
@@ -487,8 +508,28 @@ class FunctionMaker(object):
         return fn
 
 
+import copy_reg
+import cPickle
+
+def _pickle_FunctionMaker(fm):
+    return (_constructor_FunctionMaker, (fm.inputs, fm.outputs, fm.mode, fm.accept_inplace))
+
+def _constructor_FunctionMaker(*args):
+    return FunctionMaker(*args)
+
+copy_reg.pickle(FunctionMaker, _pickle_FunctionMaker)
+
+
+def _pickle_slice(s):
+    return (slice, (s.start, s.stop, s.step))
+
+copy_reg.pickle(slice, _pickle_slice)
+
+
+
 from functools import partial
 
+
 DUPLICATE = ['DUPLICATE'] # unique id object used as a placeholder for duplicate entries
 class Function(object):
     """
@@ -498,8 +539,8 @@ class Function(object):
     def __init__(self, fn, input_storage, output_storage, indices, outputs, defaults, unpack_single, maker):
         """
         fn -> a function returned by some linker's make_thunk method
-        input_storage -> list of Filter instances used by fn to fetch the inputs
-        output_storage -> list of Filter instances used by fn to store the outputs in
+        input_storage -> list of Container instances used by fn to fetch the inputs
+        output_storage -> list of Container instances used by fn to store the outputs in
         indices -> list of (SymbolicInput|SymbolicInputKit, indices, [SymbolicInput,...]), one tuple for each input
         defaults -> list of (required (bool), refeed (bool), value), one tuple for each input
             required -> whether this input is required or optional
@@ -531,6 +572,8 @@ class Function(object):
         for i, ((input, indices, sinputs), (required, refeed, value)) in enumerate(zip(self.indices, defaults)):
             if indices is None: # this is true iff input is not a SymbolicInputKit
                 c = containers[0]
+                if input.strict:
+                    c.strict = True
                 if value is not None:
                     # always initialize the storage
                     c.data = value
@@ -591,7 +634,7 @@ class Function(object):
                     raise TypeError("Unknown input or state: %s" % item)
                 if s is DUPLICATE:
                     raise TypeError("Ambiguous name: %s - please check the names of the inputs of your function for duplicates." % item)
-                if isinstance(s, gof.Filter):
+                if isinstance(s, gof.Container):
                     return s.value
                 else:
                     raise NotImplementedError
@@ -602,7 +645,7 @@ class Function(object):
                     raise TypeError("Unknown input or state: %s" % item)
                 if s is DUPLICATE:
                     raise TypeError("Ambiguous name: %s - please check the names of the inputs of your function for duplicates." % item)
-                if isinstance(s, gof.Filter):
+                if isinstance(s, gof.Container):
                     s.value = value
                     s.provided += 1
                 else:
@@ -625,6 +668,7 @@ class Function(object):
     def __setitem__(self, item, value):
         self.value[item] = value
         
+    
     def __copy__(self):
         defaults = [default for _1, _2, default in self.defaults]
         cpy = self.maker.create(defaults, trustme = True)
@@ -677,6 +721,26 @@ class Function(object):
         doc="""TODOC""")
 
 
+def _pickle_Function(f):
+    ins = list(f.input_storage)
+    defaults = []
+    for (input, indices, inputs), (required, refeed, default) in zip(f.indices, f.defaults):
+        if isinstance(input, SymbolicInputKit):
+            defaults.append(default)
+            ins[:len(indices)] = []
+        else:
+            defaults.append(ins[0])
+            del ins[0]
+    return (_constructor_Function, (f.maker, defaults, [x.data for x in f.input_storage]))
+
+def _constructor_Function(maker, defaults, data):
+    f = maker.create(defaults, trustme = True)
+    for container, x in zip(f.input_storage, data):
+        container.data = x
+    return f
+
+copy_reg.pickle(Function, _pickle_Function)
+
 
 def function(inputs, outputs, mode='FAST_RUN', accept_inplace = False):
     """
@@ -759,34 +823,8 @@ def function(inputs, outputs, mode='FAST_RUN', accept_inplace = False):
     inputs = map(wrap_in, inputs)
     outputs = map(wrap_out, outputs) if isinstance(outputs, (list, tuple)) else wrap_out(outputs)
 
-    # create a subclass of Function for the given arguments.
-    class F(Function):
-        pass
-
     fn = FunctionMaker(inputs, outputs, mode, accept_inplace = accept_inplace).create([getattr(input, 'value', None) for input in inputs])
 
-    # add all input names as properties of F
-    def _get(name, self):
-        return self[name]
-    def _set(name, self, value):
-        self[name] = value
-    def _err(name, self):
-        raise TypeError("Ambiguous name: %s - please check the names of the inputs of your function for duplicates." % name)
-    seen = set()
-    for input in inputs:
-        name = input.name
-        if name:
-            if name in seen:
-                f = property(partial(_err, input.name), partial(_err, input.name))
-                setattr(F, input.name, f)
-            elif not hasattr(F, name):
-                f = property(partial(_get, input.name), partial(_set, input.name))
-                setattr(F, input.name, f)
-                seen.add(input.name)
-            else:
-                pass
-
-    fn.__class__ = F
     return fn
 
 
@@ -825,10 +863,6 @@ class OpFromGraph(gof.Op):
     """
     
     def __init__(self, inputs, outputs, grad_depth = 1, **kwargs):
-        if kwargs.get('borrow_outputs') or kwargs.get('unpack_single'):
-            raise ValueError('The borrow_outputs and unpack_single options cannot be True')
-        kwargs['unpack_single'] = False
-        kwargs['borrow_outputs'] = False
         self.fn = function(inputs, outputs, **kwargs)
         self.inputs = inputs
         self.outputs = outputs

elemwise.py

@@ -7,6 +7,7 @@ import scalar
 from scalar import Scalar
 import gof
 from gof.python25 import all
+from copy import copy
 
 
 # tensor depends on elemwise to provide definitions for several ops
@@ -231,6 +232,15 @@ class Elemwise(Op):
         else:
             self.ufunc = None
 
+    def __getstate__(self):
+        d = copy(self.__dict__)
+        d.pop('ufunc')
+        return d
+    
+    def __setstate__(self, d):
+        self.__dict__.update(d)
+        self.ufunc = numpy.frompyfunc(self.scalar_op.impl, self.scalar_op.nin, self.scalar_op.nout)
+
     def make_node(self, *inputs):
         """
         If the inputs have different number of dimensions, their shape

gof/__init__.py

@@ -12,7 +12,7 @@ from graph import \
     Apply, Result, Constant, Value, view_roots
 
 from link import \
-    Filter, Linker, LocalLinker, PerformLinker, WrapLinker, Profiler
+    Container, Linker, LocalLinker, PerformLinker, WrapLinker, Profiler
 
 from op import \
     Op
@@ -22,7 +22,8 @@ from opt import \
     MergeOptimizer, MergeOptMerge, \
     LocalOptimizer, local_optimizer, LocalOptGroup, LocalOpKeyOptGroup, \
     OpSub, OpRemove, PatternSub, \
-    NavigatorOptimizer, TopoOptimizer, OpKeyOptimizer
+    NavigatorOptimizer, TopoOptimizer, OpKeyOptimizer, \
+    PureThenInplaceOptimizer
 
 from toolbox import \
     Bookkeeper, History, Validator, ReplaceValidate, NodeFinder, PrintListener

gof/cc.py

@@ -624,8 +624,8 @@ class CLinker(link.Linker):
                                     input_storage,
                                     output_storage)
         return thunk, \
-            [link.Filter(input, storage) for input, storage in zip(self.env.inputs, input_storage)], \
-            [link.Filter(output, storage, True) for output, storage in zip(self.env.outputs, output_storage)], \
+            [link.Container(input, storage) for input, storage in zip(self.env.inputs, input_storage)], \
+            [link.Container(output, storage, True) for output, storage in zip(self.env.outputs, output_storage)], \
             error_storage
 
     def make_thunk(self, input_storage = None, output_storage = None):
@@ -873,8 +873,8 @@ class OpWiseCLinker(link.LocalLinker):
 
         f = link.streamline(env, thunks, order, no_recycling = no_recycling, profiler = profiler)
 
-        return f, [link.Filter(input, storage) for input, storage in zip(env.inputs, input_storage)], \
-            [link.Filter(output, storage, True) for output, storage in zip(env.outputs, output_storage)], \
+        return f, [link.Container(input, storage) for input, storage in zip(env.inputs, input_storage)], \
+            [link.Container(output, storage, True) for output, storage in zip(env.outputs, output_storage)], \
             thunks, order
 
 
@@ -940,6 +940,7 @@ class DualLinker(link.Linker):
         no_recycling = self.no_recycling
 
         _f, i1, o1, thunks1, order1 = link.PerformLinker().accept(env, no_recycling = no_recycling).make_all(**kwargs)
+        kwargs.pop('input_storage', None)
         _f, i2, o2, thunks2, order2 =      OpWiseCLinker().accept(env, no_recycling = no_recycling).make_all(**kwargs)
 
         def f():

gof/graph.py

@@ -140,7 +140,7 @@ class Result(utils.object2):
             else:
                 return str(self.owner.op) + "." + str(self.index)
         else:
-            return "<?>::" + str(self.type)
+            return "<%s>" % str(self.type)
     def __repr__(self):
         return str(self)
     def clone(self):

gof/link.py

 
 import utils
 import graph
+from type import Type
 
 import sys, traceback
 from copy import copy
@@ -107,25 +108,30 @@ class Linker(object):
         return execute
 
 
-class Filter(object):
-    def __init__(self, r, storage, readonly = False, strict = False):
-        self.r = r
+class Container(object):
+    def __init__(self, r, storage, readonly = False, strict = False, name = None):
+        #self.r = r
+        if isinstance(r, Type):
+            self.type = r
+        else:
             self.type = r.type
+        self.name = name or r.name
         self.storage = storage
         self.readonly = readonly
         self.strict = strict
     def __get(self):
         return self.storage[0]
     def __set(self, value):
-        try:
         if self.readonly:
-                raise Exception("Cannot set readonly storage.")
+            raise Exception("Cannot set readonly storage: %s" % self.name)
+        try:
             if self.strict:
                 self.storage[0] = self.type.filter(value, strict = True)
             else:
                 self.storage[0] = self.type.filter(value)
-        except:
-            raise_with_op(self.r)
+        except Exception, e:
+            e.args = e.args + (self.name,)
+            raise
     data = property(__get, __set)
     value = property(__get, __set)
     def __str__(self):
@@ -256,8 +262,8 @@ class PerformLinker(LocalLinker):
 
         f = streamline(env, thunks, order, no_recycling = no_recycling, profiler = profiler)
   
-        return f, [Filter(input, storage) for input, storage in zip(env.inputs, input_storage)], \
-            [Filter(output, storage, True) for output, storage in zip(env.outputs, output_storage)], \
+        return f, [Container(input, storage) for input, storage in zip(env.inputs, input_storage)], \
+            [Container(output, storage, True) for output, storage in zip(env.outputs, output_storage)], \
             thunks, order
 
 
@@ -329,7 +335,9 @@ class WrapLinker(Linker):
     def make_thunk(self, **kwargs):
         no_recycling = self.no_recycling
 
-        make_all = [l.make_all(**kwargs) for l in self.linkers]
+        make_all = [self.linkers[0].make_all(**kwargs)]
+        kwargs.pop('input_storage', None)
+        make_all += [l.make_all(**kwargs) for l in self.linkers[1:]]
 
         fns, input_lists, output_lists, thunk_lists, order_lists \
                 = zip(*make_all)

gof/opt.py

@@ -12,6 +12,7 @@ import toolbox
 import op
 from copy import copy
 from collections import deque
+import destroyhandler as dh
 
 
 class Optimizer:
@@ -60,7 +61,7 @@ class FromFunctionOptimizer(Optimizer):
     def __init__(self, fn):
         self.apply = fn
     def add_requirements(self, env):
-        env.extend(gof.toolbox.ReplaceValidate)
+        env.extend(toolbox.ReplaceValidate())
 
 def optimizer(f):
     return FromFunctionOptimizer(f)
@@ -208,7 +209,7 @@ class FromFunctionLocalOptimizer(LocalOptimizer):
     def __init__(self, fn):
         self.transform = fn
     def add_requirements(self, env):
-        env.extend(gof.toolbox.ReplaceValidate)
+        env.extend(toolbox.ReplaceValidate())
 
 def local_optimizer(f):
     return FromFunctionLocalOptimizer(f)
@@ -608,6 +609,21 @@ def check_chain(r, *chain):
 
 
 
+############
+### Misc ###
+############
+
+class PureThenInplaceOptimizer(Optimizer):
+
+    def __init__(self, pure, inplace):
+        self.pure = pure
+        self.inplace = inplace
+
+    def apply(self, env):
+        self.pure(env)
+        env.extend(dh.DestroyHandler())
+        self.inplace(env)
+
 
 
 

scalar.py

@@ -252,16 +252,17 @@ def upcast_out(*types):
     return Scalar(dtype = Scalar.upcast(*types)),
 def same_out(type):
     return type,
-def transfer_type(i):
+class transfer_type:
+    def __init__(self, i):
         assert type(i) == int
-    def f(*types):
-        return types[i],
-    f.__name__ = "transfer_type_%i" % i
-    return f
-def specific_out(*spec):
-    def f(*types):
-        return spec
-    return f
+        self.i = i
+    def __call__(self, *types):
+        return types[self.i]
+class specific_out:
+    def __init__(self, *spec):
+        self.spec = spec
+    def __call__(self, *types):
+        return self.spec
 def int_out(*types):
     return int64,
 def float_out(*types):

tensor.py

@@ -82,10 +82,11 @@ class Tensor(Type):
           for L{broadcasting}, as described and implemented in Numpy.
     """
 
-    def __init__(self, dtype, broadcastable):
+    def __init__(self, dtype, broadcastable, name = None):
         self.dtype = str(dtype)
         self.broadcastable = tuple(broadcastable)
         self.dtype_specs() # error checking is done there
+        self.name = name
     
     def filter(self, data, strict = False):
         _data = data
@@ -141,10 +142,21 @@ class Tensor(Type):
         return TensorResult(self, name = name)
 
     def __str__(self):
-        return "%s(%s)" % (str(self.dtype), str(self.broadcastable))
+        if self.name:
+            return self.name
+        else:
+            b = self.broadcastable
+            #bcast = str(self.broadcastable)
+            bcast = {(): 'scalar',
+                     (False,): 'vector',
+                     (False, True): 'col',
+                     (True, False): 'row',
+                     (False, False): 'matrix'}.get(b, "%iD" % len(b) if not any(b) else str(b))
+            return "Tensor(%s, %s)" % (str(self.dtype), bcast)
 
     def __repr__(self):
-        return "Tensor{%s, %s}" % (str(self.dtype), str(self.broadcastable))
+        return str(self)
+        #"Tensor{%s, %s}" % (str(self.dtype), str(self.broadcastable))
 
     def c_declare(self, name, sub):
         return """

tensor_opt.py

@@ -7,6 +7,7 @@ import tensor as T
 import numpy as N
 import operator
 import itertools
+import sys
 
 
 # Utilities
@@ -40,8 +41,7 @@ dot_to_gemm = gof.PatternSub((T.dot, 'a', 'b'),
                              allow_multiple_clients = False)
 
 
-@gof.optimizer
-def insert_inplace_optimizer(self, env):
+def _insert_inplace_optimizer(env):
     """
     Usage: inplace_optimizer.optimize(env)
     
@@ -66,14 +66,16 @@ def insert_inplace_optimizer(self, env):
             for candidate_input in candidate_inputs:
                 inplace_pattern = dict(baseline, **{candidate_output: candidate_input})
                 try:
-                    new = Elemwise(op.scalar_op, inplace_pattern).make_node(op.inputs)
-                    env.replace_all_validate(dict(zip(node.outputs, new.outputs)))
-                except:
+                    new = Elemwise(op.scalar_op, inplace_pattern).make_node(*node.inputs)
+                    env.replace_all_validate(zip(node.outputs, new.outputs))
+                except Exception, e:
                     continue
                 candidate_inputs.remove(candidate_input)
                 node = new
                 baseline = inplace_pattern
                 break
+insert_inplace_optimizer = gof.optimizer(_insert_inplace_optimizer)
+
 
 inplace_optimizer = gof.SeqOptimizer(out2in(gemm_pattern_1),
                                      out2in(dot_to_gemm),

tensor_random.py

@@ -154,186 +154,3 @@ class RandomKit(SymbolicInputKit):
 rk = RandomKit('rk', 0xBAD5EED)
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-# class RandomState(object):
-#     """The Theano version of numpy.RandomState
-
-#     This class generates a sequence of L{Op} instances via the gen() and
-#     gen_like() methods.
-
-#     @ivar seed: an integer which determines the initial state of the L{Op}
-#     instances returned by gen(), gen_like()
-#     @type seed: int
-#     """
-
-#     def __init__(self, seed):
-#         self.seed = seed
-
-#     def gen(self, dist, shape=(), ndim=None):
-#         """
-#         @param dist: identifier of a sampling distribution. See L{_fn_from_dist}.
-#         @param shape: tuple
-
-#         @return: A tensor of random numbers, with given shape.
-#         @rtype: L{Result} (output of L{Apply} of L{NumpyGenerator} instance)
-#         """
-#         self.seed += 1
-#         fn = RandomState._fn_from_dist(dist)
-#         if isinstance(shape, tuple):
-#             return NumpyGenerator(self.seed-1, len(shape),fn) (shape)
-#         return NumpyGenerator(self.seed - 1, ndim, fn)(shape)
-
-#     def gen_like(self, dist, x):
-#         """
-#         @param dist: identifier of a sampling distribution. See L{_fn_from_dist}.
-#         @param x: L{Result} of type L{Tensor}
-
-#         @return: A tensor of random numbers, with the same shape as x.
-#         @rtype: L{Result} (output of L{Apply} of L{NumpyGenerator} instance)
-#         """
-#         self.seed += 1
-#         fn = RandomState._fn_from_dist(dist)
-#         return NumpyGenerator(self.seed-1, x.type.ndim, fn)(tensor.shape(x))
-
-#     def uniform_like(self, template, low=0.,high=1.):
-#         """
-#         Return a multivariate uniform(low,high)
-#         random variable in a tensor of the same shape as template
-#         (template can either be a tensor or a shape tuple). Each element of the
-#         resulting tensor is sampled independently. low and high can
-#         be scalars or have the same shape as the template (or broadcastable
-#         to it).
-#         """
-#         return self.gen_like(('uniform',{'low':low,'high':high}),template)
-
-#     def binomial_like(self, template, n=1, p=0.5):
-#         """
-#         Return a multivariate binomial(n,p) random variable in a tensor of the same shape as template
-#         (template can either be a tensor or a shape tuple). Each element of the
-#         resulting tensor is sampled independently. low and high can
-#         be scalars or have the same shape as the template (or broadcastable
-#         to it).
-#         """
-#         return self.gen_like(('binomial',{'n':n,'p':p}),template)
-
-#     @staticmethod
-#     def _fn_from_dist(dist, cache={}):
-#         """Return a function from a distribution description
-
-#         @param dist: identifier of a sampling distribution.
-#         @type dist: callable or str or tuple(str, dict)
-
-#         @param cache: The optional cache argument implements a closure, which ensures that
-#         multiple requests for the same sampling function will get the same
-#         sampling function. L{NumpyGenerator}.__hash__ depends on this.
-
-#         @type cache: dict
-#         """
-#         if callable(dist):
-#             return dist
-#         if isinstance(dist, str):
-#             return getattr(numpy.random.RandomState, dist)
-
-#         name, kwargs = dist
-#         key = (name, tuple(kwargs.items()))
-#         if key not in cache:
-#             fn = getattr(numpy.random.RandomState, name)
-#             fn = functools.partial(fn, **kwargs)
-#             cache[key] = fn
-#         return cache[key]
-
-
-# class NumpyGenerator(gof.op.Op):
-#     """Supply a sequence of random tensors of a given shape, from a given
-#     distribution.
-
-#     @param seed: initial state for instances of this L{Op}.
-#     @type seed: anything that numpy.random.RandomState accepts.
-#     @param ndim: the rank of random tensors produced by this op.
-#     @type ndim: non-negative integer
-#     @param fn: a sampling function
-#     @type fn: a callable that can reply to fn(numpy.RandomState(), size=<tuple>)
-#     """
-#     destroy_map = {0: [0]}
-
-#     def __init__(self, seed, ndim, fn, **kwargs):
-#         gof.op.Op.__init__(self, **kwargs)
-#         self.seed = seed
-#         self.ndim = ndim
-#         self.fn = fn
-#         assert numpy.random.RandomState(seed) #test the seed
-#         assert 'int' in str(type(ndim))
-#         assert callable(self.fn)
-
-#     def __eq__(self, other):
-#         return (type(self) is type(other))\
-#                 and self.__class__ is NumpyGenerator \
-#                 and self.seed == other.seed \
-#                 and self.ndim == other.ndim \
-#                 and self.fn == other.fn
-#     def __hash__(self):
-#         return self.seed ^ self.ndim ^ hash(self.fn)
-
-#     def make_node(self, _shape):
-#         #TODO: check for constant shape, and guess the broadcastable bits
-#         shape = tensor.convert_to_int64(_shape)
-#         if shape.type.ndim != 1:
-#             raise TypeError('shape argument was not converted to 1-d tensor', _shape)
-
-#         # we generate one random number with the distribution to determine what dtype to expect
-#         output_dtype = str(self.fn(numpy.random.RandomState(18), size=(1,)).dtype)
-
-#         inputs = [gof.Value(gof.type.generic, numpy.random.RandomState(self.seed)), shape]
-#         outputs = [tensor.Tensor(dtype=output_dtype, broadcastable = [False]*self.ndim).make_result()]
-#         return gof.Apply(op = self, inputs = inputs, outputs = outputs)
-
-#     def grad(self, inputs, grad_outputs):
-#         return [None, None]
-
-#     def perform(self, node, input_storage, output_storage):
-#         rng = input_storage[0]
-#         shape = input_storage[1]
-#         if self.ndim != len(shape):
-#             raise ValueError('shape argument %s had the wrong length (!=%i)' %
-#                     (shape, self.ndim) )
-#         output_storage[0][0] = self.fn(rng, size=shape)
-