0


【图神经网络实战】深入浅出地学习图神经网络GNN(上)

文章目录


本文为学习产物,学习链接(如有侵权,请告知删除):
人工智能【图神经网络实战】教程,让你一天就学会深入浅出图神经网络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)要求输入格式是固定的(如2424、128128等)。

但在实际场景中(例如道路交通),不同城市的道路数量和节点数量都不同,即输入数据格式不固定。对此,传统神经网络不能很好地解决,但是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(f'Dataset:{dataset}:')print('='*30)print(f'Number of graphs:{len(dataset)}')print(f'Number of features:{dataset.num_features}')print(f'Number 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

# 画图函数defvisualize_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()# 画点函数defvisualize_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 isnotNoneand loss isnotNone:
        plt.xlabel(f'Epoch:{epoch},Loss:{loss.item():.4f}', fontsize=16)
    plt.show()if __name__ =='__main__':# 不加这个可能会报错
    os.environ['KMP_DUPLICATE_LIB_OK']='True'

    dataset = KarateClub()print(f'Dataset:{dataset}:')print('='*30)print(f'Number of graphs:{len(dataset)}')print(f'Number of features:{dataset.num_features}')print(f'Number 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

classGCN(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)defforward(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

# 画图函数defvisualize_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()# 画点函数defvisualize_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 isnotNoneand loss isnotNone:
        plt.xlabel(f'Epoch:{epoch},Loss:{loss.item():.4f}', fontsize=16)
    plt.show()classGCN(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)defforward(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

# 训练函数deftrain(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 inrange(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(f'Dataset:{dataset}:')print(f'Number of graphs:{len(dataset)}')print(f'Number of features:{dataset.num_features}')print(f'Number of classes:{dataset.num_classes}')print(f'Number of nodes:{data.num_nodes}')print(f'Number of edges:{data.num_edges}')print(f'Average node degree:{data.num_edges / data.num_nodes}')print(f'Number of training nodes:{data.train_mask.sum()}')print(f'Training node label rate:{int(data.train_mask.sum())/ data.num_nodes}')print(f'Has isolated nodes:{data.has_isolated_nodes()}')print(f'Has 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

classMLP(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)defforward(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

deftrain():
    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

defttt():
    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 inrange(1,201):
        loss = train()if epoch %20==0:print(f'Epoch:{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

classGCN(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)defforward(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

deftrain():
    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

defttt():
    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 inrange(1,201):
        loss = train()if epoch %20==0:print(f'Epoch:{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 =[(Trueif d isnotNoneelseFalse)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 数据集介绍

在这里插入图片描述

未完待续......

本文转载自: https://blog.csdn.net/weixin_51545953/article/details/127160151
版权归原作者 WSKH0929 所有, 如有侵权,请联系我们删除。

“【图神经网络实战】深入浅出地学习图神经网络GNN(上)”的评论:

还没有评论