图神经网络（GNN）入门：用PyG库处理分子结构与社会网络

点击 “AladdinEdu，同学们用得起的【H卡】算力平台”，注册即送-H卡级别算力，沉浸式云原生的集成开发环境，80G大显存多卡并行，按量弹性计费，教育用户更享超低价。

---

引言：图数据的挑战与机遇

在现实世界中，许多复杂系统都可以用图结构来表示：社交网络中的用户关系、分子中的原子连接、论文引用网络、交通网络等。与传统网格数据（如图像）或序列数据（如文本）不同，图数据具有不规则的结构、复杂的拓扑关系和多维特征，这给传统机器学习方法带来了巨大挑战。

图神经网络（Graph Neural Networks, GNN）的出现革命性地改变了我们处理图数据的方式。通过借鉴卷积神经网络的思想并将其推广到图结构，GNN能够有效地学习节点表示、捕获图拓扑信息，并在各种图学习任务中取得突破性性能。

本文将全面介绍图神经网络的核心概念，重点讲解消息传递范式，并通过PyTorch Geometric（PyG）库实战演示GCN、GAT等经典模型在节点分类和链接预测任务中的应用。

一、图神经网络基础

1.1 图的基本概念

在图神经网络中，一个图通常表示为 $G=(V,E)$，其中：

• $V$ 是节点集合
• $E$ 是边集合
• $X$ 是节点特征矩阵
• $E$ 可能包含边特征

1.2 图神经网络的核心思想

GNN的核心思想是通过迭代地聚合邻居信息来更新节点表示。在每一层，节点从其邻居接收信息，并更新自己的表示。这个过程可以表示为：
hv(l+1)=f(hv(l),AGGREGATE({hu(l),∀u∈N(v)}))h_v^{(l+1)} = f\left(h_v^{(l)}, \text{AGGREGATE}\left(\{h_u^{(l)}, \forall u \in \mathcal{N}(v)\}\right)\right) hv(l+1)​=f(hv(l)​,AGGREGATE({hu(l)​,∀u∈N(v)}))

其中：

• $h_v^{(l)}$ 是节点 $v$ 在第 $l$ 层的表示
• $\mathcal{N}(v)$ 是节点 $v$ 的邻居集合
• AGGREGATE 是聚合函数
• $f$ 是更新函数

二、环境配置与PyG库安装

首先安装必要的库：

pip install torch torchvision torchaudio
pip install torch-scatter torch-sparse torch-cluster torch-spline-conv -f https://data.pyg.org/whl/torch-2.0.0+cpu.html
pip install torch-geometric

验证安装：

import torch
import torch_geometric
from torch_geometric.data import Data
from torch_geometric.nn import GCNConv, GATConv
from torch_geometric.datasets import Planetoid, TUDatasetprint("PyTorch版本:", torch.__version__)
print("PyG版本:", torch_geometric.__version__)

三、消息传递范式

消息传递是GNN的核心范式，包含三个主要步骤：

1. 消息生成：每个节点生成要发送给邻居的消息
2. 消息聚合：聚合来自邻居的消息
3. 节点更新：根据聚合的消息更新节点表示

3.1 消息传递的数学表达

$$x_i^{(k)}={\gamma }^{(k)}\left(x_i^{(k-1)},{\square }_{j\in \mathcal{N}(i)}{\varphi }^{(k)}\left(x_i^{(k-1)},x_j^{(k-1)},e_{j,i}\right)\right)$$

其中：

• $x_i^{(k)}$ 是节点 $i$ 在第 $k$ 层的特征
• $\square$ 是可微的聚合函数（如sum、mean、max）
• $\gamma$ 和 $\varphi$ 是可微函数（如MLP）
• $e_{j,i}$ 是边特征（可选）

3.2 实现自定义消息传递层

import torch
from torch_geometric.nn import MessagePassing
from torch_geometric.utils import add_self_loops, degreeclass CustomGNNLayer(MessagePassing):def __init__(self, in_channels, out_channels):super(CustomGNNLayer, self).__init__(aggr='add')  # 使用sum聚合self.lin = torch.nn.Linear(in_channels, out_channels)self.update_mlp = torch.nn.Sequential(torch.nn.Linear(out_channels + in_channels, out_channels),torch.nn.ReLU(),torch.nn.Linear(out_channels, out_channels))def forward(self, x, edge_index):# 添加自环edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0))# 线性变换x = self.lin(x)# 开始消息传递return self.propagate(edge_index, x=x)def message(self, x_j):# 消息生成：直接使用邻居的特征return x_jdef update(self, aggr_out, x):# 节点更新：结合自身特征和聚合结果new_x = torch.cat([x, aggr_out], dim=1)return self.update_mlp(new_x)# 测试自定义层
def test_custom_layer():# 创建简单图数据：4个节点，4条边edge_index = torch.tensor([[0, 1, 1, 2, 2, 3], [1, 0, 2, 1, 3, 2]], dtype=torch.long)x = torch.tensor([[1.0], [2.0], [3.0], [4.0]], dtype=torch.float)layer = CustomGNNLayer(1, 2)output = layer(x, edge_index)print("输入特征:", x.squeeze().tolist())print("输出特征:", output.tolist())print("输出形状:", output.shape)test_custom_layer()

四、图卷积网络（GCN）

4.1 GCN原理

GCN通过谱图理论将卷积操作推广到图数据。其核心思想是使用归一化的邻接矩阵来聚合邻居信息：

$$H^{(l+1)}=\sigma \left({\tilde{D}}^{-\frac{1}{2}}\tilde{A}{\tilde{D}}^{-\frac{1}{2}}{H}^{(l)}{W}^{(l)}\right)$$

其中：

• $\tilde{A}=A+I$ 是添加自环的邻接矩阵
• $\tilde{D}$ 是 $\tilde{A}$ 的度矩阵
• $W^{(l)}$ 是可学习的权重矩阵
• $\sigma$ 是激活函数

4.2 PyG实现GCN

import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.nn import GCNConvclass GCN(nn.Module):def __init__(self, in_channels, hidden_channels, out_channels, num_layers=2, dropout=0.5):super(GCN, self).__init__()self.convs = nn.ModuleList()self.convs.append(GCNConv(in_channels, hidden_channels))for _ in range(num_layers - 2):self.convs.append(GCNConv(hidden_channels, hidden_channels))self.convs.append(GCNConv(hidden_channels, out_channels))self.dropout = dropoutdef forward(self, x, edge_index):for i, conv in enumerate(self.convs[:-1]):x = conv(x, edge_index)x = F.relu(x)x = F.dropout(x, p=self.dropout, training=self.training)x = self.convs[-1](x, edge_index)return F.log_softmax(x, dim=1)# 测试GCN模型
def test_gcn():# 使用Cora数据集dataset = Planetoid(root='/tmp/Cora', name='Cora')data = dataset[0]print("数据集信息:")print(f"节点数: {data.num_nodes}")print(f"边数: {data.num_edges}")print(f"特征维度: {data.num_features}")print(f"类别数: {dataset.num_classes}")print(f"训练节点数: {data.train_mask.sum().item()}")print(f"测试节点数: {data.test_mask.sum().item()}")# 创建GCN模型model = GCN(in_channels=dataset.num_features,hidden_channels=16,out_channels=dataset.num_classes)# 前向传播output = model(data.x, data.edge_index)print(f"输出形状: {output.shape}")return model, datamodel, data = test_gcn()

五、图注意力网络（GAT）

5.1 GAT原理

GAT引入了注意力机制，允许节点为不同的邻居分配不同的重要性权重：

$$h_i^{(l+1)}=\sigma \left(\sum _{j\in \mathcal{N}(i)}{\alpha }_{ij}{W}^{(l)}{h}_j^{(l)}\right)$$

注意力系数 ${\alpha }_{ij}$ 的计算：

$${\alpha }_{ij}=\frac{\exp \left(\text{LeakyReLU}\left(a^T[W{h}_i\Vert W{h}_j]\right)\right)}{{\sum }_{k\in \mathcal{N}(i)}\exp \left(\text{LeakyReLU}\left(a^T[W{h}_i\Vert W{h}_k]\right)\right)}$$

5.2 PyG实现GAT

from torch_geometric.nn import GATConvclass GAT(nn.Module):def __init__(self, in_channels, hidden_channels, out_channels, num_heads=8, dropout=0.6):super(GAT, self).__init__()self.dropout = dropout# 第一层：多注意力头self.conv1 = GATConv(in_channels, hidden_channels, heads=num_heads, dropout=dropout)# 第二层：单注意力头self.conv2 = GATConv(hidden_channels * num_heads, out_channels, heads=1, concat=False, dropout=dropout)def forward(self, x, edge_index):x = F.dropout(x, p=self.dropout, training=self.training)x = F.elu(self.conv1(x, edge_index))x = F.dropout(x, p=self.dropout, training=self.training)x = self.conv2(x, edge_index)return F.log_softmax(x, dim=1)# 测试GAT模型
def test_gat():dataset = Planetoid(root='/tmp/Cora', name='Cora')data = dataset[0]model = GAT(in_channels=dataset.num_features,hidden_channels=8,out_channels=dataset.num_classes,num_heads=8)output = model(data.x, data.edge_index)print(f"GAT输出形状: {output.shape}")return model, datagat_model, data = test_gat()

六、节点分类实战

6.1 训练与评估函数

def train_node_classification(model, data, optimizer, criterion, epochs=200):model.train()train_losses = []val_accuracies = []for epoch in range(epochs):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()# 验证model.eval()with torch.no_grad():pred = model(data.x, data.edge_index).argmax(dim=1)correct = (pred[data.val_mask] == data.y[data.val_mask]).sum()val_acc = correct / data.val_mask.sum()val_accuracies.append(val_acc.item())train_losses.append(loss.item())if epoch % 50 == 0:print(f'Epoch {epoch:03d}, Loss: {loss:.4f}, Val Acc: {val_acc:.4f}')return train_losses, val_accuraciesdef evaluate_node_classification(model, data):model.eval()with torch.no_grad():pred = model(data.x, data.edge_index).argmax(dim=1)correct = (pred[data.test_mask] == data.y[data.test_mask]).sum()test_acc = correct / data.test_mask.sum()print(f'Test Accuracy: {test_acc:.4f}')return test_acc.item()# 比较GCN和GAT性能
def compare_models():dataset = Planetoid(root='/tmp/Cora', name='Cora')data = dataset[0]# GCN训练gcn_model = GCN(dataset.num_features, 16, dataset.num_classes)gcn_optimizer = torch.optim.Adam(gcn_model.parameters(), lr=0.01, weight_decay=5e-4)gcn_criterion = nn.NLLLoss()print("训练GCN模型...")gcn_losses, gcn_accs = train_node_classification(gcn_model, data, gcn_optimizer, gcn_criterion)gcn_test_acc = evaluate_node_classification(gcn_model, data)# GAT训练gat_model = GAT(dataset.num_features, 8, dataset.num_classes)gat_optimizer = torch.optim.Adam(gat_model.parameters(), lr=0.005, weight_decay=5e-4)gat_criterion = nn.NLLLoss()print("\n训练GAT模型...")gat_losses, gat_accs = train_node_classification(gat_model, data, gat_optimizer, gat_criterion)gat_test_acc = evaluate_node_classification(gat_model, data)# 绘制结果import matplotlib.pyplot as pltplt.figure(figsize=(12, 5))plt.subplot(1, 2, 1)plt.plot(gcn_losses, label='GCN')plt.plot(gat_losses, label='GAT')plt.xlabel('Epoch')plt.ylabel('Loss')plt.title('Training Loss')plt.legend()plt.subplot(1, 2, 2)plt.plot(gcn_accs, label='GCN')plt.plot(gat_accs, label='GAT')plt.xlabel('Epoch')plt.ylabel('Validation Accuracy')plt.title('Validation Accuracy')plt.legend()plt.tight_layout()plt.show()return gcn_test_acc, gat_test_accgcn_acc, gat_acc = compare_models()

七、链接预测实战

7.1 链接预测任务介绍

链接预测旨在预测图中缺失的边或未来可能出现的边。常用方法包括：

1. 基于节点表示的相似度计算
2. 专门的链接预测模型

7.2 负采样与数据准备

from torch_geometric.utils import negative_samplingdef prepare_link_prediction_data(data, val_ratio=0.05, test_ratio=0.1):# 获取所有边edge_index = data.edge_indexnum_nodes = data.num_nodesnum_edges = edge_index.size(1)# 划分正样本perm = torch.randperm(num_edges)val_size = int(num_edges * val_ratio)test_size = int(num_edges * test_ratio)train_size = num_edges - val_size - test_sizetrain_edges = edge_index[:, perm[:train_size]]val_edges = edge_index[:, perm[train_size:train_size+val_size]]test_edges = edge_index[:, perm[train_size+val_size:]]# 生成负样本train_neg_edges = negative_sampling(edge_index, num_neg_samples=train_size, num_nodes=num_nodes)val_neg_edges = negative_sampling(edge_index, num_neg_samples=val_size, num_nodes=num_nodes)test_neg_edges = negative_sampling(edge_index, num_neg_samples=test_size, num_nodes=num_nodes)# 创建数据对象link_data = {'train_edges': train_edges,'train_neg_edges': train_neg_edges,'val_edges': val_edges,'val_neg_edges': val_neg_edges,'test_edges': test_edges,'test_neg_edges': test_neg_edges,'num_nodes': num_nodes}return link_data# 准备链接预测数据
link_data = prepare_link_prediction_data(data)
print("链接预测数据准备完成")
print(f"训练正样本: {link_data['train_edges'].shape[1]}条边")
print(f"训练负样本: {link_data['train_neg_edges'].shape[1]}条边")

7.3 链接预测模型

class LinkPredictionModel(nn.Module):def __init__(self, encoder, hidden_channels, out_channels):super(LinkPredictionModel, self).__init__()self.encoder = encoderself.lin = nn.Linear(2 * hidden_channels, out_channels)self.decode = nn.Linear(out_channels, 1)def encode(self, x, edge_index):return self.encoder(x, edge_index)def decode_edge(self, z, edge_index):# 获取源节点和目标节点的表示src = z[edge_index[0]]dst = z[edge_index[1]]# 拼接特征并预测edge_rep = torch.cat([src, dst], dim=1)edge_rep = F.relu(self.lin(edge_rep))return torch.sigmoid(self.decode(edge_rep)).squeeze()def forward(self, x, edge_index, pos_edges, neg_edges):z = self.encode(x, edge_index)pos_pred = self.decode_edge(z, pos_edges)neg_pred = self.decode_edge(z, neg_edges)return pos_pred, neg_preddef train_link_prediction(model, data, link_data, optimizer, criterion, epochs=100):model.train()train_losses = []val_aucs = []for epoch in range(epochs):optimizer.zero_grad()# 前向传播pos_pred, neg_pred = model(data.x, data.edge_index, link_data['train_edges'], link_data['train_neg_edges'])# 计算损失pos_loss = criterion(pos_pred, torch.ones_like(pos_pred))neg_loss = criterion(neg_pred, torch.zeros_like(neg_pred))loss = pos_loss + neg_lossloss.backward()optimizer.step()# 验证model.eval()with torch.no_grad():val_pos_pred, val_neg_pred = model(data.x, data.edge_index,link_data['val_edges'],link_data['val_neg_edges'])val_auc = calculate_auc(val_pos_pred, val_neg_pred)val_aucs.append(val_auc)train_losses.append(loss.item())if epoch % 20 == 0:print(f'Epoch {epoch:03d}, Loss: {loss:.4f}, Val AUC: {val_auc:.4f}')return train_losses, val_aucsdef calculate_auc(pos_pred, neg_pred):from sklearn.metrics import roc_auc_scorepreds = torch.cat([pos_pred, neg_pred]).cpu().numpy()labels = torch.cat([torch.ones_like(pos_pred), torch.zeros_like(neg_pred)]).cpu().numpy()return roc_auc_score(labels, preds)# 训练链接预测模型
def run_link_prediction():dataset = Planetoid(root='/tmp/Cora', name='Cora')data = dataset[0]link_data = prepare_link_prediction_data(data)# 创建编码器（GCN）encoder = GCN(dataset.num_features, 16, 16, num_layers=2)model = LinkPredictionModel(encoder, 16, 16)optimizer = torch.optim.Adam(model.parameters(), lr=0.01)criterion = nn.BCELoss()print("训练链接预测模型...")losses, aucs = train_link_prediction(model, data, link_data, optimizer, criterion, epochs=100)# 测试model.eval()with torch.no_grad():test_pos_pred, test_neg_pred = model(data.x, data.edge_index,link_data['test_edges'],link_data['test_neg_edges'])test_auc = calculate_auc(test_pos_pred, test_neg_pred)print(f'Test AUC: {test_auc:.4f}')# 绘制结果plt.figure(figsize=(12, 5))plt.subplot(1, 2, 1)plt.plot(losses)plt.xlabel('Epoch')plt.ylabel('Loss')plt.title('Training Loss')plt.subplot(1, 2, 2)plt.plot(aucs)plt.xlabel('Epoch')plt.ylabel('AUC')plt.title('Validation AUC')plt.tight_layout()plt.show()return test_auclink_auc = run_link_prediction()

八、分子图处理实战

8.1 分子图数据集

from torch_geometric.datasets import TUDataset
from torch_geometric.loader import DataLoaderdef explore_molecule_dataset():# 加载分子数据集（如HIV病毒抑制活性预测）dataset = TUDataset(root='/tmp/HIV', name='HIV')print(f"数据集: {dataset}")print(f"图数量: {len(dataset)}")print(f"类别数: {dataset.num_classes}")print(f"节点特征数: {dataset.num_node_features}")print(f"边特征数: {dataset.num_edge_features}")# 查看第一个图data = dataset[0]print(f"\n第一个图的信息:")print(f"节点数: {data.num_nodes}")print(f"边数: {data.num_edges}")print(f"节点特征形状: {data.x.shape}")print(f"边特征形状: {data.edge_attr.shape if hasattr(data, 'edge_attr') else '无'}")print(f"图标签: {data.y}")return datasetmolecule_dataset = explore_molecule_dataset()

8.2 分子图分类模型

from torch_geometric.nn import global_mean_pool, global_add_poolclass MolecularGNN(nn.Module):def __init__(self, in_channels, hidden_channels, out_channels, edge_dim=None):super(MolecularGNN, self).__init__()# 使用GIN卷积（适合分子图）self.conv1 = GINConv(nn.Sequential(nn.Linear(in_channels, hidden_channels),nn.ReLU(),nn.Linear(hidden_channels, hidden_channels)))self.conv2 = GINConv(nn.Sequential(nn.Linear(hidden_channels, hidden_channels),nn.ReLU(),nn.Linear(hidden_channels, hidden_channels)))self.conv3 = GINConv(nn.Sequential(nn.Linear(hidden_channels, hidden_channels),nn.ReLU(),nn.Linear(hidden_channels, hidden_channels)))self.lin = nn.Linear(hidden_channels, out_channels)def forward(self, x, edge_index, batch, edge_attr=None):# 节点特征学习x = F.relu(self.conv1(x, edge_index))x = F.relu(self.conv2(x, edge_index))x = F.relu(self.conv3(x, edge_index))# 全局池化x = global_mean_pool(x, batch)# 分类x = F.dropout(x, p=0.5, training=self.training)return F.log_softmax(self.lin(x), dim=-1)def train_molecular_gnn():dataset = TUDataset(root='/tmp/HIV', name='HIV')# 划分训练测试集torch.manual_seed(42)dataset = dataset.shuffle()train_dataset = dataset[:len(dataset) * 8 // 10]test_dataset = dataset[len(dataset) * 8 // 10:]train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)# 创建模型model = MolecularGNN(in_channels=dataset.num_node_features,hidden_channels=64,out_channels=dataset.num_classes)optimizer = torch.optim.Adam(model.parameters(), lr=0.01)criterion = nn.NLLLoss()# 训练train_losses = []test_accuracies = []for epoch in range(100):model.train()total_loss = 0for data in train_loader:optimizer.zero_grad()out = model(data.x, data.edge_index, data.batch)loss = criterion(out, data.y)loss.backward()optimizer.step()total_loss += loss.item()avg_loss = total_loss / len(train_loader)train_losses.append(avg_loss)# 测试model.eval()correct = 0total = 0with torch.no_grad():for data in test_loader:out = model(data.x, data.edge_index, data.batch)pred = out.argmax(dim=1)correct += (pred == data.y).sum().item()total += data.y.size(0)test_acc = correct / totaltest_accuracies.append(test_acc)if epoch % 10 == 0:print(f'Epoch {epoch:03d}, Loss: {avg_loss:.4f}, Test Acc: {test_acc:.4f}')# 绘制结果plt.figure(figsize=(12, 5))plt.subplot(1, 2, 1)plt.plot(train_losses)plt.xlabel('Epoch')plt.ylabel('Loss')plt.title('Training Loss')plt.subplot(1, 2, 2)plt.plot(test_accuracies)plt.xlabel('Epoch')plt.ylabel('Accuracy')plt.title('Test Accuracy')plt.tight_layout()plt.show()return test_accuracies[-1]mol_acc = train_molecular_gnn()

九、社会网络分析实战

9.1 社交网络数据集处理

def analyze_social_network():# 使用Facebook Page-Page数据集from torch_geometric.datasets import FacebookPagePagedataset = FacebookPagePage(root='/tmp/Facebook')data = dataset[0]print("社交网络数据集信息:")print(f"节点数: {data.num_nodes}")print(f"边数: {data.num_edges}")print(f"节点特征数: {data.num_features}")print(f"类别数: {data.y.max().item() + 1}")print(f"训练/验证/测试掩码: {data.train_mask.sum().item()}/{data.val_mask.sum().item()}/{data.test_mask.sum().item()}")# 可视化节点嵌入（使用PCA降维）from sklearn.decomposition import PCApca = PCA(n_components=2)embeddings_2d = pca.fit_transform(data.x.numpy())plt.figure(figsize=(10, 8))scatter = plt.scatter(embeddings_2d[:, 0], embeddings_2d[:, 1], c=data.y.numpy(), cmap='viridis', alpha=0.7)plt.colorbar(scatter)plt.title('Social Network Node Embeddings (PCA)')plt.xlabel('PC1')plt.ylabel('PC2')plt.show()return datasocial_data = analyze_social_network()

9.2 社区检测与可视化

def community_detection():import networkx as nxfrom torch_geometric.utils import to_networkx# 转换为NetworkX图G = to_networkx(data, to_undirected=True)# 使用Louvain算法进行社区检测import community as community_louvainpartition = community_louvain.best_partition(G)# 可视化plt.figure(figsize=(12, 10))pos = nx.spring_layout(G, seed=42)# 绘制节点（按社区着色）cmap = plt.cm.tab20nodes = nx.draw_networkx_nodes(G, pos, node_color=list(partition.values()),cmap=cmap, node_size=50,alpha=0.8)# 绘制边nx.draw_networkx_edges(G, pos, alpha=0.2)plt.colorbar(nodes)plt.title('Social Network Community Detection')plt.axis('off')plt.show()# 分析社区结构from collections import Countercommunity_sizes = Counter(partition.values())print(f"检测到 {len(community_sizes)} 个社区")print("社区大小分布:", community_sizes.most_common(10))community_detection()

十、高级技巧与最佳实践

10.1 图预处理技巧

def graph_preprocessing_techniques():from torch_geometric.transforms import NormalizeFeatures, AddSelfLoops, ToUndirected# 特征标准化transform1 = NormalizeFeatures()# 添加自环transform2 = AddSelfLoops()# 转换为无向图transform3 = ToUndirected()# 组合变换from torch_geometric.transforms import Composetransform = Compose([NormalizeFeatures(), AddSelfLoops(), ToUndirected()])# 应用变换dataset = Planetoid(root='/tmp/Cora', name='Cora', transform=transform)data = dataset[0]print("预处理后的图数据:")print(f"节点特征范围: [{data.x.min().item():.3f}, {data.x.max().item():.3f}]")print(f"边数（含自环）: {data.edge_index.shape[1]}")return datapreprocessed_data = graph_preprocessing_techniques()

10.2 模型优化策略

def advanced_training_strategies():# 学习率调度from torch.optim.lr_scheduler import ReduceLROnPlateaudataset = Planetoid(root='/tmp/Cora', name='Cora')data = dataset[0]model = GCN(dataset.num_features, 16, dataset.num_classes)optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)scheduler = ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=10, verbose=True)criterion = nn.NLLLoss()best_val_acc = 0patience_counter = 0patience = 20for epoch in range(200):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()# 验证model.eval()with torch.no_grad():pred = model(data.x, data.edge_index).argmax(dim=1)val_acc = (pred[data.val_mask] == data.y[data.val_mask]).sum() / data.val_mask.sum()# 学习率调度scheduler.step(val_acc)# 早停if val_acc > best_val_acc:best_val_acc = val_accpatience_counter = 0# 保存最佳模型torch.save(model.state_dict(), 'best_model.pth')else:patience_counter += 1if patience_counter >= patience:print(f'Early stopping at epoch {epoch}')breakif epoch % 20 == 0:print(f'Epoch {epoch:03d}, Loss: {loss:.4f}, Val Acc: {val_acc:.4f}')# 加载最佳模型model.load_state_dict(torch.load('best_model.pth'))return modelbest_model = advanced_training_strategies()

十一、总结与展望

11.1 关键技术总结

通过本文的详细讲解和实践，我们掌握了：

1. 消息传递范式：GNN的核心机制，通过聚合邻居信息更新节点表示
2. GCN：基于谱图理论的图卷积网络，适合各种图学习任务
3. GAT：引入注意力机制的图网络，能够为不同邻居分配不同权重
4. 节点分类：预测图中节点的类别标签
5. 链接预测：预测图中缺失或未来可能出现的边
6. 分子图处理：处理化学分子结构数据
7. 社会网络分析：分析社交网络中的社区结构和节点关系

11.2 实践建议

1. 数据预处理：总是对节点特征进行标准化，考虑添加自环和转换为无向图
2. 模型选择：
   • 对于同质图（节点类型单一），GCN通常是不错的选择
   • 对于异质图或需要关注特定邻居的任务，考虑GAT
   • 对于分子图，GIN通常表现更好
3. 训练技巧：
   • 使用学习率调度和早停策略
   • 适当使用Dropout防止过拟合
   • 监控训练和验证性能，避免过拟合

11.3 未来发展方向

图神经网络领域仍在快速发展，未来方向包括：

1. 可扩展GNN：处理超大规模图数据
2. 动态图神经网络：处理随时间变化的图数据
3. 异质图神经网络：处理包含多种节点和边类型的图
4. 图生成模型：生成新的图结构
5. 图解释性：理解和解释GNN的决策过程

通过掌握本文介绍的核心概念和实践技巧，您已经具备了使用PyG库处理各种图数据任务的能力。无论是分子结构分析还是社会网络挖掘，图神经网络都提供了强大的工具来从复杂的图数据中提取有价值的信息。

---

点击 “AladdinEdu，同学们用得起的【H卡】算力平台”，注册即送-H卡级别算力，沉浸式云原生的集成开发环境，80G大显存多卡并行，按量弹性计费，教育用户更享超低价。