Multi-view Graph Representation Learning

Table of Contents

👨‍🏫 Method

Figure 1: The MVGRL Framework

Given a graph $\large \mathcal{G}$ we generate multiple correlated augmented views of the same graph. A differentiating factor from GraphCL is that in MVGRL we apply augmentations only to the structure of the graphs and not the initial node features.
These views are then passed through separate graph encoders $\large g(\cdot)$. Another differentiating factor from GraphCL is that in MVGRL the graph encoders are not shared.
After getting encoded the representations are passed through a readout function $\large \sum$ (a variant of a graph pooling layer) and then passed through a shared projection head $\large f (\cdot)$. This is in contrast to GraphCL in which the graph encoder is shared.
A contrastive objective is applied via a discriminator which contrasts node representations from one view with graph representations from another view.

👨‍💻 Code

class MVGRL(nn.Module):
    def __init__(self, n_in, n_h, num_layers):
        super(MVGRL, self).__init__()
        self.mlp1 = MLP(1 * n_h, n_h)
        self.mlp2 = MLP(num_layers * n_h, n_h)
        self.gnn1 = GCN(n_in, n_h, num_layers)
        self.gnn2 = GCN(n_in, n_h, num_layers)

    def forward(self, adj, diff, feat, mask):
        lv1, gv1 = self.gnn1(feat, adj, mask)
        lv2, gv2 = self.gnn2(feat, diff, mask)

        lv1 = self.mlp1(lv1)
        lv2 = self.mlp1(lv2)

        gv1 = self.mlp2(gv1)
        gv2 = self.mlp2(gv2)

        return lv1, gv1, lv2, gv2

    def embed(self, feat, adj, diff, mask):
        __, gv1, __, gv2 = self.forward(adj, diff, feat, mask)
        return (gv1 + gv2).detach()

📊 Results

🔗 Summary