diff --git a/configs/transforms/liftings/graph2simplicial/directed_clique_lifting.yaml b/configs/transforms/liftings/graph2simplicial/directed_clique_lifting.yaml new file mode 100644 index 00000000..8a3c14dd --- /dev/null +++ b/configs/transforms/liftings/graph2simplicial/directed_clique_lifting.yaml @@ -0,0 +1,6 @@ +transform_type: 'lifting' +transform_name: "DirectedSimplicialCliqueLifting" +complex_dim: 3 +preserve_edge_attr: False +signed: True +feature_lifting: ProjectionSum \ No newline at end of file diff --git a/modules/transforms/data_transform.py b/modules/transforms/data_transform.py index 59253ecf..eca9670f 100755 --- a/modules/transforms/data_transform.py +++ b/modules/transforms/data_transform.py @@ -15,12 +15,16 @@ from modules.transforms.liftings.graph2simplicial.clique_lifting import ( SimplicialCliqueLifting, ) +from modules.transforms.liftings.graph2simplicial.directed_clique_lifting import ( + DirectedSimplicialCliqueLifting, +) TRANSFORMS = { # Graph -> Hypergraph "HypergraphKNNLifting": HypergraphKNNLifting, # Graph -> Simplicial Complex "SimplicialCliqueLifting": SimplicialCliqueLifting, + "DirectedSimplicialCliqueLifting": DirectedSimplicialCliqueLifting, # Graph -> Cell Complex "CellCycleLifting": CellCycleLifting, # Feature Liftings diff --git a/modules/transforms/liftings/graph2simplicial/directed_clique_lifting.py b/modules/transforms/liftings/graph2simplicial/directed_clique_lifting.py new file mode 100644 index 00000000..5e3acacf --- /dev/null +++ b/modules/transforms/liftings/graph2simplicial/directed_clique_lifting.py @@ -0,0 +1,105 @@ +from itertools import combinations + +import networkx as nx +import torch_geometric +from toponetx.classes import SimplicialComplex +from torch_geometric.utils.undirected import is_undirected + +from modules.transforms.liftings.graph2simplicial.base import Graph2SimplicialLifting + + +class DirectedSimplicialCliqueLifting(Graph2SimplicialLifting): + r"""Lifts graphs to simplicial complex domain by identifying + the (k-1)-cliques as k-simplices if the clique has a single + source and sink. + + See [Computing persistent homology of directed flag complexes](https://arxiv.org/abs/1906.10458) + for more details. + + Parameters + ---------- + **kwargs : optional + Additional arguments for the class. + """ + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def _generate_graph_from_data(self, data: torch_geometric.data.Data) -> nx.Graph: + r"""Generates a NetworkX graph from the input data object. + Falls back to superclass method if data is not directed. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data. + + Returns + ------- + nx.DiGraph + The generated NetworkX graph. + """ + # Check if undirected and fall back to superclass method if so + if is_undirected(data.edge_index, data.edge_attr): + return super()._generate_graph_from_data(data) + + # Check if data object have edge_attr, return list of tuples as [(node_id, {'features':data}, 'dim':1)] or ?? + nodes = [(n, dict(features=data.x[n], dim=0)) for n in range(data.x.shape[0])] + + if self.preserve_edge_attr and self._data_has_edge_attr(data): + # In case edge features are given, assign features to every edge + edge_index, edge_attr = (data.edge_index, data.edge_attr) + edges = [ + (i.item(), j.item(), dict(features=edge_attr[edge_idx], dim=1)) + for edge_idx, (i, j) in enumerate( + zip(edge_index[0], edge_index[1], strict=False) + ) + ] + self.contains_edge_attr = True + else: + # If edge_attr is not present, return list list of edges + edges = [ + (i.item(), j.item()) + for i, j in zip(data.edge_index[0], data.edge_index[1], strict=False) + ] + self.contains_edge_attr = False + graph = nx.DiGraph() + graph.add_nodes_from(nodes) + graph.add_edges_from(edges) + return graph + + def lift_topology(self, data: torch_geometric.data.Data) -> dict: + r"""Lifts the topology of a graph to a simplicial complex by identifying + the (k-1)-cliques of a graph as the k-simplices if the cliques have a single + source and sink. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data to be lifted. + + Returns + ------- + dict + The lifted topology. + """ + graph = self._generate_graph_from_data(data) + simplicial_complex = SimplicialComplex(graph) + # find cliques in the undirected graph + cliques = nx.find_cliques(graph.to_undirected()) + simplices = [set() for _ in range(2, self.complex_dim + 1)] + + for clique in cliques: + # locate the clique in the original directed graph + gs = graph.subgraph(clique) + # check if the clique has a single source and sink + # (i.e. is a DAG) and add as a simplex if so + if nx.is_directed_acyclic_graph(gs): + for i in range(2, self.complex_dim + 1): + for c in combinations(gs, i + 1): + simplices[i - 2].add(tuple(c)) + + for set_k_simplices in simplices: + simplicial_complex.add_simplices_from(list(set_k_simplices)) + + return self._get_lifted_topology(simplicial_complex, graph) diff --git a/test/transforms/liftings/graph2simplicial/test_directed_clique_lifting.py b/test/transforms/liftings/graph2simplicial/test_directed_clique_lifting.py new file mode 100644 index 00000000..a3692540 --- /dev/null +++ b/test/transforms/liftings/graph2simplicial/test_directed_clique_lifting.py @@ -0,0 +1,174 @@ +"""Test the message passing module.""" + +import networkx as nx +import torch +import torch_geometric + +from modules.transforms.liftings.graph2simplicial.directed_clique_lifting import ( + DirectedSimplicialCliqueLifting, +) + + +class TestDirectedSimplicialCliqueLifting: + """Test the SimplicialCliqueLifting class.""" + + def setup_triangle_graph(self): + """Sets up a test graph with 0 as a source node which + generates a 2-simplex amongst (0,1,2), equivalent to + the standard/undirected clique complex. + """ + edges = [ + [0, 1], + [0, 2], + [2, 1], + ] + g = nx.DiGraph() + g.add_edges_from(edges) + edge_list = torch.Tensor(list(g.edges())).T.long() + # Generate feature from 0 to 3 + x = torch.tensor([1, 5, 10]).unsqueeze(1).float() + self.triangle_data = torch_geometric.data.Data( + x=x, edge_index=edge_list, num_nodes=len(g.nodes) + ) + + def setup_three_two_graph(self): + """Sets up a test graph with a single source node (0) + with three edges emanating from it, and two sinks (1,2). + + The directed clique complex should result in two 2-simplices + (0,2,3) and (0,1,3). + """ + edges = [ + [0, 3], + [0, 2], + [0, 1], + [3, 2], + [3, 1], + ] + g = nx.DiGraph() + g.add_edges_from(edges) + edge_list = torch.Tensor(list(g.edges())).T.long() + # Generate feature from 0 to 3 + x = torch.tensor([1, 5, 10, 50]).unsqueeze(1).float() + self.three_two_data = torch_geometric.data.Data( + x=x, edge_index=edge_list, num_nodes=len(g.nodes) + ) + + def setup_missing_triangle_graph(self): + """Sets up a test graph with one clique with a single source + and sink (0,1,3) and one without either (1,2,3). + + The directed clique complex should result in only one 2-simplex + (0,1,3), the other clique is empty, illustrating the difference + between the directed clique complex and the undirected clique + complex. + """ + edges = [ + [0, 3], + [0, 1], + [3, 2], + [2, 1], + [1, 3], + ] + g = nx.DiGraph() + g.add_edges_from(edges) + edge_list = torch.Tensor(list(g.edges())).T.long() + # Generate feature from 0 to 3 + x = torch.tensor([1, 5, 10, 50]).unsqueeze(1).float() + self.missing_triangle_data = torch_geometric.data.Data( + x=x, edge_index=edge_list, num_nodes=len(g.nodes) + ) + + def setup_method(self): + self.setup_triangle_graph() + self.triangle_lifting = DirectedSimplicialCliqueLifting(complex_dim=2) + + self.setup_three_two_graph() + self.three_two_lifting = DirectedSimplicialCliqueLifting(complex_dim=2) + + self.setup_missing_triangle_graph() + self.missing_triangle_lifting = DirectedSimplicialCliqueLifting(complex_dim=2) + + def test_lift_topology(self): + """Test the lift_topology method.""" + + # Test the triangle_graph lifting + triangle_lifted_data = self.triangle_lifting.forward(self.triangle_data.clone()) + + expected_triangle_incidence_1 = torch.tensor( + [[1.0, 1.0, 0.0], [1.0, 0.0, 1.0], [0.0, 1.0, 1.0]] + ) + + assert ( + expected_triangle_incidence_1 == triangle_lifted_data.incidence_1.to_dense() + ).all(), "Something is wrong with triangle incidence_1 (nodes to edges)." + + # single triangle with all edges connected + expected_triangle_incidence_2 = torch.tensor([[1.0], [1.0], [1.0]]) + + assert ( + expected_triangle_incidence_2 == triangle_lifted_data.incidence_2.to_dense() + ).all(), "Something is wrong with triangle incidence_2 (edges to triangles)." + + # Test the three_two_graph lifting + three_two_lifted_data = self.three_two_lifting.forward( + self.three_two_data.clone() + ) + + expected_three_two_incidence_1 = torch.tensor( + [ + [1.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, 0.0, 1.0], + [0.0, 0.0, 1.0, 1.0, 1.0], + ] + ) + + assert ( + expected_three_two_incidence_1 + == three_two_lifted_data.incidence_1.to_dense() + ).all(), "Something is wrong with three_two incidence_1 (nodes to edges)." + + # five edges incident to two triangles, and the edge + # connecting (0,3) is shared by both triangles. + expected_three_two_incidence_2 = torch.tensor( + [[1.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0], [0.0, 1.0]] + ) + + assert ( + expected_three_two_incidence_2 + == three_two_lifted_data.incidence_2.to_dense() + ).all(), "Something is wrong with three_two incidence_2 (edges to triangles)." + + # Test missing_triangle lifting + missing_triangle_lifted_data = self.missing_triangle_lifting.forward( + self.missing_triangle_data.clone() + ) + + expected_missing_triangle_incidence_1 = torch.tensor( + [ + [1.0, 1.0, 0.0, 0.0, 0.0], + [1.0, 0.0, 1.0, 1.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 1.0], + [0.0, 1.0, 0.0, 1.0, 1.0], + ] + ) + + assert ( + expected_missing_triangle_incidence_1 + == missing_triangle_lifted_data.incidence_1.to_dense() + ).all(), ( + "Something is wrong with missing_triangle incidence_1 (nodes to edges)." + ) + + # only one triangle with the edges (3,2) and (2,1) ignored. + expected_missing_triangle_incidence_2 = torch.tensor( + [[1.0], [1.0], [0.0], [1.0], [0.0]] + ) + + assert ( + expected_missing_triangle_incidence_2 + == missing_triangle_lifted_data.incidence_2.to_dense() + ).all(), ( + "Something is wrong with missing_triangle incidence_2 (edges to triangles)." + ) diff --git a/tutorials/graph2simplicial/directed_clique_lifting.ipynb b/tutorials/graph2simplicial/directed_clique_lifting.ipynb new file mode 100644 index 00000000..5db2c028 --- /dev/null +++ b/tutorials/graph2simplicial/directed_clique_lifting.ipynb @@ -0,0 +1,646 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Graph-to-Simplicial Directed Clique 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, creates 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", + "Note that for simplicity the notebook is setup to use a simple graph. However, there is a set of available datasets that you can play with.\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", + "* cocitation_cora\n", + "* cocitation_citeseer\n", + "* cocitation_pubmed\n", + "* MUTAG\n", + "* NCI1\n", + "* NCI109\n", + "* PROTEINS_TU\n", + "* AQSOL\n", + "* ZINC\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", + "import networkx as nx\n", + "import torch\n", + "import torch_geometric\n", + "\n", + "from modules.data.load.loaders import GraphLoader\n", + "from modules.data.preprocess.preprocessor import PreProcessor\n", + "from modules.transforms.liftings.graph2simplicial.directed_clique_lifting import (\n", + " DirectedSimplicialCliqueLifting,\n", + ")\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_dataset:\n", + "\n", + "{'data_domain': 'graph',\n", + " 'data_type': 'toy_dataset',\n", + " 'data_name': 'manual',\n", + " 'data_dir': 'datasets/graph/toy_dataset',\n", + " 'num_features': 1,\n", + " 'num_classes': 2,\n", + " 'task': 'classification',\n", + " 'loss_type': 'cross_entropy',\n", + " 'monitor_metric': 'accuracy',\n", + " 'task_level': 'node'}\n" + ] + } + ], + "source": [ + "dataset_name = \"manual_dataset\"\n", + "dataset_config = load_dataset_config(dataset_name)\n", + "loader = GraphLoader(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": [ + " - Graph with 8 vertices and 13 edges.\n", + " - Features dimensions: [1, 0]\n", + " - There are 0 isolated nodes.\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": [ + "To get a sense for how the directed clique/flag complex differs from the more common undirected version, we will generate a clique complex for a toy graph then augment its connectivity to be directed and observe the differences in their resulting simplicial structure.\n", + "\n", + "For more information on the directed clique complex, see references [1,2].\n", + "\n", + "\n", + "***\n", + "[[1]](https://www.frontiersin.org/journals/computational-neuroscience/articles/10.3389/fncom.2017.00048/full) Reimann, Michael W., et al. \"Cliques of neurons bound into cavities provide a missing link between structure and function.\" Frontiers in computational neuroscience 11 (2017): 266051.\n", + "[[2]](https://arxiv.org/abs/1906.10458) Lütgehetmann, Daniel, et al. \"Computing persistent homology of directed flag complexes.\" Algorithms 13.1 (2020): 19.\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 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_clique = \"graph2simplicial/clique_lifting\"\n", + "\n", + "# Read yaml file\n", + "transform_config_clique = {\n", + " \"lifting\": load_transform_config(transform_type, transform_id_clique)\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: /home/tgebhart/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_clique, loader.data_dir)\n", + "describe_data(lifted_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Adding direction\n", + "\n", + "Let's recreate this example graph to see how the directionality of the network affects the resulting simplicial complex structure.\n", + "\n", + "To make our lives easier, we'll first create a plotting function which mimics the transformations that are going on behind the scenes within the data loader in the prior cells. Note that this helper function creates a `DirectedSimplicialCliqueLifting` function which we pass the underlying network data through." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/tgebhart/anaconda3/envs/topox/lib/python3.11/site-packages/torch_geometric/data/in_memory_dataset.py:300: UserWarning: It is not recommended to directly access the internal storage format `data` of an 'InMemoryDataset'. If you are absolutely certain what you are doing, access the internal storage via `InMemoryDataset._data` instead to suppress this warning. Alternatively, you can access stacked individual attributes of every graph via `dataset.{attr_name}`.\n", + " warnings.warn(msg)\n" + ] + } + ], + "source": [ + "def create_graph_and_plot(edges, node_data=dataset.data.x, complex_dim=3):\n", + " \"\"\"A helper function which creates a directed clique\n", + " complex from a direct edgelist and plots its simplices.\n", + " \"\"\"\n", + " G = nx.DiGraph(edges)\n", + " edge_list = torch.Tensor(list(G.edges())).T.long()\n", + " # Generate feature from 0 to 3\n", + " directed_data = torch_geometric.data.Data(\n", + " x=node_data, edge_index=edge_list, num_nodes=len(G.nodes)\n", + " )\n", + "\n", + " # create lifting\n", + " dcl = DirectedSimplicialCliqueLifting(complex_dim=complex_dim)\n", + " directed_data = dcl.forward(directed_data.clone())\n", + " describe_data({0: directed_data})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start our investigation by re-creating the simplicial structure of the clique complex. Note that the edgelist below always treats vertex 2 as a source. Note also that vertex 1 is a sink to 2, 0, and 4." + ] + }, + { + "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": [ + "/home/tgebhart/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" + ] + }, + { + "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": [ + "edges = [\n", + " (2, 1),\n", + " (2, 4),\n", + " (2, 0),\n", + " (4, 1),\n", + " (0, 1),\n", + " (0, 4),\n", + " (7, 0),\n", + " (2, 7),\n", + " (2, 5),\n", + " (5, 7),\n", + " (6, 5),\n", + " (6, 3),\n", + " (2, 3),\n", + "]\n", + "create_graph_and_plot(edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected, we get back the exact same simplicial complex as when we used the undirected clique complex. Now what happens if we swap the direction of the edge connecting nodes 1 and 2? " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "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": [ + " - 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 2 2-cells.\n", + " - The 2-cells have features dimension 1\n", + "\n" + ] + } + ], + "source": [ + "edges = [\n", + " (1, 2), # reverse only this edge\n", + " (2, 4),\n", + " (2, 0),\n", + " (4, 1),\n", + " (0, 1),\n", + " (0, 4),\n", + " (7, 0),\n", + " (2, 7),\n", + " (2, 5),\n", + " (5, 7),\n", + " (6, 5),\n", + " (6, 3),\n", + " (2, 3),\n", + "]\n", + "create_graph_and_plot(edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By introducing a directed cycle into the clique (0,1,2,4), we've completely destroyed the 3-simplex. This behavior distinguishes the `DirectedSimplicialCliqueLifting` from the `SimplicialCliqueLifting`: cliques in the directed case must have a single source and sink node. This requirement is satisfied vacuously by graph vertices and edges. \n", + "\n", + "What about the 2-cells? Let's see if we can \"unfill\" one of the triangles (2-cells) in the figure above and \"fill in\" the triangles in the 4-clique:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "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": [ + " - The complex has 8 0-cells.\n", + " - The 0-cells have features dimension 1\n", + " - The complex has 12 1-cells.\n", + " - The 1-cells have features dimension 1\n", + " - The complex has 3 2-cells.\n", + " - The 2-cells have features dimension 1\n", + "\n" + ] + } + ], + "source": [ + "edges = [\n", + " # (2,1), # remove this edge to break the 4-clique\n", + " (2, 4),\n", + " (0, 2), # change direction to unfill the triangle (0,2,7)\n", + " (4, 1),\n", + " (0, 1),\n", + " (0, 4),\n", + " (7, 0),\n", + " (2, 7),\n", + " (2, 5),\n", + " (5, 7),\n", + " (6, 5),\n", + " (6, 3),\n", + " (2, 3),\n", + "]\n", + "create_graph_and_plot(edges)" + ] + }, + { + "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": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Transform configuration for graph2simplicial/directed_clique_lifting:\n", + "\n", + "{'transform_type': 'lifting',\n", + " 'transform_name': 'DirectedSimplicialCliqueLifting',\n", + " 'complex_dim': 3,\n", + " 'preserve_edge_attr': False,\n", + " 'signed': True,\n", + " 'feature_lifting': 'ProjectionSum'}\n", + "Transform parameters are the same, using existing data_dir: /home/tgebhart/projects/challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/22337573\n" + ] + } + ], + "source": [ + "transform_id_directed_clique = \"graph2simplicial/directed_clique_lifting\"\n", + "\n", + "# Read yaml file\n", + "transform_config_directed_clique = {\n", + " \"lifting\": load_transform_config(transform_type, transform_id_directed_clique)\n", + " # other transforms (e.g. data manipulations, feature liftings) can be added here\n", + "}\n", + "\n", + "lifted_dataset = PreProcessor(\n", + " dataset, transform_config_directed_clique, loader.data_dir\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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": 12, + "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": "venv_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" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}