Question about node classification examples

[whtitefall]

Hi,

I'm new to GNN, I'm trying to do a project about node classification,

basically, I'm trying to model molecules using GCN and predict which atom will have a certain chemical reaction (so, atoms are nodes here)

the inputs are atom features, bond features, bond index,
the output is an array where each of the elements represents the probability of the chemical reaction will happen at this atom,

e.g.

input: Data(edge_attr=[64, 6], edge_index=[2, 64], x=[29, 82], y=[29, 1])
output: same shape as y=[29,1], with probability ranged from 0 - 1

here's my example code for the model,

class Net(torch.nn.Module):

     def __init__(self,num_node_features):
        super(Net, self).__init__()

        self.conv1 = GCNConv(num_node_features, 128)
        self.conv2 = GCNConv(128, 32)
        self.conv3 = GCNConv(32, 16)
        self.l1 = torch.nn.Linear(16,1)
     def forward(self, data):

        x, edge_index = data.x, data.edge_index

        x = self.conv1(x, edge_index)

        x = F.relu(x)
        x = self.conv2(x, edge_index)
        x = F.relu(x)
        x = self.conv3(x, edge_index)
        x = self.l1(x)
        return F.softmax(x)


class Net_Trainer():

    def __init__(self,model,loader):
        
        self.device = torch.device('cpu')
        self.model = model
        self.loader = loader
        self.optimizer = torch.optim.Adam(self.model.parameters(), lr=0.00001,)
 
    def train(self):
        
        self.model.train()
        total_loss = correct_nodes = total_nodes = 0

        highlighed_node = []

        for epoch in range(1):
            
            for i, data in enumerate(self.loader):
   
                data = data.to(self.device)

                self.optimizer.zero_grad()
                out = self.model(data)

                out = torch.squeeze(out,1)
        
                out_max = out.argmax(0)
      
                out_res = torch.zeros (out.shape,requires_grad=True).scatter (0, out_max, 1.0)
                out_res = torch.unsqueeze(out_res,1)

                loss = F.mse_loss(out_res, data.y)
   
                total_loss += loss.item()
                loss.backward()
                self.optimizer.step()

but the result returns all ones, I'm kind of confused about it,

I'm wondering if anyone can point out any examples or tell me where I did wrong in this case,

in particular, I'm wondering is it correct to pick the max value out_max from the model output as the prediction to calculate the loss?

Thank you!

[rusty1s]

Yes, the out_max is problematic here as you simple train your model only against positive atoms, resulting in a model that will output only ones regardless of input. Instead of using argmax, I suggest that you use a softer formulation, e.g., via softmax.

[whtitefall]

Hi, thank you so much for your reply, there's one thing I want to make sure of since I'm kind of new to GNN.

My task is to predict chemical reactions on each of the atoms (either 0 or 1), where the molecule is the graph and the atoms are the nodes, my plan is to output the probability on each of the atoms and take the atom with the largest prob as my prediction.

but I'm a bit confused since I checked the definition of node classification and graph classification, and found that my task doesn't belong to any one of those. (I'm assuming it's node classification)

currently, I'm using softmax on my model's output and take the largest embed value as the prob for the atoms, as shown below.

embed, pred = self.model(data).max(dim=1)

one problem with such configuration is that the pred shows all 0 because of the softmax,

I have two questions here,

1. To solve the problem above, can I have the sigmoid function that applies to each individual atom?
2. I'm wondering if I'm on the right track? since I didn't find any similar examples thus I'm a bit afraid I'm in the wrong direction.

Thank you so much !!

[rusty1s]

I still think you can treat this as a regular node classification task (with sigmoid output). During inference, you can then simply take the atom with highest probability, e.g.:

out = model(x, edge_index, edge_attr)  # [num_nodes, 1] output shape
# Training:
loss = F.binary_cross_entropy_with_logits(out, y)
# Inference: Find the atoms with highest probability:
max_prob, argmax_prob = torch_scatter.scatter_max(out, batch, dim=0)

[whtitefall]

Hello,

sorry to bring this old question up,

I'm still having a question,
as my experiment shows softmax + MSE has a much better F1-score than the binary_cross entropy,
(if I take the threshold > 0.5 as an answer from binary_cross, and picking top3 in softmax )

but I can't explain why this happens,

I did a bit of research on the loss functions

e.g.,

I checked the book GRL by William Hamilton on page 69, where it says the standard way for node classification is to use negative-loss likelihood as loss + softmax.

I read some articles and they said MSE for classification problem is not a good choice which is counter facts my experiment.

From my own understanding,

I'm wondering could it be the reason that the softmax is taking all atoms on the entire graph into consideration whereas binary_corss_entropy is considering a single atom at a time?

in case you can't remember my question, here is the link to my question asked on stack exchange

Thank you so much!!

[rusty1s]

I don't have a clear explanation for you. This is very interesting.

I think that in theory, the softmax approach should work just as fine. While you only utilize a single atom at a time for loss computation, all other atoms will be pushed to zero as well. However, it might be the case that the softmax struggles more due to a potentially high number of nodes, leading to vanishing gradients.