Trouble with heterogeneous graph learning using GCNConv operator

[cenzy]

I'm following the tutorial about Heterogeneous Graph Learning.
I imported the ogb-mag dataset and I wrote a simple model using GCNConv operators:

class GNN(torch.nn.Module):
    def __init__(self, hidden_channels, out_channels):
        super().__init__()
        self.conv1 = GCNConv(-1, hidden_channels)
        self.conv2 = GCNConv(-1, out_channels)

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

Then I create the model and convert to heterogeneous.

model = GNN(hidden_channels=64, out_channels=dataset.num_classes)
model = to_hetero(model, data.metadata(), aggr='sum')

But when I call the model

out = model(data.x_dict, data.edge_index_dict)

I get the following error:

----> 2 out = model(data.x_dict, data.edge_index_dict)

~/anaconda3/envs/thesis-project/lib/python3.9/site-packages/torch/fx/graph_module.py in wrapped_call(self, *args, **kwargs)
511 print(generate_error_message(topmost_framesummary),
512 file=sys.stderr)
--> 513 raise e.with_traceback(None)
514
515 cls.call = wrapped_call

AttributeError: 'tuple' object has no attribute 'size'

I replaced the GCNConv operator with the SAGEConv and everything works fine.
What is wrong about GCNConv?

[rusty1s]

Yes, GCNConv is only defined to work on homogeneous graphs. Our GNN cheat sheet table lists all operators that can operate on bipartite graphs.

[cenzy]

Thank you for the reply.
I see that in the tutorial the Heterogenous Convolution Wrapper allow you to use the GCNConv (as explained here). I tried the following but I get the same error (AttributeError: 'tuple' object has no attribute 'size'). Basically, for each edge type I set the GCNConv.

class HeteroGNN(torch.nn.Module):
    def __init__(self, metadata, hidden_channels, out_channels):
        super().__init__()

        self.conv1 = HeteroConv({
            edge_type: GCNConv(-1, hidden_channels)
            for edge_type in metadata[1]
        }, aggr='sum')

        self.conv2 = HeteroConv({
            edge_type: GCNConv(hidden_channels, out_channels)
            for edge_type in metadata[1]
        }, aggr='sum')

    def forward(self, x, edge_index):
        x_dict= self.conv1(x, edge_index)
        x_dict = {key: x.relu() for key, x in x_dict.items()}
        x_dict = self.conv2(x_dict, edge_index)
        x_dict = {key: F.log_softmax(x, dim=1) for key, x in x_dict.items()}
        return x_dict
        
model = HeteroGNN(metadata=data.metadata(), hidden_channels=64, out_channels=dataset.num_classes)
out = model(data.x_dict, data.edge_index_dict)

[rusty1s]

Note that in the tutorial, the GCNConv is applied on the edge type with same source and destination node type. For other edge types, it will fail.

[cenzy]

You're right! I didn't notice that. What do you suggest for applying the GCNConv operator for heterogeneous graphs?

[rusty1s]

You can swap it for SAGEConv or GraphConv (with mean aggregation), which are quite similar to the GCNConv (except that they perform mean aggregation instead of symmetric normalization).

[cenzy]

Thank you very much.