基于Pytorch的图卷积网络GCN实例应用及详解

import numpy as np
import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
import mat4py
import scipy.sparse as sp
from torch_geometric.data import Data
import torch_geometric.nn as pyg_nn
from torch_geometric.data import DataLoader
import warnings
warnings.filterwarnings("ignore", category=Warning)
# 数据集读取
data = mat4py.loadmat('J:/aidb.mat') # 读取数据集mat文件数据
laidb = data['laidb'] # 图标签（0和1），输出为list数据类型
aidb = data['aidb'] # 图数据，list数据类型
nl = aidb['nl'] # 节点及节点特征，[20,1]
am = aidb['am'] # 节点和边的邻接矩阵[20,20]
# no = aidb['no'] # 图的编号，也就是第几张图
dataset = [] # data数据对象的list集合
for i in range(len(laidb)):
    # 数据转换
    # 邻接矩阵转换成COO稀疏矩阵及转换
    # am = np.array(am[i])  # 无所谓，list先转换成numpy
    edge_index_temp = sp.coo_matrix(am[i])
    indices = np.vstack((edge_index_temp.row, edge_index_temp.col))
    edge_index = torch.LongTensor(indices)
    # 节点及节点特征数据转换[20,1]
    x = np.array(list(nl[i].values()))
    x = x.squeeze(0)
    x = torch.FloatTensor(x)
    # 图标签数据转换
    y = torch.LongTensor(laidb[i])
    # 构建数据集:为一张图，20个节点，每个节点一个特征，Coo稀疏矩阵的边，一个图一个标签
    data = Data(x=x, edge_index=edge_index, y=y) # 构建新型data数据对象
    dataset.append(data) # # 将每个data数据对象加入列表

class Net(torch.nn.Module):
    """构造GCN模型网络"""
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = GCNConv(1, 16) # 构造第一层，输入和输出通道，输入通道的大小和节点的特征维度一致
        self.conv2 = GCNConv(16, 2) # 构造第二层，输入和输出通道，输出通道的大小和图或者节点的分类数量一致，比如此程序中图标记就是二分类0和1，所以等于2
    def forward(self, data): # 前向传播
        x, edge_index, batch = data.x, data.edge_index, data.batch # 赋值
        # print(batch)
        # print(x)
        x = self.conv1(x, edge_index) # 第一层启动运算，输入为节点及特征和边的稀疏矩阵，输出结果是二维度[20张图的所有节点数,16]
        # print(x.shape)
        x = F.relu(x) # 激活函数
        x = F.dropout(x, training=self.training)
        x = self.conv2(x, edge_index) # 第二层启动运算，输入为节点及特征和边的稀疏矩阵，输出结果是二维度[20张图的所有节点数,2]
        # print(batch) # 每张图片的节点的分类值不同0-19（0-19这个范围大小是根据batch_size的数目更新）
        x = pyg_nn.global_max_pool(x, batch) # 池化降维，根据batch的值知道有多少张图片（每张图片的节点的分类值不同0-19），再将每张图片的节点取一个全局最大的节点作为该张图片的一个输出
        # print(x.shape) # 输出维度变成[20，2]
        return F.log_softmax(x, dim=1) # softmax可以得到每张图片的概率分布，设置dim=1，可以看到每一行的加和为1，再取对数矩阵每个结果的值域变成负无穷到0
# 构建模型实例
model = Net() # 构建模型实例
optimizer = torch.optim.Adam(model.parameters(), lr=0.005) # 优化器，参数优化计算
train_loader = DataLoader(train_dataset, batch_size=20, shuffle=False) # 加载训练数据集，训练数据中分成每批次20个图片data数据

# 训练模型
model.train() # 表示模型开始训练
for epoch in range(100): # 训练所有训练数据集100次
    loss_all = 0
    # 一轮epoch优化的内容
    for data in train_loader: # 每次提取训练数据集一批20张data图片数据赋值给data
        # data是batch_size图片的大小
        # print(data.edge_index)
        # print(data.batch.shape)
        # print(data.x.shape)
        optimizer.zero_grad() # 梯度清零
        output = model(data) # 前向传播，把一批训练数据集导入模型并返回输出结果，输出结果的维度是[20,2]
        label = data.y # 20张图片数据的标签集合，维度是[20]
        # print(label)
        loss = F.nll_loss(output,label) # 损失函数计算，原理是把output的数值根据Label对应的那个值拿出来，比如lable为[1,1,1]，那就把output中的第一二三维的第二个元素取出，然后去掉负号，再求和之后取均值。
        loss.backward() #反向传播
        loss_all += loss.item() # 将最后的损失值汇总
        optimizer.step() # 更新模型参数
    tmp = (loss_all / len(train_dataset)) # 算出损失值或者错误率
    if epoch % 20 == 0:
        print(tmp) # 每二十次训练完整个训练数据集，输出其错误率

# 测试
from  sklearn.metrics import accuracy_score
def evaluate(loader): # 构造测试函数
    model.eval() # 表示模型开始测试
    with torch.no_grad():
        # print("1111")
        for data in loader: # 读取测试数据集单个data数据
            # print("1111")
            pred = model(data).numpy() # 将数据导入之前构造好的模型，返回输出结果维度是[20,2]
            label = data.y.numpy() # 获取测试集的图片标签
            # print(label)
    return pred,label
loaders = DataLoader(test_dataset, batch_size=20, shuffle=False) # 读取测试数据集数据
# print(loaders.dataset)
pred,label = evaluate(loaders)
# print(pred, label)
preds = []
# list_a.index(max(list_a))
for i in range(pred.shape[0]): # shape[0]表示读取矩阵pred第一维度的长度，那么就是20
    tmp = pred[i].tolist() # tensor转成列表，pred[i]表示第i张图片，数据维度是[1,2]
    # print(tmp)
    preds.append(tmp.index(max(tmp))) # 从列表的两个元素选出最大的tmp.index（x）返回寻找元素x的下标，此时只有两个元素那么下标就是0和1
# print(preds)
# print(len(preds))
print(accuracy_score(label, preds)) # 求出分类准确率分数是指所有分类正确的百分比率，完全正确为1

import numpy as np
import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
import mat4py
import scipy.sparse as sp
from torch_geometric.data import Data
import torch_geometric.nn as pyg_nn
from torch_geometric.data import DataLoader
import warnings
warnings.filterwarnings("ignore", category=Warning)
# 数据集读取
data = mat4py.loadmat('J:/aidb.mat') # 读取数据集mat文件数据
laidb = data['laidb'] # 图标签（0和1），输出为list数据类型
aidb = data['aidb'] # 图数据，list数据类型
nl = aidb['nl'] # 节点及节点特征，[20,1]
am = aidb['am'] # 节点和边的邻接矩阵[20,20]
# no = aidb['no'] # 图的编号，也就是第几张图
dataset = [] # data数据对象的list集合
for i in range(len(laidb)):
    # 数据转换
    # 邻接矩阵转换成COO稀疏矩阵及转换
    # am = np.array(am[i])  # 无所谓，list先转换成numpy
    edge_index_temp = sp.coo_matrix(am[i])
    indices = np.vstack((edge_index_temp.row, edge_index_temp.col))
    edge_index = torch.LongTensor(indices)
    # 节点及节点特征数据转换[20,1]
    x = np.array(list(nl[i].values()))
    x = x.squeeze(0)
    x = torch.FloatTensor(x)
    # 图标签数据转换
    y = torch.LongTensor(laidb[i])
    # 构建数据集:一张图20个节点，每个节点一个特征，边的Coo稀疏矩阵，一个图标签，图的标签分两类0和1
    data = Data(x=x, edge_index=edge_index, y=y) # 构建新型data数据对象
    dataset.append(data) # 将每个data数据对象加入列表
# import numpy as np
# 加载ENZYMES数据集.(自动帮你下载)
# dataset = TUDataset(root='/data/ENZYMES', name='ENZYMES')
# # print(dataset.data)
# dataset = dataset.shuffle()
# 切分数据集，分成训练和测试两部分
train_dataset = dataset[:5000]
test_dataset = dataset[5030:5050]
class Net(torch.nn.Module):
    """构造GCN模型网络"""
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = GCNConv(1, 16) # 构造第一层，输入和输出通道，输入通道的大小和节点的特征维度一致
        self.conv2 = GCNConv(16, 2) # 构造第二层，输入和输出通道，输出通道的大小和图或者节点的分类数量一致，比如此程序中图标记就是二分类0和1，所以等于2
    def forward(self, data): # 前向传播
        x, edge_index, batch = data.x, data.edge_index, data.batch # 赋值
        # print(batch)
        # print(x)
        x = self.conv1(x, edge_index) # 第一层启动运算，输入为节点及特征和边的稀疏矩阵，输出结果是二维度[20张图的所有节点数,16]
        # print(x.shape)
        x = F.relu(x) # 激活函数
        x = F.dropout(x, training=self.training)
        x = self.conv2(x, edge_index) # 第二层启动运算，输入为节点及特征和边的稀疏矩阵，输出结果是二维度[20张图的所有节点数,2]
        # print(batch) # 每张图片的节点的分类值不同0-19（0-19这个范围大小是根据batch_size的数目更新）
        x = pyg_nn.global_max_pool(x, batch) # 池化降维，根据batch的值知道有多少张图片（每张图片的节点的分类值不同0-19），再将每张图片的节点取一个全局最大的节点作为该张图片的一个输出值
        # print(x.shape) # 输出维度变成[20，2]
        return F.log_softmax(x, dim=1) # softmax可以得到每张图片的概率分布，设置dim=1，可以看到每一行的加和为1，再取对数矩阵每个结果的值域变成负无穷到0
# device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# 构建模型实例
model = Net() # 构建模型实例
optimizer = torch.optim.Adam(model.parameters(), lr=0.005) # 优化器，模型参数优化计算
train_loader = DataLoader(train_dataset, batch_size=20, shuffle=False) # 加载训练数据集，训练数据中分成每批次20个图片data数据
# print(len(train_dataset))
# 训练模型
model.train() # 表示模型开始训练
for epoch in range(100): # 训练所有训练数据集100次
    loss_all = 0
    # 一轮epoch优化的内容
    for data in train_loader: # 每次提取训练数据集一批20张data图片数据赋值给data
        # data是batch_size图片的大小
        # print(data.edge_index)
        # print(data.batch.shape)
        # print(data.x.shape)
        optimizer.zero_grad() # 梯度清零
        output = model(data) # 前向传播，把一批训练数据集导入模型并返回输出结果，输出结果的维度是[20,2]
        label = data.y # 20张图片数据的标签集合，维度是[20]
        # print(label)
        loss = F.nll_loss(output,label) # 损失函数计算，原理是把output的数值根据Label对应的那个值拿出来，比如lable为[1,1,1]，那就把output中的第一二三维的第二个元素取出，然后去掉负号，再求和之后取均值。
        loss.backward() #反向传播
        loss_all += loss.item() # 将最后的损失值汇总
        optimizer.step() # 更新模型参数
    tmp = (loss_all / len(train_dataset)) # 算出损失值或者错误率
    if epoch % 20 == 0:
        print(tmp) # 每二十次训练完整个训练数据集，输出其错误率
# 测试
from  sklearn.metrics import accuracy_score
def evaluate(loader): # 构造测试函数
    model.eval() # 表示模型开始测试
    with torch.no_grad():
        # print("1111")
        for data in loader: # 读取测试数据集单个data数据
            # print("1111")
            pred = model(data).numpy() # 将数据导入之前构造好的模型，返回输出结果维度是[20,2]
            label = data.y.numpy() # 获取测试集的图片标签
            # print(label)
    return pred,label
loaders = DataLoader(test_dataset, batch_size=20, shuffle=False) # 读取测试数据集数据
# print(loaders.dataset)
pred,label = evaluate(loaders)
# print(pred, label)
preds = []
# list_a.index(max(list_a))
for i in range(pred.shape[0]): # shape[0]表示读取矩阵pred第一维度的长度，那么就是20
    tmp = pred[i].tolist() # tensor转成列表，pred[i]表示第i张图片，数据维度是[1,2]
    # print(tmp)
    preds.append(tmp.index(max(tmp))) # 从列表的两个元素选出最大的tmp.index（x）返回寻找元素x的下标，此时只有两个元素那么下标就是0和1
# print(preds)
# print(len(preds))
print(accuracy_score(label, preds)) # 求出分类准确率分数是指所有分类正确的百分比率，完全正确为1