Making heterogeneous graph classification models

[aauricchio]

Hello, I am currently trying to make a heterogenous graph classification model with a dataset of 1000 graphs. I haven't been able to find any examples of this online, and I get the error "RuntimeError: mat1 and mat2 must have the same dtype". The datatype of the x in the forward method is "Proxy(getattr_1)", and I am unsure of what this means. Any help would be greatly appreciated.

torch.nn.functional as F
import torch_geometric.transforms as T
from torch_geometric.nn import SAGEConv, to_hetero
from torch_geometric.nn import global_mean_pool
from torch_geometric.nn import Linear, SAGEConv, to_hetero

class GNNHetero(torch.nn.Module):
    def __init__(self, hidden_channels):
        super().__init__()
        self.conv1 = SAGEConv((-1, -1), hidden_channels)
        self.conv2 = SAGEConv((-1, -1), 1)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index).relu()
        x = self.conv2(x, edge_index)
        print(x.dtype)

        return x
    
data = dataset[0]
model = to_hetero(GNNHetero(64), data.metadata(), aggr='sum')

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = torch.nn.MSELoss()

def train_hetero():
    model.train()

    for batch in train_loader:  # Iterate in batches over the training dataset.

        out = model(batch.x_dict, batch.edge_index_dict)  # Perform a single forward pass.
        target = data.y.unsqueeze(1)
        loss = criterion(out, target)  # Compute the loss.
        loss.backward()  # Derive gradients.
        optimizer.step()  # Update parameters based on gradients.
        optimizer.zero_grad()  # Clear gradients.

for epoch in range(1, 171):
    print(f'Epoch: {epoch}')
    train_hetero()

print('Done!')

Any help would be really appreciated! Thank you in advance.

An example of one of the graphs is below:

dataset[0]

HeteroData(
  y=0.0254,
  central={ x=[1, 1] },
  in_plane={ x=[3, 1] },
  out_plane={ x=[2, 1] },
  (in_plane, to, central)={ edge_index=[2, 3] },
  (out_plane, to, central)={ edge_index=[2, 2] },
  (central, to, in_plane)={ edge_index=[2, 3] },
  (central, to, out_plane)={ edge_index=[2, 2] }
)

Thank you!

[rusty1s]

We don‘t have any examples for this since I am
not aware of any publicly available heterogeneous graph datasets for graph classification.

I think your example looks good, but you are missing a global pooling. Currently, your model returns a dictionary of node features while it needs to return a single tensor. One way to achieve this would be to run

out = sum(global_mean_pool(x_dict[v], batch_dict[v]) for v in data.node_types))

[aauricchio]

Thank you very much for the reply. This worked. I also fixed the dtype error by setting the weights of the x_dict to float with x_dict['central'] = x_dict['central'].to(torch.float).