Merge branch 'alvarolmartinez-universalstrict'

Author: gbg141

configs/datasets/manual_hypergraph_dataset.yaml

@@ -0,0 +1,12 @@
+data_domain: hypergraph
+data_type: toy_dataset
+data_name: manual
+data_dir: datasets/${data_domain}/${data_type}
+
+# Dataset parameters
+num_features: 1
+num_classes: 2
+task: classification
+loss_type: cross_entropy
+monitor_metric: accuracy
+task_level: node

configs/models/combinatorial/hmc.yaml

@@ -2,4 +2,4 @@ in_channels: null # This will be set by the dataset
 hidden_channels: 32
 out_channels: null # This will be set by the dataset
 n_layers: 2
-negative_slope: 0.2
+negative_slope: 0.2

configs/transforms/liftings/hypergraph2combinatorial/universal_strict_lifting.yaml

@@ -0,0 +1,2 @@
+transform_type: "lifting"
+transform_name: "UniversalStrictLifting"

modules/data/load/loaders.py

@@ -21,6 +21,7 @@
     load_gudhi_dataset,
     load_hypergraph_pickle_dataset,
     load_manual_graph,
+    load_manual_hypergraph,
     load_manual_mol,
     load_manual_points,
     load_point_cloud,
@@ -245,6 +246,19 @@ def load(
         torch_geometric.data.Dataset
             torch_geometric.data.Dataset object containing the loaded data.
         """
+        # Manual hypergraph
+        if self.parameters.data_name in ["manual"]:
+            root_folder = rootutils.find_root()
+            root_data_dir = os.path.join(
+                root_folder, self.parameters["data_dir"]
+            )
+            self.data_dir = os.path.join(
+                root_data_dir, self.parameters["data_name"]
+            )
+
+            data = load_manual_hypergraph()
+            return CustomDataset([data], self.parameters.data_dir)
+
         return load_hypergraph_pickle_dataset(self.parameters)
 
 
@@ -303,38 +317,38 @@ def load(self) -> torch_geometric.data.Dataset:
             root_data_dir, self.parameters["data_name"]
         )
 
-        if self.parameters.data_name.startswith("gudhi_"):
+        if self.parameters["data_name"].startswith("gudhi_"):
             data = load_gudhi_dataset(
                 self.parameters,
                 feature_generator=self.feature_generator,
                 target_generator=self.target_generator,
             )
-        elif self.parameters.data_name == "random_points":
+        elif self.parameters["data_name"] == "random_points":
             data = load_random_points(
                 dim=self.parameters["dim"],
                 num_classes=self.parameters["num_classes"],
                 num_samples=self.parameters["num_samples"],
             )
-        elif self.parameters.data_name == "toy_point_cloud":
+        elif self.parameters["data_name"] == "toy_point_cloud":
             data = load_point_cloud(
                 num_classes=self.parameters["num_classes"],
                 num_samples=self.parameters["num_samples"],
             )
-        elif self.parameters.data_name == "manual_points":
+        elif self.parameters["data_name"] == "manual_points":
             data = load_manual_points()
         elif self.parameters.data_name == "stanford_bunny":
             self.data_dir = os.path.join(
                 root_folder, self.parameters["data_dir"]
             )
             data = load_pointcloud_dataset(self.parameters)
-        elif self.parameters.data_name == "shapes":
+        elif self.parameters["data_name"] == "shapes":
             data = load_random_shape_point_cloud(
                 num_points=self.parameters["num_points"],
                 num_classes=self.parameters["num_classes"],
             )
         else:
             raise NotImplementedError(
-                f"Dataset {self.parameters.data_name} not implemented"
+                f"Dataset {self.parameters["data_name"]} not implemented"
             )
 
         return CustomDataset([data], self.data_dir)

modules/data/utils/utils.py

@@ -119,6 +119,61 @@ def get_complex_connectivity(complex, max_rank, signed=False):
     return connectivity
 
 
+def get_combinatorial_complex_connectivity(complex, max_rank=None):
+    r"""Gets the connectivity matrices for the combinatorial complex.
+
+    Parameters
+    ----------
+    complex : topnetx.CombinatorialComplex
+        Combinatorial complex.
+    max_rank : int
+        Maximum rank of the complex.
+
+    Returns
+    -------
+    dict
+        Dictionary containing the connectivity matrices.
+    """
+    if max_rank is None:
+        max_rank = complex.dim
+    practical_shape = list(
+        np.pad(list(complex.shape), (0, max_rank + 1 - len(complex.shape)))
+    )
+
+    connectivity = {}
+
+    for rank_idx in range(max_rank + 1):
+        if rank_idx > 0:
+            try:
+                connectivity[f"incidence_{rank_idx}"] = from_sparse(
+                    complex.incidence_matrix(
+                        rank=rank_idx - 1, to_rank=rank_idx
+                    )
+                )
+            except ValueError:
+                connectivity[f"incidence_{rank_idx}"] = (
+                    generate_zero_sparse_connectivity(
+                        m=practical_shape[rank_idx],
+                        n=practical_shape[rank_idx],
+                    )
+                )
+
+        try:
+            connectivity[f"adjacency_{rank_idx}"] = from_sparse(
+                complex.adjacency_matrix(rank=rank_idx, via_rank=rank_idx + 1)
+            )
+        except ValueError:
+            connectivity[f"adjacency_{rank_idx}"] = (
+                generate_zero_sparse_connectivity(
+                    m=practical_shape[rank_idx], n=practical_shape[rank_idx]
+                )
+            )
+
+        connectivity["shape"] = practical_shape
+
+    return connectivity
+
+
 def generate_zero_sparse_connectivity(m, n):
     r"""Generates a zero sparse connectivity matrix.
 
@@ -285,17 +340,13 @@ def load_hypergraph_pickle_dataset(cfg):
 
     print(f"number of hyperedges: {len(hypergraph)}")
 
-    edge_idx = 0  # num_nodes
     node_list = []
     edge_list = []
-    for he in hypergraph:
-        cur_he = hypergraph[he]
-        cur_size = len(cur_he)
-
-        node_list += list(cur_he)
-        edge_list += [edge_idx] * cur_size
 
-        edge_idx += 1
+    for edge_idx, cur_he in enumerate(hypergraph.values()):
+        cur_size = len(cur_he)
+        node_list.extend(cur_he)
+        edge_list.extend([edge_idx] * cur_size)
 
     # check that every node is in some hyperedge
     if len(np.unique(node_list)) != num_nodes:
@@ -641,6 +692,55 @@ def load_manual_mol():
     )
 
 
+def load_manual_hypergraph():
+    """Create a manual hypergraph for testing purposes."""
+    # Define the vertices (just 8 vertices)
+    vertices = [i for i in range(8)]
+    y = [0, 1, 1, 1, 0, 0, 0, 0]
+    # Define the hyperedges
+    hyperedges = [
+        [0, 1, 2, 3],
+        [4, 5, 6, 7],
+        [0, 1, 2],
+        [0, 1, 3],
+        [0, 2, 3],
+        [1, 2, 3],
+        [3, 4],
+        [4, 5],
+        [4, 7],
+        [5, 6],
+        [6, 7],
+    ]
+
+    # Generate feature from 0 to 7
+    x = torch.tensor([1, 5, 10, 50, 100, 500, 1000, 5000]).unsqueeze(1).float()
+    labels = torch.tensor(y, dtype=torch.long)
+
+    node_list = []
+    edge_list = []
+
+    for edge_idx, he in enumerate(hyperedges):
+        cur_size = len(he)
+        node_list += he
+        edge_list += [edge_idx] * cur_size
+
+    edge_index = np.array([node_list, edge_list], dtype=int)
+    edge_index = torch.LongTensor(edge_index)
+
+    incidence_hyperedges = torch.sparse_coo_tensor(
+        edge_index,
+        values=torch.ones(edge_index.shape[1]),
+        size=(len(vertices), len(hyperedges)),
+    )
+
+    return Data(
+        x=x,
+        edge_index=edge_index,
+        y=labels,
+        incidence_hyperedges=incidence_hyperedges,
+    )
+
+
 def get_Planetoid_pyg(cfg):
     r"""Loads Planetoid graph datasets from torch_geometric.
 

modules/models/combinatorial/hmc.py

@@ -33,7 +33,7 @@ def __init__(self, model_config, dataset_config):
             int_channels_l = []
             out_channels_l = []
 
-            for _ in range(3): # only 3 ranks
+            for _ in range(3):  # only 3 ranks
                 # First layer behavior
                 if layer == 0:
                     in_channels_l.append(in_channels)
@@ -42,11 +42,13 @@ def __init__(self, model_config, dataset_config):
                 int_channels_l.append(hidden_channels)
                 out_channels_l.append(hidden_channels)
 
-            channels_per_layer.append((in_channels_l, int_channels_l, out_channels_l))
+            channels_per_layer.append(
+                (in_channels_l, int_channels_l, out_channels_l)
+            )
 
         self.base_model = HMC(
             channels_per_layer=channels_per_layer,
-            negative_slope=negative_slope
+            negative_slope=negative_slope,
         )
         self.linear_0 = torch.nn.Linear(hidden_channels, out_channels)
         self.linear_1 = torch.nn.Linear(hidden_channels, out_channels)

modules/transforms/data_transform.py

@@ -44,6 +44,9 @@
 from modules.transforms.liftings.graph2simplicial.vietoris_rips_lifting import (
     SimplicialVietorisRipsLifting,
 )
+from modules.transforms.liftings.hypergraph2combinatorial.universal_strict_lifting import (
+    UniversalStrictLifting,
+)
 from modules.transforms.liftings.pointcloud2hypergraph.mogmst_lifting import (
     MoGMSTLifting,
 )
@@ -81,6 +84,8 @@
     # Pointcloud -> Hypergraph
     "VoronoiLifting": VoronoiLifting,
     "MoGMSTLifting": MoGMSTLifting,
+    # Hypergraph -> Combinatorial Complex
+    "UniversalStrictLifting": UniversalStrictLifting,
     # Feature Liftings
     "ProjectionSum": ProjectionSum,
     # Data Manipulations

modules/transforms/liftings/hypergraph2combinatorial/base.py

@@ -0,0 +1,52 @@
+import torch
+from toponetx import CombinatorialComplex
+
+from modules.data.utils.utils import get_combinatorial_complex_connectivity
+from modules.transforms.liftings.lifting import HypergraphLifting
+
+
+class Hypergraph2CombinatorialLifting(HypergraphLifting):
+    r"""Abstract class for lifting hypergraphs to combinatorial complexes.
+
+    Parameters
+    ----------
+    **kwargs : optional
+        Additional arguments for the class.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.type = "hypergraph2combinatorial"
+
+    def _get_lifted_topology(self, combinatorial_complex: CombinatorialComplex) -> dict:
+        r"""Returns the lifted topology.
+
+        Parameters
+        ----------
+        combinatorial_complex : CombinatorialComplex
+            The combinatorial complex.
+
+        Returns
+        -------
+        dict
+            The lifted topology.
+        """
+        lifted_topology = get_combinatorial_complex_connectivity(combinatorial_complex)
+
+        # Feature liftings
+
+        features = combinatorial_complex.get_cell_attributes("features")
+
+        for i in range(combinatorial_complex.dim + 1):
+            x = [
+                feat
+                for cell, feat in features
+                if combinatorial_complex.cells.get_rank(cell) == i
+            ]
+            if x:
+                lifted_topology[f"x_{i}"] = torch.stack(x)
+            else:
+                num_cells = len(combinatorial_complex.skeleton(i))
+                lifted_topology[f"x_{i}"] = torch.zeros(num_cells, 1)
+
+        return lifted_topology