Fix binomial and moved out of sandbox.

theano/sparse/basic.py

@@ -3005,6 +3005,58 @@ class Poisson(gof.op.Op):
 poisson = Poisson()
 
 
+class Binomial(gof.op.Op):
+    """Return a sparse matrix having random values from a binomial
+    density having number of experiment `n` and probability of succes
+    `p`.
+
+    :param n: Tensor scalar representing the number of experiment.
+    :param p: Tensor scalar representing the probability of success.
+    :param shape: Tensor vector for the output shape.
+
+    :return: A sparse matrix of integers representing the number
+             of success.
+    """
+
+    def __init__(self, format, dtype):
+        self.format = format
+        self.dtype = dtype
+
+    def __eq__(self, other):
+        return ((type(self) == type(other)) and
+                self.format == other.format and
+                self.dtype == other.dtype)
+
+    def __hash__(self):
+        return hash(type(self)) ^ hash(self.format) ^ hash(self.dtype)
+
+    def make_node(self, n, p, shape):
+        n = tensor.as_tensor_variable(n)
+        p = tensor.as_tensor_variable(p)
+        shape = tensor.as_tensor_variable(shape)
+        return gof.Apply(self, [n, p, shape], [SparseType(dtype=self.dtype,
+                                 format=self.format).make_variable()])
+
+    def perform(self, node, (n, p, shape, ), (out, )):
+        binomial = numpy.random.binomial(n, p, size=shape)
+        csx_matrix = getattr(scipy.sparse, self.format + '_matrix')
+        out[0] = csx_matrix(binomial, dtype=self.dtype)
+
+    def grad(self, (n, p, shape, ), (gz,)):
+        return None, None, None
+
+    def infer_shape(self, node, ins_shapes):
+        return [(node.inputs[2][0], node.inputs[2][1])]
+
+    def __str__(self):
+        return self.__class__.__name__
+
+csr_fbinomial = Binomial('csr', 'float32')
+csc_fbinomial = Binomial('csc', 'float32')
+csr_dbinomial = Binomial('csr', 'float64')
+csc_dbinomial = Binomial('csc', 'float64')
+
+
 class Multinomial(gof.op.Op):
     """Return a sparse matrix having random values from a multinomial
     density having number of experiment `n` and probability of succes

theano/sparse/sandbox/sp2.py

@@ -19,6 +19,7 @@ from theano.sparse.basic import (
     AddSSData, add_s_s_data,
     MulSDCSC, mul_s_d_csc, MulSDCSR, mul_s_d_csr,
     Multinomial, multinomial, Poisson, poisson,
+    Binomial, csr_fbinomial, csc_fbinomial, csr_dbinomial, csc_dbinomial,
     structured_monoid,
     structured_sigmoid, structured_exp, structured_log, structured_pow,
     structured_minimum, structured_maximum, structured_add,
@@ -35,71 +36,3 @@ from theano.sparse.opt import (
 # Alias to maintain compatibility
 EliminateZeros = Remove0
 eliminate_zeros = remove0
-
-
-class Binomial(gof.op.Op):
-    # TODO This op is not an equivalent of numpy.random.binomial. In
-    # facts, this does not follow a binomial distribution at all.
-    # To see it, just try with p = 1.
-
-    """Return a sparse matrix having random values from a binomial
-    density having number of experiment `n` and probability of succes
-    `p`.
-
-    .. warning::
-
-        For now, this op does not return a true binomial
-        distribution. It is a random disposition of ones
-        in a sparse matrix.
-
-    :param n: Tensor scalar representing the number of experiment.
-    :param p: Tensor scalar representing the probability of success.
-    :param shape: Tensor vector for the output shape.
-
-    :return: A sparse matrix of integers representing the number
-             of success.
-    """
-
-    def __init__(self, format, dtype):
-        self.format = format
-        self.dtype = dtype
-
-    def __eq__(self, other):
-        return ((type(self) == type(other)) and
-                self.format == other.format and
-                self.dtype == other.dtype)
-
-    def __hash__(self):
-        return hash(type(self)) ^ hash(self.format) ^ hash(self.dtype)
-
-    def make_node(self, n, p, shape):
-        n = tensor.as_tensor_variable(n)
-        p = tensor.as_tensor_variable(p)
-        shape = tensor.as_tensor_variable(shape)
-        return gof.Apply(self, [n, p, shape], [SparseType(dtype=self.dtype,
-                                 format=self.format).make_variable()])
-
-    def perform(self, node, (n, p, shape, ), (out, )):
-        N = n * p * shape[0] * shape[1]
-        data = numpy.ones(N, dtype=self.dtype)
-        row = numpy.random.randint(0, shape[0], N)
-        col = numpy.random.randint(0, shape[1], N)
-
-        res = scipy.sparse.coo_matrix((data, (row, col)), shape=shape)
-
-        out[0] = getattr(res, 'to' + self.format)()
-        out[0].data = numpy.ones_like(out[0].data)
-
-    def grad(self, (n, p, shape, ), (gz,)):
-        return None, None, None
-
-    def infer_shape(self, node, ins_shapes):
-        return [(node.inputs[2][0], node.inputs[2][1])]
-
-    def __str__(self):
-        return self.__class__.__name__
-
-csr_fbinomial = Binomial('csr', 'float32')
-csc_fbinomial = Binomial('csc', 'float32')
-csr_dbinomial = Binomial('csr', 'float64')
-csc_dbinomial = Binomial('csc', 'float64')

theano/sparse/tests/test_basic.py

@@ -33,7 +33,7 @@ from theano.sparse import (
     Dot, Usmm, UsmmCscDense, sp_ones_like, GetItemScalar,
     SparseFromDense,
     Cast, HStack, VStack, AddSSData, add_s_s_data,
-    Poisson, poisson, Multinomial, multinomial,
+    Poisson, poisson, Binomial, Multinomial, multinomial,
     structured_sigmoid, structured_exp, structured_log,
     structured_pow, structured_minimum, structured_maximum, structured_add,
     MulSV, mul_s_v, StructuredAddSV, structured_add_s_v,
@@ -2142,6 +2142,46 @@ class PoissonTester(utt.InferShapeTester):
                                     self.op_class)
 
 
+class BinomialTester(utt.InferShapeTester):
+    n = tensor.scalar()
+    p = tensor.scalar()
+    shape = tensor.lvector()
+    _n = 5
+    _p = .25
+    _shape = numpy.asarray([3, 5], dtype='int64')
+
+    inputs = [n, p, shape]
+    _inputs = [_n, _p, _shape]
+
+    def setUp(self):
+        super(BinomialTester, self).setUp()
+        self.op_class = Binomial
+
+    def test_op(self):
+        for sp_format in sparse.sparse_formats:
+            for o_type in sparse.float_dtypes:
+                f = theano.function(
+                    self.inputs,
+                    Binomial(sp_format, o_type)(*self.inputs))
+
+                tested = f(*self._inputs)
+
+                assert tested.shape == tuple(self._shape)
+                assert tested.format == sp_format
+                assert tested.dtype == o_type
+                assert numpy.allclose(numpy.floor(tested.todense()),
+                                   tested.todense())
+
+    def test_infer_shape(self):
+        for sp_format in sparse.sparse_formats:
+            for o_type in sparse.float_dtypes:
+                self._compile_and_check(
+                    self.inputs,
+                    [Binomial(sp_format, o_type)(*self.inputs)],
+                    self._inputs,
+                    self.op_class)
+
+
 class MultinomialTester(utt.InferShapeTester):
     p = sparse.csr_matrix()
     _p = sp.csr_matrix(numpy.asarray([[0.0, 0.5, 0.0, 0.5],

theano/sparse/tests/test_sp2.py

@@ -22,45 +22,5 @@ from theano.tests import unittest_tools as utt
 from theano.sparse.basic import verify_grad_sparse
 
 
-class BinomialTester(utt.InferShapeTester):
-    n = tensor.scalar()
-    p = tensor.scalar()
-    shape = tensor.lvector()
-    _n = 5
-    _p = .25
-    _shape = np.asarray([3, 5], dtype='int64')
-
-    inputs = [n, p, shape]
-    _inputs = [_n, _p, _shape]
-
-    def setUp(self):
-        super(BinomialTester, self).setUp()
-        self.op_class = S2.Binomial
-
-    def test_op(self):
-        for sp_format in sparse.sparse_formats:
-            for o_type in sparse.float_dtypes:
-                f = theano.function(
-                    self.inputs,
-                    S2.Binomial(sp_format, o_type)(*self.inputs))
-
-                tested = f(*self._inputs)
-
-                assert tested.shape == tuple(self._shape)
-                assert tested.format == sp_format
-                assert tested.dtype == o_type
-                assert np.allclose(np.floor(tested.todense()),
-                                   tested.todense())
-
-    def test_infer_shape(self):
-        for sp_format in sparse.sparse_formats:
-            for o_type in sparse.float_dtypes:
-                self._compile_and_check(
-                    self.inputs,
-                    [S2.Binomial(sp_format, o_type)(*self.inputs)],
-                    self._inputs,
-                    self.op_class)
-
-
 if __name__ == '__main__':
     unittest.main()