本文为学习产物 
    
    
   ，学习链接（如有侵权
     


     


     

，请告知删除）：

人工智能【图神经网络实战】教程 




 




 




，让你一天就学会深入浅出图神经网络GNN 

   

   

  ，从入门到精通！

一    
    
    
、图神经网络应用领域

1.1 芯片设计

芯片的设计比较耗费人力和物力
     

     

     
，如果可以通过AI算法自动设计芯片  




  




  




，则可以大大提高芯片制造的效率 


  


  


 ，降低芯片制造的成本

1.2 场景分析与问题推理

例如剧本杀中的推理
     
     
     ，警匪片中嫌疑人的图推理等

1.3 推荐系统

例如   




   




   




，刷抖音 



 



 



，经常看英雄联盟的游戏视频               ，那么说明你对游戏比较感兴趣
    




    




    



，系统会根据网络图结构推荐更多和英雄联盟相关的内容给你

1.4 欺诈检测与风控相关

贷款软件














，读取用户的通讯录信息和app使用情况               ，从而测评用户的还款能力
     



     



     


，然后决定用户的借款额度

1.5 知识图谱

智能客服

1.6 道路交通的流量预测

预测道路上每条边的流量

1.7 自动驾驶（无人机等场景）

1.8 化学














，医疗等场景

利用AI对化学结构进行分析 
    
    
   ，预测

1.9 物理模型相关

根据分子结构进行相关分析

二  


     


     


   、图神经网络基本知识

2.1 图基本模块定义

V

：点
     


     


     

，每个点都有自己的特征向量（特征举例：邻居点数量


 




 




 

、一阶二阶相似度）

E

：边 




 




 




，每个边都有自己的特征向量（特征举例：边的权重值   

   

   

、边的定义）

U

：整个图 

   

   

  ，每个图都有自己的特征向量（特征举例：节点数量   

     

     

  、图直径）

2.2 图神经网络要做的事情

为每个节点整合特征向量
     

     

     
，根据其对节点做分类或者回归 为每条边整合特征向量  




  




  




，根据其对边做分类或者回归 为每张图整合特征向量 


  


  


 ，根据其对图做分类或者回归

2.3 邻接矩阵的定义

2.3.1 图数据的邻接矩阵

2.3.2 文本数据的邻接矩阵

2.4 GNN中的常见任务

传统神经网络（CNN



  




  




  
、RNN  


  


  


、DNN）要求输入格式是固定的（如24×24    
     
     
 、128×128等）    
    
    
。

但在实际场景中（例如道路交通）
     
     
     ，不同城市的道路数量和节点数量都不同   




   




   




，即输入数据格式不固定  


     


     


   。对此 



 



 



，传统神经网络不能很好地解决               ，但是GNN可以用来解决此类问题




 




 




 

。

对于输入数据格式不固定的情况
    




    




    



，GNN的常见任务有以下几种：

2.4.1 Graph级别任务

基于整个图














，做分类和回归   

   

   

。

例如               ，给定一个分子结构图
     



     



     


，判断它里面存在几个环 或者 判断该分子结构属于哪一类

2.4.2 Node与Edge级别任务

预测这个点是教练还是学员














，即预测点

预测两个点之间的关系（是打架关系还是观看关系） 
    
    
   ，即预测边

2.5 消息传递计算方法

2.5.1 优化邻接矩阵

之前学过
     


     


     

，邻接矩阵的大小为N*N 




 




 




，当节点很多的时候 

   

   

  ，邻接矩阵的大小也会特别大

为了解决这个问题
     

     

     
，我们一般采取只保存source数组和target数组的方式

source数组即起点（起源点）数组  




  




  




，target数组即终点（目标点）数组

这两个数组的维度是一样的

对应位置的source和target值就可以代表一条可连接的有向边 


  


  


 ，对于没有连接关系的边则不需要保存其信息
     
     
     ，这样就可以大大减少数据规模

2.5.2 点的特征重构

汇总 = 自身的信息 + 所有邻居点的信息

所有邻居点信息的表达有几种：

求解Sum 求平均Mean 求最大Max 求最小Min

2.6 多层GNN的作用

层数越多   




   




   




，GNN的“感受野 
    
    
   ”越大 



 



 



，每个点考虑其他点的信息越多               ，考虑越全面

GNN输出特征的用处

三




   




   




   、GCN详解

3.1 GCN基本模型概述

3.1.1 卷积 vs 图卷积

卷积：卷积核平移计算

图卷积：自身信息+所有邻居信息

3.1.2 图中常见任务

3.1.3 如果获取特征

3.1.4 半监督学习

GCN属于半监督学习（不需要每个节点都有标签都可以进行训练）

计算Loss时
    




    




    



，只需要考虑有标签的节点即可   

     

     

  。

为了减少有标签节点的Loss














，其周围的点也会做相应的调整               ，这也是图结构的特点
     



     



     


，因此GNN和GCN中














，不需要所有节点都有标签也可以进行训练（当然至少需要一个节点有标签）

3.2 图卷积的基本计算方法

3.2.1 GCN基本思想

对每个节点计算特征 然后合成每个节点的特征 将合成的特征传入全连接网络进行分类

3.2.2 GCN层数

图卷积也可以做多层 
    
    
   ，但是一般不做太深层
     


     


     

，一般只做2-3层

（类似于一种说法 




 




 




，你只需要认识6个人就可以认识全世界）

实验表明

：GCN中 

   

   

  ，深层的网络结构往往不会带来更好的效果



  




  




  
。

直观解释：我表哥认识的朋友的朋友的朋友的朋友认识市长
     

     

     
，不代表我和市长关系就很好  


  


  


。

层数越多  




  




  




，特征表达就越发散

一般2-5层即可

3.2.3 图中基本组成

3.2.4 特征计算方法

3.3 邻接矩阵的变换

单位矩阵相当于给每个节点加了一条自连接的边

但是现在存在一个问题：一个节点的度越大 


  


  


 ，其做矩阵乘法后的值就越大（累加次数变多了）
     
     
     ，这种情况是不好的（相当于一个人认识的人越多   




   




   




，其的特征值就越大 



 



 



，这样不好）

为了解决这个问题               ，我们需要对度矩阵求倒数
    




    




    



，相当于平均的感觉














，对度数大的节点加以限制

上面的左乘相当于对行做了归一化操作               ，那么列也需要做归一化操作

但是又有问题了
     



     



     


，行和列都做了归一化














，那不是会存在2次归一化的情况吗（行列重叠处）

所以我们需要在度矩阵倒数那加一个0.5次方来抵消这个2次归一化的影响

3.4 GCN变换原理解读

如下图所示 
    
    
   ，假设绿色框中的人是个富人
     


     


     

，红色框中的人是个穷人 




 




 




，他们只是小时候认识 

   

   

  ，穷人只认识富人
     

     

     
，而富人认识很多人    
     
     
 。

如果只对行做归一化  




  




  




，由于穷人只认识富人 


  


  


 ，所以其度为1
     
     
     ，则其在进行特征重构的时候很大一部分信息会来自于富人   




   




   




，这样的模型大概率会认为穷人和富人是同一种人




   




   




   。显然 



 



 



，这是不合理的

所以               ，我们需要同时对行和列都进行归一化
    




    




    



，这样不仅只考虑富人对穷人的关系














，还考虑了穷人对富人的关系 



 



 



。

简单来说               ，对行做归一化考虑到了
     



     



     


，富人对穷人来说很重要；对列作归一化














，考虑到了穷人对富人可能没那么重要（因为富人的度很大 
    
    
   ，穷人的度很小
     


     


     

，富人很可能不记得穷人了） 




 




 




，这样相对更加合理               。

3.5 GCN传播公式

softmax是作多分类常用的激活函数

四 



 



 



、PyTorch Geometric 库的基本使用

4.1 PyTorch Geometric 的安装

注意： 千万不要直接pip install 去安装这个库！！！

进入这个GitHub网址： https://github.com/pyg-team/pytorch_geometric

进入页面后往下滑 

   

   

  ，找到如下图所示的字样
     

     

     
，点击here

选择你电脑中已经安装的torch版本（一定要和你已经安装的torch版本一致）

怎么查看torch版本？

在Pycharm中  




  




  




，点击底部栏的Terminal 


  


  


 ，输入pip show torch
     
     
     ，即可查看torch版本

选择完正确的torch版本后   




   




   




，会进入下面的界面 



 



 



，一共有4个不同的.whl文件               ，每一种选一个符合你的版本下载即可

例如：torch_cluster-1.5.9-cp36-cp36m-win_amd64.whl 指的是python为3.6的windows版本

我的电脑是windows的
    




    




    



，python版本为3.8.12














，所以我下载的四个包如下图所示：

下载好之后               ，直接pip install 你的.whl文件地址

下面是我安装时候的命令（仅供参考）:

pip install C:\Users\WSKH\Desktop\torch_cluster-1.5.9-cp38-cp38-win_amd64.whl pip install ‪C:\Users\WSKH\Desktop\torch_scatter-2.0.6-cp38-cp38-win_amd64.whl pip install C:\Users\WSKH\Desktop\torch_sparse-0.6.9-cp38-cp38-win_amd64.whl pip install ‪C:\Users\WSKH\Desktop\torch_spline_conv-1.2.1-cp38-cp38-win_amd64.whl

最后
     



     



     


，一定要等上面四步完成之后














，再执行下面的操作

pip install torch-geometric

4.2 数据集与邻接矩阵格式

4.2.1 数据集介绍

Hello World 级别的数据集 
    
    
   ，34个节点

4.2.2 数据探索

from torch_geometric.datasets import KarateClub dataset = KarateClub() print(fDataset:{dataset}:) print(= * 30) print(fNumber of graphs:{len(dataset)}) print(fNumber of features:{dataset.num_features}) print(fNumber of classes:{dataset.num_classes}) print(= * 30) data = dataset[0] # train_mask = [True,False,...] ：代表第1个点是有标签的
     


     


     

，第2个点是没标签的 




 




 




，方便后面LOSS的计算 print(data) # Data(x=[节点数, 特征数], edge_index=[2, 边的条数], y=[节点数], train_mask=[节点数])

输出：

Dataset:KarateClub(): ============================== Number of graphs:1 Number of features:34 Number of classes:4 ============================== Data(x=[34, 34], edge_index=[2, 156], y=[34], train_mask=[34])

4.2.3 使用networkx进行可视化展示

import os from torch_geometric.datasets import KarateClub from torch_geometric.utils import to_networkx import networkx as nx import matplotlib.pyplot as plt # 画图函数 def visualize_graph(G, color): plt.figure(figsize=(7, 7)) plt.xticks([]) plt.yticks([]) nx.draw_networkx(G, pos=nx.spring_layout(G, seed=42), with_labels=False, node_color=color, cmap="Set2") plt.show() # 画点函数 def visualize_embedding(h, color, epoch=None, loss=None): plt.figure(figsize=(7, 7)) plt.xticks([]) plt.yticks([]) h = h.detach().cpu().numpy() plt.scatter(h[:, 0], h[:, 1], s=140, c=color, cmap="Set2") if epoch is not None and loss is not None: plt.xlabel(fEpoch:{epoch},Loss:{loss.item():.4f}, fontsize=16) plt.show() if __name__ == __main__: # 不加这个可能会报错 os.environ[KMP_DUPLICATE_LIB_OK] = True dataset = KarateClub() print(fDataset:{dataset}:) print(= * 30) print(fNumber of graphs:{len(dataset)}) print(fNumber of features:{dataset.num_features}) print(fNumber of classes:{dataset.num_classes}) print(= * 30) data = dataset[0] # train_mask = [True,False,...] ：代表第1个点是有标签的 

   

   

  ，第2个点是没标签的
     

     

     
，方便后面LOSS的计算 print(data) # Data(x=[节点数, 特征数], edge_index=[2, 边的条数], y=[节点数], train_mask=[节点数]) G = to_networkx(data, to_undirected=True) visualize_graph(G, color=data.y)

可视化结果：

4.2.4 GCN模型搭建

import torch from torch.nn import Linear from torch_geometric.nn import GCNConv class GCN(torch.nn.Module): def __init__(self, num_features, num_classes): super(GCN, self).__init__() torch.manual_seed(520) self.num_features = num_features self.num_classes = num_classes self.conv1 = GCNConv(self.num_features, 4) # 只定义子输入特证和输出特证即可 self.conv2 = GCNConv(4, 4) self.conv3 = GCNConv(4, 2) self.classifier = Linear(2, self.num_classes) def forward(self, x, edge_index): # 3层GCN h = self.convl(x, edge_index) # 给入特征与邻接矩阵（注意格式  




  




  




，上面那种） h = h.tanh() h = self.conv2(h.edge_index) h = h.tanh() h = self.conv3(h, edge_index) h = h.tanh() # 分类层 out = self.classifier(h) return out, h

4.2.5 使用搭建好的GCN模型

import os import time from torch_geometric.datasets import KarateClub import networkx as nx import matplotlib.pyplot as plt import torch from torch.nn import Linear from torch_geometric.nn import GCNConv # 画图函数 def visualize_graph(G, color): plt.figure(figsize=(7, 7)) plt.xticks([]) plt.yticks([]) nx.draw_networkx(G, pos=nx.spring_layout(G, seed=42), with_labels=False, node_color=color, cmap="Set2") plt.show() # 画点函数 def visualize_embedding(h, color, epoch=None, loss=None): plt.figure(figsize=(7, 7)) plt.xticks([]) plt.yticks([]) h = h.detach().cpu().numpy() plt.scatter(h[:, 0], h[:, 1], s=140, c=color, cmap="Set2") if epoch is not None and loss is not None: plt.xlabel(fEpoch:{epoch},Loss:{loss.item():.4f}, fontsize=16) plt.show() class GCN(torch.nn.Module): def __init__(self, num_features, num_classes): super(GCN, self).__init__() torch.manual_seed(520) self.num_features = num_features self.num_classes = num_classes self.conv1 = GCNConv(self.num_features, 4) # 只定义子输入特证和输出特证即可 self.conv2 = GCNConv(4, 4) self.conv3 = GCNConv(4, 2) self.classifier = Linear(2, self.num_classes) def forward(self, x, edge_index): # 3层GCN h = self.conv1(x, edge_index) # 给入特征与邻接矩阵（注意格式 


  


  


 ，上面那种） h = h.tanh() h = self.conv2(h, edge_index) h = h.tanh() h = self.conv3(h, edge_index) h = h.tanh() # 分类层 out = self.classifier(h) return out, h # 训练函数 def train(data): optimizer.zero_grad() out, h = model(data.x, data.edge_index) loss = criterion(out[data.train_mask], data.y[data.train_mask]) loss.backward() optimizer.step() return loss, h if __name__ == __main__: # 不加这个可能会报错 os.environ[KMP_DUPLICATE_LIB_OK] = True # 数据集准备 dataset = KarateClub() data = dataset[0] # 声明GCN模型 model = GCN(dataset.num_features, dataset.num_classes) # 损失函数 交叉熵损失 criterion = torch.nn.CrossEntropyLoss() # 优化器 Adam optimizer = torch.optim.Adam(model.parameters(), lr=0.01) # 训练 for epoch in range(401): loss, h = train(data) if epoch % 100 == 0: visualize_embedding(h, color=data.y, epoch=epoch, loss=loss) time.sleep(0.3)

输出图片：

五               、文献引用数据集分类案例实战（基于点的任务）

5.1 数据集介绍

5.2 数据探索

from torch_geometric.datasets import Planetoid from torch_geometric.transforms import NormalizeFeatures if __name__ == "__main__": # 数据准备 dataset = Planetoid(root=../data/Planetoid, name=Cora, transform=NormalizeFeatures()) # transform预处理 data = dataset[0] print(fDataset:{dataset}:) print(fNumber of graphs:{len(dataset)}) print(fNumber of features:{dataset.num_features}) print(fNumber of classes:{dataset.num_classes}) print(fNumber of nodes:{data.num_nodes}) print(fNumber of edges:{data.num_edges}) print(fAverage node degree:{data.num_edges / data.num_nodes}) print(fNumber of training nodes:{data.train_mask.sum()}) print(fTraining node label rate:{int(data.train_mask.sum()) / data.num_nodes}) print(fHas isolated nodes:{data.has_isolated_nodes()}) print(fHas self-loops:{data.has_self_loops()})

输出：

Dataset:Cora(): Number of graphs:1 Number of features:1433 Number of classes:7 Number of nodes:2708 Number of edges:10556 Average node degree:3.8980797636632203 Number of training nodes:140 Training node label rate:0.051698670605613 Has isolated nodes:False Has self-loops:False

5.3 试试传统MLP的效果

import torch from torch.nn import Linear import torch.nn.functional as F from torch_geometric.datasets import Planetoid from torch_geometric.transforms import NormalizeFeatures class MLP(torch.nn.Module): def __init__(self, hidden_channels): super(MLP, self).__init__() torch.manual_seed(520) self.lin1 = Linear(dataset.num_features, hidden_channels) self.lin2 = Linear(hidden_channels, dataset.num_classes) def forward(self, x): x = self.lin1(x) x = x.relu() x = F.dropout(x, p=0.5, training=self.training) x = self.lin2(x) return x def train(): model.train() optimizer.zero_grad() out = model(data.x) loss = criterion(out[data.train_mask], data.y[data.train_mask]) loss.backward() optimizer.step() return loss def ttt(): model.eval() out = model(data.x) pred = out.argmax(dim=1) test_correct = pred[data.test_mask] == data.y[data.test_mask] test_acc = int(test_correct.sum()) / int(data.test_mask.sum()) return test_acc if __name__ == __main__: # 数据准备 dataset = Planetoid(root=../data/Planetoid, name=Cora, transform=NormalizeFeatures()) # transform预处理 data = dataset[0] # 模型建立 model = MLP(hidden_channels=16) print(model) print("=" * 50) criterion = torch.nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4) # Define optimizer. # 迭代训练 for epoch in range(1, 201): loss = train() if epoch % 20 == 0: print(fEpoch:{epoch} , loss:{loss.item()}) # 测试 print("正确率：", ttt())

输出：

MLP( (lin1): Linear(in_features=1433, out_features=16, bias=True) (lin2): Linear(in_features=16, out_features=7, bias=True) ) ================================================== Epoch:20 , loss:1.7634577751159668 Epoch:40 , loss:1.3432351350784302 Epoch:60 , loss:0.8805856108665466 Epoch:80 , loss:0.6011439561843872 Epoch:100 , loss:0.612098753452301 Epoch:120 , loss:0.6141201853752136 Epoch:140 , loss:0.4915192723274231 Epoch:160 , loss:0.45700499415397644 Epoch:180 , loss:0.4424014687538147 Epoch:200 , loss:0.32399505376815796 正确率： 0.53

5.4 再看看GCN的效果

import torch from torch_geometric.nn import GCNConv import torch.nn.functional as F from torch_geometric.datasets import Planetoid from torch_geometric.transforms import NormalizeFeatures class GCN(torch.nn.Module): def __init__(self, hidden_channels): super(GCN, self).__init__() torch.manual_seed(520) self.conv1 = GCNConv(dataset.num_features, hidden_channels) self.conv2 = GCNConv(hidden_channels, dataset.num_classes) def forward(self, x, edge_index): x = self.conv1(x, edge_index) x = x.relu() x = F.dropout(x, p=0.5, training=self.training) x = self.conv2(x, edge_index) return x def train(): model.train() optimizer.zero_grad() out = model(data.x, data.edge_index) loss = criterion(out[data.train_mask], data.y[data.train_mask]) loss.backward() optimizer.step() return loss def ttt(): model.eval() out = model(data.x, data.edge_index) pred = out.argmax(dim=1) test_correct = pred[data.test_mask] == data.y[data.test_mask] test_acc = int(test_correct.sum()) / int(data.test_mask.sum()) return test_acc if __name__ == __main__: # 数据准备 dataset = Planetoid(root=../data/Planetoid, name=Cora, transform=NormalizeFeatures()) # transform预处理 data = dataset[0] # 模型建立 model = GCN(hidden_channels=16) print(model) print("=" * 50) criterion = torch.nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4) # Define optimizer. # 迭代训练 for epoch in range(1, 201): loss = train() if epoch % 20 == 0: print(fEpoch:{epoch} , loss:{loss.item()}) # 测试 print("正确率：", ttt())

输出：

GCN( (conv1): GCNConv(1433, 16) (conv2): GCNConv(16, 7) ) ================================================== Epoch:20 , loss:1.7255724668502808 Epoch:40 , loss:1.3229681253433228 Epoch:60 , loss:0.9705381989479065 Epoch:80 , loss:0.7201246619224548 Epoch:100 , loss:0.5934590697288513 Epoch:120 , loss:0.4580436646938324 Epoch:140 , loss:0.4311455488204956 Epoch:160 , loss:0.4086465537548065 Epoch:180 , loss:0.3476596772670746 Epoch:200 , loss:0.32204487919807434 正确率： 0.813

可以看出
     
     
     ，使用GCN的准确率为81%   




   




   




，使用MLP的准确率为59% 



 



 



，提高了22%

六




    




    




    、构建自己的图数据集

import torch from torch_geometric.data import Data if __name__ == __main__: # 定义节点特征向量x和标签y x = torch.tensor([[2, 1], [5, 6], [3, 7], [12, 0]], dtype=torch.float) y = torch.tensor([0, 1, 0, 1], dtype=torch.float) # 定义边 edge_index = torch.tensor([[0, 1, 2, 0, 3], # 起始点 [1, 0, 1, 3, 2]], dtype=torch.long) # 终止点 # 定义train_mask train_mask = [(True if d is not None else False) for d in y] # 构建data data = Data(x=x, y=y, edge_index=edge_index, train_mask=train_mask) print("data:", data) print("train_mask:", data.train_mask)

输出：

data: Data(x=[4, 2], edge_index=[2, 5], y=[4], train_mask=[4]) train_mask: [True, True, True, True]

上面的例子中               ，只构建了一张图
    




    




    



，如果需要构建很多图














，则重复操作即可




    




    




    。

最后将所有图放到一个list列表里就可以了

七














、基于图神经网络的电商购买预测实例

7.1 数据集介绍

未完待续......