GCN学习笔记_01

GNN学习笔记

1 基本定义与概念

1.1 点、边、图

点：特征(人、实物…)

边：联系/关系(特征)

图：全局特征

图神经网络的目标：整合特征、重构点边和图。首先就需要进行embedding

输出结果：点分类回归、边分类回归、图的分类回归

1.2 表示图的方法

n*n的关系：邻接矩阵

表示谁与谁的关系，怎么相连的，即邻居之间的关系

邻接矩阵的保存其实不是N*N的，而是Source->Target：【（0，1），（2，0）】

建模的过程：

GNN（A，X）-- A：邻接矩阵，X：点的特征

图的邻接矩阵同样适合于文本，表示词与词之间的关系

GNN可以适用于什么领域？可能是创新点

• 图像和文本中
• 文本固定的长度和词向量其实不需要特殊的邻接矩阵

消息传递过程：

每个点如何更新：不仅考虑自身还得考虑邻居的信息

消息传递的方式：

• 求和
• 求平均
• 求最大/最小贡献

多层GNN：

GNN的本质是更新各个部分的特征，其中输入是特征，输出也是特征，邻接矩阵也不会变。多个层就是对全局关系的整合。

可以用来干什么：

• 多个点特征的整合：图分类
• 节点分类
• 边的分类
• …

1.3 GCN

半监督学习：在图中，有部分点没有标签，比如交通流量有的地方没有标签，同样可以进行预测。用少量标签也可以进行训练，但是计算损失的时候只用有标签的。

基本思想：

图卷积跟卷积类似，也是可以做多层的，每一层的输入的还是节点特征，然后将当前特征与网络结构图继续传入下层就可以不断计算。

图的组成：

• G：图
• A：邻接矩阵
• D：节点的度，每个点和多少个点有关系，这就是度，比如E和四个点有关，所以是4
• F：每个节点的特征

邻接矩阵的变换：
$$\hat{A}=A+\lambda I_N$$

度矩阵的变换：实际是一种平均的概念
$${\hat{D}}^{-1}$$

整体的计算流程：

$${\hat{D}}^{-1}(\hat{A}X)=({\hat{D}}^{-1}\hat{A})X$$

其中的${\hat{D}}^{-1}$实际就是相当于scale的方法，相当于对行的归一化操作

需要对列也进行归一化：
$$({\hat{D}}^{-1}\hat{A}{\hat{D}}^{-1})X$$

但这进行了两边归一化，所以这里只需要进行1/2次幂：
$$({\hat{D}}^{-1/2}\hat{A}{\hat{D}}^{-1/2})X$$

双层GCN示例：

2 pytorch基础代码实战

model.py

import torch_geometric.nn as nn
import torch

class GCN(torch.nn.Module):
    def __init__(self,n_features,n_classes):
        super(GCN, self).__init__()
        self.GCN1 = nn.GCNConv(n_features,4)
        self.GCN2 = nn.GCNConv(4, 4)
        self.GCN3 = nn.GCNConv(4,2)
        self.projection = nn.Linear(2,n_classes)

    def forward(self,x,edge_index):
        h = self.GCN1(x,edge_index)
        h = h.tanh()
        h = self.GCN2(h,edge_index)
        h = h.tanh()
        h = self.GCN3(h, edge_index)
        h = h.tanh()
        out = self.projection(h)
        return out,h

if __name__ == '__main__':
    model = GCN(34,4)
    print(model)

visualization.py

from torch_geometric.datasets.karate import KarateClub
import networkx as nx
import matplotlib.pyplot as plt
from torch_geometric.utils.convert import to_networkx
# 导入benchmark数据集

def get_data():
    datasets = KarateClub()
    # print(data.data) # Data(x=[34, 34], edge_index=[2, 156], y=[34], train_mask=[34])
    data = datasets[0]
    print('输入样本(x,f):',data.x.shape)
    print('标签:',data.y.shape)
    print('邻接矩阵:',data.edge_index.shape)
    print('半监督标签的mask:',data.train_mask.shape)
    G = to_networkx(data)
    visualize_graph(G,color=data.y)
    return data,datasets.num_features

# 图的可视化
def visualize_graph(G,color):
    plt.figure(figsize=(7,7))
    plt.xticks([])
    plt.yticks([])
    nx.draw_networkx(G,pos=nx.spring_layout(G,seed=34),arrows=False,with_labels=True,node_color=color)
    plt.show()

# 中间层的可视化
def visualize_embedding(H,color,epochs=None,loss=None):
    plt.figure(figsize=(7,7))
    plt.xticks([])
    plt.yticks([])
    plt.scatter(H[:,0],H[:,1],s=15,c=color)
    if (epochs is not None) and (loss is not None):
        plt.title(f'epoch:{epochs} loss:{loss}')
    plt.show()

if __name__ == '__main__':
    get_data()

train.py

import torch
from model import GCN
from visualization import visualize_embedding,get_data

device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
def train(epochs:int,model,optim,criterion,data):
    x = data.x
    def epoch_train(train_x):
        optim.zero_grad()
        out,h = model(train_x,data.edge_index)
        loss = criterion(out[data.train_mask],data.y[data.train_mask])
        loss.backward()
        optim.step()
        return out,h,loss

    for epoch in range(epochs):
        out,h,loss = epoch_train(x)
        print(f'epoch:{epoch+1} loss:{loss.sum()}')
        if (epoch+1) % 100 == 0:
            h = h.detach().cpu()
            visualize_embedding(h,data.y)

def main():
    data,num_features = get_data()
    GCN_model = GCN(num_features,4)
    optim = torch.optim.Adam(GCN_model.parameters(),lr=0.1)
    criterion = torch.nn.CrossEntropyLoss()
    epochs = 400
    train(epochs,GCN_model,optim,criterion,data)

main()