GNNExplainer can only export the node_feat_mask node01

[shaanxicode]

hello dear,
I am running the GNNExplainer of Cora dataset to get the importance of node features. I found that node_feat_mask can output non-zero items only when i=0, otherwise it will output vectors with all zeros. And I also did a node regression problem can found the similar results. I'm wondering the reason for this question, does it can only output the average importance of all node features? Or can each node output its corresponding feature importance?
My codes are shown as below:

And the features and edgeindex are the whole graph's.

[shaanxicode]

I also found a new question that in my installed torch-geometric version 2.2.0 the Explainer is different from the source code here https://pytorch-geometric.readthedocs.io/en/latest/_modules/torch_geometric/explain/explainer.html#Explainer. This is the source code here:

class Explainer:
    r"""An explainer class for instance-level explanations of Graph Neural
    Networks.

    Args:
        model (torch.nn.Module): The model to explain.
        algorithm (ExplainerAlgorithm): The explanation algorithm.
        explanation_type (ExplanationType or str): The type of explanation to
            compute. The possible values are:

                - :obj:`"model"`: Explains the model prediction.

                - :obj:`"phenomenon"`: Explains the phenomenon that the model
                  is trying to predict.

            In practice, this means that the explanation algorithm will either
            compute their losses with respect to the model output
            (:obj:`"model"`) or the target output (:obj:`"phenomenon"`).
        model_config (ModelConfig): The model configuration.
            See :class:`~torch_geometric.explain.config.ModelConfig` for
            available options. (default: :obj:`None`)
        node_mask_type (MaskType or str, optional): The type of mask to apply
            on nodes. The possible values are (default: :obj:`None`):

                - :obj:`None`: Will not apply any mask on nodes.

                - :obj:`"object"`: Will mask each node.

                - :obj:`"common_attributes"`: Will mask each feature.

                - :obj:`"attributes"`: Will mask each feature across all nodes.

        edge_mask_type (MaskType or str, optional): The type of mask to apply
            on edges. Has the sample possible values as :obj:`node_mask_type`.
            (default: :obj:`None`)
        threshold_config (ThresholdConfig, optional): The threshold
            configuration.
            See :class:`~torch_geometric.explain.config.ThresholdConfig` for
            available options. (default: :obj:`None`)
    """
    def __init__(
        self,
        model: torch.nn.Module,
        algorithm: ExplainerAlgorithm,
        explanation_type: Union[ExplanationType, str],
        model_config: Union[ModelConfig, Dict[str, Any]],
        node_mask_type: Optional[Union[MaskType, str]] = None,
        edge_mask_type: Optional[Union[MaskType, str]] = None,
        threshold_config: Optional[ThresholdConfig] = None,
    ):
        explainer_config = ExplainerConfig(
            explanation_type=explanation_type,
            node_mask_type=node_mask_type,
            edge_mask_type=edge_mask_type,
        )

I cannot find some parameters such as "explanation_type".
Therefore I cannot run the example https://github.com/pyg-team/pytorch_geometric/blob/master/examples/gnn_explainer.py
This is my installed version:

class Explainer:
    r"""An explainer class for instance-level explanations of Graph Neural
    Networks.

    Args:
        model (torch.nn.Module): The model to explain.
        algorithm (ExplainerAlgorithm): The explanation algorithm.
        explainer_config (ExplainerConfig): The explainer configuration.
        model_config (ModelConfig): The model configuration.
        threshold_config (ThresholdConfig, optional): The threshold
            configuration. (default: :obj:`None`)
    """
    def __init__(
        self,
        model: torch.nn.Module,
        algorithm: ExplainerAlgorithm,
        explainer_config: ExplainerConfig,
        model_config: ModelConfig,
        threshold_config: Optional[ThresholdConfig] = None,
    ):
        self.model = model
        self.algorithm = algorithm

        self.explainer_config = ExplainerConfig.cast(explainer_config)
        self.model_config = ModelConfig.cast(model_config)
        self.threshold_config = ThresholdConfig.cast(threshold_config)

        self.algorithm.connect(self.explainer_config, self.model_config)

    @torch.no_grad()
    def get_prediction(self, *args, **kwargs) -> torch.Tensor:
        r"""Returns the prediction of the model on the input graph.

        If the model mode is :obj:`"regression"`, the prediction is returned as
        a scalar value.
        If the model mode :obj:`"classification"`, the prediction is returned
        as the predicted class label.

        Args:
            *args: Arguments passed to the model.
            **kwargs (optional): Additional keyword arguments passed to the
                model.
        """
        training = self.model.training
        self.model.eval()

        with torch.no_grad():
            out = self.model(*args, **kwargs)
        if self.model_config.mode == ModelMode.classification:
            out = out.argmax(dim=-1)

        self.model.train(training)

        return out

And the details of my environment related to pyG is shown below:

torch                              1.8.1+cu111
torch-cluster                      1.5.9
torch-geometric                    2.2.0
torch-scatter                      2.0.6
torch-sparse                       0.6.9
torch-spline-conv                  1.2.1

I am wondering how can I run the example https://github.com/pyg-team/pytorch_geometric/blob/master/examples/gnn_explainer.py and finally use GNNExplainer in my own project?

[rusty1s]

Yes, torch_geometric.explain is in active development and we are currently doing some modifications to the interface. You can either checkout the example for PyG 2.2 or install PyG from master to fix.

Furthermore, node_feat_mask should contain non-zero values for every node that is reachable within message passing to the node you want to make predictions for. Something like

out = node_feat_mask[:i].sum() + node_feat_mask[i + 1:].sum()

should definitely print something out different from 0.

[shaanxicode]

Thanks for your advice. My network is a GAT based network and used for node regression task. I have checked my code, it is shown below:

explainer = GNNExplainer(model, epochs=200)
feature_mask = torch.zeros(101,len(labels))
for i in range(len(labels)):
    node_feat_mask, edge_mask = explainer.explain_node(i, features, edgeindex)
    feature_mask[:,i] = node_feat_mask

where i is the index of different nodes in the graph, and features and edgeindex above are the whole graph's. I used the feature_mask to save all the node_feat_mask for different nodes in the graph.
I used your recommend code as:

explainer = GNNExplainer(model, epochs=200)
feature_mask = torch.zeros(101,len(labels))
for i in range(len(labels)):
    node_feat_mask, edge_mask = explainer.explain_node(i, features, edgeindex)
    out = node_feat_mask[:i].sum() + node_feat_mask[i + 1:].sum()

And I found only when i=0, the output has the non-zero values. The GNNExplainer I used is shown below:

class GNNExplainer_:
    r"""Deprecated version for :class:`GNNExplainer`."""

    coeffs = GNNExplainer.coeffs

    conversion_node_mask_type = {
        'feature': 'common_attributes',
        'individual_feature': 'attributes',
        'scalar': 'object',
    }

    conversion_return_type = {
        'log_prob': 'log_probs',
        'prob': 'probs',
        'raw': 'raw',
        'regression': 'raw',
    }

    def __init__(
        self,
        model: torch.nn.Module,
        epochs: int = 100,
        lr: float = 0.01,
        return_type: str = 'log_prob',
        feat_mask_type: str = 'feature',
        allow_edge_mask: bool = True,
        **kwargs,
    ):
        assert feat_mask_type in ['feature', 'individual_feature', 'scalar']

        explainer_config = ExplainerConfig(
            explanation_type='model',
            node_mask_type=self.conversion_node_mask_type[feat_mask_type],
            edge_mask_type=MaskType.object if allow_edge_mask else None,
        )
        model_config = ModelConfig(
            mode='regression'
            if return_type == 'regression' else 'classification',
            task_level=ModelTaskLevel.node,
            return_type=self.conversion_return_type[return_type],
        )

        self.model = model
        self._explainer = GNNExplainer(epochs=epochs, lr=lr, **kwargs)
        self._explainer.connect(explainer_config, model_config)

    @torch.no_grad()
    def get_initial_prediction(self, *args, **kwargs) -> Tensor:

        training = self.model.training
        self.model.eval()

        out = self.model(*args, **kwargs)
        if self._explainer.model_config.mode == ModelMode.classification:
            out = out.argmax(dim=-1)

        self.model.train(training)

        return out

    def explain_graph(
        self,
        x: Tensor,
        edge_index: Tensor,
        **kwargs,
    ) -> Tuple[Tensor, Tensor]:
        self._explainer.model_config.task_level = ModelTaskLevel.graph

        explanation = self._explainer(
            self.model,
            x,
            edge_index,
            target=self.get_initial_prediction(x, edge_index, **kwargs),
            **kwargs,
        )
        return self._convert_output(explanation, edge_index)

    def explain_node(
        self,
        node_idx: int,
        x: Tensor,
        edge_index: Tensor,
        **kwargs,
    ) -> Tuple[Tensor, Tensor]:
        self._explainer.model_config.task_level = ModelTaskLevel.node
        explanation = self._explainer(
            self.model,
            x,
            edge_index,
            target=self.get_initial_prediction(x, edge_index, **kwargs),
            index=node_idx,
            **kwargs,
        )
        return self._convert_output(explanation, edge_index, index=node_idx,
                                    x=x)

    def _convert_output(self, explanation, edge_index, index=None, x=None):
        if 'node_mask' in explanation.available_explanations:
            node_mask = explanation.node_mask
        else:
            if (self._explainer.explainer_config.node_mask_type ==
                    MaskType.common_attributes):
                node_mask = explanation.node_feat_mask[0]
            else:
                node_mask = explanation.node_feat_mask

        edge_mask = None
        if 'edge_mask' in explanation.available_explanations:
            edge_mask = explanation.edge_mask
        else:
            if index is not None:
                _, edge_mask = self._explainer._get_hard_masks(
                    self.model, index, edge_index, num_nodes=x.size(0))
                edge_mask = edge_mask.to(x.dtype)
            else:
                edge_mask = torch.ones(edge_index.shape[1],
                                       device=edge_index.device)

        return node_mask, edge_mask

[rusty1s]

Thank you. I did something similar in the examples/gnn_explainer.py example:

node_index = 10
explanation = explainer(data.x, data.edge_index, index=node_index)
node_feat_mask = explanation.node_feat_mask
print(node_feat_mask.sum(dim=0))
print(node_feat_mask[:10].sum(dim=0))
print(node_feat_mask[10:11].sum(dim=0))
print(node_feat_mask[11:].sum(dim=0))

and cannot really confirm this. Other nodes have node attributions as well. Maybe i=0 is an isolated node in your case?