Source code for torch_geometric.nn.pool.sag_pool

from typing import Callable, Optional, Union

import torch

from torch_geometric.nn import GraphConv
from torch_geometric.nn.pool.topk_pool import filter_adj, topk
from torch_geometric.utils import softmax

[docs]class SAGPooling(torch.nn.Module): r"""The self-attention pooling operator from the `"Self-Attention Graph Pooling" <>`_ and `"Understanding Attention and Generalization in Graph Neural Networks" <>`_ papers if :obj:`min_score` :math:`\tilde{\alpha}` is :obj:`None`: .. math:: \mathbf{y} &= \textrm{GNN}(\mathbf{X}, \mathbf{A}) \mathbf{i} &= \mathrm{top}_k(\mathbf{y}) \mathbf{X}^{\prime} &= (\mathbf{X} \odot \mathrm{tanh}(\mathbf{y}))_{\mathbf{i}} \mathbf{A}^{\prime} &= \mathbf{A}_{\mathbf{i},\mathbf{i}} if :obj:`min_score` :math:`\tilde{\alpha}` is a value in [0, 1]: .. math:: \mathbf{y} &= \mathrm{softmax}(\textrm{GNN}(\mathbf{X},\mathbf{A})) \mathbf{i} &= \mathbf{y}_i > \tilde{\alpha} \mathbf{X}^{\prime} &= (\mathbf{X} \odot \mathbf{y})_{\mathbf{i}} \mathbf{A}^{\prime} &= \mathbf{A}_{\mathbf{i},\mathbf{i}}, where nodes are dropped based on a learnable projection score :math:`\mathbf{p}`. Projections scores are learned based on a graph neural network layer. Args: in_channels (int): Size of each input sample. ratio (float or int): Graph pooling ratio, which is used to compute :math:`k = \lceil \mathrm{ratio} \cdot N \rceil`, or the value of :math:`k` itself, depending on whether the type of :obj:`ratio` is :obj:`float` or :obj:`int`. This value is ignored if :obj:`min_score` is not :obj:`None`. (default: :obj:`0.5`) GNN (torch.nn.Module, optional): A graph neural network layer for calculating projection scores (one of :class:`torch_geometric.nn.conv.GraphConv`, :class:`torch_geometric.nn.conv.GCNConv`, :class:`torch_geometric.nn.conv.GATConv` or :class:`torch_geometric.nn.conv.SAGEConv`). (default: :class:`torch_geometric.nn.conv.GraphConv`) min_score (float, optional): Minimal node score :math:`\tilde{\alpha}` which is used to compute indices of pooled nodes :math:`\mathbf{i} = \mathbf{y}_i > \tilde{\alpha}`. When this value is not :obj:`None`, the :obj:`ratio` argument is ignored. (default: :obj:`None`) multiplier (float, optional): Coefficient by which features gets multiplied after pooling. This can be useful for large graphs and when :obj:`min_score` is used. (default: :obj:`1`) nonlinearity (torch.nn.functional, optional): The nonlinearity to use. (default: :obj:`torch.tanh`) **kwargs (optional): Additional parameters for initializing the graph neural network layer. """ def __init__(self, in_channels: int, ratio: Union[float, int] = 0.5, GNN: Callable = GraphConv, min_score: Optional[float] = None, multiplier: float = 1.0, nonlinearity: Callable = torch.tanh, **kwargs): super().__init__() self.in_channels = in_channels self.ratio = ratio self.gnn = GNN(in_channels, 1, **kwargs) self.min_score = min_score self.multiplier = multiplier self.nonlinearity = nonlinearity self.reset_parameters()
[docs] def reset_parameters(self): self.gnn.reset_parameters()
[docs] def forward(self, x, edge_index, edge_attr=None, batch=None, attn=None): """""" if batch is None: batch = edge_index.new_zeros(x.size(0)) attn = x if attn is None else attn attn = attn.unsqueeze(-1) if attn.dim() == 1 else attn score = self.gnn(attn, edge_index).view(-1) if self.min_score is None: score = self.nonlinearity(score) else: score = softmax(score, batch) perm = topk(score, self.ratio, batch, self.min_score) x = x[perm] * score[perm].view(-1, 1) x = self.multiplier * x if self.multiplier != 1 else x batch = batch[perm] edge_index, edge_attr = filter_adj(edge_index, edge_attr, perm, num_nodes=score.size(0)) return x, edge_index, edge_attr, batch, perm, score[perm]
def __repr__(self) -> str: if self.min_score is None: ratio = f'ratio={self.ratio}' else: ratio = f'min_score={self.min_score}' return (f'{self.__class__.__name__}({self.gnn.__class__.__name__}, ' f'{self.in_channels}, {ratio}, multiplier={self.multiplier})')