egosplit-sknetwork 0.0.4__tar.gz

egosplit_sknetwork-0.0.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ryan DeWolfe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

egosplit_sknetwork-0.0.4/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: egosplit_sknetwork
+Version: 0.0.4
+Summary: Fast python implementation of the egosplitting framework for overlapping clustering using sknetwork.
+Author-email: Ryan DeWolfe <ryandewolfe33@gmail.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: scikit-network>=0.33
+Requires-Dist: numba>=0.60.0
+Dynamic: license-file
+
+# EgoSplit-sknetwork
+
+This package provides a fast and flexible implementation of the egosplitting community detection paradigm for detecting overlapping communities.
+For details and motivation of the algorithm, please see the paper below.
+The reference implementation is available [here](https://github.com/google-research/google-research/blob/master/graph_embedding/persona/persona.py).
+
+
+> Alessandro Epasto, Silvio Lattanzi, and Renato Paes Leme. 2017. Ego-Splitting Framework: from Non-Overlapping to Overlapping Clusters. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD '17). Association for Computing Machinery, New York, NY, USA, 145-154. https://doi.org/10.1145/3097983.3098054
+
+# Installation
+
+Currently you can install this package by cloning this repository and installing locally.
+```sh
+git clone https://github.com/ryandewolfe33/egosplit-sknetwork.git
+cd egosplit-sknetwork
+pip install .
+```
+
+
+# Example
+
+```python
+import sknetwork as sn
+from egosplit_sknetwork import EgoSplit
+
+g = sn.data.toy_graphs.karate_club()
+egosplit = EgoSplit()
+labels = egosplit.fit_predict(g)
+```
+
+By default the algorithm uses [Propagation Clustering](https://scikit-network.readthedocs.io/en/latest/reference/clustering.html#sknetwork.clustering.PropagationClustering) for local clustering and [Leiden](https://scikit-network.readthedocs.io/en/latest/reference/clustering.html#sknetwork.clustering.Leiden) for global clustering.
+To pass other clustering algorithms to egosplit, they must be initialized in advace and passed as parameters.
+The algorithm accepts any subclass of [sknetwork.clustering.BaseClustering](https://scikit-network.readthedocs.io/en/latest/reference/clustering.html) for either local_clustering (used to cluster the egonets) or global_clustering (used to cluster the persona graph).
+
+```python
+high_res_clusterer = sn.clustering.Louvain(resolution=5, random_state=42)
+egosplit = EgoSplit(local_clustering='PC', global_clustering=high_res_clusterer)
+egosplit.fit(g)
+labels = egosplit.labels_
+```
+
+Labels is a sparse matrix with dimensions (n_labels, n_vertices), where `labels[i,j] = True` if vertex j is in cluster i.

egosplit_sknetwork-0.0.4/README.md

@@ -0,0 +1,42 @@
+# EgoSplit-sknetwork
+
+This package provides a fast and flexible implementation of the egosplitting community detection paradigm for detecting overlapping communities.
+For details and motivation of the algorithm, please see the paper below.
+The reference implementation is available [here](https://github.com/google-research/google-research/blob/master/graph_embedding/persona/persona.py).
+
+
+> Alessandro Epasto, Silvio Lattanzi, and Renato Paes Leme. 2017. Ego-Splitting Framework: from Non-Overlapping to Overlapping Clusters. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD '17). Association for Computing Machinery, New York, NY, USA, 145-154. https://doi.org/10.1145/3097983.3098054
+
+# Installation
+
+Currently you can install this package by cloning this repository and installing locally.
+```sh
+git clone https://github.com/ryandewolfe33/egosplit-sknetwork.git
+cd egosplit-sknetwork
+pip install .
+```
+
+
+# Example
+
+```python
+import sknetwork as sn
+from egosplit_sknetwork import EgoSplit
+
+g = sn.data.toy_graphs.karate_club()
+egosplit = EgoSplit()
+labels = egosplit.fit_predict(g)
+```
+
+By default the algorithm uses [Propagation Clustering](https://scikit-network.readthedocs.io/en/latest/reference/clustering.html#sknetwork.clustering.PropagationClustering) for local clustering and [Leiden](https://scikit-network.readthedocs.io/en/latest/reference/clustering.html#sknetwork.clustering.Leiden) for global clustering.
+To pass other clustering algorithms to egosplit, they must be initialized in advace and passed as parameters.
+The algorithm accepts any subclass of [sknetwork.clustering.BaseClustering](https://scikit-network.readthedocs.io/en/latest/reference/clustering.html) for either local_clustering (used to cluster the egonets) or global_clustering (used to cluster the persona graph).
+
+```python
+high_res_clusterer = sn.clustering.Louvain(resolution=5, random_state=42)
+egosplit = EgoSplit(local_clustering='PC', global_clustering=high_res_clusterer)
+egosplit.fit(g)
+labels = egosplit.labels_
+```
+
+Labels is a sparse matrix with dimensions (n_labels, n_vertices), where `labels[i,j] = True` if vertex j is in cluster i.

egosplit_sknetwork-0.0.4/egosplit_sknetwork/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.0.4"
+from .egosplit_sknetwork_ import EgoSplit
+
+__all__ = ["EgoSplit"]

egosplit_sknetwork-0.0.4/egosplit_sknetwork/egosplit_sknetwork_.py

@@ -0,0 +1,279 @@
+import sknetwork as sn
+import numpy as np
+import scipy.sparse as sp
+import numba
+from numba.typed import List
+from numba.types import int32
+from tqdm import tqdm
+
+
+class ConnectedComponents(sn.clustering.BaseClustering):
+    """
+    A helper class that allows connected components to behave like a clustering algorithm.
+    The clusters are the connected components of the input graph
+    """
+
+    def __init__(
+        self,
+        sort_clusters: bool = True,
+        return_probs: bool = False,
+        return_aggregate: bool = False,
+    ):
+        super(ConnectedComponents, self).__init__(
+            sort_clusters=sort_clusters,
+            return_probs=return_probs,
+            return_aggregate=return_aggregate,
+        )
+
+    def fit(self, g):
+        self.labels_ = sp.csgraph.connected_components(g)[1]
+        return self
+
+
+#################################
+# Helper Functions for EgoSplit #
+#################################
+
+
+@numba.njit(nogil=True)
+def _get_data(indptr, indices, data, i, j):
+    for index in range(indptr[i], indptr[i + 1]):
+        if indices[index] == j:
+            return data[index]
+    return -1
+
+
+@numba.njit
+def _make_neighbor_sets(indptr, indices):
+    neighbors = List(
+        [set(indices[indptr[i] : indptr[i + 1]]) for i in range(len(indptr) - 1)]
+    )
+    return neighbors
+
+
+@numba.njit
+def _make_egonet(i, neighbor_sets, global_indptr, global_indices, global_data):
+    egonet_nodes = neighbor_sets[i]
+    egonet_old_ids = np.empty(len(egonet_nodes), dtype="int32")
+    for i, node in enumerate(egonet_nodes):
+        egonet_old_ids[i] = node
+    new_ids = {node: int32(index) for index, node in enumerate(egonet_old_ids)}
+    lil = List.empty_list(int32[:])
+    for node in egonet_old_ids:
+        egonet_neighbors_old_ids = neighbor_sets[node].intersection(egonet_nodes)
+        egonet_neighbors_new_ids = np.empty(
+            len(egonet_neighbors_old_ids), dtype="int32"
+        )
+        for i, old_id in enumerate(egonet_neighbors_old_ids):
+            egonet_neighbors_new_ids[i] = new_ids[old_id]
+        egonet_neighbors_new_ids.sort()
+        lil.append(egonet_neighbors_new_ids)
+    indptr = np.empty(len(lil) + 1, dtype="int32")
+    indptr[0] = 0
+    n_edges = 0
+    for i in lil:
+        n_edges += len(i)
+    indices = np.empty(n_edges, dtype="int32")
+    data = np.empty_like(indices, dtype=global_data.dtype)
+    for i, neighbors in enumerate(lil):
+        indptr[i + 1] = indptr[i] + len(neighbors)
+        indices[indptr[i] : indptr[i + 1]] = neighbors
+
+        i_old_id = egonet_old_ids[i]
+        neighbors_old_ids = np.empty_like(neighbors)
+        for j, n in enumerate(neighbors):
+            neighbors_old_ids[j] = egonet_old_ids[n]
+        for j, index in enumerate(range(indptr[i], indptr[i + 1])):
+            data[index] = _get_data(
+                global_indptr,
+                global_indices,
+                global_data,
+                i_old_id,
+                neighbors_old_ids[j],
+            )
+    return indptr, indices, data
+
+
+@numba.njit
+def make_persona_graph(
+    g_indptr, g_indices, g_data, egonet_indices, egonet_community, first_personae_index
+):
+    persona_indptr = np.empty(first_personae_index[-1] + 1, dtype="int32")
+    persona_indptr[-1] = len(g_indices)
+    persona_indices = np.empty_like(g_indices)
+    persona_data = np.empty_like(g_data)
+
+    next_index = 0
+    for og_n1 in range(len(g_indptr) - 1):
+        og_neighbors = egonet_indices[og_n1]
+        communities = egonet_community[og_n1]
+
+        for c in range(np.max(communities) + 1):
+            new_n1 = first_personae_index[og_n1] + c
+            new_n1_indptr = next_index
+            persona_indptr[new_n1] = new_n1_indptr
+            for i in range(len(communities)):
+                if communities[i] != c:
+                    continue
+                og_n2 = og_neighbors[i]
+                # Get new id of the other end of the edge (og_n1, og_n2)
+                og_n2_neighbors = egonet_indices[og_n2]
+                # search for og_n1
+                for j in range(len(og_n2_neighbors)):
+                    if og_n2_neighbors[j] != og_n1:
+                        continue
+                    # Get the egonet commuity of og_n1
+                    n2_persona_for_n1 = egonet_community[og_n2][j]
+                    new_n2 = first_personae_index[og_n2] + n2_persona_for_n1
+                    # write new n2_persona and data into persona graph
+                    persona_indices[next_index] = new_n2
+                    persona_data[next_index] = g_data[g_indptr[og_n1]] + i
+                    next_index += 1
+    return persona_data, persona_indices, persona_indptr
+
+
+class EgoSplit:
+    """
+    Implementation of the Egosplitting framework method for overlapping clustering using
+    sknetwork. Since sknetwork does not allow overlapping clusterings, this is not a
+    subclass of the sknetwork.clustering.BaseClustering, but it is built to behave similarly.
+
+    Parameters
+    ----------
+    local_clustering: The clustering method used for the egonet. Should be either "CC"
+        (ConnectedCompnents), "PC" (PropagationClustering), or a subclass of
+        sknetwork.clustering.BaseClustering.
+    global_clustering: The clustering method used for the persona graph. Should
+        be either "Louvain", "Leiden", or a subclass of sknetwork.clustering.BaseClustering.
+    random_state: The random state to pass to the default clustering algorithms
+
+    Returns
+    -------
+    scipy.sparse.csr_matrix: An overlapping clustering of the nodes. Rows correspond to clusters
+        and columns to nodes.
+
+    Example
+    -------
+    >>> g = sn.data.karate_club()
+    >>> part1 = EgoSplit().fit_predict(g)
+
+    Reference
+    ---------
+    Alessandro Epasto, Silvio Lattanzi, and Renato Paes Leme. 2017. Ego-Splitting Framework:
+    from Non-Overlapping to Overlapping Clusters. In Proceedings of the 23rd ACM SIGKDD
+    International Conference on Knowledge Discovery and Data Mining (KDD '17). Association
+    for Computing Machinery, New York, NY, USA, 145-154. https://doi.org/10.1145/3097983.3098054
+    """
+
+    def __init__(
+        self,
+        local_clustering="PC",
+        global_clustering="Leiden",
+        min_cluster_size=5,
+        random_state=None,
+        verbose=False,
+    ):
+        if local_clustering == "CC":
+            self.local_clustering_ = ConnectedComponents()
+        elif local_clustering == "PC":
+            self.local_clustering_ = sn.clustering.PropagationClustering()
+        elif issubclass(type(local_clustering), sn.clustering.BaseClustering):
+            self.local_clustering_ = local_clustering
+        else:
+            raise ValueError(
+                f"local_clustering should be either 'CC' or 'PC', or a subclass of sknetwork.clustering.BaseClustering. Got {type(local_clustering)}"
+            )
+
+        if global_clustering == "Leiden":
+            self.global_clustering_ = sn.clustering.Leiden(random_state=random_state)
+        elif global_clustering == "Louvain":
+            self.global_clustering_ = sn.clustering.Louvain(random_state=random_state)
+        elif global_clustering == "PC":
+            self.global_clustering_ = sn.clustering.PropagationClustering()
+        elif issubclass(type(global_clustering), sn.clustering.BaseClustering):
+            self.global_clustering_ = global_clustering
+        else:
+            raise ValueError(
+                f"global_clustering should be in ['Louvain', 'Leiden', 'PC'] or a subclass of sknetwork.clustering.BaseClustering. Got {type(global_clustering)}"
+            )
+
+        self.min_cluster_size = min_cluster_size
+        if not isinstance(self.min_cluster_size, int):
+            if self.max_rounds % 1 != 0:
+                raise ValueError("min_cluster_size must be a whole number")
+            try:
+                # convert other types of int to python int
+                self.min_cluster_size = int(self.min_cluster_size)
+            except ValueError:
+                raise ValueError("min_cluster_size must be an int")
+        if self.min_cluster_size < 0:
+            raise ValueError("min_cluster_size must be non-negative")
+        self.verbose = verbose
+
+    def fit(self, g):
+        egonet_indices = []  # Store the original indices of the egonet
+        egonet_community = []  # Store the community labels of the ego nets
+        self.first_personae_index_ = np.empty(
+            g.shape[0] + 1, dtype="int32"
+        )  # Store the first index for a nodes new personae.
+        # The new personae of node i will be stored in rows
+        # first_personae_index[i], first_personae_index[i]+1, ... , first_personae_index[i+1]-1.
+        next_index = 0
+        neighbor_sets = _make_neighbor_sets(g.indptr, g.indices)
+        print("Making Egonets") if self.verbose else None
+        for node in tqdm(range(g.shape[0]), disable=not self.verbose):
+            neighbors = g.indices[g.indptr[node] : g.indptr[node + 1]]
+            egonet_indices.append(neighbors)
+            indptr, indices, data = _make_egonet(
+                node, neighbor_sets, g.indptr, g.indices, g.data
+            )
+            egonet = sp.csr_matrix(
+                (data, indices, indptr), shape=(len(neighbors), len(neighbors))
+            )
+            if (
+                len(egonet.data) == 0
+            ):  # egonet has no edges, each node is its own cluster
+                persona_map = sp.csgraph.connected_components(egonet)[1]
+            else:
+                persona_map = self.local_clustering_.fit_predict(egonet).astype("int32")
+            egonet_community.append(persona_map)
+            self.first_personae_index_[node] = next_index
+            next_index += np.max(persona_map) + 1
+
+        self.first_personae_index_[-1] = next_index
+        ei = List(egonet_indices)
+        ec = List(egonet_community)
+        print("Making Persona Graph") if self.verbose else None
+        persona_graph_data = make_persona_graph(
+            g.indptr, g.indices, g.data, ei, ec, self.first_personae_index_
+        )
+        self.persona_graph_ = sp.csr_matrix(
+            persona_graph_data,
+            shape=(self.first_personae_index_[-1], self.first_personae_index_[-1]),
+        )
+        print("Clustering Persona Graph") if self.verbose else None
+        self.persona_clusters_ = self.global_clustering_.fit_predict(
+            self.persona_graph_
+        )
+        print("Mapping Clusters") if self.verbose else None
+        n_clusters = np.max(self.persona_clusters_) + 1
+        clusters = sp.lil_matrix((g.shape[0], n_clusters), dtype="bool")
+        for node in tqdm(range(g.shape[0]), disable=not self.verbose):
+            node_clusters = np.unique(
+                self.persona_clusters_[
+                    self.first_personae_index_[node] : self.first_personae_index_[
+                        node + 1
+                    ]
+                ]
+            )
+            clusters[node, node_clusters] = True
+        clusters = clusters.tocsc().transpose()
+        if self.min_cluster_size > 0:
+            clusters = clusters[clusters.getnnz(1) >= self.min_cluster_size]
+
+        self.labels_ = clusters
+        return self
+
+    def fit_predict(self, g):
+        self.fit(g)
+        return self.labels_

egosplit_sknetwork-0.0.4/egosplit_sknetwork.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: egosplit_sknetwork
+Version: 0.0.4
+Summary: Fast python implementation of the egosplitting framework for overlapping clustering using sknetwork.
+Author-email: Ryan DeWolfe <ryandewolfe33@gmail.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: scikit-network>=0.33
+Requires-Dist: numba>=0.60.0
+Dynamic: license-file
+
+# EgoSplit-sknetwork
+
+This package provides a fast and flexible implementation of the egosplitting community detection paradigm for detecting overlapping communities.
+For details and motivation of the algorithm, please see the paper below.
+The reference implementation is available [here](https://github.com/google-research/google-research/blob/master/graph_embedding/persona/persona.py).
+
+
+> Alessandro Epasto, Silvio Lattanzi, and Renato Paes Leme. 2017. Ego-Splitting Framework: from Non-Overlapping to Overlapping Clusters. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD '17). Association for Computing Machinery, New York, NY, USA, 145-154. https://doi.org/10.1145/3097983.3098054
+
+# Installation
+
+Currently you can install this package by cloning this repository and installing locally.
+```sh
+git clone https://github.com/ryandewolfe33/egosplit-sknetwork.git
+cd egosplit-sknetwork
+pip install .
+```
+
+
+# Example
+
+```python
+import sknetwork as sn
+from egosplit_sknetwork import EgoSplit
+
+g = sn.data.toy_graphs.karate_club()
+egosplit = EgoSplit()
+labels = egosplit.fit_predict(g)
+```
+
+By default the algorithm uses [Propagation Clustering](https://scikit-network.readthedocs.io/en/latest/reference/clustering.html#sknetwork.clustering.PropagationClustering) for local clustering and [Leiden](https://scikit-network.readthedocs.io/en/latest/reference/clustering.html#sknetwork.clustering.Leiden) for global clustering.
+To pass other clustering algorithms to egosplit, they must be initialized in advace and passed as parameters.
+The algorithm accepts any subclass of [sknetwork.clustering.BaseClustering](https://scikit-network.readthedocs.io/en/latest/reference/clustering.html) for either local_clustering (used to cluster the egonets) or global_clustering (used to cluster the persona graph).
+
+```python
+high_res_clusterer = sn.clustering.Louvain(resolution=5, random_state=42)
+egosplit = EgoSplit(local_clustering='PC', global_clustering=high_res_clusterer)
+egosplit.fit(g)
+labels = egosplit.labels_
+```
+
+Labels is a sparse matrix with dimensions (n_labels, n_vertices), where `labels[i,j] = True` if vertex j is in cluster i.

egosplit_sknetwork-0.0.4/egosplit_sknetwork.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+egosplit_sknetwork/__init__.py
+egosplit_sknetwork/egosplit_sknetwork_.py
+egosplit_sknetwork.egg-info/PKG-INFO
+egosplit_sknetwork.egg-info/SOURCES.txt
+egosplit_sknetwork.egg-info/dependency_links.txt
+egosplit_sknetwork.egg-info/requires.txt
+egosplit_sknetwork.egg-info/top_level.txt
+tests/test_egosplit_sknetwork.py

egosplit_sknetwork-0.0.4/egosplit_sknetwork.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

egosplit_sknetwork-0.0.4/egosplit_sknetwork.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=2.0
+scikit-network>=0.33
+numba>=0.60.0

egosplit_sknetwork-0.0.4/egosplit_sknetwork.egg-info/top_level.txt

@@ -0,0 +1 @@
+egosplit_sknetwork

egosplit_sknetwork-0.0.4/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "egosplit_sknetwork"
+version = "0.0.4"
+authors = [
+  { name="Ryan DeWolfe", email="ryandewolfe33@gmail.com" },
+]
+description = "Fast python implementation of the egosplitting framework for overlapping clustering using sknetwork."
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+readme = "README.md"
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+requires-python = ">=3.10"
+dependencies = [
+    "numpy >= 2.0",
+    "scikit-network >= 0.33",
+    "numba >= 0.60.0",
+]

egosplit_sknetwork-0.0.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

egosplit_sknetwork-0.0.4/tests/test_egosplit_sknetwork.py

@@ -0,0 +1,101 @@
+import numpy as np
+import scipy.sparse as sp
+import sknetwork as sn
+import pytest
+
+import egosplit_sknetwork as esn
+
+
+@pytest.fixture
+def karate():
+    return sn.data.toy_graphs.karate_club()
+
+
+def test_make_egonet():
+    g = sp.csr_matrix(
+        [
+            [0, 1, 1, 1, 0],
+            [1, 0, 1, 1, 1],
+            [1, 1, 0, 0, 0],
+            [0, 1, 0, 0, 1],
+            [0, 1, 0, 1, 0],
+        ]
+    )
+
+    true_egonet = sp.csr_matrix(
+        [
+            [0, 1, 1],
+            [1, 0, 0],
+            [1, 0, 0],
+        ]
+    )
+
+    neighbor_sets = esn.egosplit_sknetwork_._make_neighbor_sets(g.indptr, g.indices)
+    neighbors = neighbor_sets[0]
+    indptr, indices, data = esn.egosplit_sknetwork_._make_egonet(
+        0, neighbor_sets, g.indptr, g.indices, g.data
+    )
+    egonet = sp.csr_matrix(
+        (data, indices, indptr), shape=(len(neighbors), len(neighbors))
+    )
+
+    assert egonet.shape == true_egonet.shape
+    assert (egonet - true_egonet).nnz == 0
+
+
+def test_make_egonet_weighted():
+    g = sp.csr_matrix(
+        [
+            [0, 0.5, 0.5, 0.5, 0],
+            [0.5, 0, 0.5, 0.5, 0.5],
+            [0.5, 0.5, 0, 0, 0],
+            [0, 0.5, 0, 0, 0.5],
+            [0, 0.5, 0, 0.5, 0],
+        ]
+    )
+
+    true_egonet = sp.csr_matrix(
+        [
+            [0, 0.5, 0.5],
+            [0.5, 0, 0],
+            [0.5, 0, 0],
+        ]
+    )
+
+    neighbor_sets = esn.egosplit_sknetwork_._make_neighbor_sets(g.indptr, g.indices)
+    neighbors = neighbor_sets[0]
+    indptr, indices, data = esn.egosplit_sknetwork_._make_egonet(
+        0, neighbor_sets, g.indptr, g.indices, g.data
+    )
+    egonet = sp.csr_matrix(
+        (data, indices, indptr), shape=(len(neighbors), len(neighbors))
+    )
+
+    assert egonet.shape == true_egonet.shape
+    assert (egonet - true_egonet).nnz == 0
+
+
+@pytest.mark.parametrize(
+    "local_alg", ["CC", "PC", sn.clustering.Louvain(random_state=42)]
+)
+@pytest.mark.parametrize(
+    "global_alg", ["Louvain", "Leiden", "PC", sn.clustering.KCenters(3)]
+)
+def test_egosplit(karate, local_alg, global_alg):
+    egosplit = esn.EgoSplit(
+        local_clustering=local_alg, global_clustering=global_alg, random_state=42
+    )
+    labels = egosplit.fit_predict(karate)
+    assert isinstance(labels, sp.csr_matrix)
+    assert labels.shape[1] == karate.shape[0]
+    assert labels.shape[0] > 0
+
+
+def test_egosplit_weighted(karate):
+    rng = np.random.default_rng(seed=42)
+    karate.data = rng.random(len(karate.data)) + 0.1  # so no 0
+    egosplit = esn.EgoSplit()
+    labels = egosplit.fit_predict(karate)
+    assert isinstance(labels, sp.csr_matrix)
+    assert labels.shape[1] == karate.shape[0]
+    assert labels.shape[0] > 0