图机器学习（10）——监督学习中的图神经网络

1. 图卷积神经网络

在无监督图学习中，我们学习了图神经网络 (graph nerual network, GNN) 和图卷积网络 (graph convolutional network, GCN) 的核心原理，重点区分了谱图卷积与空间图卷积的差异。具体而言，我们深入理解了 GCN 层如何通过保持节点相似性等图属性，在无监督环境下实现图结构或节点的编码。
在本节中，将探索监督学习框架下的这些方法。此时的核心目标转变为：学习能够精准预测节点或图标签的图/节点表征。需要注意的是，编码函数保持不变，改变的是优化目标。

2. 使用 GCN 进行图分类

(1) 使用 PROTEINS 数据集：

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.data import DataLoader
from torch_geometric.nn import global_sort_pool, GCNConv
from torch_geometric.datasets import TUDataset
from sklearn.model_selection import train_test_split
import numpy as np# Load PROTEINS dataset
dataset = TUDataset(root='data/TUDataset', name='PROTEINS')

(2) 接下来，实现图分类 GCN 算法。构建 GCN 模型：

class DGCNN(nn.Module):def __init__(self, hidden_channels=32, num_layers=4, k=35):super(DGCNN, self).__init__()self.k = kself.convs = nn.ModuleList()for _ in range(num_layers):self.convs.append(GCNConv(-1, hidden_channels))# Corrected Conv1d layersself.conv1 = nn.Conv1d(hidden_channels * num_layers, 16, kernel_size=1)self.pool = nn.MaxPool1d(kernel_size=2)self.conv2 = nn.Conv1d(16, 32, kernel_size=5, stride=1)# Calculate the correct input size for the linear layer# After sort pooling: [batch_size, k * hidden_channels * num_layers]# After conv1: [batch_size, 16, k]# After pool: [batch_size, 16, k//2]# After conv2: [batch_size, 32, (k//2)-4]linear_input_size = 32 * ((k // 2) - 4)self.fc1 = nn.Linear(linear_input_size, 128)self.dropout = nn.Dropout(0.5)self.fc2 = nn.Linear(128, 1)def forward(self, x, edge_index, batch):xs = []for conv in self.convs:x = torch.tanh(conv(x, edge_index))xs.append(x)x = torch.cat(xs, dim=1)x = global_sort_pool(x, batch, self.k)  # [batch_size, k * hidden_channels * num_layers]# Reshape for Conv1d: [batch_size, channels, sequence_length]batch_size = len(torch.unique(batch))x = x.view(batch_size, self.k, -1)  # [batch_size, k, hidden_channels * num_layers]x = x.permute(0, 2, 1)  # [batch_size, hidden_channels * num_layers, k]x = F.relu(self.conv1(x))x = self.pool(x)x = F.relu(self.conv2(x))x = x.view(batch_size, -1)  # Flattenx = F.relu(self.fc1(x))x = self.dropout(x)x = torch.sigmoid(self.fc2(x))return x

(3) 实例化模型，使用二元交叉熵损失函数(用于衡量预测标签与真实标签之间的差异)，并使用 Adam 优化器，学习率为 0.0001：

model = DGCNN(hidden_channels=32, num_layers=4, k=35)
optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)
criterion = nn.BCELoss()device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)

(4) 创建训练集和测试集，在本节中，使用 70% 的数据集作为训练集，剩余的作为测试集：

train_idx, test_idx = train_test_split(range(len(dataset)), test_size=0.3, stratify=[data.y.item() for data in dataset],random_state=42
)train_dataset = dataset[train_idx]
test_dataset = dataset[test_idx]train_loader = DataLoader(train_dataset, batch_size=50, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False)

(5) 训练模型 100 个 epoch：

def train():model.train()total_loss = 0for data in train_loader:data = data.to(device)optimizer.zero_grad()out = model(data.x, data.edge_index, data.batch)loss = criterion(out, data.y.float().unsqueeze(1))loss.backward()optimizer.step()total_loss += loss.item() * data.num_graphsreturn total_loss / len(train_dataset)def test(loader):model.eval()correct = 0for data in loader:data = data.to(device)with torch.no_grad():pred = model(data.x, data.edge_index, data.batch)pred = (pred > 0.5).float()correct += int((pred == data.y.unsqueeze(1)).sum())return correct / len(loader.dataset)# Training loop
for epoch in range(1, 101):loss = train()train_acc = test(train_loader)test_acc = test(test_loader)print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}, Train Acc: {train_acc:.4f}, Test Acc: {test_acc:.4f}')

训练过程输出如下所示，可以看到在训练集上准确率可以达到 75%，在测试集上达到了约 74% 的准确率：

Epoch: 100, Loss: 0.4896, Train Acc: 0.7599, Test Acc: 0.7485

3. 使用 GraphSAGE 进行节点分类

(1) 接下来，我们将训练 GraphSAGE 来对 Cora 数据集的节点进行分类。首先加载数据集：

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.datasets import Planetoid
from torch_geometric.nn import SAGEConv
from sklearn.model_selection import train_test_split
import numpy as np# Load Cora dataset
dataset = Planetoid(root='data/Planetoid', name='Cora')
data = dataset[0]

(2) 拆分数据集，使用 90% 的数据集作为训练集，剩余部分作为测试集：

nodes = np.arange(data.num_nodes)
train_nodes, test_nodes = train_test_split(nodes, train_size=0.1, test_size=None, stratify=data.y.numpy()
)data.train_mask = torch.zeros(data.num_nodes, dtype=torch.bool)
data.train_mask[train_nodes] = True
data.test_mask = torch.zeros(data.num_nodes, dtype=torch.bool)
data.test_mask[test_nodes] = True

(3) 创建模型。在本节中，使用一个三层的 GraphSAGE 编码器，分别为 32、32 和 16 维度。然后，编码器将连接到一个具有 softmax 激活的全连接层来执行分类。使用学习率为 0.03 的 Adam 优化器，并将损失函数设置为categorical_crossentropy：

class GraphSAGE(nn.Module):def __init__(self, in_channels, hidden_channels, out_channels, num_layers, dropout):super(GraphSAGE, self).__init__()self.convs = nn.ModuleList()self.convs.append(SAGEConv(in_channels, hidden_channels))for _ in range(num_layers - 2):self.convs.append(SAGEConv(hidden_channels, hidden_channels))self.convs.append(SAGEConv(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)model = GraphSAGE(in_channels=dataset.num_features,hidden_channels=32,out_channels=dataset.num_classes,num_layers=3,dropout=0.6
)optimizer = torch.optim.Adam(model.parameters(), lr=0.003)
criterion = nn.NLLLoss()device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
data = data.to(device)

(4) 训练模型 20 个 epoch：

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()with torch.no_grad():out = model(data.x, data.edge_index)pred = out.argmax(dim=1)correct = (pred[data.test_mask] == data.y[data.test_mask]).sum()return correct / int(data.test_mask.sum())# Training loop
for epoch in range(1, 21):loss = train()test_acc = test()print(f'Epoch: {epoch:02d}, Loss: {loss:.4f}, Test Acc: {test_acc:.4f}')

训练过程输出如下所示，可以看到，模型在测试集上达到了约 80% 的准确率：