File size: 3,989 Bytes
0ca2ffc | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 | import torch
import math
from torch_geometric.utils.num_nodes import maybe_num_nodes
from torch_geometric.data import Data
from torch_geometric.utils import degree
def split_batch(data):
split = degree(data.batch[data.edge_index[0]], dtype=torch.long).tolist()
edge_indices = torch.split(data.edge_index, split, dim=1)
if not data.edge_attr is None:
edge_attrs = torch.split(data.edge_attr, split, dim=1)
else:
edge_attrs = [None for _ in range(len(edge_indices))]
num_nodes = degree(data.batch, dtype=torch.long)
cum_nodes = torch.cat([data.batch.new_zeros(1), num_nodes.cumsum(dim=0)[:-1]])
num_edges = torch.tensor([e.size(1) for e in edge_indices], dtype=torch.long).to(data.x.device)
cum_edges = torch.cat([data.batch.new_zeros(1), num_edges.cumsum(dim=0)[:-1]])
data_list = []
for edge_index, edge_attr, N, C in zip(edge_indices, edge_attrs,
num_nodes, cum_nodes
):
data_list.append(Data(x=data.x[C:C+N],
edge_index=edge_index - C,
edge_attr=edge_attr,
batch=torch.zeros(N).long()
).to(data.x.device))
return data_list
# Bidirectional k-hop subgraph
# adapted from torch-geometric.utils.subgraph
def bid_k_hop_subgraph(node_idx, num_hops, edge_index, relabel_nodes=False,
num_nodes=None):
r"""Computes the :math:`k`-hop subgraph of :obj:`edge_index` around node
:attr:`node_idx`.
It returns (1) the nodes involved in the subgraph, (2) the filtered
:obj:`edge_index` connectivity, (3) the mapping from node indices in
:obj:`node_idx` to their new location, and (4) the edge mask indicating
which edges were preserved.
Args:
node_idx (int, list, tuple or :obj:`torch.Tensor`): The central
node(s).
num_hops: (int): The number of hops :math:`k`.
edge_index (LongTensor): The edge indices.
relabel_nodes (bool, optional): If set to :obj:`True`, the resulting
:obj:`edge_index` will be relabeled to hold consecutive indices
starting from zero. (default: :obj:`False`)
num_nodes (int, optional): The number of nodes, *i.e.*
:obj:`max_val + 1` of :attr:`edge_index`. (default: :obj:`None`)
flow (string, optional): The flow direction of :math:`k`-hop
aggregation (:obj:`"source_to_target"` or
:obj:`"target_to_source"`). (default: :obj:`"source_to_target"`)
:rtype: (:class:`LongTensor`, :class:`LongTensor`, :class:`LongTensor`,
:class:`BoolTensor`)
"""
num_nodes = maybe_num_nodes(edge_index, num_nodes)
row, col = edge_index
node_mask = row.new_empty(num_nodes, dtype=torch.bool)
edge_mask = row.new_empty(row.size(0), dtype=torch.bool)
if isinstance(node_idx, (int, list, tuple)):
node_idx = torch.tensor([node_idx], device=row.device).flatten()
else:
node_idx = node_idx.to(row.device)
subsets = [node_idx]
for _ in range(num_hops):
node_mask.fill_(False)
node_mask[subsets[-1]] = True
if len(subsets) > 1:
node_mask[subsets[-2]] = True
edge_mask1 = torch.index_select(node_mask, 0, row)
edge_mask2 = torch.index_select(node_mask, 0, col)
subsets.append(col[edge_mask1])
subsets.append(row[edge_mask2])
subset, inv = torch.cat(subsets).unique(return_inverse=True)
inv = inv[:node_idx.numel()]
node_mask.fill_(False)
node_mask[subset] = True
edge_mask = node_mask[row] & node_mask[col]
edge_index = edge_index[:, edge_mask]
if relabel_nodes:
node_idx = row.new_full((num_nodes, ), -1)
node_idx[subset] = torch.arange(subset.size(0), device=row.device)
edge_index = node_idx[edge_index]
return subset, edge_index, inv, edge_mask
|