Update to version 0.0.5 - includes SciPy csc, csr, dok, lil matrices support.

Author: interpret-ml

.gitignore

@@ -9,4 +9,5 @@ dist/
 *.egg-info/
 htmlcov/
 .idea/
-staging/
+staging/
+.vscode/

CHANGELOG.md

@@ -4,8 +4,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and the versioning is mostly derived from [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v0.0.5] - 2020-11-04
+### Added
+- Added support for SciPy csr, csc, lil, dok matrices.
+
 ## [v0.0.4] - 2020-09-17
 ### Added
 - Initial public release.
 
+[v0.0.5]: https://github.com/interpretml/slicer/releases/tag/v0.0.5
 [v0.0.4]: https://github.com/interpretml/slicer/releases/tag/v0.0.4

setup.py

@@ -5,7 +5,7 @@
 
 setuptools.setup(
     name="slicer",
-    version="0.0.4",
+    version="0.0.5",
     author="InterpretML",
     author_email="interpret@microsoft.com",
     description="A small package for big slicing.",

slicer/slicer_internal.py

@@ -405,15 +405,27 @@ def head_slice(cls, o, index_tup, max_dim):
 
         # Process native array dimensions
         cut_index = index_tup[:cut]
-        is_element = True if isinstance(cut_index[-1], int) else False
+        is_element = any([True if isinstance(x, int) else False for x in cut_index])
         sliced_o = o[cut_index]
 
         return is_element, sliced_o, cut
 
     @classmethod
     def tail_slice(cls, o, tail_index, max_dim, flatten=True):
         if flatten:
-            return AtomicSlicer(o, max_dim=max_dim)[tail_index]
+            # NOTE: If we're dealing with a scipy matrix,
+            #       we have to manually flatten it ourselves
+            #       to keep consistent to the rest of slicer's API.
+            if _safe_isinstance(o, "scipy.sparse.csc", "csc_matrix"):
+                return AtomicSlicer(o.toarray().flatten(), max_dim=max_dim)[tail_index]
+            elif _safe_isinstance(o, "scipy.sparse.csr", "csr_matrix"):
+                return AtomicSlicer(o.toarray().flatten(), max_dim=max_dim)[tail_index]
+            elif _safe_isinstance(o, "scipy.sparse.dok", "dok_matrix"):
+                return AtomicSlicer(o.toarray().flatten(), max_dim=max_dim)[tail_index]
+            elif _safe_isinstance(o, "scipy.sparse.lil", "lil_matrix"):
+                return AtomicSlicer(o.toarray().flatten(), max_dim=max_dim)[tail_index]
+            else:
+                return AtomicSlicer(o, max_dim=max_dim)[tail_index]
         else:
             inner = [AtomicSlicer(e, max_dim=max_dim)[tail_index] for e in o]
             if _safe_isinstance(o, "numpy", "ndarray"):
@@ -427,6 +439,22 @@ def tail_slice(cls, o, tail_index, max_dim, flatten=True):
                     return torch.stack(inner)
                 else:
                     return torch.tensor(inner)
+            elif _safe_isinstance(o, "scipy.sparse.csc", "csc_matrix"):
+                from scipy.sparse import vstack
+                out = vstack(inner, format='csc')
+                return out
+            elif _safe_isinstance(o, "scipy.sparse.csr", "csr_matrix"):
+                from scipy.sparse import vstack
+                out = vstack(inner, format='csr')
+                return out
+            elif _safe_isinstance(o, "scipy.sparse.dok", "dok_matrix"):
+                from scipy.sparse import vstack
+                out = vstack(inner, format='dok')
+                return out
+            elif _safe_isinstance(o, "scipy.sparse.lil", "lil_matrix"):
+                from scipy.sparse import vstack
+                out = vstack(inner, format='lil')
+                return out
             else:
                 raise ValueError(f"Cannot handle type {type(o)}.")  # pragma: no cover
 
@@ -519,6 +547,10 @@ class UnifiedDataHandler:
         ("builtins", "dict"): DictHandler,
         ("torch", "Tensor"): ArrayHandler,
         ("numpy", "ndarray"): ArrayHandler,
+        ("scipy.sparse.csc", "csc_matrix"): ArrayHandler,
+        ("scipy.sparse.csr", "csr_matrix"): ArrayHandler,
+        ("scipy.sparse.dok", "dok_matrix"): ArrayHandler,
+        ("scipy.sparse.lil", "lil_matrix"): ArrayHandler,
         ("pandas.core.frame", "DataFrame"): DataFrameHandler,
         ("pandas.core.series", "Series"): SeriesHandler,
     }

slicer/test_slicer.py

@@ -2,16 +2,23 @@
 An unholy balance of use cases and test coverage.
 """
 
+import pytest
+
 from .slicer import AtomicSlicer
 
 from . import Slicer as S
 from . import Alias as A
 from . import Obj as O
 
-import pytest
 import pandas as pd
-import torch
 import numpy as np
+import torch
+from scipy.sparse import csc_matrix
+from scipy.sparse import csr_matrix
+from scipy.sparse import dok_matrix
+from scipy.sparse import lil_matrix
+
+
 from .utils_testing import ctr_eq
 
 
@@ -214,6 +221,38 @@ def test_slicer_simple_di():
     assert ctr_eq(actual, 3)
 
 
+def test_slicer_sparse():
+    array = np.array([[1, 0, 4], [0, 0, 5], [2, 3, 6]])
+    csc_array = csc_matrix(array)
+    csr_array = csr_matrix(array)
+    dok_array = dok_matrix(array)
+    lil_array = lil_matrix(array)
+
+    candidates = [csc_array, csr_array, dok_array, lil_array]
+    for candidate in candidates:
+        slicer = S(candidate)
+        actual = slicer[0, 0]
+        assert ctr_eq(actual.o, 1)
+        actual = slicer[1, 1]
+        assert ctr_eq(actual.o, 0)
+
+        actual = slicer[0]
+        expected = np.array([1, 0, 4])
+        assert ctr_eq(actual.o, expected)
+
+        actual = slicer[:, 1]
+        expected = np.array([0, 0, 3])
+        assert ctr_eq(actual.o, expected)
+
+        actual = slicer[:, :]
+        expected = np.array([[1, 0, 4], [0, 0, 5], [2, 3, 6]])
+        assert ctr_eq(actual.o, expected)
+
+        actual = slicer[0, :]
+        expected = np.array([1, 0, 4])
+        assert ctr_eq(actual.o, expected)
+
+
 def test_slicer_torch():
     import torch
 
@@ -277,7 +316,7 @@ def test_tracked_dim_arg_smoke():
     assert True
 
 
-def test_atomic_1d():
+def test_operations_1d():
     elements = [1, 2, 3, 4]
     li = elements
     tup = tuple(elements)
@@ -305,12 +344,17 @@ def test_atomic_1d():
             assert ctr_eq(slicer[0:3:2], elements[0:3:2])
 
 
-def test_atomic_2d():
+def test_operations_2d():
     elements = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
     li = elements
     df = pd.DataFrame(elements, columns=["A", "B", "C"])
 
-    containers = [li, df]
+    sparse_csc = csc_matrix(elements)
+    sparse_csr = csr_matrix(elements)
+    sparse_dok = dok_matrix(elements)
+    sparse_lil = lil_matrix(elements)
+
+    containers = [li, df, sparse_csc, sparse_csr, sparse_dok, sparse_lil]
     for _, ctr in enumerate(containers):
         slicer = AtomicSlicer(ctr)
 
@@ -337,7 +381,7 @@ def test_atomic_2d():
         assert ctr_eq(slicer[..., 0], [elements[i][0] for i, _ in enumerate(elements)])
 
 
-def test_atomic_3d():
+def test_operations_3d():
     # 3-dimensional fixed dimension case
     elements = [
         [[1, 2, 3], [4, 5, 6]],

slicer/utils_testing.py

@@ -7,9 +7,16 @@
 import numpy as np
 import torch
 import pandas as pd
+from scipy.sparse import csc_matrix
+from scipy.sparse import csr_matrix
+from scipy.sparse import dok_matrix
+from scipy.sparse import lil_matrix
 
 
 def coerced(o: Any):
+    if isinstance(o, (csc_matrix, csr_matrix, dok_matrix, lil_matrix)):
+        o = o.toarray()
+
     to_list_collections = tuple([np.ndarray, torch.Tensor, pd.core.series.Series])
     if isinstance(o, (list, tuple)):
         return o