diff --git a/configs/datasets/random_dataset.yaml b/configs/datasets/random_dataset.yaml new file mode 100644 index 00000000..acb5f8aa --- /dev/null +++ b/configs/datasets/random_dataset.yaml @@ -0,0 +1,10 @@ +data_domain: pointcloud +data_type: toy_dataset +data_name: random_dataset +data_dir: datasets/${data_domain}/${data_type} + +# Dataset parameters +num_features: 1 +num_classes: 2 +task: classification +loss_type: cross_entropy diff --git a/configs/transforms/liftings/pointcloud2simplicial/vietoris_rips_lifting.yaml b/configs/transforms/liftings/pointcloud2simplicial/vietoris_rips_lifting.yaml new file mode 100644 index 00000000..e40257f6 --- /dev/null +++ b/configs/transforms/liftings/pointcloud2simplicial/vietoris_rips_lifting.yaml @@ -0,0 +1,5 @@ +transform_type: 'lifting' +transform_name: "VietorisRipsLifting" +complex_dim: 2 +feature_lifting: ProjectionSum +epsilon: 0.5 diff --git a/modules/data/load/loaders.py b/modules/data/load/loaders.py index 8ccafb11..0387db0f 100755 --- a/modules/data/load/loaders.py +++ b/modules/data/load/loaders.py @@ -12,6 +12,7 @@ load_cell_complex_dataset, load_hypergraph_pickle_dataset, load_manual_graph, + load_random_points, load_simplicial_dataset, ) @@ -204,3 +205,32 @@ def load( torch_geometric.data.Dataset object containing the loaded data. """ return load_hypergraph_pickle_dataset(self.parameters) + + +class PointCloudLoader(AbstractLoader): + r"""Loader for point-cloud dataset. + + Parameters + ---------- + parameters: DictConfig + Configuration parameters + """ + + def __init__(self, parameters: DictConfig): + super().__init__(parameters) + self.parameters = parameters + + def load(self) -> torch_geometric.data.Dataset: + r"""Load point-cloud dataset. + + Parameters + ---------- + None + + Returns + ------- + torch_geometric.data.Dataset + torch_geometric.data.Dataset object containing the loaded data. + """ + data = load_random_points(num_classes=self.cfg["num_classes"]) + return CustomDataset([data], self.cfg["data_dir"]) diff --git a/modules/data/utils/utils.py b/modules/data/utils/utils.py index 93ab5021..40e48984 100755 --- a/modules/data/utils/utils.py +++ b/modules/data/utils/utils.py @@ -50,16 +50,16 @@ def get_complex_connectivity(complex, max_rank, signed=False): ) except ValueError: # noqa: PERF203 if connectivity_info == "incidence": - connectivity[f"{connectivity_info}_{rank_idx}"] = ( - generate_zero_sparse_connectivity( - m=practical_shape[rank_idx - 1], n=practical_shape[rank_idx] - ) + connectivity[ + f"{connectivity_info}_{rank_idx}" + ] = generate_zero_sparse_connectivity( + m=practical_shape[rank_idx - 1], n=practical_shape[rank_idx] ) else: - connectivity[f"{connectivity_info}_{rank_idx}"] = ( - generate_zero_sparse_connectivity( - m=practical_shape[rank_idx], n=practical_shape[rank_idx] - ) + connectivity[ + f"{connectivity_info}_{rank_idx}" + ] = generate_zero_sparse_connectivity( + m=practical_shape[rank_idx], n=practical_shape[rank_idx] ) connectivity["shape"] = practical_shape return connectivity @@ -283,6 +283,17 @@ def load_hypergraph_pickle_dataset(cfg): return data +def load_random_points(num_classes: int = 2, num_points: int = 8, seed: int = 128): + """Create a toy point cloud dataset""" + rng = np.random.default_rng(seed) + + points = torch.tensor(rng.random((num_points, 2)), dtype=torch.float) + classes = torch.tensor(rng.integers(num_classes, size=num_points), dtype=torch.long) + features = torch.tensor(rng.integers(3, size=(num_points, 1)), dtype=torch.float) + + return torch_geometric.data.Data(x=features, y=classes, pos=points) + + def load_manual_graph(): """Create a manual graph for testing purposes.""" # Define the vertices (just 8 vertices) diff --git a/modules/transforms/data_transform.py b/modules/transforms/data_transform.py index 59253ecf..636af19a 100755 --- a/modules/transforms/data_transform.py +++ b/modules/transforms/data_transform.py @@ -15,6 +15,9 @@ from modules.transforms.liftings.graph2simplicial.clique_lifting import ( SimplicialCliqueLifting, ) +from modules.transforms.liftings.pointcloud2simplicial.vietoris_rips_lifting import ( + VietorisRipsLifting, +) TRANSFORMS = { # Graph -> Hypergraph @@ -23,6 +26,8 @@ "SimplicialCliqueLifting": SimplicialCliqueLifting, # Graph -> Cell Complex "CellCycleLifting": CellCycleLifting, + # Point Cloud -> Simplicial Complex + "VietorisRipsLifting": VietorisRipsLifting, # Feature Liftings "ProjectionSum": ProjectionSum, # Data Manipulations diff --git a/modules/transforms/liftings/pointcloud2simplicial/vietoris_rips_lifting.py b/modules/transforms/liftings/pointcloud2simplicial/vietoris_rips_lifting.py new file mode 100644 index 00000000..90efae3f --- /dev/null +++ b/modules/transforms/liftings/pointcloud2simplicial/vietoris_rips_lifting.py @@ -0,0 +1,101 @@ +from itertools import combinations + +import torch +import torch_geometric +from toponetx.classes import Simplex, SimplicialComplex + +from modules.data.utils.utils import get_complex_connectivity +from modules.transforms.liftings.pointcloud2simplicial.base import ( + PointCloud2SimplicialLifting, +) + + +class VietorisRipsLifting(PointCloud2SimplicialLifting): + """Lifts point cloud data to a Vietoris-Rips Complex. It works + by creating a 1-simplex between any two points if their distance + is less than or equal to epsilon. It then creates an n-simplex if + every pair of its n+1 vertices is connected by a 1-simplex. + + """ + + def __init__(self, epsilon: float, **kwargs): + assert epsilon > 0 + + self.epsilon = epsilon + super().__init__(**kwargs) + + def _get_lifted_topology(self, simplicial_complex: SimplicialComplex) -> dict: + r"""Returns the lifted topology. + + Parameters + ---------- + simplicial_complex : SimplicialComplex + The simplicial complex. + + Returns + ------- + dict + The lifted topology. + """ + lifted_topology = get_complex_connectivity( + simplicial_complex, simplicial_complex.maxdim + ) + + lifted_topology["x_0"] = torch.stack( + list(simplicial_complex.get_simplex_attributes("features", 0).values()) + ) + + return lifted_topology + + def lift_topology(self, data: torch_geometric.data.Data) -> dict: + """ + Applies Vietoris-Rips lifting strategy to point cloud. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data to be lifted. + + Returns + ------- + dict + The lifted topology. + """ + points = data.pos + + # Calculate pairwise distance matrix between points. + distance_matrix = torch.cdist(points, points) + + n = len(points) + + # Add 0-simplices (vertices) with their associated features. + simplices = [Simplex([i], features=data.x[i]) for i in range(n)] + + # Add 1-simplices (edges) where the pairwise distance between + # points are less than epsilon + edges = [[i, j] for i in range(n) for j in range(i + 1, n) if distance_matrix[i, j] <= self.epsilon] + simplices.extend(Simplex(edge) for edge in edges) + + # Step 3: Construct higher-dimensional simplices + # Iteratively finds all k-dimensional simplices (starting from k = 2) that can be formed in the graph. + k = 2 + while True: + higher_dim_simplices = [ + Simplex(list(simplex)) + for simplex in combinations(range(n), k + 1) + if all( + ([simplex[i], simplex[j]] in edges or [simplex[j], simplex[i]] in edges) + for i in range(k) + for j in range(i + 1, k + 1) + ) + ] + + if not higher_dim_simplices: + break + + simplices.extend(higher_dim_simplices) + k += 1 + + SC = SimplicialComplex(simplices) + + return self._get_lifted_topology(SC) diff --git a/test/transforms/liftings/pointcloud2simplicial/test_viteoris_rips_lifting.py b/test/transforms/liftings/pointcloud2simplicial/test_viteoris_rips_lifting.py new file mode 100644 index 00000000..6fc46756 --- /dev/null +++ b/test/transforms/liftings/pointcloud2simplicial/test_viteoris_rips_lifting.py @@ -0,0 +1,74 @@ +import unittest + +import torch +from torch_geometric.data import Data + +from modules.transforms.liftings.pointcloud2simplicial.vietoris_rips_lifting import ( + VietorisRipsLifting, +) + + +class TestVietorisRipsLifting(unittest.TestCase): + def setUp(self): + # Set up some basic point cloud data for testing + self.points = torch.tensor( + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], dtype=torch.float + ) + self.features = torch.tensor([[1], [2], [3], [4]], dtype=torch.float) + self.data = Data(pos=self.points, x=self.features) + self.epsilon = 1.5 # Set epsilon distance + + def test_initialization(self): + # Test initialization + lifting = VietorisRipsLifting(epsilon=self.epsilon) + self.assertEqual(lifting.epsilon, self.epsilon) + + def test_lift_topology(self): + # Test lift_topology method + lifting = VietorisRipsLifting(epsilon=self.epsilon) + lifted_topology = lifting.lift_topology(self.data) + + # Check if the lifted topology contains expected keys + self.assertIn("x_0", lifted_topology) + + # Check if the number of vertices matches the input points + self.assertEqual(lifted_topology["shape"][0], len(self.points)) + + # Check if the features are correctly assigned + for i, feature in enumerate(self.features): + self.assertTrue(torch.equal(lifted_topology["x_0"][i], feature)) + + def test_lifted_topology_structure(self): + # Check the structure of the lifted topology + lifting_tiny_epsilon = VietorisRipsLifting(epsilon=0.5) + lifted_topology_tiny = lifting_tiny_epsilon.lift_topology(self.data) + + # Ensure the output is a dictionary + self.assertIsInstance(lifted_topology_tiny, dict) + + self.assertEqual(lifted_topology_tiny["shape"], [4]) + + lifting_small_epsilon = VietorisRipsLifting(epsilon=1) + lifted_topology_small = lifting_small_epsilon.lift_topology(self.data) + self.assertEqual(lifted_topology_small["shape"], [4, 4]) + + lifting_large_epsilon = VietorisRipsLifting(epsilon=1.5) + lifted_topology_large = lifting_large_epsilon.lift_topology(self.data) + self.assertEqual(lifted_topology_large["shape"], [4, 6, 4, 1]) + + def test_epsilon_effect(self): + # Test the effect of different epsilon values + lifting_small_epsilon = VietorisRipsLifting(epsilon=1) + lifted_topology_small = lifting_small_epsilon.lift_topology(self.data) + simplices_count_small = sum(lifted_topology_small["shape"]) + + lifting_large_epsilon = VietorisRipsLifting(epsilon=1.5) + lifted_topology_large = lifting_large_epsilon.lift_topology(self.data) + simplices_count_large = sum(lifted_topology_large["shape"]) + + # With a smaller epsilon, the total number of simplic + self.assertGreater(simplices_count_large, simplices_count_small) + + +if __name__ == "__main__": + unittest.main() diff --git a/tutorials/pointcloud2simplicial/vietoris_rips_lifting.ipynb b/tutorials/pointcloud2simplicial/vietoris_rips_lifting.ipynb new file mode 100644 index 00000000..b66d2e8f --- /dev/null +++ b/tutorials/pointcloud2simplicial/vietoris_rips_lifting.ipynb @@ -0,0 +1,287 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true, + "ExecuteTime": { + "start_time": "2024-06-23T16:44:17.471879Z", + "end_time": "2024-06-23T16:44:17.499155Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "from modules.data.load.loaders import PointCloudLoader\n", + "from modules.data.preprocess.preprocessor import PreProcessor\n", + "from modules.utils.utils import (\n", + " describe_data,\n", + " load_dataset_config,\n", + " load_model_config,\n", + " load_transform_config,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset configuration for random_dataset:\n", + "\n", + "{'data_domain': 'pointcloud',\n", + " 'data_type': 'toy_dataset',\n", + " 'data_name': 'random_dataset',\n", + " 'data_dir': 'datasets/pointcloud/toy_dataset',\n", + " 'num_features': 1,\n", + " 'num_classes': 2,\n", + " 'task': 'classification',\n", + " 'loss_type': 'cross_entropy'}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing...\n", + "Done!\n" + ] + } + ], + "source": [ + "# loader = PointCloudLoader(\n", + "# {\n", + "# \"num_classes\": 3,\n", + "# \"data_dir\": \"modules/transforms/liftings/pointcloud2simplicial/\",\n", + "# }\n", + "# )\n", + "\n", + "dataset_name = \"random_dataset\"\n", + "dataset_config = load_dataset_config(dataset_name)\n", + "loader = PointCloudLoader(dataset_config)\n", + "\n", + "dataset = loader.load()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-06-23T16:44:22.905086Z", + "end_time": "2024-06-23T16:44:22.940047Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 11, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Transform configuration for pointcloud2simplicial/vietoris_rips_lifting:\n", + "\n", + "{'transform_type': 'lifting',\n", + " 'transform_name': 'VietorisRipsLifting',\n", + " 'complex_dim': 2,\n", + " 'feature_lifting': 'ProjectionSum',\n", + " 'epsilon': 0.5}\n" + ] + } + ], + "source": [ + "transform_type = \"liftings\"\n", + "# If the transform is a topological lifting, it should include both the type of the lifting and the identifier\n", + "transform_id = \"pointcloud2simplicial/vietoris_rips_lifting\"\n", + "\n", + "# Read yaml file\n", + "transform_config = {\n", + " \"lifting\": load_transform_config(transform_type, transform_id)\n", + " # other transforms (e.g. data manipulations, feature liftings) can be added here\n", + "}" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-06-23T16:44:34.781062Z", + "end_time": "2024-06-23T16:44:34.811609Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 12, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing...\n", + "/Users/elphicm/mambaforge/envs/topox/lib/python3.11/site-packages/scipy/sparse/_index.py:143: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n", + " self._set_arrayXarray(i, j, x)\n", + "Done!\n" + ] + } + ], + "source": [ + "lifted_dataset = PreProcessor(dataset, transform_config, loader.parameters[\"data_dir\"])" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-06-23T16:44:35.715747Z", + "end_time": "2024-06-23T16:44:35.762659Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 13, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset only contains 1 sample:\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 18 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 17 2-cells.\n", + " - The 2-cells have features dimension 1\n", + " - The complex has 7 3-cells.\n", + " - The 3-cells have features dimension 1\n", + " - The complex has 1 4-cells.\n", + " - The 4-cells have features dimension 1\n", + "\n" + ] + } + ], + "source": [ + "describe_data(lifted_dataset)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-06-23T16:44:36.383385Z", + "end_time": "2024-06-23T16:44:36.778717Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 14, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Model configuration for simplicial SAN:\n", + "\n", + "{'in_channels': None,\n", + " 'hidden_channels': 32,\n", + " 'out_channels': None,\n", + " 'n_layers': 2,\n", + " 'n_filters': 2,\n", + " 'order_harmonic': 5,\n", + " 'epsilon_harmonic': 0.1}\n" + ] + } + ], + "source": [ + "from modules.models.simplicial.san import SANModel\n", + "\n", + "model_type = \"simplicial\"\n", + "model_id = \"san\"\n", + "model_config = load_model_config(model_type, model_id)\n", + "\n", + "model = SANModel(model_config, dataset_config)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-06-23T16:44:37.431847Z", + "end_time": "2024-06-23T16:44:37.464032Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 17, + "outputs": [ + { + "data": { + "text/plain": "tensor([[0.5710, 0.5974],\n [0.5751, 0.5552],\n [0.5592, 0.6042],\n [0.5718, 0.6019],\n [0.5619, 0.6089],\n [0.5743, 0.5460],\n [0.5607, 0.6206],\n [0.5710, 0.5974],\n [0.5678, 0.5981],\n [0.5716, 0.5490],\n [0.5647, 0.5582],\n [0.5831, 0.5089],\n [0.5751, 0.5552],\n [0.5797, 0.5526],\n [0.5592, 0.6042],\n [0.5548, 0.6062],\n [0.5681, 0.5536],\n [0.5619, 0.6089]], grad_fn=)" + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_hat = model(lifted_dataset.get(0))\n", + "\n", + "y_hat" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "start_time": "2024-06-23T16:45:16.116100Z", + "end_time": "2024-06-23T16:45:16.145987Z" + } + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}