merge

_test_tensor.py

@@ -407,6 +407,9 @@ class T_transpose(unittest.TestCase):
         #test aliasing
         tval += 55.0
         self.failUnless(n.data[0,0,0] == 56.0)
+    def test_grad(self):
+        verify_grad(self, TransposeInplace, [numpy.random.rand(2, 3)])
+        verify_grad(self, TransposeInplace, [numpy.ones(3)])
 
 class T_subtensor(unittest.TestCase):
     def test0_err_invalid(self):
@@ -838,6 +841,9 @@ class t_dot(unittest.TestCase):
     def test_align_3_2(self): self.not_aligned(self.rand(5,4,3), self.rand(6,7))
     def test_align_3_3(self): self.not_aligned(self.rand(5,4,3), self.rand(6,7,8))
 
+    def test_grad(self):
+        verify_grad(self, Dot, [self.rand(2,3), self.rand(3,2)])
+
 class t_gemm(unittest.TestCase):
     def setUp(self):
         numpy.random.seed(44)

compile.py

@@ -43,6 +43,15 @@ class Function:
     linker_cls - the linker class
     linker - the linker allocated from env
     env - The env passed to the linker
+
+    REMARK Re: Memory ownership, aliasing, re-use
+    -------------------------------------------
+    Note that the objects returned by Function.__call__(self, *args) are owned
+    by self, and that in general these outputs might be overwritten (in-place)
+    by subsequent calls to self.__call__(*args).  Why?  This behaviour is
+    necessary for inplace operations to work, and Function's linker might re-use
+    memory from one execution to the next in order to make each execution faster.
+
     """
     def __init__(self, inputs, outputs,
             features = [],

tensor.py

-"""A Result to store numpy.ndarray with basic accompanying Ops"""
+"""A L{Result} to store L{numpy.ndarray} with basic accompanying L{Op}s"""
 import sys # for sys.maxint
 import inspect
 
@@ -17,12 +17,12 @@ import scalar as scal
 
 class Tensor(BaseTensor):
     """
-    This subclass of BaseTensor provides operator overloading using implementations
-    of Tensor operations contained in this file.
+    This subclass of L{BaseTensor} provides operator overloading using
+    implementations of L{Tensor} operations contained in this file.
     
     Operators:
-    - most numeric operators are overloaded (to return Ops that perform the
-      corresponding calculation)
+    - most numeric operators are overloaded (to return L{Op}s that
+    perform the corresponding calculation)
     """
 
     #UNARY
@@ -72,7 +72,7 @@ s2t.Tensor = Tensor
 
 # alternate Tensor constructor
 def astensor(data, broadcastable=None, role=None, name=None):
-    """Return a Tensor containing given data"""
+    """Return a L{Tensor} containing given data"""
     if isinstance(data, Tensor) and broadcastable is None and role is None and name is None:
         return data
     data = numpy.asarray(data)
@@ -239,7 +239,7 @@ class TransposeInplace(_Op, Viewer):
         return [rval]
     def impl(self, x):
         return x.T #numpy's transpose
-    def grad(self, (x,), (gz),):
+    def grad(self, (x,), (gz,)):
         return transpose(gz),
     
     def c_code(self, (x, ), (z, ), sub):