From b039924aacf873a5dce1d01e69bd3ff633dff7be Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 29 Jun 2024 15:46:58 -0400 Subject: [PATCH 01/15] add point cloud datasets from gudhi --- configs/datasets/gudhi_bunny.yaml | 9 + configs/datasets/gudhi_daily_activities.yaml | 9 + configs/datasets/gudhi_sphere.yaml | 12 + configs/datasets/gudhi_spiral_2d.yaml | 9 + configs/datasets/gudhi_torus.yaml | 12 + configs/datasets/random_points.yaml | 11 + modules/data/load/loaders.py | 65 ++++ modules/data/utils/utils.py | 107 +++++- modules/utils/utils.py | 60 ++- .../point_cloud_complex_lifting.ipynb | 352 ++++++++++++++++++ 10 files changed, 635 insertions(+), 11 deletions(-) create mode 100644 configs/datasets/gudhi_bunny.yaml create mode 100644 configs/datasets/gudhi_daily_activities.yaml create mode 100644 configs/datasets/gudhi_sphere.yaml create mode 100644 configs/datasets/gudhi_spiral_2d.yaml create mode 100644 configs/datasets/gudhi_torus.yaml create mode 100644 configs/datasets/random_points.yaml create mode 100644 tutorials/pointcloud2simplicial/point_cloud_complex_lifting.ipynb diff --git a/configs/datasets/gudhi_bunny.yaml b/configs/datasets/gudhi_bunny.yaml new file mode 100644 index 00000000..3c7b41b4 --- /dev/null +++ b/configs/datasets/gudhi_bunny.yaml @@ -0,0 +1,9 @@ +data_domain: pointcloud +data_type: gudhi +data_name: gudhi_bunny +data_dir: datasets/${data_domain}/${data_type} + +# Dataset parameters +task: regression +loss_type: mse +monitor_metric: mae \ No newline at end of file diff --git a/configs/datasets/gudhi_daily_activities.yaml b/configs/datasets/gudhi_daily_activities.yaml new file mode 100644 index 00000000..7b6bdd97 --- /dev/null +++ b/configs/datasets/gudhi_daily_activities.yaml @@ -0,0 +1,9 @@ +data_domain: pointcloud +data_type: gudhi +data_name: gudhi_daily_activities +data_dir: datasets/${data_domain}/${data_type} + +# Dataset parameters +task: regression +loss_type: mse +monitor_metric: mae \ No newline at end of file diff --git a/configs/datasets/gudhi_sphere.yaml b/configs/datasets/gudhi_sphere.yaml new file mode 100644 index 00000000..6bff480b --- /dev/null +++ b/configs/datasets/gudhi_sphere.yaml @@ -0,0 +1,12 @@ +data_domain: pointcloud +data_type: toy_dataset +data_name: gudhi_sphere +data_dir: datasets/${data_domain}/${data_type} + +# Dataset parameters +ambient_dim: 3 +sample: random # can also be 'grid' +n_samples: 1000 +task: regression +loss_type: mse +monitor_metric: mae \ No newline at end of file diff --git a/configs/datasets/gudhi_spiral_2d.yaml b/configs/datasets/gudhi_spiral_2d.yaml new file mode 100644 index 00000000..a101b4a2 --- /dev/null +++ b/configs/datasets/gudhi_spiral_2d.yaml @@ -0,0 +1,9 @@ +data_domain: pointcloud +data_type: toy_dataset +data_name: gudhi_spiral_2d +data_dir: datasets/${data_domain}/${data_type} + +# Dataset parameters +task: regression +loss_type: mse +monitor_metric: mae \ No newline at end of file diff --git a/configs/datasets/gudhi_torus.yaml b/configs/datasets/gudhi_torus.yaml new file mode 100644 index 00000000..5020ce65 --- /dev/null +++ b/configs/datasets/gudhi_torus.yaml @@ -0,0 +1,12 @@ +data_domain: pointcloud +data_type: toy_dataset +data_name: gudhi_torus +data_dir: datasets/${data_domain}/${data_type} + +# Dataset parameters +dim: 3 # The dimension of the *torus* - the ambient space has dimension 2 * dim +sample: random # can also be 'grid' +n_samples: 1000 +task: regression +loss_type: mse +monitor_metric: mae \ No newline at end of file diff --git a/configs/datasets/random_points.yaml b/configs/datasets/random_points.yaml new file mode 100644 index 00000000..ff1dbb93 --- /dev/null +++ b/configs/datasets/random_points.yaml @@ -0,0 +1,11 @@ +data_domain: pointcloud +data_type: toy_dataset +data_name: random_points +data_dir: datasets/${data_domain}/${data_type} + +# Dataset parameters +dim: 3 +num_classes: 2 +num_samples: 1000 +task: classification +loss_type: cross_entropy \ No newline at end of file diff --git a/modules/data/load/loaders.py b/modules/data/load/loaders.py index 8ccafb11..ef3d2705 100755 --- a/modules/data/load/loaders.py +++ b/modules/data/load/loaders.py @@ -1,7 +1,9 @@ import os +from typing import Callable, Optional import numpy as np import rootutils +import torch import torch_geometric from omegaconf import DictConfig @@ -10,8 +12,10 @@ from modules.data.utils.custom_dataset import CustomDataset from modules.data.utils.utils import ( load_cell_complex_dataset, + load_gudhi_dataset, load_hypergraph_pickle_dataset, load_manual_graph, + load_random_points, load_simplicial_dataset, ) @@ -204,3 +208,64 @@ 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 datasets. + + Parameters + ---------- + parameters : DictConfig + Configuration parameters. + feature_generator: Optional[Callable[[torch.Tensor], torch.Tensor]] + Function to generate the dataset features. If None, no features added. + target_generator: Optional[Callable[[torch.Tensor], torch.Tensor]] + Function to generate the target variable. If None, no target added. + """ + + def __init__( + self, + parameters: DictConfig, + feature_generator: Optional[Callable[[torch.Tensor], torch.Tensor]] = None, + target_generator: Optional[Callable[[torch.Tensor], torch.Tensor]] = None, + ): + self.feature_generator = feature_generator + self.target_generator = target_generator + 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. + """ + # Define the path to the data directory + 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"]) + + 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": + data = load_random_points( + dim=self.parameters["dim"], + num_classes=self.parameters["num_classes"], + num_samples=self.parameters["num_samples"], + ) + else: + raise NotImplementedError( + f"Dataset {self.parameters.data_name} not implemented" + ) + + return CustomDataset([data], self.data_dir) diff --git a/modules/data/utils/utils.py b/modules/data/utils/utils.py index 93ab5021..c61342c3 100755 --- a/modules/data/utils/utils.py +++ b/modules/data/utils/utils.py @@ -1,17 +1,23 @@ import hashlib import os.path as osp import pickle +from typing import Callable, Optional import networkx as nx import numpy as np import omegaconf +import rootutils import toponetx.datasets.graph as graph import torch import torch_geometric +from gudhi.datasets.generators import points +from gudhi.datasets.remote import fetch_bunny, fetch_daily_activities, fetch_spiral_2d from topomodelx.utils.sparse import from_sparse from torch_geometric.data import Data from torch_sparse import coalesce +rootutils.setup_root("./", indicator=".project-root", pythonpath=True) + def get_complex_connectivity(complex, max_rank, signed=False): r"""Gets the connectivity matrices for the complex. @@ -50,16 +56,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 @@ -421,3 +427,88 @@ def make_hash(o): hash_as_hex = sha1.hexdigest() # Convert the hex back to int and restrict it to the relevant int range return int(hash_as_hex, 16) % 4294967295 + + +def load_gudhi_dataset( + cfg: omegaconf.DictConfig, + feature_generator: Optional[Callable[[torch.Tensor], torch.Tensor]] = None, + target_generator: Optional[Callable[[torch.Tensor], torch.Tensor]] = None, +) -> torch_geometric.data.Data: + """Load a dataset from the gudhi.datasets module.""" + if not cfg.data_name.startswith("gudhi_"): + raise ValueError("This function should only be used with gudhi datasets") + + gudhi_dataset_name = cfg.data_name.removeprefix("gudhi_") + + if gudhi_dataset_name == "sphere": + points_data = points.sphere( + n_samples=cfg["n_samples"], + ambient_dim=cfg["ambient_dim"], + sample=cfg["sample"], + ) + elif gudhi_dataset_name == "torus": + points_data = points.torus( + n_samples=cfg["n_samples"], dim=cfg["dim"], sample=cfg["sample"] + ) + elif gudhi_dataset_name == "bunny": + file_path = osp.join( + rootutils.find_root(), cfg["data_dir"], "bunny", "bunny.npy" + ) + points_data = fetch_bunny( + file_path=file_path, accept_license=cfg.get("accept_license", False) + ) + elif gudhi_dataset_name == "spiral_2d": + file_path = osp.join( + rootutils.find_root(), cfg["data_dir"], "spiral_2d", "spiral_2d.npy" + ) + points_data = fetch_spiral_2d(file_path=file_path) + elif gudhi_dataset_name == "daily_activities": + file_path = osp.join( + rootutils.find_root(), cfg["data_dir"], "activities", "activities.npy" + ) + data = fetch_daily_activities(file_path=file_path) + points_data = data[:, :3] + else: + raise ValueError(f"Gudhi dataset {gudhi_dataset_name} not recognized.") + + pos = torch.tensor(points_data, dtype=torch.float) + if feature_generator: + x = feature_generator(points) + if x.shape[0] != points.shape[0]: + raise ValueError( + "feature_generator must not change first dimension of points data." + ) + else: + x = None + + if target_generator: + y = target_generator(points) + if y.shape[0] != points.shape[0]: + raise ValueError( + "target_generator must not change first dimension of points data." + ) + elif gudhi_dataset_name == "daily_activities": + # Target is the activity type + # 14. for ‘cross_training’, 18. for ‘jumping’, 13. for ‘stepper’, or 9. for ‘walking’ + y = torch.tensor(data[:, 3:], dtype=torch.float) + else: + y = None + + data = torch_geometric.data.Data(x=x, y=y, pos=pos, complex_dim=0) + return data + + +def load_random_points( + dim: int, num_classes: int, num_samples: int, seed: int = 42 +) -> torch_geometric.data.Data: + """Create a random point cloud dataset.""" + rng = np.random.default_rng(seed) + + points = torch.tensor(rng.random((num_samples, dim)), dtype=torch.float) + classes = torch.tensor( + rng.integers(num_classes, size=num_samples), dtype=torch.long + ) + features = torch.tensor(rng.integers(2, size=(num_samples, 1)), dtype=torch.float) + + data = torch_geometric.data.Data(x=features, y=classes, pos=points, complex_dim=0) + return data diff --git a/modules/utils/utils.py b/modules/utils/utils.py index 1dfcdc2e..ca590307 100644 --- a/modules/utils/utils.py +++ b/modules/utils/utils.py @@ -133,10 +133,10 @@ def describe_data(dataset: torch_geometric.data.Dataset, idx_sample: int = 0): features_dim.append(data.x.shape[1]) else: raise ValueError("Data object does not contain any vertices/points.") - if hasattr(data, "num_edges"): + if hasattr(data, "num_edges") and data.num_edges: complex_dim.append(data.num_edges) features_dim.append(data.num_edge_features) - elif hasattr(data, "edge_index"): + elif hasattr(data, "edge_index") and data.edge_index: complex_dim.append(data.edge_index.shape[1]) features_dim.append(data.edge_attr.shape[1]) # Check if the data object contains hyperedges @@ -149,6 +149,15 @@ def describe_data(dataset: torch_geometric.data.Dataset, idx_sample: int = 0): if complex_dim[0] < 50: plot_manual_graph(data) + # Plot point cloud if it is not too large + if ( + complex_dim[0] < 10_000 + and len(complex_dim) == 1 + and not hyperedges + and data.pos.shape[1] in [2, 3] + ): + plot_point_cloud(data) + if hyperedges: print( f" - Hypergraph with {complex_dim[0]} vertices and {hyperedges} hyperedges." @@ -166,7 +175,7 @@ def describe_data(dataset: torch_geometric.data.Dataset, idx_sample: int = 0): ) print(f" - Features dimensions: {features_dim}") # Check if there are isolated nodes - if hasattr(data, "edge_index") and hasattr(data, "x"): + if hasattr(data, "edge_index") and hasattr(data, "x") and data.edge_index: connected_nodes = torch.unique(data.edge_index) isolated_nodes = [] for i in range(data.x.shape[0]): @@ -180,6 +189,51 @@ def describe_data(dataset: torch_geometric.data.Dataset, idx_sample: int = 0): print("") +def plot_point_cloud(data, title=None): + """Plot point cloud data. + + Parameters + ---------- + data : torch_geometric.data.Data + Data object containing the point cloud. + title: str + Title for the plot. + """ + + if not hasattr(data, "pos"): + raise ValueError("Must have a pos attribute to plot point cloud data.") + + if len(data.pos.shape) != 2: + raise ValueError( + f"pos tensor should have 2 dimensions, found {len(data.pos.shape)}" + ) + + if data.pos.shape[1] == 3: + dim = 2 + x = data.pos[:, 0] + y = data.pos[:, 1] + z = data.pos[:, 2] + fig = plt.figure(figsize=(8, 8)) + ax = fig.add_subplot(111, projection="3d") + ax.scatter(x, y, z) + plt.show() + elif data.pos.shape[1] == 2: + dim = 3 + x = data.pos[:, 0] + y = data.pos[:, 1] + fig = plt.figure(figsize=(8, 8)) + ax = fig.add_subplot(111) + ax.scatter(x, y) + else: + raise ValueError("Only 2 and 3 dimensional point cloud data can be plotted") + + if title is not None: + ax.set_title(title) + else: + ax.set_title(f"{dim}D Point Cloud") + plt.show() + + def plot_manual_graph(data, title=None): r"""Plot a manual graph. If lifted, the plot shows the inferred higher-order structures (bipartite graph for hyperedges, diff --git a/tutorials/pointcloud2simplicial/point_cloud_complex_lifting.ipynb b/tutorials/pointcloud2simplicial/point_cloud_complex_lifting.ipynb new file mode 100644 index 00000000..42a983b6 --- /dev/null +++ b/tutorials/pointcloud2simplicial/point_cloud_complex_lifting.ipynb @@ -0,0 +1,352 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Point Cloud-to-Simplicial Alpha Complex Lifting Tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "This notebook shows how to import a dataset, with the desired lifting, and how to run a neural network using the loaded data.\n", + "\n", + "The notebook is divided into sections:\n", + "\n", + "- [Loading the dataset](#loading-the-dataset) loads the config files for the data and the desired tranformation, createsa a dataset object and visualizes it.\n", + "- [Loading and applying the lifting](#loading-and-applying-the-lifting) defines a simple neural network to test that the lifting creates the expected incidence matrices.\n", + "- [Create and run a simplicial nn model](#create-and-run-a-simplicial-nn-model) simply runs a forward pass of the model to check that everything is working as expected.\n", + "\n", + "***\n", + "***\n", + "\n", + "For simplicity the notebook is setup to use a random point cloud. However, there is a set of available datasets that you can play with from the gudhi python library.\n", + "\n", + "To switch to one of the available datasets, simply change the *dataset_name* variable in [Dataset config](#dataset-config) to one of the following names:\n", + "\n", + "* gudhi_sphere\n", + "* gudhi_torus\n", + "* gudhi_bunny\n", + "* gudhi_spiral_2d\n", + "* gudhi_daily_activities\n", + "\n", + "Please see the gudhi documentation [1] for a description of these datasets and the relevant config options\n", + "\n", + "[[1]](https://gudhi.inria.fr/python/latest/index.html) GUDHI Python documentation\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports and utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# With this cell any imported module is reloaded before each cell execution\n", + "%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": "markdown", + "metadata": {}, + "source": [ + "## Loading the Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we just need to spicify the name of the available dataset that we want to load. First, the dataset config is read from the corresponding yaml file (located at `/configs/datasets/` directory), and then the data is loaded via the implemented `Loaders`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset configuration for gudhi_daily_activities:\n", + "\n", + "{'data_domain': 'pointcloud',\n", + " 'data_type': 'gudhi',\n", + " 'data_name': 'gudhi_daily_activities',\n", + " 'data_dir': 'datasets/pointcloud/gudhi',\n", + " 'task': 'regression',\n", + " 'loss_type': 'mse',\n", + " 'monitor_metric': 'mae'}\n" + ] + } + ], + "source": [ + "dataset_name = \"gudhi_daily_activities\"\n", + "dataset_config = load_dataset_config(dataset_name)\n", + "dataset_config[\"n_samples\"] = 900\n", + "loader = PointCloudLoader(dataset_config)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then access to the data through the `load()`method:" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The 'daily and sports activities' dataset comes from the UC Irvine Machine Learning Repository https://archive.ics.uci.edu/ml/datasets/daily+and+sports+activities\n", + "This dataset is licensed under a Creative Commons Attribution 4.0 International (CC BY 4.0) license.\n", + "\n", + "\n", + "Dataset only contains 1 sample:\n", + " - Set with 30000 points.\n", + " - Features dimension: 0\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing...\n", + "Done!\n" + ] + } + ], + "source": [ + "dataset = loader.load()\n", + "describe_data(dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading and Applying the Lifting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section we will instantiate the lifting we want to apply to the data. For this example the clique lifting was chosen. For a clique of n nodes the algorithm for $m=3,...,max(n, complex\\_dim)$ will create simplicials for every possible combinations containing m nodes of the clique. $complex\\_dim$ is a parameter of the lifting. This is a deterministic lifting, based on connectivity, that does not modify the initial connectivity of the graph. The problem of extracting all the cliques in a graph is NP-hard, on in some formulaitons NP-complete (clique decision problem). The computational complexity of this algorithm is $O(n^k k^2)$[[1]](https://www.sciencedirect.com/science/article/pii/S0019995885800413), where $n$ is the number of nodes in the graph and $k$ is the highest clique dimension considered.\n", + "\n", + "***\n", + "[[1]](https://www.sciencedirect.com/science/article/pii/S0019995885800413) Cook, S. A. (1985). A taxonomy of problems with fast parallel algorithms. Information and control, 64(1-3), 2-22.\n", + "***\n", + "\n", + "For simplicial complexes creating a lifting involves creating a `SimplicialComplex` object from topomodelx and adding simplices to it using the method `add_simplices_from`. The `SimplicialComplex` class then takes care of creating all the needed matrices.\n", + "\n", + "Similarly to before, we can specify the transformation we want to apply through its type and id --the correxponding config files located at `/configs/transforms`. \n", + "\n", + "Note that the *tranform_config* dictionary generated below can contain a sequence of tranforms if it is needed.\n", + "\n", + "This can also be used to explore liftings from one topological domain to another, for example using two liftings it is possible to achieve a sequence such as: graph -> simplicial complex -> hypergraph. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Transform configuration for graph2simplicial/clique_lifting:\n", + "\n", + "{'transform_type': 'lifting',\n", + " 'transform_name': 'SimplicialCliqueLifting',\n", + " 'complex_dim': 3,\n", + " 'preserve_edge_attr': False,\n", + " 'signed': True,\n", + " 'feature_lifting': 'ProjectionSum'}\n" + ] + } + ], + "source": [ + "# Define transformation type and id\n", + "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 = \"graph2simplicial/clique_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", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We than apply the transform via our `PreProcesor`:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transform parameters are the same, using existing data_dir: /Users/leone/Desktop/PhD-S/projects/challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/2744620725\n", + "\n", + "Dataset only contains 1 sample:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "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 13 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 6 2-cells.\n", + " - The 2-cells have features dimension 1\n", + " - The complex has 1 3-cells.\n", + " - The 3-cells have features dimension 1\n", + "\n" + ] + } + ], + "source": [ + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create and Run a Simplicial NN Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section a simple model is created to test that the used lifting works as intended. In this case the model uses the `up_laplacian_1` and the `down_laplacian_1` so the lifting should make sure to add them to the data." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "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)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "y_hat = model(lifted_dataset.get(0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is correct the cell above should execute without errors. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.11.3 ('topox')", + "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" + }, + "vscode": { + "interpreter": { + "hash": "5209ee787340d6caf238f8c0093dc78889cb331b3f459734c35c70f07b690b2a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 3acd1a2e391b2436d36a2d5562e29de7abe6de78 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 29 Jun 2024 16:37:55 -0400 Subject: [PATCH 02/15] fix --- modules/data/utils/utils.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/modules/data/utils/utils.py b/modules/data/utils/utils.py index c61342c3..bdea1334 100755 --- a/modules/data/utils/utils.py +++ b/modules/data/utils/utils.py @@ -473,8 +473,8 @@ def load_gudhi_dataset( pos = torch.tensor(points_data, dtype=torch.float) if feature_generator: - x = feature_generator(points) - if x.shape[0] != points.shape[0]: + x = feature_generator(pos) + if x.shape[0] != pos.shape[0]: raise ValueError( "feature_generator must not change first dimension of points data." ) @@ -482,8 +482,8 @@ def load_gudhi_dataset( x = None if target_generator: - y = target_generator(points) - if y.shape[0] != points.shape[0]: + y = target_generator(pos) + if y.shape[0] != pos.shape[0]: raise ValueError( "target_generator must not change first dimension of points data." ) From 447074895f4dd8ed47692b7a6e99ccc937f69e96 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 29 Jun 2024 17:35:12 -0400 Subject: [PATCH 03/15] add manual dataset and fix configs --- configs/datasets/manual_points.yaml | 12 ++++++++++++ configs/datasets/random_points.yaml | 1 + .../alpha_complex_lifting.yaml | 7 +++++++ modules/data/load/loaders.py | 3 +++ modules/data/utils/utils.py | 18 ++++++++++++++++++ modules/utils/utils.py | 6 +++--- 6 files changed, 44 insertions(+), 3 deletions(-) create mode 100644 configs/datasets/manual_points.yaml create mode 100644 configs/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.yaml diff --git a/configs/datasets/manual_points.yaml b/configs/datasets/manual_points.yaml new file mode 100644 index 00000000..be137fc8 --- /dev/null +++ b/configs/datasets/manual_points.yaml @@ -0,0 +1,12 @@ +data_domain: pointcloud +data_type: toy_dataset +data_name: manual_points +data_dir: datasets/${data_domain}/${data_type} + +# Dataset parameters +dim: 2 +num_classes: 2 +num_samples: 7 +num_features: 2 +task: classification +loss_type: cross_entropy \ No newline at end of file diff --git a/configs/datasets/random_points.yaml b/configs/datasets/random_points.yaml index ff1dbb93..f6f22524 100644 --- a/configs/datasets/random_points.yaml +++ b/configs/datasets/random_points.yaml @@ -7,5 +7,6 @@ data_dir: datasets/${data_domain}/${data_type} dim: 3 num_classes: 2 num_samples: 1000 +num_features: 1 task: classification loss_type: cross_entropy \ No newline at end of file diff --git a/configs/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.yaml b/configs/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.yaml new file mode 100644 index 00000000..6b8771a5 --- /dev/null +++ b/configs/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.yaml @@ -0,0 +1,7 @@ +transform_type: 'lifting' +transform_name: "AlphaComplexLifting" +complex_dim: 3 +alpha: 25.0 +preserve_edge_attr: False +signed: True +feature_lifting: ProjectionSum diff --git a/modules/data/load/loaders.py b/modules/data/load/loaders.py index ef3d2705..6e8a7b7e 100755 --- a/modules/data/load/loaders.py +++ b/modules/data/load/loaders.py @@ -15,6 +15,7 @@ load_gudhi_dataset, load_hypergraph_pickle_dataset, load_manual_graph, + load_manual_points, load_random_points, load_simplicial_dataset, ) @@ -263,6 +264,8 @@ def load(self) -> torch_geometric.data.Dataset: num_classes=self.parameters["num_classes"], num_samples=self.parameters["num_samples"], ) + elif self.parameters.data_name == "manual_points": + data = load_manual_points() else: raise NotImplementedError( f"Dataset {self.parameters.data_name} not implemented" diff --git a/modules/data/utils/utils.py b/modules/data/utils/utils.py index bdea1334..d8c2aa9e 100755 --- a/modules/data/utils/utils.py +++ b/modules/data/utils/utils.py @@ -512,3 +512,21 @@ def load_random_points( data = torch_geometric.data.Data(x=features, y=classes, pos=points, complex_dim=0) return data + + +def load_manual_points(): + pos = torch.tensor( + [ + [1.0, 1.0], + [7.0, 0.0], + [4.0, 6.0], + [9.0, 6.0], + [0.0, 14.0], + [2.0, 19.0], + [9.0, 17.0], + ], + dtype=torch.float, + ) + x = torch.ones_like(pos, dtype=torch.float) + y = torch.randint(0, 2, (pos.shape[0],), dtype=torch.float) + return torch_geometric.data.Data(x=x, y=y, pos=pos, complex_dim=0) diff --git a/modules/utils/utils.py b/modules/utils/utils.py index ca590307..7a1e9275 100644 --- a/modules/utils/utils.py +++ b/modules/utils/utils.py @@ -146,7 +146,7 @@ def describe_data(dataset: torch_geometric.data.Dataset, idx_sample: int = 0): hyperedges_features_dim = data.x_hyperedges.shape[1] # Plot the graph if it is not too large - if complex_dim[0] < 50: + if complex_dim[0] < 50 and len(complex_dim) != 1: plot_manual_graph(data) # Plot point cloud if it is not too large @@ -209,7 +209,7 @@ def plot_point_cloud(data, title=None): ) if data.pos.shape[1] == 3: - dim = 2 + dim = 3 x = data.pos[:, 0] y = data.pos[:, 1] z = data.pos[:, 2] @@ -218,7 +218,7 @@ def plot_point_cloud(data, title=None): ax.scatter(x, y, z) plt.show() elif data.pos.shape[1] == 2: - dim = 3 + dim = 2 x = data.pos[:, 0] y = data.pos[:, 1] fig = plt.figure(figsize=(8, 8)) From 59eaca5e0031dffbade654850ecffd4e230825e5 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 29 Jun 2024 17:35:37 -0400 Subject: [PATCH 04/15] add alpha complex --- modules/transforms/data_transform.py | 5 + .../alpha_complex_lifting.py | 43 +++ .../liftings/pointcloud2simplicial/base.py | 18 + .../alpha_complex_lifting.ipynb | 364 ++++++++++++++++++ .../point_cloud_complex_lifting.ipynb | 352 ----------------- 5 files changed, 430 insertions(+), 352 deletions(-) create mode 100644 modules/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.py create mode 100644 tutorials/pointcloud2simplicial/alpha_complex_lifting.ipynb delete mode 100644 tutorials/pointcloud2simplicial/point_cloud_complex_lifting.ipynb diff --git a/modules/transforms/data_transform.py b/modules/transforms/data_transform.py index 59253ecf..4376966c 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.alpha_complex_lifting import ( + AlphaComplexLifting, +) TRANSFORMS = { # Graph -> Hypergraph @@ -23,6 +26,8 @@ "SimplicialCliqueLifting": SimplicialCliqueLifting, # Graph -> Cell Complex "CellCycleLifting": CellCycleLifting, + # Point Cloud -> Simplicial Complex, + "AlphaComplexLifting": AlphaComplexLifting, # Feature Liftings "ProjectionSum": ProjectionSum, # Data Manipulations diff --git a/modules/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.py b/modules/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.py new file mode 100644 index 00000000..5dc06516 --- /dev/null +++ b/modules/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.py @@ -0,0 +1,43 @@ +import gudhi +import torch_geometric +from toponetx.classes import SimplicialComplex + +from modules.transforms.liftings.pointcloud2simplicial.base import ( + PointCloud2SimplicialLifting, +) + + +class AlphaComplexLifting(PointCloud2SimplicialLifting): + r"""Lifts point clouds to simplicial complex domain by generating the alpha complex using the Gudhi library. The alpha complex is a simplicial complex constructed from the finite cells of a Delaunay Triangulation. It has the same persistent homology as the Čech complex and is significantly smaller. + + Parameters + ---------- + **kwargs : optional + Additional arguments for the class. + """ + + def __init__(self, alpha: float, **kwargs): + self.alpha = alpha + super().__init__(**kwargs) + + def lift_topology(self, data: torch_geometric.data.Data) -> dict: + r"""Lifts the topology of a point cloud to the alpha complex. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data to be lifted. + + Returns + ------- + dict + The lifted topology. + """ + ac = gudhi.AlphaComplex(data.pos) + stree = ac.create_simplex_tree() + stree.prune_above_filtration(self.alpha) + stree.prune_above_dimension(self.complex_dim) + sc = SimplicialComplex(s for s, filtration_value in stree.get_simplices()) + lifted_topolgy = self._get_lifted_topology(sc) + lifted_topolgy["x_0"] = data.x + return lifted_topolgy diff --git a/modules/transforms/liftings/pointcloud2simplicial/base.py b/modules/transforms/liftings/pointcloud2simplicial/base.py index fddfaf17..88c3137f 100755 --- a/modules/transforms/liftings/pointcloud2simplicial/base.py +++ b/modules/transforms/liftings/pointcloud2simplicial/base.py @@ -1,3 +1,6 @@ +from toponetx.classes import SimplicialComplex + +from modules.data.utils.utils import get_complex_connectivity from modules.transforms.liftings.lifting import PointCloudLifting @@ -12,6 +15,21 @@ class PointCloud2SimplicialLifting(PointCloudLifting): Additional arguments for the class. """ + 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, self.complex_dim) + return lifted_topology + def __init__(self, complex_dim=2, **kwargs): super().__init__(**kwargs) self.complex_dim = complex_dim diff --git a/tutorials/pointcloud2simplicial/alpha_complex_lifting.ipynb b/tutorials/pointcloud2simplicial/alpha_complex_lifting.ipynb new file mode 100644 index 00000000..603674b6 --- /dev/null +++ b/tutorials/pointcloud2simplicial/alpha_complex_lifting.ipynb @@ -0,0 +1,364 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Point Cloud-to-Simplicial Alpha Complex Lifting Tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "This notebook shows how to import a dataset, with the desired lifting, and how to run a neural network using the loaded data.\n", + "\n", + "The notebook is divided into sections:\n", + "\n", + "- [Loading the dataset](#loading-the-dataset) loads the config files for the data and the desired tranformation, createsa a dataset object and visualizes it.\n", + "- [Loading and applying the lifting](#loading-and-applying-the-lifting) defines a simple neural network to test that the lifting creates the expected incidence matrices.\n", + "- [Create and run a simplicial nn model](#create-and-run-a-simplicial-nn-model) simply runs a forward pass of the model to check that everything is working as expected.\n", + "\n", + "***\n", + "***\n", + "\n", + "There is a set of available datasets that you can play with from the gudhi python library.\n", + "\n", + "To switch to one of the available datasets, simply change the *dataset_name* variable in [Dataset config](#dataset-config) to one of the following names:\n", + "\n", + "* gudhi_sphere\n", + "* gudhi_torus\n", + "* gudhi_bunny\n", + "* gudhi_spiral_2d\n", + "* gudhi_daily_activities\n", + "\n", + "Please see the gudhi documentation [1] for a description of these datasets and the relevant config options. Note that *all datasets except gudhi_daily_activities lack features and targets*. You must instead provide a feature_generator target_generator in the PointCloudLoader\n", + "\n", + "[[1]](https://gudhi.inria.fr/python/latest/index.html) GUDHI Python documentation\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports and utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# With this cell any imported module is reloaded before each cell execution\n", + "%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": "markdown", + "metadata": {}, + "source": [ + "## Loading the Dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we just need to spicify the name of the available dataset that we want to load. First, the dataset config is read from the corresponding yaml file (located at `/configs/datasets/` directory), and then the data is loaded via the implemented `Loaders`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset configuration for manual_points:\n", + "\n", + "{'data_domain': 'pointcloud',\n", + " 'data_type': 'toy_dataset',\n", + " 'data_name': 'manual_points',\n", + " 'data_dir': 'datasets/pointcloud/toy_dataset',\n", + " 'dim': 2,\n", + " 'num_classes': 2,\n", + " 'num_samples': 7,\n", + " 'num_features': 2,\n", + " 'task': 'classification',\n", + " 'loss_type': 'cross_entropy'}\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "dataset_name = \"manual_points\"\n", + "dataset_config = load_dataset_config(dataset_name)\n", + "\n", + "# Note that some point cloud datasets may not have features or targets\n", + "# In this case you must provide the feature_generator and target_generator methods yourself!\n", + "loader = PointCloudLoader(dataset_config)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then access to the data through the `load()`method:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset only contains 1 sample:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Set with 7 points.\n", + " - Features dimension: 2\n", + "\n" + ] + } + ], + "source": [ + "dataset = loader.load()\n", + "describe_data(dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading and Applying the Lifting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section we will instantiate the lifting we want to apply to the data. For this example the alpha complex lifting was chosen. The alpha complex is a subcomplex of the Delaunay triangulation [1]. It is generated by filtering the simplices of the Delaunay triangulation such that only those with diameter less than $\\alpha^2$ are retained. The GUDHI library is used to compute the complex [2].\n", + "\n", + "---\n", + "[[1]](https://en.wikipedia.org/wiki/Delaunay_triangulation) Delauny Triangulation Wikipedia\n", + "[[2]](https://gudhi.inria.fr/python/latest/alpha_complex_user.html#) Gudhi Alpha Complex User Manual\n", + "\n", + "---\n", + "\n", + "For simplicial complexes creating a lifting involves creating a `SimplicialComplex` object from topomodelx and adding simplices to it using the method `add_simplices_from`. The `SimplicialComplex` class then takes care of creating all the needed matrices.\n", + "\n", + "Similarly to before, we can specify the transformation we want to apply through its type and id --the correxponding config files located at `/configs/transforms`. \n", + "\n", + "Note that the *tranform_config* dictionary generated below can contain a sequence of tranforms if it is needed.\n", + "\n", + "This can also be used to explore liftings from one topological domain to another, for example using two liftings it is possible to achieve a sequence such as: graph -> simplicial complex -> hypergraph. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Transform configuration for pointcloud2simplicial/alpha_complex_lifting:\n", + "\n", + "{'transform_type': 'lifting',\n", + " 'transform_name': 'AlphaComplexLifting',\n", + " 'complex_dim': 3,\n", + " 'alpha': 25.0,\n", + " 'preserve_edge_attr': False,\n", + " 'signed': True,\n", + " 'feature_lifting': 'ProjectionSum'}\n" + ] + } + ], + "source": [ + "# Define transformation type and id\n", + "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/alpha_complex_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", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We than apply the transform via our `PreProcesor`:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transform parameters are the same, using existing data_dir: /Users/tlong/Documents/code/challenge-icml-2024/datasets/pointcloud/toy_dataset/manual_points/lifting/3217688758\n", + "\n", + "Dataset only contains 1 sample:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 7 0-cells.\n", + " - The 0-cells have features dimension 2\n", + " - The complex has 9 1-cells.\n", + " - The 1-cells have features dimension 2\n", + " - The complex has 3 2-cells.\n", + " - The 2-cells have features dimension 2\n", + "\n" + ] + } + ], + "source": [ + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create and Run a Simplicial NN Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section a simple model is created to test that the used lifting works as intended. In this case the model uses the `up_laplacian_1` and the `down_laplacian_1` so the lifting should make sure to add them to the data." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "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", + "model = SANModel(model_config, dataset_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "y_hat = model(lifted_dataset.get(0))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is correct the cell above should execute without errors. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.11.3 ('topox')", + "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" + }, + "vscode": { + "interpreter": { + "hash": "5209ee787340d6caf238f8c0093dc78889cb331b3f459734c35c70f07b690b2a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/pointcloud2simplicial/point_cloud_complex_lifting.ipynb b/tutorials/pointcloud2simplicial/point_cloud_complex_lifting.ipynb deleted file mode 100644 index 42a983b6..00000000 --- a/tutorials/pointcloud2simplicial/point_cloud_complex_lifting.ipynb +++ /dev/null @@ -1,352 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Point Cloud-to-Simplicial Alpha Complex Lifting Tutorial" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "***\n", - "This notebook shows how to import a dataset, with the desired lifting, and how to run a neural network using the loaded data.\n", - "\n", - "The notebook is divided into sections:\n", - "\n", - "- [Loading the dataset](#loading-the-dataset) loads the config files for the data and the desired tranformation, createsa a dataset object and visualizes it.\n", - "- [Loading and applying the lifting](#loading-and-applying-the-lifting) defines a simple neural network to test that the lifting creates the expected incidence matrices.\n", - "- [Create and run a simplicial nn model](#create-and-run-a-simplicial-nn-model) simply runs a forward pass of the model to check that everything is working as expected.\n", - "\n", - "***\n", - "***\n", - "\n", - "For simplicity the notebook is setup to use a random point cloud. However, there is a set of available datasets that you can play with from the gudhi python library.\n", - "\n", - "To switch to one of the available datasets, simply change the *dataset_name* variable in [Dataset config](#dataset-config) to one of the following names:\n", - "\n", - "* gudhi_sphere\n", - "* gudhi_torus\n", - "* gudhi_bunny\n", - "* gudhi_spiral_2d\n", - "* gudhi_daily_activities\n", - "\n", - "Please see the gudhi documentation [1] for a description of these datasets and the relevant config options\n", - "\n", - "[[1]](https://gudhi.inria.fr/python/latest/index.html) GUDHI Python documentation\n", - "***" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Imports and utilities" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# With this cell any imported module is reloaded before each cell execution\n", - "%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": "markdown", - "metadata": {}, - "source": [ - "## Loading the Dataset" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we just need to spicify the name of the available dataset that we want to load. First, the dataset config is read from the corresponding yaml file (located at `/configs/datasets/` directory), and then the data is loaded via the implemented `Loaders`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Dataset configuration for gudhi_daily_activities:\n", - "\n", - "{'data_domain': 'pointcloud',\n", - " 'data_type': 'gudhi',\n", - " 'data_name': 'gudhi_daily_activities',\n", - " 'data_dir': 'datasets/pointcloud/gudhi',\n", - " 'task': 'regression',\n", - " 'loss_type': 'mse',\n", - " 'monitor_metric': 'mae'}\n" - ] - } - ], - "source": [ - "dataset_name = \"gudhi_daily_activities\"\n", - "dataset_config = load_dataset_config(dataset_name)\n", - "dataset_config[\"n_samples\"] = 900\n", - "loader = PointCloudLoader(dataset_config)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can then access to the data through the `load()`method:" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The 'daily and sports activities' dataset comes from the UC Irvine Machine Learning Repository https://archive.ics.uci.edu/ml/datasets/daily+and+sports+activities\n", - "This dataset is licensed under a Creative Commons Attribution 4.0 International (CC BY 4.0) license.\n", - "\n", - "\n", - "Dataset only contains 1 sample:\n", - " - Set with 30000 points.\n", - " - Features dimension: 0\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Processing...\n", - "Done!\n" - ] - } - ], - "source": [ - "dataset = loader.load()\n", - "describe_data(dataset)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Loading and Applying the Lifting" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In this section we will instantiate the lifting we want to apply to the data. For this example the clique lifting was chosen. For a clique of n nodes the algorithm for $m=3,...,max(n, complex\\_dim)$ will create simplicials for every possible combinations containing m nodes of the clique. $complex\\_dim$ is a parameter of the lifting. This is a deterministic lifting, based on connectivity, that does not modify the initial connectivity of the graph. The problem of extracting all the cliques in a graph is NP-hard, on in some formulaitons NP-complete (clique decision problem). The computational complexity of this algorithm is $O(n^k k^2)$[[1]](https://www.sciencedirect.com/science/article/pii/S0019995885800413), where $n$ is the number of nodes in the graph and $k$ is the highest clique dimension considered.\n", - "\n", - "***\n", - "[[1]](https://www.sciencedirect.com/science/article/pii/S0019995885800413) Cook, S. A. (1985). A taxonomy of problems with fast parallel algorithms. Information and control, 64(1-3), 2-22.\n", - "***\n", - "\n", - "For simplicial complexes creating a lifting involves creating a `SimplicialComplex` object from topomodelx and adding simplices to it using the method `add_simplices_from`. The `SimplicialComplex` class then takes care of creating all the needed matrices.\n", - "\n", - "Similarly to before, we can specify the transformation we want to apply through its type and id --the correxponding config files located at `/configs/transforms`. \n", - "\n", - "Note that the *tranform_config* dictionary generated below can contain a sequence of tranforms if it is needed.\n", - "\n", - "This can also be used to explore liftings from one topological domain to another, for example using two liftings it is possible to achieve a sequence such as: graph -> simplicial complex -> hypergraph. " - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Transform configuration for graph2simplicial/clique_lifting:\n", - "\n", - "{'transform_type': 'lifting',\n", - " 'transform_name': 'SimplicialCliqueLifting',\n", - " 'complex_dim': 3,\n", - " 'preserve_edge_attr': False,\n", - " 'signed': True,\n", - " 'feature_lifting': 'ProjectionSum'}\n" - ] - } - ], - "source": [ - "# Define transformation type and id\n", - "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 = \"graph2simplicial/clique_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", - "}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We than apply the transform via our `PreProcesor`:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transform parameters are the same, using existing data_dir: /Users/leone/Desktop/PhD-S/projects/challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/2744620725\n", - "\n", - "Dataset only contains 1 sample:\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "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 13 1-cells.\n", - " - The 1-cells have features dimension 1\n", - " - The complex has 6 2-cells.\n", - " - The 2-cells have features dimension 1\n", - " - The complex has 1 3-cells.\n", - " - The 3-cells have features dimension 1\n", - "\n" - ] - } - ], - "source": [ - "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", - "describe_data(lifted_dataset)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Create and Run a Simplicial NN Model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In this section a simple model is created to test that the used lifting works as intended. In this case the model uses the `up_laplacian_1` and the `down_laplacian_1` so the lifting should make sure to add them to the data." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "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)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "y_hat = model(lifted_dataset.get(0))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If everything is correct the cell above should execute without errors. " - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.11.3 ('topox')", - "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" - }, - "vscode": { - "interpreter": { - "hash": "5209ee787340d6caf238f8c0093dc78889cb331b3f459734c35c70f07b690b2a" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From cfa47e4d4aaf7aa79868e9e3efcf274b9a4d7ea7 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 29 Jun 2024 17:35:43 -0400 Subject: [PATCH 05/15] add tests --- .../test_alpha_complex_lifting.py | 65 +++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 test/transforms/liftings/pointcloud2simplicial/test_alpha_complex_lifting.py diff --git a/test/transforms/liftings/pointcloud2simplicial/test_alpha_complex_lifting.py b/test/transforms/liftings/pointcloud2simplicial/test_alpha_complex_lifting.py new file mode 100644 index 00000000..0fe8af35 --- /dev/null +++ b/test/transforms/liftings/pointcloud2simplicial/test_alpha_complex_lifting.py @@ -0,0 +1,65 @@ +"""Test the alpha complex lifting.""" + +import torch + +from modules.data.utils.utils import load_manual_points +from modules.transforms.liftings.pointcloud2simplicial.alpha_complex_lifting import ( + AlphaComplexLifting, +) + + +class TestSimplicialCliqueLifting: + """Test the SimplicialCliqueLifting class.""" + + def setup_method(self): + # Load the graph + self.data = load_manual_points() + + # Initialise the SimplicialCliqueLifting class + self.lifting = AlphaComplexLifting(complex_dim=3, alpha=25.0) + + def test_lift_topology(self): + """Test the lift_topology method.""" + + # Test the lift_topology method + lifted_data = self.lifting.forward(self.data.clone()) + + expected_incidence_1 = torch.tensor( + [ + [1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], + ] + ) + + assert ( + expected_incidence_1 == lifted_data.incidence_1.to_dense() + ).all(), "Something is wrong with incidence_1 (nodes to edges)." + + expected_incidence_2 = torch.tensor( + [ + [1.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 1.0], + [0.0, 0.0, 1.0], + [0.0, 0.0, 1.0], + ] + ) + + assert ( + abs(expected_incidence_2) == lifted_data.incidence_2.to_dense() + ).all(), "Something is wrong with incidence_2 (edges to triangles)." + + expected_incidence_3 = torch.tensor([]) + + assert ( + abs(expected_incidence_3) == lifted_data.incidence_3.to_dense() + ).all(), "Something is wrong with incidence_3 (triangles to tetrahedrons)." From 2b377677d92229e3c71ba1a7f16172df10845a35 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 29 Jun 2024 17:45:46 -0400 Subject: [PATCH 06/15] ruff fixes --- modules/data/load/loaders.py | 6 +++--- modules/data/utils/utils.py | 14 ++++++-------- .../liftings/pointcloud2simplicial/base.py | 3 +-- .../alpha_complex_lifting.ipynb | 2 -- 4 files changed, 10 insertions(+), 15 deletions(-) diff --git a/modules/data/load/loaders.py b/modules/data/load/loaders.py index 6e8a7b7e..291fe023 100755 --- a/modules/data/load/loaders.py +++ b/modules/data/load/loaders.py @@ -1,5 +1,5 @@ import os -from typing import Callable, Optional +from collections.abc import Callable import numpy as np import rootutils @@ -227,8 +227,8 @@ class PointCloudLoader(AbstractLoader): def __init__( self, parameters: DictConfig, - feature_generator: Optional[Callable[[torch.Tensor], torch.Tensor]] = None, - target_generator: Optional[Callable[[torch.Tensor], torch.Tensor]] = None, + feature_generator: Callable[[torch.Tensor], torch.Tensor] | None = None, + target_generator: Callable[[torch.Tensor], torch.Tensor] | None = None, ): self.feature_generator = feature_generator self.target_generator = target_generator diff --git a/modules/data/utils/utils.py b/modules/data/utils/utils.py index d8c2aa9e..fd2aefec 100755 --- a/modules/data/utils/utils.py +++ b/modules/data/utils/utils.py @@ -1,7 +1,7 @@ import hashlib import os.path as osp import pickle -from typing import Callable, Optional +from collections.abc import Callable import networkx as nx import numpy as np @@ -431,8 +431,8 @@ def make_hash(o): def load_gudhi_dataset( cfg: omegaconf.DictConfig, - feature_generator: Optional[Callable[[torch.Tensor], torch.Tensor]] = None, - target_generator: Optional[Callable[[torch.Tensor], torch.Tensor]] = None, + feature_generator: Callable[[torch.Tensor], torch.Tensor] | None = None, + target_generator: Callable[[torch.Tensor], torch.Tensor] | None = None, ) -> torch_geometric.data.Data: """Load a dataset from the gudhi.datasets module.""" if not cfg.data_name.startswith("gudhi_"): @@ -489,13 +489,12 @@ def load_gudhi_dataset( ) elif gudhi_dataset_name == "daily_activities": # Target is the activity type - # 14. for ‘cross_training’, 18. for ‘jumping’, 13. for ‘stepper’, or 9. for ‘walking’ + # 14. for 'cross_training', 18. for 'jumping', 13. for 'stepper', or 9. for 'walking' y = torch.tensor(data[:, 3:], dtype=torch.float) else: y = None - data = torch_geometric.data.Data(x=x, y=y, pos=pos, complex_dim=0) - return data + return torch_geometric.data.Data(x=x, y=y, pos=pos, complex_dim=0) def load_random_points( @@ -510,8 +509,7 @@ def load_random_points( ) features = torch.tensor(rng.integers(2, size=(num_samples, 1)), dtype=torch.float) - data = torch_geometric.data.Data(x=features, y=classes, pos=points, complex_dim=0) - return data + return torch_geometric.data.Data(x=features, y=classes, pos=points, complex_dim=0) def load_manual_points(): diff --git a/modules/transforms/liftings/pointcloud2simplicial/base.py b/modules/transforms/liftings/pointcloud2simplicial/base.py index 88c3137f..0d1e5031 100755 --- a/modules/transforms/liftings/pointcloud2simplicial/base.py +++ b/modules/transforms/liftings/pointcloud2simplicial/base.py @@ -27,8 +27,7 @@ def _get_lifted_topology(self, simplicial_complex: SimplicialComplex) -> dict: dict The lifted topology. """ - lifted_topology = get_complex_connectivity(simplicial_complex, self.complex_dim) - return lifted_topology + return get_complex_connectivity(simplicial_complex, self.complex_dim) def __init__(self, complex_dim=2, **kwargs): super().__init__(**kwargs) diff --git a/tutorials/pointcloud2simplicial/alpha_complex_lifting.ipynb b/tutorials/pointcloud2simplicial/alpha_complex_lifting.ipynb index 603674b6..1c4f9452 100644 --- a/tutorials/pointcloud2simplicial/alpha_complex_lifting.ipynb +++ b/tutorials/pointcloud2simplicial/alpha_complex_lifting.ipynb @@ -105,8 +105,6 @@ } ], "source": [ - "import torch\n", - "\n", "dataset_name = \"manual_points\"\n", "dataset_config = load_dataset_config(dataset_name)\n", "\n", From 97c37604446ca31a81337694afcb78068d59edd7 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 29 Jun 2024 17:55:14 -0400 Subject: [PATCH 07/15] handle tensor values --- modules/utils/utils.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/modules/utils/utils.py b/modules/utils/utils.py index 7a1e9275..3bbdb385 100644 --- a/modules/utils/utils.py +++ b/modules/utils/utils.py @@ -136,7 +136,7 @@ def describe_data(dataset: torch_geometric.data.Dataset, idx_sample: int = 0): if hasattr(data, "num_edges") and data.num_edges: complex_dim.append(data.num_edges) features_dim.append(data.num_edge_features) - elif hasattr(data, "edge_index") and data.edge_index: + elif hasattr(data, "edge_index") and (data.edge_index is not None): complex_dim.append(data.edge_index.shape[1]) features_dim.append(data.edge_attr.shape[1]) # Check if the data object contains hyperedges @@ -175,7 +175,11 @@ def describe_data(dataset: torch_geometric.data.Dataset, idx_sample: int = 0): ) print(f" - Features dimensions: {features_dim}") # Check if there are isolated nodes - if hasattr(data, "edge_index") and hasattr(data, "x") and data.edge_index: + if ( + hasattr(data, "edge_index") + and hasattr(data, "x") + and (data.edge_index is not None) + ): connected_nodes = torch.unique(data.edge_index) isolated_nodes = [] for i in range(data.x.shape[0]): From 2777da1f6498c7bdb3c886ee6928b3b6f5c0e2b2 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 29 Jun 2024 18:53:43 -0400 Subject: [PATCH 08/15] wip feature-based rips lifting --- .../alpha_complex_lifting.yaml | 7 +- modules/transforms/data_transform.py | 6 +- .../alpha_complex_lifting.py | 43 ---------- .../feature_rips_complex_lifting.py | 80 +++++++++++++++++++ ...y => test_feature_rips_complex_lifting.py} | 12 +-- ...ynb => feature_rips_complex_lifting.ipynb} | 15 ++-- 6 files changed, 103 insertions(+), 60 deletions(-) delete mode 100644 modules/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.py create mode 100644 modules/transforms/liftings/pointcloud2simplicial/feature_rips_complex_lifting.py rename test/transforms/liftings/pointcloud2simplicial/{test_alpha_complex_lifting.py => test_feature_rips_complex_lifting.py} (84%) rename tutorials/pointcloud2simplicial/{alpha_complex_lifting.ipynb => feature_rips_complex_lifting.ipynb} (97%) diff --git a/configs/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.yaml b/configs/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.yaml index 6b8771a5..9aa266c3 100644 --- a/configs/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.yaml +++ b/configs/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.yaml @@ -1,7 +1,8 @@ transform_type: 'lifting' -transform_name: "AlphaComplexLifting" +transform_name: "FeatureRipsComplexLifting" complex_dim: 3 -alpha: 25.0 +feature_percent: 0.2 +max_edge_length: 10.0 +sparse: null preserve_edge_attr: False -signed: True feature_lifting: ProjectionSum diff --git a/modules/transforms/data_transform.py b/modules/transforms/data_transform.py index 4376966c..71c0b552 100755 --- a/modules/transforms/data_transform.py +++ b/modules/transforms/data_transform.py @@ -15,8 +15,8 @@ from modules.transforms.liftings.graph2simplicial.clique_lifting import ( SimplicialCliqueLifting, ) -from modules.transforms.liftings.pointcloud2simplicial.alpha_complex_lifting import ( - AlphaComplexLifting, +from modules.transforms.liftings.pointcloud2simplicial.feature_rips_complex_lifting import ( + FeatureRipsComplexLifting, ) TRANSFORMS = { @@ -27,7 +27,7 @@ # Graph -> Cell Complex "CellCycleLifting": CellCycleLifting, # Point Cloud -> Simplicial Complex, - "AlphaComplexLifting": AlphaComplexLifting, + "FeatureRipsComplexLifting": FeatureRipsComplexLifting, # Feature Liftings "ProjectionSum": ProjectionSum, # Data Manipulations diff --git a/modules/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.py b/modules/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.py deleted file mode 100644 index 5dc06516..00000000 --- a/modules/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.py +++ /dev/null @@ -1,43 +0,0 @@ -import gudhi -import torch_geometric -from toponetx.classes import SimplicialComplex - -from modules.transforms.liftings.pointcloud2simplicial.base import ( - PointCloud2SimplicialLifting, -) - - -class AlphaComplexLifting(PointCloud2SimplicialLifting): - r"""Lifts point clouds to simplicial complex domain by generating the alpha complex using the Gudhi library. The alpha complex is a simplicial complex constructed from the finite cells of a Delaunay Triangulation. It has the same persistent homology as the Čech complex and is significantly smaller. - - Parameters - ---------- - **kwargs : optional - Additional arguments for the class. - """ - - def __init__(self, alpha: float, **kwargs): - self.alpha = alpha - super().__init__(**kwargs) - - def lift_topology(self, data: torch_geometric.data.Data) -> dict: - r"""Lifts the topology of a point cloud to the alpha complex. - - Parameters - ---------- - data : torch_geometric.data.Data - The input data to be lifted. - - Returns - ------- - dict - The lifted topology. - """ - ac = gudhi.AlphaComplex(data.pos) - stree = ac.create_simplex_tree() - stree.prune_above_filtration(self.alpha) - stree.prune_above_dimension(self.complex_dim) - sc = SimplicialComplex(s for s, filtration_value in stree.get_simplices()) - lifted_topolgy = self._get_lifted_topology(sc) - lifted_topolgy["x_0"] = data.x - return lifted_topolgy diff --git a/modules/transforms/liftings/pointcloud2simplicial/feature_rips_complex_lifting.py b/modules/transforms/liftings/pointcloud2simplicial/feature_rips_complex_lifting.py new file mode 100644 index 00000000..36ff4152 --- /dev/null +++ b/modules/transforms/liftings/pointcloud2simplicial/feature_rips_complex_lifting.py @@ -0,0 +1,80 @@ +import gudhi +import torch +import torch_geometric +from toponetx.classes import SimplicialComplex + +from modules.transforms.liftings.pointcloud2simplicial.base import ( + PointCloud2SimplicialLifting, +) + + +class FeatureRipsComplexLifting(PointCloud2SimplicialLifting): + r"""Lifts point clouds to simplicial complex domain by generating the Vietoris-Rips complex using the Gudhi library. This complex is constructed in two steps - first add edges for all pairs of vertices a distance < d away from each other. Then generate the clique complex of the graph. Note that this implementation allows for *feature-based* distances as well - the distance of two nodes is a function of both the position and the features. + + If using feature-based distances, it is recommended that the features be normalized or standardized beforehand. This is because the Euclidean distance of the features will be used directly, so if the scales are wildy different the distances may be dominated by a small number of features with large magnitudes. + + Parameters + ---------- + max_edge_length: float + The maximum pairwise distance to add an edge to the graph + + feature_percent: float + The percentage weight to give the feature-based distance (should be between 0 and 1) + + sparse: float or None. + If float, uses a sparse approximation to the Rips complex to speed up computation. + + **kwargs : optional + Additional arguments for the class. + """ + + def __init__(self, max_edge_length: float, feature_percent: float, **kwargs): + self.feature_percent = feature_percent + self.max_edge_length = max_edge_length + self.sparse = self.sparse + super().__init__(**kwargs) + + def generate_distance_matrix(self, data): + """Generate the pairwise distance matrix of point cloud data, based on both point distances and feature-based distance. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data to be lifted. + + Returns + ------- + torch.tensor + The pairwise distances. + """ + x_expanded_1 = data.x.unsqueeze(1) + x_expanded_2 = data.x.unsqueeze(0) + + # Calculate pairwise differences + feature_differences = x_expanded_1 - x_expanded_2 + + pass + + def lift_topology(self, data: torch_geometric.data.Data) -> dict: + r"""Lifts the topology of a point cloud to the Rips complex based on point-wise and feature-based distances. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data to be lifted. + + Returns + ------- + dict + The lifted topology. + """ + dm = self.generate_distance_matrix(data.pos, data.x) + sc = gudhi.RipsComplex( + distance_matrix=dm, sparse=self.sparse, max_edge_length=self.max_edge_length + ) + stree = sc.create_simplex_tree() + stree.prune_above_dimension(self.complex_dim) + sc = SimplicialComplex(s for s, filtration_value in stree.get_simplices()) + lifted_topolgy = self._get_lifted_topology(sc) + lifted_topolgy["x_0"] = data.x + return lifted_topolgy diff --git a/test/transforms/liftings/pointcloud2simplicial/test_alpha_complex_lifting.py b/test/transforms/liftings/pointcloud2simplicial/test_feature_rips_complex_lifting.py similarity index 84% rename from test/transforms/liftings/pointcloud2simplicial/test_alpha_complex_lifting.py rename to test/transforms/liftings/pointcloud2simplicial/test_feature_rips_complex_lifting.py index 0fe8af35..5ef8ec4d 100644 --- a/test/transforms/liftings/pointcloud2simplicial/test_alpha_complex_lifting.py +++ b/test/transforms/liftings/pointcloud2simplicial/test_feature_rips_complex_lifting.py @@ -1,22 +1,22 @@ -"""Test the alpha complex lifting.""" +"""Test the feature-based Rips complex lifting.""" import torch from modules.data.utils.utils import load_manual_points -from modules.transforms.liftings.pointcloud2simplicial.alpha_complex_lifting import ( - AlphaComplexLifting, +from modules.transforms.liftings.pointcloud2simplicial.feature_rips_complex_lifting import ( + FeatureRipsComplexLifting, ) -class TestSimplicialCliqueLifting: - """Test the SimplicialCliqueLifting class.""" +class TestFeatureRipsComplexLifting: + """Test the FeatureRipsComplexLifting class.""" def setup_method(self): # Load the graph self.data = load_manual_points() # Initialise the SimplicialCliqueLifting class - self.lifting = AlphaComplexLifting(complex_dim=3, alpha=25.0) + self.lifting = FeatureRipsComplexLifting(complex_dim=3, alpha=25.0) def test_lift_topology(self): """Test the lift_topology method.""" diff --git a/tutorials/pointcloud2simplicial/alpha_complex_lifting.ipynb b/tutorials/pointcloud2simplicial/feature_rips_complex_lifting.ipynb similarity index 97% rename from tutorials/pointcloud2simplicial/alpha_complex_lifting.ipynb rename to tutorials/pointcloud2simplicial/feature_rips_complex_lifting.ipynb index 1c4f9452..948da7fa 100644 --- a/tutorials/pointcloud2simplicial/alpha_complex_lifting.ipynb +++ b/tutorials/pointcloud2simplicial/feature_rips_complex_lifting.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Point Cloud-to-Simplicial Alpha Complex Lifting Tutorial" + "# Point Cloud-to-Simplicial Feature-Based Vietoris Rips Complex Lifting Tutorial" ] }, { @@ -169,11 +169,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In this section we will instantiate the lifting we want to apply to the data. For this example the alpha complex lifting was chosen. The alpha complex is a subcomplex of the Delaunay triangulation [1]. It is generated by filtering the simplices of the Delaunay triangulation such that only those with diameter less than $\\alpha^2$ are retained. The GUDHI library is used to compute the complex [2].\n", + "In this section we will instantiate the lifting we want to apply to the data. For this example the Vietoris-Rips (or Rips) complex lifting was chosen. It is generated in two steps - first pairwise distances between points are computed, and for any pair with distance $\\le d$, an edge is added. The simplicial complex is then the clique complex of this graph. \n", + "\n", + "Note that this implementation *includes features* in the pairwise distance. More precisely, the parameter `feature_percent` allows the user to adjust how much weight to give to feature differences in the overall distance. Currently the feature distance is simply the Euclidean distance between feature vectors, which is combined with the usual Euclidean distance to generate the final pairwise distances.\n", + "\n", + "This can be useful in cases where the features correspond to a *signal* on a surface. For example, temperature measurments on the surface of a human body. If your arms are by your side, a naïve point cloud complex might interpret the points in your hand as being very close to those of your torso. However, your hand is in fact quite far since the 'true' distance goes up your arm. The feature-based lifting may be able to distinguish this since the feature values are likely quite different, hence the points will not be connected in the lifting.\n", + "\n", + "The GUDHI library is used to compute the complex [1].\n", "\n", "---\n", - "[[1]](https://en.wikipedia.org/wiki/Delaunay_triangulation) Delauny Triangulation Wikipedia\n", - "[[2]](https://gudhi.inria.fr/python/latest/alpha_complex_user.html#) Gudhi Alpha Complex User Manual\n", + "[[1]](https://gudhi.inria.fr/python/latest/rips_complex_user.htm) Gudhi Rips Complex User Manual\n", "\n", "---\n", "\n", @@ -212,7 +217,7 @@ "# Define transformation type and id\n", "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/alpha_complex_lifting\"\n", + "transform_id = \"pointcloud2simplicial/feature_rips_complex_lifting\"\n", "\n", "# Read yaml file\n", "transform_config = {\n", From 53818eb28616d4b06caa99a0925adcce15a3aa9a Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 6 Jul 2024 19:40:22 -0400 Subject: [PATCH 09/15] remove old config --- .../pointcloud2simplicial/alpha_complex_lifting.yaml | 8 -------- 1 file changed, 8 deletions(-) delete mode 100644 configs/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.yaml diff --git a/configs/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.yaml b/configs/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.yaml deleted file mode 100644 index 9aa266c3..00000000 --- a/configs/transforms/liftings/pointcloud2simplicial/alpha_complex_lifting.yaml +++ /dev/null @@ -1,8 +0,0 @@ -transform_type: 'lifting' -transform_name: "FeatureRipsComplexLifting" -complex_dim: 3 -feature_percent: 0.2 -max_edge_length: 10.0 -sparse: null -preserve_edge_attr: False -feature_lifting: ProjectionSum From 118a3dc69d77fd301102c7a05cf6585ce322af3f Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 6 Jul 2024 19:40:28 -0400 Subject: [PATCH 10/15] add new config --- .../pointcloud2simplicial/feature_rips_lifting.yaml | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 configs/transforms/liftings/pointcloud2simplicial/feature_rips_lifting.yaml diff --git a/configs/transforms/liftings/pointcloud2simplicial/feature_rips_lifting.yaml b/configs/transforms/liftings/pointcloud2simplicial/feature_rips_lifting.yaml new file mode 100644 index 00000000..14aa2d21 --- /dev/null +++ b/configs/transforms/liftings/pointcloud2simplicial/feature_rips_lifting.yaml @@ -0,0 +1,7 @@ +transform_type: 'lifting' +transform_name: "FeatureRipsComplexLifting" +complex_dim: 3 +feature_percent: 0.2 +max_edge_length: 10.0 +sparse: null +feature_lifting: ProjectionSum From afbc8e16149d56199851e410fa32909ce146ea07 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 6 Jul 2024 19:41:02 -0400 Subject: [PATCH 11/15] rips lifting --- .../feature_rips_complex_lifting.py | 52 ++++++++++++++----- modules/utils/utils.py | 36 +++++++++++++ 2 files changed, 76 insertions(+), 12 deletions(-) diff --git a/modules/transforms/liftings/pointcloud2simplicial/feature_rips_complex_lifting.py b/modules/transforms/liftings/pointcloud2simplicial/feature_rips_complex_lifting.py index 36ff4152..817b4a2f 100644 --- a/modules/transforms/liftings/pointcloud2simplicial/feature_rips_complex_lifting.py +++ b/modules/transforms/liftings/pointcloud2simplicial/feature_rips_complex_lifting.py @@ -6,6 +6,7 @@ from modules.transforms.liftings.pointcloud2simplicial.base import ( PointCloud2SimplicialLifting, ) +from modules.utils.utils import add_epsilon_to_zeros, calculate_pairwise_differences class FeatureRipsComplexLifting(PointCloud2SimplicialLifting): @@ -19,19 +20,34 @@ class FeatureRipsComplexLifting(PointCloud2SimplicialLifting): The maximum pairwise distance to add an edge to the graph feature_percent: float - The percentage weight to give the feature-based distance (should be between 0 and 1) + The percentage weight to give the feature-based distance (should be between 0 and 1). 0 corresponds to the usual Rips Complex, while 1 corresponds to a complex generated using only distance-based features. sparse: float or None. If float, uses a sparse approximation to the Rips complex to speed up computation. + epsilon: float + A small value that gets added to 0 values in the pairwise distance matrix. This is only used to handle an edge case in gudhi where it treats points with distance 0 as the same, and should rarely need to be modified. + **kwargs : optional Additional arguments for the class. """ - def __init__(self, max_edge_length: float, feature_percent: float, **kwargs): + def __init__( + self, + max_edge_length: float, + feature_percent: float, + sparse: bool = False, + epsilon: float = 1e-8, + **kwargs, + ): + if feature_percent < 0 or feature_percent > 1: + raise ValueError( + "feature_percent must be a value between 0 and 1 inclusive." + ) self.feature_percent = feature_percent self.max_edge_length = max_edge_length - self.sparse = self.sparse + self.sparse = sparse + self.epsilon = epsilon super().__init__(**kwargs) def generate_distance_matrix(self, data): @@ -47,13 +63,26 @@ def generate_distance_matrix(self, data): torch.tensor The pairwise distances. """ - x_expanded_1 = data.x.unsqueeze(1) - x_expanded_2 = data.x.unsqueeze(0) + pairwise_distances = torch.zeros( + ( + data.pos.shape[0], + data.pos.shape[0], + ) + ) + + if self.feature_percent > 0: + feature_differences = calculate_pairwise_differences(data.x) + pairwise_distances += self.feature_percent * torch.linalg.norm( + feature_differences, dim=-1 + ) - # Calculate pairwise differences - feature_differences = x_expanded_1 - x_expanded_2 + if self.feature_percent < 1.0: + position_differences = calculate_pairwise_differences(data.pos) + pairwise_distances += (1 - self.feature_percent) * torch.linalg.norm( + position_differences, dim=-1 + ) - pass + return add_epsilon_to_zeros(pairwise_distances, self.epsilon) def lift_topology(self, data: torch_geometric.data.Data) -> dict: r"""Lifts the topology of a point cloud to the Rips complex based on point-wise and feature-based distances. @@ -68,12 +97,11 @@ def lift_topology(self, data: torch_geometric.data.Data) -> dict: dict The lifted topology. """ - dm = self.generate_distance_matrix(data.pos, data.x) - sc = gudhi.RipsComplex( + dm = self.generate_distance_matrix(data) + gudhi_sc = gudhi.RipsComplex( distance_matrix=dm, sparse=self.sparse, max_edge_length=self.max_edge_length ) - stree = sc.create_simplex_tree() - stree.prune_above_dimension(self.complex_dim) + stree = gudhi_sc.create_simplex_tree(max_dimension=self.complex_dim) sc = SimplicialComplex(s for s, filtration_value in stree.get_simplices()) lifted_topolgy = self._get_lifted_topology(sc) lifted_topolgy["x_0"] = data.x diff --git a/modules/utils/utils.py b/modules/utils/utils.py index 3bbdb385..1d17e17b 100644 --- a/modules/utils/utils.py +++ b/modules/utils/utils.py @@ -553,3 +553,39 @@ def describe_hypergraph(data: torch_geometric.data.Data): if he_idx >= 10: print("...") break + + +def calculate_pairwise_differences(x: torch.Tensor): + r"""Generate tensor of pairwise differences between each row of x. + + Parameters + ---------- + x : torch.Tensor + 2-dimensional tensor. + + Returns + ------- + torch.Tensor + Tensor of pairwise differences of rows of x. + """ + x_expanded_1 = x.unsqueeze(1) + x_expanded_2 = x.unsqueeze(0) + return x_expanded_1 - x_expanded_2 + + +def add_epsilon_to_zeros(tensor, epsilon=1e-8): + """Add a small epsilon value to off-diagonal elements which are zero. This is useful for using the gudhi library since it treats pairwise distances which are 0 as the same point.""" + + # Create a mask for non-diagonal elements + non_diagonal_mask = ~torch.eye( + tensor.shape[0], dtype=torch.bool, device=tensor.device + ) + + # Create a tensor with epsilon values where the original tensor is 0 + epsilon_tensor = torch.zeros_like(tensor) + epsilon_tensor[non_diagonal_mask & (tensor == 0)] = epsilon + + # Add the epsilon tensor to the original tensor + result = tensor + epsilon_tensor + + return result From 00f744dd2a45a5aaa0fa964bbbf869c0eaedc1be Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 6 Jul 2024 19:41:27 -0400 Subject: [PATCH 12/15] update notebook and dataset --- modules/data/utils/utils.py | 2 + .../feature_rips_complex_lifting.ipynb | 292 +++++++++++++++++- 2 files changed, 281 insertions(+), 13 deletions(-) diff --git a/modules/data/utils/utils.py b/modules/data/utils/utils.py index fd2aefec..9982cb1b 100755 --- a/modules/data/utils/utils.py +++ b/modules/data/utils/utils.py @@ -526,5 +526,7 @@ def load_manual_points(): dtype=torch.float, ) x = torch.ones_like(pos, dtype=torch.float) + x[:4] = 0.0 + x[3, 1] = 1.0 y = torch.randint(0, 2, (pos.shape[0],), dtype=torch.float) return torch_geometric.data.Data(x=x, y=y, pos=pos, complex_dim=0) diff --git a/tutorials/pointcloud2simplicial/feature_rips_complex_lifting.ipynb b/tutorials/pointcloud2simplicial/feature_rips_complex_lifting.ipynb index 948da7fa..d8021b57 100644 --- a/tutorials/pointcloud2simplicial/feature_rips_complex_lifting.ipynb +++ b/tutorials/pointcloud2simplicial/feature_rips_complex_lifting.ipynb @@ -33,7 +33,7 @@ "* gudhi_spiral_2d\n", "* gudhi_daily_activities\n", "\n", - "Please see the gudhi documentation [1] for a description of these datasets and the relevant config options. Note that *all datasets except gudhi_daily_activities lack features and targets*. You must instead provide a feature_generator target_generator in the PointCloudLoader\n", + "Please see the gudhi documentation [1] for a description of these datasets and the relevant config options. Note that *all datasets except gudhi_daily_activities lack features and targets*. You must instead provide a feature_generator and target_generator in the PointCloudLoader\n", "\n", "[[1]](https://gudhi.inria.fr/python/latest/index.html) GUDHI Python documentation\n", "***" @@ -133,6 +133,14 @@ "Dataset only contains 1 sample:\n" ] }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing...\n", + "Done!\n" + ] + }, { "data": { "image/png": "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", @@ -201,14 +209,14 @@ "output_type": "stream", "text": [ "\n", - "Transform configuration for pointcloud2simplicial/alpha_complex_lifting:\n", + "Transform configuration for pointcloud2simplicial/feature_rips_lifting:\n", "\n", "{'transform_type': 'lifting',\n", - " 'transform_name': 'AlphaComplexLifting',\n", + " 'transform_name': 'FeatureRipsComplexLifting',\n", " 'complex_dim': 3,\n", - " 'alpha': 25.0,\n", - " 'preserve_edge_attr': False,\n", - " 'signed': True,\n", + " 'feature_percent': 0.2,\n", + " 'max_edge_length': 10.0,\n", + " 'sparse': None,\n", " 'feature_lifting': 'ProjectionSum'}\n" ] } @@ -217,7 +225,7 @@ "# Define transformation type and id\n", "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/feature_rips_complex_lifting\"\n", + "transform_id = \"pointcloud2simplicial/feature_rips_lifting\"\n", "\n", "# Read yaml file\n", "transform_config = {\n", @@ -242,14 +250,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "Transform parameters are the same, using existing data_dir: /Users/tlong/Documents/code/challenge-icml-2024/datasets/pointcloud/toy_dataset/manual_points/lifting/3217688758\n", "\n", "Dataset only contains 1 sample:\n" ] }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing...\n", + "/Users/tlong/anaconda3/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" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -263,10 +280,12 @@ "text": [ " - The complex has 7 0-cells.\n", " - The 0-cells have features dimension 2\n", - " - The complex has 9 1-cells.\n", + " - The complex has 13 1-cells.\n", " - The 1-cells have features dimension 2\n", - " - The complex has 3 2-cells.\n", + " - The complex has 9 2-cells.\n", " - The 2-cells have features dimension 2\n", + " - The complex has 2 3-cells.\n", + " - The 3-cells have features dimension 2\n", "\n" ] } @@ -276,6 +295,253 @@ "describe_data(lifted_dataset)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Illustrating how the Feature-based Rips Complex differs from the standard Rips complex\n", + "\n", + "Let's see what the effect of the `feature_percent` parameter is. The Rips complex is generated based on **pairwise distances** between points. Usually these are calculated using the usual Euclidean distance of point positions, however this implementation also lets us linearly combine this with the distance between **feature vectors**." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Transform configuration for pointcloud2simplicial/feature_rips_lifting:\n", + "\n", + "{'transform_type': 'lifting',\n", + " 'transform_name': 'FeatureRipsComplexLifting',\n", + " 'complex_dim': 3,\n", + " 'feature_percent': 0.2,\n", + " 'max_edge_length': 10.0,\n", + " 'sparse': None,\n", + " 'feature_lifting': 'ProjectionSum'}\n" + ] + } + ], + "source": [ + "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", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With `feature_percent=0.0`, we obtain the 'standard' Rips Complex, which is based only on the distances between points." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset only contains 1 sample:\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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 7 0-cells.\n", + " - The 0-cells have features dimension 2\n", + " - The complex has 10 1-cells.\n", + " - The 1-cells have features dimension 2\n", + " - The complex has 5 2-cells.\n", + " - The 2-cells have features dimension 2\n", + " - The complex has 1 3-cells.\n", + " - The 3-cells have features dimension 2\n", + "\n" + ] + } + ], + "source": [ + "transform_config[\"lifting\"][\"feature_percent\"] = 0.0\n", + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With `feature_percent=1.0`, the distances between points are **entirely** based on the features. There are only 3 unique feature vectors in this dataset - 3 vertices with feature vector `[0.0, 0.0]`, 3 with `[1.0, 1.0]`, and 1 with `[1.0, 0.0]`. This is reflected in the geometry of the resulting complex - there are two simplexes of 4 vertices with a 'bridge' corresponding to the single vertex with an intermediate feature vector.\n", + "\n", + "Note that we also set `max_edge_length=1.0` since the scale of the feature vectors is much smaller than the position vectors. When using this lifting, one should be careful to normalize or standardize both features and positions to ensure that the scales match appropriately. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transform parameters are the same, using existing data_dir: /Users/tlong/Documents/code/challenge-icml-2024/datasets/pointcloud/toy_dataset/manual_points/lifting/1869000105\n", + "\n", + "Dataset only contains 1 sample:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 7 0-cells.\n", + " - The 0-cells have features dimension 2\n", + " - The complex has 12 1-cells.\n", + " - The 1-cells have features dimension 2\n", + " - The complex has 8 2-cells.\n", + " - The 2-cells have features dimension 2\n", + " - The complex has 2 3-cells.\n", + " - The 3-cells have features dimension 2\n", + "\n" + ] + } + ], + "source": [ + "transform_config[\"lifting\"][\"feature_percent\"] = 1.0\n", + "transform_config[\"lifting\"][\"max_edge_length\"] = 1.0\n", + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(indices=tensor([[0, 1, 2, 3, 4, 5, 6, 7],\n", + " [0, 0, 0, 0, 1, 1, 1, 1]]),\n", + " values=tensor([1., 1., 1., 1., 1., 1., 1., 1.]),\n", + " size=(8, 2), nnz=8, layout=torch.sparse_coo)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lifted_dataset.get(0).incidence_3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally we test `feature_percent=0.2`, an intermediate value where the distances are mostly determined by the positions, with a small influence from the features. We see that the geometry is now different from both of the other two cases." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset only contains 1 sample:\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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 7 0-cells.\n", + " - The 0-cells have features dimension 2\n", + " - The complex has 13 1-cells.\n", + " - The 1-cells have features dimension 2\n", + " - The complex has 9 2-cells.\n", + " - The 2-cells have features dimension 2\n", + " - The complex has 2 3-cells.\n", + " - The 3-cells have features dimension 2\n", + "\n" + ] + } + ], + "source": [ + "transform_config[\"lifting\"][\"feature_percent\"] = 0.2\n", + "transform_config[\"lifting\"][\"max_edge_length\"] = 10\n", + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When might feature-based Rips Complexes be useful? Suppose we have a point cloud dataset that actually consists of samples from multiple **independent objects**. For example, disjoint spheres. If two of the spheres are very close to one another, the standard Rips complex may generate a topology which incorrectly connects these two spheres. If a feature contribution is added, these spheres may have quite different feature vectors allowing the 'correct' geometry to be inferred.\n", + "\n", + "Another use case is to generate more expressive message-passing toplogies. One might want to have two message-passing networks, one which operates over the usual Euclidean metric topology, while the other use the feature-based topology. This can allow for more complex interactions to be embedded in the topology of the lifted point cloud." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -292,7 +558,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -323,7 +589,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ From 46d79cee11f686a8d0c71a4821532972646aa71e Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 6 Jul 2024 19:41:33 -0400 Subject: [PATCH 13/15] add testing --- .../test_feature_rips_complex_lifting.py | 192 ++++++++++++++---- 1 file changed, 157 insertions(+), 35 deletions(-) diff --git a/test/transforms/liftings/pointcloud2simplicial/test_feature_rips_complex_lifting.py b/test/transforms/liftings/pointcloud2simplicial/test_feature_rips_complex_lifting.py index 5ef8ec4d..85ecb134 100644 --- a/test/transforms/liftings/pointcloud2simplicial/test_feature_rips_complex_lifting.py +++ b/test/transforms/liftings/pointcloud2simplicial/test_feature_rips_complex_lifting.py @@ -12,54 +12,176 @@ class TestFeatureRipsComplexLifting: """Test the FeatureRipsComplexLifting class.""" def setup_method(self): - # Load the graph + # Load the point cloud self.data = load_manual_points() - # Initialise the SimplicialCliqueLifting class - self.lifting = FeatureRipsComplexLifting(complex_dim=3, alpha=25.0) + # Initialise the FeatureRipsLifting class + self.position_lifting = FeatureRipsComplexLifting( + complex_dim=3, feature_percent=0.0, max_edge_length=10.0 + ) + self.feature_lifting = FeatureRipsComplexLifting( + complex_dim=3, feature_percent=1.0, max_edge_length=1.0 + ) + self.mixed_lifting = FeatureRipsComplexLifting( + complex_dim=3, feature_percent=0.2, max_edge_length=10.0 + ) def test_lift_topology(self): """Test the lift_topology method.""" # Test the lift_topology method - lifted_data = self.lifting.forward(self.data.clone()) - - expected_incidence_1 = torch.tensor( - [ - [1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], - [1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], - [0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0], - [0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0], - [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0], - [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0], - [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], - ] + lifted_data = self.position_lifting.forward(self.data.clone()) + + expected_incidences = ( + torch.tensor( + [ + [1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], + ] + ), + torch.tensor( + [ + [1.0, 1.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 1.0, 1.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 1.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 1.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0], + [0.0, 0.0, 0.0, 0.0, 1.0], + [0.0, 0.0, 0.0, 0.0, 1.0], + ] + ), + torch.tensor([[1.0], [1.0], [1.0], [1.0], [0.0]]), ) assert ( - expected_incidence_1 == lifted_data.incidence_1.to_dense() - ).all(), "Something is wrong with incidence_1 (nodes to edges)." - - expected_incidence_2 = torch.tensor( - [ - [1.0, 0.0, 0.0], - [1.0, 0.0, 0.0], - [1.0, 1.0, 0.0], - [0.0, 1.0, 0.0], - [0.0, 1.0, 0.0], - [0.0, 0.0, 0.0], - [0.0, 0.0, 1.0], - [0.0, 0.0, 1.0], - [0.0, 0.0, 1.0], - ] + expected_incidences[0] == lifted_data.incidence_1.to_dense() + ).all(), "Something is wrong with incidence_1 (nodes to edges) for feature_percent=0.0." + + assert ( + abs(expected_incidences[1]) == lifted_data.incidence_2.to_dense() + ).all(), "Something is wrong with incidence_2 (edges to triangles) for feature_percent=0.0." + + assert ( + abs(expected_incidences[2]) == lifted_data.incidence_3.to_dense() + ).all(), "Something is wrong with incidence_3 (triangles to tetrahedrons) for feature_percent=0.0." + + expected_incidences = ( + torch.tensor( + [ + [1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0], + ] + ), + torch.tensor( + [ + [1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0], + ] + ), + torch.tensor( + [ + [1.0, 0.0], + [1.0, 0.0], + [1.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [0.0, 1.0], + [0.0, 1.0], + [0.0, 1.0], + ] + ), ) + lifted_data = self.feature_lifting.forward(self.data.clone()) assert ( - abs(expected_incidence_2) == lifted_data.incidence_2.to_dense() - ).all(), "Something is wrong with incidence_2 (edges to triangles)." + expected_incidences[0] == lifted_data.incidence_1.to_dense() + ).all(), "Something is wrong with incidence_1 (nodes to edges) for feature_percent=1.0." - expected_incidence_3 = torch.tensor([]) + assert ( + abs(expected_incidences[1]) == lifted_data.incidence_2.to_dense() + ).all(), "Something is wrong with incidence_2 (edges to triangles) for feature_percent=1.0." + + assert ( + abs(expected_incidences[2]) == lifted_data.incidence_3.to_dense() + ).all(), "Something is wrong with incidence_3 (triangles to tetrahedrons) for feature_percent=1.0." + + expected_incidences = ( + torch.tensor( + [ + [1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0], + ] + ), + torch.tensor( + [ + [1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], + ] + ), + torch.tensor( + [ + [1.0, 0.0], + [1.0, 0.0], + [1.0, 0.0], + [1.0, 0.0], + [0.0, 1.0], + [0.0, 1.0], + [0.0, 1.0], + [0.0, 1.0], + [0.0, 0.0], + ] + ), + ) + + lifted_data = self.mixed_lifting.forward(self.data.clone()) + + assert ( + expected_incidences[0] == lifted_data.incidence_1.to_dense() + ).all(), "Something is wrong with incidence_1 (nodes to edges) for feature_percent=0.2 ." + + assert ( + abs(expected_incidences[1]) == lifted_data.incidence_2.to_dense() + ).all(), "Something is wrong with incidence_2 (edges to triangles) for feature_percent=0.2 ." assert ( - abs(expected_incidence_3) == lifted_data.incidence_3.to_dense() - ).all(), "Something is wrong with incidence_3 (triangles to tetrahedrons)." + abs(expected_incidences[2]) == lifted_data.incidence_3.to_dense() + ).all(), "Something is wrong with incidence_3 (triangles to tetrahedrons) for feature_percent=0.2 ." From 83121ceabc4a9ed441fc2ab25ea0b801181aa150 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 6 Jul 2024 20:54:03 -0400 Subject: [PATCH 14/15] update function (linting + docstring) --- modules/utils/utils.py | 27 +++++++++++++++++---------- 1 file changed, 17 insertions(+), 10 deletions(-) diff --git a/modules/utils/utils.py b/modules/utils/utils.py index 1d17e17b..be012115 100644 --- a/modules/utils/utils.py +++ b/modules/utils/utils.py @@ -573,19 +573,26 @@ def calculate_pairwise_differences(x: torch.Tensor): return x_expanded_1 - x_expanded_2 -def add_epsilon_to_zeros(tensor, epsilon=1e-8): - """Add a small epsilon value to off-diagonal elements which are zero. This is useful for using the gudhi library since it treats pairwise distances which are 0 as the same point.""" +def add_epsilon_to_zeros(t: torch.Tensor, epsilon=1e-8): + """Add a small epsilon value to off-diagonal elements which are zero. This is useful for using the gudhi library since it treats pairwise distances which are 0 as the same point. + + Parameters + ---------- + t : torch.Tensor + 2-dimensional tensor. + + Returns + ------- + torch.Tensor + Tensor with non-diagonal elements that are zero shifted slightly by a small epsilon. + """ # Create a mask for non-diagonal elements - non_diagonal_mask = ~torch.eye( - tensor.shape[0], dtype=torch.bool, device=tensor.device - ) + non_diagonal_mask = ~torch.eye(t.shape[0], dtype=torch.bool, device=t.device) # Create a tensor with epsilon values where the original tensor is 0 - epsilon_tensor = torch.zeros_like(tensor) - epsilon_tensor[non_diagonal_mask & (tensor == 0)] = epsilon + epsilon_tensor = torch.zeros_like(t) + epsilon_tensor[non_diagonal_mask & (t == 0)] = epsilon # Add the epsilon tensor to the original tensor - result = tensor + epsilon_tensor - - return result + return t + epsilon_tensor From 617993c8956f23363d078e01f6a7fd0e35e0feaf Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 13 Jul 2024 01:13:01 -0400 Subject: [PATCH 15/15] add test --- .../test_feature_rips_complex_lifting.py | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/test/transforms/liftings/pointcloud2simplicial/test_feature_rips_complex_lifting.py b/test/transforms/liftings/pointcloud2simplicial/test_feature_rips_complex_lifting.py index 85ecb134..3c037c17 100644 --- a/test/transforms/liftings/pointcloud2simplicial/test_feature_rips_complex_lifting.py +++ b/test/transforms/liftings/pointcloud2simplicial/test_feature_rips_complex_lifting.py @@ -1,6 +1,7 @@ """Test the feature-based Rips complex lifting.""" import torch +import torch_geometric from modules.data.utils.utils import load_manual_points from modules.transforms.liftings.pointcloud2simplicial.feature_rips_complex_lifting import ( @@ -25,6 +26,27 @@ def setup_method(self): self.mixed_lifting = FeatureRipsComplexLifting( complex_dim=3, feature_percent=0.2, max_edge_length=10.0 ) + self.no_epsilon_lifting = FeatureRipsComplexLifting( + complex_dim=3, + feature_percent=0.5, + max_edge_length=10.0, + epsilon=0.0, + ) + + def test_generate_distance_matrix(self): + # Test the generate_distance_matrix method + data = torch_geometric.data.Data( + pos=torch.tensor([[-1], [1], [2]]).float(), + x=torch.tensor([[2], [4], [6]]).float(), + ) + expected_pairwise_distances = torch.tensor( + [[0, 2, 3.5], [2, 0, 1.5], [3.5, 1.5, 0]] + ) + + assert ( + self.no_epsilon_lifting.generate_distance_matrix(data) + == expected_pairwise_distances + ).all(), "generate_distance_matrix not working as expected" def test_lift_topology(self): """Test the lift_topology method."""