Merge pull request #99 from anty-filidor/develop

Develop

Author: anty-filidor

network_diffusion/mln/centralities.py

@@ -11,6 +11,7 @@
 from typing import Any, Callable
 
 import networkx as nx
+import torch
 
 from network_diffusion.mln.actor import MLNetworkActor
 from network_diffusion.mln.functions import all_neighbours
@@ -310,3 +311,128 @@ def voterank_actorwise(
             vote_rank[nbr][1] = max(vote_rank[nbr][1], 0)
 
     return influential_actors
+
+
+def _build_edge_tensors(
+    net: MultilayerNetwork,
+    actor_to_idx: dict[MLNetworkActor, int],
+    device: torch.device,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """
+    Build undirected edge index tensors from a multilayer network.
+
+    Each edge (a, b) is represented twice — as (a→b) and (b→a) — so that
+    scatter-based aggregation covers both directions without special-casing.
+
+    :param net: multilayer network to extract edges from.
+    :param actor_to_idx: mapping from actor to its integer index.
+    :param device: torch device to place the resulting tensors on.
+    :return: tuple (edge_src, edge_dst), each a 1-D long tensor of length 2E,
+        where E is the number of undirected edges in the network.
+    """
+    links = list(net.get_links())
+
+    if not links:
+        empty = torch.empty(0, dtype=torch.long, device=device)
+        return empty, empty
+
+    src = torch.tensor([actor_to_idx[a] for a, _ in links], dtype=torch.long)
+    dst = torch.tensor([actor_to_idx[b] for _, b in links], dtype=torch.long)
+
+    edge_src = torch.cat([src, dst]).to(device)
+    edge_dst = torch.cat([dst, src]).to(device)
+
+    return edge_src, edge_dst
+
+
+def _get_device(device: str | None) -> torch.device:
+    """
+    Resolve device string to torch.device, auto-detecting if not provided.
+
+    :param device: device string (e.g. ``"cuda"``, ``"mps"``, ``"cpu"``,
+        ``"cuda:1"``), or ``None`` for auto-detection.
+    :return: resolved :class:`torch.device` instance.
+    """
+    if device:
+        return torch.device(device)
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    if torch.backends.mps.is_available():
+        return torch.device("mps")
+    return torch.device("cpu")
+
+
+def torch_voterank_actorwise(
+    net: MultilayerNetwork,
+    number_of_actors: int | None = None,
+    device: str | None = None,
+) -> list[MLNetworkActor]:
+    """
+    Select a list of influential ACTORS in a graph using VoteRank algorithm.
+
+    VoteRank computes a ranking of the actors in a graph based on a voting
+    scheme. With VoteRank, all actors vote for each of its neighbours and the
+    actor with the highest votes is elected iteratively. The voting ability of
+    neighbors of elected actors is decreased in subsequent turns.
+
+    Optimized with PyTorch tensors — supports CUDA, MPS (float32), and CPU.
+
+    :param net: multilayer network.
+    :param number_of_actors: number of ranked actors to extract (default all).
+    :param device: torch device string e.g. "cuda", "mps", "cpu".
+        Auto-detected if not provided (CUDA > MPS > CPU).
+    :return: ordered list of computed seeds, only actors with positive number
+        of votes are returned.
+    """
+    if net.is_directed():
+        raise NotImplementedError(
+            "Voterank for directed networks is not implemented!"
+        )
+    if len(net) == 0:
+        return []
+
+    # Step 1 actors — snapshot once, single source of truth for ordering
+    actors: list[MLNetworkActor] = list(net.get_actors())
+    n = len(actors)
+    actor_to_idx = {a: i for i, a in enumerate(actors)}
+    number_of_actors = min(number_of_actors or n, n)
+    # Step 2 Build edge tensors
+    edge_src, edge_dst = _build_edge_tensors(
+        net=net,
+        actor_to_idx=actor_to_idx,
+        device=_get_device(device),
+    )
+
+    inv_avg_nbs = torch.tensor(
+        n / sum(neighbourhood_size(net=net).values()),
+        dtype=torch.float32,
+        device=edge_src.device,
+    )
+    # Step 3 VoteRank state
+    scores = torch.zeros(n, dtype=torch.float32, device=edge_src.device)
+    ability = torch.ones(n, dtype=torch.float32, device=edge_src.device)
+    elected = torch.zeros(n, dtype=torch.bool, device=edge_src.device)
+
+    influential_actors: list[MLNetworkActor] = []
+
+    for _ in range(number_of_actors):
+        scores.zero_()
+        scores.scatter_add_(0, edge_dst, ability[edge_src])
+        scores[elected] = 0.0
+
+        # Step 4 select top actor
+        top_idx = int(scores.argmax().item())
+        if scores[top_idx].item() == 0.0:
+            break
+
+        influential_actors.append(actors[top_idx])
+        elected[top_idx] = True
+        ability[top_idx] = 0.0
+
+        # Step 5 weaken neighbours of elected actor
+        neighbour_mask = edge_dst[edge_src == top_idx]
+        if neighbour_mask.numel() > 0:
+            ability[neighbour_mask] -= inv_avg_nbs
+            ability.clamp_(min=0.0)
+
+    return influential_actors

network_diffusion/mln/mlnetwork.py

@@ -193,6 +193,13 @@ def copy(self) -> "MultilayerNetwork":
         )
         return copied_instance
 
+    def save(self, path: str) -> None:
+        """Save the multilayer network as an mpx file."""
+        dummy_net = multinet.empty()
+        for l_name in self.layers:
+            multinet.add_nx_layer(dummy_net, self[l_name], l_name)
+        multinet.write(dummy_net, path, "multilayer")
+
     def subgraph(self, actors: list[MLNetworkActor]) -> "MultilayerNetwork":
         """
         Return a subgraph of the network.

network_diffusion/nets/mln_generator.py

@@ -45,7 +45,7 @@ def get_dependency(self) -> np.ndarray:
             and 1/nb_layers otherwise
         """
         dep = np.full(
-            fill_value=(1 / self.nb_layers),
+            fill_value=(1 / (self.nb_layers - 1)),
             shape=(self.nb_layers, self.nb_layers),
         )
         np.fill_diagonal(dep, 0)

network_diffusion/seeding/voterank_selector.py

@@ -13,7 +13,7 @@
 import networkx as nx
 
 from network_diffusion.mln.actor import MLNetworkActor
-from network_diffusion.mln.centralities import voterank_actorwise
+from network_diffusion.mln.centralities import torch_voterank_actorwise
 from network_diffusion.mln.mlnetwork import MultilayerNetwork
 from network_diffusion.seeding.base_selector import (
     BaseSeedSelector,
@@ -52,6 +52,11 @@ def actorwise(self, net: MultilayerNetwork) -> list[MLNetworkActor]:
 class VoteRankMLNSeedSelector(BaseSeedSelector):
     """Selector for MLTModel based on Vote Rank algorithm."""
 
+    def __init__(self, device: str | None = None, **kwargs: Any) -> None:
+        """Initialise the object."""
+        super().__init__(**kwargs)
+        self.device = device
+
     def _calculate_ranking_list(self, graph: nx.Graph) -> list[Any]:
         """Create nodewise ranking."""
         raise NotImplementedError(
@@ -67,7 +72,7 @@ def __str__(self) -> str:
 
     def actorwise(self, net: MultilayerNetwork) -> list[MLNetworkActor]:
         """Compute ranking for actors."""
-        elected_nodes = voterank_actorwise(net=net)
+        elected_nodes = torch_voterank_actorwise(net=net, device=self.device)
         unelected_nodes = set(net.get_actors()).difference(set(elected_nodes))
         elected_nodes.extend(unelected_nodes)
         return elected_nodes

network_diffusion/tests/mln/test_functions.py

@@ -9,6 +9,8 @@
     degree,
     multiplexing_coefficient,
     neighbourhood_size,
+    torch_voterank_actorwise,
+    voterank_actorwise,
 )
 from network_diffusion.mln.functions import remove_selfloop_edges
 from network_diffusion.nets import get_toy_network_piotr
@@ -75,6 +77,15 @@
     11: 3,
 }
 
+VOTERANK_NET_1_TOP_5 = [
+    "Medici",
+    "Peruzzi",
+    "Guadagni",
+    "Strozzi",
+    "Barbadori",
+]
+VOTERANK_NET_2_TOP_5 = [2, 6, 10, 9, 4]
+
 
 class TestFunctions(unittest.TestCase):
     """Test functions."""
@@ -138,6 +149,45 @@ def test_remove_selfloop_edges(self):
                 list(nx.selfloop_edges(self.network_1[l_name])), []
             )
 
+    def test_voterank_consistency(self):
+        """Test that voterank_actorwise and torch_voterank_actorwise produce identical results."""
+        for network in [self.network_1, self.network_2]:
+            # Test with all actors
+            result_cpu = voterank_actorwise(network)
+            result_torch = torch_voterank_actorwise(network)
+            self.assertEqual(
+                [a.actor_id for a in result_cpu],
+                [a.actor_id for a in result_torch],
+                "VoteRank results should be identical for all actors",
+            )
+            # Test with limited number of actors
+            num_actors = min(5, len(network))
+            result_cpu_limited = voterank_actorwise(
+                network, number_of_actors=num_actors
+            )
+            result_torch_limited = torch_voterank_actorwise(
+                network, number_of_actors=num_actors
+            )
+            self.assertEqual(
+                [a.actor_id for a in result_cpu_limited],
+                [a.actor_id for a in result_torch_limited],
+                f"VoteRank results should be identical for {num_actors} actors",
+            )
+
+    def test_voterank_actorwise(self):
+        """Ensure VoteRank returns expected hardcoded actor sequences."""
+        for network, expected in zip(
+            [self.network_1, self.network_2],
+            [VOTERANK_NET_1_TOP_5, VOTERANK_NET_2_TOP_5],
+        ):
+            result = voterank_actorwise(network)
+            actor_ids = [a.actor_id for a in result[:5]]
+            self.assertEqual(
+                actor_ids,
+                expected,
+                "VoteRank output should match the hardcoded sequence",
+            )
+
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)

network_diffusion/tests/mln/test_mlnetwork.py

@@ -1,5 +1,6 @@
 import copy
 import os
+import tempfile
 import unittest
 
 import networkx as nx
@@ -182,6 +183,66 @@ def test_to_multiplex(self):
             "business": {"Ridolfi", "Albizzi", "Acciaiuoli", "Strozzi"},
         }
 
+    def test_save_creates_file(self):
+        """Test that save() method creates a file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = os.path.join(tmpdir, "test_network.mpx")
+            self.florentine.save(file_path)
+            self.assertTrue(
+                os.path.exists(file_path),
+                "Save method should create an MPX file",
+            )
+
+    def test_save_and_load_roundtrip(self):
+        """Test save and load roundtrip preserves network structure."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = os.path.join(tmpdir, "test_network.mpx")
+
+            # Save the network
+            self.florentine.save(file_path)
+
+            # Load it back
+            loaded_network = MultilayerNetwork.from_mpx(file_path)
+
+            # Verify basic properties are preserved
+            self.assertEqual(
+                set(self.florentine.get_layer_names()),
+                set(loaded_network.get_layer_names()),
+                "Layer names should be preserved after save/load",
+            )
+            self.assertEqual(
+                self.florentine.get_actors_num(),
+                loaded_network.get_actors_num(),
+                "Number of actors should be preserved after save/load",
+            )
+
+    def test_save_preserves_edges(self):
+        """Test that save() preserves edge information for each layer."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = os.path.join(tmpdir, "test_network.mpx")
+
+            # Get original edge counts per layer
+            original_edge_counts = {
+                l_name: len(self.florentine[l_name].edges())
+                for l_name in self.florentine.get_layer_names()
+            }
+
+            # Save and load
+            self.florentine.save(file_path)
+            loaded_network = MultilayerNetwork.from_mpx(file_path)
+
+            # Verify edge counts match
+            loaded_edge_counts = {
+                l_name: len(loaded_network[l_name].edges())
+                for l_name in loaded_network.get_layer_names()
+            }
+
+            self.assertEqual(
+                original_edge_counts,
+                loaded_edge_counts,
+                "Edge counts should be preserved in each layer",
+            )
+
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "network_diffusion"
-version = "0.18.1"
+version = "0.19.0"
 requires-python = ">=3.12"
 authors = [
     {name = "Michał Czuba", email="michal.czuba@pwr.edu.pl"},