利用官方torch版GCN训练并测试cora数据集

最新推荐文章于 2024-07-02 09:24:33 发布
最新推荐文章于 2024-07-02 09:24:33 发布
阅读量2.6k 收藏 28
点赞数 3
分类专栏： pytorch 图卷积神经网络 文章标签： python 图卷积 深度学习 pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33952811/article/details/120955106
版权

目录

cora数据集

Cora数据集由2708份论文名称，及对应的特征向量组成，分成了七大类，分别是，Case_Based、Genetic_Algorithms、Neural_Networks、Probabilistic_Methods、Reinforcement_Learning、Rule_Learning、Theory。特征向量由1433个独特的单词组成，由01值描述，表示论文中这些单词的频数是否小于10，小于为0，大于为1。该数据集中，每一篇论文至少引用了该数据集里面另外一篇论文或者被另外一篇论文引用。

数据集包含两个文件，分别是Content文件和Cites文件。

Content文件

包含2708行，代表2708条论文的数据，每一行由 “< paper id > + < word attribution > + < class label >” 组成，一共1435列

  • < paper id > 表示论文的id编号
  • < word attribution > 表示论文的单词向量，01值，一共1433列，论文中这些单词的频数如果小于10，为0，大于为1
  • < class label > 改论文所属的类别

Cites文件

包含5429行，两列，< id of cited paper > + < id of citing paper >

< id of cited paper > 表示被引用论文的编号

< id of citing paper> 表示引用论文的编号

代码实现

数据预处理和数据加载

import numpy as np
import scipy.sparse as sp	# 稀疏矩阵

def load_data(path="../data/cora/", dataset="cora"):
    print('Loading {} dataset...'.format(dataset))
	# content数据加载
    idx_features_labels = np.genfromtxt("{}{}.content".format(path, dataset),dtype=np.dtype(str))
    # 获取特征向量，并将特征向量转为稀疏矩阵，
    features = sp.csr_matrix(idx_features_labels[:, 1:-1], dtype=np.float32)
    # 获取标签
    labels = encode_onehot(idx_features_labels[:, -1])
    # 搭建图
    idx = np.array(idx_features_labels[:, 0], dtype=np.int32)
    # 搭建字典，论文编号-->索引
    idx_map = {j: i for i, j in enumerate(idx)}
    # cites数据加载，shape：5429,2
    edges_unordered = np.genfromtxt("{}{}.cites".format(path, dataset),dtype=np.int32)
    # 边，将编号映射为索引，因为编号是非连续的整数
    edges = np.array(list(map(idx_map.get, edges_unordered.flatten())),dtype=np.int32).reshape(edges_unordered.shape)
    # 构建邻接矩阵
    adj = sp.coo_matrix((np.ones(edges.shape[0]), (edges[:, 0], edges[:, 1])),
                        shape=(labels.shape[0], labels.shape[0]),
                        dtype=np.float32)
	# 转换为对称邻接矩阵 
    adj = adj + adj.T.multiply(adj.T > adj) - adj.multiply(adj.T > adj)
	# 归一化特征矩阵和邻接矩阵
    features = normalize(features)
    adj = normalize(adj + sp.eye(adj.shape[0]))
	
    # 设置训练、验证和测试的数量
    idx_train = range(140)
    idx_val = range(200, 500)
    idx_test = range(500, 1500)
	
    # 转为Tensor格式
    features = torch.FloatTensor(np.array(features.todense())	# toarray返回ndarray; todense返回矩阵
    labels = torch.LongTensor(np.where(labels)[1])				
    adj = sparse_mx_to_torch_sparse_tensor(adj)
	
    idx_train = torch.LongTensor(idx_train)
    idx_val = torch.LongTensor(idx_val)
    idx_test = torch.LongTensor(idx_test)
	
    return adj, features, labels, idx_train, idx_val, idx_test
    # adj 		2708,2708
    # features 	2708,1433
    # labels	2708,      0~6

GCN网络

class GCN(nn.Module):
    def __init__(self, nfeat, nhid, nclass, dropout):
        super(GCN, self).__init__()

        self.gc1 = GraphConvolution(nfeat, nhid)	# 这里nfeat是1433个特征单词向量
        self.gc2 = GraphConvolution(nhid, nclass)	# 这里nclass是7类
        self.dropout = dropout

    def forward(self, x, adj):
        '''
        step1. gc
        step2. relu
        step3. dropout
        step4. gc
        step5. log_softmax 并输出
        '''
        x = F.relu(self.gc1(x, adj))
        x = F.dropout(x, self.dropout, training=self.training)
        x = self.gc2(x, adj)
        return F.log_softmax(x, dim=1)

    
class GraphConvolution(Module):
    """
    Simple GCN layer, similar to https://arxiv.org/abs/1609.02907
    """
    def __init__(self, in_features, out_features, bias=True):
        super(GraphConvolution, self).__init__()
        self.in_features = in_features
        self.out_features = out_features
        self.weight = Parameter(torch.FloatTensor(in_features, out_features))
        if bias:
            self.bias = Parameter(torch.FloatTensor(out_features))
        else:
            self.register_parameter('bias', None)
        self.reset_parameters()

    def reset_parameters(self):
        stdv = 1. / math.sqrt(self.weight.size(1))
        self.weight.data.uniform_(-stdv, stdv)
        if self.bias is not None:
            self.bias.data.uniform_(-stdv, stdv)

    # 这里设，特征矩阵feature为H，邻接矩阵adj为A，权重为W，则输出为， 
    # step1. 求 H 和 W 乘积  HW
    # step2. 求 A 和 HW 乘积 AHW，这里 A = D_A ^ -1 · (A + I) 做了归一化， H = D_H^-1 · H 
    # 对于维度
    '''
    # adj 		2708,2708   		A
    # features 	2708,1433			H0
    # labels	2708,      0~6
    第一次gc后为2708,nhid
    第二次gc后为2708,7 (7个类别)
    '''
    def forward(self, input, adj):
        support = torch.mm(input, self.weight)	
        output = torch.spmm(adj, support)
        if self.bias is not None:
            return output + self.bias
        else:
            return output

    def __repr__(self):
        return self.__class__.__name__ + ' (' \
               + str(self.in_features) + ' -> ' \
               + str(self.out_features) + ')'

优化器等加载

optimizer = optim.Adam(model.parameters(),lr=args.lr, weight_decay=args.weight_decay)

训练和测试

def train(epoch):
    t = time.time()
    model.train()
    optimizer.zero_grad()
    output = model(features, adj)
    loss_train = F.nll_loss(output[idx_train], labels[idx_train])
    acc_train = accuracy(output[idx_train], labels[idx_train])
    loss_train.backward()
    optimizer.step()

    if not args.fastmode:
        # Evaluate validation set performance separately,
        # deactivates dropout during validation run.
        model.eval()
        output = model(features, adj)

    loss_val = F.nll_loss(output[idx_val], labels[idx_val])
    acc_val = accuracy(output[idx_val], labels[idx_val])
    print('Epoch: {:04d}'.format(epoch + 1),
          'loss_train: {:.4f}'.format(loss_train.item()),
          'acc_train: {:.4f}'.format(acc_train.item()),
          'loss_val: {:.4f}'.format(loss_val.item()),
          'acc_val: {:.4f}'.format(acc_val.item()),
          'time: {:.4f}s'.format(time.time() - t))
    
def test():
    model.eval()
    output = model(features, adj)
    loss_test = F.nll_loss(output[idx_test], labels[idx_test])
    acc_test = accuracy(output[idx_test], labels[idx_test])
    print("Test set results:",
          "loss= {:.4f}".format(loss_test.item()),
          "accuracy= {:.4f}".format(acc_test.item()))

其他必须的函数

def encode_onehot(labels):
    classes = set(labels)
    classes_dict = {c: np.identity(len(classes))[i, :] for i, c in
                    enumerate(classes)}
    labels_onehot = np.array(list(map(classes_dict.get, labels)),
                             dtype=np.int32)
    return labels_onehot

def normalize(mx):
    """Row-normalize sparse matrix"""
    rowsum = np.array(mx.sum(1))
    r_inv = np.power(rowsum, -1).flatten()
    r_inv[np.isinf(r_inv)] = 0.
    r_mat_inv = sp.diags(r_inv)
    mx = r_mat_inv.dot(mx)
    return mx

def accuracy(output, labels):
    preds = output.max(1)[1].type_as(labels)
    correct = preds.eq(labels).double()
    correct = correct.sum()
    return correct / len(labels)

def sparse_mx_to_torch_sparse_tensor(sparse_mx):
    """Convert a scipy sparse matrix to a torch sparse tensor."""
    sparse_mx = sparse_mx.tocoo().astype(np.float32)
    indices = torch.from_numpy(
        np.vstack((sparse_mx.row, sparse_mx.col)).astype(np.int64))
    values = torch.from_numpy(sparse_mx.data)
    shape = torch.Size(sparse_mx.shape)
    return torch.sparse.FloatTensor(indices, values, shape)

输出结果

...
Epoch: 0188 loss_train: 0.4158 acc_train: 0.9200 loss_val: 0.7011 acc_val: 0.7886 time: 0.0070s
Epoch: 0189 loss_train: 0.4453 acc_train: 0.9467 loss_val: 0.6996 acc_val: 0.7914 time: 0.0080s
Epoch: 0190 loss_train: 0.4042 acc_train: 0.9400 loss_val: 0.6973 acc_val: 0.7914 time: 0.0070s
Epoch: 0191 loss_train: 0.4443 acc_train: 0.9267 loss_val: 0.6966 acc_val: 0.7914 time: 0.0070s
Epoch: 0192 loss_train: 0.4082 acc_train: 0.9400 loss_val: 0.6956 acc_val: 0.7914 time: 0.0070s
Epoch: 0193 loss_train: 0.3909 acc_train: 0.9467 loss_val: 0.6937 acc_val: 0.7971 time: 0.0080s
Epoch: 0194 loss_train: 0.4289 acc_train: 0.9333 loss_val: 0.6921 acc_val: 0.7971 time: 0.0070s
Epoch: 0195 loss_train: 0.4092 acc_train: 0.9267 loss_val: 0.6898 acc_val: 0.8000 time: 0.0070s
Epoch: 0196 loss_train: 0.3790 acc_train: 0.9600 loss_val: 0.6882 acc_val: 0.8029 time: 0.0080s
Epoch: 0197 loss_train: 0.3813 acc_train: 0.9467 loss_val: 0.6867 acc_val: 0.8000 time: 0.0070s
Epoch: 0198 loss_train: 0.4018 acc_train: 0.9533 loss_val: 0.6858 acc_val: 0.8057 time: 0.0080s
Epoch: 0199 loss_train: 0.3730 acc_train: 0.9467 loss_val: 0.6847 acc_val: 0.8114 time: 0.0070s
Epoch: 0200 loss_train: 0.3693 acc_train: 0.9600 loss_val: 0.6845 acc_val: 0.8143 time: 0.0080s
Optimization Finished!
Total time elapsed: 1.7434s
Test set results: loss= 0.7244 accuracy= 0.8230

参考链接

https://github.com/tkipf/pygcn

小风_
关注
专栏目录
node classification：基于torch_geometric（PyG）框架搭建简单GCN网络对Cora数据集进行训练测试
qq_38432089的博客
12-28 1996
参考文章： GNN的第一个简单案例：Cora分类 PyG文档之二：快速入门 1、Cora数据集 （1）GNN常用的数据集：https://linqs.soe.ucsc.edu/data） （2）Cora数据集是GNN中的一个经典数据集，相当于mnist数据集在CNN中的地位。该数据集是机器学习论文之间的引用网络，共有2708篇论文（即：节点数量）、7类论文（即：节点类别数）、5429条边，每个节点有1433个特征。 2、torch_geometric框架（PyG） 参考官方文档：https://pytor
gcn torch 实验
路边的石头
03-07 215
常用版本 记录 比较奇怪的是，用了adjency normlization之后OA不升高，反而降低 import itertools #循环器每次返回的对象将赋予给i，直到循环结束 from scipy.io import loadmat import numpy as np import os import os.path as osp from collections import namedtuple #具名元组 import random import scipy.sparse as sp i
GCN 代码解析(一) for pytorch
WANGYANG的博客
05-31 1254
在前文中，已经对图卷积神经网络（Graph Convolutional Neural Networks, GCN）的理论基础进行了深入探讨。接下来的章节将会进入新的阶段——将借助PyTorch，这一强大的深度学习框架，通过实战讲解来展示如何构建和训练一个图卷积神经网络。这一过程不仅将帮助读者巩固理论知识，更重要的是，它将引导读者迈出理论到实践的关键一步，从而在处理具有图结构数据的问题上实现质的飞跃。
【PYG】简单验证GCN结合Cora数据集
最新发布
Never Give Up
07-02 664
Cora 数据集由 2708 篇科学出版物组成，这些出版物被分为 7 个类别。节点代表论文，边代表引用关系。每个节点有一个 1433 维的特征向量，表示论文的词袋模型（Bag of Words），特征向量中的每个维度表示某个词汇是否出现在论文中。
大模型的api封装与本地端口调用（二）——fastapi实现
2201_75499442的博客
06-24 1380
FastAPI 是一个现代、快速（高性能）的 Python Web 框架，用于构建基于标准 Python 类型提示的 API。基于模型的输入json样式，向本地localhost:6006发送POST请求，发现能够正常返回模型的输出结果！2. 设置设备参数与清理 GPU 内存函数。4.创建 FastAPI 应用。5.处理 POST 请求的端点。1. 引入库和设置设备参数。3.构建对话输入模版。
【torch】搭建GCN的详细介绍
panbaoran913的博客
03-22 2713
一、GCN的原理 简单，也有很多博客在说明！ 链接1：https://arxiv.org/abs/1609.02907 链接2：https://mp.weixin.qq.com/s/DJAimuhrXIXjAqm2dciTXg 二、GCN的层代码 import math import torch from torch.nn.parameter import Parameter from torch.nn.modules.module import Module class GraphConvolution(
[图神经网络]PyTorch简单实现一个GCN
就随便写写....
04-12 3114
图神经网络PyG实现
【torch_geometric】图介绍及GCN基本用法（上）
qq_41693168的博客
12-19 2369
图由顶点（Vertex）以及连接顶点的边（Edge）构成。顶点表示研究的对象，边表示两个对象之间特定的关系。图可以表示为顶点和边的集合，记为G=(V, E)，其中V是顶点集合，E是边集合。图又分为有向图和无向图；非加权图和加权图；连通图和非连通图（看是否有孤立的点）等。可以自行看官方文档from torch.nn import Linear #线性层from torch_geometric.nn import GCNConv #卷积层这个过程非常简单，和之前定义MLP网络很像。
在Cora和Citeseer数据集上使用GCN网络实现链路预测
04-06
Cora数据集包含了2708篇计算机科学领域的论文，这些论文通过7个类别相互引用，形成了一个复杂的图结构。Citeseer数据集则包含3312篇论文，分为6个类别，同样以引用关系构建了图。这两个数据集的每个节点都有一个特征...
gcn练习代码-Cora数据集
02-16
Cora数据集在之前的资源中可以下载 并非原创，于github上找到的代码，并进行了相应的修改，目前没找到源 于85个epoch中结束了训练，逻辑是设计循环中一个epoch有10次所有的train、val、test值都不再改变
基于GCN的CORA图数据集节点级多分类任务python源码+项目运行说明+数据.zip
01-16
基于GCN的CORA图数据集节点级多分类任务python源码+项目运行说明+数据.zip 项目说明 - 数据集CORA 图数据集 - 任务：多分类 - 使用模型GCN SVM FNN - 包括构图、数据预处理及feature encoding ### 依赖库安装 ``` ...
Python-PyTorch实现的ClusterGCN一种用于训练深度和大型图形卷积网络的高效算法
08-11
A PyTorch implementation of "Cluster-GCN: An Efficient Algorithm for Training Deep and Large Graph Convolutional Networks" (KDD 2019).
la-gcn-torch:PyTorch中用于图卷积网络的可学习聚合器的实现
03-14
PyTorch中用于图卷积网络的可学习聚合器 PyTorch中用于图卷积网络的可学习聚合器的实现。 通过引入共享的辅助模型为GCN（LA-GCN）提供可学习的聚合器，该模型在邻域聚合中提供了自定义架构。 在此框架下，提出了一种称为LA-GCN（Mask）的新模型，其中包括一个新的聚合函数，即掩码聚合器。 辅助模型为给定节点的每个邻居学习一个特定的掩码，从而可以同时注意节点级别和功能级别。 该机制将学习为预测的节点和特征分配不同的重要性，从而为预测提供可解释的解释并提高模型的鲁棒性。 张力，吕海萍， ://dl.acm.org/doi/abs/10.1145/3340531.3411983（CIKM 2020） 对于官方实施 要求 PyTorch 0.4或0.5 Python 2.7或3.6 训练 python train.py 参考 [1] [2]
cora数据集、含图卷积训练代码
11-12
cora数据集、含图卷积训练代码
GCN论文源码（pytorch）超级详细注释讲解！
01-20
本文参考了这篇文章：https://blog.csdn.net/weixin_36474809/article/details/89379727侵删 这篇文章的代码非常经典，很值得学习，如有错误请指正 utils.py import numpy as np import scipy.sparse as sp import torch ''' 先将所有由字符串表示的标签数组用set保存，set的重要特征就是元素没有重复， 因此表示成set后可以直接得到所有标签的总数，随后为每个标签分配一个编号，创建一个单位矩阵， 单位矩阵的每一行对应一个one-hot向量，也就是np.identity(len(
cora数据集科研论文头部信息抽取
07-12
信息抽取，或者所论文头部信息抽取需要的数据集，这里只放了论文头部抽取所需要的数据集，并不是整个cora数据集，整个的很大有几百兆，这里不可能放的下
GCN相关数据集（含cora，citeseer，football等数据集）
06-29
# karateclub那个数据集 import numpy as np data = pd.read_csv('data.csv') data = np.array(data) print(data) print(data.shape) # 34个节点，78条边 无权无向图 def build_karate_club_graph(): src = ...
GCN torch_geometric message_passing方法源码解析
qq_39407949的博客
05-15 1519
message_passing方法源码解析前言源码位置源码及注释MessagePassing类propagate方法感谢及参考博文 前言 最近在看关于图神经网络相关论文，涉及到论文复现，所以要啃源码。 网上虽然有一部分对源码的解析，如torch_geometric（）方法，但是在深入到里面具体方法，资料寥寥无几。 特将自己学习笔记分享，一来方便自己以后查阅，二来给和我一样苦难的同胞一点点思路，三来方便热心网友补充，最后为后面大神分享代码或思路抛砖引玉。^_^ 源码位置 torch_geometric\nn\
GCN torch_geometric utils scatter_方法源码解析及样例
qq_39407949的博客
05-15 1621
scatter_方法源码解析源码位置源码及注释torch_scatter方法scatter_方法解析常规运行节点特征维度dim_size（运算后返回的维度）参数index（索引）参数name（聚合方式）感谢及参考博文 源码位置 torch_geometric\utils\scatter.py 源码及注释 代码相当于在原有torch_scatter包的基础上进行二次开发。 import torch_scatter def scatter_(name, src, index, dim=0, dim_size
torch GNN实现 增加测试、训练代码
05-26
好的，我可以给你提供一个简单的 PyTorch GNN 实现，并且附带训练和测试代码。这个实现是基于 GCN （Graph Convolutional Network）的，你可以根据需要进行改进。 首先，我们需要安装 PyTorch 和 DGL（Deep Graph Library）： ```bash pip install torch dgl ``` 然后，我们可以定义一个简单的 GNN 模型： ```python import torch import torch.nn as nn import dgl.function as fn from dgl.nn.pytorch import GraphConv class GNN(nn.Module): def __init__(self, in_feats, hidden_feats, out_feats): super(GNN, self).__init__() self.conv1 = GraphConv(in_feats, hidden_feats) self.conv2 = GraphConv(hidden_feats, out_feats) def forward(self, g, features): h = self.conv1(g, features) h = torch.relu(h) h = self.conv2(g, h) return h ``` 这个 GNN 模型包含两个 GraphConv 层，每个层都是由输入特征到输出特征的线性变换，然后通过 ReLU 激活函数进行非线性变换。在这个例子中，我们使用了两个 GraphConv 层，但你可以根据需要添加更多层。 接下来，我们可以定义一个简单的训练循环： ```python import dgl import torch.optim as optim def train(model, g, features, labels, train_mask, epochs): optimizer = optim.Adam(model.parameters()) criterion = nn.CrossEntropyLoss() for epoch in range(epochs): model.train() logits = model(g, features) loss = criterion(logits[train_mask], labels[train_mask]) optimizer.zero_grad() loss.backward() optimizer.step() print('Epoch %d | Loss: %.4f' % (epoch, loss.item())) ``` 在这个训练循环中，我们使用 Adam 优化器和交叉熵损失函数对 GNN 进行训练。训练过程中，我们计算模型的预测值（logits），然后根据训练集上的标签和掩码计算交叉熵损失。最后，我们通过反向传播和优化器来更新模型参数。 最后，我们可以定义一个简单的测试函数： ```python import torch.nn.functional as F def test(model, g, features, labels, test_mask): model.eval() with torch.no_grad(): logits = model(g, features) pred = logits.argmax(1) acc = F.accuracy(logits[test_mask], labels[test_mask]) print('Accuracy: %.4f' % acc.item()) ``` 在这个测试函数中，我们首先将模型设置为评估模式，然后使用模型对测试集进行预测。最后，我们计算准确率并输出结果。 现在，我们可以使用这些代码来训练和测试我们的 GNN 模型： ```python import dgl.data dataset = dgl.data.CoraGraphDataset() g = dataset[0] features = g.ndata['feat'] labels = g.ndata['label'] train_mask = g.ndata['train_mask'] test_mask = g.ndata['test_mask'] model = GNN(features.shape[1], 16, dataset.num_classes) train(model, g, features, labels, train_mask, epochs=100) test(model, g, features, labels, test_mask) ``` 在这个例子中，我们使用 Cora 数据集来测试我们的 GNN 模型。训练和测试代码将使用上述函数进行训练和测试，最后输出测试准确率。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小风_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值