Training Enzyme Dataset

[akhil969]

Hello every one... Respected elders and my dear young people
I am very new to pytorch-geometry and I found this discussion page and i became very happy..Hope this page will help every one.

I am trying to train a model on enzyme dataset and getting the error.Olease help me in this

from torch_geometric.datasets import TUDataset
from torch_geometric.data import Data
from torch_geometric.loader import DataLoader
from sklearn.model_selection import train_test_split
dataset = TUDataset(root='/path/to/your/dataset', name='ENZYMES')
train_size=400
val_size=100
test_size=100

train_data, temp_data = train_test_split(dataset, train_size=train_size, shuffle=True, random_state=42)
val_data, test_data = train_test_split(temp_data, train_size=val_size/(val_size+test_size), shuffle=True, random_state=42)


#making data set into batches
train_loader=DataLoader(dataset=train_data,batch_size=10,shuffle=True)
val_loader=DataLoader(dataset=val_data,batch_size=10,shuffle=False)

#Defining NN classifier

import torch.nn as nn
from torch_geometric.nn import GCNConv

class EnzymeClassifier(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_classes):
        super(EnzymeClassifier, self).__init__()
        self.conv1 = GCNConv(input_dim, hidden_dim)
        self.conv2 = GCNConv(hidden_dim, num_classes)

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = self.conv2(x, edge_index)
        return x
model=EnzymeClassifier(3,10,6)

# Optimizer and loss def

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)



# Training loop
def train(model, train_loader, optimizer, criterion, device):
    model.train()
    total_loss = 0

    for data in train_loader:
        data = data.to(device)
        optimizer.zero_grad()
        output = model(data)
        # print("came")
        loss = criterion(output, data.y)
        print("came")
        loss.backward()
        optimizer.step()
        total_loss += loss.item()

    return total_loss / len(train_loader)

# Validation function
import torch
def validate(model, val_loader, criterion, device):
    model.eval()
    total_loss = 0
    with torch.no_grad():
        for data in val_loader:
            data = data.to(device)
            output = model(data)
            loss = criterion(output, data.y)
            total_loss += loss.item()

    return total_loss / len(val_loader)


# Move the model and data to a GPU if available
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

# Training loop
num_epochs = 50
for epoch in range(num_epochs):
    train_loss = train(model, train_loader, optimizer, criterion, device)
    val_loss = validate(model, val_loader, criterion, device)
    
    print(f"Epoch [{epoch + 1}/{num_epochs}]")
    print(f"Train Loss: {train_loss:.4f} | Validation Loss: {val_loss:.4f}")

I am getting the following error:

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Untitled-2.ipynb Cell 3 line 8
     [80](vscode-notebook-cell:Untitled-2.ipynb?jupyter-notebook#W5sdW50aXRsZWQ%3D?line=79) num_epochs = 50
     [81](vscode-notebook-cell:Untitled-2.ipynb?jupyter-notebook#W5sdW50aXRsZWQ%3D?line=80) for epoch in range(num_epochs):
---> [82](vscode-notebook-cell:Untitled-2.ipynb?jupyter-notebook#W5sdW50aXRsZWQ%3D?line=81)     train_loss = train(model, train_loader, optimizer, criterion, device)
     [83](vscode-notebook-cell:Untitled-2.ipynb?jupyter-notebook#W5sdW50aXRsZWQ%3D?line=82)     val_loss = validate(model, val_loader, criterion, device)
     [85](vscode-notebook-cell:Untitled-2.ipynb?jupyter-notebook#W5sdW50aXRsZWQ%3D?line=84)     print(f"Epoch [{epoch + 1}/{num_epochs}]")

Untitled-2.ipynb Cell 3 line 5
     [50](vscode-notebook-cell:Untitled-2.ipynb?jupyter-notebook#W5sdW50aXRsZWQ%3D?line=49) output = model(data)
     [51](vscode-notebook-cell:Untitled-2.ipynb?jupyter-notebook#W5sdW50aXRsZWQ%3D?line=50) # print("came")
---> [52](vscode-notebook-cell:Untitled-2.ipynb?jupyter-notebook#W5sdW50aXRsZWQ%3D?line=51) loss = criterion(output, data.y)
     [53](vscode-notebook-cell:Untitled-2.ipynb?jupyter-notebook#W5sdW50aXRsZWQ%3D?line=52) print("came")
     [54](vscode-notebook-cell:Untitled-2.ipynb?jupyter-notebook#W5sdW50aXRsZWQ%3D?line=53) loss.backward()

File [c:\Users\AKHIL\AppData\Local\Programs\Python\Python311\Lib\site-packages\torch\nn\modules\module.py:1501](file:///C:/Users/AKHIL/AppData/Local/Programs/Python/Python311/Lib/site-packages/torch/nn/modules/module.py:1501), in Module._call_impl(self, *args, **kwargs)
   1496 # If we don't have any hooks, we want to skip the rest of the logic in
   1497 # this function, and just call forward.
   1498 if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks
   1499         or _global_backward_pre_hooks or _global_backward_hooks
   1500         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1501     return forward_call(*args, **kwargs)
   1502 # Do not call functions when jit is used
   1503 full_backward_hooks, non_full_backward_hooks = [], []
...
   3027 if size_average is not None or reduce is not None:
   3028     reduction = _Reduction.legacy_get_string(size_average, reduce)
-> 3029 return torch._C._nn.cross_entropy_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index, label_smoothing)

ValueError: Expected input batch_size (324) to match target batch_size (10).

[rusty1s]

You are missing a graph-level readout function, since you want to predict a class per graph, not per node. This works for me:

class EnzymeClassifier(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_classes):
        super(EnzymeClassifier, self).__init__()
        self.conv1 = GCNConv(input_dim, hidden_dim)
        self.conv2 = GCNConv(hidden_dim, hidden_dim)
        self.lin = torch.nn.Linear(hidden_dim, num_classes)

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = self.conv2(x, edge_index)
        x = global_mean_pool(x, data.batch)
        x = self.lin(x)
        return x

[akhil969]

Thanks for your reply sir I got it now . Now I am getting my test accuracy very less around 0.15 . How can I improve it . I have this doubt there are many functions as mentioned in GNNCheatsheet:
https://pytorch-geometric.readthedocs.io/en/latest/cheatsheet/gnn_cheatsheet.html . How to know which function should we use when ?
For your kind information my test code is here:

def test(model, test_loader, criterion, device):
    model.eval()
    total_loss = 0
    correct=0
    total=0
    with torch.no_grad():
        for data in test_loader:
            data = data.to(device)
            output = model(data)
            loss = criterion(output, data.y)
            total_loss += loss.item()
            # Calculate accuracy
            _, predicted = torch.max(output, 1)  # Get the predicted class with the highest score
            total += data.y.size(0)  # Total number of examples
            correct += (predicted == data.y).sum().item()  # Number of correct predictions
    accuracy=correct/total
    return total_loss / len(test_loader),accuracy
test_loss,accuracy = test(model, test_loader, criterion, device)

ThankYou

[rusty1s]

Your code looks absolutely fine. To improve performance, I suggest you try out SAGEConv, stack more layers, use BatchNorm in between GNN layers and use an MLP rather than a Linear layer for final prediction.