Graph-level regression dataset num_classes

[JeffreyOwen]

I have recently dabbled in graph neural networks.
I have collected my own dataset of 1000 graphs where i plan on performing graph-level regression task. I believe i have stored each graph in the dataset class by using

graph= Data(x=x, edge_index=edge_idx, edge_attr=edge_attribute_tensor, y=y)

so when i print my dataset[i] it looks like this:

Data(x=[64, 1], edge_index=[2, 182], edge_attr=[182, 3], y=[1])

now the problem is that when i print out dataset.num_classes, it shows that i have 1000 classes because i think the _infer_num_classes each target value as its own class. does anyone know how to fix this? how is the dataset supposed to be stored when the task is graph-level regression?

One "solution" i tried was changing output channel directly to 1 and it causes all prediction to output the same value. for the whole dataset.
I also tried changing the num_classes property directly to 1 and it yields the same result.
By output of the same value, i mean that when i run the following code it gives the same answer for all loop iterations:

for data in dataset:
    out = model(data.x, data.edge_index, data.batch, data.edge_attr)
    print(out.detach().cpu().numpy())

In addition, i am wondering if anyone has a simple implementation/tutorial for graph-level regression task for any open dataset since i can't seem to find one.
any help is appreciated!

[wsad1]

What would you like num_classes to return in this case? Since this is a regression task can we just ignore the num_classes?

[JeffreyOwen]

Thank you for your response. I am deeply grateful!

I am not sure either. Is it normal for it to return 1000 if i have a dataset of 1000 graphs with different target values (ex.: float ranging from 0 to 50)?

In addition, can I confirm if this graph-level regression implementation makes sense?

class GNN(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super().__init__()
        self.conv1 = nn.GATv2Conv(in_channels, hidden_channels, edge_dim=3) # I have 3 edge features
        self.conv2 = nn.GATv2Conv(hidden_channels, hidden_channels, edge_dim=3)
        self.lin1 = Linear(hidden_channels, hidden_channels)
        self.lin2 = Linear(hidden_channels, out_channels)

    def forward(self, x, edge_index, batch, edge_attrs):
        
        x = self.conv1(x, edge_index, edge_attr = edge_attrs)
        x = F.relu(x)
        x = F.dropout(x, p=0.1, training=self.training)
        x = self.conv2(x, edge_index, edge_attr = edge_attrs)
        x = F.relu(x)
        x = F.dropout(x, p=0.1, training=self.training)
        x = global_mean_pool(x, batch)
        x = self.lin1(x)
       return self.lin2(x)

model = GNN(dataset.num_features, hidden_channels=64, out_channels=1).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
# and then proceeds with training

I realized that when I run the following code to check my output, each one of the instance in the for-loop produces the same output value. (Ex.: 25.123).

for data in test_dataset:
    model.eval()
    out = model(data.x, data.edge_index, data.batch, data.edge_attr)
    print(out.detach().cpu().numpy())

any ideas why this might happen? Is it simply an indication of oversmoothing?

[wsad1]

For regression tasks ignore Dataset.num_classes because it simply counts the unique values in y.

To your follow up question. It is weird that the outputs are exactly the same. Are x and edge_attr different?

[JeffreyOwen]

Yes, they are different. x contains my node feature (dim: 64 nodes * 1 feature) and edge_attr contains my edge features (dim: 182 edges * 3 features).

All of my graphs are of the same size with different node feature, edge features, and target value y for each graph.
Data(x=[64, 1], edge_index=[2, 182], edge_attr=[182, 3], y=[1])

Is GNN unable to train these kinds of datasets? (a dataset with a bunch of same graph shape, just different features?

[wsad1]

global_mean_pool could oversmooth your output, maybe try other pooling methods from here. To debug try global_max_pool to make sure the NN is indeed learning different features representations.

[JeffreyOwen]

Amazing! I tried using global_max_pool and it gave me insight on how I should proceed. It was simply a case of severe over-smoothing.
I am deeply grateful for your reply! God bless!