train_test_split_edges.py

import math
import torch
from torch_geometric.utils import to_undirected


def train_split_edges(data):
    r"""Splits the edges of a :obj:`torch_geometric.data.Data` object
    into positive and negative train/val/test edges, and adds attributes of
    `train_pos_edge_index`, `train_neg_adj_mask`, `val_pos_edge_index`,
    `val_neg_edge_index`, `test_pos_edge_index`, and `test_neg_edge_index`
    to :attr:`data`.

    Args:
        data (Data): The data object.
        val_ratio (float, optional): The ratio of positive validation
            edges. (default: :obj:`0.05`)
        test_ratio (float, optional): The ratio of positive test
            edges. (default: :obj:`0.1`)

    :rtype: :class:`torch_geometric.data.Data`
    """

    #assert 'batch' not in data  # No batch-mode.

    num_nodes = data.num_nodes
    row, col = data.edge_index

    if data.edge_index.shape[1] == 0:
        data.train_pos_edge_index = data.edge_index
        data.train_neg_edge_index = torch.empty((2,0), dtype=torch.long)

        data.test_pos_edge_index = torch.empty((2,0), dtype=torch.long)
        data.test_neg_edge_index = torch.empty((2,0), dtype=torch.long)

        data.val_pos_edge_index = torch.empty((2,0), dtype=torch.long)
        data.val_neg_edge_index = torch.empty((2,0), dtype=torch.long)

        data.edge_index = None
        return data
    
    data.edge_index = None

    # Return upper triangular portion.
    
    mask = row > col
    row, col = row[mask], col[mask]
    

    # Positive edges.
    perm = torch.randperm(row.size(0))
    row, col = row[perm], col[perm]

    data.test_pos_edge_index = torch.empty((2,0), dtype=torch.long)

    data.val_pos_edge_index = torch.empty((2,0), dtype=torch.long)

    r, c = row[:], col[:]

    data.train_pos_edge_index = torch.stack([r, c], dim=0)

    data.train_pos_edge_index = to_undirected(data.train_pos_edge_index)


    # Negative edges.
    neg_adj_mask = torch.ones(num_nodes, num_nodes, dtype=torch.uint8)
    neg_adj_mask = neg_adj_mask.tril(diagonal=1).to(torch.bool) #neg_adj_mask = neg_adj_mask.triu(diagonal=1).to(torch.bool)
    neg_adj_mask[row, col] = 0

    neg_row, neg_col = neg_adj_mask.nonzero(as_tuple=False).t()
    perm = torch.randperm(neg_row.size(0))[:]

    perm = torch.randperm(neg_row.size(0))[:]
    neg_row, neg_col = neg_row[perm], neg_col[perm]

    neg_adj_mask[neg_row, neg_col] = 0
    data.train_neg_adj_mask = neg_adj_mask

    row, col = neg_row[:], neg_col[:]
    data.train_neg_edge_index = torch.stack([row, col], dim=0)


    data.test_neg_edge_index = torch.empty((2,0), dtype=torch.long)

    data.val_neg_edge_index = torch.empty((2,0), dtype=torch.long)

    return data