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_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)

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
-        self.type = r.type
+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):
+        if self.readonly:
+            raise Exception("Cannot set readonly storage: %s" % self.name)
         try:
-            if self.readonly:
-                raise Exception("Cannot set readonly storage.")
             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):
-    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
+class transfer_type:
+    def __init__(self, i):
+        assert type(i) == int
+        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)
-