【PYG】GNN和全连接层（FC）分别在不同的类中，使用反向传播联合训练，实现端到端的训练过程

文章目录

- 基本步骤
- GNN和全连接层（FC）联合训练
- - 1. 定义GNN模型类
  - 2. 定义FC模型类
  - 3. 训练循环中的联合优化
  - 解释
  - 完整代码
- GNN和全连接层（FC）分别使用不同的优化器和学习率分别进行参数更新
- - 解释

基本步骤

要从GNN（图神经网络）中提取特征，并使用全连接层（FC，Fully Connected Layer）进行后续处理，可以按照以下步骤进行：

构建图神经网络模型：选择一种GNN架构，例如GCN（Graph Convolutional Network）、GAT（Graph Attention Network）等。你可以使用深度学习框架（如PyTorch、TensorFlow）来实现。
获取节点特征和图结构：准备好节点特征矩阵和邻接矩阵，这些是GNN模型的输入。
通过GNN提取特征：
- 设计GNN模型的前向传播过程，将节点特征和邻接矩阵输入GNN层。
- 从GNN层的输出中提取节点的嵌入特征。
连接全连接层进行分类或回归：
- 将GNN提取的节点特征作为输入传递给一个或多个全连接层。
- 通过全连接层进行后续的分类、回归等任务。

GNN和全连接层（FC）联合训练

如果GNN和全连接层（FC）分别在不同的类中，并且你希望它们可以联合训练，你可以通过以下步骤实现端到端的训练过程，并确保反向传播能够正确进行：

定义GNN和FC模型：分别定义GNN和FC模型类。
特征提取与分类：在训练循环中，将GNN提取的特征传递给FC进行分类。
联合优化：使用一个优化器来更新两个模型的参数。

以下是具体的实现步骤和代码示例：

1. 定义GNN模型类

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
from torch_geometric.data import Data, Batch
from sklearn.preprocessing import StandardScaler

class GNN(nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super(GNN, self).__init__()
        self.conv1 = GCNConv(in_channels, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, out_channels)

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.conv2(x, edge_index)
        gnn_features = F.relu(x)
        return gnn_features

2. 定义FC模型类

class FC(nn.Module):
    def __init__(self, in_features, num_classes):
        super(FC, self).__init__()
        self.fc = nn.Linear(in_features, num_classes)

    def forward(self, x):
        out = self.fc(x)
        return out

3. 训练循环中的联合优化

# 假设我们有一些数据
num_nodes_per_graph = 10
num_graphs = 5
num_node_features = 16
num_classes = 3

# 创建多个图数据
graphs = []
for _ in range(num_graphs):
    x = torch.randn((num_nodes_per_graph, num_node_features))
    scaler = StandardScaler()
    x = torch.tensor(scaler.fit_transform(x), dtype=torch.float)  # 标准化
    edge_index = torch_geometric.utils.grid(num_nodes_per_graph)
    graphs.append(Data(x=x, edge_index=edge_index))

# 批处理数据
batch = Batch.from_data_list(graphs)

# 创建模型
gnn_model = GNN(in_channels=num_node_features, hidden_channels=32, out_channels=64)
fc_model = FC(in_features=64, num_classes=num_classes)

# 使用一个优化器来联合优化两个模型的参数
optimizer = torch.optim.Adam(list(gnn_model.parameters()) + list(fc_model.parameters()), lr=1e-4)
criterion = nn.CrossEntropyLoss()

# 生成一些随机目标
target = torch.randint(0, num_classes, (num_nodes_per_graph * num_graphs,))

# 训练模型
for epoch in range(100):
    gnn_model.train()
    fc_model.train()
    
    optimizer.zero_grad()
    
    # 前向传播通过GNN模型
    gnn_features = gnn_model(batch)
    
    # 前向传播通过FC模型
    output = fc_model(gnn_features)
    
    # 计算损失
    loss = criterion(output, target)
    
    # 反向传播
    loss.backward()
    
    # 优化器步
    optimizer.step()
    
    print(f'Epoch {epoch+1}, Loss: {loss.item()}')

# 查看特征
print("Extracted GNN features:", gnn_features)

解释

GNN模型类：GNN类定义了一个简单的两层GCN模型，用于特征提取。
FC模型类：FC类定义了一个全连接层模型，用于分类。
联合优化：
- 在训练循环中，首先通过GNN模型提取特征，然后将提取的特征传递给FC模型进行分类。
- 使用一个优化器来同时优化GNN和FC模型的参数。
- 通过调用optimizer.zero_grad()清除梯度，调用loss.backward()进行反向传播，最后调用optimizer.step()更新参数。

通过这种方式，尽管GNN和FC模型分别在不同的类中，它们仍然可以端到端地进行联合训练，并确保梯度正确地传播到整个模型的每一部分。

使用正确的参数来生成随机图。torch_geometric.utils.erdos_renyi_graph需要使用num_nodes和edge_prob参数

完整代码

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.data import Data, Batch
from torch_geometric.nn import GCNConv
from torch_geometric.utils import erdos_renyi_graph
from sklearn.preprocessing import StandardScaler

class GNN(nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super(GNN, self).__init__()
        self.conv1 = GCNConv(in_channels, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, out_channels)

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.conv2(x, edge_index)
        gnn_features = F.relu(x)
        return gnn_features

class FC(nn.Module):
    def __init__(self, in_features, num_classes):
        super(FC, self).__init__()
        self.fc = nn.Linear(in_features, num_classes)

    def forward(self, x):
        out = self.fc(x)
        return out

# 假设我们有一些数据
num_nodes_per_graph = 10
num_graphs = 5
num_node_features = 16
num_classes = 3

# 创建多个图数据
graphs = []
for _ in range(num_graphs):
    x = torch.randn((num_nodes_per_graph, num_node_features))
    scaler = StandardScaler()
    x = torch.tensor(scaler.fit_transform(x), dtype=torch.float)  # 标准化
    edge_index = erdos_renyi_graph(num_nodes=num_nodes_per_graph, edge_prob=0.5)  # 生成随机图
    graphs.append(Data(x=x, edge_index=edge_index))

# 批处理数据
batch = Batch.from_data_list(graphs)

# 创建模型
gnn_model = GNN(in_channels=num_node_features, hidden_channels=32, out_channels=64)
fc_model = FC(in_features=64, num_classes=num_classes)

# 使用一个优化器来联合优化两个模型的参数
optimizer = torch.optim.Adam(list(gnn_model.parameters()) + list(fc_model.parameters()), lr=1e-4)
criterion = nn.CrossEntropyLoss()

# 生成一些随机目标
target = torch.randint(0, num_classes, (num_nodes_per_graph * num_graphs,))

# 训练模型
for epoch in range(100):
    gnn_model.train()
    fc_model.train()
    
    optimizer.zero_grad()
    
    # 前向传播通过GNN模型
    gnn_features = gnn_model(batch)
    
    # 前向传播通过FC模型
    output = fc_model(gnn_features)
    
    # 计算损失
    loss = criterion(output, target)
    
    # 反向传播
    loss.backward()
    
    # 优化器步
    optimizer.step()
    
    print(f'Epoch {epoch+1}, Loss: {loss.item()}')

# 查看特征
print("Extracted GNN features:", gnn_features)

GNN和全连接层（FC）分别使用不同的优化器和学习率分别进行参数更新

如果你想为GNN和全连接层（FC）分别使用不同的优化器和学习率，可以按照以下步骤进行：

定义两个优化器：一个用于GNN模型，另一个用于FC模型。
分别进行参数更新：在训练循环中，分别对两个模型进行前向传播、损失计算和反向传播，然后使用各自的优化器更新参数。

以下是实现代码示例：

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.data import Data, Batch
from torch_geometric.nn import GCNConv
from torch_geometric.utils import erdos_renyi_graph
from sklearn.preprocessing import StandardScaler

class GNN(nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super(GNN, self).__init__()
        self.conv1 = GCNConv(in_channels, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, out_channels)

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.conv2(x, edge_index)
        gnn_features = F.relu(x)
        return gnn_features

class FC(nn.Module):
    def __init__(self, in_features, num_classes):
        super(FC, self).__init__()
        self.fc = nn.Linear(in_features, num_classes)

    def forward(self, x):
        out = self.fc(x)
        return out

# 假设我们有一些数据
num_nodes_per_graph = 10
num_graphs = 5
num_node_features = 16
num_classes = 3

# 创建多个图数据
graphs = []
for _ in range(num_graphs):
    x = torch.randn((num_nodes_per_graph, num_node_features))
    scaler = StandardScaler()
    x = torch.tensor(scaler.fit_transform(x), dtype=torch.float)  # 标准化
    edge_index = erdos_renyi_graph(num_nodes=num_nodes_per_graph, edge_prob=0.5)  # 生成随机图
    graphs.append(Data(x=x, edge_index=edge_index))

# 批处理数据
batch = Batch.from_data_list(graphs)

# 创建模型
gnn_model = GNN(in_channels=num_node_features, hidden_channels=32, out_channels=64)
fc_model = FC(in_features=64, num_classes=num_classes)

# 使用两个优化器分别优化GNN和FC模型的参数
optimizer_gnn = torch.optim.Adam(gnn_model.parameters(), lr=1e-3)  # GNN使用较高的学习率
optimizer_fc = torch.optim.Adam(fc_model.parameters(), lr=1e-4)  # FC使用较低的学习率
criterion = nn.CrossEntropyLoss()

# 生成一些随机目标
target = torch.randint(0, num_classes, (num_nodes_per_graph * num_graphs,))

# 训练模型
for epoch in range(100):
    gnn_model.train()
    fc_model.train()
    
    optimizer_gnn.zero_grad()
    optimizer_fc.zero_grad()
    
    # 前向传播通过GNN模型
    gnn_features = gnn_model(batch)
    
    # 前向传播通过FC模型
    output = fc_model(gnn_features)
    
    # 计算损失
    loss = criterion(output, target)
    
    # 反向传播
    loss.backward()
    
    # 使用各自的优化器更新参数
    optimizer_gnn.step()
    optimizer_fc.step()
    
    print(f'Epoch {epoch+1}, Loss: {loss.item()}')

# 查看特征
print("Extracted GNN features:", gnn_features)

解释

GNN模型类：GNN类定义了一个简单的两层GCN模型，用于特征提取。
FC模型类：FC类定义了一个全连接层模型，用于分类。
数据生成：使用torch_geometric.utils.erdos_renyi_graph生成随机图数据，并确保参数正确。
联合优化：
- 定义两个优化器，分别用于GNN和FC模型，并为它们设置不同的学习率。
- 在训练循环中，首先通过GNN模型提取特征，然后将提取的特征传递给FC模型进行分类。
- 使用各自的优化器来分别清除梯度、进行反向传播和更新参数。

通过这种方式，尽管GNN和FC模型分别在不同的类中，并使用不同的优化器和学习率，它们仍然可以端到端地进行联合训练，并确保梯度正确地传播到整个模型的每一部分。

秒客网