explain_graph

[JerryJohnThomas]

So I have a standard GNN model with def forward(self, x, edge_attr, edge_index, batch = torch.zeros(5)): and in my explainer function node_feat_mask, edge_mask = explainer.explain_graph(graph.x, graph.edge_index) so when i do this the error is
TypeError: forward() missing 1 required positional argument: 'edge_attr'
so when i add an additional argument it says
TypeError: forward() got multiple values for argument 'edge_attr'

NOTE: Answering the above q would be very valueable. or answering this next line is also fine. Im not using edge_attr in my model at the moment, so is there a way i can remove it from forward.

[xuesongwang]

Hi Jerry,

I am not an expert in explain_graph, but if you want to explain graph edges, you can't get results on edge_index as their types are torch.Long and I belive you can only obtain results from torch.Float. So in order to get edge explanation, you can simply input edge_attr as torch.ones((edge_index.shape[-1])).to(graph.x.device) just to give them a standard weight 1 and you will be able to see any result from there. Hope that's helpful

[rusty1s]

I don't think this is necessary since we will automatically set a trainable weight for edges during message passing. Explainability in PyG should work with or without any edge features.

[rusty1s]

I think this was a bug introduced in PyG 2.0.4, sorry for that. Can you try to confirm if that problem still exists when upgrading, see here?

[JerryJohnThomas]

Unfortunately even after installing nightly the error persists

[JerryJohnThomas]

Im attaching some snippets of the code If any good samiritan wants to help :') .

The Model Code

class GNN(torch.nn.Module):
    def __init__(self, feature_size):
        super(GNN, self).__init__()
        num_classes = 2
        embedding_size = 128

        # GNN layers
        self.conv1 = GATConv(feature_size, embedding_size, heads=3, dropout=0.3)
        self.head_transform1 = Linear(embedding_size*3, embedding_size)
        self.pool1 = TopKPooling(embedding_size, ratio=0.8)
        self.conv2 = GATConv(embedding_size, embedding_size, heads=3, dropout=0.3)
        self.head_transform2 = Linear(embedding_size*3, embedding_size)
        self.pool2 = TopKPooling(embedding_size, ratio=0.5)
        self.conv3 = GATConv(embedding_size, embedding_size, heads=3, dropout=0.3)
        self.head_transform3 = Linear(embedding_size*3, embedding_size)
        self.pool3 = TopKPooling(embedding_size, ratio=0.2)

            # Linear layers
        self.linear1 = Linear(embedding_size*2, 1024)
        self.linear2 = Linear(1024 , 512)  
        self.linear3 = Linear(512, 128)  
        self.linear4 = Linear(128, num_classes)  

    def forward(self, x, edge_attr, edge_index, batch):
        # First block
        x = self.conv1(x, edge_index)
        x = self.head_transform1(x)

        x, edge_index, edge_attr, batch, _, _ = self.pool1(x, 
                                                        edge_index, 
                                                        None,
                                                        batch
                                                        )

        x1 = torch.cat([gmp(x, batch), gap(x, batch)], dim=1)

        # Second block
        x = self.conv2(x, edge_index)
        x = self.head_transform2(x)
        x, edge_index, edge_attr, batch, _, _ = self.pool2(x, 
                                                        edge_index, 
                                                        None, 
                                                        batch)
        x2 = torch.cat([gmp(x, batch), gap(x, batch)], dim=1)

        # Third block
        x = self.conv3(x, edge_index)
        x = self.head_transform3(x)
        x, edge_index, edge_attr, batch, _, _ = self.pool3(x, 
                                                        edge_index, 
                                                        None, 
                                                        batch)
        x3 = torch.cat([gmp(x, batch), gap(x, batch)], dim=1)
        x = x1 + x2 + x3

        x = self.linear1(x).relu()
        x = F.dropout(x, p=0.15, training=self.training)
        x = self.linear2(x)
        # x = F.dropout(x, p=0.15, training=self.training)
        x = self.linear3(x)
        x = F.dropout(x, p=0.15, training=self.training)
        x = self.linear4(x)
        return x

The training runs as usual

Now for the explainer

Initliasing it

from torch_geometric.nn import GNNExplainer
explainer = GNNExplainer(model, epochs=200, return_type='log_prob')
graph = train_dataset[1]

Try 1 : from torch_geometric.nn import GNNExplainer explainer = GNNExplainer(model, epochs=200, return_type='log_prob') graph = train_dataset[1]

I get : TypeError: forward() got multiple values for argument 'edge_attr'

Try 2: node_feat_mask, cedge_mask = explainer.explain_graph(graph.x, graph.edge_index)
I get : TypeError: forward() missing 1 required positional argument: 'batch'

So I add batch

Try3:: node_feat_mask, cedge_mask = explainer.explain_graph(graph.x, graph.edge_index, batch=3)
Now I get : torch_geometric.nn.models.explainer.Explainer.get_initial_prediction() got multiple values for keyword argument 'batch'

Before I had upgraded to the new version i got the same error in edge_attr

My insights:
I feel thats because the

in explainer.py

234     if batch is not None:
235         out = self.model(x, edge_index, batch, **kwargs)
236     else:
237         out = self.model(x, edge_index, **kwargs)

here i feel edge_index was given before any other parameter hence the edge_attr coming before edge_index can never reach there.
(This is what i feel for edge_attr failing before, but now for this batch thing I'm clueless)

I am not a pro hence I could have made some fundamental mistakes, Thanking you in advance for your time, patience and your help..

[rusty1s]

Ah, got it. Note that you cannot use pooling when trying to explain a graph-level explanations. The graph structure needs to be constant across different applications of GNN layers in order to learn a single edge-level mask. This is a current limitation :(