深度学习中的图神经网络：原理与实践

背景

图神经网络（Graph Neural Networks, GNNs）是一类专门处理图结构数据的深度学习模型，在社交网络分析、分子属性预测、推荐系统等领域取得了显著成果。本文将深入探讨图神经网络的基本原理，介绍常用的图神经网络模型，并提供实践案例。

图神经网络的基本原理

1. 图的表示

图由节点（Nodes）和边（Edges）组成，可以表示为 G = (V, E) ，其中 V 是节点集合， E 是边集合。

2. 图神经网络的核心思想

图神经网络的核心思想是通过聚合邻居节点的信息来更新节点的表示，从而捕捉图的结构信息。

3. 消息传递机制

大多数图神经网络采用消息传递机制：

  1. 消息计算：计算节点对其邻居的消息
  2. 消息聚合：聚合邻居节点的消息
  3. 节点更新：使用聚合的消息更新节点表示

常用图神经网络模型

1. Graph Convolutional Network (GCN)

GCN是一种基于谱域的图卷积网络，通过对图的拉普拉斯矩阵进行特征分解来实现卷积操作。

import torch
import torch.nn as nn
import torch.nn.functional as F

class GCN(nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(in_channels, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, out_channels)
    
    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, p=0.5, training=self.training)
        x = self.conv2(x, edge_index)
        return x

# 定义GCN卷积层
class GCNConv(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(GCNConv, self).__init__()
        self.linear = nn.Linear(in_channels, out_channels)
    
    def forward(self, x, edge_index):
        # 构建邻接矩阵
        N = x.size(0)
        adj = torch.zeros((N, N), device=x.device)
        adj[edge_index[0], edge_index[1]] = 1
        
        # 添加自环
        adj = adj + torch.eye(N, device=x.device)
        
        # 计算度矩阵的逆平方根
        degree = adj.sum(dim=1)
        degree_inv_sqrt = torch.pow(degree, -0.5)
        degree_inv_sqrt[torch.isinf(degree_inv_sqrt)] = 0
        degree_matrix = torch.diag(degree_inv_sqrt)
        
        # 计算标准化的邻接矩阵
        normalized_adj = degree_matrix @ adj @ degree_matrix
        
        # 执行图卷积
        x = self.linear(x)
        x = normalized_adj @ x
        
        return x

2. GraphSAGE

GraphSAGE通过采样和聚合邻居节点的特征来生成节点表示，适用于归纳学习场景。

import torch
import torch.nn as nn
import torch.nn.functional as F

class GraphSAGE(nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super(GraphSAGE, self).__init__()
        self.conv1 = SAGEConv(in_channels, hidden_channels)
        self.conv2 = SAGEConv(hidden_channels, out_channels)
    
    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, p=0.5, training=self.training)
        x = self.conv2(x, edge_index)
        return x

# 定义GraphSAGE卷积层
class SAGEConv(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(SAGEConv, self).__init__()
        self.linear = nn.Linear(in_channels * 2, out_channels)
    
    def forward(self, x, edge_index):
        N = x.size(0)
        
        # 聚合邻居特征
        neighbor_features = []
        for i in range(N):
            # 找到节点i的所有邻居
            neighbors = edge_index[1][edge_index[0] == i]
            if len(neighbors) == 0:
                # 如果没有邻居，使用零向量
                neighbor_feature = torch.zeros_like(x[i])
            else:
                # 平均聚合邻居特征
                neighbor_feature = x[neighbors].mean(dim=0)
            neighbor_features.append(neighbor_feature)
        
        neighbor_features = torch.stack(neighbor_features)
        
        # 拼接节点自身特征和邻居聚合特征
        combined = torch.cat([x, neighbor_features], dim=1)
        
        # 线性变换
        x = self.linear(combined)
        
        return x

3. Graph Attention Network (GAT)

GAT引入注意力机制，为不同的邻居分配不同的注意力权重。

import torch
import torch.nn as nn
import torch.nn.functional as F

class GAT(nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels, heads=8):
        super(GAT, self).__init__()
        self.conv1 = GATConv(in_channels, hidden_channels, heads=heads)
        self.conv2 = GATConv(hidden_channels * heads, out_channels, heads=1)
    
    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, p=0.5, training=self.training)
        x = self.conv2(x, edge_index)
        return x

# 定义GAT卷积层
class GATConv(nn.Module):
    def __init__(self, in_channels, out_channels, heads=1):
        super(GATConv, self).__init__()
        self.heads = heads
        self.linear = nn.Linear(in_channels, out_channels * heads)
        self.attention = nn.Linear(2 * out_channels, 1)
    
    def forward(self, x, edge_index):
        N = x.size(0)
        
        # 线性变换
        x = self.linear(x).view(N, self.heads, -1)
        
        # 计算注意力分数
        edge_src, edge_dst = edge_index
        src_features = x[edge_src]
        dst_features = x[edge_dst]
        
        # 拼接源节点和目标节点的特征
        combined = torch.cat([src_features, dst_features], dim=-1)
        
        # 计算注意力权重
        attention_scores = F.leaky_relu(self.attention(combined)).squeeze(-1)
        
        # 归一化注意力权重
        attention_weights = F.softmax(attention_scores, dim=0)
        
        # 聚合邻居特征
        out = torch.zeros_like(x)
        for i in range(self.heads):
            # 对每个注意力头单独处理
            head_weights = attention_weights.view(-1, self.heads)[:, i]
            head_src_features = src_features[:, i]
            
            # 聚合
            for j in range(N):
                # 找到目标节点为j的所有边
                edges = edge_dst == j
                if edges.any():
                    out[j, i] = (head_src_features[edges] * head_weights[edges].unsqueeze(-1)).sum(dim=0)
        
        # 拼接多个注意力头的输出
        out = out.view(N, -1)
        
        return out

4. 图自编码器 (Graph Autoencoder)

图自编码器用于图的降维和表示学习。

import torch
import torch.nn as nn
import torch.nn.functional as F

class GraphAutoencoder(nn.Module):
    def __init__(self, in_channels, hidden_channels, latent_channels):
        super(GraphAutoencoder, self).__init__()
        self.encoder = GCN(in_channels, hidden_channels, latent_channels)
        self.decoder = nn.Linear(latent_channels, in_channels)
    
    def forward(self, x, edge_index):
        # 编码
        z = self.encoder(x, edge_index)
        # 解码
        x_reconstructed = self.decoder(z)
        return x_reconstructed, z

# 定义GCN编码器
class GCN(nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(in_channels, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, out_channels)
    
    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.conv2(x, edge_index)
        return x

# 定义GCN卷积层
class GCNConv(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(GCNConv, self).__init__()
        self.linear = nn.Linear(in_channels, out_channels)
    
    def forward(self, x, edge_index):
        N = x.size(0)
        adj = torch.zeros((N, N), device=x.device)
        adj[edge_index[0], edge_index[1]] = 1
        adj = adj + torch.eye(N, device=x.device)
        degree = adj.sum(dim=1)
        degree_inv_sqrt = torch.pow(degree, -0.5)
        degree_inv_sqrt[torch.isinf(degree_inv_sqrt)] = 0
        degree_matrix = torch.diag(degree_inv_sqrt)
        normalized_adj = degree_matrix @ adj @ degree_matrix
        x = self.linear(x)
        x = normalized_adj @ x
        return x

图神经网络的性能评估

不同图神经网络模型的性能对比

模型 Cora分类准确率 Citeseer分类准确率 Pubmed分类准确率 计算复杂度
GCN 81.5% 70.3% 79.0% O(
GraphSAGE 80.1% 69.5% 77.3% O(
GAT 83.0% 72.5% 80.1% O(
Graph Autoencoder - - - O(

训练时间对比

模型 Cora数据集训练时间（秒） Citeseer数据集训练时间（秒） Pubmed数据集训练时间（秒）
GCN 10.2 15.6 25.8
GraphSAGE 12.5 18.3 29.4
GAT 18.7 25.2 38.6
Graph Autoencoder 14.3 20.1 31.2

图神经网络的应用场景

  1. 节点分类：预测图中节点的类别
  2. 链接预测：预测图中可能存在的边
  3. 图分类：预测整个图的类别
  4. 社区检测：识别图中的社区结构
  5. 推荐系统：基于用户-物品交互图进行推荐
  6. 分子属性预测：预测分子的物理化学性质

代码优化建议

  1. 性能优化：

    • 使用稀疏矩阵表示邻接矩阵，减少内存使用
    • 利用GPU加速计算
    • 实现批处理以处理大规模图

  2. 内存优化：

    • 使用采样技术处理大规模图
    • 采用小批量训练

  3. 效果优化：

    • 结合多种图神经网络模型
    • 使用注意力机制提高模型性能
    • 采用图数据增强技术

实践案例：节点分类

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeatures

# 加载数据集
dataset = Planetoid(root='./data', name='Cora', transform=NormalizeFeatures())
data = dataset[0]

# 定义GCN模型
class GCN(nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super(GCN, self).__init__()
        self.conv1 = nn.Linear(in_channels, hidden_channels)
        self.conv2 = nn.Linear(hidden_channels, out_channels)
    
    def forward(self, x, edge_index):
        # 构建邻接矩阵
        N = x.size(0)
        adj = torch.zeros((N, N), device=x.device)
        adj[edge_index[0], edge_index[1]] = 1
        
        # 添加自环
        adj = adj + torch.eye(N, device=x.device)
        
        # 计算度矩阵的逆平方根
        degree = adj.sum(dim=1)
        degree_inv_sqrt = torch.pow(degree, -0.5)
        degree_inv_sqrt[torch.isinf(degree_inv_sqrt)] = 0
        degree_matrix = torch.diag(degree_inv_sqrt)
        
        # 计算标准化的邻接矩阵
        normalized_adj = degree_matrix @ adj @ degree_matrix
        
        # 执行图卷积
        x = F.relu(normalized_adj @ self.conv1(x))
        x = normalized_adj @ self.conv2(x)
        
        return x

# 初始化模型、损失函数和优化器
model = GCN(dataset.num_node_features, 16, dataset.num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)

# 训练模型
def train():
    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.item()

# 测试模型
def test():
    model.eval()
    out = model(data.x, data.edge_index)
    pred = out.argmax(dim=1)
    
    # 计算不同掩码下的准确率
    train_correct = (pred[data.train_mask] == data.y[data.train_mask]).sum().item()
    train_acc = train_correct / data.train_mask.sum().item()
    
    val_correct = (pred[data.val_mask] == data.y[data.val_mask]).sum().item()
    val_acc = val_correct / data.val_mask.sum().item()
    
    test_correct = (pred[data.test_mask] == data.y[data.test_mask]).sum().item()
    test_acc = test_correct / data.test_mask.sum().item()
    
    return train_acc, val_acc, test_acc

# 训练循环
for epoch in range(200):
    loss = train()
    if epoch % 10 == 0:
        train_acc, val_acc, test_acc = test()
        print(f"Epoch {epoch}, Loss: {loss:.4f}, Train Acc: {train_acc:.4f}, Val Acc: {val_acc:.4f}, Test Acc: {test_acc:.4f}")

# 最终测试
_, _, test_acc = test()
print(f"Final Test Acc: {test_acc:.4f}")

结论

图神经网络是一类强大的深度学习模型，能够有效处理图结构数据，在多个领域取得了显著成果。本文介绍了几种常用的图神经网络模型，包括GCN、GraphSAGE、GAT和图自编码器，并提供了实践案例。

在实际应用中，我们应该根据具体任务的特点选择合适的图神经网络模型，并结合数据预处理、模型调优等技术，以获得最佳性能。同时，我们也需要关注模型的计算效率和内存使用，在性能和资源消耗之间找到适当的平衡。

通过不断探索和应用图神经网络技术，我们可以开发出更强大、更智能的系统，为各种图结构数据相关的应用场景提供更好的解决方案。

# flutter # harmonyos # 鸿蒙
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

从Java转行大模型应用，RAG使用效果评估及相关工具

1. 评估落地：优先用Ragas进行快速原型评估，量化核心质量指标与能力指标；用TruLens进行生产级全链路评估与监控，定位问题并迭代优化。2. 应用选型：个人/小团队入门用FastGPT，快速部署验证；企业级场景用RAGFlow或Dify，兼顾扩展性与协作需求；需高度自定义用纯代码开发（LangChain+评估工具）。3. 核心优化方向：围绕“上下文相关性、答案忠实度”优化检索策略（切片、向量

avatar AtomGit开源社区
cover

验证码终结者：基于YOLOv10与强化学习的滑块/点选验证码自动化破解方案

avatar AtomGit开源社区
cover

真事，小龙虾把库删了！我来背锅。

avatar AtomGit开源社区