| | 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 |
| | } |
