PGExplainer runtime error

[masteryqq]

Hi,

I am trying to use PGExplainer on MUTAG dataset after GCN. My GCN is as follows:

from torch.nn import Linear
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
from torch_geometric.nn import global_mean_pool


class GCN(torch.nn.Module):
    def __init__(self, hidden_channels):
        super(GCN, self).__init__()
        torch.manual_seed(12345)
        self.conv1 = GCNConv(dataset.num_node_features, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, hidden_channels)
        self.conv3 = GCNConv(hidden_channels, hidden_channels)
        self.lin = Linear(hidden_channels, dataset.num_classes)

    def forward(self, x, edge_index, batch):
        # 1. Obtain node embeddings
        x = self.conv1(x, edge_index)
        x = x.relu()
        x = self.conv2(x, edge_index)
        x = x.relu()
        x = self.conv3(x, edge_index)

        # 2. Readout layer
        x = global_mean_pool(x, batch)  # [batch_size, hidden_channels]

        # 3. Apply a final classifier
        x = F.dropout(x, p=0.5, training=self.training)
        x = self.lin(x)

        return x

model = GCN(hidden_channels=64)
print(model)

After training the dataset I used PGExplainer:

from tqdm import tqdm
from torch_geometric.explain import Explainer, PGExplainer
model.eval()

explainer_pge = Explainer(
    model=model,
    algorithm=PGExplainer(epochs=30, lr=0.003),
    explanation_type='phenomenon',
    edge_mask_type='object',
    model_config=dict(
        mode='binary_classification',
        task_level='graph',
        return_type='raw',
    ),
)

# Train against a variety of node-level or graph-level predictions:
for epoch in range(30):
    for data in train_loader:  # Indices to train against.
        loss = explainer_pge.algorithm.train(epoch, model, data.x, data.edge_index, target=data.y, batch=data.batch)

However, it shows error:

RuntimeError: shape '[64]' is invalid for input of size 128.

Could you please offer some suggestions?

Thanks!

-David

[akihironitta]

Hi @masteryqq, do you have a full stacktrace?

[masteryqq]

Hi @akihironitta , I am sorry I just saw the notification. The stacktrace is

[rusty1s]

I think for binary classification, you should make sure to return a single scalar inside your model. Otherwise, use multiclass_classification.

[masteryqq]

Hi @rusty1s , thanks to your help I could run PGExplainer now. However, the explanation it generated is abnormal.

from tqdm import tqdm
from torch_geometric.explain import Explainer, PGExplainer

# Initialize explainer with the model and PGExplainer algorithm
explainer_p = Explainer(
    model=model,
    algorithm=PGExplainer(epochs=30, lr=0.003),
    explanation_type='phenomenon',
    edge_mask_type='object',
    model_config=dict(
        mode='binary_classification',
        task_level='graph',
        return_type='raw',
    ),
)

for epoch in range(30):
  ls_loss = []
  for data in train_loader:
    loss = explainer_p.algorithm.train(
            epoch,
            model,
            data.x,
            data.edge_index,
            target=data.y,
            batch=data.batch
        )
    ls_loss.append(loss)
  print(epoch, ls_loss)

model.eval()

# The index of the graph in the dataset you want to explain
graph_index = 25

# Get the specific graph data
data_t = dataset[graph_index]

# Generate the explanation for the graph
explanation_t = explainer_p(
    x=data_t.x,
    edge_index=data_t.edge_index,
    batch=data_t.batch,
    target=data_t.y
)

data_t.y

print(explanation_t.edge_mask)

And the result is that the edge_mask is really small.

[mibah]

I have a similar observation. As far as I understand the optimization process its about the relative sizes because the regularization tries to push the values as low as possible. However, I'm still experimenting on this issue as well so I'm also interested in the latter issue.