Graph Neural Networks 有关图的模型纵览

有关图的模型纵览

        从数据只能的存储模型（信息的抽取与存储）向图，动态模型的转变。可能模型中有隐形的结构，但感觉隐性的结构没有显性的快与易于引导与控制。

$$\{\begin{array}{l}PropagationModule.传播模块用于在节点之间传播信息，以便聚合的信息能够捕获特征信息和拓扑信息。\\ SamplingModule.采样模块通常需要在图上进行传播。采样模块通常与传播模块相结合。\\ PoolingModule.当我们需要高级子图或图的表示时，需要池化模块来从节点提取信息。\end{array}$$
$$PropagationModule\{\begin{array}{l}convolutionoperator\\ recurrentoperator\end{array}卷积算子和递归算子通常用于聚合来自邻居的信息，而跳过连接操作用于从节点的历史表示中收集信息，并缓解过度平滑(over-smoothing)问题。$$

GNN网络将图映射到输出通过以下两个步骤。

1. 首先，通过传播(propagation step)的出每个节点的表示。
2. 然后使用输出模型 $o_v=g(h_v,l_v)$ 把每个节点的表示和标签映射为一个输出。
   $为了使用一般方法处理图整体的分类,也有模型建议构造一个通过特殊边与所有节点相连接的"supernode"$
   以下为一般GNN 模型的架构。
   
   

模型纵览的论文，结尾有实现代码链接
图卷积神经网络
RESIDUAL GATED GRAPH CONVNETS

GRAPH CONVOLUTIONAL NETWORKS
图神经网络
Transformers是一种图神经网络

可以通过dgl库实现，以下为github中得到的代码：

 -*- coding: utf-8 -*-

"""
==================================================
   File Name：     gcn.py
   email:         songdongdong@weidian.com
   Author :       songdongdong
   date：          2021/3/8 15:44
   Description :
   gcn图卷积网络，全称：graph convolutional networks 图卷积网络，提出于2017年，GCN的出现标志这图神经网络的出现，要说深度学习最常用的网络结构就是
        CNN，RNN。GCN与CNN不仅名字相似，其实理解起来也很类似，都是特征提取器。不同的是，CNN提取的张量数据特征，而GCN提出的是图数据特征

==================================================
"""

import torch
import torch.nn as nn
import torch.nn.functional as F

from dgl.nn.pytorch import GraphConv  # 这是一个图 DGL库
from dgl.data import CoraGraphDataset


class GCN(nn.Module):
    def __init__(self, g, in_feats,
                 n_hidden,
                 n_classes,
                 n_layers,
                 activation,
                 dropout):
        super(GCN, self).__init__()
        self.g = g
        self.layers = nn.ModuleList()
        # 输入层
        self.layers.append(GraphConv(in_feats, n_hidden, activation=activation))
        #
        for i in range(n_layers - 1):
            self.layers.append(GraphConv(n_hidden, n_hidden, activation=activation))
        # 输出层：
        self.layers.append(GraphConv(n_hidden, n_classes))
        self.dropout = nn.Dropout(p=dropout)

    def forward(self, features):
        h = features
        for i, layer in enumerate(self.layers):
            if i!=0:
                h = self.dropout(h)
            h = layer(self.g,h)
        return h
# @torch.no_grad()
def evalutate(model,features,labels,mask):
    model.eval()
    with torch.no_grad():
        logits = model(features)
        # print(logits)
        logits = logits[mask]
        labels = labels[mask]
        _,indices  = torch.max(logits,dim=1)
        correct = torch.sum(indices == labels)
        return correct.item() * 1.0 / len(labels)

def train( n_epochs=100,lr=1e-2,
           weight_decay=5e-4,n_hidden=16,
           n_layers=1,activation=F.relu,
           dropout=0.5):
    data = CoraGraphDataset()
    print(data)
    g = data[0]
    features = g.ndata['feat']
    labels = g.ndata['label']
    train_mask = g.ndata['train_mask'] #是true，fasle。其实就是样本提取
    val_mask = g.ndata['val_mask']
    test_mask = g.ndata['test_mask']
    in_feats = features.shape[1]
    n_classes = data.num_classes

    model  = GCN(g,in_feats,n_hidden,n_classes,n_layers,activation,dropout)

    loss_fcn = torch.nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(),lr=lr,weight_decay=weight_decay)

    for epoch in range(n_epochs):
        model.train()
        logits =model(features)
        loss = loss_fcn(logits[train_mask],labels[train_mask])
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        acc =evalutate(model,features,labels,val_mask)
        print("Epoch {} | Locc {:.4f} | accuracy {:.4f}".format(epoch,loss.item(),acc))
    print()
    acc =evalutate(model,features,labels,test_mask)
    print("Test accuracy {:.2%}".format(acc))

if __name__ == "__main__":
    train()

https://github.com/rexrex9/recbyhand

gnn
Graph_learning

www.bilibili.com

DGL官方教程–API–dgl.nn