GCN模型训练：节点特征提取、标签数据处理和边关系构建

本教程演示如何使用GCN模型对图形数据进行训练，代码中涉及CNN模型、GCN模型和数据加载器等内容，并解释了代码中遇到的错误以及解决方法。

数据集介绍

图数量： 42个
节点数量： 37个
图像尺寸： 40x40像素
标签数量： 8个
边数量： 61条

节点特征文件： 'C:\Users\jh\Desktop\data\input\images{i}.png_{j}.png'，其中：

i 表示图序号，从1到42
j 表示节点序号，从0到36

每个节点特征文件包含图片的像素值。

标签文件： 'C:\Users\jh\Desktop\data\input\labels{i}{j}.txt'，其中：

i 表示图序号
j 表示节点序号

每个标签文件包含8个标签，用空格隔开，例如：'2 3 1 1 3 2 2 1'。

标签类别： 0, 1, 2, 3, 4

边关系文件： 'C:\Users\jh\Desktop\data\input\edges_L.csv'，文件格式为csv，没有header，第一列为源节点，第二列为目标节点。

代码示例

import os
import pandas as pd
import torch
import torch.nn as nn
from torch_geometric.data import Data, DataLoader
from torch_geometric.nn import GCNConv
import torch.nn.functional as F
from torchvision import transforms
from PIL import Image
from sklearn.model_selection import train_test_split

# 定义CNN网络
class CNN(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, 16, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        self.conv2 = nn.Conv2d(16, out_channels, kernel_size=3, stride=1, padding=1)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool(x)
        x = F.relu(self.conv2(x))
        x = self.pool(x)
        return x

# 定义GCN模型
class GCN(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(in_channels, 128)
        self.conv2 = GCNConv(128, out_channels)

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

# 读取边的关系数据
edges = pd.read_csv('C:\Users\jh\Desktop\data\input\edges_L.csv', header=None)
edges = edges.values  # 转换为NumPy数组

# 读取节点特征数据
features = []
for i in range(1, 43):
    for j in range(37):
        image_path = f'C:\Users\jh\Desktop\data\input\images\{i}.png_{j}.png'
        image = Image.open(image_path).convert('RGB')
        transform = transforms.Compose([transforms.Resize((40, 40)), transforms.ToTensor()])
        image_tensor = transform(image)
        features.append(image_tensor)

# 将节点特征转换为PyTorch的Tensor
x = torch.stack(features)
x = x.view(-1, 3, 40, 40)  # 调整数据的维度

# 划分训练集和验证集的掩码
mask_train = torch.zeros(42, 37, dtype=torch.bool)
mask_val = torch.zeros(42, 37, dtype=torch.bool)
for i in range(42):
    mask_train[i, :30] = 1  # 将每个图的前30个节点设置为训练集
    mask_val[i, 30:] = 1   # 将每个图的后7个节点设置为验证集
mask_train = mask_train.view(-1)
mask_val = mask_val.view(-1)

# 创建图结构
edge_index = torch.tensor(edges, dtype=torch.long).t().contiguous()
data_list = []
for i in range(42):
    data = Data(x=x, edge_index=edge_index)
    data.mask_train = mask_train[i*37:(i+1)*37]
    data.mask_val = mask_val[i*37:(i+1)*37]
    data_list.append(data)

# 创建CNN模型实例，降维至8维
cnn_model = CNN(in_channels=3, out_channels=8)

# 使用CNN模型对节点特征进行降维
with torch.no_grad():
    cnn_output = []
    for i in range(42):
        x_i = x[i*37:(i+1)*37].unsqueeze(1)  # 获取当前图的节点特征
        x_i = x_i.squeeze(1)  # 去掉维度中的1
        output_i = cnn_model(x_i)  # 使用CNN模型对节点特征进行降维
        output_i = output_i.view(output_i.size(0), -1)  # 将特征展平为二维矩阵
        cnn_output.append(output_i)
    cnn_output = torch.cat(cnn_output, dim=0)  # 将降维后的特征加入data对象

# 将降维后的特征加入data对象
for i in range(42):
    data_list[i].x = cnn_output[i*37:(i+1)*37]

# 创建GCN模型实例
gcn_model = GCN(in_channels=800, out_channels=8)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(gcn_model.parameters(), lr=0.01)

# 训练模型
num_epochs = 50
for epoch in range(num_epochs):
    gcn_model.train()
    total_loss = 0
    for i in range(42):
        for j in range(37):
            data = data_list[i]
            optimizer.zero_grad()
            out = gcn_model(data)
            labels_path = f'C:\Users\jh\Desktop\data\input\labels{i}{j}.txt'
            labels = torch.tensor([list(map(int, open(labels_path).read().strip().split()))])
            labels = labels.view(-1, 8) # 将标签的shape修改为 (batch_size, num_labels)
            loss = criterion(out, labels)
            loss.backward()
            optimizer.step()
            total_loss += loss.item()

    avg_loss = total_loss / len(data_list)
    print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {avg_loss:.4f}')

# 在验证集上评估模型
gcn_model.eval()
with torch.no_grad():
    total_correct = 0
    total_samples = 0
    for i in range(42):
        for j in range(37):
            data = data_list[i]
            out = gcn_model(data)
            labels_path = f'C:\Users\jh\Desktop\data\input\labels{i}{j}.txt'
            labels = torch.tensor([list(map(int, open(labels_path).read().strip().split()))])
            predicted = (torch.sigmoid(out) > 0.5).float()
            total_correct += (predicted == labels).sum().item()
            total_samples += labels.size(0) * labels.size(1)
    accuracy = total_correct / total_samples
    print(f'Validation Accuracy: {accuracy:.2f}')

错误解决

代码中遇到的错误提示： ValueError: Expected input batch_size (37) to match target batch_size (8).

错误原因：

在训练模型过程中，损失函数criterion(out, labels)需要传入的标签数据labels的维度应该是(batch_size, num_labels)，而代码中labels的维度是(batch_size)。

解决方法：

将labels的维度修改为(batch_size, num_labels)，代码如下：

labels_path = f'C:\Users\jh\Desktop\data\input\labels{i}{j}.txt'
labels = torch.tensor([list(map(int, open(labels_path).read().strip().split()))])
labels = labels.view(-1, 8) # 将标签的shape修改为 (batch_size, num_labels)
loss = criterion(out, labels)

另外，需要注意的是，labels_path的路径应该是f'C:\Users\jh\Desktop\data\input\labels{i}{j}.txt'，而不是f'C:\Users\jh\Desktop\data\input\labels\{i}_{j}.txt'。

总结

本教程展示了如何使用GCN模型对图形数据进行训练，包括节点特征提取、标签数据处理和边关系构建。代码示例中涉及CNN模型、GCN模型和数据加载器等内容，并解释了代码中遇到的错误以及解决方法。