Merge pull request #431 from goodfeli/q

theano/tensor/elemwise.py

+import sys
+import traceback
 from copy import copy
+from itertools import izip
 
 import numpy
 
@@ -17,16 +20,23 @@ config = theano.config
 # but elemwise needs to make TensorType instances, so we have these as
 # placeholders and the tensor module fills them
 def as_tensor_variable(data):
-    raise Exception("Circular dependencies prevent using this here. import tensor before elemwise")
+    raise Exception("Circular dependencies prevent using this"
+                    "here. import tensor before elemwise")
+
 
 def TensorType(*inputs, **kwargs):
-    raise Exception("Circular dependencies prevent using this here. import tensor before elemwise")
+    raise Exception("Circular dependencies prevent "
+                    "using this here. import tensor before elemwise")
+
 
 def TensorVariable(*inputs, **kwargs):
-    raise Exception("Circular dependencies prevent using this here. import tensor before elemwise")
+    raise Exception("Circular dependencies "
+                    "prevent using this here. import tensor before elemwise")
+
 
 def TensorConstant(*inputs, **kwargs):
-    raise Exception("Circular dependencies prevent using this here. import tensor before elemwise")
+    raise Exception("Circular dependencies "
+                    "prevent using this here. import tensor before elemwise")
 
 
 ##################
@@ -54,22 +64,27 @@ class DimShuffle(Op):
 
       DimShuffle((True, False), [1])
 
-       This op will only work on 2d tensors with the first dimension broadcastable.
+       This op will only work on 2d tensors with the first dimension
+       broadcastable.
        The second dimension of the input tensor will be the first dimension of
-       the resulting tensor. If the tensor has shape (1, 20), the resulting tensor
-       will have shape (20, ).
+       the resulting tensor.
+       If the tensor has shape (1, 20), the resulting tensor will have shape
+       (20, ).
 
     More examples:
       DimShuffle((), ['x']) -> make a 0d (scalar) into a 1d vector
       DimShuffle((False, False), [0, 1]) -> identity
-      DimShuffle((False, False), [1, 0]) -> inverts the first and second dimensions
-      DimShuffle((False,), ['x', 0]) -> make a row out of a 1d vector (N to 1xN)
-      DimShuffle((False,), [0, 'x']) -> make a column out of a 1d vector (N to Nx1)
+      DimShuffle((False, False), [1, 0]) -> inverts the 1st and 2nd dimensions
+      DimShuffle((False,), ['x', 0]) -> make a row out
+                                        of a 1d vector (N to 1xN)
+      DimShuffle((False,), [0, 'x']) -> make a column
+                                        out of a 1d vector (N to Nx1)
       DimShuffle((False, False, False), [2, 0, 1]) -> AxBxC to CxAxB
       DimShuffle((False, False), [0, 'x', 1]) -> AxB to Ax1xB
       DimShuffle((False, False), [1, 'x', 0]) -> AxB to Bx1xA
 
-    The reordering of the dimensions can be done in numpy with the transpose function.
+    The reordering of the dimensions can be done in numpy with the
+    transpose function.
     Adding, subtracting dimensions can be done with reshape.
     """
 
@@ -714,7 +729,7 @@ class Elemwise(Op):
                     if odat is not None:
                         odat.resize(shape, refcheck = 0)
                     else:
-                        odat = numpy.ndarray(shape, dtype = output.type.dtype)
+                        odat = numpy.ndarray(shape, dtype=output.type.dtype)
                 storage[0] = odat
 
         ufunc_args = inputs  # + output_storage
@@ -729,21 +744,42 @@ class Elemwise(Op):
             # optimization is probably not worth the effort, since we
             # should normally run the C version of the Op.
         else:
-            # the second calling form is used because in certain versions of numpy
-            # the first (faster) version leads to segfaults
-            ufunc = self.ufunc or numpy.frompyfunc(self.scalar_op.impl, len(inputs), self.scalar_op.nout)
+            # the second calling form is used because in certain versions of
+            # numpy the first (faster) version leads to segfaults
+            ufunc = (self.ufunc or
+                     numpy.frompyfunc(self.scalar_op.impl, len(inputs),
+                                      self.scalar_op.nout))
             nout = ufunc.nout
 
         try:
             variables = ufunc(*ufunc_args)
         except Exception, e:
-            errormsg = 'While computing '+str(node.outputs)+': Failed calling ufunc for op', self.scalar_op,\
-                        'for params of shape', [arg.shape for arg in ufunc_args]
-            e.args = e.args + errormsg
+            errormsg = ('While computing ' + str(node.outputs) +
+                        ': Failed calling ufunc for op ' +
+                        str(self.scalar_op) +
+                        'for params of shape ' +
+                        str([arg.shape for arg in ufunc_args]))
+
+            if config.exception_verbosity == 'high':
+                errormsg += 'inputs are: \n'
+                for i, ipt in enumerate(node.inputs):
+                    errormsg += '(' + str(i) + ') ' + \
+                            min_informative_str(ipt) + '\n'
+                errormsg += 'outputs are: \n'
+                for i, output in enumerate(node.outputs):
+                    errormsg += '(' + str(i) + ') ' + \
+                            min_informative_str(output) + '\n'
+                errormsg += 'original exception was: ' + '\n'.join(
+                        traceback.format_exception_only(*sys.exc_info()[0:2]))
+                raise Exception(errormsg)
+            else:
+                e.args = e.args + (errormsg, )
                 raise
+
         if nout == 1:
             variables = [variables]
-        for variable, storage, nout in zip(variables, output_storage, node.outputs):
+        for variable, storage, nout in izip(variables, output_storage,
+                                            node.outputs):
             if str(getattr(variable, "dtype", "")) == 'object':
                 # Since numpy 1.6, function created with numpy.frompyfunc
                 # always return an ndarray with dtype object