diff --git a/configs/dataset/graph/US-county-demos.yaml b/configs/dataset/graph/US-county-demos.yaml index 6e21a4a9..87b12fea 100755 --- a/configs/dataset/graph/US-county-demos.yaml +++ b/configs/dataset/graph/US-county-demos.yaml @@ -30,6 +30,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 0 pin_memory: False diff --git a/configs/dataset/graph/amazon_ratings.yaml b/configs/dataset/graph/amazon_ratings.yaml index 3e5a9dae..149b20ea 100755 --- a/configs/dataset/graph/amazon_ratings.yaml +++ b/configs/dataset/graph/amazon_ratings.yaml @@ -27,6 +27,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 0 pin_memory: False diff --git a/configs/dataset/graph/cocitation_citeseer.yaml b/configs/dataset/graph/cocitation_citeseer.yaml index cfb1b6fe..b92f31a9 100755 --- a/configs/dataset/graph/cocitation_citeseer.yaml +++ b/configs/dataset/graph/cocitation_citeseer.yaml @@ -28,6 +28,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 1 pin_memory: False diff --git a/configs/dataset/graph/cocitation_cora.yaml b/configs/dataset/graph/cocitation_cora.yaml index d2b9fa3b..64de64e3 100755 --- a/configs/dataset/graph/cocitation_cora.yaml +++ b/configs/dataset/graph/cocitation_cora.yaml @@ -27,6 +27,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 1 pin_memory: False diff --git a/configs/dataset/graph/cocitation_pubmed.yaml b/configs/dataset/graph/cocitation_pubmed.yaml index 7d901437..c974b6b1 100755 --- a/configs/dataset/graph/cocitation_pubmed.yaml +++ b/configs/dataset/graph/cocitation_pubmed.yaml @@ -27,6 +27,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 1 pin_memory: False diff --git a/configs/dataset/graph/manual_dataset.yaml b/configs/dataset/graph/manual_dataset.yaml index e0357d2b..bafe272a 100755 --- a/configs/dataset/graph/manual_dataset.yaml +++ b/configs/dataset/graph/manual_dataset.yaml @@ -28,6 +28,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 + batch_size: -1 num_workers: 1 pin_memory: False diff --git a/configs/dataset/graph/minesweeper.yaml b/configs/dataset/graph/minesweeper.yaml index 19119e78..c487de79 100755 --- a/configs/dataset/graph/minesweeper.yaml +++ b/configs/dataset/graph/minesweeper.yaml @@ -28,6 +28,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 0 pin_memory: False diff --git a/configs/dataset/graph/questions.yaml b/configs/dataset/graph/questions.yaml index 25333b75..a10d0f9a 100755 --- a/configs/dataset/graph/questions.yaml +++ b/configs/dataset/graph/questions.yaml @@ -27,6 +27,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 1 pin_memory: False diff --git a/configs/dataset/graph/roman_empire.yaml b/configs/dataset/graph/roman_empire.yaml index 37adfb4b..e40d0e7b 100755 --- a/configs/dataset/graph/roman_empire.yaml +++ b/configs/dataset/graph/roman_empire.yaml @@ -27,6 +27,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 0 pin_memory: False diff --git a/configs/dataset/graph/tolokers.yaml b/configs/dataset/graph/tolokers.yaml index f1657f16..2da6e9af 100755 --- a/configs/dataset/graph/tolokers.yaml +++ b/configs/dataset/graph/tolokers.yaml @@ -27,6 +27,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 1 pin_memory: False diff --git a/configs/dataset/hypergraph/coauthorship_cora.yaml b/configs/dataset/hypergraph/coauthorship_cora.yaml index 80699bbd..2bc0ea7c 100755 --- a/configs/dataset/hypergraph/coauthorship_cora.yaml +++ b/configs/dataset/hypergraph/coauthorship_cora.yaml @@ -27,6 +27,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 1 pin_memory: False diff --git a/configs/dataset/hypergraph/coauthorship_dblp.yaml b/configs/dataset/hypergraph/coauthorship_dblp.yaml index 5f4c4e25..0e378a9b 100755 --- a/configs/dataset/hypergraph/coauthorship_dblp.yaml +++ b/configs/dataset/hypergraph/coauthorship_dblp.yaml @@ -27,6 +27,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 1 pin_memory: False diff --git a/configs/dataset/hypergraph/cocitation_citeseer.yaml b/configs/dataset/hypergraph/cocitation_citeseer.yaml index d51b884f..7823c357 100755 --- a/configs/dataset/hypergraph/cocitation_citeseer.yaml +++ b/configs/dataset/hypergraph/cocitation_citeseer.yaml @@ -27,6 +27,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 1 pin_memory: False diff --git a/configs/dataset/hypergraph/cocitation_cora.yaml b/configs/dataset/hypergraph/cocitation_cora.yaml index 557b0a14..cbe8c613 100755 --- a/configs/dataset/hypergraph/cocitation_cora.yaml +++ b/configs/dataset/hypergraph/cocitation_cora.yaml @@ -27,6 +27,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 1 pin_memory: False diff --git a/configs/dataset/hypergraph/cocitation_pubmed.yaml b/configs/dataset/hypergraph/cocitation_pubmed.yaml index 8aa19826..6fb00abf 100755 --- a/configs/dataset/hypergraph/cocitation_pubmed.yaml +++ b/configs/dataset/hypergraph/cocitation_pubmed.yaml @@ -27,6 +27,6 @@ split_params: # Dataloader parameters dataloader_params: - batch_size: 1 # Fixed + batch_size: -1 # Fixed num_workers: 1 pin_memory: False diff --git a/test/data/batching/test_neighbor_cells_loader.py b/test/data/batching/test_neighbor_cells_loader.py new file mode 100644 index 00000000..5153183b --- /dev/null +++ b/test/data/batching/test_neighbor_cells_loader.py @@ -0,0 +1,132 @@ +""" Test for the NeighborCellsLoader class.""" +import os +import shutil +import rootutils +from hydra import compose +import torch + +from topobenchmark.data.preprocessor import PreProcessor +from topobenchmark.data.utils.utils import load_manual_graph +from topobenchmark.data.batching import NeighborCellsLoader +from topobenchmark.run import initialize_hydra + +initialize_hydra() + +path = "./graph2simplicial_lifting/" +if os.path.isdir(path): + shutil.rmtree(path) +cfg = compose(config_name="run.yaml", + overrides=["dataset=graph/manual_dataset", "model=simplicial/san"], + return_hydra_config=True) + +data = load_manual_graph() +preprocessed_dataset = PreProcessor(data, path, cfg['transforms']) +data = preprocessed_dataset[0] + +batch_size=2 + +rank = 0 +n_cells = data[f'x_{rank}'].shape[0] +train_prop = 0.5 +n_train = int(train_prop * n_cells) +train_mask = torch.zeros(n_cells, dtype=torch.bool) +train_mask[:n_train] = 1 + +y = torch.zeros(n_cells, dtype=torch.long) +data.y = y + +loader = NeighborCellsLoader(data, + rank=rank, + num_neighbors=[-1], + input_nodes=train_mask, + batch_size=batch_size, + shuffle=False) +train_nodes = [] +for batch in loader: + train_nodes += [n for n in batch.n_id[:batch_size]] +for i in range(n_train): + assert i in train_nodes + +rank = 1 +n_cells = data[f'x_{rank}'].shape[0] +train_prop = 0.5 +n_train = int(train_prop * n_cells) +train_mask = torch.zeros(n_cells, dtype=torch.bool) +train_mask[:n_train] = 1 + +y = torch.zeros(n_cells, dtype=torch.long) +data.y = y + +loader = NeighborCellsLoader(data, + rank=rank, + num_neighbors=[-1,-1], + input_nodes=train_mask, + batch_size=batch_size, + shuffle=False) + +train_nodes = [] +for batch in loader: + train_nodes += [n for n in batch.n_id[:batch_size]] +for i in range(n_train): + assert i in train_nodes +shutil.rmtree(path) + + +path = "./graph2hypergraph_lifting/" +if os.path.isdir(path): + shutil.rmtree(path) +cfg = compose(config_name="run.yaml", + overrides=["dataset=graph/manual_dataset", "model=hypergraph/allsettransformer"], + return_hydra_config=True) + +data = load_manual_graph() +preprocessed_dataset = PreProcessor(data, path, cfg['transforms']) +data = preprocessed_dataset[0] + +batch_size=2 + +rank = 0 +n_cells = data[f'x_0'].shape[0] +train_prop = 0.5 +n_train = int(train_prop * n_cells) +train_mask = torch.zeros(n_cells, dtype=torch.bool) +train_mask[:n_train] = 1 + +y = torch.zeros(n_cells, dtype=torch.long) +data.y = y + +loader = NeighborCellsLoader(data, + rank=rank, + num_neighbors=[-1], + input_nodes=train_mask, + batch_size=batch_size, + shuffle=False) +train_nodes = [] +for batch in loader: + train_nodes += [n for n in batch.n_id[:batch_size]] +for i in range(n_train): + assert i in train_nodes + +rank = 1 +n_cells = data[f'x_hyperedges'].shape[0] +train_prop = 0.5 +n_train = int(train_prop * n_cells) +train_mask = torch.zeros(n_cells, dtype=torch.bool) +train_mask[:n_train] = 1 + +y = torch.zeros(n_cells, dtype=torch.long) +data.y = y + +loader = NeighborCellsLoader(data, + rank=rank, + num_neighbors=[-1,-1], + input_nodes=train_mask, + batch_size=batch_size, + shuffle=False) + +train_nodes = [] +for batch in loader: + train_nodes += [n for n in batch.n_id[:batch_size]] +for i in range(n_train): + assert i in train_nodes +shutil.rmtree(path) \ No newline at end of file diff --git a/test/data/dataload/test_Dataloaders.py b/test/data/dataload/test_Dataloaders.py index 35770d68..26b7de36 100644 --- a/test/data/dataload/test_Dataloaders.py +++ b/test/data/dataload/test_Dataloaders.py @@ -20,10 +20,6 @@ class TestCollateFunction: def setup_method(self): """Setup the test.""" - - hydra.initialize( - version_base="1.3", config_path="../../../configs", job_name="run" - ) cfg = hydra.compose(config_name="run.yaml", overrides=["dataset=graph/NCI1"]) graph_loader = hydra.utils.instantiate(cfg.dataset.loader, _recursive_=False) diff --git a/topobenchmark/data/batching/__init__.py b/topobenchmark/data/batching/__init__.py new file mode 100644 index 00000000..71952e48 --- /dev/null +++ b/topobenchmark/data/batching/__init__.py @@ -0,0 +1,7 @@ +"""Init file for batching module.""" + +from .neighbor_cells_loader import NeighborCellsLoader + +__all__ = [ + "NeighborCellsLoader", +] diff --git a/topobenchmark/data/batching/cell_loader.py b/topobenchmark/data/batching/cell_loader.py new file mode 100644 index 00000000..21593ec6 --- /dev/null +++ b/topobenchmark/data/batching/cell_loader.py @@ -0,0 +1,241 @@ +"""Cell Loader module from PyTorch Geometric with custom filter_data function.""" + +from collections.abc import Callable, Iterator +from typing import Any + +import torch +from torch import Tensor +from torch_geometric.data import Data, FeatureStore, GraphStore, HeteroData +from torch_geometric.loader.base import DataLoaderIterator +from torch_geometric.loader.mixin import ( + AffinityMixin, + LogMemoryMixin, + MultithreadingMixin, +) +from torch_geometric.loader.utils import ( + get_input_nodes, + infer_filter_per_worker, +) +from torch_geometric.sampler import ( + BaseSampler, + HeteroSamplerOutput, + NodeSamplerInput, + SamplerOutput, +) +from torch_geometric.typing import InputNodes, OptTensor + +from topobenchmark.data.batching.utils import filter_data + + +class CellLoader( + torch.utils.data.DataLoader, + AffinityMixin, + MultithreadingMixin, + LogMemoryMixin, +): + r"""A data loader that performs mini-batch sampling from cell information. + + It uses a generic :class:`~torch_geometric.sampler.BaseSampler` + implementation that defines a + :meth:`~torch_geometric.sampler.BaseSampler.sample_from_nodes` function and + is supported on the provided input :obj:`data` object. + + Parameters + ---------- + data : Any + A :class:`~torch_geometric.data.Data`, + :class:`~torch_geometric.data.HeteroData`, or + (:class:`~torch_geometric.data.FeatureStore`, + :class:`~torch_geometric.data.GraphStore`) data object. + cell_sampler : torch_geometric.sampler.BaseSampler + The sampler implementation to be used with this loader. + Needs to implement + :meth:`~torch_geometric.sampler.BaseSampler.sample_from_cells`. + The sampler implementation must be compatible with the input + :obj:`data` object. + input_cells : torch.Tensor or str or Tuple[str, torch.Tensor] + The indices of seed cells to start sampling from. + Needs to be either given as a :obj:`torch.LongTensor` or + :obj:`torch.BoolTensor`. + If set to :obj:`None`, all cells will be considered. + In heterogeneous graphs, needs to be passed as a tuple that holds + the cell type and cell indices. (default: :obj:`None`). + input_time : torch.Tensor, optional + Optional values to override the timestamp for the input cells given in + :obj:`input_cells`. If not set, will use the timestamps in + :obj:`time_attr` as default (if present). The :obj:`time_attr` needs + to be set for this to work. (default: :obj:`None`). + transform : callable, optional + A function/transform that takes in a sampled mini-batch and returns a + transformed version. (default: :obj:`None`). + transform_sampler_output : callable, optional + A function/transform that takes in a + :class:`torch_geometric.sampler.SamplerOutput` and returns a + transformed version. (default: :obj:`None`). + filter_per_worker : bool, optional + If set to :obj:`True`, will filter the returned data in each worker's + subprocess. + If set to :obj:`False`, will filter the returned data in the main + process. + If set to :obj:`None`, will automatically infer the decision based + on whether data partially lives on the GPU + (:obj:`filter_per_worker=True`) or entirely on the CPU + (:obj:`filter_per_worker=False`). + There exists different trade-offs for setting this option. + Specifically, setting this option to :obj:`True` for in-memory + datasets will move all features to shared memory, which may result + in too many open file handles. (default: :obj:`None`). + custom_cls : torch_geometric.data.HeteroData, optional + A custom :class:`~torch_geometric.data.HeteroData` class to return for + mini-batches in case of remote backends. (default: :obj:`None`). + input_id : torch.Tensor, optional + The indices of the input cells in the original data object. + (default: :obj:`None`). + **kwargs : optional + Additional arguments of :class:`torch.utils.data.DataLoader`, such as + :obj:`batch_size`, :obj:`shuffle`, :obj:`drop_last` or + :obj:`num_workers`. + """ + + def __init__( + self, + data: Data | HeteroData | tuple[FeatureStore, GraphStore], + cell_sampler: BaseSampler, + input_cells: InputNodes = None, + input_time: OptTensor = None, + transform: Callable | None = None, + transform_sampler_output: Callable | None = None, + filter_per_worker: bool | None = None, + custom_cls: HeteroData | None = None, + input_id: OptTensor = None, + **kwargs, + ): + if filter_per_worker is None: + filter_per_worker = infer_filter_per_worker(data) + + self.data = data + self.cell_sampler = cell_sampler + self.input_cells = input_cells + self.input_time = input_time + self.transform = transform + self.transform_sampler_output = transform_sampler_output + self.filter_per_worker = filter_per_worker + self.custom_cls = custom_cls + self.input_id = input_id + + kwargs.pop("dataset", None) + kwargs.pop("collate_fn", None) + + # Get cell type (or `None` for homogeneous graphs): + input_type, input_cells, input_id = get_input_nodes( + data, input_cells, input_id + ) + + self.input_data = NodeSamplerInput( + input_id=input_id, + node=input_cells, + time=input_time, + input_type=input_type, + ) + + iterator = range(input_cells.size(0)) + super().__init__(iterator, collate_fn=self.collate_fn, **kwargs) + + def __call__( + self, + index: Tensor | list[int], + ) -> Data | HeteroData: + r"""Sample a subgraph from a batch of input cells. + + Parameters + ---------- + index : torch.Tensor or List[int] + The indices of cells to sample. + + Returns + ------- + Union[Data, HeteroData] + The sampled subgraph. + """ + out = self.collate_fn(index) + if not self.filter_per_worker: + out = self.filter_fn(out) + return out + + def collate_fn(self, index: Tensor | list[int]) -> Any: + r"""Sample a subgraph from a batch of input cells. + + Parameters + ---------- + index : torch.Tensor or List[int] + The indices of cells to sample. + + Returns + ------- + Any + The sampled subgraph. + """ + input_data: NodeSamplerInput = self.input_data[index] + + out = self.cell_sampler.sample_from_nodes(input_data) + + if self.filter_per_worker: # Execute `filter_fn` in the worker process + out = self.filter_fn(out) + + return out + + def filter_fn( + self, + out: SamplerOutput | HeteroSamplerOutput, + ) -> Data | HeteroData: + r"""Join the sampled cells with their corresponding features. + + It returns the resulting :class:`~torch_geometric.data.Data` + object to be used downstream. + + Parameters + ---------- + out : Union[SamplerOutput, HeteroSamplerOutput] + The output of the sampler. + + Returns + ------- + Union[Data, HeteroData] + The resulting data object. + """ + if self.transform_sampler_output: + out = self.transform_sampler_output(out) + + if isinstance(out, SamplerOutput) and isinstance(self.data, Data): + data = filter_data(self.data, out.node, self.rank) + else: + raise TypeError( + f"'{self.__class__.__name__}'' found invalid " + f"type: '{type(data)}'" + ) + + return data if self.transform is None else self.transform(data) + + def _get_iterator(self) -> Iterator: + r"""Return the internal iterator to be used for sampling. + + Returns + ------- + Iterator + The internal iterator to be used for sampling. + """ + if self.filter_per_worker: + return super()._get_iterator() + + # if not self.is_cuda_available and not self.cpu_affinity_enabled: + # TODO: Add manual page for best CPU practices + # link = ... + # Warning('Dataloader CPU affinity opt is not enabled, consider ' + # 'switching it on with enable_cpu_affinity() or see CPU ' + # f'best practices for PyG [{link}])') + + # Execute `filter_fn` in the main process: + return DataLoaderIterator(super()._get_iterator(), self.filter_fn) + + def __repr__(self) -> str: + return f"{self.__class__.__name__}()" diff --git a/topobenchmark/data/batching/neighbor_cells_loader.py b/topobenchmark/data/batching/neighbor_cells_loader.py new file mode 100644 index 00000000..be772ef9 --- /dev/null +++ b/topobenchmark/data/batching/neighbor_cells_loader.py @@ -0,0 +1,182 @@ +"""NeighborCellsLoader class to batch in the transductive setting when working with topological domains.""" + +from collections.abc import Callable + +from torch_geometric.data import Data, FeatureStore, GraphStore, HeteroData +from torch_geometric.sampler import NeighborSampler +from torch_geometric.sampler.base import SubgraphType +from torch_geometric.typing import EdgeType, InputNodes, OptTensor + +from topobenchmark.data.batching.cell_loader import CellLoader +from topobenchmark.data.batching.utils import get_sampled_neighborhood +from topobenchmark.dataloader import DataloadDataset + + +class NeighborCellsLoader(CellLoader): + r"""A data loader that samples neighbors for each cell. Cells are considered neighbors if they are upper or lower neighbors. + + Parameters + ---------- + data : Any + A :class:`~torch_geometric.data.Data`, + :class:`~torch_geometric.data.HeteroData`, or + (:class:`~torch_geometric.data.FeatureStore`, + :class:`~torch_geometric.data.GraphStore`) data object. + rank : int + The rank of the cells to consider. + num_neighbors : List[int] or Dict[Tuple[str, str, str], List[int]] + The number of neighbors to sample for each node in each iteration. + If an entry is set to :obj:`-1`, all neighbors will be included. + input_nodes : torch.Tensor or str or Tuple[str, torch.Tensor] + The indices of nodes for which neighbors are sampled to create + mini-batches. + Needs to be either given as a :obj:`torch.LongTensor` or + :obj:`torch.BoolTensor`. + If set to :obj:`None`, all nodes will be considered. + input_time : torch.Tensor, optional + Optional values to override the timestamp for the input nodes given in :obj:`input_nodes`. If not + set, will use the timestamps in :obj:`time_attr` as default (if + present). The :obj:`time_attr` needs to be set for this to work. + (default: :obj:`None`). + replace : bool, optional + If set to :obj:`True`, will sample with replacement. (default: :obj:`False`). + subgraph_type : SubgraphType or str, optional + The type of the returned subgraph. + If set to :obj:`"directional"`, the returned subgraph only holds + the sampled (directed) edges which are necessary to compute + representations for the sampled seed nodes. + If set to :obj:`"bidirectional"`, sampled edges are converted to + bidirectional edges. + If set to :obj:`"induced"`, the returned subgraph contains the + induced subgraph of all sampled nodes. + (default: :obj:`"directional"`). + disjoint : bool, optional + If set to :obj: `True`, each seed node will create its own disjoint subgraph. + If set to :obj:`True`, mini-batch outputs will have a :obj:`batch` + vector holding the mapping of nodes to their respective subgraph. + Will get automatically set to :obj:`True` in case of temporal + sampling. (default: :obj:`False`). + temporal_strategy : str, optional + The sampling strategy when using temporal sampling (:obj:`"uniform"`, :obj:`"last"`). + If set to :obj:`"uniform"`, will sample uniformly across neighbors + that fulfill temporal constraints. + If set to :obj:`"last"`, will sample the last `num_neighbors` that + fulfill temporal constraints. + (default: :obj:`"uniform"`). + time_attr : str, optional + The name of the attribute that denotes timestamps for either the nodes or edges in the graph. + If set, temporal sampling will be used such that neighbors are + guaranteed to fulfill temporal constraints, *i.e.* neighbors have + an earlier or equal timestamp than the center node. + (default: :obj:`None`). + weight_attr : str, optional + The name of the attribute that denotes edge weights in the graph. + If set, weighted/biased sampling will be used such that neighbors + are more likely to get sampled the higher their edge weights are. + Edge weights do not need to sum to one, but must be non-negative, + finite and have a non-zero sum within local neighborhoods. + (default: :obj:`None`). + transform : callable, optional + A function/transform that takes in a sampled mini-batch and returns a transformed version. + (default: :obj:`None`). + transform_sampler_output : callable, optional + A function/transform that takes in a :class:`torch_geometric.sampler.SamplerOutput` and + returns a transformed version. (default: :obj:`None`). + is_sorted : bool, optional + If set to :obj:`True`, assumes that :obj:`edge_index` is sorted by column. + If :obj:`time_attr` is set, additionally requires that rows are + sorted according to time within individual neighborhoods. + This avoids internal re-sorting of the data and can improve + runtime and memory efficiency. (default: :obj:`False`). + filter_per_worker : bool, optional + If set to :obj:`True`, will filter the returned data in each worker's subprocess. + If set to :obj:`False`, will filter the returned data in the main process. + If set to :obj:`None`, will automatically infer the decision based + on whether data partially lives on the GPU + (:obj:`filter_per_worker=True`) or entirely on the CPU + (:obj:`filter_per_worker=False`). + There exists different trade-offs for setting this option. + Specifically, setting this option to :obj:`True` for in-memory + datasets will move all features to shared memory, which may result + in too many open file handles. (default: :obj:`None`). + neighbor_sampler : NeighborSampler, optional + The neighbor sampler implementation to be used with this loader. + If not set, a new :class:`torch_geometric.sampler.NeighborSampler` + instance will be created. (default: :obj:`None`). + directed : bool, optional + If set to :obj:`True`, will consider the graph as directed. + If set to :obj:`False`, will consider the graph as undirected. + (default: :obj:`True`). + **kwargs : optional + Additional arguments of :class:`torch.utils.data.DataLoader`, such as + :obj:`batch_size`, :obj:`shuffle`, :obj:`drop_last` or :obj:`num_workers`. + """ + + def __init__( + self, + data: Data | HeteroData | tuple[FeatureStore, GraphStore], + rank: int, + num_neighbors: list[int] | dict[EdgeType, list[int]], + input_nodes: InputNodes = None, + input_time: OptTensor = None, + replace: bool = False, + subgraph_type: SubgraphType | str = "directional", + disjoint: bool = False, + temporal_strategy: str = "uniform", + time_attr: str | None = None, + weight_attr: str | None = None, + transform: Callable | None = None, + transform_sampler_output: Callable | None = None, + is_sorted: bool = False, + filter_per_worker: bool | None = None, + neighbor_sampler: NeighborSampler | None = None, + directed: bool = True, + **kwargs, + ): + if input_time is not None and time_attr is None: + raise ValueError( + "Received conflicting 'input_time' and " + "'time_attr' arguments: 'input_time' is set " + "while 'time_attr' is not set." + ) + + data_obj = Data() + if isinstance(data, DataloadDataset): + for tensor, name in zip(data[0][0], data[0][1], strict=False): + setattr(data_obj, name, tensor) + else: + data_obj = data + is_hypergraph = hasattr(data_obj, "incidence_hyperedges") + n_hops = len(num_neighbors) + data_obj = get_sampled_neighborhood( + data_obj, rank, n_hops, is_hypergraph + ) + self.rank = rank + if self.rank != 0: + # When rank is different than 0 get_sampled_neighborhood connects cells that are up to n_hops away, meaning that the NeighborhoodSampler needs to consider only one hop. + num_neighbors = [num_neighbors[0]] + if neighbor_sampler is None: + neighbor_sampler = NeighborSampler( + data_obj, + num_neighbors=num_neighbors, + replace=replace, + subgraph_type=subgraph_type, + disjoint=disjoint, + temporal_strategy=temporal_strategy, + time_attr=time_attr, + weight_attr=weight_attr, + is_sorted=is_sorted, + share_memory=kwargs.get("num_workers", 0) > 0, + directed=directed, + ) + + super().__init__( + data=data_obj, + cell_sampler=neighbor_sampler, + input_cells=input_nodes, + input_time=input_time, + transform=transform, + transform_sampler_output=transform_sampler_output, + filter_per_worker=filter_per_worker, + **kwargs, + ) diff --git a/topobenchmark/data/batching/utils.py b/topobenchmark/data/batching/utils.py new file mode 100644 index 00000000..78df4fe9 --- /dev/null +++ b/topobenchmark/data/batching/utils.py @@ -0,0 +1,331 @@ +"""Utility functions for batching cells of different ranks.""" + +import copy + +import torch +import torch_geometric.typing +from torch import Tensor +from torch_geometric.data import Data + + +def reduce_higher_ranks_incidences( + batch, cells_ids, rank, max_rank, is_hypergraph=False +): + """Reduce the incidences with higher rank than the specified one. + + Parameters + ---------- + batch : torch_geometric.data.Data + The input data. + cells_ids : list[torch.Tensor] + List of tensors containing the ids of the cells. The length of the list should be equal to the maximum rank. + rank : int + The rank to select the higher order incidences. + max_rank : int + The maximum rank of the incidences. + is_hypergraph : bool + Whether the data represents an hypergraph. + + Returns + ------- + torch_geometric.data.Data + The output data with the reduced incidences. + list[torch.Tensor] + The updated indices of the cells. Each element of the list is a tensor containing the ids of the cells of the corresponding rank. + """ + for i in range(rank + 1, max_rank + 1): + if is_hypergraph: + incidence = batch.incidence_hyperedges + else: + incidence = batch[f"incidence_{i}"] + + # if i != rank+1: + incidence = torch.index_select(incidence, 0, cells_ids[i - 1]) + cells_ids[i] = torch.where(torch.sum(incidence, dim=0).to_dense() > 1)[ + 0 + ] + incidence = torch.index_select(incidence, 1, cells_ids[i]) + if is_hypergraph: + batch.incidence_hyperedges = incidence + else: + batch[f"incidence_{i}"] = incidence + + return batch, cells_ids + + +def reduce_lower_ranks_incidences(batch, cells_ids, rank, is_hypergraph=False): + """Reduce the incidences with lower rank than the specified one. + + Parameters + ---------- + batch : torch_geometric.data.Data + The input data. + cells_ids : list[torch.Tensor] + List of tensors containing the ids of the cells. The length of the list should be equal to the maximum rank. + rank : int + The rank of the cells to consider. + is_hypergraph : bool + Whether the data represents an hypergraph. + + Returns + ------- + torch.Tensor + The indices of the nodes contained by the cells. + list[torch.Tensor] + The updated indices of the cells. Each element of the list is a tensor containing the ids of the cells of the corresponding rank. + """ + for i in range(rank, 0, -1): + if is_hypergraph: + incidence = batch.incidence_hyperedges + else: + incidence = batch[f"incidence_{i}"] + incidence = torch.index_select(incidence, 1, cells_ids[i]) + cells_ids[i - 1] = torch.where( + torch.sum(incidence, dim=1).to_dense() > 0 + )[0] + incidence = torch.index_select(incidence, 0, cells_ids[i - 1]) + if is_hypergraph: + batch.incidence_hyperedges = incidence + else: + batch[f"incidence_{i}"] = incidence + + if not is_hypergraph: + incidence = batch["incidence_0"] + incidence = torch.index_select(incidence, 1, cells_ids[0]) + batch["incidence_0"] = incidence + return batch, cells_ids + + +def reduce_matrices(batch, cells_ids, names, max_rank): + """Reduce the matrices using the indices in cells_ids. + + The matrices are assumed to be in the batch with the names specified in the list names. + + Parameters + ---------- + batch : torch_geometric.data.Data + The input data. + cells_ids : list[torch.Tensor] + List of tensors containing the ids of the cells. The length of the list should be equal to the maximum rank. + names : list[str] + List of names of the matrices in the batch. They should appear in the format f"{name}{i}" where i is the rank of the matrix. + max_rank : int + The maximum rank of the matrices. + + Returns + ------- + torch_geometric.data.Data + The output data with the reduced matrices. + """ + for i in range(max_rank + 1): + for name in names: + if f"{name}{i}" in batch.keys(): # noqa + matrix = batch[f"{name}{i}"] + matrix = torch.index_select(matrix, 0, cells_ids[i]) + matrix = torch.index_select(matrix, 1, cells_ids[i]) + batch[f"{name}{i}"] = matrix + return batch + + +def reduce_neighborhoods(batch, node, rank=0, remove_self_loops=True): + """Reduce the neighborhoods of the cells in the batch. + + Parameters + ---------- + batch : torch_geometric.data.Data + The input data. + node : torch.Tensor + The indices of the cells to batch over. + rank : int + The rank of the cells to batch over. + remove_self_loops : bool + Whether to remove self loops from the edge_index. + + Returns + ------- + torch_geometric.data.Data + The output data with the reduced neighborhoods. + """ + is_hypergraph = False + if hasattr(batch, "incidence_hyperedges"): + is_hypergraph = True + max_rank = 1 + else: + max_rank = len([key for key in batch.keys() if "incidence" in key]) - 1 # noqa + + if rank > max_rank: + raise ValueError( + f"Rank {rank} is greater than the maximum rank {max_rank} in the dataset." + ) + + cells_ids = [None for _ in range(max_rank + 1)] + + # the indices of the cells selected by the NeighborhoodLoader are saved in the batch in the attribute n_id + cells_ids[rank] = node + + batch, cells_ids = reduce_higher_ranks_incidences( + batch, cells_ids, rank, max_rank, is_hypergraph + ) + batch, cells_ids = reduce_lower_ranks_incidences( + batch, cells_ids, rank, is_hypergraph + ) + + batch = reduce_matrices( + batch, + cells_ids, + names=[ + "down_laplacian_", + "up_laplacian_", + "hodge_laplacian_", + "adjacency_", + ], + max_rank=max_rank, + ) + + # reduce the feature matrices + for i in range(max_rank + 1): + if f"x_{i}" in batch.keys(): # noqa + batch[f"x_{i}"] = batch[f"x_{i}"][cells_ids[i]] + + # fix edge_index + if not is_hypergraph: + adjacency_0 = batch.adjacency_0.coalesce() + edge_index = adjacency_0.indices() + if remove_self_loops: + edge_index = torch_geometric.utils.remove_self_loops(edge_index)[0] + batch.edge_index = edge_index + + # fix x + batch.x = batch["x_0"] + if hasattr(batch, "num_nodes"): + batch.num_nodes = batch.x.shape[0] + + if hasattr(batch, "y"): + batch.y = batch.y[cells_ids[rank]] + + batch.cells_ids = cells_ids + return batch + + +def filter_data(data: Data, cells: Tensor, rank: int) -> Data: + """Filter the attributes of the data based on the cells passed. + + The function uses the indices passed to select the cells of the specified rank. The cells of lower or higher ranks are selected using the incidence matrices. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data. + cells : Tensor + Tensor containing the indices of the cells of the specified rank to keep. + rank : int + Rank of the cells of interest. + + Returns + ------- + torch_geometric.data.Data + The output data with the filtered attributes. + """ + out = copy.copy(data) + out = reduce_neighborhoods(out, cells, rank=rank) + out.n_id = cells + return out + + +def get_sampled_neighborhood(data, rank=0, n_hops=1, is_hypergraph=False): + """Update the edge_index attribute of torch_geometric.data.Data. + + The function finds cells, of the specified rank, that are either upper or lower neighbors. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data. + rank : int + The rank of the cells that you want to batch over. + n_hops : int + Two cells are considered neighbors if they are connected by n hops in the upper or lower neighborhoods. + is_hypergraph : bool + Whether the data represents an hypergraph. + + Returns + ------- + torch_geometric.data.Data + The output data with updated edge_index. + edge_index contains indices of connected cells of the specified rank K. + Two cells of rank K are connected if they are either lower or upper neighbors. + """ + if rank == 0: + data.edge_index = torch_geometric.utils.to_undirected(data.edge_index) + return data + if is_hypergraph: + if rank > 1: + raise ValueError( + "Hypergraphs are not supported for ranks greater than 1." + ) + if rank == 1: + incidence = data.incidence_hyperedges + A = torch.sparse.mm(incidence, incidence.T) # lower adj matrix + else: + incidence = data.incidence_hyperedges + A = torch.sparse.mm(incidence.T, incidence) + for _ in range(n_hops - 1): + A = torch.sparse.mm(A, A) + edges = A.indices() + else: + # get number of incidences + max_rank = len([key for key in data.keys() if "incidence" in key]) - 1 # noqa + if rank > max_rank: + raise ValueError( + f"Rank {rank} is greater than the maximum rank {max_rank} in the data." + ) + + # This considers the upper adjacencies + n_cells = data[f"x_{rank}"].shape[0] + A_sum = torch.sparse_coo_tensor([[], []], [], (n_cells, n_cells)) + if rank == max_rank: + edges = torch.empty((2, 0), dtype=torch.long) + else: + incidence = data[f"incidence_{rank+1}"] + A = torch.sparse.mm(incidence, incidence.T) + for _ in range(n_hops - 1): + A = torch.sparse.mm(A, A) + A_sum += A + + # This is for selecting the whole upper cells + # for i in range(rank+1, max_rank): + # P = torch.sparse.mm(P, data[f"incidence_{i+1}"]) + # Q = torch.sparse.mm(P,P.T) + # edges = torch.cat((edges, Q.indices()), dim=1) + + # This considers the lower adjacencies + if rank != 0: + incidence = data[f"incidence_{rank}"] + A = torch.sparse.mm(incidence.T, incidence) + for _ in range(n_hops - 1): + A = torch.sparse.mm(A, A) + A_sum += A + + # This is for selecting cells if they share any node + # for i in range(rank-1, 0, -1): + # P = torch.sparse.mm(data[f"incidence_{i}"], P) + # Q = torch.sparse.mm(P.T,P) + # edges = torch.cat((edges, Q.indices()), dim=1) + + edges = A_sum.coalesce().indices() + # Remove self edges + mask = edges[0, :] != edges[1, :] + edges = edges[:, mask] + + data.edge_index = edges + + # We need to set x to x_{rank} since NeighborLoader will take the number of nodes from the x attribute + # The correct x is given after the reduce_neighborhoods function + if is_hypergraph and rank == 1: + data.x = data.x_hyperedges + else: + data.x = data[f"x_{rank}"] + + if hasattr(data, "num_nodes"): + data.num_nodes = data.x.shape[0] + return data diff --git a/topobenchmark/dataloader/dataloader.py b/topobenchmark/dataloader/dataloader.py index 30c42689..b3d50a86 100755 --- a/topobenchmark/dataloader/dataloader.py +++ b/topobenchmark/dataloader/dataloader.py @@ -5,6 +5,7 @@ from lightning import LightningDataModule from torch.utils.data import DataLoader +from topobenchmark.data.batching import NeighborCellsLoader from topobenchmark.dataloader.dataload_dataset import DataloadDataset from topobenchmark.dataloader.utils import collate_fn @@ -24,6 +25,10 @@ class TBDataloader(LightningDataModule): The test dataset (default: None). batch_size : int, optional The batch size for the dataloader (default: 1). + rank : int, optional + The rank of the cells to consider when batching in the transductive setting (default: 0). + num_neighbors : list[int], optional + The number of neighbors to sample in the transductive setting. To consider n-hop neighborhoods this list should contain n elements. Care should be taken to check that the number of hops is appropriate for your model. With topological models the number of layers might not be enough to determine how far information is propagated. (default: [-1]). num_workers : int, optional The number of worker processes to use for data loading (default: 0). pin_memory : bool, optional @@ -43,6 +48,8 @@ def __init__( dataset_val: DataloadDataset = None, dataset_test: DataloadDataset = None, batch_size: int = 1, + rank: int = 0, + num_neighbors: list[int] | None = None, num_workers: int = 0, pin_memory: bool = False, **kwargs: Any, @@ -57,24 +64,67 @@ def __init__( ) self.dataset_train = dataset_train self.batch_size = batch_size - + self.transductive = False + self.rank = rank + self.num_neighbors = ( + num_neighbors if num_neighbors is not None else [-1] + ) if dataset_val is None and dataset_test is None: # Transductive setting self.dataset_val = dataset_train self.dataset_test = dataset_train - assert ( - self.batch_size == 1 - ), "Batch size must be 1 for transductive setting." + self.transductive = True else: self.dataset_val = dataset_val self.dataset_test = dataset_test self.num_workers = num_workers self.pin_memory = pin_memory self.persistent_workers = kwargs.get("persistent_workers", False) + self.kwargs = kwargs def __repr__(self) -> str: return f"{self.__class__.__name__}(dataset_train={self.dataset_train}, dataset_val={self.dataset_val}, dataset_test={self.dataset_test}, batch_size={self.batch_size})" + def _get_dataloader(self, split: str) -> DataLoader | NeighborCellsLoader: + r"""Create and return the dataloader for the specified split. + + Parameters + ---------- + split : str + The split to create the dataloader for. + + Returns + ------- + torch.utils.data.DataLoader | NeighborCellsLoader + The dataloader for the specified split. + """ + shuffle = split == "train" + + if not self.transductive or self.batch_size == -1: + batch_size = self.batch_size if self.batch_size != -1 else 1 + + return DataLoader( + dataset=getattr(self, f"dataset_{split}"), + batch_size=batch_size, + num_workers=self.num_workers, + pin_memory=self.pin_memory, + shuffle=shuffle, + collate_fn=collate_fn, + persistent_workers=self.persistent_workers, + **self.kwargs, + ) + mask_idx = self.dataset_train[0][1].index(f"{split}_mask") + mask = self.dataset_train[0][0][mask_idx] + return NeighborCellsLoader( + data=getattr(self, f"dataset_{split}"), + rank=self.rank, + num_neighbors=self.num_neighbors, + input_nodes=mask, + batch_size=self.batch_size, + shuffle=shuffle, + **self.kwargs, + ) + def train_dataloader(self) -> DataLoader: r"""Create and return the train dataloader. @@ -83,15 +133,7 @@ def train_dataloader(self) -> DataLoader: torch.utils.data.DataLoader The train dataloader. """ - return DataLoader( - dataset=self.dataset_train, - batch_size=self.batch_size, - num_workers=self.num_workers, - pin_memory=self.pin_memory, - shuffle=True, - collate_fn=collate_fn, - persistent_workers=self.persistent_workers, - ) + return self._get_dataloader("train") def val_dataloader(self) -> DataLoader: r"""Create and return the validation dataloader. @@ -101,15 +143,7 @@ def val_dataloader(self) -> DataLoader: torch.utils.data.DataLoader The validation dataloader. """ - return DataLoader( - dataset=self.dataset_val, - batch_size=self.batch_size, - num_workers=self.num_workers, - pin_memory=self.pin_memory, - shuffle=False, - collate_fn=collate_fn, - persistent_workers=self.persistent_workers, - ) + return self._get_dataloader("val") def test_dataloader(self) -> DataLoader: r"""Create and return the test dataloader. @@ -121,15 +155,7 @@ def test_dataloader(self) -> DataLoader: """ if self.dataset_test is None: raise ValueError("There is no test dataloader.") - return DataLoader( - dataset=self.dataset_test, - batch_size=self.batch_size, - num_workers=self.num_workers, - pin_memory=self.pin_memory, - shuffle=False, - collate_fn=collate_fn, - persistent_workers=self.persistent_workers, - ) + return self._get_dataloader("test") def teardown(self, stage: str | None = None) -> None: r"""Lightning hook for cleaning up after `trainer.fit()`, `trainer.validate()`, `trainer.test()`, and `trainer.predict()`. diff --git a/topobenchmark/nn/readouts/propagate_signal_down.py b/topobenchmark/nn/readouts/propagate_signal_down.py index 1eafe325..d79dc466 100644 --- a/topobenchmark/nn/readouts/propagate_signal_down.py +++ b/topobenchmark/nn/readouts/propagate_signal_down.py @@ -26,23 +26,23 @@ def __init__(self, **kwargs): self.name = kwargs["readout_name"] self.dimensions = range(kwargs["num_cell_dimensions"] - 1, 0, -1) - hidden_dim = kwargs["hidden_dim"] + self.hidden_dim = kwargs["hidden_dim"] for i in self.dimensions: setattr( self, f"agg_conv_{i}", topomodelx.base.conv.Conv( - hidden_dim, hidden_dim, aggr_norm=False + self.hidden_dim, self.hidden_dim, aggr_norm=False ), ) - setattr(self, f"ln_{i}", torch.nn.LayerNorm(hidden_dim)) + setattr(self, f"ln_{i}", torch.nn.LayerNorm(self.hidden_dim)) setattr( self, f"projector_{i}", - torch.nn.Linear(2 * hidden_dim, hidden_dim), + torch.nn.Linear(2 * self.hidden_dim, self.hidden_dim), ) def forward(self, model_out: dict, batch: torch_geometric.data.Data): diff --git a/tutorials/batching.ipynb b/tutorials/batching.ipynb new file mode 100644 index 00000000..b78ea289 --- /dev/null +++ b/tutorials/batching.ipynb @@ -0,0 +1,712 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Batching\n", + "\n", + "This notebook shows how to use and test the NeighborCellsLoader, which is the topological counterpart of NeighborLoader from torch_geometric." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports and utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_26947/1154935553.py:31: UserWarning: \n", + "The version_base parameter is not specified.\n", + "Please specify a compatability version level, or None.\n", + "Will assume defaults for version 1.1\n", + " initialize(config_path=\"../configs\", job_name=\"job\")\n" + ] + }, + { + "data": { + "text/plain": [ + "hydra.initialize()" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os, shutil, rootutils\n", + "\n", + "rootutils.setup_root(\"./\", indicator=\".project-root\", pythonpath=True)\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import hydra\n", + "import torch\n", + "import torch_geometric\n", + "from hydra import compose, initialize\n", + "from omegaconf import OmegaConf\n", + "\n", + "from topobenchmark.data.utils.utils import load_manual_graph\n", + "from topobenchmark.data.preprocessor import PreProcessor\n", + "from topobenchmark.dataloader.dataloader import TBDataloader\n", + "from topobenchmark.data.loaders import PlanetoidDatasetLoader\n", + "\n", + "from topobenchmark.data.batching.neighbor_cells_loader import NeighborCellsLoader\n", + "from topobenchmark.data.preprocessor import PreProcessor\n", + "from topomodelx.nn.simplicial.scn2 import SCN2\n", + "from topomodelx.nn.hypergraph.allset_transformer import AllSetTransformer\n", + "\n", + "from topobenchmark.utils.config_resolvers import (\n", + " get_default_transform,\n", + " get_monitor_metric,\n", + " get_monitor_mode,\n", + " infer_in_channels,\n", + ")\n", + "\n", + "initialize(config_path=\"../configs\", job_name=\"job\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import networkx as nx\n", + "import numpy as np\n", + "import torch\n", + "from matplotlib.patches import Polygon\n", + "from itertools import combinations\n", + "from typing import Optional, Dict, List\n", + "\n", + "def plot_graph(\n", + " data,\n", + " face_color_map: Optional[Dict[int, str]] = None,\n", + " node_size: int = 500,\n", + " font_size: int = 12,\n", + " seed: int = 5,\n", + " show: bool = True\n", + ") -> plt.Figure:\n", + " \"\"\"\n", + " Visualize a simplicial complex from a PyTorch Geometric Data object.\n", + " \n", + " Args:\n", + " data: torch_geometric.data.Data object containing the simplicial complex\n", + " face_color_map: Dictionary mapping number of tetrahedrons to colors\n", + " node_size: Size of nodes in the visualization\n", + " font_size: Size of font for labels\n", + " seed: Random seed for layout\n", + " show: Whether to display the plot immediately\n", + " \n", + " Returns:\n", + " matplotlib.figure.Figure: The generated figure\n", + " \"\"\"\n", + " # Default color map if none provided\n", + " if face_color_map is None:\n", + " face_color_map = {\n", + " 0: \"pink\",\n", + " 1: \"gray\",\n", + " 2: \"blue\",\n", + " 3: \"blue\",\n", + " 4: \"orange\",\n", + " 5: \"purple\",\n", + " 6: \"red\",\n", + " 7: \"brown\",\n", + " 8: \"black\",\n", + " 9: \"gray\",\n", + " }\n", + " \n", + " # Extract vertices\n", + " num_vertices = data.num_nodes if hasattr(data, 'num_nodes') else data.x.shape[0]\n", + " vertices = list(range(num_vertices))\n", + " \n", + " # Extract edges from incidence matrix\n", + " edges = []\n", + " for edge in abs(data.incidence_1.to_dense().T):\n", + " edges.append(torch.where(edge == 1)[0].numpy())\n", + " edges = np.array(edges)\n", + " \n", + " # Extract tetrahedrons if available\n", + " tetrahedrons = []\n", + " if hasattr(data, 'tetrahedrons'):\n", + " tetrahedrons = data.tetrahedrons\n", + " elif hasattr(data, 'incidence_2'):\n", + " # Extract tetrahedrons from incidence_2 matrix if available\n", + " for tetra in abs(data.incidence_2.to_dense().T):\n", + " tetrahedrons.append(torch.where(tetra == 1)[0].tolist())\n", + " \n", + " # Create graph\n", + " G = nx.Graph()\n", + " G.add_nodes_from(vertices)\n", + " G.add_edges_from(edges)\n", + " \n", + " # Find triangular cliques\n", + " cliques = list(nx.enumerate_all_cliques(G))\n", + " cliques = [triangle for triangle in cliques if len(triangle) == 3]\n", + " \n", + " # Create layout\n", + " pos = nx.spring_layout(G, seed=seed)\n", + " \n", + " # Create figure\n", + " fig = plt.figure(figsize=(10, 8))\n", + " \n", + " # Draw nodes and labels\n", + " node_labels = {i: f\"v_{n.item()}\" for i,n in enumerate(data.n_id)} if hasattr(data, 'n_id') else {i: f\"v_{i}\" for i in G.nodes()}\n", + " nx.draw(\n", + " G,\n", + " pos,\n", + " labels=node_labels,\n", + " node_size=node_size,\n", + " node_color=\"skyblue\",\n", + " font_size=font_size,\n", + " )\n", + " \n", + " # Draw edges\n", + " nx.draw_networkx_edges(G, pos, edgelist=edges, edge_color=\"g\", width=2, alpha=0.5)\n", + " \n", + " # # Add edge labels\n", + " for i, (u, v) in enumerate(edges):\n", + " x = (pos[u][0] + pos[v][0]) / 2\n", + " y = (pos[u][1] + pos[v][1]) / 2\n", + " plt.text(x, y, f\"e_{i}\", fontsize=font_size - 2, color=\"r\")\n", + " \n", + " # Color the faces (cliques)\n", + " for clique in cliques:\n", + " # Count tetrahedrons containing this clique\n", + " counter = 0\n", + " for tetrahedron in tetrahedrons:\n", + " for comb in combinations(tetrahedron, 3):\n", + " if set(clique) == set(comb):\n", + " counter += 1\n", + " \n", + " # Create and add polygon\n", + " polygon = [pos[v] for v in clique]\n", + " poly = Polygon(\n", + " polygon,\n", + " closed=True,\n", + " facecolor=face_color_map.get(counter, \"gray\"), # Default to gray if counter not in map\n", + " edgecolor=\"pink\",\n", + " alpha=0.3,\n", + " )\n", + " plt.gca().add_patch(poly)\n", + " \n", + " plt.title(f\"Graph with cliques colored ({num_vertices} vertices)\")\n", + " \n", + " if show:\n", + " plt.show()\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Different use cases" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Manual Simplicial Graph" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data(x=[8, 1], edge_index=[2, 13], y=[8], num_nodes=8, incidence_0=[1, 8], down_laplacian_0=[8, 8], up_laplacian_0=[8, 8], adjacency_0=[8, 8], coadjacency_0=[8, 8], hodge_laplacian_0=[8, 8], incidence_1=[8, 13], down_laplacian_1=[13, 13], up_laplacian_1=[13, 13], adjacency_1=[13, 13], coadjacency_1=[13, 13], hodge_laplacian_1=[13, 13], incidence_2=[13, 6], down_laplacian_2=[6, 6], up_laplacian_2=[6, 6], adjacency_2=[6, 6], coadjacency_2=[6, 6], hodge_laplacian_2=[6, 6], incidence_3=[6, 1], down_laplacian_3=[1, 1], up_laplacian_3=[1, 1], adjacency_3=[1, 1], coadjacency_3=[1, 1], hodge_laplacian_3=[1, 1], shape=[4], x_0=[8, 1], x_1=[13, 1], x_2=[6, 1], x_3=[1, 1])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing...\n", + "Done!\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "path = \"./graph2simplicial_lifting/\"\n", + "if os.path.isdir(path):\n", + " shutil.rmtree(path)\n", + "cfg = compose(config_name=\"run.yaml\", \n", + " overrides=[\"dataset=graph/manual_dataset\", \"model=simplicial/san\"], \n", + " return_hydra_config=True)\n", + "\n", + "data = load_manual_graph()\n", + "preprocessed_dataset = PreProcessor(data, './', cfg['transforms'])\n", + "data = preprocessed_dataset[0]\n", + "print(data)\n", + "plot_graph(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Data(x=[8, 1], edge_index=[2, 13], y=[8], num_nodes=8, incidence_0=[1, 8], down_laplacian_0=[8, 8], up_laplacian_0=[8, 8], adjacency_0=[8, 8], coadjacency_0=[8, 8], hodge_laplacian_0=[8, 8], incidence_1=[8, 13], down_laplacian_1=[13, 13], up_laplacian_1=[13, 13], adjacency_1=[13, 13], coadjacency_1=[13, 13], hodge_laplacian_1=[13, 13], incidence_2=[13, 6], down_laplacian_2=[6, 6], up_laplacian_2=[6, 6], adjacency_2=[6, 6], coadjacency_2=[6, 6], hodge_laplacian_2=[6, 6], incidence_3=[6, 1], down_laplacian_3=[1, 1], up_laplacian_3=[1, 1], adjacency_3=[1, 1], coadjacency_3=[1, 1], hodge_laplacian_3=[1, 1], shape=[4], x_0=[8, 1], x_1=[13, 1], x_2=[6, 1], x_3=[1, 1])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Training, validation and split idxs should be defined somewhere, here we use a toy example\n", + "rank = 0\n", + "if hasattr(data, \"x_hyperedges\") and rank==1:\n", + " n_cells = data.x_hyperedges.shape[0]\n", + "else:\n", + " n_cells = data[f'x_{rank}'].shape[0]\n", + "\n", + "train_prop = 0.5\n", + "n_train = int(train_prop * n_cells)\n", + "train_mask = torch.zeros(n_cells, dtype=torch.bool)\n", + "train_mask[:n_train] = 1\n", + "\n", + "y = torch.zeros(n_cells, dtype=torch.long)\n", + "data.y = y\n", + "\n", + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 1\n", + "\n", + "loader = NeighborCellsLoader(data,\n", + " rank=rank,\n", + " num_neighbors=[-1],\n", + " input_nodes=train_mask,\n", + " batch_size=batch_size,\n", + " shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data(x=[5, 1], edge_index=[2, 16], y=[5], num_nodes=5, incidence_0=[1, 5], down_laplacian_0=[5, 5], up_laplacian_0=[5, 5], adjacency_0=[5, 5], coadjacency_0=[8, 8], hodge_laplacian_0=[5, 5], incidence_1=[5, 8], down_laplacian_1=[8, 8], up_laplacian_1=[8, 8], adjacency_1=[8, 8], coadjacency_1=[13, 13], hodge_laplacian_1=[8, 8], incidence_2=[8, 5], down_laplacian_2=[5, 5], up_laplacian_2=[5, 5], adjacency_2=[5, 5], coadjacency_2=[6, 6], hodge_laplacian_2=[5, 5], incidence_3=[5, 1], down_laplacian_3=[1, 1], up_laplacian_3=[1, 1], adjacency_3=[1, 1], coadjacency_3=[1, 1], hodge_laplacian_3=[1, 1], shape=[4], x_0=[5, 1], x_1=[8, 1], x_2=[5, 1], x_3=[1, 1], cells_ids=[4], n_id=[5])\n", + "The cells of rank 0 that were originally selected are [0]\n", + "Selected cells of rank 0: tensor([0, 7, 1, 2, 4])\n", + "Incidence 3:\n", + "tensor([[1.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.]])\n", + "Incidence 2:\n", + "tensor([[1., 1., 0., 0., 0.],\n", + " [1., 0., 1., 1., 0.],\n", + " [0., 1., 1., 0., 0.],\n", + " [0., 0., 0., 1., 0.],\n", + " [1., 0., 0., 0., 1.],\n", + " [0., 1., 0., 0., 1.],\n", + " [0., 0., 1., 0., 1.],\n", + " [0., 0., 0., 1., 0.]])\n", + "Incidence 1:\n", + "tensor([[1., 1., 1., 1., 0., 0., 0., 0.],\n", + " [0., 0., 0., 1., 0., 0., 0., 1.],\n", + " [1., 0., 0., 0., 1., 1., 0., 0.],\n", + " [0., 1., 0., 0., 1., 0., 1., 1.],\n", + " [0., 0., 1., 0., 0., 1., 1., 0.]])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for batch in loader:\n", + " print(batch)\n", + " print(f\"The cells of rank {rank} that were originally selected are {batch.n_id[:batch_size].tolist()}\")\n", + " \n", + " print(f\"Selected cells of rank {rank}: {batch.n_id}\")\n", + " if hasattr(batch, 'incidence_hyperedges'):\n", + " print(\"Incidence hyperedges:\")\n", + " print(batch.incidence_hyperedges.to_dense())\n", + " else:\n", + " print(\"Incidence 3:\")\n", + " print(batch.incidence_3.to_dense())\n", + " print(\"Incidence 2:\")\n", + " print(batch.incidence_2.to_dense())\n", + " print(\"Incidence 1:\")\n", + " print(batch.incidence_1.to_dense())\n", + " if rank == 0:\n", + " plot_graph(batch)\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cora hypergraph" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing...\n", + "Done!\n" + ] + } + ], + "source": [ + "path = \"./graph2hypergraph_lifting/\"\n", + "if os.path.isdir(path):\n", + " shutil.rmtree(path)\n", + "cfg = compose(config_name=\"run.yaml\", \n", + " overrides=[\"dataset=graph/cocitation_cora\", \"model=hypergraph/allsettransformer\"], \n", + " return_hydra_config=True)\n", + "graph_loader = PlanetoidDatasetLoader(cfg.dataset.loader.parameters)\n", + "dataset, dataset_dir = graph_loader.load()\n", + "preprocessed_dataset = PreProcessor(dataset, './', cfg['transforms'])\n", + "data = preprocessed_dataset[0]\n", + "\n", + "# Training, validation and split idxs should be defined somewhere, here we use a toy example\n", + "rank = 0\n", + "if hasattr(data, \"x_hyperedges\") and rank==1:\n", + " n_cells = data.x_hyperedges.shape[0]\n", + "else:\n", + " n_cells = data[f'x_{rank}'].shape[0]\n", + "\n", + "train_prop = 0.5\n", + "n_train = int(train_prop * n_cells)\n", + "train_mask = torch.zeros(n_cells, dtype=torch.bool)\n", + "train_mask[:n_train] = 1\n", + "\n", + "if rank != 0:\n", + " y = torch.zeros(n_cells, dtype=torch.long)\n", + " data.y = y\n", + "batch_size = 1\n", + "\n", + "# num_neighbors controls also the number of hops (for 2 hops do num_neighbors=[-1, -1])\n", + "\n", + "\n", + "loader = NeighborCellsLoader(data,\n", + " rank=rank,\n", + " num_neighbors=[-1],\n", + " input_nodes=train_mask,\n", + " batch_size=batch_size,\n", + " shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data(x=[4, 1433], edge_index=[2, 10556], y=[4], train_mask=[2708], val_mask=[2708], test_mask=[2708], incidence_hyperedges=[4, 5], num_hyperedges=2708, x_0=[4, 1433], x_hyperedges=[2708, 1433], num_nodes=4, cells_ids=[2], n_id=[4])\n", + "tensor([ 0, 1862, 633, 2582])\n", + "tensor([[ 0, 0, 0, ..., 2707, 2707, 2707],\n", + " [ 633, 1862, 2582, ..., 598, 1473, 2706]])\n", + "tensor([[1., 1., 0., 1., 1.],\n", + " [1., 0., 1., 1., 1.],\n", + " [1., 1., 1., 0., 0.],\n", + " [1., 0., 0., 1., 1.]])\n" + ] + } + ], + "source": [ + "for batch in loader:\n", + " print(batch)\n", + " print(batch.n_id)\n", + " print(batch.edge_index)\n", + " if hasattr(batch, 'incidence_hyperedges'):\n", + " print(batch.incidence_hyperedges.to_dense())\n", + " else:\n", + " print(batch.incidence_3.to_dense())\n", + " print(batch.incidence_2.to_dense())\n", + " print(batch.incidence_1.to_dense())\n", + " \n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing NeighborCellLoader" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If batching is done correctly the results on the selected cells should not change when compared to the results obtained over the whole graph.\n", + "We test this to check that our batching strategy is correct." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Testing simplicial complexes" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transform parameters are the same, using existing data_dir: /TopoBenchmark/datasets/graph/cocitation/Cora/graph2simplicial_lifting/1597083846\n", + "Testing batching for SCN2 using 2 layers.\n", + "We return the MSE between the full batch and the batched version.\n", + " n_hops = 1 MSE: 3.947006937138043\n", + " n_hops = 2 MSE: 9.035350438167982e-12\n", + " n_hops = 3 MSE: 1.0411274301838695e-11\n" + ] + } + ], + "source": [ + "path = \"./graph2simplicial_lifting/\"\n", + "if os.path.isdir(path):\n", + " shutil.rmtree(path)\n", + "cfg = compose(config_name=\"run.yaml\", \n", + " overrides=[\"dataset=graph/cocitation_cora\", \"model=simplicial/scn\"], \n", + " return_hydra_config=True)\n", + "\n", + "dataset_loader = hydra.utils.instantiate(cfg.dataset.loader)\n", + "dataset, dataset_dir = dataset_loader.load()\n", + "# Preprocess dataset and load the splits\n", + "transform_config = cfg.get(\"transforms\", None)\n", + "preprocessor = PreProcessor(dataset, dataset_dir, transform_config)\n", + "dataset_train, dataset_val, dataset_test = (\n", + " preprocessor.load_dataset_splits(cfg.dataset.split_params)\n", + ")\n", + "\n", + "### Full batch --------------------------------------------------------\n", + "cfg.dataset.dataloader_params.batch_size = -1\n", + "\n", + "datamodule = TBDataloader(\n", + " dataset_train=dataset_train,\n", + " dataset_val=dataset_val,\n", + " dataset_test=dataset_test,\n", + " **cfg.dataset.get(\"dataloader_params\", {}),\n", + " )\n", + "\n", + "input_dim = 1433\n", + "hidden_channels = 16\n", + "out_dim = 7\n", + "\n", + "model = SCN2(input_dim, input_dim, input_dim, n_layers=2)\n", + "model.eval()\n", + "\n", + "train_dataloader = datamodule.train_dataloader()\n", + "for data in train_dataloader:\n", + " x_0_full, x_1_full, x_2_full = model(data.x_0, data.x_1, data.x_2, data.hodge_laplacian_0, data.hodge_laplacian_1, data.hodge_laplacian_2)\n", + "\n", + "### Batched --------------------------------------------------------\n", + "print(\"Testing batching for SCN2 using 2 layers.\")\n", + "print(\"We return the MSE between the full batch and the batched version.\")\n", + "for n_hops in range(1, 4):\n", + " cfg.dataset.dataloader_params.batch_size = 32\n", + "\n", + " datamodule_batched = TBDataloader(\n", + " dataset_train=dataset_train,\n", + " dataset_val=dataset_val,\n", + " dataset_test=dataset_test,\n", + " num_neighbors = [-1] * n_hops,\n", + " **cfg.dataset.get(\"dataloader_params\", {}),\n", + " )\n", + " train_dataloader_batched = datamodule_batched.train_dataloader()\n", + " mse = 0\n", + " for i, batch in enumerate(train_dataloader_batched):\n", + " x_0_batch, x_1_batch, x_2_batch = model(batch.x_0, batch.x_1, batch.x_2, batch.hodge_laplacian_0, batch.hodge_laplacian_1, batch.hodge_laplacian_2)\n", + " n_ids = batch.n_id[:batch_size]\n", + " mse += torch.mean((x_0_full[n_ids, :] - x_0_batch[:batch_size, :]).pow(2)).item()\n", + " mse = mse / (i + 1)\n", + " \n", + " # The last element might be False since the last batch might not be full\n", + " print(f\" n_hops = {n_hops} MSE: {mse}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Testing hypergraphs" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transform parameters are the same, using existing data_dir: /TopoBenchmark/datasets/graph/cocitation/Cora/graph2hypergraph_lifting/1010717418\n", + "Testing batching for AllSetTransformer using 3 layers.\n", + "We return the MSE between the full batch and the batched version.\n", + " n_hops = 1 MSE: 0.0002609546898304469\n", + " n_hops = 2 MSE: 1.660647607597814e-05\n", + " n_hops = 3 MSE: 1.1712208103968767e-06\n", + " n_hops = 4 MSE: 1.5722682561617035e-08\n", + " n_hops = 5 MSE: 1.550387910249659e-11\n", + " n_hops = 6 MSE: 8.365642818938425e-15\n", + " n_hops = 7 MSE: 7.258141882427575e-15\n", + " n_hops = 8 MSE: 7.711832348623849e-15\n", + " n_hops = 9 MSE: 4.981246563409259e-15\n" + ] + } + ], + "source": [ + "path = \"./graph2hypergraph_lifting/\"\n", + "if os.path.isdir(path):\n", + " shutil.rmtree(path)\n", + "cfg = compose(config_name=\"run.yaml\", \n", + " overrides=[\"dataset=graph/cocitation_cora\", \"model=hypergraph/allsettransformer\"], \n", + " return_hydra_config=True)\n", + "\n", + "dataset_loader = hydra.utils.instantiate(cfg.dataset.loader)\n", + "dataset, dataset_dir = dataset_loader.load()\n", + "# Preprocess dataset and load the splits\n", + "transform_config = cfg.get(\"transforms\", None)\n", + "preprocessor = PreProcessor(dataset, dataset_dir, transform_config)\n", + "dataset_train, dataset_val, dataset_test = (\n", + " preprocessor.load_dataset_splits(cfg.dataset.split_params)\n", + ")\n", + "\n", + "### Full batch --------------------------------------------------------\n", + "cfg.dataset.dataloader_params.batch_size = -1\n", + "\n", + "datamodule = TBDataloader(\n", + " dataset_train=dataset_train,\n", + " dataset_val=dataset_val,\n", + " dataset_test=dataset_test,\n", + " **cfg.dataset.get(\"dataloader_params\", {}),\n", + " )\n", + "\n", + "input_dim = 1433\n", + "hidden_channels = 16\n", + "out_dim = 7\n", + "n_layers = 3\n", + "model = AllSetTransformer(input_dim, hidden_channels, n_layers=n_layers)\n", + "model.eval()\n", + "\n", + "train_dataloader = datamodule.train_dataloader()\n", + "for data in train_dataloader:\n", + " x_0_full, x_1_full = model(data.x_0, data.incidence_hyperedges)\n", + "\n", + "### Batched --------------------------------------------------------\n", + "print(f\"Testing batching for AllSetTransformer using {n_layers} layers.\")\n", + "print(\"We return the MSE between the full batch and the batched version.\")\n", + "for n_hops in range(1, 10):\n", + " cfg.dataset.dataloader_params.batch_size = 32\n", + "\n", + " datamodule_batched = TBDataloader(\n", + " dataset_train=dataset_train,\n", + " dataset_val=dataset_val,\n", + " dataset_test=dataset_test,\n", + " num_neighbors = [-1] * n_hops,\n", + " **cfg.dataset.get(\"dataloader_params\", {}),\n", + " )\n", + " train_dataloader_batched = datamodule_batched.train_dataloader()\n", + " mse = 0\n", + " for i, batch in enumerate(train_dataloader_batched):\n", + " x_0_batch, x_1_batch = model(batch.x_0, batch.incidence_hyperedges)\n", + " n_ids = batch.n_id[:batch_size]\n", + " mse += torch.mean((x_0_full[n_ids, :] - x_0_batch[:batch_size, :]).pow(2)).item()\n", + " mse = mse / (i + 1)\n", + " \n", + " # The last element might be False since the last batch might not be full\n", + " print(f\" n_hops = {n_hops} MSE: {mse}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}