From 17acfb110796ac1a519e7ad286551afd5c95b37c Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sun, 7 Jul 2024 12:37:34 -0400 Subject: [PATCH 01/11] first commit - create class --- .../discrete_configuration_complex_lifting.py | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py diff --git a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py new file mode 100644 index 00000000..e2ed1067 --- /dev/null +++ b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py @@ -0,0 +1,40 @@ +import networkx as nx +import torch_geometric +from toponetx.classes import CellComplex + +from modules.transforms.liftings.graph2cell.base import Graph2CellLifting + + +class CellCycleLifting(Graph2CellLifting): + r"""Lifts graphs to cell complexes by generating the k-th *discrete configuration complex* $D_k(G)$ of the graph. This is a cube complex, which is similar to a simplicial complex except each n-dimensional cell is homeomorphic to a n-dimensional cube rather than an n-dimensional simplex. + + The discrete configuration complex of order k consists of all sets of k unique edges or vertices of $G$, with the additional constraint that if an edge e is in a cell, then neither of the endpoints of e are in the cell. For examples of different graphs and their configuration complexes, see the tutorial. + + Parameters + ---------- + k : int + The order of the configuration complex, or the number of 'points' in the configuration. + **kwargs : optional + Additional arguments for the class. + """ + + def __init__(self, k: int, **kwargs): + super().__init__(**kwargs) + self.k = k + + def lift_topology(self, data: torch_geometric.data.Data) -> dict: + r"""Generates the cubical complex of discrete graph configurations. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data to be lifted. + + Returns + ------- + dict + The lifted topology. + """ + G = self._generate_graph_from_data(data) + cell_complex = CellComplex(G) + return From 29f49af9c58fbfc81ac9b56bfe46d7c8fa81f3a1 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Fri, 12 Jul 2024 20:13:20 -0400 Subject: [PATCH 02/11] wip --- .../discrete_configuration_complex_lifting.py | 106 +++++++++++++++++- 1 file changed, 101 insertions(+), 5 deletions(-) diff --git a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py index e2ed1067..f1e55a6d 100644 --- a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py +++ b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py @@ -1,24 +1,110 @@ +from itertools import permutations +from typing import Tuple + import networkx as nx import torch_geometric from toponetx.classes import CellComplex from modules.transforms.liftings.graph2cell.base import Graph2CellLifting +Vertex = int +Edge = Tuple[Vertex, Vertex] +ConfigurationTuple = Tuple[Vertex | Edge] + + +def DiscreteConfigurationComplex(k: int, graph: nx.Graph): + class Configuration: + _instances: dict[ConfigurationTuple, "Configuration"] = {} + _counter = 0 + + def __new__(cls, configuration_tuple: ConfigurationTuple): + # Create a key from the arguments + key = configuration + + # If an instance doesn't exist for these arguments, create one + if key not in cls._instances: + cls._instances[key] = super().__new__(cls) + + # Return the instance for these arguments + return cls._instances[key] + + def __init__(self, configuration_tuple: ConfigurationTuple) -> None: + if hasattr(self, "initialized"): + return + + self.initialized = True + self.configuration_tuple = configuration_tuple + self.neighborhood = set() + self.dim = 0 + for agent in configuration_tuple: + if isinstance(agent, Edge): + self.neighborhood.update(set(agent)) + self.dim += 1 + else: + self.neighborhood.add(agent) + + if self.dim == 0: + self.contents = {Configuration._counter} + Configuration._counter += 1 + else: + self.contents = set() + + self._upwards_neighbors_generated = False + self._generate_upwards_neighbors() -class CellCycleLifting(Graph2CellLifting): + def _generate_upwards_neighbors(self): + if self._upwards_neighbors_generated: + return + self._upwards_neighbors_generated = True + for i, agent in enumerate(self.configuration_tuple): + if isinstance(agent, Edge): + continue + for neighbor in graph[agent]: + self._generate_new_configuration(i, agent, neighbor) + + def _generate_new_configuration( + self, index: int, vertex_agent: Vertex, neighbor: Vertex + ): + if neighbor in self.neighborhood: + return + new_edge = (min(vertex_agent, neighbor), max(vertex_agent, neighbor)) + new_configuration_tuple = ( + *self.configuration_tuple[:index], + new_edge, + *self.configuration_tuple[index + 1 :], + ) + new_configuration = Configuration(new_configuration_tuple) + new_configuration.contents.add(frozenset(self.contents)) + new_configuration._generate_upwards_neighbors() + + for dim_0_configuration_tuple in permutations(graph, k): + configuration = Configuration(dim_0_configuration_tuple) + + cells = {i: [] for i in range(k + 1)} + for conf in Configuration._instances.values(): + cells[conf.dim].append(conf.contents) + + return cells + + +class DiscreteConfigurationLifting(Graph2CellLifting): r"""Lifts graphs to cell complexes by generating the k-th *discrete configuration complex* $D_k(G)$ of the graph. This is a cube complex, which is similar to a simplicial complex except each n-dimensional cell is homeomorphic to a n-dimensional cube rather than an n-dimensional simplex. The discrete configuration complex of order k consists of all sets of k unique edges or vertices of $G$, with the additional constraint that if an edge e is in a cell, then neither of the endpoints of e are in the cell. For examples of different graphs and their configuration complexes, see the tutorial. Parameters ---------- - k : int - The order of the configuration complex, or the number of 'points' in the configuration. + k : int, optional. + The order of the configuration complex, or the number of 'points' in the configuration. Currently only k <= 2 is supported, since TopoNetX only allows cell complexes to have dimension 2. Default is 2. **kwargs : optional Additional arguments for the class. """ - def __init__(self, k: int, **kwargs): + def __init__(self, k: int = 2, **kwargs): + if k < 0 or k > 2: + raise NotImplementedError( + "Only k = 0, 1, or 2 is currently supported. This is due to TopoNetX only supporting cell complexes of dimension 2. This may change in the future." + ) super().__init__(**kwargs) self.k = k @@ -36,5 +122,15 @@ def lift_topology(self, data: torch_geometric.data.Data) -> dict: The lifted topology. """ G = self._generate_graph_from_data(data) - cell_complex = CellComplex(G) + cell_complex_data = DiscreteConfigurationComplex(self.k, G) + cc = CellComplex.from_networkx_graph() + cc.from_networkx_graph(nx.Graph(cell_complex_data[1])) + + if self.k == 1: + return + + for dim_2_cell in cell_complex_data[2]: + cycle = [e[0] for e in nx.find_cycle(nx.Graph(dim_2_cell))] + cc.add_cell(cell=cycle, rank=2) + return From 3458a9ffff3342f13b0e53ee02185359f7825e61 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Fri, 12 Jul 2024 21:06:38 -0400 Subject: [PATCH 03/11] clean up code --- .../discrete_configuration_complex_lifting.py | 173 +++++++++++------- modules/utils/utils.py | 5 + 2 files changed, 108 insertions(+), 70 deletions(-) diff --git a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py index f1e55a6d..5a89efe8 100644 --- a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py +++ b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py @@ -1,34 +1,103 @@ from itertools import permutations -from typing import Tuple +from typing import ClassVar import networkx as nx import torch_geometric from toponetx.classes import CellComplex from modules.transforms.liftings.graph2cell.base import Graph2CellLifting +from modules.utils.utils import edge_cycle_to_vertex_cycle Vertex = int -Edge = Tuple[Vertex, Vertex] -ConfigurationTuple = Tuple[Vertex | Edge] +Edge = tuple[Vertex, Vertex] +ConfigurationTuple = tuple[Vertex | Edge] -def DiscreteConfigurationComplex(k: int, graph: nx.Graph): +class DiscreteConfigurationLifting(Graph2CellLifting): + r"""Lifts graphs to cell complexes by generating the k-th *discrete configuration complex* $D_k(G)$ of the graph. This is a cube complex, which is similar to a simplicial complex except each n-dimensional cell is homeomorphic to a n-dimensional cube rather than an n-dimensional simplex. + + The discrete configuration complex of order k consists of all sets of k unique edges or vertices of $G$, with the additional constraint that if an edge e is in a cell, then neither of the endpoints of e are in the cell. For examples of different graphs and their configuration complexes, see the tutorial. + + Parameters + ---------- + k : int, optional. + The order of the configuration complex, or the number of 'points' in the configuration. Currently only k <= 2 is supported, since TopoNetX only allows cell complexes to have dimension 2. Default is 2. + **kwargs : optional + Additional arguments for the class. + """ + + def __init__(self, k: int = 2, **kwargs): + if k < 1 or k > 2: + raise NotImplementedError( + "Only k = 1, or 2 is currently supported. This is due to TopoNetX only supporting cell complexes of dimension 2. This may change in the future." + ) + super().__init__(**kwargs) + self.k = k + + def _get_lifted_topology(self, cell_complex: CellComplex) -> dict: + raise NotImplementedError() + + def lift_topology(self, data: torch_geometric.data.Data) -> dict: + r"""Generates the cubical complex of discrete graph configurations. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data to be lifted. + + Returns + ------- + dict + The lifted topology. + """ + # configurations of k = 1 agents are the same as the graph + if self.k == 1: + return data + + G = self._generate_graph_from_data(data) + if G.is_directed(): + raise ValueError("Directed Graphs are not supported.") + + cell_complex_data = generate_configuration_complex_data(self.k, G) + cc = CellComplex() + cc.from_networkx_graph(nx.Graph(cell_complex_data[1])) + + if self.k == 1: + return None + + for dim_2_cell in cell_complex_data[2]: + cc.add_cell(edge_cycle_to_vertex_cycle(dim_2_cell), rank=2) + + return self._get_lifted_topology(cc) + + +def generate_configuration_class(k: int, graph: nx.Graph): + """Class factory for the Configuration class.""" + class Configuration: - _instances: dict[ConfigurationTuple, "Configuration"] = {} + """Represents a single legal configuration of k agents on a graph G. A legal configuration is a tuple of k edges and vertices of G where all the vertices and endpoints are **distinct** i.e. no two edges sharing an endpoint can simultaneously be in the configuration, and adjacent (edge, vertex) pair can be contained in the configuration. + + Parameters + ---------- + k : int, optional. + The order of the configuration complex, or the number of 'points' in the configuration. + graph: nx.Graph. + The graph on which the configurations are defined. + """ + + instances: ClassVar[dict[ConfigurationTuple, "Configuration"]] = {} _counter = 0 def __new__(cls, configuration_tuple: ConfigurationTuple): - # Create a key from the arguments - key = configuration - - # If an instance doesn't exist for these arguments, create one + # Ensure that a configuration tuple corresponds to a *unique* configuration object + key = configuration_tuple if key not in cls._instances: cls._instances[key] = super().__new__(cls) - # Return the instance for these arguments return cls._instances[key] def __init__(self, configuration_tuple: ConfigurationTuple) -> None: + # If this object was already initialized earlier, maintain current state if hasattr(self, "initialized"): return @@ -44,29 +113,33 @@ def __init__(self, configuration_tuple: ConfigurationTuple) -> None: self.neighborhood.add(agent) if self.dim == 0: - self.contents = {Configuration._counter} + self.contents = Configuration._counter Configuration._counter += 1 else: - self.contents = set() + self.contents = [] self._upwards_neighbors_generated = False - self._generate_upwards_neighbors() - def _generate_upwards_neighbors(self): + def generate_upwards_neighbors(self): + """For the configuration self of dimension d, generate the configurations of dimension d+1 containing it.""" if self._upwards_neighbors_generated: return self._upwards_neighbors_generated = True for i, agent in enumerate(self.configuration_tuple): - if isinstance(agent, Edge): + if isinstance(agent, tuple): continue for neighbor in graph[agent]: - self._generate_new_configuration(i, agent, neighbor) + self._generate_single_neighbor(i, agent, neighbor) - def _generate_new_configuration( - self, index: int, vertex_agent: Vertex, neighbor: Vertex + def _generate_single_neighbor( + self, index: int, vertex_agent: int, neighbor: int ): + """Generate a configuration containing the configuration self by 'expanding' an edge.""" + # If adding the edge (vertex_agent, neighbor) would produce an illegal configuration, ignore it if neighbor in self.neighborhood: return + + # We always orient edges (min -> max) to maintain uniqueness of configuration tuples new_edge = (min(vertex_agent, neighbor), max(vertex_agent, neighbor)) new_configuration_tuple = ( *self.configuration_tuple[:index], @@ -74,63 +147,23 @@ def _generate_new_configuration( *self.configuration_tuple[index + 1 :], ) new_configuration = Configuration(new_configuration_tuple) - new_configuration.contents.add(frozenset(self.contents)) - new_configuration._generate_upwards_neighbors() + new_configuration.contents.append(self.contents) + new_configuration.generate_upwards_neighbors() + + return Configuration + +def generate_configuration_complex_data(k: int, graph: nx.Graph): + """Generate the cell data of the configuration complex $D_k(G)$.""" + Configuration = generate_configuration_class(k, graph) + + # The vertices of the configuration complex are just tuples of k vertices for dim_0_configuration_tuple in permutations(graph, k): configuration = Configuration(dim_0_configuration_tuple) + configuration.generate_upwards_neighbors() cells = {i: [] for i in range(k + 1)} - for conf in Configuration._instances.values(): + for conf in Configuration.instances.values(): cells[conf.dim].append(conf.contents) return cells - - -class DiscreteConfigurationLifting(Graph2CellLifting): - r"""Lifts graphs to cell complexes by generating the k-th *discrete configuration complex* $D_k(G)$ of the graph. This is a cube complex, which is similar to a simplicial complex except each n-dimensional cell is homeomorphic to a n-dimensional cube rather than an n-dimensional simplex. - - The discrete configuration complex of order k consists of all sets of k unique edges or vertices of $G$, with the additional constraint that if an edge e is in a cell, then neither of the endpoints of e are in the cell. For examples of different graphs and their configuration complexes, see the tutorial. - - Parameters - ---------- - k : int, optional. - The order of the configuration complex, or the number of 'points' in the configuration. Currently only k <= 2 is supported, since TopoNetX only allows cell complexes to have dimension 2. Default is 2. - **kwargs : optional - Additional arguments for the class. - """ - - def __init__(self, k: int = 2, **kwargs): - if k < 0 or k > 2: - raise NotImplementedError( - "Only k = 0, 1, or 2 is currently supported. This is due to TopoNetX only supporting cell complexes of dimension 2. This may change in the future." - ) - super().__init__(**kwargs) - self.k = k - - def lift_topology(self, data: torch_geometric.data.Data) -> dict: - r"""Generates the cubical complex of discrete graph configurations. - - Parameters - ---------- - data : torch_geometric.data.Data - The input data to be lifted. - - Returns - ------- - dict - The lifted topology. - """ - G = self._generate_graph_from_data(data) - cell_complex_data = DiscreteConfigurationComplex(self.k, G) - cc = CellComplex.from_networkx_graph() - cc.from_networkx_graph(nx.Graph(cell_complex_data[1])) - - if self.k == 1: - return - - for dim_2_cell in cell_complex_data[2]: - cycle = [e[0] for e in nx.find_cycle(nx.Graph(dim_2_cell))] - cc.add_cell(cell=cycle, rank=2) - - return diff --git a/modules/utils/utils.py b/modules/utils/utils.py index 1dfcdc2e..f01b280a 100644 --- a/modules/utils/utils.py +++ b/modules/utils/utils.py @@ -495,3 +495,8 @@ def describe_hypergraph(data: torch_geometric.data.Data): if he_idx >= 10: print("...") break + + +def edge_cycle_to_vertex_cycle(edge_cycle: list[list | tuple]): + """Takes a cycle represented by a list of edges and returns a vertex representation: [(1, 2), (0, 1), (1, 2)] -> [1, 2, 3].""" + return [e[0] for e in nx.find_cycle(nx.Graph(edge_cycle))] From 0bc0a5c4d924949b8798be464243838685f65b3a Mon Sep 17 00:00:00 2001 From: Theo Long Date: Fri, 12 Jul 2024 22:59:52 -0400 Subject: [PATCH 04/11] add feature lifting and other improvements --- .../discrete_configuration_complex_lifting.py | 147 +++++++++++------- 1 file changed, 92 insertions(+), 55 deletions(-) diff --git a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py index 5a89efe8..bcf40d30 100644 --- a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py +++ b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py @@ -2,6 +2,7 @@ from typing import ClassVar import networkx as nx +import torch import torch_geometric from toponetx.classes import CellComplex @@ -18,24 +19,35 @@ class DiscreteConfigurationLifting(Graph2CellLifting): The discrete configuration complex of order k consists of all sets of k unique edges or vertices of $G$, with the additional constraint that if an edge e is in a cell, then neither of the endpoints of e are in the cell. For examples of different graphs and their configuration complexes, see the tutorial. + Note that since TopoNetx only supports cell complexes of dimension 2, if you generate a configuration complex of order k > 2 this will only produce the 2-skeleton. + Parameters ---------- - k : int, optional. - The order of the configuration complex, or the number of 'points' in the configuration. Currently only k <= 2 is supported, since TopoNetX only allows cell complexes to have dimension 2. Default is 2. + k: int, + The order of the configuration complex, i.e. the number of 'agents' in a single configuration. + preserve_edge_attr : bool, optional + Whether to preserve edge attributes. Default is True. + feature_aggregation: str, optional + For a k-agent configuration, the method by which the features are aggregated. Can be "mean", "sum", or "concat". Default is "mean". **kwargs : optional Additional arguments for the class. """ - def __init__(self, k: int = 2, **kwargs): - if k < 1 or k > 2: - raise NotImplementedError( - "Only k = 1, or 2 is currently supported. This is due to TopoNetX only supporting cell complexes of dimension 2. This may change in the future." - ) - super().__init__(**kwargs) + def __init__( + self, + k: int, + preserve_edge_attr: bool = True, + feature_aggregation="mean", + **kwargs, + ): self.k = k - - def _get_lifted_topology(self, cell_complex: CellComplex) -> dict: - raise NotImplementedError() + self.complex_dim = 2 + if feature_aggregation not in ["mean", "sum", "concat"]: + raise ValueError( + "feature_aggregation must be one of 'mean', 'sum', 'concat'" + ) + self.feature_aggregation = feature_aggregation + super().__init__(preserve_edge_attr=preserve_edge_attr, **kwargs) def lift_topology(self, data: torch_geometric.data.Data) -> dict: r"""Generates the cubical complex of discrete graph configurations. @@ -50,32 +62,44 @@ def lift_topology(self, data: torch_geometric.data.Data) -> dict: dict The lifted topology. """ - # configurations of k = 1 agents are the same as the graph - if self.k == 1: - return data - G = self._generate_graph_from_data(data) if G.is_directed(): raise ValueError("Directed Graphs are not supported.") - cell_complex_data = generate_configuration_complex_data(self.k, G) - cc = CellComplex() - cc.from_networkx_graph(nx.Graph(cell_complex_data[1])) + Configuration = generate_configuration_class( + G, self.feature_aggregation, self.contains_edge_attr + ) + + # The vertices of the configuration complex are just tuples of k vertices + for dim_0_configuration_tuple in permutations(G, self.k): + configuration = Configuration(dim_0_configuration_tuple) + configuration.generate_upwards_neighbors() - if self.k == 1: - return None + cells = {i: [] for i in range(self.k + 1)} + for conf in Configuration.instances.values(): + cell = (conf.contents, {"features": conf.features()}) + cells[conf.dim].append(cell) - for dim_2_cell in cell_complex_data[2]: - cc.add_cell(edge_cycle_to_vertex_cycle(dim_2_cell), rank=2) + # TopoNetX only supports cells of dimension <= 2 + cc = CellComplex() + for node, attrs in cells[0]: + cc.add_node(node, **attrs) + for edge, attrs in cells[1]: + cc.add_edge(edge[0], edge[1], **attrs) + for cell, attrs in cells[2]: + cell_vertices = edge_cycle_to_vertex_cycle(cell) + cc.add_cell(cell_vertices, rank=2, **attrs) - return self._get_lifted_topology(cc) + return self._get_lifted_topology(cc, G) -def generate_configuration_class(k: int, graph: nx.Graph): +def generate_configuration_class( + graph: nx.Graph, feature_aggregation: str, edge_features: bool +): """Class factory for the Configuration class.""" class Configuration: - """Represents a single legal configuration of k agents on a graph G. A legal configuration is a tuple of k edges and vertices of G where all the vertices and endpoints are **distinct** i.e. no two edges sharing an endpoint can simultaneously be in the configuration, and adjacent (edge, vertex) pair can be contained in the configuration. + """Represents a single legal configuration of k agents on a graph G. A legal configuration is a tuple of k edges and vertices of G where all the vertices and endpoints are **distinct** i.e. no two edges sharing an endpoint can simultaneously be in the configuration, and adjacent (edge, vertex) pair can be contained in the configuration. Each configuration corresponds to a cell, and the number of edges in the configuration is the dimension. Parameters ---------- @@ -86,15 +110,14 @@ class Configuration: """ instances: ClassVar[dict[ConfigurationTuple, "Configuration"]] = {} - _counter = 0 def __new__(cls, configuration_tuple: ConfigurationTuple): # Ensure that a configuration tuple corresponds to a *unique* configuration object key = configuration_tuple - if key not in cls._instances: - cls._instances[key] = super().__new__(cls) + if key not in cls.instances: + cls.instances[key] = super().__new__(cls) - return cls._instances[key] + return cls.instances[key] def __init__(self, configuration_tuple: ConfigurationTuple) -> None: # If this object was already initialized earlier, maintain current state @@ -106,41 +129,71 @@ def __init__(self, configuration_tuple: ConfigurationTuple) -> None: self.neighborhood = set() self.dim = 0 for agent in configuration_tuple: - if isinstance(agent, Edge): + if isinstance(agent, Vertex): + self.neighborhood.add(agent) + else: self.neighborhood.update(set(agent)) self.dim += 1 - else: - self.neighborhood.add(agent) if self.dim == 0: - self.contents = Configuration._counter - Configuration._counter += 1 + self.contents = configuration_tuple else: self.contents = [] self._upwards_neighbors_generated = False + def features(self): + """Generate the features for the configuration by combining the edge and vertex features.""" + features = [] + for agent in self.configuration_tuple: + if isinstance(agent, Vertex): + features.append(graph.nodes[agent]["features"]) + elif edge_features: + features.append(graph.edges[agent]["features"]) + + if feature_aggregation == "mean": + try: + return torch.stack(features, dim=0).mean(dim=0) + except Exception as e: + raise ValueError( + "Failed to mean feature tensors. This may be because edge features and vertex features have different shapes. If this is the case, use feature_aggregation='concat', or disable edge features." + ) from e + elif feature_aggregation == "sum": + try: + return torch.stack(features, dim=0).sum(dim=0) + except Exception as e: + raise ValueError( + "Failed to sum feature tensors. This may be because edge features and vertex features have different shapes. If this is the case, use feature_aggregation='concat', or disable edge features." + ) from e + elif feature_aggregation == "concat": + return torch.concatenate(features, dim=-1) + else: + raise ValueError( + f"Unrecognized feature_aggregation: {feature_aggregation}" + ) + def generate_upwards_neighbors(self): """For the configuration self of dimension d, generate the configurations of dimension d+1 containing it.""" if self._upwards_neighbors_generated: return self._upwards_neighbors_generated = True for i, agent in enumerate(self.configuration_tuple): - if isinstance(agent, tuple): - continue - for neighbor in graph[agent]: - self._generate_single_neighbor(i, agent, neighbor) + if isinstance(agent, Vertex): + for neighbor in graph[agent]: + self._generate_single_neighbor(i, agent, neighbor) def _generate_single_neighbor( self, index: int, vertex_agent: int, neighbor: int ): - """Generate a configuration containing the configuration self by 'expanding' an edge.""" + """Generate a configuration containing self by moving an agent from a vertex onto an edge.""" # If adding the edge (vertex_agent, neighbor) would produce an illegal configuration, ignore it if neighbor in self.neighborhood: return # We always orient edges (min -> max) to maintain uniqueness of configuration tuples new_edge = (min(vertex_agent, neighbor), max(vertex_agent, neighbor)) + + # Remove the vertex at index and replace it with new edge new_configuration_tuple = ( *self.configuration_tuple[:index], new_edge, @@ -151,19 +204,3 @@ def _generate_single_neighbor( new_configuration.generate_upwards_neighbors() return Configuration - - -def generate_configuration_complex_data(k: int, graph: nx.Graph): - """Generate the cell data of the configuration complex $D_k(G)$.""" - Configuration = generate_configuration_class(k, graph) - - # The vertices of the configuration complex are just tuples of k vertices - for dim_0_configuration_tuple in permutations(graph, k): - configuration = Configuration(dim_0_configuration_tuple) - configuration.generate_upwards_neighbors() - - cells = {i: [] for i in range(k + 1)} - for conf in Configuration.instances.values(): - cells[conf.dim].append(conf.contents) - - return cells From 486bb36713d18ae8ed5a5f54a4f9252d3217c8b6 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Fri, 12 Jul 2024 23:47:53 -0400 Subject: [PATCH 05/11] small fixes --- .../discrete_configuration_complex_lifting.py | 30 +++++++++++++++++-- 1 file changed, 27 insertions(+), 3 deletions(-) diff --git a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py index bcf40d30..e0a97249 100644 --- a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py +++ b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py @@ -28,7 +28,7 @@ class DiscreteConfigurationLifting(Graph2CellLifting): preserve_edge_attr : bool, optional Whether to preserve edge attributes. Default is True. feature_aggregation: str, optional - For a k-agent configuration, the method by which the features are aggregated. Can be "mean", "sum", or "concat". Default is "mean". + For a k-agent configuration, the method by which the features are aggregated. Can be "mean", "sum", or "concat". Default is "concat". **kwargs : optional Additional arguments for the class. """ @@ -37,7 +37,7 @@ def __init__( self, k: int, preserve_edge_attr: bool = True, - feature_aggregation="mean", + feature_aggregation="concat", **kwargs, ): self.k = k @@ -49,6 +49,25 @@ def __init__( self.feature_aggregation = feature_aggregation super().__init__(preserve_edge_attr=preserve_edge_attr, **kwargs) + def forward(self, data: torch_geometric.data.Data) -> torch_geometric.data.Data: + r"""Applies the full lifting (topology + features) to the input data. + + Parameters + ---------- + data : torch_geometric.data.Data + The input data to be lifted. + + Returns + ------- + torch_geometric.data.Data + The lifted data. + """ + # Unlike the base class, we do not pass the initial data to the final data + # This is because the configuration complex has a completely different 1-skeleton from the original graph + lifted_topology = self.lift_topology(data) + lifted_topology = self.feature_lifting(lifted_topology) + return torch_geometric.data.Data(**lifted_topology) + def lift_topology(self, data: torch_geometric.data.Data) -> dict: r"""Generates the cubical complex of discrete graph configurations. @@ -77,7 +96,9 @@ def lift_topology(self, data: torch_geometric.data.Data) -> dict: cells = {i: [] for i in range(self.k + 1)} for conf in Configuration.instances.values(): - cell = (conf.contents, {"features": conf.features()}) + features = conf.features() + attrs = {"features": features} if features is not None else {} + cell = (conf.contents, attrs) cells[conf.dim].append(cell) # TopoNetX only supports cells of dimension <= 2 @@ -151,6 +172,9 @@ def features(self): elif edge_features: features.append(graph.edges[agent]["features"]) + if not features: + return None + if feature_aggregation == "mean": try: return torch.stack(features, dim=0).mean(dim=0) From 63214dc322d8b125b4049ecff8097704f8092175 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Fri, 12 Jul 2024 23:48:17 -0400 Subject: [PATCH 06/11] add configs --- .../graph2cell/discrete_configuration_complex_lifting.yaml | 6 ++++++ modules/transforms/data_transform.py | 4 ++++ 2 files changed, 10 insertions(+) create mode 100644 configs/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.yaml diff --git a/configs/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.yaml b/configs/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.yaml new file mode 100644 index 00000000..2360b0ae --- /dev/null +++ b/configs/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.yaml @@ -0,0 +1,6 @@ +transform_type: 'lifting' +transform_name: "DiscreteConfigurationLifting" +k: 2 +feature_aggregation: "concat" +preserve_edge_attr: 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..ee0945bb 100755 --- a/modules/transforms/data_transform.py +++ b/modules/transforms/data_transform.py @@ -9,6 +9,9 @@ ) from modules.transforms.feature_liftings.feature_liftings import ProjectionSum from modules.transforms.liftings.graph2cell.cycle_lifting import CellCycleLifting +from modules.transforms.liftings.graph2cell.discrete_configuration_complex_lifting import ( + DiscreteConfigurationLifting, +) from modules.transforms.liftings.graph2hypergraph.knn_lifting import ( HypergraphKNNLifting, ) @@ -31,6 +34,7 @@ "OneHotDegreeFeatures": OneHotDegreeFeatures, "NodeFeaturesToFloat": NodeFeaturesToFloat, "KeepOnlyConnectedComponent": KeepOnlyConnectedComponent, + "DiscreteConfigurationLifting": DiscreteConfigurationLifting, } From 37cd771d44a626eb32219c3b3a4e0377b6694da7 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 13 Jul 2024 00:21:40 -0400 Subject: [PATCH 07/11] add new dataset for tutorial --- .../datasets/simple_configuration_graphs.yaml | 12 ++++ modules/data/load/loaders.py | 5 ++ modules/data/utils/utils.py | 55 ++++++++++++++++--- .../discrete_configuration_complex_lifting.py | 2 +- modules/transforms/liftings/lifting.py | 5 +- modules/utils/utils.py | 11 +++- 6 files changed, 76 insertions(+), 14 deletions(-) create mode 100755 configs/datasets/simple_configuration_graphs.yaml diff --git a/configs/datasets/simple_configuration_graphs.yaml b/configs/datasets/simple_configuration_graphs.yaml new file mode 100755 index 00000000..59f445e5 --- /dev/null +++ b/configs/datasets/simple_configuration_graphs.yaml @@ -0,0 +1,12 @@ +data_domain: graph +data_type: toy_dataset +data_name: simple_configuration_graphs +data_dir: datasets/${data_domain}/${data_type} + +# Dataset parameters +num_features: 1 +num_classes: 2 +task: classification +loss_type: cross_entropy +monitor_metric: accuracy +task_level: graph diff --git a/modules/data/load/loaders.py b/modules/data/load/loaders.py index 8ccafb11..1ca7e819 100755 --- a/modules/data/load/loaders.py +++ b/modules/data/load/loaders.py @@ -12,6 +12,7 @@ load_cell_complex_dataset, load_hypergraph_pickle_dataset, load_manual_graph, + load_simple_configuration_graphs, load_simplicial_dataset, ) @@ -108,6 +109,10 @@ def load(self) -> torch_geometric.data.Dataset: data = load_manual_graph() dataset = CustomDataset([data], self.data_dir) + elif self.parameters.data_name in ["simple_configuration_graphs"]: + data = load_simple_configuration_graphs() + dataset = CustomDataset([*data], self.data_dir) + 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 93ab5021..e98fdfad 100755 --- a/modules/data/utils/utils.py +++ b/modules/data/utils/utils.py @@ -50,16 +50,16 @@ def get_complex_connectivity(complex, max_rank, signed=False): ) except ValueError: # noqa: PERF203 if connectivity_info == "incidence": - connectivity[f"{connectivity_info}_{rank_idx}"] = ( - generate_zero_sparse_connectivity( - m=practical_shape[rank_idx - 1], n=practical_shape[rank_idx] - ) + connectivity[ + f"{connectivity_info}_{rank_idx}" + ] = generate_zero_sparse_connectivity( + m=practical_shape[rank_idx - 1], n=practical_shape[rank_idx] ) else: - connectivity[f"{connectivity_info}_{rank_idx}"] = ( - generate_zero_sparse_connectivity( - m=practical_shape[rank_idx], n=practical_shape[rank_idx] - ) + connectivity[ + f"{connectivity_info}_{rank_idx}" + ] = generate_zero_sparse_connectivity( + m=practical_shape[rank_idx], n=practical_shape[rank_idx] ) connectivity["shape"] = practical_shape return connectivity @@ -334,6 +334,45 @@ def load_manual_graph(): ) +def load_simple_configuration_graphs(): + """Generate small graphs to illustrate the discrete configuration complex.""" + + # Y shaped graph + y_graph = nx.Graph() + y_graph.add_edges_from([(0, 1), (0, 2), (0, 3)]) + y_data = torch_geometric.data.Data( + x=torch.tensor([0, 1, 2, 3]).unsqueeze(1).float(), + y=torch.tensor([0]), + edge_index=torch.Tensor(list(y_graph.edges())).T.long(), + num_nodes=4, + edge_attr=torch.Tensor([-1, -2, -3]).unsqueeze(1).float(), + ) + + # X shaped graph + x_graph = nx.Graph() + x_graph.add_edges_from([(0, 1), (0, 2), (0, 3), (0, 4)]) + x_data = torch_geometric.data.Data( + x=torch.tensor([0, 1, 2, 3, 4]).unsqueeze(1).float(), + y=torch.tensor([0]), + edge_index=torch.Tensor(list(x_graph.edges())).T.long(), + num_nodes=4, + edge_attr=torch.Tensor([-1, -2, -3, -4]).unsqueeze(1).float(), + ) + + # g shaped graph + g_graph = nx.Graph() + g_graph.add_edges_from([(0, 1), (1, 2), (2, 0), (2, 3)]) + g_data = torch_geometric.data.Data( + x=torch.tensor([0, 1, 2, 3]).unsqueeze(1).float(), + y=torch.tensor([1]), + edge_index=torch.Tensor(list(g_graph.edges())).T.long(), + num_nodes=4, + edge_attr=torch.Tensor([-1, -2, -3, -4]).unsqueeze(1).float(), + ) + + return x_data, y_data, g_data + + def get_Planetoid_pyg(cfg): r"""Loads Planetoid graph datasets from torch_geometric. diff --git a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py index e0a97249..c7c81a9e 100644 --- a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py +++ b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py @@ -66,7 +66,7 @@ def forward(self, data: torch_geometric.data.Data) -> torch_geometric.data.Data: # This is because the configuration complex has a completely different 1-skeleton from the original graph lifted_topology = self.lift_topology(data) lifted_topology = self.feature_lifting(lifted_topology) - return torch_geometric.data.Data(**lifted_topology) + return torch_geometric.data.Data(y=data.y, **lifted_topology) def lift_topology(self, data: torch_geometric.data.Data) -> dict: r"""Generates the cubical complex of discrete graph configurations. diff --git a/modules/transforms/liftings/lifting.py b/modules/transforms/liftings/lifting.py index ddb72781..fe865267 100644 --- a/modules/transforms/liftings/lifting.py +++ b/modules/transforms/liftings/lifting.py @@ -117,10 +117,9 @@ def _generate_graph_from_data(self, data: torch_geometric.data.Data) -> nx.Graph 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 + (data.edge_index, data.edge_attr) if is_undirected(data.edge_index, data.edge_attr) - else to_undirected(data.edge_index, data.edge_attr), + else to_undirected(data.edge_index, data.edge_attr) ) edges = [ (i.item(), j.item(), dict(features=edge_attr[edge_idx], dim=1)) diff --git a/modules/utils/utils.py b/modules/utils/utils.py index f01b280a..c6540ee2 100644 --- a/modules/utils/utils.py +++ b/modules/utils/utils.py @@ -166,7 +166,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"): + if ( + hasattr(data, "edge_index") + and hasattr(data, "x") + and data.x is not None + ): connected_nodes = torch.unique(data.edge_index) isolated_nodes = [] for i in range(data.x.shape[0]): @@ -225,7 +229,10 @@ def sort_vertices_ccw(vertices): incidence = data.incidence_hyperedges.coalesce() # Collect vertices - vertices = [i for i in range(data.x.shape[0])] + if hasattr(data, "x") and data.x is not None: + vertices = [i for i in range(data.x.shape[0])] + else: + vertices = [i for i in range(data["x_0"].shape[0])] # Hyperedges if max_order == 0: From 803af970b5e78a289abe270b62a066e74e16afac Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 13 Jul 2024 00:21:53 -0400 Subject: [PATCH 08/11] add tutorial --- ...screte_configuration_complex_lifting.ipynb | 464 ++++++++++++++++++ 1 file changed, 464 insertions(+) create mode 100644 tutorials/graph2cell/discrete_configuration_complex_lifting.ipynb diff --git a/tutorials/graph2cell/discrete_configuration_complex_lifting.ipynb b/tutorials/graph2cell/discrete_configuration_complex_lifting.ipynb new file mode 100644 index 00000000..2fd3d260 --- /dev/null +++ b/tutorials/graph2cell/discrete_configuration_complex_lifting.ipynb @@ -0,0 +1,464 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Graph-to-Cell Discrete Configuration Complex Lifting Tutorial\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\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", + "\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", + "\n", + "---\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports and utilities\n" + ] + }, + { + "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 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\n" + ] + }, + { + "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 simple_configuration_graphs:\n", + "\n", + "{'data_domain': 'graph',\n", + " 'data_type': 'toy_dataset',\n", + " 'data_name': 'simple_configuration_graphs',\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': 'graph'}\n" + ] + } + ], + "source": [ + "dataset_name = \"simple_configuration_graphs\"\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:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing...\n", + "Done!\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Dataset contains 3 samples.\n", + "\n", + "Providing more details about sample 0/3:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 4 vertices and 4 edges.\n", + " - Features dimensions: [1, 1]\n", + " - There are 0 isolated nodes.\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "Data(x=[4, 1], edge_index=[2, 4], edge_attr=[4, 1], y=[1], num_nodes=4)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset = loader.load()\n", + "describe_data(dataset, 0)\n", + "dataset.get(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading and Applying the Lifting\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section we will instantiate the lifting we want to apply to the data. For this example the **discrete configuration complex** of a graph was chosen. This was first proposed by Abrams in [1] (see also [2] and [3]), and is an example of a **cubical complex**[4]. While a simplicial complex is built up of points, edges, triangles, tertrahedrons, and so on, a cubical complex is composed of points, edges, squares, cubes, and hypercubes. Another way to think of a cubical complex is that a cell of dimension $n$ is composed of exactly $2n$ 'faces' of dimension $n-1$ (so a square is composed of 4 edges, a cube of 6 squares, and so on).\n", + "\n", + "The **discrete configuration complex** $D_k(G)$ of a graph $G$ is the set of all _legal configurations of k agents_ on edges or vertices of $G$. For a configuration to be legal, each chosen edge or vertex must be unique, and if a given edge is part of a configuration, then neither of its endpoints may also be included (but two edges sharing an endpoint may both be included). This can also be phrased as 'each agent must be at least 1 edge away from any other agent'. Each configuration is then a cell in the complex, where the dimension of the cell is the number of edges in the configuration (hence the complex has dimension $k$).\n", + "\n", + "One motivation for this construction is motion planning for robotics. In this case, the 'agents' represent individual robots, and the graph represents the possible locations each robot can take and the paths between them. The topology of the configuration complex then encodes how robots can move from one configuration to another in a 'safe' way without collisions. For more details see [1], [2], and [3].\n", + "\n", + "Note that this cell complex is large - it has $O((n + m)^k)$ cells (and has runtime $O((n + m)^k)$), where $n$ is the number of nodes and $m$ is the number of edges in $G$. Therefore it is not recommended to use it for large graphs.\n", + "\n", + "---\n", + "\n", + "[1] A. Abrams and R. Ghrist. Finding topology in a factory: Configuration spaces. Amer. Math. Monthly 109:140–150, 2002.\n", + "\n", + "[2] A. Abrams and R. Ghrist. State complexes for metamorphic robot systems. Int. J. Robotics Research 23(7–8):809–824, 2004.\n", + "\n", + "[3] A. D. Abrams. Configuration Spaces and Braid Groups of Graphs. Ph.D. thesis, Dept. Math., U.C. Berkeley, 2000. [link](http://www.mathcs.emory.edu/~abrams/research/Papers/thesis.ps).\n", + "\n", + "[4] [Wikipedia - Cubical Complex](https://en.wikipedia.org/wiki/Cubical_complex)\n", + "\n", + "---\n", + "\n", + "For cell complexes creating a lifting involves creating a `CellComplex` object from topomodelx and adding cells to it using the method `add_cells_from`. The `CellComplex` 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 _transform_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 -> cell complex -> hypergraph.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Transform configuration for graph2cell/discrete_configuration_complex_lifting:\n", + "\n", + "{'transform_type': 'lifting',\n", + " 'transform_name': 'DiscreteConfigurationLifting',\n", + " 'k': 2,\n", + " 'feature_aggregation': 'concat',\n", + " 'preserve_edge_attr': 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 = \"graph2cell/discrete_configuration_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`:\n" + ] + }, + { + "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/graph/toy_dataset/simple_configuration_graphs/lifting/3176945688\n", + "\n", + "Dataset contains 3 samples.\n", + "\n", + "Providing more details about sample 0/3:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 20 vertices and 24 edges.\n", + " - Features dimensions: [2, 2]\n", + "\n", + "\n", + "Dataset contains 3 samples.\n", + "\n", + "Providing more details about sample 1/3:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Graph with 12 vertices and 12 edges.\n", + " - Features dimensions: [2, 2]\n", + "\n", + "\n", + "Dataset contains 3 samples.\n", + "\n", + "Providing more details about sample 2/3:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - The complex has 12 0-cells.\n", + " - The 0-cells have features dimension 2\n", + " - The complex has 16 1-cells.\n", + " - The 1-cells have features dimension 2\n", + " - The complex has 2 2-cells.\n", + " - The 2-cells have features dimension 2\n", + "\n" + ] + } + ], + "source": [ + "lifted_dataset = PreProcessor(dataset, transform_config, loader.data_dir)\n", + "\n", + "if dataset_name == \"simple_configuration_graphs\":\n", + " for i in range(len(lifted_dataset.data_list)):\n", + " describe_data(lifted_dataset, i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create and Run a Cell NN Model\n" + ] + }, + { + "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 `x_0`, `x_1`, `x_2` which are the features of the nodes, edges and cells respectively. It also uses the `adjacency_1`, `incidence_1` and `incidence_2` matrices so the lifting should make sure to add them to the data.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Model configuration for cell CWN:\n", + "\n", + "{'in_channels_0': None,\n", + " 'in_channels_1': None,\n", + " 'in_channels_2': None,\n", + " 'hidden_channels': 32,\n", + " 'out_channels': None,\n", + " 'n_layers': 2}\n" + ] + } + ], + "source": [ + "from modules.models.cell.cwn import CWNModel\n", + "\n", + "model_type = \"cell\"\n", + "model_id = \"cwn\"\n", + "model_config = load_model_config(model_type, model_id)\n", + "\n", + "# If we concatenate features in the lifting, they will be larger\n", + "if transform_config[\"lifting\"][\"feature_aggregation\"] == \"concat\":\n", + " dataset_config[\"num_features\"] *= transform_config[\"lifting\"][\"k\"]\n", + "\n", + "model = CWNModel(model_config, dataset_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "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.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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 d579c24fdbad9808b50960f13cddf11c7a7727f9 Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 13 Jul 2024 00:48:00 -0400 Subject: [PATCH 09/11] rename --- ...iscrete_configuration_complex_lifting.yaml | 2 +- modules/transforms/data_transform.py | 4 +- .../discrete_configuration_complex_lifting.py | 2 +- ...screte_configuration_complex_lifting.ipynb | 51 ++++++++++--------- 4 files changed, 32 insertions(+), 27 deletions(-) diff --git a/configs/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.yaml b/configs/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.yaml index 2360b0ae..3c84eab1 100644 --- a/configs/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.yaml +++ b/configs/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.yaml @@ -1,5 +1,5 @@ transform_type: 'lifting' -transform_name: "DiscreteConfigurationLifting" +transform_name: "DiscreteConfigurationComplexLifting" k: 2 feature_aggregation: "concat" preserve_edge_attr: True diff --git a/modules/transforms/data_transform.py b/modules/transforms/data_transform.py index ee0945bb..cee17e45 100755 --- a/modules/transforms/data_transform.py +++ b/modules/transforms/data_transform.py @@ -10,7 +10,7 @@ from modules.transforms.feature_liftings.feature_liftings import ProjectionSum from modules.transforms.liftings.graph2cell.cycle_lifting import CellCycleLifting from modules.transforms.liftings.graph2cell.discrete_configuration_complex_lifting import ( - DiscreteConfigurationLifting, + DiscreteConfigurationComplexLifting, ) from modules.transforms.liftings.graph2hypergraph.knn_lifting import ( HypergraphKNNLifting, @@ -34,7 +34,7 @@ "OneHotDegreeFeatures": OneHotDegreeFeatures, "NodeFeaturesToFloat": NodeFeaturesToFloat, "KeepOnlyConnectedComponent": KeepOnlyConnectedComponent, - "DiscreteConfigurationLifting": DiscreteConfigurationLifting, + "DiscreteConfigurationComplexLifting": DiscreteConfigurationComplexLifting, } diff --git a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py index c7c81a9e..60f049e3 100644 --- a/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py +++ b/modules/transforms/liftings/graph2cell/discrete_configuration_complex_lifting.py @@ -14,7 +14,7 @@ ConfigurationTuple = tuple[Vertex | Edge] -class DiscreteConfigurationLifting(Graph2CellLifting): +class DiscreteConfigurationComplexLifting(Graph2CellLifting): r"""Lifts graphs to cell complexes by generating the k-th *discrete configuration complex* $D_k(G)$ of the graph. This is a cube complex, which is similar to a simplicial complex except each n-dimensional cell is homeomorphic to a n-dimensional cube rather than an n-dimensional simplex. The discrete configuration complex of order k consists of all sets of k unique edges or vertices of $G$, with the additional constraint that if an edge e is in a cell, then neither of the endpoints of e are in the cell. For examples of different graphs and their configuration complexes, see the tutorial. diff --git a/tutorials/graph2cell/discrete_configuration_complex_lifting.ipynb b/tutorials/graph2cell/discrete_configuration_complex_lifting.ipynb index 2fd3d260..bc0f566d 100644 --- a/tutorials/graph2cell/discrete_configuration_complex_lifting.ipynb +++ b/tutorials/graph2cell/discrete_configuration_complex_lifting.ipynb @@ -51,9 +51,18 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 16, "metadata": {}, - "outputs": [], + "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", @@ -84,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -122,17 +131,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 18, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Processing...\n", - "Done!\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -169,7 +170,7 @@ "Data(x=[4, 1], edge_index=[2, 4], edge_attr=[4, 1], y=[1], num_nodes=4)" ] }, - "execution_count": 3, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -193,9 +194,9 @@ "source": [ "In this section we will instantiate the lifting we want to apply to the data. For this example the **discrete configuration complex** of a graph was chosen. This was first proposed by Abrams in [1] (see also [2] and [3]), and is an example of a **cubical complex**[4]. While a simplicial complex is built up of points, edges, triangles, tertrahedrons, and so on, a cubical complex is composed of points, edges, squares, cubes, and hypercubes. Another way to think of a cubical complex is that a cell of dimension $n$ is composed of exactly $2n$ 'faces' of dimension $n-1$ (so a square is composed of 4 edges, a cube of 6 squares, and so on).\n", "\n", - "The **discrete configuration complex** $D_k(G)$ of a graph $G$ is the set of all _legal configurations of k agents_ on edges or vertices of $G$. For a configuration to be legal, each chosen edge or vertex must be unique, and if a given edge is part of a configuration, then neither of its endpoints may also be included (but two edges sharing an endpoint may both be included). This can also be phrased as 'each agent must be at least 1 edge away from any other agent'. Each configuration is then a cell in the complex, where the dimension of the cell is the number of edges in the configuration (hence the complex has dimension $k$).\n", + "The **discrete configuration complex** $D_k(G)$ of a graph $G$ is the set of all _legal configurations of k agents_ on edges or vertices of $G$. For a configuration to be legal, each chosen edge or vertex must be unique, and if a given edge is part of a configuration, then neither of its endpoints may also be included. Furthermore, if two edges share an endpoint, then only one can be included. This can also be phrased as 'each agent must be at least 1 edge away from any other agent'. Each configuration is then a cell in the complex, where the dimension of the cell is the number of edges in the configuration (hence the complex has dimension $k$).\n", "\n", - "One motivation for this construction is motion planning for robotics. In this case, the 'agents' represent individual robots, and the graph represents the possible locations each robot can take and the paths between them. The topology of the configuration complex then encodes how robots can move from one configuration to another in a 'safe' way without collisions. For more details see [1], [2], and [3].\n", + "One motivation for this construction is motion planning for robotics. In this case, the 'agents' represent individual robots, and the graph represents the possible locations each robot can take and the paths between them. The topology of the configuration complex then encodes how robots can move from one configuration to another in a 'safe' way without collisions. For more details see [1], [2], [3], and [5].\n", "\n", "Note that this cell complex is large - it has $O((n + m)^k)$ cells (and has runtime $O((n + m)^k)$), where $n$ is the number of nodes and $m$ is the number of edges in $G$. Therefore it is not recommended to use it for large graphs.\n", "\n", @@ -209,6 +210,8 @@ "\n", "[4] [Wikipedia - Cubical Complex](https://en.wikipedia.org/wiki/Cubical_complex)\n", "\n", + "[5] Computational Topology (Jeff Erickson) Cell Complexes: Definitions. (n.d.). Available at: [https://jeffe.cs.illinois.edu/teaching/comptop/2009/notes/cell-complex-examples.pdf](https://jeffe.cs.illinois.edu/teaching/comptop/2009/notes/cell-complex-examples.pdf)\n", + "\n", "---\n", "\n", "For cell complexes creating a lifting involves creating a `CellComplex` object from topomodelx and adding cells to it using the method `add_cells_from`. The `CellComplex` class then takes care of creating all the needed matrices.\n", @@ -222,7 +225,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -233,7 +236,7 @@ "Transform configuration for graph2cell/discrete_configuration_complex_lifting:\n", "\n", "{'transform_type': 'lifting',\n", - " 'transform_name': 'DiscreteConfigurationLifting',\n", + " 'transform_name': 'DiscreteConfigurationComplexLifting',\n", " 'k': 2,\n", " 'feature_aggregation': 'concat',\n", " 'preserve_edge_attr': True,\n", @@ -258,19 +261,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We than apply the transform via our `PreProcesor`:\n" + "We than apply the transform via our `PreProcesor`. Observe that the lifting does not preserve the original graph! That is because the nodes of the new complex are now **tuples** of $k$ vertices in the original graph. The new lifted complex may have very different topology - it may even be disconnected.\n" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 25, "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/graph/toy_dataset/simple_configuration_graphs/lifting/3176945688\n", + "Transform parameters are the same, using existing data_dir: /Users/tlong/Documents/code/challenge-icml-2024/datasets/graph/toy_dataset/simple_configuration_graphs/lifting/3192475844\n", "\n", "Dataset contains 3 samples.\n", "\n", @@ -325,7 +328,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -352,7 +355,9 @@ "\n", "if dataset_name == \"simple_configuration_graphs\":\n", " for i in range(len(lifted_dataset.data_list)):\n", - " describe_data(lifted_dataset, i)" + " describe_data(lifted_dataset, i)\n", + "else:\n", + " describe_data(lifted_dataset)" ] }, { @@ -371,7 +376,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 24, "metadata": {}, "outputs": [ { From 5ef0c2b4c046232b64372de9b52d15794701475a Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 13 Jul 2024 00:48:15 -0400 Subject: [PATCH 10/11] add testing --- ..._discrete_configuration_complex_lifting.py | 851 ++++++++++++++++++ 1 file changed, 851 insertions(+) create mode 100644 test/transforms/liftings/graph2cell/test_discrete_configuration_complex_lifting.py diff --git a/test/transforms/liftings/graph2cell/test_discrete_configuration_complex_lifting.py b/test/transforms/liftings/graph2cell/test_discrete_configuration_complex_lifting.py new file mode 100644 index 00000000..1b8051da --- /dev/null +++ b/test/transforms/liftings/graph2cell/test_discrete_configuration_complex_lifting.py @@ -0,0 +1,851 @@ +"""Test the message passing module.""" + +import torch + +from modules.data.utils.utils import load_simple_configuration_graphs +from modules.transforms.liftings.graph2cell.discrete_configuration_complex_lifting import ( + DiscreteConfigurationComplexLifting, +) + + +class TestDiscreteConfigurationComplexLifting: + """Test the DiscreteConfigurationComplexLifting class.""" + + def setup_method(self): + # Load the graph + self.dataset = load_simple_configuration_graphs() + + # Initialise the DiscreteConfigurationComplexLifting class + self.liftings = [ + DiscreteConfigurationComplexLifting( + k=2, preserve_edge_attr=True, feature_aggregation="mean" + ), + DiscreteConfigurationComplexLifting( + k=2, preserve_edge_attr=True, feature_aggregation="sum" + ), + DiscreteConfigurationComplexLifting( + k=2, preserve_edge_attr=True, feature_aggregation="concat" + ), + ] + + def test_lift_topology(self): + # Test the lift_topology method + + expected_incidences_data_0 = ( + 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, + 0.0, + 0.0, + 0.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, + 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, + 0.0, + 0.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, + 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, + 0.0, + 0.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, + 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, + 0.0, + ], + [ + 0.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, + 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, + 0.0, + 1.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, + 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, + 0.0, + 0.0, + 0.0, + 0.0, + 0.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, + 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, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + ], + [ + 0.0, + 0.0, + 0.0, + 0.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, + 1.0, + 1.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, + 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, + 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, + 0.0, + 0.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, + 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, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + ], + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.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, + 1.0, + 1.0, + 0.0, + 0.0, + 0.0, + ], + [ + 0.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, + 0.0, + 0.0, + 0.0, + 0.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, + 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, + 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, + 0.0, + 0.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, + 0.0, + 0.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, + 1.0, + 1.0, + ], + [ + 0.0, + 0.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, + 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, + 0.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, + 0.0, + 0.0, + 0.0, + 0.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, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 1.0, + ], + ] + ), + torch.tensor([]), + ) + + expected_incidences_data_1 = ( + torch.tensor( + [ + [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, 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, 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, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 0.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, 1.0, 0.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, 1.0, 0.0, 0.0], + [1.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, 0.0, 0.0, 1.0, 0.0, 0.0, 0.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, 0.0, 1.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], + [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0], + ] + ), + torch.tensor([]), + ) + + expected_incidences_data_2 = ( + torch.tensor( + [ + [ + 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, + 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, + 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, + ], + [ + 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, + 0.0, + 0.0, + 1.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, + 0.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, + 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, + 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, + 0.0, + 0.0, + 0.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, + 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, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 1.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, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 1.0, + 1.0, + ], + ] + ), + torch.tensor( + [ + [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], + [1.0, 0.0], + [0.0, 0.0], + [0.0, 1.0], + [0.0, 1.0], + [0.0, 1.0], + [0.0, 1.0], + [0.0, 0.0], + [0.0, 0.0], + ] + ), + ) + + for lifting in self.liftings: + lifted_data = lifting.forward(self.dataset[0].clone()) + assert ( + expected_incidences_data_0[0] == lifted_data.incidence_1.to_dense() + ).all(), f"Something is wrong with incidence_1 for graph 0, {lifting.feature_aggregation} aggregation." + + assert ( + expected_incidences_data_0[1] == lifted_data.incidence_2.to_dense() + ).all(), f"Something is wrong with incidence_2 for graph 0, {lifting.feature_aggregation} aggregation." + + lifted_data = lifting.forward(self.dataset[1].clone()) + assert ( + expected_incidences_data_1[0] == lifted_data.incidence_1.to_dense() + ).all(), f"Something is wrong with incidence_1 for graph 1, {lifting.feature_aggregation} aggregation." + + assert ( + expected_incidences_data_1[1] == lifted_data.incidence_2.to_dense() + ).all(), f"Something is wrong with incidence_2 for graph 1, {lifting.feature_aggregation} aggregation." + + lifted_data = lifting.forward(self.dataset[2].clone()) + assert ( + expected_incidences_data_2[0] == lifted_data.incidence_1.to_dense() + ).all(), f"Something is wrong with incidence_1 for graph 2, {lifting.feature_aggregation} aggregation." + + assert ( + expected_incidences_data_2[1] == lifted_data.incidence_2.to_dense() + ).all(), f"Something is wrong with incidence_2 for graph 2, {lifting.feature_aggregation} aggregation." From 9591c92d6b66876919d7bdfd5aabcd0e204f043c Mon Sep 17 00:00:00 2001 From: Theo Long Date: Sat, 13 Jul 2024 00:48:48 -0400 Subject: [PATCH 11/11] run --- ...screte_configuration_complex_lifting.ipynb | 29 +++++++------------ 1 file changed, 10 insertions(+), 19 deletions(-) diff --git a/tutorials/graph2cell/discrete_configuration_complex_lifting.ipynb b/tutorials/graph2cell/discrete_configuration_complex_lifting.ipynb index bc0f566d..ccd12e39 100644 --- a/tutorials/graph2cell/discrete_configuration_complex_lifting.ipynb +++ b/tutorials/graph2cell/discrete_configuration_complex_lifting.ipynb @@ -51,18 +51,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "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", @@ -93,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -131,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -170,7 +161,7 @@ "Data(x=[4, 1], edge_index=[2, 4], edge_attr=[4, 1], y=[1], num_nodes=4)" ] }, - "execution_count": 18, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -225,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -266,7 +257,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -328,7 +319,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -376,7 +367,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -411,7 +402,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [