testing more dtypes

theano/gpuarray/tests/test_multinomial.py

@@ -23,31 +23,33 @@ def test_multinomial_0():
     p = tensor.fmatrix()
     u = tensor.fvector()
 
-    m = theano.sandbox.multinomial.MultinomialFromUniform('auto')(p, u)
+    for dtype in ['int64', 'float32', 'auto']:
 
-    # the m*2 allows the multinomial to reuse output
-    f = function([p, u], m * 2, allow_input_downcast=True, mode=mode_with_gpu)
+        m = theano.sandbox.multinomial.MultinomialFromUniform(dtype)(p, u)
 
-    assert any([type(node.op) is GPUAMultinomialFromUniform
-                for node in f.maker.fgraph.toposort()])
+        # the m*2 allows the multinomial to reuse output
+        f = function([p, u], m * 2, allow_input_downcast=True, mode=mode_with_gpu)
 
-    # test that both first and second samples can be drawn
-    utt.assert_allclose(f([[1, 0], [0, 1]], [.1, .1]),
-                        [[2, 0], [0, 2]])
+        assert any([type(node.op) is GPUAMultinomialFromUniform
+                    for node in f.maker.fgraph.toposort()])
+
+        # test that both first and second samples can be drawn
+        utt.assert_allclose(f([[1, 0], [0, 1]], [.1, .1]),
+                            [[2, 0], [0, 2]])
 
-    # test that both second labels can be drawn
-    r = f([[.2, .8], [.3, .7]], [.31, .31])
-    utt.assert_allclose(r, [[0, 2], [0, 2]])
+        # test that both second labels can be drawn
+        r = f([[.2, .8], [.3, .7]], [.31, .31])
+        utt.assert_allclose(r, [[0, 2], [0, 2]])
 
-    # test that both first labels can be drawn
-    r = f([[.2, .8], [.3, .7]], [.21, .21])
-    utt.assert_allclose(r, [[0, 2], [2, 0]])
+        # test that both first labels can be drawn
+        r = f([[.2, .8], [.3, .7]], [.21, .21])
+        utt.assert_allclose(r, [[0, 2], [2, 0]])
 
-    # change the size to make sure output gets reallocated ok
-    # and also make sure that the GPU version doesn't screw up the
-    # transposed-ness
-    r = f([[.2, .8]], [.25])
-    utt.assert_allclose(r, [[0, 2]])
+        # change the size to make sure output gets reallocated ok
+        # and also make sure that the GPU version doesn't screw up the
+        # transposed-ness
+        r = f([[.2, .8]], [.25])
+        utt.assert_allclose(r, [[0, 2]])
 
 
 # TODO: check a bigger example (make sure blocking on GPU is handled correctly)
@@ -81,8 +83,8 @@ def test_multinomial_large():
 
 
 def test_gpu_opt_dtypes():
-    # Does have some overlap with test_multinomial_0
-    for dtype in ['float32', 'int64', 'float64']:
+    # Test if the returned samples are of the datatype specified
+    for dtype in ['uint32', 'float32', 'int64', 'float64']:
         p = tensor.fmatrix()
         u = tensor.fvector()
         m = theano.sandbox.multinomial.MultinomialFromUniform(dtype)(p, u)
@@ -104,8 +106,8 @@ def test_gpu_opt():
     # is moved to the gpu.
     p = tensor.fmatrix()
     u = tensor.fvector()
-    m = theano.sandbox.multinomial.MultinomialFromUniform('float32')(p, u)
-    # assert m.dtype == 'float32', m.dtype
+    m = theano.sandbox.multinomial.MultinomialFromUniform('auto')(p, u)
+    assert m.dtype == 'float32', m.dtype
 
     f = function([p, u], m, allow_input_downcast=True, mode=mode_with_gpu)
     assert any([type(node.op) is GPUAMultinomialFromUniform
@@ -115,18 +117,18 @@ def test_gpu_opt():
     uval = numpy.ones_like(pval[:, 0]) * 0.5
     f(pval, uval)
 
-    # # Test with a row, it was failing in the past.
-    # r = tensor.frow()
-    # m = theano.sandbox.multinomial.MultinomialFromUniform('auto')(r, u)
-    # assert m.dtype == 'float32', m.dtype
-
-    # f = function([r, u], m, allow_input_downcast=True, mode=mode_with_gpu)
-    # assert any([type(node.op) is GPUAMultinomialFromUniform
-    #             for node in f.maker.fgraph.toposort()])
-    # pval = numpy.arange(1 * 4, dtype='float32').reshape((1, 4)) + 0.1
-    # pval = pval / pval.sum(axis=1)[:, None]
-    # uval = numpy.ones_like(pval[:, 0]) * 0.5
-    # f(pval, uval)
+    # Test with a row, it was failing in the past.
+    r = tensor.frow()
+    m = theano.sandbox.multinomial.MultinomialFromUniform('auto')(r, u)
+    assert m.dtype == 'float32', m.dtype
+
+    f = function([r, u], m, allow_input_downcast=True, mode=mode_with_gpu)
+    assert any([type(node.op) is GPUAMultinomialFromUniform
+                for node in f.maker.fgraph.toposort()])
+    pval = numpy.arange(1 * 4, dtype='float32').reshape((1, 4)) + 0.1
+    pval = pval / pval.sum(axis=1)[:, None]
+    uval = numpy.ones_like(pval[:, 0]) * 0.5
+    f(pval, uval)
 
 
 class test_OP_wor(unittest.TestCase):