GatedGCNConv

class dgl.nn.pytorch.conv.GatedGCNConv(input_feats, edge_feats, output_feats, dropout=0, batch_norm=True, residual=True, activation=<function relu>)

Bases: Module

Gated graph convolutional layer from Benchmarking Graph Neural Networks

$$\begin{array}{r}\begin{array}{c}{e}_{ij}^{l+1}=D^l{h}_i^l+E^l{h}_j^l+C^l{e}_{ij}^l\\ nor{m}_{ij}={\mathrm{\Sigma }}_{j\in N_i}\sigma \left(e_{ij}^{l+1}\right)+\epsilon \\ {\hat{e}}_{ij}^{l+1}=\sigma (e_{ij}^{l+1})/nor{m}_{ij}\\ h_i^{l+1}=A^l{h}_i^l+{\mathrm{\Sigma }}_{j\in N_i}{\hat{e}}_{ij}^{l+1}\odot B^l{h}_j^l\end{array}\end{array}$$

where $h_i^l$ is node $i$ feature of layer $l$, $e_{ij}^l$ is edge $ij$ feature of layer $l$, $\sigma$ is sigmoid function, $\epsilon$ is a small fixed constant for numerical stability, $A^l,B^l,C^l,D^l,E^l$ are linear layers.

Parameters:

• input_feats (int) – Input feature size; i.e, the number of dimensions of $h_i^l$.

• edge_feats (int) – Edge feature size; i.e., the number of dimensions of $e_{ij}^l$.

• output_feats (int) – Output feature size; i.e., the number of dimensions of $h_i^{l+1}$.

• dropout (float, optional) – Dropout rate on node and edge feature. Default: 0.

• batch_norm (bool, optional) – Whether to include batch normalization on node and edge feature. Default: True.

• residual (bool, optional) – Whether to include residual connections. Default: True.

• activation (callable activation function/layer or None, optional) – If not None, apply an activation function to the updated node features. Default: F.relu.

Example

>>> import dgl
>>> import torch as th
>>> import torch.nn.functional as F
>>> from dgl.nn import GatedGCNConv

>>> num_nodes, num_edges = 8, 30
>>> graph = dgl.rand_graph(num_nodes,num_edges)
>>> node_feats = th.rand(num_nodes, 20)
>>> edge_feats = th.rand(num_edges, 12)
>>> gatedGCN = GatedGCNConv(20, 12, 20)
>>> new_node_feats, new_edge_feats = gatedGCN(graph, node_feats, edge_feats)
>>> new_node_feats.shape, new_edge_feats.shape
(torch.Size([8, 20]), torch.Size([30, 20]))

forward(graph, feat, edge_feat)

Description

Compute gated graph convolution layer.

param graph:

The graph.

type graph:

DGLGraph

param feat:

The input feature of shape $(N,D_{in})$ where $N$ is the number of nodes of the graph and $D_{in}$ is the input feature size.

type feat:

torch.Tensor

param edge_feat:

The input edge feature of shape $(E,D_{edge})$, where $E$ is the number of edges and $D_{edge}$ is the size of the edge features.

type edge_feat:

torch.Tensor

returns:

• torch.Tensor – The output node feature of shape $(N,D_{out})$ where $D_{out}$ is the output feature size.

• torch.Tensor – The output edge feature of shape $(E,D_{out})$ where $D_{out}$ is the output feature size.