Strange fixed output comming from GCNConv

[CaueEvang]

Hi, dear community.

I'm facing an issue with the outputs of a network based on the GCNConv Layer. I'm trying to build a graph classification network heavily based on the official collab notebook. My dataset(wich construction was talked about in this previous post) is a list of data objects, classified into three categories with 10 features per node.

The class of the network is as follows:

class GCN(torch.nn.Module):
    def __init__(self, hidden_channels):
        super(GCN, self).__init__()
        torch.manual_seed(12345)
        self.conv0   = GCNConv(10, 150)
        self.conv1   = GCNConv(150, 148)
        self.conv2   = GCNConv(148, 144)
        self.conv3   = GCNConv(144, 136)
        self.conv4   = GCNConv(136, 120)
        self.conv5   = GCNConv(120, 88)
        self.conv6   = GCNConv(88, 24)        
        self.lin     = Linear(24, 3)
        self.softmax = nn.Softmax(dim=1)

    def forward(self, x, edge_index, batch):
        # 1. Obtain node embeddings 
        x = self.conv0(x, edge_index)
        x = x.relu()
        x = self.conv1(x, edge_index)
        x = x.relu()
        x = self.conv2(x, edge_index)
        x = x.relu()
        x = self.conv3(x, edge_index)
        x = x.relu()
        x = self.conv4(x, edge_index)
        x = x.relu()
        x = self.conv5(x, edge_index)
        x = x.relu()
        x = self.conv6(x, edge_index)        

        # 2. Readout layer
        x = global_mean_pool(x, batch)  # [batch_size, hidden_channels]

        # 3. Apply a final classifier
        x = F.dropout(x, p=0.5, training=self.training)
        x = self.lin(x)
        x = self.softmax(x)
        
        return x

On the training loop, I'm using the labels as hot-encoded vectors:

def train():
    model.train()
    for data in train_loader:  # Iterate in batches over the training dataset.

        y_true = data.y
        y_true = y_true.numpy()
        y_true = one_hot(y_true,3)

        y_pred = model(data.x, data.edge_index, data.batch)  # Perform a single forward pass.     
        
        loss = torch.nn.CrossEntropyLoss(y_pred, y_true)  # Compute the loss.
        loss.backward()  # Derive gradients.
        SGDoptimizer.step()  # Update parameters based on gradients.
        SGDoptimizer.zero_grad()  # Clear gradients.

where the function one_hot(np_array,n_classes) takes an array of labels and returns a torch tensor whose components are one-hot encoded vectors({1,0,0},{0,1,0},{0,0,1}).

The issue is that after training, when I apply the network to the test data, the only label it gives me is {1,0,0}. This is confusing to me since I wrote a simple MLP that concatenates all the 10 features of each node, and it was able to return some results, so I think there is some detectable structure in the data.

I appreciate any help on this matter, this is driving me crazy!

[rusty1s]

Do you observe the same issue when reducing the number of GCNConv layers? GCNConv tends to blur the representations when stacked deeply. You can also try to use SAGEConv instead.