Download annotations/annotation_15/GraphMETRO/graphmetro/utils/split_graph.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 3.99 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_15/GraphMETRO/graphmetro/utils/split_graph.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_15/GraphMETRO/graphmetro/utils/split_graph.py
-
curl -L -o split_graph.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_15/GraphMETRO/graphmetro/utils/split_graph.py
3.99 kB
| 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 | |