GATModule Class Reference

Inheritance diagram for GATModule:

Public Member Functions
	__init__ (self, in_feats, units, num_heads, in_feats_glob, use_gap=False)
	forward (self, graph, feat, feat_glob=None)

Public Attributes
	gat = dglnn.GATConv(in_feats, units, num_heads)
	GAT layer to update node features.
	fc = torch.nn.Linear(in_feats_glob + out_feats, units)
	Fully connected layer for feature aggregation to update global features.
	use_gap = use_gap
	Whether to use Global Attention Pooling (GAP) for the production of global features.
	gap_gate = torch.nn.Linear(out_feats, 1)
	Linear gate to produce global features.
	gap = GlobalAttentionPooling(self.gap_gate)
	Global Attention Pooling layer to produce global features.

Detailed Description

Apply a GAT layer to node features, flatten outputs of attention heads
and update global features.

Definition at line 19 of file gatgap.py.

Constructor & Destructor Documentation

__init__()

__init__	(		self,
			in_feats,
			units,
			num_heads,
			in_feats_glob,
			use_gap = False )

Initialise the class.

:param in_feats: Number of features for each node.
:param units: Number of output units for the GAT layer.
:param num_heads: Number of attention heads in the GAT layer.
:param in_feats_glob: Current dimension of global features. Initialized as 0.
:param use_gap: Whether to use Global Attention Pooling (GAP) for the production of global features.

Definition at line 25 of file gatgap.py.

    ):
        """
        Initialise the class.
 
        :param in_feats: Number of features for each node.
        :param units: Number of output units for the GAT layer.
        :param num_heads: Number of attention heads in the GAT layer.
        :param in_feats_glob: Current dimension of global features. Initialized as 0.
        :param use_gap: Whether to use Global Attention Pooling (GAP) for the production of global features.
        """
        super().__init__()
        
        self.gat = dglnn.GATConv(in_feats, units, num_heads)
        out_feats = units * num_heads
        
        self.fc = torch.nn.Linear(in_feats_glob + out_feats, units)
        
        self.use_gap = use_gap
        if self.use_gap:
            
            self.gap_gate = torch.nn.Linear(out_feats, 1)
            
            self.gap = GlobalAttentionPooling(self.gap_gate)
 

Member Function Documentation

forward()

forward	(		self,
			graph,
			feat,
			feat_glob = None )

Forward pass of the GAT module.

Arguments:
    graph (torch.Tensor): DGLGraph representing the decay tree.
    feat (torch.Tensor): Node feataures attached to the graph.
    feat_glob (torch.Tensor): Global features from previous layers.
    `None` for initialized as the global average or attention pooling of the whole graph.

Returns:
    torch.Tensor: updated node features.
    torch.Tensor: updated global features.

Definition at line 56 of file gatgap.py.

    def forward(self, graph, feat, feat_glob=None):
        """
        Forward pass of the GAT module.
 
        Arguments:
            graph (torch.Tensor): DGLGraph representing the decay tree.
            feat (torch.Tensor): Node feataures attached to the graph.
            feat_glob (torch.Tensor): Global features from previous layers.
            `None` for initialized as the global average or attention pooling of the whole graph.
 
        Returns:
            torch.Tensor: updated node features.
            torch.Tensor: updated global features.
        """
        h = F.leaky_relu(self.gat(graph, feat)).flatten(1)
        hg = feat_glob
        if not self.use_gap:
            with graph.local_scope():
                graph.ndata['h'] = h
                hmean = dgl.mean_nodes(graph, 'h')
        else:
            hmean = self.gap(graph, h)
        if hg is None:
            hg = hmean
        else:
            # Concatenate previous global features with new aggregation
            hg = torch.cat((hg, hmean), axis=1)
        # Update global features
        hg = F.leaky_relu(self.fc(hg))
        return h, hg
 
 

Member Data Documentation

fc

fc = torch.nn.Linear(in_feats_glob + out_feats, units)

Fully connected layer for feature aggregation to update global features.

Definition at line 47 of file gatgap.py.

gap

gap = GlobalAttentionPooling(self.gap_gate)

Global Attention Pooling layer to produce global features.

Definition at line 54 of file gatgap.py.

gap_gate

gap_gate = torch.nn.Linear(out_feats, 1)

Linear gate to produce global features.

Definition at line 52 of file gatgap.py.

gat

gat = dglnn.GATConv(in_feats, units, num_heads)

GAT layer to update node features.

Definition at line 44 of file gatgap.py.

use_gap

use_gap = use_gap

Whether to use Global Attention Pooling (GAP) for the production of global features.

Definition at line 49 of file gatgap.py.

---

The documentation for this class was generated from the following file:

• generators/scripts/smartBKG/models/gatgap.py