From f060bbf3dd57078717ea46369d9fef6f80e220d4 Mon Sep 17 00:00:00 2001 From: pierrick Date: Tue, 9 Jul 2024 15:24:11 +0200 Subject: [PATCH 1/8] created path lifting files post precommit --- .../graph2hypergraph/path_lifting.yaml | 3 + modules/transforms/data_transform.py | 2 + .../liftings/graph2hypergraph/path_lifting.py | 136 ++++++++++++++++++ 3 files changed, 141 insertions(+) create mode 100755 configs/transforms/liftings/graph2hypergraph/path_lifting.yaml create mode 100644 modules/transforms/liftings/graph2hypergraph/path_lifting.py diff --git a/configs/transforms/liftings/graph2hypergraph/path_lifting.yaml b/configs/transforms/liftings/graph2hypergraph/path_lifting.yaml new file mode 100755 index 00000000..2e7fee78 --- /dev/null +++ b/configs/transforms/liftings/graph2hypergraph/path_lifting.yaml @@ -0,0 +1,3 @@ +transform_type: 'lifting' +transform_name: "PathLifting" +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..74a7ff2e 100755 --- a/modules/transforms/data_transform.py +++ b/modules/transforms/data_transform.py @@ -12,6 +12,7 @@ from modules.transforms.liftings.graph2hypergraph.knn_lifting import ( HypergraphKNNLifting, ) +from modules.transforms.liftings.graph2hypergraph.path_lifting import PathLifting from modules.transforms.liftings.graph2simplicial.clique_lifting import ( SimplicialCliqueLifting, ) @@ -31,6 +32,7 @@ "OneHotDegreeFeatures": OneHotDegreeFeatures, "NodeFeaturesToFloat": NodeFeaturesToFloat, "KeepOnlyConnectedComponent": KeepOnlyConnectedComponent, + "PathLifting": PathLifting, } diff --git a/modules/transforms/liftings/graph2hypergraph/path_lifting.py b/modules/transforms/liftings/graph2hypergraph/path_lifting.py new file mode 100644 index 00000000..f3a29ea2 --- /dev/null +++ b/modules/transforms/liftings/graph2hypergraph/path_lifting.py @@ -0,0 +1,136 @@ +"""A module for the PathLifting class.""" +import networkx as nx +import numpy as np +import torch +import torch_geometric + +from modules.transforms.liftings.graph2hypergraph.base import Graph2HypergraphLifting + + +class PathLifting(Graph2HypergraphLifting): + """Lifts graphs to hypergraph domain by considering paths between nodes.""" + + def __init__( + self, + source_nodes: list[int], + target_nodes: list[int], + lengths: list[int], + include_smaller_paths=False, + **kwargs, + ): + # guard clauses + if len(source_nodes) != len(lengths): + raise ValueError("source_nodes and lengths must have the same length") + if target_nodes is not None and len(target_nodes) != len(source_nodes): + raise ValueError( + "When target_nodes is not None, it must have the same length" + "as source_nodes" + ) + if len(source_nodes) == 0: + raise ValueError( + "source_nodes,target_nodes and lengths must have at least one element" + ) + + super().__init__(**kwargs) + self.source_nodes = source_nodes + self.target_nodes = target_nodes + self.lengths = lengths + self.include_smaller_paths = include_smaller_paths + + def find_hyperedges(self, data: torch_geometric.data.Data): + """Finds hyperedges from paths between nodes in a graph.""" + G = torch_geometric.utils.convert.to_networkx(data, to_undirected=True) + s_hyperedges = set() + + if self.target_nodes is None: # all paths stemming from source nodes only + for source, length in zip(self.source_nodes, self.lengths): + D, d_id2label, l_leafs = self.build_stemmingTree(G, source, length) + s = self.extract_hyperedgesFromStemmingTree(D, d_id2label, l_leafs) + s_hyperedges = s_hyperedges.union(s) + + else: # paths from source_nodes to target_nodes or from source nodes only + for source, target, length in zip( + self.source_nodes, self.target_nodes, self.lengths + ): + if target is None: + D, d_id2label, l_leafs = self.build_stemmingTree(G, source, length) + s = self.extract_hyperedgesFromStemmingTree(D, d_id2label, l_leafs) + s_hyperedges = s_hyperedges.union(s) + else: + paths = list( + nx.all_simple_paths( + G, source=source, target=target, cutoff=length + ) + ) + if not self.include_smaller_paths: + paths = [path for path in paths if len(path) - 1 == length] + s_hyperedges = s_hyperedges.union({frozenset(x) for x in paths}) + return s_hyperedges + + def lift_topology(self, data: torch_geometric.data.Data): + s_hyperedges = self.find_hyperedges(data) + indices = [[], []] + for edge_id, x in enumerate(s_hyperedges): + indices[1].extend([edge_id] * len(x)) + indices[0].extend(list(x)) + incidence = torch.sparse_coo_tensor( + indices, torch.ones(len(indices[0])), (len(data.x), len(s_hyperedges)) + ) + return { + "incidence_hyperedges": incidence, + "num_hyperedges": len(s_hyperedges), + "x_0": data.x, + } + + def build_stemmingTree(self, G, source_root, length, verbose=False): + """Creates a directed tree from a source node with paths of a given length.""" + d_id2label = {} + stack = [] + D = nx.DiGraph() + n_id = 0 + D.add_node(n_id) + d_id2label[n_id] = source_root + stack.append(n_id) + n_id += 1 + l_leafs = [] + while len(stack) > 0: + node = stack.pop() + neighbors = list(G.neighbors(d_id2label[node])) + visited_id = nx.shortest_path(D, source=0, target=node) + visited_labels = [d_id2label[i] for i in visited_id] + for neighbor in neighbors: + if neighbor not in visited_labels: + D.add_node(n_id) + d_id2label[n_id] = neighbor + if len(visited_labels) < length: + stack.append(n_id) + elif len(visited_labels) == length: + l_leafs.append(n_id) + else: + raise ValueError("Visited labels length is greater than length") + D.add_edge(node, n_id) + n_id += 1 + if verbose: + print("\nLoop Variables Summary:") + print("nodes:", node) + print("neighbors:", neighbors) + print("visited_id:", visited_id) + print("visited_labels:", visited_labels) + print("stack:", stack) + print("id2label:", d_id2label) + return D, d_id2label, l_leafs + + def extract_hyperedgesFromStemmingTree(self, D, d_id2label, l_leafs): + """From the root of the directed tree D, + extract hyperedges from the paths to the leafs.""" + a_paths = np.array( + [list(map(d_id2label.get, nx.shortest_path(D, 0, x))) for x in l_leafs] + ) + s_hyperedges = { + (frozenset(x)) for x in a_paths + } # set bc != paths can be same hpedge + if self.include_smaller_paths: + for i in range(a_paths.shape[1] - 1, 1, -1): + a_paths = np.unique(a_paths[:, :i], axis=0) + s_hyperedges = s_hyperedges.union({(frozenset(x)) for x in a_paths}) + return s_hyperedges From 11df3be940b2cb5382d1f0e7702447bde2331ba8 Mon Sep 17 00:00:00 2001 From: pierrick Date: Thu, 11 Jul 2024 15:20:57 +0200 Subject: [PATCH 2/8] added tuto notebook --- tutorials/graph2hypergraph/path_lifting.ipynb | 343 ++++++++++++++++++ 1 file changed, 343 insertions(+) create mode 100644 tutorials/graph2hypergraph/path_lifting.ipynb diff --git a/tutorials/graph2hypergraph/path_lifting.ipynb b/tutorials/graph2hypergraph/path_lifting.ipynb new file mode 100644 index 00000000..e3a29871 --- /dev/null +++ b/tutorials/graph2hypergraph/path_lifting.ipynb @@ -0,0 +1,343 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Graph-to-Hypergraph Path 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, creates a a dataset object and visualizes it.\n", + "- [Loading and applying the lifting](#loading-and-applying-the-lifting) the desired lifting tranformation is configured and applied.\n", + "- [Create and run a simplicial nn model](#create-and-run-a-simplicial-nn-model) defines a simple neural network and simply runs a forward pass 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 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": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "# With this cell any imported module is reloaded before each cell execution\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "import sys\n", + "\n", + "sys.path.append(\"../..\")\n", + "from modules.data.load.loaders import GraphLoader\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": 11, + "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": "code", + "execution_count": 12, + "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": [ + "In this section we will instantiate the lifting we want to apply to the data. For this example the knn lifting was chosen. The algorithm takes the k nearest neighbors for each node and creates a hyperedge with them. The lifting is deterministic and creates a hypergraph with the same number of hyperedges as the number of nodes, and all the hyperedges have the same number of nodes in them. This lifting is based on the initial features of the nodes. The computational complexity of the algorithm is $O(nd+kn)$ [[1]](https://pubmed.ncbi.nlm.nih.gov/33211654/) where $n$ is the number of nodes in the graph, $d$ is the dimension of the feature space and $k$ is fixed.\n", + "\n", + "***\n", + "[[1]](https://pubmed.ncbi.nlm.nih.gov/33211654/) Gao, Y., Zhang, Z., Lin, H., Zhao, X., Du, S., & Zou, C. (2020). Hypergraph learning: Methods and\n", + "practices. IEEE Transactions on Pattern Analysis and Machine Intelligence, 44(5), 2548-2566.\n", + "***\n", + "\n", + "For hypergraphs creating a lifting involves creating the `incidence_hyperedges` matrix.\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": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Transform configuration for graph2hypergraph/path_lifting:\n", + "\n", + "{'transform_type': 'lifting',\n", + " 'transform_name': 'PathLifting',\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 = \"graph2hypergraph/path_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", + "}\n", + "# add required arguments\n", + "transform_config[\"lifting\"][\"source_nodes\"] = [1]\n", + "transform_config[\"lifting\"][\"target_nodes\"] = [2]\n", + "transform_config[\"lifting\"][\"lengths\"] = [2]\n", + "\n", + "# select a value for optional argument\n", + "transform_config[\"lifting\"][\"include_smaller_paths\"] = False" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transform parameters are the same, using existing data_dir: /home/pierrick/local/challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/480906646\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": [ + " - Hypergraph with 8 vertices and 2 hyperedges.\n", + " - The nodes have feature dimensions 1.\n", + " - The hyperedges have feature dimensions 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 an hypergraph 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 `incidence_hyperedges` matrix so the lifting should make sure to add it to the data." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Model configuration for hypergraph UNIGCN:\n", + "\n", + "{'in_channels': None,\n", + " 'hidden_channels': 32,\n", + " 'out_channels': None,\n", + " 'n_layers': 2}\n" + ] + } + ], + "source": [ + "from modules.models.hypergraph.unigcn import UniGCNModel\n", + "\n", + "model_type = \"hypergraph\"\n", + "model_id = \"unigcn\"\n", + "model_config = load_model_config(model_type, model_id)\n", + "\n", + "model = UniGCNModel(model_config, dataset_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "y_hat = model(lifted_dataset.get(0))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "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 +} From df87a7094eda4400cb69332e6d1829cf9c42af35 Mon Sep 17 00:00:00 2001 From: pierrick Date: Thu, 11 Jul 2024 18:16:25 +0200 Subject: [PATCH 3/8] added tests --- .../graph2hypergraph/test_path_lifting.py | 154 ++++++++++++++++++ tutorials/graph2hypergraph/path_lifting.ipynb | 42 ++--- 2 files changed, 164 insertions(+), 32 deletions(-) create mode 100644 test/transforms/liftings/graph2hypergraph/test_path_lifting.py diff --git a/test/transforms/liftings/graph2hypergraph/test_path_lifting.py b/test/transforms/liftings/graph2hypergraph/test_path_lifting.py new file mode 100644 index 00000000..a8dd9cc3 --- /dev/null +++ b/test/transforms/liftings/graph2hypergraph/test_path_lifting.py @@ -0,0 +1,154 @@ +"""Test the path lifting module.""" + +import numpy as np + +from modules.data.load.loaders import GraphLoader +from modules.transforms.liftings.graph2hypergraph.path_lifting import PathLifting +from modules.utils.utils import load_dataset_config + + +class TestHypergraphPathLifting: + """Test the PathLifting class.""" + + def setup_method(self): + """Initialise the PathLifting class.""" + dataset_config = load_dataset_config("manual_dataset") + loader = GraphLoader(dataset_config) + self.dataset = loader.load() + self.data = self.dataset._data + + def test_true(self): + """Naive test to check if the test is running.""" + assert True + + # def test_false(self): + # """Naive test to check if the test is running.""" + # assert False + + def test_1(self): + """Verifies setup_method is working.""" + assert self.dataset is not None + + def test_2(self): + """test: no target node for one source node returns something""" + source_nodes = [0, 2] + target_nodes = [1, None] + lengths = [2, 2] + include_smaller_paths = True + path_lifting = PathLifting( + source_nodes, + target_nodes, + lengths, + include_smaller_paths=include_smaller_paths, + ) + res = path_lifting.find_hyperedges(self.data) + res_expected = [ + [0, 1], + [0, 1, 2], + [0, 4, 1], + [2, 4], + [2, 1], + [2, 0], + [2, 7], + [2, 5], + [2, 3], + [2, 1, 4], + [2, 4, 0], + [2, 1, 0], + [2, 0, 7], + [2, 5, 7], + [2, 3, 6], + [2, 5, 6], + # [], + ] + assert {frozenset(x) for x in res_expected} == res + + def test_3(self): + """test: include_smaller_paths=False""" + source_nodes = [0] + target_nodes = [1] + lengths = [2] + include_smaller_paths = False + res = PathLifting( + source_nodes, + target_nodes, + lengths, + include_smaller_paths=include_smaller_paths, + ).find_hyperedges(self.data) + assert not frozenset({0, 1}) in res + + def test_4(self): + """test: include_smaller_paths=True""" + source_nodes = [0] + target_nodes = [1] + lengths = [2] + include_smaller_paths = True + res = PathLifting( + source_nodes, + target_nodes, + lengths, + include_smaller_paths=include_smaller_paths, + ).find_hyperedges(self.data) + assert frozenset({0, 1}) in res + + def test_5(self): + """test: when include_smaller_paths=False all paths have the length specified""" + source_nodes = [0] + target_nodes = [1] + include_smaller_paths = False + for k in range(1, 5): + lengths = [k] + res = PathLifting( + source_nodes, + target_nodes, + lengths, + include_smaller_paths=include_smaller_paths, + ).find_hyperedges(self.data) + assert np.array([len(x) - 1 == k for x in res]).all() + + def test_6(self): + """test: no target node global returns something""" + source_nodes = [0, 1] + target_nodes = None + lengths = [2, 2] + include_smaller_paths = False + res = PathLifting( + source_nodes, + target_nodes, + lengths, + include_smaller_paths=include_smaller_paths, + ).find_hyperedges(self.data) + assert len(res) > 0 + + def test_7(self): + """test: every hyperedge contains the source and target nodes when specified""" + a = np.random.choice(np.arange(len(self.data.x)), 2, replace=False) + source_nodes = [a[0]] + target_nodes = [a[1]] + lengths = [np.random.randint(1, 5)] + include_smaller_paths = False + res = PathLifting( + source_nodes, + target_nodes, + lengths, + include_smaller_paths=include_smaller_paths, + ).find_hyperedges(self.data) + if len(res) > 0: + assert ( + np.array([source_nodes[0] in x for x in res]).all() + and np.array([target_nodes[0] in x for x in res]).all() + ) + + def test_8(self): + """test: no target node for one source node returns something""" + source_nodes = [0, 2] + target_nodes = [1, None] + lengths = [2, 2] + include_smaller_paths = False + res = PathLifting( + source_nodes, + target_nodes, + lengths, + include_smaller_paths=include_smaller_paths, + ).find_hyperedges(self.data) + assert len(res) > 0 diff --git a/tutorials/graph2hypergraph/path_lifting.ipynb b/tutorials/graph2hypergraph/path_lifting.ipynb index e3a29871..5269dada 100644 --- a/tutorials/graph2hypergraph/path_lifting.ipynb +++ b/tutorials/graph2hypergraph/path_lifting.ipynb @@ -48,18 +48,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "# With this cell any imported module is reloaded before each cell execution\n", "%load_ext autoreload\n", @@ -88,12 +79,12 @@ "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" + "Here we just need to specify 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`." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -124,7 +115,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -172,25 +163,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In this section we will instantiate the lifting we want to apply to the data. For this example the knn lifting was chosen. The algorithm takes the k nearest neighbors for each node and creates a hyperedge with them. The lifting is deterministic and creates a hypergraph with the same number of hyperedges as the number of nodes, and all the hyperedges have the same number of nodes in them. This lifting is based on the initial features of the nodes. The computational complexity of the algorithm is $O(nd+kn)$ [[1]](https://pubmed.ncbi.nlm.nih.gov/33211654/) where $n$ is the number of nodes in the graph, $d$ is the dimension of the feature space and $k$ is fixed.\n", - "\n", - "***\n", - "[[1]](https://pubmed.ncbi.nlm.nih.gov/33211654/) Gao, Y., Zhang, Z., Lin, H., Zhao, X., Du, S., & Zou, C. (2020). Hypergraph learning: Methods and\n", - "practices. IEEE Transactions on Pattern Analysis and Machine Intelligence, 44(5), 2548-2566.\n", - "***\n", - "\n", - "For hypergraphs creating a lifting involves creating the `incidence_hyperedges` matrix.\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. " + "In this section we will instantiate the lifting we want to apply to the data." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -228,7 +206,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -282,7 +260,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -311,7 +289,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ From 5676e4e7ac5b8325a53b5ee24a112c2c9292a973 Mon Sep 17 00:00:00 2001 From: pierrick Date: Thu, 11 Jul 2024 18:17:31 +0200 Subject: [PATCH 4/8] fix bug in plot_manual_graph --- modules/utils/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/utils/utils.py b/modules/utils/utils.py index 1dfcdc2e..54e955d5 100644 --- a/modules/utils/utils.py +++ b/modules/utils/utils.py @@ -233,7 +233,7 @@ def sort_vertices_ccw(vertices): n_hyperedges = incidence.shape[1] vertices += [i + n_vertices for i in range(n_hyperedges)] indices = incidence.indices() - edges = np.array([indices[1].numpy(), indices[0].numpy() + n_vertices]).T + edges = np.array([indices[0].numpy(), indices[1].numpy() + n_vertices]).T pos_n = [[i, 0] for i in range(n_vertices)] pos_he = [[i, 1] for i in range(n_hyperedges)] pos = pos_n + pos_he From cb007ef129285ae459e5f3e698bf87fc3a9c3336 Mon Sep 17 00:00:00 2001 From: pierrick Date: Fri, 12 Jul 2024 00:36:58 +0200 Subject: [PATCH 5/8] refactoring for ruff check --- .../transforms/liftings/graph2hypergraph/path_lifting.py | 4 ++-- .../liftings/graph2hypergraph/test_path_lifting.py | 8 +++++--- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/modules/transforms/liftings/graph2hypergraph/path_lifting.py b/modules/transforms/liftings/graph2hypergraph/path_lifting.py index f3a29ea2..634a182e 100644 --- a/modules/transforms/liftings/graph2hypergraph/path_lifting.py +++ b/modules/transforms/liftings/graph2hypergraph/path_lifting.py @@ -43,14 +43,14 @@ def find_hyperedges(self, data: torch_geometric.data.Data): s_hyperedges = set() if self.target_nodes is None: # all paths stemming from source nodes only - for source, length in zip(self.source_nodes, self.lengths): + for source, length in zip(self.source_nodes, self.lengths, strict=True): D, d_id2label, l_leafs = self.build_stemmingTree(G, source, length) s = self.extract_hyperedgesFromStemmingTree(D, d_id2label, l_leafs) s_hyperedges = s_hyperedges.union(s) else: # paths from source_nodes to target_nodes or from source nodes only for source, target, length in zip( - self.source_nodes, self.target_nodes, self.lengths + self.source_nodes, self.target_nodes, self.lengths, strict=True ): if target is None: D, d_id2label, l_leafs = self.build_stemmingTree(G, source, length) diff --git a/test/transforms/liftings/graph2hypergraph/test_path_lifting.py b/test/transforms/liftings/graph2hypergraph/test_path_lifting.py index a8dd9cc3..56429eb0 100644 --- a/test/transforms/liftings/graph2hypergraph/test_path_lifting.py +++ b/test/transforms/liftings/graph2hypergraph/test_path_lifting.py @@ -75,7 +75,7 @@ def test_3(self): lengths, include_smaller_paths=include_smaller_paths, ).find_hyperedges(self.data) - assert not frozenset({0, 1}) in res + assert frozenset({0, 1}) not in res def test_4(self): """test: include_smaller_paths=True""" @@ -122,10 +122,12 @@ def test_6(self): def test_7(self): """test: every hyperedge contains the source and target nodes when specified""" - a = np.random.choice(np.arange(len(self.data.x)), 2, replace=False) + a = np.random.default_rng().choice( + np.arange(len(self.data.x)), 2, replace=False + ) source_nodes = [a[0]] target_nodes = [a[1]] - lengths = [np.random.randint(1, 5)] + lengths = [np.random.default_rng().integers(1, 5)] include_smaller_paths = False res = PathLifting( source_nodes, From b26701f125c27fd027fe65cd78c377290e8b7209 Mon Sep 17 00:00:00 2001 From: pierrick Date: Fri, 12 Jul 2024 15:41:06 +0200 Subject: [PATCH 6/8] added default behavior of path lifting --- .../liftings/graph2hypergraph/path_lifting.py | 25 +++++++++++++------ 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/modules/transforms/liftings/graph2hypergraph/path_lifting.py b/modules/transforms/liftings/graph2hypergraph/path_lifting.py index 634a182e..0f1811c2 100644 --- a/modules/transforms/liftings/graph2hypergraph/path_lifting.py +++ b/modules/transforms/liftings/graph2hypergraph/path_lifting.py @@ -12,24 +12,24 @@ class PathLifting(Graph2HypergraphLifting): def __init__( self, - source_nodes: list[int], - target_nodes: list[int], - lengths: list[int], + source_nodes: list[int] = None, + target_nodes: list[int] = None, + lengths: list[int] = None, include_smaller_paths=False, **kwargs, ): # guard clauses - if len(source_nodes) != len(lengths): + if ( + lengths is not None + and source_nodes is not None + and len(source_nodes) != len(lengths) + ): raise ValueError("source_nodes and lengths must have the same length") if target_nodes is not None and len(target_nodes) != len(source_nodes): raise ValueError( "When target_nodes is not None, it must have the same length" "as source_nodes" ) - if len(source_nodes) == 0: - raise ValueError( - "source_nodes,target_nodes and lengths must have at least one element" - ) super().__init__(**kwargs) self.source_nodes = source_nodes @@ -37,6 +37,13 @@ def __init__( self.lengths = lengths self.include_smaller_paths = include_smaller_paths + def value_defaults(self, data: torch_geometric.data.Data): + """Sets default values for source_nodes and lengths if not provided.""" + if self.source_nodes is None: + self.source_nodes = np.arange(data.num_nodes) + if self.lengths is None: + self.lengths = [2] * len(self.source_nodes) + def find_hyperedges(self, data: torch_geometric.data.Data): """Finds hyperedges from paths between nodes in a graph.""" G = torch_geometric.utils.convert.to_networkx(data, to_undirected=True) @@ -68,6 +75,8 @@ def find_hyperedges(self, data: torch_geometric.data.Data): return s_hyperedges def lift_topology(self, data: torch_geometric.data.Data): + if self.source_nodes is None or self.lengths is None: + self.value_defaults(data) s_hyperedges = self.find_hyperedges(data) indices = [[], []] for edge_id, x in enumerate(s_hyperedges): From 4754e6c28f1a632da3b0e7999103790b5addabbd Mon Sep 17 00:00:00 2001 From: pierrick Date: Fri, 12 Jul 2024 17:54:06 +0200 Subject: [PATCH 7/8] refactor for ruff check --- .../transforms/liftings/graph2hypergraph/path_lifting.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/modules/transforms/liftings/graph2hypergraph/path_lifting.py b/modules/transforms/liftings/graph2hypergraph/path_lifting.py index 0f1811c2..75e0d43a 100644 --- a/modules/transforms/liftings/graph2hypergraph/path_lifting.py +++ b/modules/transforms/liftings/graph2hypergraph/path_lifting.py @@ -12,9 +12,9 @@ class PathLifting(Graph2HypergraphLifting): def __init__( self, - source_nodes: list[int] = None, - target_nodes: list[int] = None, - lengths: list[int] = None, + source_nodes: list[int] | None = None, + target_nodes: list[int] | None = None, + lengths: list[int] | None = None, include_smaller_paths=False, **kwargs, ): From 541045313257266692a318680715cb9ad1dddd21 Mon Sep 17 00:00:00 2001 From: pierrick Date: Fri, 12 Jul 2024 23:58:05 +0200 Subject: [PATCH 8/8] improved code readability --- .../liftings/graph2hypergraph/path_lifting.py | 70 ++++- .../graph2hypergraph/test_path_lifting.py | 14 +- tutorials/graph2hypergraph/path_lifting.ipynb | 286 +++++++++++++++++- 3 files changed, 338 insertions(+), 32 deletions(-) diff --git a/modules/transforms/liftings/graph2hypergraph/path_lifting.py b/modules/transforms/liftings/graph2hypergraph/path_lifting.py index 0f1811c2..59061776 100644 --- a/modules/transforms/liftings/graph2hypergraph/path_lifting.py +++ b/modules/transforms/liftings/graph2hypergraph/path_lifting.py @@ -18,6 +18,22 @@ def __init__( include_smaller_paths=False, **kwargs, ): + """Init function + + Args: + source_nodes (list[int], optional): a list of nodes from which to start the paths. + Defaults to None in __init__ but is later valued in value_defaults(). + target_nodes (list[int], optional): a list of nodes where the paths must end. + Defaults to None. + lengths (list[int], optional): a list of paths lenghts. + Defaults to None in __init__ but is later valued in value_defaults(). + include_smaller_paths (bool, optional): whether or not to include paths from source + to target smaller than the length specified. Defaults to False. + + Raises: + ValueError: when provided source_nodes and lengths must have the same length + ValueError: when provided target_nodes and source_nodes must have the same length + """ # guard clauses if ( lengths is not None @@ -37,22 +53,22 @@ def __init__( self.lengths = lengths self.include_smaller_paths = include_smaller_paths - def value_defaults(self, data: torch_geometric.data.Data): + def _value_defaults(self, data: torch_geometric.data.Data): """Sets default values for source_nodes and lengths if not provided.""" if self.source_nodes is None: self.source_nodes = np.arange(data.num_nodes) if self.lengths is None: self.lengths = [2] * len(self.source_nodes) - def find_hyperedges(self, data: torch_geometric.data.Data): + def _find_hyperedges(self, data: torch_geometric.data.Data): """Finds hyperedges from paths between nodes in a graph.""" G = torch_geometric.utils.convert.to_networkx(data, to_undirected=True) s_hyperedges = set() if self.target_nodes is None: # all paths stemming from source nodes only for source, length in zip(self.source_nodes, self.lengths, strict=True): - D, d_id2label, l_leafs = self.build_stemmingTree(G, source, length) - s = self.extract_hyperedgesFromStemmingTree(D, d_id2label, l_leafs) + D, d_id2label, l_leafs = self._build_stemmingTree(G, source, length) + s = self._extract_hyperedgesFromStemmingTree(D, d_id2label, l_leafs) s_hyperedges = s_hyperedges.union(s) else: # paths from source_nodes to target_nodes or from source nodes only @@ -60,8 +76,8 @@ def find_hyperedges(self, data: torch_geometric.data.Data): self.source_nodes, self.target_nodes, self.lengths, strict=True ): if target is None: - D, d_id2label, l_leafs = self.build_stemmingTree(G, source, length) - s = self.extract_hyperedgesFromStemmingTree(D, d_id2label, l_leafs) + D, d_id2label, l_leafs = self._build_stemmingTree(G, source, length) + s = self._extract_hyperedgesFromStemmingTree(D, d_id2label, l_leafs) s_hyperedges = s_hyperedges.union(s) else: paths = list( @@ -75,9 +91,10 @@ def find_hyperedges(self, data: torch_geometric.data.Data): return s_hyperedges def lift_topology(self, data: torch_geometric.data.Data): + """Lifts the graph data to a hypergraph by considering paths between nodes.""" if self.source_nodes is None or self.lengths is None: - self.value_defaults(data) - s_hyperedges = self.find_hyperedges(data) + self._value_defaults(data) + s_hyperedges = self._find_hyperedges(data) indices = [[], []] for edge_id, x in enumerate(s_hyperedges): indices[1].extend([edge_id] * len(x)) @@ -91,8 +108,22 @@ def lift_topology(self, data: torch_geometric.data.Data): "x_0": data.x, } - def build_stemmingTree(self, G, source_root, length, verbose=False): - """Creates a directed tree from a source node with paths of a given length.""" + def _build_stemmingTree(self, G, source_root, length, verbose=False): + """Creates a directed tree from a source node with paths of a given length. + This directed tree has as root the source node and paths stemming from it. + This tree is used to extract hyperedges from paths to leafs. + + Args: + G (networkx.classes.graph.Graph): the original graph + source_root (int): the source node from which to start the paths + length (int): the length of the paths + verbose (bool, optional): Defaults to False. + + Returns: + D (networkx.classes.graph.DiGraph): a directed tree stemming from source_root + d_id2label (dict): a dictionary mapping node ids to node labels + l_leafs (list): a list of leaf nodes ids + """ d_id2label = {} stack = [] D = nx.DiGraph() @@ -115,11 +146,11 @@ def build_stemmingTree(self, G, source_root, length, verbose=False): stack.append(n_id) elif len(visited_labels) == length: l_leafs.append(n_id) - else: + else: # security check raise ValueError("Visited labels length is greater than length") D.add_edge(node, n_id) n_id += 1 - if verbose: + if verbose: # output information during the process print("\nLoop Variables Summary:") print("nodes:", node) print("neighbors:", neighbors) @@ -129,15 +160,24 @@ def build_stemmingTree(self, G, source_root, length, verbose=False): print("id2label:", d_id2label) return D, d_id2label, l_leafs - def extract_hyperedgesFromStemmingTree(self, D, d_id2label, l_leafs): + def _extract_hyperedgesFromStemmingTree(self, D, d_id2label, l_leafs): """From the root of the directed tree D, - extract hyperedges from the paths to the leafs.""" + extract hyperedges from the paths to the leafs. + + Args: + D (networkx.classes.graph.DiGraph): a directed tree stemming from source_root + d_id2label (dict): a dictionary mapping node ids to node labels + l_leafs (list): a list of leaf nodes ids + + Returns: + _type_: _description_ + """ a_paths = np.array( [list(map(d_id2label.get, nx.shortest_path(D, 0, x))) for x in l_leafs] ) s_hyperedges = { (frozenset(x)) for x in a_paths - } # set bc != paths can be same hpedge + } # set because different paths can be same hyperedge if self.include_smaller_paths: for i in range(a_paths.shape[1] - 1, 1, -1): a_paths = np.unique(a_paths[:, :i], axis=0) diff --git a/test/transforms/liftings/graph2hypergraph/test_path_lifting.py b/test/transforms/liftings/graph2hypergraph/test_path_lifting.py index 56429eb0..ad64229e 100644 --- a/test/transforms/liftings/graph2hypergraph/test_path_lifting.py +++ b/test/transforms/liftings/graph2hypergraph/test_path_lifting.py @@ -41,7 +41,7 @@ def test_2(self): lengths, include_smaller_paths=include_smaller_paths, ) - res = path_lifting.find_hyperedges(self.data) + res = path_lifting._find_hyperedges(self.data) res_expected = [ [0, 1], [0, 1, 2], @@ -74,7 +74,7 @@ def test_3(self): target_nodes, lengths, include_smaller_paths=include_smaller_paths, - ).find_hyperedges(self.data) + )._find_hyperedges(self.data) assert frozenset({0, 1}) not in res def test_4(self): @@ -88,7 +88,7 @@ def test_4(self): target_nodes, lengths, include_smaller_paths=include_smaller_paths, - ).find_hyperedges(self.data) + )._find_hyperedges(self.data) assert frozenset({0, 1}) in res def test_5(self): @@ -103,7 +103,7 @@ def test_5(self): target_nodes, lengths, include_smaller_paths=include_smaller_paths, - ).find_hyperedges(self.data) + )._find_hyperedges(self.data) assert np.array([len(x) - 1 == k for x in res]).all() def test_6(self): @@ -117,7 +117,7 @@ def test_6(self): target_nodes, lengths, include_smaller_paths=include_smaller_paths, - ).find_hyperedges(self.data) + )._find_hyperedges(self.data) assert len(res) > 0 def test_7(self): @@ -134,7 +134,7 @@ def test_7(self): target_nodes, lengths, include_smaller_paths=include_smaller_paths, - ).find_hyperedges(self.data) + )._find_hyperedges(self.data) if len(res) > 0: assert ( np.array([source_nodes[0] in x for x in res]).all() @@ -152,5 +152,5 @@ def test_8(self): target_nodes, lengths, include_smaller_paths=include_smaller_paths, - ).find_hyperedges(self.data) + )._find_hyperedges(self.data) assert len(res) > 0 diff --git a/tutorials/graph2hypergraph/path_lifting.ipynb b/tutorials/graph2hypergraph/path_lifting.ipynb index 5269dada..610a7184 100644 --- a/tutorials/graph2hypergraph/path_lifting.ipynb +++ b/tutorials/graph2hypergraph/path_lifting.ipynb @@ -156,14 +156,24 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Loading and Applying the Lifting" + "## Loading and Applying the Lifting\n", + "In this section we will instantiate the lifting we want to apply to the data.\n", + "***\n", + "**Description of the lifting**\n", + "\n", + "This lifting is based on paths. Intuitively, we specify which paths are of interest by giving for each path a source node, a length and optionally a target node.\n", + "Formally the lifting is parametrized by a set of tuples of the form: $$(u, v, n) \\in V\\times V\\times\\mathbb N^{*}$$\n", + "where $V$ is the set of vertices and $n$ is the length of the paths between nodes $u$ and $v$. The lifting is then a family of such tuples $(u_i, v_i, n_i)$.\n", + "The graph is treated as undirected. Features are lifted using the standard sum projection according to the incidence matrix.\n", + "***" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "In this section we will instantiate the lifting we want to apply to the data." + "### Example 1: basic\n", + "Here we define a path lifting where paths are between node 1 (source) and node 2 (target) and have exactly length 2. This is specified by the parameter ```include_smaller_paths```. There are two hyperedges in the results corresponding to path (v1, v0, V2) and (v1, v4, V2)" ] }, { @@ -195,13 +205,10 @@ " \"lifting\": load_transform_config(transform_type, transform_id)\n", " # other transforms (e.g. data manipulations, feature liftings) can be added here\n", "}\n", - "# add required arguments\n", + "# parametrize the transform\n", "transform_config[\"lifting\"][\"source_nodes\"] = [1]\n", "transform_config[\"lifting\"][\"target_nodes\"] = [2]\n", - "transform_config[\"lifting\"][\"lengths\"] = [2]\n", - "\n", - "# select a value for optional argument\n", - "transform_config[\"lifting\"][\"include_smaller_paths\"] = False" + "transform_config[\"lifting\"][\"lengths\"] = [2]" ] }, { @@ -213,11 +220,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "Transform parameters are the same, using existing data_dir: /home/pierrick/local/challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/480906646\n", "\n", "Dataset only contains 1 sample:\n" ] }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing...\n", + "Done!\n" + ] + }, { "data": { "image/png": "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", @@ -244,6 +258,258 @@ "describe_data(lifted_dataset)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example 2: adding shorter paths\n", + "Here we define the same path lifting as before but we include all paths shorter than the specified length as it is indicated by ```include_smaller_paths=True```. Indeed, we see that another hyperedge is added." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Transform configuration for graph2hypergraph/path_lifting:\n", + "\n", + "{'transform_type': 'lifting',\n", + " 'transform_name': 'PathLifting',\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 = \"graph2hypergraph/path_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", + "}\n", + "# parametrize the transform\n", + "transform_config[\"lifting\"][\"source_nodes\"] = [1]\n", + "transform_config[\"lifting\"][\"target_nodes\"] = [2]\n", + "transform_config[\"lifting\"][\"lengths\"] = [2]\n", + "transform_config[\"lifting\"][\"include_smaller_paths\"] = True" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transform parameters are the same, using existing data_dir: /home/pierrick/local/challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/2187712706\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": [ + " - Hypergraph with 8 vertices and 3 hyperedges.\n", + " - The nodes have feature dimensions 1.\n", + " - The hyperedges have feature dimensions 1.\n", + "\n" + ] + } + ], + "source": [ + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example 3: multiple sources and targets\n", + "We can ask for paths stemming from multiple nodes, it is done by passing to the parameter ```source_nodes``` multiple elements in the list. The ```target_nodes``` list and ```lengths``` list contain as much elements as ```source_nodes``` does. When an element of ```target_nodes``` is None, then there is no target for this node and all paths paths stemming from the source are keps, indifferently of where they finish." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Transform configuration for graph2hypergraph/path_lifting:\n", + "\n", + "{'transform_type': 'lifting',\n", + " 'transform_name': 'PathLifting',\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 = \"graph2hypergraph/path_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", + "}\n", + "# parametrize the transform\n", + "transform_config[\"lifting\"][\"source_nodes\"] = [1, 5, 0]\n", + "transform_config[\"lifting\"][\"target_nodes\"] = [2, 6, None]\n", + "transform_config[\"lifting\"][\"lengths\"] = [2, 3, 1]\n", + "transform_config[\"lifting\"][\"include_smaller_paths\"] = False" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transform parameters are the same, using existing data_dir: /home/pierrick/local/challenge-icml-2024/datasets/graph/toy_dataset/manual/lifting/3803470566\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": [ + " - Hypergraph with 8 vertices and 7 hyperedges.\n", + " - The nodes have feature dimensions 1.\n", + " - The hyperedges have feature dimensions 1.\n", + "\n" + ] + } + ], + "source": [ + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example 4: randomized lifting\n", + "The hyperedge generation can be randomized, here we draw paths between 3 pairs of nodes." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Transform configuration for graph2hypergraph/path_lifting:\n", + "\n", + "{'transform_type': 'lifting',\n", + " 'transform_name': 'PathLifting',\n", + " 'feature_lifting': 'ProjectionSum'}\n", + "\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": [ + " - Hypergraph with 8 vertices and 6 hyperedges.\n", + " - The nodes have feature dimensions 1.\n", + " - The hyperedges have feature dimensions 1.\n", + "\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "# 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 = \"graph2hypergraph/path_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", + "}\n", + "# parametrize the transform\n", + "transform_config[\"lifting\"][\"source_nodes\"] = torch.randint(\n", + " 0, dataset._data.num_nodes, (3,)\n", + ").tolist()\n", + "transform_config[\"lifting\"][\"target_nodes\"] = torch.randint(\n", + " 0, dataset._data.num_nodes, (3,)\n", + ").tolist()\n", + "transform_config[\"lifting\"][\"lengths\"] = torch.randint(\n", + " 0, dataset._data.num_nodes, (3,)\n", + ").tolist()\n", + "transform_config[\"lifting\"][\"include_smaller_paths\"] = False\n", + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "describe_data(lifted_dataset)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -260,7 +526,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -289,7 +555,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [