Pytorch+PyG实现GIN过程示例详解

下面是关于“Pytorch+PyG实现GIN过程示例详解”的完整攻略。

GIN简介

GIN（Graph Isomorphism Network）是一种基于图同构的神经网络模型，它可以对任意形状的图进行分类、回归和聚类等任务。GIN模型的核心思想是将每个节点的特征向量与其邻居节点的特征向量进行聚合，然后将聚合后的特征向量作为节点的新特征向量。GIN模型可以通过堆叠多个GIN层来构建深度神经网络。

Pytorch+PyG实现GIN过程示例

示例1：使用PyG实现GIN模型

我们将使用PyG（PyTorch Geometric）库来实现GIN模型。PyG是一个基于PyTorch的几何深度学习库，它提供了一组用于处理图形数据的工具和模型。我们将使用PyG中的torch_geometric.nn模块来实现GIN模型。下面是一个示例：

import torch
import torch.nn.functional as F
from torch_geometric.nn import MessagePassing
from torch_geometric.utils import add_self_loops, degree

# 定义GIN层
class GINConv(MessagePassing):
    def __init__(self, emb_dim):
        super(GINConv, self).__init__(aggr='add')
        self.mlp = torch.nn.Sequential(torch.nn.Linear(emb_dim, 2 * emb_dim),
                                        torch.nn.BatchNorm1d(2 * emb_dim),
                                        torch.nn.ReLU(),
                                        torch.nn.Linear(2 * emb_dim, emb_dim),
                                        torch.nn.BatchNorm1d(emb_dim),
                                        torch.nn.ReLU())

    def forward(self, x, edge_index):
        edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0))
        row, col = edge_index
        deg = degree(col, x.size(0), dtype=x.dtype)
        deg_inv_sqrt = deg.pow(-0.5)
        norm = deg_inv_sqrt[row] * deg_inv_sqrt[col]

        x = self.mlp((1 + norm) * x)
        return x

# 定义GIN模型
class GIN(torch.nn.Module):
    def __init__(self, emb_dim, num_classes):
        super(GIN, self).__init__()
        self.conv1 = GINConv(emb_dim)
        self.conv2 = GINConv(emb_dim)
        self.fc = torch.nn.Linear(emb_dim, num_classes)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.conv2(x, edge_index)
        x = F.relu(x)
        x = global_add_pool(x, edge_index)
        x = self.fc(x)
        return F.log_softmax(x, dim=1)

在这个示例中，我们首先定义了一个名为GINConv的GIN层。该层包含一个多层感知机（MLP）和一个图消息传递函数。在forward方法中，我们首先使用add_self_loops函数将自环添加到边缘索引中，然后使用degree函数计算每个节点的度数。接下来，我们计算每个节点的归一化因子，并使用它来聚合每个节点的邻居节点的特征向量。最后，我们使用MLP对聚合后的特征向量进行非线性变换，并返回新的特征向量。

然后，我们定义了一个名为GIN的GIN模型。该模型包含两个GIN层和一个全连接层。在forward方法中，我们首先使用第一个GIN层对节点特征向量进行聚合，并使用ReLU函数进行非线性变换。然后，我们使用第二个GIN层对特征向量进行聚合，并再次使用ReLU函数进行非线性变换。接下来，我们使用global_add_pool函数对所有节点的特征向量进行汇总，并使用全连接层将其映射到类别概率。最后，我们使用F.log_softmax函数将输出转换为概率。

示例2：使用PyG实现GIN模型进行节点分类

我们将使用Cora数据集来演示如何使用PyG实现GIN模型进行节点分类。Cora数据集是一个引文网络数据集，其中每个节点表示一篇论文，每个边表示两篇论文之间的引用关系。每个节点都有一个特征向量，表示论文的词袋表示。我们的目标是预测每篇论文的类别。下面是一个示例：

from torch_geometric.datasets import Planetoid
from torch_geometric.nn import global_add_pool
from torch_geometric.utils import train_test_split_edges

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

# 划分训练集、验证集和测试集
data.train_mask = data.val_mask = data.test_mask = data.y = None
data = train_test_split_edges(data)
data.train_mask = data.val_mask = data.test_mask = None
data.y = data.y.squeeze()

# 定义模型和优化器
model = GIN(emb_dim=16, num_classes=dataset.num_classes)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 训练模型
model.train()
for epoch in range(200):
    optimizer.zero_grad()
    out = model(data.x, data.edge_index)
    loss = F.nll_loss(out[data.train_pos_edge_index], data.train_y)
    loss.backward()
    optimizer.step()

    # 在验证集上评估模型
    model.eval()
    with torch.no_grad():
        out = model(data.x, data.edge_index)
        val_loss = F.nll_loss(out[data.val_pos_edge_index], data.val_y)
        val_acc = accuracy(out[data.val_pos_edge_index], data.val_y)

    print('Epoch: {:03d}, Loss: {:.4f}, Val Loss: {:.4f}, Val Acc: {:.4f}'.format(
        epoch, loss.item(), val_loss.item(), val_acc.item()))

# 在测试集上评估模型
model.eval()
with torch.no_grad():
    out = model(data.x, data.edge_index)
    test_loss = F.nll_loss(out[data.test_pos_edge_index], data.test_y)
    test_acc = accuracy(out[data.test_pos_edge_index], data.test_y)

print('Test Loss: {:.4f}, Test Acc: {:.4f}'.format(test_loss.item(), test_acc.item()))

在这个示例中，我们首先使用Planetoid类加载Cora数据集，并使用train_test_split_edges函数将数据集划分为训练集、验证集和测试集。然后，我们定义了一个名为model的GIN模型，并使用Adam优化器进行训练。在每个时期中，我们首先使用optimizer.zero_grad()方法除梯度，然后使用模型对训练数据进行预测，并使用F.nll_loss函数计算损失。接下来，我们使用模型对验证数据进行预测，并计算验证损失和准确率。最后，我们打印出每个时期的损失、验证损失和验证准确率。

在训练结束后，我们使用模型对测试数据进行预测，并计算测试损失和准确率。最后，我们打印出测试损失和测试准确率。