pytorch|图卷积神经网络(GCN)在Karate数据集的应用

博主又重新学习GCN,本文用的数据集是空手道数据集,最后呈现出可视化。

首先附上全部代码:

import matplotlib.pyplot as plt
import torch
from torch.nn import Linear
from torch_geometric.datasets import KarateClub
from torch_geometric.nn import GCNConv


def show_embedding(h, color, epoch=None, loss=None):

    plt.figure(figsize=(14,9))
    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('Epoch: {}, Loss: {:.4f}'.format(epoch, loss), fontsize=16)
    plt.show()

def show_loss(epoch,loss):

    plt.figure(figsize=(14,9))
    plt.plot(epoch,loss,marker='<')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.grid()
    plt.show()

class GCN(torch.nn.Module):

    def __init__(self):
        super().__init__()
        torch.manual_seed(12234)
        self.conv1 = GCNConv(dataset.num_features, 4) # 定义好输入特征和输出特征
        self.conv2 = GCNConv(4, 4)
        self.conv3 = GCNConv(4, 2) # 输出 2 维向量
        self.classifier = Linear(2, dataset.num_classes)

    def forward(self, x, edge_index):
        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()  # 此时的 h 是 2 维向量

        # 分类层
        out = self.classifier(h)
    
        return out,h

if __name__ == "__main__":

    dataset = KarateClub()
    data = dataset[0]
    Model = GCN()
    print(Model) # 模型结构

    criterion = torch.nn.CrossEntropyLoss() # 定义损失函数
    optimizer = torch.optim.Adam(Model.parameters(), lr=0.01) # 定义优化器

    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

    loss_data = []

    for epoch in range(401):
        loss, h = train(data)
        loss_data.append(loss)
        if epoch % 50 == 0:
            show_embedding(h, color=data.y, epoch=epoch, loss=loss)

    show_loss(epoch=range(401), loss=loss_data)

然后看下输出的模型:
在这里插入图片描述
下面是h的可视化,只展示了最开始和最后的情况
在这里插入图片描述
在这里插入图片描述
最后是Loss值随着Epoch的变化
在这里插入图片描述

### 回答1: 图卷积神经网络(Graph Convolutional Neural Network,GCNN)是一种基于图结构的深度学习模型,能够在图像和其他图结构数据上进行分类、回归和其他任务。链路预测是指在给定输入节点和输出节点之间预测是否存在一条链路(即边)。 下面是一个使用 GCNN 进行链路预测的代码示例,使用的是 PyTorch 框架: ```python import torch import torch.nn as nn import torch.nn.functional as F class GraphConvolution(nn.Module): def __init__(self, input_dim, output_dim, adjacency_matrix): super(GraphConvolution, self).__init__() self.input_dim = input_dim self.output_dim = output_dim self.adjacency_matrix = adjacency_matrix self.weight = nn.Parameter(torch.randn(input_dim, output_dim)) self.bias = nn.Parameter(torch.randn(output_dim)) def forward(self, input_tensor): support = torch.mm(input_tensor, self.weight) output = torch.spmm(self.adjacency_matrix, support) + self.bias return output class GCNN(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim, adjacency_matrix): super(GCNN, self).__init__() self.graph_conv1 = GraphConvolution(input_dim, hidden_dim, adjacency_matrix) self.graph_conv2 = GraphConvolution(hidden_dim, output_dim, adjacency_matrix) def forward(self, input_tensor): hidden = F.relu(self.graph_conv1(input_tensor)) output = F.sigmoid(self.graph_conv2(hidden)) return output # 假设输入是一个 NxD 的矩阵,N 是节点数量,D 是节点特征维度 # 假设输出是一个 Nx1 的矩阵,表示 ### 回答2: 链路预测是指在一个图中预测两个节点之间是否存在连接关系的问题。而图卷积神经网络(Graph Convolutional Neural Networks, GCN)则是一种用于处理图结构数据的深度学习算法。下面我将简要介绍如何利用GCN进行链路预测的方法,并提供示例代码。 链路预测的基本思路是通过学习节点之间的连接模式来预测节点之间的连接关系。GCN是一种基于邻居节点特征聚合的图神经网络,可以提取节点及其邻居的特征,从而捕捉到节点之间的关系。以下是利用GCN进行链路预测的一般步骤: 1. 构建图结构:首先,需要根据问题构建图结构,即将节点和连接关系表示成图。这里可以使用networkx库构建并操作图对象。 2. 特征表示:对于每个节点,需要将其转化为向量形式作为GCN的输入。可以为每个节点定义特征向量,例如将每个节点表示为一个one-hot编码或使用节点的属性特征向量。 3. 邻居聚合:GCN通过将每个节点的特征与其邻居节点的特征进行聚合来获取更丰富的表示。这里可以定义多层GCN来逐步聚合节点的邻居信息。 4. 预测连接:通过训练GCN模型,可以学习到节点之间的连接模式。常用的方法是使用二分类的交叉熵损失函数,并用优化算法(如随机梯度下降)对模型参数进行更新。 下面是一个使用Python和DGL库进行GCN链路预测的示例代码: ```python import dgl import torch import torch.nn as nn import torch.optim as optim from dgl.data import citation_graph as citegrh from sklearn.metrics import roc_auc_score # 构建图结构 data = citegrh.load_cora() g = dgl.DGLGraph(data.graph) features = torch.FloatTensor(data.features) labels = torch.LongTensor(data.labels) num_classes = data.num_labels # 定义GCN模型 class GCN(nn.Module): def __init__(self, in_feats, hidden_size, num_classes): super(GCN, self).__init__() self.gcn_layer = nn.Linear(in_feats, hidden_size) self.predict_layer = nn.Linear(hidden_size, num_classes) def forward(self, g, features): h = self.gcn_layer(g, features) h = torch.relu(h) logits = self.predict_layer(g, h) return logits # 训练模型 model = GCN(in_feats=features.shape[1], hidden_size=16, num_classes=num_classes) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.01) model.train() for epoch in range(30): logits = model(g, features) loss = criterion(logits, labels) optimizer.zero_grad() loss.backward() optimizer.step() # 预测连接 model.eval() with torch.no_grad(): logits = model(g, features) pred_prob = torch.softmax(logits, dim=1)[:, 1] pred_labels = torch.round(pred_prob).long() auc_score = roc_auc_score(labels.numpy(), pred_prob.numpy()) print("AUC Score: {:.4f}".format(auc_score)) ``` 以上代码实现了一个简单的GCN链路预测模型,并使用CORA数据集进行训练和评估。具体步骤包括了构建图结构、定义GCN模型、训练模型和预测连接。代码中GCN模型继承自`nn.Module`类,并使用Adam优化器进行参数更新。在训练阶段,使用交叉熵损失函数计算损失。最后,使用ROC-AUC评估模型性能。 ### 回答3: 链路预测是指通过已知的网络结构信息,预测网络中尚未建立的连接关系。图卷积神经网络(Graph Convolutional Neural Network, GCN)是一种用于节点分类和图分类任务的深度学习模型,也可以用于链路预测。 以下是使用图卷积神经网络进行链路预测的步骤和代码示例: 步骤1:准备数据 1.1 导入必要的库 import numpy as np import networkx as nx import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F 1.2 构建图网络 G = nx.karate_club_graph() # 以Zachary's Karate Club数据集为例 adj = nx.adjacency_matrix(G).todense() adj = torch.tensor(adj, dtype=torch.float) 1.3 划分训练集和测试集 train_ratio = 0.8 train_size = int(train_ratio * adj.shape[0]) train_mask = np.zeros(adj.shape[0], dtype=bool) train_mask[np.random.choice(range(adj.shape[0]), size=train_size, replace=False)] = True train_mask = torch.BoolTensor(train_mask) test_mask = torch.BoolTensor(~train_mask) 步骤2:构建GCN模型 class GCN(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim): super(GCN, self).__init__() self.gc1 = GraphConvolution(input_dim, hidden_dim) self.gc2 = GraphConvolution(hidden_dim, output_dim) def forward(self, x, adj): x = self.gc1(x, adj) x = F.relu(x) x = self.gc2(x, adj) return torch.softmax(x, dim=1) class GraphConvolution(nn.Module): def __init__(self, input_dim, output_dim): super(GraphConvolution, self).__init__() self.fc = nn.Linear(input_dim, output_dim) def forward(self, x, adj): x = torch.matmul(adj, x) x = self.fc(x) return x 步骤3:定义训练过程 def train(model, features, adj, train_mask): optimizer = optim.Adam(model.parameters(), lr=0.01) criterion = nn.MSELoss() model.train() optimizer.zero_grad() output = model(features, adj) loss = criterion(output[train_mask], adj[train_mask]) loss.backward() optimizer.step() 步骤4:执行训练和测试 input_dim = adj.shape[1] hidden_dim = 16 output_dim = 1 epochs = 100 model = GCN(input_dim, hidden_dim, output_dim) for epoch in range(epochs): train(model, adj, adj, train_mask) model.eval() output = model(adj, adj) output = output.detach().numpy().flatten() test_auc = roc_auc_score(adj[test_mask], output[test_mask]) 以上是使用图卷积神经网络进行链路预测的基本步骤和代码示例。需要注意的是,具体的模型结构、超参数调节等需要根据具体问题进行调整。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

xiao黄

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

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

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

打赏作者

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

抵扣说明:

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

余额充值