Rename SparseType to SparseTensorType

aesara/__init__.py

@@ -167,7 +167,7 @@ def get_scalar_constant_value(v):
     """
     # Is it necessary to test for presence of aesara.sparse at runtime?
     sparse = globals().get("sparse")
-    if sparse and isinstance(v.type, sparse.SparseType):
+    if sparse and isinstance(v.type, sparse.SparseTensorType):
         if v.owner is not None and isinstance(v.owner.op, sparse.CSM):
             data = v.owner.inputs[0]
             return tensor.get_scalar_constant_value(data)

aesara/link/c/type.py

@@ -17,7 +17,7 @@ class CType(Type, CLinkerType):
 
     - `TensorType`: for numpy.ndarray
 
-    - `SparseType`: for scipy.sparse
+    - `SparseTensorType`: for scipy.sparse
 
     But you are encouraged to write your own, as described in WRITEME.
 

aesara/misc/may_share_memory.py

@@ -12,7 +12,7 @@ from aesara.tensor.type import TensorType
 try:
     import scipy.sparse
 
-    from aesara.sparse.basic import SparseType
+    from aesara.sparse.basic import SparseTensorType
 
     def _is_sparse(a):
         return scipy.sparse.issparse(a)
@@ -64,4 +64,4 @@ def may_share_memory(a, b, raise_other_type=True):
 
     if a_gpua or b_gpua:
         return False
-    return SparseType.may_share_memory(a, b)
+    return SparseTensorType.may_share_memory(a, b)

aesara/sparse/__init__.py

@@ -9,7 +9,7 @@ except ImportError:
     enable_sparse = False
     warn("SciPy can't be imported.  Sparse matrix support is disabled.")
 
-from aesara.sparse.type import SparseType, _is_sparse
+from aesara.sparse.type import SparseTensorType, _is_sparse
 
 
 if enable_sparse:

aesara/sparse/sandbox/sp2.py

@@ -7,7 +7,7 @@ from aesara.graph.basic import Apply
 from aesara.graph.op import Op
 from aesara.sparse.basic import (
     Remove0,
-    SparseType,
+    SparseTensorType,
     _is_sparse,
     as_sparse_variable,
     remove0,
@@ -108,7 +108,9 @@ class Binomial(Op):
         assert shape.dtype in discrete_dtypes
 
         return Apply(
-            self, [n, p, shape], [SparseType(dtype=self.dtype, format=self.format)()]
+            self,
+            [n, p, shape],
+            [SparseTensorType(dtype=self.dtype, format=self.format)()],
         )
 
     def perform(self, node, inputs, outputs):

aesara/sparse/sharedvar.py

@@ -3,7 +3,7 @@ import copy
 import scipy.sparse
 
 from aesara.compile import SharedVariable, shared_constructor
-from aesara.sparse.basic import SparseType, _sparse_py_operators
+from aesara.sparse.basic import SparseTensorType, _sparse_py_operators
 
 
 class SparseTensorSharedVariable(_sparse_py_operators, SharedVariable):
@@ -16,7 +16,7 @@ def sparse_constructor(
     value, name=None, strict=False, allow_downcast=None, borrow=False, format=None
 ):
     """
-    SharedVariable Constructor for SparseType.
+    SharedVariable Constructor for SparseTensorType.
 
     writeme
 
@@ -29,7 +29,7 @@ def sparse_constructor(
 
     if format is None:
         format = value.format
-    type = SparseType(format=format, dtype=value.dtype)
+    type = SparseTensorType(format=format, dtype=value.dtype)
     if not borrow:
         value = copy.deepcopy(value)
     return SparseTensorSharedVariable(

aesara/sparse/type.py

@@ -25,9 +25,8 @@ def _is_sparse(x):
     return isinstance(x, scipy.sparse.spmatrix)
 
 
-class SparseType(TensorType, HasDataType):
-    """
-    Fundamental way to create a sparse node.
+class SparseTensorType(TensorType, HasDataType):
+    """A `Type` for sparse tensors.
 
     Parameters
     ----------
@@ -42,8 +41,7 @@ class SparseType(TensorType, HasDataType):
 
     Notes
     -----
-    As far as I can tell, L{scipy.sparse} objects must be matrices, i.e.
-    have dimension 2.
+    Currently, sparse tensors can only be matrices (i.e. have two dimensions).
 
     """
 
@@ -126,15 +124,13 @@ class SparseType(TensorType, HasDataType):
             raise NotImplementedError()
         return sp
 
-    @staticmethod
-    def may_share_memory(a, b):
-        # This is Fred suggestion for a quick and dirty way of checking
-        # aliasing .. this can potentially be further refined (ticket #374)
+    @classmethod
+    def may_share_memory(cls, a, b):
         if _is_sparse(a) and _is_sparse(b):
             return (
-                SparseType.may_share_memory(a, b.data)
-                or SparseType.may_share_memory(a, b.indices)
-                or SparseType.may_share_memory(a, b.indptr)
+                cls.may_share_memory(a, b.data)
+                or cls.may_share_memory(a, b.indices)
+                or cls.may_share_memory(a, b.indptr)
             )
         if _is_sparse(b) and isinstance(a, np.ndarray):
             a, b = b, a
@@ -151,7 +147,7 @@ class SparseType(TensorType, HasDataType):
     def convert_variable(self, var):
         res = super().convert_variable(var)
 
-        if res and not isinstance(res.type, SparseType):
+        if res and not isinstance(res.type, type(self)):
             # TODO: Convert to this sparse format
             raise NotImplementedError()
 
@@ -232,9 +228,8 @@ class SparseType(TensorType, HasDataType):
         return False
 
 
-# Register SparseType's C code for ViewOp.
 aesara.compile.register_view_op_c_code(
-    SparseType,
+    SparseTensorType,
     """
     Py_XDECREF(%(oname)s);
     %(oname)s = %(iname)s;
@@ -242,3 +237,6 @@ aesara.compile.register_view_op_c_code(
     """,
     1,
 )
+
+# This is a deprecated alias used for (temporary) backward-compatibility
+SparseType = SparseTensorType

aesara/tensor/basic.py

@@ -314,9 +314,9 @@ def get_scalar_constant_value(
                 except ValueError:
                     raise NotScalarConstantError()
 
-            from aesara.sparse.type import SparseType
+            from aesara.sparse.type import SparseTensorType
 
-            if isinstance(v.type, SparseType):
+            if isinstance(v.type, SparseTensorType):
                 raise NotScalarConstantError()
 
             return data

doc/extending/other_ops.rst

@@ -44,7 +44,7 @@ usual dense tensors. In particular, in the
 instead of ``as_tensor_variable(x)``.
 
 Another difference is that you need to use ``SparseVariable`` and
-``SparseType`` instead of ``TensorVariable`` and ``TensorType``.
+``SparseTensorType`` instead of ``TensorVariable`` and ``TensorType``.
 
 Do not forget that we support only sparse matrices (so only 2 dimensions)
 and (like in SciPy) they do not support broadcasting operations by default
@@ -55,7 +55,7 @@ you can create output variables like this:
 .. code-block:: python
 
     out_format = inputs[0].format  # or 'csr' or 'csc' if the output format is fixed
-    SparseType(dtype=inputs[0].dtype, format=out_format).make_variable()
+    SparseTensorType(dtype=inputs[0].dtype, format=out_format).make_variable()
 
 See the sparse :class:`Aesara.sparse.basic.Cast` `Op` code for a good example of
 a sparse `Op` with Python code.
@@ -226,7 +226,7 @@ along with pointers to the relevant documentation.
         primitive type. The C type associated with this Aesara type is the
         represented C primitive itself.
 
-*       :ref:`SparseType <sparse_ops>` : Aesara `Type` used to represent sparse
+*       :ref:`SparseTensorType <sparse_ops>` : Aesara `Type` used to represent sparse
         tensors. There is no equivalent C type for this Aesara `Type` but you
         can split a sparse variable into its parts as TensorVariables. Those
         can then be used as inputs to an op with C code.

tests/compile/function/test_pfunc.py

@@ -751,8 +751,8 @@ class TestAliasingRules:
         #        operations are used) and to break the elemwise composition
         #        with some non-elemwise op (here dot)
 
-        x = sparse.SparseType("csc", dtype="float64")()
-        y = sparse.SparseType("csc", dtype="float64")()
+        x = sparse.SparseTensorType("csc", dtype="float64")()
+        y = sparse.SparseTensorType("csc", dtype="float64")()
         f = function([In(x, mutable=True), In(y, mutable=True)], (x + y) + (x + y))
         # Test 1. If the same variable is given twice
 

tests/sparse/test_type.py

 import pytest
 
 from aesara.sparse import matrix as sp_matrix
-from aesara.sparse.type import SparseType
+from aesara.sparse.type import SparseTensorType
 from aesara.tensor import dmatrix
 
 
 def test_clone():
-    st = SparseType("csr", "float64")
+    st = SparseTensorType("csr", "float64")
     assert st == st.clone()
 
 

tests/sparse/test_var.py

@@ -7,7 +7,7 @@ from scipy.sparse.csr import csr_matrix
 import aesara
 import aesara.sparse as sparse
 import aesara.tensor as at
-from aesara.sparse.type import SparseType
+from aesara.sparse.type import SparseTensorType
 from aesara.tensor.type import DenseTensorType
 
 
@@ -16,7 +16,7 @@ class TestSparseVariable:
         "method, exp_type, cm",
         [
             ("__abs__", DenseTensorType, None),
-            ("__neg__", SparseType, ExitStack()),
+            ("__neg__", SparseTensorType, ExitStack()),
             ("__ceil__", DenseTensorType, None),
             ("__floor__", DenseTensorType, None),
             ("__trunc__", DenseTensorType, None),
@@ -65,7 +65,7 @@ class TestSparseVariable:
             ("conj", DenseTensorType, None),
             ("round", DenseTensorType, None),
             ("trace", DenseTensorType, None),
-            ("zeros_like", SparseType, ExitStack()),
+            ("zeros_like", SparseTensorType, ExitStack()),
             ("ones_like", DenseTensorType, ExitStack()),
             ("cumsum", DenseTensorType, None),
             ("cumprod", DenseTensorType, None),
@@ -83,7 +83,7 @@ class TestSparseVariable:
         if cm is None:
             cm = pytest.warns(UserWarning, match=".*converted to dense.*")
 
-        if exp_type == SparseType:
+        if exp_type == SparseTensorType:
             exp_res_type = csr_matrix
         else:
             exp_res_type = np.ndarray
@@ -112,16 +112,16 @@ class TestSparseVariable:
     @pytest.mark.parametrize(
         "method, exp_type",
         [
-            ("__lt__", SparseType),
-            ("__le__", SparseType),
-            ("__gt__", SparseType),
-            ("__ge__", SparseType),
+            ("__lt__", SparseTensorType),
+            ("__le__", SparseTensorType),
+            ("__gt__", SparseTensorType),
+            ("__ge__", SparseTensorType),
             ("__and__", DenseTensorType),
             ("__or__", DenseTensorType),
             ("__xor__", DenseTensorType),
-            ("__add__", SparseType),
-            ("__sub__", SparseType),
-            ("__mul__", SparseType),
+            ("__add__", SparseTensorType),
+            ("__sub__", SparseTensorType),
+            ("__mul__", SparseTensorType),
             ("__pow__", DenseTensorType),
             ("__mod__", DenseTensorType),
             ("__divmod__", DenseTensorType),
@@ -137,7 +137,7 @@ class TestSparseVariable:
 
         method_to_call = getattr(x, method)
 
-        if exp_type == SparseType:
+        if exp_type == SparseTensorType:
             exp_res_type = csr_matrix
             cm = ExitStack()
         else:
@@ -198,7 +198,7 @@ class TestSparseVariable:
         x = sparse.csr_from_dense(x)
 
         z = x[:, :2]
-        assert isinstance(z.type, SparseType)
+        assert isinstance(z.type, SparseTensorType)
 
         f = aesara.function([x], z)
         exp_res = f([[1.1, 0.0, 2.0], [-1.0, 0.0, 0.0]])
@@ -211,7 +211,7 @@ class TestSparseVariable:
         y = sparse.csr_from_dense(y)
 
         z = x.__dot__(y)
-        assert isinstance(z.type, SparseType)
+        assert isinstance(z.type, SparseTensorType)
 
         f = aesara.function([x, y], z)
         exp_res = f(

tests/typed_list/test_basic.py

@@ -451,7 +451,7 @@ class TestIndex:
     def test_sparse(self):
         sp = pytest.importorskip("scipy")
         mySymbolicSparseList = TypedListType(
-            sparse.SparseType("csr", aesara.config.floatX)
+            sparse.SparseTensorType("csr", aesara.config.floatX)
         )()
         mySymbolicSparse = sparse.csr_matrix()
 
@@ -519,7 +519,7 @@ class TestCount:
     def test_sparse(self):
         sp = pytest.importorskip("scipy")
         mySymbolicSparseList = TypedListType(
-            sparse.SparseType("csr", aesara.config.floatX)
+            sparse.SparseTensorType("csr", aesara.config.floatX)
         )()
         mySymbolicSparse = sparse.csr_matrix()