• PyTorch搭建图卷积神经网络（GCN）完成对论文分类及预测实战（附源码和数据集）

    需要数据集和源码请点赞关注收藏后评论区留言~~~

    一、数据集简介

    我们将使用Cora数据集。

    该数据集共2708个样本点，每个样本点都是一篇科学论文，所有样本点被分为7个类别，类别分别是1）基于案例；2）遗传算法；3）神经网络；4）概率方法；5）强化学习；6）规则学习；7）理论

    每篇论文都由一个1433维的词向量表示，所以，每个样本点具有1433个特征。词向量的每个元素都对应一个词，且该元素只有0或1两种取值。取0表示该元素对应的词不在论文中，取1表示在论文中。所有的词来源于一个具有1433个词的字典。

    每篇论文都至少引用了一篇其他论文，或者被其他论文引用，也就是样本点之间存在联系，没有任何一个样本点与其他样本点完全没联系。如果将样本点看作图中的点，则这是一个连通的图，不存在孤立点。

    数据集主要文件有两个：cora.cites, cora.content。其中，cora.content包含了2708个样本的具体信息，每行代表一个论文样本，格式为

    <论文id>  <由01组成的1433维特征>  <论文类别（label）>

    总的来说，如果将论文当作“图”的节点，则引用关系则为“图”的边，论文节点信息和引用关系共同构成了图数据。本次实验，我们将利用这些信息，对论文所属的类别进行预测，完成关于论文类别的分类任务。

    二、图神经网络与图卷积神经网络简介

     图神经网络（Graph Neural Networks, GNN）作为新的人工智能学习模型，可以将实际问题看作图数据中节点之间的连接和消息传播问题，对节点之间的依赖关系进行建模，挖掘传统神经网络无法分析的非欧几里得空间数据的潜在信息。在自然语言处理、计算机视觉、生物化学等领域中，图神经网络得到广泛的应用，并发挥着重要作用。

    图卷积神经网络(Graph Convolutional Networks, GCN)是目前主流的图神经网络分支，分类任务则是机器学习中的常见任务。我们将利用GCN算法完成分类任务，进一步体会理解图神经网络工作的原理、GCN的构建实现过程，以及如何将GCN应用于分类任务。

    三、运行效果

    如下图 可见随着训练次数的增加，损失率在下降，精确度在上升，大概在200次左右收敛。

     

     

     

     四、部分源码

    主测试类代码如下

    1. from __future__ import division
    2. from __future__ import print_function
    3. import os
    4. os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
    5. import time
    6. import argparse
    7. import numpy as np
    8. from torch.utils.data import  DataLoader
    9. import torch
    10. import torch.nn.functional as F
    11. import torch.optim as optim
    12.  
    13. from utils import load_data, accuracy
    14. from models import GCN
    15. import matplotlib.pyplot as plt
    16.  
    17. # Training settings
    18. parser = argparse.ArgumentParser()
    19. parser.add_argument('--no-cuda', action='store_true', default=False,
    20.                     help='Disables CUDA training.')
    21. parser.add_argument('--fastmode', action='store_true', default=False,
    22.                     help='Validate during training pass.')
    23. parser.add_argument('--seed', type=int, default=42, help='Random seed.')
    24. parser.add_argument('--epochs', type=int, default=300,
    25.                     help='Number of epochs to train.')
    26. parser.add_argument('--lr', type=float, default=0.01,
    27.                     help='Initial learning rate.')
    28. parser.add_argument('--weight_decay', type=float, default=5e-4,
    29.                     help='Weight decay (L2 loss on parameters).')
    30. parser.add_argument('--hidden', type=int, default=16,
    31.                     help='Number of hidden units.')
    32. parser.add_argument('--dropout', type=float, default=0.5,
    33.                     help='Dropout rate (1 - keep probability).')
    34.  
    35. args = parser.parse_args()
    36. args.cuda = not args.no_cuda and torch.cuda.is_available()
    37.  
    38. .manual_seed(args.seed)
    39.  
    40. # Load data
    41. adj, features, labels, idx_train, idx_val, idx_test = load_data()
    42.  
    43. # Model and optimizer
    44. model = GCN(nfeat=features.shape[1],
    45.             nhid=args.hidden,
    46.             nclass=labels.max().item() + 1,
    47.             dropout=args.dropout)
    48. optimizer = optim.Adam(model.parameters(),
    49.                        lr=args.lr, weight_decay=args.weight_decay)
    50.  
    51. if args.cuda:
    52.     model.cuda()
    53.     features = features.cuda()
    54.     adj = adj.cuda()
    55.     labels = labels.cuda()
    56.     idx_train = idx_train.cuda()
    57.     idx_val = idx_val.cuda()
    58.     idx_test = idx_test.cuda()
    59. Loss_list = []
    60.  
    61.  
    62. accval=[]
    63.  
    64. def train(epoch):
    65.        t=time.time()
    66.        model.train()
    67.        optimizer.zero_grad()
    68.        output=model(features,adj)
    69.        loss_train=F.nll_loss(output[idx_train],labels[idx_train])
    70.        acc_train=accuracy(output[idx_train],labels[idx_train])
    71.        loss_train.backward()
    72.        optimizer.step()
    73.  
    74.        if not args.fastmode:
    75.            model.eval()
    76.            output=model(features,adj)
    77.        loss_val=F.nll_loss(output[idx_val],labels[idx_val])
    78.        acc_val=accuracy(output[idx_val],labels[idx_val])
    79.        print('Epoch:{:04d}'.format(epoch+1),
    80.        'loss_train:{:.4f}'.format(loss_train.item()),
    81.        'acc_train:{:.4f}'.format(acc_train.item()),
    82.        'loss_val:{:.4f}'.format(loss_val.item()),
    83.        'acc_val:{:.4f}'.format(acc_val.item()),
    84.         'time:{:.4f}s'.format(time.time()-t))
    85.        Loss_list.append(loss_train.item())
    86.        Accuracy_list.append(acc_train.item())
    87.        lossval.append(loss_val.item())
    88.        accval.append(acc_val.item())
    89.  
    90.  
    91.  
    92.  
    93.  
    94.  
    95.  
    96.  
    97.  
    98.  
    99.  
    100. def test():
    101.     model.eval()
    102.     output = model(features, adj)
    103.     loss_test = F.nll_loss(output[idx_test], labels[idx_test])
    104.     acc_test = accuracy(output[idx_test], labels[idx_test])
    105.     print("Test set results:",
    106.           "loss= {:.4f}".format(loss_test.item()),
    107.           "accuracy= {:.4f}".format(acc_test.item()))
    108.     acc=acc_test.detach().numpy()
    109.     loss=loss_test.detach().numpy()
    110.  
    111.     print(type(loss_test))
    112.     print(type(acc_test))
    113.  
    114.  
    115.     # 定义两个数组
    116.  
    117.  
    118. # Train model
    119. t_total = time.time()
    120.  
    121. for epoch in range(args.epochs):
    122.     train(epoch)
    123.  
    124.  
    125.  
    126.  
    127.  
    128. print("Optimization Finished!")
    129. printal time elapsed: {:.4f}s".format(time.time() - t_total))
    130. '''
    131. plt.plot([i for i in range(len(Loss_list))],Loss_list)
    132. pplot([i for i in range(len(Accuracy_list))],Accuracy_list)
    133. '''
    134. plt.plot([i for i in range(len(lossval))],lossval)
    135. plot([i for i in range(len(accval))],accval)
    136. print(type(Loss_list))
    137. print(type(Accuracy_list))
    138. #plt.plot([i for i in range(len(Accuracy_list),Accuracy_list)])
    139. plt.show()
    140. # Testing
    142. test()

    模型类如下

    1. import torch.nn as nn
    2. import torch.nn.functional as F
    3. from layers import GraphConvolution
    4.  
    5.  
    6. class GCN(nn.Module):
    7.     def __init__(self, nfeat, nhid, nclass, dropout):
    8.         super(GCN, self).__init__()
    9.  
    10.         self.gc1 = GraphConvolution(nfeat, nhid)
    11.     on(nhid, nclass)
    12.         self.dropout = dropout
    13.  
    14.     def forward(self, x, adj):
    15.         x=F.relu(self.gc1(x,adj))
    16.         x=F.dropout(x,self.dropout,training=self.training)
    17.         x=self.gc2(x,adj)
    18.         return F.log_softmax(x,dim=1)

    layer类如下

    1. import math
    2.  
    3. import torch
    4.  
    5. from torch.nn.parameter import Parameter
    6. from torch.nn.modules.module import Module
    7.  
    8.  
    9. class GraphConvolution(Module):
    10.     """
    11.     Simple GCN layer, similar to https://arxiv.org/abs/1609.02907
    12.     """
    13.  
    14.     def __init__(self, in_features, out_features, bias=True):
    15.         super(GraphConvolution, self).__init__()
    16.         self.in_features=in_features
    17.         self.out_features=out_features
    18.         self.weight=Parameter(torch.FloatTensor(in_features,out_features))
    19.         if bias:
    20.             self.bias=Parameter(torch.FloatTensor(out_features))
    21.         else:
    22.             self.register_parameter('bias',None)
    23.         self.reset_parameters()
    24.  
    25.  
    26.     def reset_parameters(self):
    27.         stdv = 1. / math.sqrt(self.weight.size(1))
    28.         self.weight.data.uniform_(-stdv, stdv)
    29.         if self.bias is not None:
    30.             self.bias.data.uniform_(-stdv, stdv)
    31.  
    32.     def forward(self, input, adj):
    33.          support=torch.mm(input,self.weight)
    34.          output=torch.spmm(adj,support)
    35.          if self.bias is not None:
    36.              return output+self.bias
    37.          else:
    38.              return output
    39.  
    40.     def __repr__(self):
    41.         return self.__class__.__name__ + ' (' \
    42.                + str(self.in_features) + ' -> ' \
    43.                + str(self.out_features) + ')'

    util类如下

    1. import numpy as np
    2. import scipy.sparse as sp
    3. import torch
    4.  
    5.  
    6. def encode_onehot(labels):
    7.     classes = set(labels)
    8.     classes_dict = {c: np.identity(len(classes))[i, :] for i, c in
    9.                     enumerate(classes)}
    10.     labels_onehot = np.array(list(map(classes_dict.get, labels)),
    11.                              dtype=np.int32)
    12.     return labels_onehot
    13.  
    14.  
    15. def load_data(path="data/cora/", dataset="cora"):
    16.     """Load citation network dataset (cora only for now)"""
    17.     print('Loading {} dataset...'.format(dataset))
    18.  
    19.     idx_features_labels = np.genfromtxt("{}{}.content".format(path, dataset),
    20.                                         dtype=np.dtype(str))
    21.     features = sp.csr_matrix(idx_features_labels[:, 1:-1], dtype=np.float32)
    22.     labels = encode_onehot(idx_features_labels[:, -1])
    23.  
    24.     # build graph
    25.     idx = np.array(idx_features_labels[:, 0], dtype=np.int32)
    26.     idx_map = {j: i for i, j in enumerate(idx)}
    27.     edges_unordered = np.genfromtxt("{}{}.cites".format(path, dataset),
    28.                                     dtype=np.int32)
    29.     edges = np.array(list(map(idx_map.get, edges_unordered.flatten())),
    30.                      dtype=np.int32).reshape(edges_unordered.shape)
    31.     adj = sp.coo_matrix((np.ones(edges.shape[0]), (edges[:, 0], edges[:, 1])),
    32.                         shape=(labels.shape[0], labels.shape[0]),
    33.                         dtype=np.float32)
    34.  
    35.     # build symmetric adjacency matrix
    36.     adj = adj + adj.T.multiply(adj.T > adj) - adj.multiply(adj.T > adj)
    37.  
    38.     features = normalize(features)
    39.     adj = normalize(adj + sp.eye(adj.shape[0]))
    40.  
    41.     idx_train = range(140)
    42.     idx_val = range(200, 500)
    43.     idx_test = range(500, 1500)
    44.  
    45.     features = torch.FloatTensor(np.array(features.todense()))
    46.     labels = torch.LongTensor(np.where(labels)[1])
    47.     adj = sparse_mx_to_torch_sparse_tensor(adj)
    48.  
    49.     idx_train = torch.LongTensor(idx_train)
    50.     idx_val = torch.LongTensor(idx_val)
    51.     idx_test = torch.LongTensor(idx_test)
    52.  
    53.     return adj, features, labels, idx_train, idx_val, idx_test
    54.  
    55.  
    56. def normalize(mx):
    57.     """Row-normalize sparse matrix"""
    58.     rowsum = np.array(mx.sum(1))
    59.     r_inv = np.power(rowsum, -1).flatten()
    60.     r_inv[np.isinf(r_inv)] = 0.
    61.     r_mat_inv = sp.diags(r_inv)
    62.     mx = r_mat_inv.dot(mx)
    63.     return mx
    64.  
    65.  
    66.  
    67.  
    68. de_to_torch_sparse_tensor(sparse_mx):
    69.     """Convert a scipy sparse matrix to a torch sparse tensor."""
    70.     sparse_mx = sparse_mx.tocoo().astype(np.float32)
    71.     indices = torch.from_numpy(
    72.         np.vstack((sparse_mx.row, sparse_mx.col)).astype(np.int64))
    73.     values = torch.from_numpy(sparse_mx.data)
    74.     shape = torch.Size(sparse_mx.shape)
    75.     return torch.sparse.FloatTensor(indices, values, shape)

    创作不易 觉得有帮助请点赞关注收藏~~~

  • 相关阅读:
    患上肝内胆管结石症状有哪些？
    linux学习（5）—— 项目部署
    docker安装oracle
    [单片机框架][bsp层][N32G4FR][bsp_flash] flash配置和使用
    不变矩特征在数字验证码识别中的应用研究-含Matlab代码
    汽配制造的智能化转型，百度智能云与海力达释义 “数实融合”
    Hive大数据项目环境搭建：安装部署Hive（超详细）
    Linux虚拟网络设备—Veth Pair
    BFS之最短路径
    网络编程扩展
  • 原文地址：https://blog.csdn.net/jiebaoshayebuhui/article/details/127820577