merge

theano/sandbox/test_conv.py

@@ -121,7 +121,12 @@ def exec_multilayer_conv_nnet(conv_mode, ss, bsize, imshp, kshps, nkerns, unroll
                 hidval1=outval.copy()
 
             # ConvOp
-            conv_op = ConvOp(imshp, kshp, nkern, bsize, ss[0],ss[1], conv_mode, unroll_batch=unroll_batch, unroll_kern=unroll_kern, unroll_patch=unroll_patch)(inputs4, kerns4)
+            if unroll_patch:
+                conv_op = ConvOp(dx=ss[0],dy=ss[1], output_mode=conv_mode,
+                                 unroll_patch=unroll_patch)(inputs4, kerns4)
+            else:
+                conv_op = ConvOp(imshp, kshp, nkern, bsize, ss[0],ss[1], conv_mode,
+                                 unroll_batch=unroll_batch, unroll_kern=unroll_kern, unroll_patch=unroll_patch)(inputs4, kerns4)
             l1shp=N.hstack((nkern,
                             getFilterOutShp(imshp, kshp, ss, conv_mode)))
             propup2 = function([inputs4, kerns4], conv_op)
@@ -328,7 +333,7 @@ class TestConvOp(unittest.TestCase):
         ssizess = [[(1,1),(1,2)],[(1,1),(2,2)]]
         convmodes = ['valid','full']
         do_convolve2=True
-        unroll = [(0,0,False),(0,0,True),(1,1,False),(2,2,False),(3,2,False)]#(batch,kern,patch)
+        unroll = [(0,0,True),(0,0,False),(1,1,False),(2,2,False),(3,2,False)]#(batch,kern,patch)
         do_speed_test = False
 
         # TODO: this version show a bug that was fixed
@@ -515,23 +520,32 @@ class TestConvOp(unittest.TestCase):
                         for un_b,un_k, un_p in unroll:
                                 for ss in ssizes:
                                     print 'test_ConvOpGrad'
-                                    print 'mode type:', mode, typ
-                                    print 'imshp:', imshp
-                                    print 'kshp:', kshp
-                                    print 'un_b:', un_b
-                                    print 'un_k:', un_k
-                                    print 'ss:', ss
-                                    print 'bsize:', bsize
-                                    print 'nkern:', 4
+#                                    print 'mode:',mode,'type:', typ
+#                                    print 'imshp:', imshp,
+#                                    print 'kshp:', kshp
+#                                    print 'un_b:', un_b,
+#                                    print 'un_k:', un_k,
+#                                    print 'un_p:', un_p
+#                                    print 'ss:', ss,
+#                                    print 'bsize:', bsize,
+#                                    print 'nkern:', nkern
 
                                     def test_i(imgs):
-                                        convop = ConvOp(imshp, kshp, nkern, bsize, ss[0], ss[1],
-                                                        output_mode=mode, unroll_batch=un_b, unroll_kern=un_k, unroll_patch=un_p)
+                                        if un_p and ss[0]==1 and ss[1]==1:
+                                            convop = ConvOp(dx=ss[0], dy=ss[1],
+                                                            output_mode=mode, unroll_patch=un_p)
+                                        else:
+                                            convop = ConvOp(imshp, kshp, nkern, bsize, ss[0], ss[1],
+                                                            output_mode=mode, unroll_batch=un_b, unroll_kern=un_k, unroll_patch=un_p)
                                         return convop(imgs, kernvals)
 
                                     def test_k(kerns):
-                                        convop = ConvOp(imshp, kshp, nkern, bsize, ss[0], ss[1],
-                                                        output_mode=mode, unroll_batch=un_b, unroll_kern=un_k, unroll_patch=un_p)
+                                        if un_p and ss[0]==1 and ss[1]==1:
+                                            convop = ConvOp(dx=ss[0], dy=ss[1],
+                                                            output_mode=mode, unroll_patch=un_p)
+                                        else:
+                                            convop = ConvOp(imshp, kshp, nkern, bsize, ss[0], ss[1],
+                                                            output_mode=mode, unroll_batch=un_b, unroll_kern=un_k, unroll_patch=un_p)
                                         return convop(imgvals, kerns)
                                     print mode, imshp, kshp, un_b, un_k, ss
                                     #TODO the tolerance needed to pass is very high for float32(0.17). Is this acceptable? Expected?

theano/sparse/basic.py

@@ -343,12 +343,29 @@ class CSM(gof.Op):
 
         """
         data = tensor.as_tensor_variable(data)
+
+        # Note that we use `view(numpy.int32)` in addition to providing the
+        # 'int32' dtype to `numpy.asarray`. This is because on some computers
+        # (e.g. a Windows 32 bits machine), we can have the following assert
+        # fail:
+        #   x = numpy.array([0], dtype=numpy.intc)
+        #   y = numpy.asarray(x, dtype=numpy.int32)
+        #   assert y.dtype.num == numpy.dtype(numpy.int32).num
+        # while the assert does *not* fail when replacing the second line by:
+        #   y = numpy.asarray(x, dtype='int32').view(numpy.int32)
+        # This is a known defect in Numpy. For more information see ticket
+        # http://projects.scipy.org/numpy/ticket/870
+
+        # Note also that it is important to keep "dtype='int32'" when calling
+        # `numpy.asarray`. This is because `view` is only some kind of cast to
+        # the exact data type we want to use. If a conversion is required (e.g.
+        # from int64 to int32), it must be done in the call to `numpy.asarray`.
         if not isinstance(indices, tensor.TensorVariable):
-            indices = numpy.asarray(indices, dtype='int32')
+            indices = numpy.asarray(indices, dtype='int32').view(numpy.int32)
         if not isinstance(indptr, tensor.TensorVariable):
-            indptr = numpy.asarray(indptr, dtype='int32')
+            indptr = numpy.asarray(indptr, dtype='int32').view(numpy.int32)
         if not isinstance(shape, tensor.TensorVariable):
-            shape = numpy.asarray(shape, dtype='int32')
+            shape = numpy.asarray(shape, dtype='int32').view(numpy.int32)
         indices = tensor.as_tensor_variable(indices)
         indptr = tensor.as_tensor_variable(indptr)
         shape = tensor.as_tensor_variable(shape)

theano/sparse/tests/test_basic.py

@@ -169,15 +169,17 @@ class test_structureddot(unittest.TestCase):
                 # iterate for a few different random graph patterns
                 for i in range(10):
                     spmat = sp.csc_matrix((4,6), dtype=sparse_dtype)
-                    for i in range(5):
+                    for k in range(5):
                         # set non-zeros in random locations (row x, col y)
                         x = numpy.floor(numpy.random.rand()*spmat.shape[0])
                         y = numpy.floor(numpy.random.rand()*spmat.shape[1])
                         spmat[x,y] = numpy.random.rand()*10
                     spmat = sp.csc_matrix(spmat)
                
-                    kerns = tensor.Tensor(broadcastable=[False], dtype=sparse_dtype)('kerns')
-                    images = tensor.Tensor(broadcastable=[False, False], dtype=dense_dtype)('images')
+                    kerns = tensor.Tensor(broadcastable=[False],
+                            dtype=sparse_dtype)('kerns')
+                    images = tensor.Tensor(broadcastable=[False, False],
+                            dtype=dense_dtype)('images')
 
                     output_dtype = theano.scalar.upcast(sparse_dtype, dense_dtype)
                     ##
@@ -186,7 +188,8 @@ class test_structureddot(unittest.TestCase):
 
                     # build symbolic theano graph
                     def buildgraphCSC(kerns,images):
-                        csc = CSC(kerns, spmat.indices[:spmat.size], spmat.indptr, spmat.shape)
+                        csc = CSC(kerns, spmat.indices[:spmat.size],
+                                spmat.indptr, spmat.shape)
                         assert csc.type.dtype == sparse_dtype
                         rval = structured_dot(csc, images.T)
                         assert rval.type.dtype == output_dtype
@@ -197,8 +200,12 @@ class test_structureddot(unittest.TestCase):
 
                     # compute theano outputs
                     kernvals = spmat.data[:spmat.size]
-                    imvals = 1.0 + 1.0 * numpy.array(numpy.arange(bsize*spmat.shape[1]).\
+                    imvals = 1.0 + 1.0 * numpy.array(
+                            numpy.arange(bsize*spmat.shape[1]).\
                             reshape(bsize,spmat.shape[1]), dtype=dense_dtype)
+                    #print('dense_dtype=%s' % dense_dtype)
+                    #print('sparse_dtype=%s' % sparse_dtype)
+                    #print('i=%s' % i)
                     print 'kerntype', str(kernvals.dtype), kernvals.dtype.num
                     outvals = f(kernvals,imvals)
                     print 'YAY'
@@ -210,9 +217,10 @@ class test_structureddot(unittest.TestCase):
                     assert _is_dense(c)
                     assert str(outvals.dtype) == output_dtype
                     assert numpy.all(numpy.abs(outvals - 
-                                     numpy.array(c, dtype=output_dtype)) < 1e-4)
+                        numpy.array(c, dtype=output_dtype)) < 1e-4)
 
-                    if sparse_dtype.startswith('float') and dense_dtype.startswith('float'):
+                    if (sparse_dtype.startswith('float') and
+                            dense_dtype.startswith('float')):
                         utt.verify_grad(buildgraphCSC, 
                                 [kernvals, imvals])