Molecule Graph Generation

[fork123aniket]

This question is regarding molecule generation using Variational Graph Autoencoders (VGAE). While following this example given as an example for VGAE in PyG, I ended up having two questions:-

1. My code looks like this:

transform = T.Compose([
    T.RandomLinkSplit(num_val=0.05, num_test=0.1, is_undirected=True,
                      split_labels=True, add_negative_train_samples=False),
])

dataset = ZINC(root='/tmp/ZINC', subset=True, transform=transform)

which outputs the following:

(
train_data: Data(x=[29, 1], edge_index=[2, 56], edge_attr=[56], y=[1], pos_edge_label=[28], pos_edge_label_index=[2, 28]), 
val_data: Data(x=[29, 1], edge_index=[2, 56], edge_attr=[56], y=[1], pos_edge_label=[1], pos_edge_label_index=[2, 1], neg_edge_label=[1], neg_edge_label_index=[2, 1]), 
test_data: Data(x=[29, 1], edge_index=[2, 58], edge_attr=[58], y=[1], pos_edge_label=[3], pos_edge_label_index=[2, 3], neg_edge_label=[3], neg_edge_label_index=[2, 3])
)

what interrupts my progress is to understand what these pos_edge_label, pos_edge_label_index, neg_edge_label, and neg_edge_label_index are and why do we need them in order to train VGAE??

2. I've used the following code snippet to generate graph for test_data:

@torch.no_grad()
def test(data):
    model.eval()
    z = model.encode(data.x, data.edge_index)
    return model.decoder.forward_all(z)

recon_adj = test(test_data)
print(recon_adj, recon_adj.size())

which outputs the following reconstructed probabilistic dense adjacency matrix (I'm including here only a small part of it):

tensor([[0.5109, 0.5115, 0.5041, 0.5010, 0.4981, 0.4981, 0.4980, 0.4981, 0.5111,
         0.5141, 0.5060, 0.5063, 0.5104, 0.5098, 0.5110, 0.5178, 0.5319, 0.5270,
         0.5270, 0.5121, 0.5064, 0.5109, 0.5079, 0.5041, 0.5038, 0.5068, 0.5024,
         0.4980, 0.5011],
        [0.5115, 0.5124, 0.5094, 0.5075, 0.5055, 0.5058, 0.5063, 0.5055, 0.5122,
         0.5130, 0.5101, 0.5096, 0.5117, 0.5114, 0.5118, 0.5153, 0.5229, 0.5182,
         0.5182, 0.5127, 0.5094, 0.5129, 0.5098, 0.5086, 0.5084, 0.5102, 0.5075,
         0.5064, 0.5070],
        [0.5041, 0.5094, 0.6242, 0.6569, 0.6826, 0.6877, 0.7005, 0.6826, 0.5158,
         0.4577, 0.5939, 0.5760, 0.5219, 0.5309, 0.5088, 0.4189, 0.2557, 0.2703,
         0.2703, 0.5007, 0.5694, 0.5358, 0.5417, 0.6068, 0.6112, 0.5779, 0.6259,
         0.7008, 0.6432],

Above reconstructed adjacency matrix has size of (29, 29) as original test_data's graph has 29 nodes in total. Suggestion about how to visualize the graph that resulted from this reconstructed adjacency matrix would be highly appreciated as this matrix has probabilities for each of the 841 (29 X 29) edges and which edge must exist for each of the 29 nodes in the graph is simply just unclear to me. In other words, we must have 0 and 1 values in the adjacency matrix to identify which edge connects the two nodes but here are just probabilities. So, do I need to somehow convert these probabilities to binary values (0 and 1) or is there any workaround to easily plot the graph using this "decoder yielded" reconstructed probabilistic dense adjacency matrix??

[rusty1s]

1. pos_edge_label_index and neg_edge_label_index denote the positive and negative links which are used for training the model via supervision. pos_edge_label and neg_edge_label hold their ground-truth labels (1 and 0, respectively). As such, you can train VGAE via

z = model(x, edge_index)  # obtain node embeddings

pos_loss = compute_loss((z[pos_edge_index_label[0]] * z[pos_edge_index_label[1]]).sum(dim=-1), pos_edge_label)
neg_loss = compute_loss((z[neg_edge_index_label[0]] * z[neg_edge_index_label[1]]).sum(dim=-1), neg_edge_label)

2. Yes, the output is a dense adjacency matrix which holds the probability of link existence. For obtaining a binary adjacency matrix, you must choose a threshold, e.g., via adj_binary = adj > 0.5.

[fork123aniket]

Thanks @rusty1s for your prompt response. This truly answers all of my questions. Thanks a lot!!!