| import os |
| import copy |
| import math |
| import pickle |
| import random |
| import collections |
| import numpy as np |
| import networkx as nx |
| import torch |
| import torch.nn.functional as F |
| from torch_geometric.data import Data |
|
|
| TRAIN_MODE = "train" |
| VAL_MODE = "val" |
| TEST_MODE = "test" |
| |
|
|
| GMN_DATA_TYPE = "gmn" |
| PYG_DATA_TYPE = "pyg" |
|
|
| GraphCollection = collections.namedtuple( |
| 'GraphCollection', |
| ['from_idx', 'to_idx', 'node_features', 'edge_features', 'graph_idx', 'num_graphs'] |
| ) |
|
|
| class SubgraphIsomorphismDataset: |
| def __init__(self, mode, dataset_name, dataset_size, batch_size, data_type, dataset_base_path, experiment, dataset_path_override=None, device=None): |
| |
| assert mode in [TRAIN_MODE, VAL_MODE, TEST_MODE] |
| self.mode = mode |
| self.dataset_name = dataset_name |
| self.dataset_size = dataset_size |
| self.max_node_set_size = {"small": 15, "large": 20}[dataset_size] |
| self.batch_size = batch_size |
| self.data_type = data_type |
| self.dataset_base_path = dataset_base_path |
| self.device = experiment.device if experiment else (device if device else 'cuda:0') |
| self.batch_setting = None |
| self.dataset_path_override = dataset_path_override |
|
|
| self.load_graphs(experiment=experiment) |
| self.preprocess_subgraphs_to_pyG_data() |
| self.build_adjacency_info() |
|
|
| self.max_edge_set_size = max( |
| max([graph.number_of_edges() for graph in self.query_graphs]), |
| max([graph.number_of_edges() for graph in self.corpus_graphs]) |
| ) |
|
|
| def load_graphs(self, experiment): |
| dataset_accessor = lambda file_name: os.path.join( |
| self.dataset_base_path, self.dataset_path_override or f"{self.dataset_size}_dataset", |
| "splits", self.mode, file_name |
| ) |
| |
| |
| pair_count = f"{80 if self.dataset_size == 'small' else 240}k" |
| mode_prefix = "test" if "test" in self.mode else self.mode |
| query_graph_file = dataset_accessor(f"{mode_prefix}_{self.dataset_name}{pair_count}_query_subgraphs.pkl") |
| self.query_graphs = pickle.load(open(query_graph_file, 'rb')) |
| num_query_graphs = len(self.query_graphs) |
| if experiment: |
| experiment.log("loaded %s query graphs from %s", self.mode, query_graph_file) |
|
|
| |
| relationships_file = query_graph_file.replace("query_subgraphs", "rel_nx_is_subgraph_iso") |
| self.relationships = pickle.load(open(relationships_file, 'rb')) |
| if experiment: |
| experiment.log("loaded %s relationships from %s", self.mode, relationships_file) |
|
|
| assert list(self.relationships.keys()) == list(range(num_query_graphs)) |
|
|
| |
| corpus_graph_file = os.path.join( |
| os.path.dirname(os.path.dirname(os.path.dirname(query_graph_file))), "corpus", |
| f"{self.dataset_name}{pair_count}_corpus_subgraphs.pkl" |
| ) |
| self.corpus_graphs = pickle.load(open(corpus_graph_file, 'rb')) |
| if experiment: |
| experiment.log("loaded corpus graphs from %s", corpus_graph_file) |
|
|
| self.pos_pairs, self.neg_pairs = [], [] |
| for query_idx in range(num_query_graphs): |
| for corpus_idx in self.relationships[query_idx]['pos']: |
| self.pos_pairs.append((query_idx, corpus_idx)) |
| for corpus_idx in self.relationships[query_idx]['neg']: |
| self.neg_pairs.append((query_idx, corpus_idx)) |
|
|
| def create_pyG_object(self, graph): |
| num_nodes = graph.number_of_nodes() |
| features = torch.ones(num_nodes, 1, dtype=torch.float, device=self.device) |
|
|
| edges = list(graph.edges) |
| doubled_edges = [[x, y] for (x, y) in edges] + [[y, x] for (x, y) in edges] |
| edge_index = torch.tensor(np.array(doubled_edges).T, dtype=torch.int64, device=self.device) |
| return Data(x = features, edge_index = edge_index), num_nodes |
|
|
| def preprocess_subgraphs_to_pyG_data(self): |
| self.query_graph_data, self.query_graph_sizes = zip( |
| *[self.create_pyG_object(query_graph) for query_graph in self.query_graphs] |
| ) |
| self.corpus_graph_data, self.corpus_graph_sizes = zip( |
| *[self.create_pyG_object(corpus_graph) for corpus_graph in self.corpus_graphs] |
| ) |
| |
| def build_adjacency_info(self): |
| def adj_list_from_graph_list(graphs): |
| adj_list = [] |
| for graph in graphs: |
| unpadded_adj = torch.tensor(nx.adjacency_matrix(graph).todense(), dtype=torch.float, device=self.device) |
| assert unpadded_adj.shape[0] == unpadded_adj.shape[1] |
| num_nodes = len(unpadded_adj) |
| padded_adj = F.pad(unpadded_adj, pad = (0, self.max_node_set_size - num_nodes, 0, self.max_node_set_size - num_nodes)) |
| adj_list.append(padded_adj) |
| return adj_list |
|
|
| self.query_adj_list = adj_list_from_graph_list(self.query_graphs) |
| self.corpus_adj_list = adj_list_from_graph_list(self.corpus_graphs) |
| |
| def _pack_batch(self, graphs): |
| from_idx = [] |
| to_idx = [] |
| graph_idx = [] |
| all_graphs = [individual_graph for graph_tuple in graphs for individual_graph in graph_tuple] |
|
|
| total_nodes, total_edges = 0, 0 |
| for idx, graph in enumerate(all_graphs): |
| num_nodes = graph.number_of_nodes() |
| num_edges = graph.number_of_edges() |
| edges = np.array(graph.edges(), dtype=np.int32) |
| |
| from_idx.append(edges[:, 0] + total_nodes) |
| to_idx.append(edges[:, 1] + total_nodes) |
| graph_idx.append(np.ones(num_nodes, dtype=np.int32) * idx) |
|
|
| total_nodes += num_nodes |
| total_edges += num_edges |
| |
| return GraphCollection( |
| from_idx = torch.tensor(np.concatenate(from_idx, axis=0), dtype=torch.int64, device=self.device), |
| to_idx = torch.tensor(np.concatenate(to_idx, axis=0), dtype=torch.int64, device=self.device), |
| graph_idx = torch.tensor(np.concatenate(graph_idx, axis=0), dtype=torch.int64, device=self.device), |
| num_graphs = len(all_graphs), |
| node_features = torch.ones(total_nodes, 1, dtype=torch.float, device=self.device), |
| edge_features = torch.ones(total_edges, 1, dtype=torch.float, device=self.device) |
| ) |
|
|
| def create_stratified_batches(self): |
| self.batch_setting = 'stratified' |
| random.shuffle(self.pos_pairs), random.shuffle(self.neg_pairs) |
| pos_to_neg_ratio = len(self.pos_pairs) / len(self.neg_pairs) |
|
|
| num_pos_per_batch = math.ceil(pos_to_neg_ratio/(1 + pos_to_neg_ratio) * self.batch_size) |
| num_neg_per_batch = self.batch_size - num_pos_per_batch |
|
|
| batches_pos, batches_neg = [], [] |
| labels_pos, labels_neg = [], [] |
| for idx in range(0, len(self.pos_pairs), num_pos_per_batch): |
| elements_remaining = len(self.pos_pairs) - idx |
| elements_chosen = min(num_pos_per_batch, elements_remaining) |
| batches_pos.append(self.pos_pairs[idx : idx + elements_chosen]) |
| labels_pos.append([1.0] * elements_chosen) |
| for idx in range(0, len(self.neg_pairs), num_neg_per_batch): |
| elements_remaining = len(self.neg_pairs) - idx |
| elements_chosen = min(num_neg_per_batch, elements_remaining) |
| batches_neg.append(self.neg_pairs[idx : idx + elements_chosen]) |
| labels_neg.append([0.0] * elements_chosen) |
|
|
| self.num_batches = min(len(batches_pos), len(batches_neg)) |
| self.batches = [pos + neg for (pos, neg) in zip(batches_pos[:self.num_batches], batches_neg[:self.num_batches])] |
| self.labels = [pos + neg for (pos, neg) in zip(labels_pos[:self.num_batches], labels_neg[:self.num_batches])] |
|
|
| return self.num_batches |
|
|
| def create_custom_batches(self, pair_list): |
| self.batch_setting = 'custom' |
| self.batches = [] |
| for idx in range(0, len(pair_list), self.batch_size): |
| self.batches.append(pair_list[idx : idx + self.batch_size]) |
| |
| self.num_batches = len(self.batches) |
| return self.num_batches |
|
|
| def fetch_batch_by_id(self, idx): |
| assert idx < self.num_batches |
| batch = self.batches[idx] |
|
|
| query_graph_idxs, corpus_graph_idxs = zip(*batch) |
| |
| if self.data_type == GMN_DATA_TYPE: |
| query_graphs = [self.query_graphs[idx] for idx in query_graph_idxs] |
| corpus_graphs = [self.corpus_graphs[idx] for idx in corpus_graph_idxs] |
| all_graphs = self._pack_batch(zip(query_graphs, corpus_graphs)) |
| elif self.data_type == PYG_DATA_TYPE: |
| query_graphs = [self.query_graph_data[idx] for idx in query_graph_idxs] |
| corpus_graphs = [self.corpus_graph_data[idx] for idx in corpus_graph_idxs] |
| all_graphs = list(zip(query_graphs, corpus_graphs)) |
|
|
| query_graph_sizes = [self.query_graph_sizes[idx] for idx in query_graph_idxs] |
| corpus_graph_sizes = [self.corpus_graph_sizes[idx] for idx in corpus_graph_idxs] |
| all_graph_sizes = list(zip(query_graph_sizes, corpus_graph_sizes)) |
|
|
| query_graph_adjs = [self.query_adj_list[idx] for idx in query_graph_idxs] |
| corpus_graph_adjs = [self.corpus_adj_list[idx] for idx in corpus_graph_idxs] |
| all_graph_adjs = list(zip(query_graph_adjs, corpus_graph_adjs)) |
|
|
| if self.batch_setting == 'stratified': |
| target = torch.tensor(np.array(self.labels[idx]), dtype=torch.float, device=self.device) |
| return all_graphs, all_graph_sizes, target, all_graph_adjs |
| elif self.batch_setting == 'custom': |
| return all_graphs, all_graph_sizes, None, all_graph_adjs |
| else: |
| raise NotImplementedError |
|
|
| def get_datasets(dataset_config, experiment, data_type, modes=['train', 'val']): |
| return { |
| mode: SubgraphIsomorphismDataset( |
| mode = mode, experiment = experiment, |
| data_type = data_type, **dataset_config |
| ) for mode in modes |
| } |
