how can I perform node classification with PyG?

[Byun-jinyoung]

Dear PyG users,
Because I recently have known pytorch_geometric, I tried to apply it.

I have inputs like this:

Data(x=[144, 34], edge_index=[2, 2010], y=[144], edge_weight=[2010])
Data(x=[260, 34], edge_index=[2, 4886], y=[260], edge_weight=[4886])
Data(x=[249, 34], edge_index=[2, 4630], y=[249], edge_weight=[4630])
Data(x=[258, 34], edge_index=[2, 4908], y=[258], edge_weight=[4908])
Data(x=[99, 34], edge_index=[2, 1430], y=[99], edge_weight=[1430])
Data(x=[99, 34], edge_index=[2, 1422], y=[99], edge_weight=[1422])
. . .

One graph has the number of '34' node features of each node
One graph has a different size true_y values consisting of [0,1,0, 1,1,1 . . .].
The number of nodes in a graph is in same as the length of y.

I want to classify that a node is whether 0 or 1 with different sizes of a graph.

How can I classify a node in a different size graph?

Best regards :)

[rusty1s]

Your inputs look great. You can wrap them inside a list and pass them to torch_geometric.loader.DataLoader to create mini-batches from it:

data_list = [...]
loader = DataLoader(data_list, batch_size=32, shuffle=True)

You can then do node classification following the PyG node-level prediction examples, e.g., here and here:

for data in loader:
    data = data.to(device)
    optimizer.zero_grad()
    pred = model(data.x, data.edge_index)
    loss = F.cross_entropy(pred, data.y)
    loss.backward()
    optimizer.step()

[Byun-jinyoung]

I wrapped data inside data_list and pass them to DataLoader as below:

train_frac, val_frac, test_frac = 0.7, 0.1, 0.2
num_train, num_val, num_test = int(len(data_list) * train_frac), int(len(data_list) * val_frac), int(len(data_list) * test_frac)
train_set, val_set, test_set = data_list[:num_train], data_list[num_train:num_train + num_val], data_list[num_train+num_val:] 

train_loader = DataLoader(train_set, batch_size=100, shuffle=True, drop_last = False)
test_loader  = DataLoader(test_set, batch_size=100, shuffle=True, drop_last = False)
val_loader   = DataLoader(val_set, batch_size=100, shuffle=False, drop_last = False)

And my model has two channels in the last layer:
self.lin2 = Linear(int(hidden_size_list[-1] / 2), 2

However, I get the message like this:
ValueError: Expected input batch_size (100) to match target batch_size (24912)

Thus, I printed and check the output size of my model:

for idx, batch in enumerate(train_loader):
    out = model(batch.to(device))
    print(f'prediction: {out.size()}, true: {batch.y.size()}')        

    loss = F.cross_entropy(out, batch.y)
    loss.backward()
    optimizer.step()  
    optimizer.zero_grad() 

the output is: prediction: torch.Size([100, 2]), true: torch.Size([27894])

Could you tell me what I'm missing?

[rusty1s]

How does your model look like? It seems that at some point you apply some global readout function to obtain graph-level representations from node-level representations. You do not need to do this when you are facing a node-level prediction task.

[Byun-jinyoung]

class myGCN(torch.nn.Module):
    def __init__(self, input_size, maxSeqLength, hidden_size_list=[64, 128, 256, 512]):
        super().__init__()                
        
        self.GCNConv_layers = []
        for idx, hidden_size in enumerate(hidden_size_list[:-1]):
            if idx == 0: 
                self.GCNConv_layers.append(
                    GCNConv(input_size, hidden_size_list[idx])
                )
            else:
                self.GCNConv_layers.append(
                    GCNConv(hidden_size_list[idx], hidden_size_list[idx+1])
                )
        
        self.module_list = nn.ModuleList(self.GCNConv_layers)
        self.lin1 = Linear(hidden_size_list[-1], int(hidden_size_list[-1]/2))
        self.lin2 = Linear(int(hidden_size_list[-1] / 2), 2)
        self.sigmoid = nn.Sigmoid()

    def forward(self, data):
        x, edge_index, batch, edge_weight = data.x, data.edge_index, data.batch, data.edge_weight

        for layer in self.module_list:
            x = layer(x, edge_index, edge_weight)
            x = F.gelu(x) # 지난 과제에서 gelu가 가장 좋은 성능을 보여서 gelu 사용
            x = F.dropout(x, training=self.training)

        x = global_mean_pool(x, batch) # 전체의 node feature의 평균 값을 취한다. # [batch_size, hidden_channels]
        x = self.lin1(x)
        x = F.elu(x)
        x = self.lin2(x) 
        x = self.sigmoid(x)

        return x

Yes! you are right! I'm using the global_mean_pool layer. I will try not to use the global_mean_pool layer.