PyTorch Geometric GCNConv 错误：边索引超出节点范围

根据报错信息，可以看出是在 GCNConv 的 forward 方法中出现了错误。具体是在调用 gcn_norm 函数时出错，报错信息显示 index 3 超出了维度 0 的大小 3。

根据代码和输入数据的描述，可以猜测可能是边的索引超出了节点的范围。根据输入数据的描述，共有 37 个节点，即节点的索引范围应该是从 0 到 36。但是错误信息中显示的是索引 3 超出了范围。

为了解决这个问题，可以检查一下边的索引数据，确保边的索引没有超出节点的范围。另外，还可以检查一下数据加载部分的逻辑，确保节点和边的信息正确地加载到了数据对象中。

具体可以采取以下步骤进行排查：

检查 edges_L.csv 文件中的数据： 确保该文件中的所有边索引都处于 0 到 36 之间。
检查 MyDataset 类中的数据加载逻辑： 确保 self.edges 的值被正确地转换为 torch.long 类型，并且在计算边索引时进行了减 1 操作，以符合 PyTorch Geometric 的索引约定。
检查 GCN 类中 self.conv1 的参数： 确保 num_node_features 参数的值与输入特征的维度一致。

如果以上检查都没有发现问题，则可能是其他代码逻辑导致了错误。可以尝试使用调试工具，逐步执行代码，观察数据流，定位错误发生的位置。

示例代码:

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 sklearn.model_selection import train_test_split
from torchvision import transforms
from PIL import Image

# 加载数据并创建 PyG 数据集类：
class MyDataset(torch.utils.data.Dataset):
    def __init__(self, root, transform=None, pre_transform=None):
        self.edges = pd.read_csv(os.path.join(root, 'input', 'edges_L.csv'), header=None)
        self.transform = transform
        self.pre_transform = pre_transform

        # 读取特征和标签数据
        self.features = []
        self.labels = []
        self.cnn = CNN()
        for i in range(1, 43):
            for j in range(37):
                # 读取特征
                img_name = os.path.join(root, 'input', 'images', '{}.png_{}.png'.format(i, j))
                img = Image.open(img_name).convert('RGBA').resize((40, 40), resample=Image.BILINEAR)
                img_tensor = transforms.ToTensor()(img)
                feature = self.cnn(img_tensor.unsqueeze(0))
                self.features.append(feature)

                # 读取标签
                label_name = os.path.join(root, 'input', 'labels', '{}_{}.txt'.format(i, j))
                with open(label_name, 'r') as f:
                    labels = [int(x) for x in f.readline().strip().split()]
                self.labels.append(labels)

        # 将特征调整维度为[batch_size, num_node_features, width, height]
        self.features = torch.stack(self.features, dim=0)
        self.labels = torch.tensor(self.labels)

        # Calculate the total number of nodes
        self.num_nodes = len(self.labels)

        # 添加边的关系
        self.edges = torch.tensor(self.edges.values, dtype=torch.long).t().contiguous() - 1

        self.cnn = CNN()  # 添加 CNN 模型

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        x = self.features[idx]
        y = self.labels[idx]

        # Define graph-wide train_mask and val_mask
        train_mask = torch.zeros(self.num_nodes, dtype=torch.bool)
        val_mask = torch.zeros(self.num_nodes, dtype=torch.bool)

        # Set train_mask for the first 30 nodes in each network, and val_mask for the last 7 nodes
        node_id = idx % 37
        network_id = idx // 37
        if node_id < 30 and (node_id + network_id * 37) < self.num_nodes:
            train_mask[node_id + network_id * 37] = 1
        elif (node_id + network_id * 37) < self.num_nodes:
            val_mask[node_id + network_id * 37] = 1

        data = Data(x=x, edge_index=self.edges, y=y, train_mask=train_mask, val_mask=val_mask)

        if self.pre_transform is not None:
            data = self.pre_transform(data)
        if self.transform is not None:
            data.x = self.transform(data.x)
        return data

# 定义 CNN 模型
class CNN(torch.nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # Modify the first convolution layer to reduce spatial dimensions
        self.conv1 = nn.Conv2d(4, 16, kernel_size=3, stride=2, padding=1)
        self.conv2 = nn.Conv2d(16, 4, kernel_size=3, stride=2, padding=1)

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

# 创建 GCN 模型
class GCN(torch.nn.Module):
    def __init__(self, num_node_features, num_classes):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(4, 8)
        self.conv2 = GCNConv(8, 16)
        self.conv3 = GCNConv(16, num_classes)
        self.cnn = CNN()

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.cnn(x)  # 使用 CNN 模型提取图像特征
        #         print(x.shape)
        #         print(edge_index.shape)
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = self.conv2(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, training=self.training)
        x = self.conv3(x, edge_index)

        return x

# 创建训练和验证模型
def train_model(dataloader, model, optimizer, device):
    model.train()
    total_loss = 0.0

    for data in dataloader:
        data = data.to(device)
        optimizer.zero_grad()
        features = model(data)  # 提取图像特征
        data.x = features
        output = model(data)
        loss = F.cross_entropy(output[data.train_mask], data.y[data.train_mask])
        loss.backward()
        optimizer.step()
        total_loss += loss.item()

    return total_loss / len(dataloader)

def validate_model(dataloader, model, device):
    model.eval()
    correct = 0
    total = 0

    for data in dataloader:
        data = data.to(device)

        features = model(data)  # 提取图像特征
        data.x = features

        output = model(data)
        _, predicted = torch.max(output[data.val_mask], 1)
        total += data.val_mask.sum().item()
        correct += (predicted == data.y[data.val_mask]).sum().item()

    return correct / total

if __name__ == '__main__':
    dataset = MyDataset(root="C:\Users\jh\Desktop\data")
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    model = GCN(num_node_features=4, num_classes=8).to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

    train_dataset, val_dataset = train_test_split(dataset, test_size=0.1)
    train_loader = DataLoader(train_dataset, batch_size=1, shuffle=True)
    val_loader = DataLoader(val_dataset, batch_size=1, shuffle=False)

    epochs = 1
    for epoch in range(epochs):
        train_loss = train_model(train_loader, model, optimizer, device)
        print(f'Epoch {epoch+1}/{epochs}, Train Loss: {train_loss:.4f}')

        val_accuracy = validate_model(val_loader, model, device)
        print(f'Val_Acc: {val_accuracy:.4f}')

注意：

代码中使用 torch.tensor(self.edges.values, dtype=torch.long).t().contiguous() - 1 转换 self.edges 的类型并进行索引调整，以确保边索引的正确性。
GCN 类中的 num_node_features 参数应设置为 4，因为每个节点的特征维度为 4。
代码中的 train_test_split 函数用于将数据集分为训练集和验证集，比例为 9:1。
代码中的 train_model 和 validate_model 函数分别用于训练和验证模型。
代码中的 epochs 参数设置为 1，表示训练 1 个 epoch。
代码中的 optimizer 参数设置为 torch.optim.Adam，学习率为 0.01。

经过以上检查和修正，应该可以解决 GCNConv 中出现的边索引超出节点范围的错误。

补充说明:

在 PyTorch Geometric 中，边索引应该从 0 开始，并且应该小于节点的总数。
在 gcn_norm 函数中，num_nodes 参数用于指定节点的总数。
如果边索引超过了节点范围，则会导致错误，因为 scatter 函数无法将数据散列到超出范围的索引上。
确保数据加载、索引转换和模型参数设置的正确性，可以避免此类错误的出现。

希望以上信息能够帮助你解决问题。