Merge pull request #496 from sjsrey/from_WSP

Implements W.from_WSP

Author: sjsrey

.github/workflows/unittests.yml

@@ -20,7 +20,6 @@
        matrix:
          os: ['ubuntu-latest']
          environment-file: [
-            ci/38-minimal.yaml,
             ci/38.yaml,
             ci/39.yaml,
             ci/310.yaml,

ci/38-minimal.yaml

@@ -2,6 +2,7 @@
 import tempfile
 
 import unittest
+import pytest
 from ..weights import W, WSP
 from .. import util
 from ..util import WSP2W, lat2W
@@ -10,6 +11,7 @@
 from ... import examples
 from ..distance import KNN
 import numpy as np
+import scipy.sparse
 
 NPTA3E = np.testing.assert_array_almost_equal
 
@@ -44,6 +46,7 @@ def setUp(self):
         }
 
         self.w3x3 = util.lat2W(3, 3)
+        self.w_islands = W({0: [1], 1: [0, 2], 2: [1], 3: []})
 
     def test_W(self):
         w = W(self.neighbors, self.weights, silence_warnings=True)
@@ -355,6 +358,33 @@ def test_roundtrip_write(self):
             new = W.from_file(path)
         np.testing.assert_array_equal(self.w.sparse.toarray(), new.sparse.toarray())
 
+    def test_to_sparse(self):
+        sparse = self.w_islands.to_sparse()
+        np.testing.assert_array_equal(sparse.data, [1, 1, 1, 1, 0])
+        np.testing.assert_array_equal(sparse.row, [0, 1, 1, 2, 3])
+        np.testing.assert_array_equal(sparse.col, [1, 0, 2, 1, 3])
+        sparse = self.w_islands.to_sparse("bsr")
+        self.assertIsInstance(sparse, scipy.sparse._arrays.bsr_array)
+        sparse = self.w_islands.to_sparse("csr")
+        self.assertIsInstance(sparse, scipy.sparse._arrays.csr_array)
+        sparse = self.w_islands.to_sparse("coo")
+        self.assertIsInstance(sparse, scipy.sparse._arrays.coo_array)
+        sparse = self.w_islands.to_sparse("csc")
+        self.assertIsInstance(sparse, scipy.sparse._arrays.csc_array)
+        sparse = self.w_islands.to_sparse()
+        self.assertIsInstance(sparse, scipy.sparse._arrays.coo_array)
+
+    def test_sparse_fmt(self):
+        with pytest.raises(ValueError) as exc_info:
+            sparse = self.w_islands.to_sparse("dog")
+
+    def test_from_sparse(self):
+        sparse = self.w_islands.to_sparse()
+        w = W.from_sparse(sparse)
+        self.assertEqual(w.n, 4)
+        self.assertEqual(len(w.islands), 0)
+        self.assertEqual(w.neighbors[3], [3])
+
 
 class Test_WSP_Back_To_W(unittest.TestCase):
     # Test to make sure we get back to the same W functionality
@@ -689,6 +719,11 @@ def test_trcWtW_WW(self):
     def test_s0(self):
         self.assertEqual(self.w3x3.s0, 24.0)
 
+    def test_from_WSP(self):
+        w = W.from_WSP(self.wsp)
+        self.assertEqual(w.n, 100)
+        self.assertEqual(w.pct_nonzero, 4.62)
+
 
 if __name__ == "__main__":
     unittest.main()

libpysal/weights/tests/test_weights.py

@@ -24,6 +24,7 @@
 
 try:
     from shapely.geometry.base import BaseGeometry
+
     HAS_SHAPELY = True
 except ImportError:
     HAS_SHAPELY = False
@@ -534,17 +535,17 @@ def higher_order_sp(
         )
 
     if lower_order:
-        wk = sum(map(lambda x: w ** x, range(2, k + 1)))
+        wk = sum(map(lambda x: w**x, range(2, k + 1)))
         shortest_path = False
     else:
-        wk = w ** k
+        wk = w**k
 
     rk, ck = wk.nonzero()
     sk = set(zip(rk, ck))
 
     if shortest_path:
         for j in range(1, k):
-            wj = w ** j
+            wj = w**j
             rj, cj = wj.nonzero()
             sj = set(zip(rj, cj))
             sk.difference_update(sj)
@@ -826,14 +827,12 @@ def WSP2W(wsp, **kwargs):
 
 
     """
-    wsp.sparse
-    indices = wsp.sparse.indices
     data = wsp.sparse.data
     indptr = wsp.sparse.indptr
     id_order = wsp.id_order
     if id_order:
         # replace indices with user IDs
-        indices = [id_order[i] for i in indices]
+        indices = [id_order[i] for i in wsp.sparse.indices]
     else:
         id_order = list(range(wsp.n))
     neighbors, weights = {}, {}
@@ -1086,12 +1085,7 @@ def get_points_array(iterable):
                 ]
             )
         else:
-            data = np.vstack(
-                [
-                    np.array(shape.centroid)
-                    for shape in first_choice
-                ]
-            )
+            data = np.vstack([np.array(shape.centroid) for shape in first_choice])
     except AttributeError:
         data = np.vstack([shape for shape in backup])
     return data

libpysal/weights/util.py

@@ -10,6 +10,8 @@
 import numpy as np
 import scipy.sparse
 from scipy.sparse.csgraph import connected_components
+from sklearn import preprocessing
+from collections import defaultdict
 
 # from .util import full, WSP2W resolve import cycle by
 # forcing these into methods
@@ -232,7 +234,67 @@ def from_shapefile(cls, *args, **kwargs):
 
     @classmethod
     def from_WSP(cls, WSP, silence_warnings=True):
-        return WSP2W(WSP, silence_warnings=silence_warnings)
+        """Create a pysal W from a pysal WSP object (thin weights matrix).
+
+        Parameters
+        ----------
+        wsp                     : WSP
+                                PySAL sparse weights object
+
+        silence_warnings        : bool
+           By default ``libpysal`` will print a warning if the dataset contains
+           any disconnected components or islands. To silence this warning set this
+           parameter to ``True``.
+
+
+        Returns
+        -------
+        w       : W
+                PySAL weights object
+
+        Examples
+        --------
+        >>> from libpysal.weights import lat2W, WSP, W
+
+        Build a 10x10 scipy.sparse matrix for a rectangular 2x5 region of cells
+        (rook contiguity), then construct a PySAL sparse weights object (wsp).
+
+        >>> sp = lat2SW(2, 5)
+        >>> wsp = WSP(sp)
+        >>> wsp.n
+        10
+        >>> wsp.sparse[0].todense()
+        matrix([[0, 1, 0, 0, 0, 1, 0, 0, 0, 0]], dtype=int8)
+
+        Create a standard PySAL W from this sparse weights object.
+
+        >>> w = W.from_WSP(wsp)
+        >>> w.n
+        10
+        >>> print(w.full()[0][0])
+        [0 1 0 0 0 1 0 0 0 0]
+        """
+        data = WSP.sparse.data
+        indptr = WSP.sparse.indptr
+        id_order = WSP.id_order
+        if id_order:
+            # replace indices with user IDs
+            indices = [id_order[i] for i in WSP.sparse.indices]
+        else:
+            id_order = list(range(WSP.n))
+        neighbors, weights = {}, {}
+        start = indptr[0]
+        for i in range(WSP.n):
+            oid = id_order[i]
+            end = indptr[i + 1]
+            neighbors[oid] = indices[start:end]
+            weights[oid] = data[start:end]
+            start = end
+        ids = copy.copy(WSP.id_order)
+        w = W(neighbors, weights, ids, silence_warnings=silence_warnings)
+        w._sparse = copy.deepcopy(WSP.sparse)
+        w._cache["sparse"] = w._sparse
+        return w
 
     @classmethod
     def from_adjlist(
@@ -385,6 +447,73 @@ def sparse(self):
             self._cache["sparse"] = self._sparse
         return self._sparse
 
+    @classmethod
+    def from_sparse(cls, sparse):
+        """Convert a ``scipy.sparse`` array to a PySAL ``W`` object.
+
+        Parameters
+        ----------
+        sparse : scipy.sparse array
+
+        Returns
+        -------
+        w : libpysal.weights.W
+            A ``W`` object containing the same graph as the ``scipy.sparse`` graph.
+
+
+        Notes
+        -----
+        When the sparse array has a zero in its data attribute, and
+        the corresponding row and column values are equal, the value
+        for the pysal weight will be 0 for the "loop".
+        """
+        coo = sparse.tocoo()
+        neighbors = defaultdict(list)
+        weights = defaultdict(list)
+        for k, v, w in zip(coo.row, coo.col, coo.data):
+            neighbors[k].append(v)
+            weights[k].append(w)
+        return W(neighbors=neighbors, weights=weights)
+
+    def to_sparse(self, fmt="coo"):
+        """Generate a ``scipy.sparse`` array object from a pysal W.
+
+        Parameters
+        ----------
+        fmt : {'bsr', 'coo', 'csc', 'csr'}
+          scipy.sparse format
+
+        Returns
+        -------
+        scipy.sparse array
+          A scipy.sparse array with a format of fmt.
+
+        Notes
+        -----
+        The keys of the w.neighbors are encoded
+        to determine row,col in the sparse array.
+
+        """
+        disp = {}
+        disp["bsr"] = scipy.sparse.bsr_array
+        disp["coo"] = scipy.sparse.coo_array
+        disp["csc"] = scipy.sparse.csc_array
+        disp["csr"] = scipy.sparse.csr_array
+        fmt_l = fmt.lower()
+        if fmt_l in disp:
+            adj_list = self.to_adjlist(drop_islands=False)
+            data = adj_list.weight
+            row = adj_list.focal
+            col = adj_list.neighbor
+            le = preprocessing.LabelEncoder()
+            le.fit(row)
+            row = le.transform(row)
+            col = le.transform(col)
+            n = self.n
+            return disp[fmt_l]((data, (row, col)), shape=(n, n))
+        else:
+            raise ValueError(f"unsupported sparse format: {fmt}")
+
     @property
     def n_components(self):
         """Store whether the adjacency matrix is fully connected."""
@@ -1306,7 +1435,7 @@ def plot(
         ax.scatter(
             gdf.centroid.apply(lambda p: p.x),
             gdf.centroid.apply(lambda p: p.y),
-            **node_kws
+            **node_kws,
         )
         return f, ax