### 图注意力网络（GAT）在 PyTorch 中的实现 图注意力网络（Graph Attention Networks, GATs）是一种特殊的图神经网络架构，旨在处理图结构化数据。该模型引入了自注意力机制来聚合节点特征，从而更好地捕捉局部邻域的信息。 #### 安装依赖库 为了使用 `PyTorch Geometric` 来构建 GAT 模型，首先需要安装必要的 Python 包： ```bash pip install torch torchvision torchaudio pytorch-lightning torch-scatter torch-sparse torch-cluster torch-spline-conv torch-geometric ``` #### 导入所需模块并定义超参数 接下来，在代码中导入所需的包，并设置一些基本配置项： ```python import os.path as osp from typing import Optional, Tuple import torch import torch.nn.functional as F from torch_sparse import SparseTensor from torch_geometric.datasets import Planetoid from torch_geometric.loader import DataLoader from torch_geometric.transforms import NormalizeFeatures from torch_geometric.nn.conv.gat_conv import GATConv # 引入GAT层[^1] dataset_name = 'Cora' path = osp.join('.', 'data', dataset_name) transform = NormalizeFeatures() dataset = Planetoid(path, dataset_name, transform=transform) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') hidden_channels = 8 num_heads = 8 dropout_rate = 0.6 learning_rate = 5e-3 weight_decay = 5e-4 epochs = 200 patience = 10 log_interval = 10 ``` #### 构建 GAT 层 这里展示如何创建一个多头图注意卷积层类 `GATLayer`: ```python class GATLayer(torch.nn.Module): def __init__(self, input_dim: int, output_dim: int, heads: int = 1, concat: bool = True, dropout: float = 0., add_self_loops: bool = True, edge_dim: Optional[int] = None, fill_value: Union[float, str] = 'mean', bias: bool = True, **kwargs) -> None: super().__init__() self.gat_layer = GATConv(in_channels=input_dim * heads if concat else input_dim, out_channels=output_dim, heads=heads, concat=concat, negative_slope=0.2, dropout=dropout, add_self_loops=add_self_loops, edge_dim=edge_dim, fill_value=fill_value, bias=bias) def forward(self, x: torch.Tensor, edge_index: Adj) -> torch.Tensor: return self.gat_layer(x=x, edge_index=edge_index) ``` #### 创建完整的 GAT 模型 现在可以组合多个 GAT 层形成整个网络架构： ```python class GATModel(torch.nn.Module): def __init__(self, num_features: int, hidden_channels: int, num_classes: int, num_layers: int = 2, head_per_layer: List[int] = [8, 1], activation=F.elu, dropout: float = 0.) -> None: super().__init__() layers = [] for i in range(num_layers): layer_input_dim = num_features if i == 0 else hidden_channels * head_per_layer[i - 1] gat_layer = GATLayer(input_dim=layer_input_dim, output_dim=hidden_channels, heads=head_per_layer[i], concat=(i != num_layers - 1), dropout=dropout) layers.append(gat_layer) if i < num_layers - 1: layers.append(lambda t: activation(t)) classifier_head = Linear(hidden_channels * head_per_layer[-2], num_classes).to(device) layers += [classifier_head] model_components = nn.Sequential(*layers[:-1]) final_linear = layers[-1] def forward_pass(data): features = data.x.to(device) adj_matrix = data.edge_index.to(device) h = model_components(features, adj_matrix) logits = final_linear(h) return logits setattr(GATModel, "forward", forward_pass) ``` #### 训练过程 最后一步是编写训练循环逻辑来进行模型拟合操作： ```python def train(model, optimizer, criterion, loader): model.train() total_loss = 0 correct_predictions = 0 for batch_data in loader: batch_data = batch_data.to(device) labels = batch_data.y.squeeze().long() optimizer.zero_grad() outputs = model(batch_data) loss = criterion(outputs[batch_data.train_mask], labels[batch_data.train_mask]) predictions = outputs.argmax(dim=-1) correct_predictions += (predictions.eq(labels)).sum().item() loss.backward() optimizer.step() total_loss += loss.item() avg_train_loss = total_loss / len(loader.dataset) accuracy = correct_predictions / sum([d.num_nodes for d in loader.dataset]) print(f'Training Loss: {avg_train_loss:.4f}, Accuracy: {accuracy*100:.2f}%') @torch.no_grad() def evaluate(model, loader, mask='val'): model.eval() all_preds = [] true_labels = [] for batch_data in loader: batch_data = batch_data.to(device) preds = model(batch_data).argmax(dim=-1) masks = getattr(batch_data, f'{mask}_mask').bool() filtered_preds = preds[masks].tolist() actuals = batch_data.y[masks].squeeze().tolist() all_preds.extend(filtered_preds) true_labels.extend(actuals) acc = sum(p == l for p,l in zip(all_preds,true_labels))/len(true_labels)*100. print(f"{mask.capitalize()} Set Accuracy: {acc:.2f}%") model = GATModel( num_features=dataset.num_node_features,