使用Torch Geometric库构建自定义数据集和GCN模型进行图数据分类

这是一个比较复杂的任务，需要先将数据处理成适合使用torch_geometric库的形式，然后定义自定义数据集和GCN模型进行训练和验证。

首先，我们需要导入需要的库：

import os
import pandas as pd
import torch
import torch.nn.functional as F
from torch_geometric.data import Data
from torch_geometric.nn import GCNConv
from torch_geometric.data import DataLoader

然后，我们可以定义一个函数来读取数据并转换成适合使用的形式：

def read_data():
    # 读取边数据
    edges = pd.read_csv('C:/Users/jh/Desktop/data/raw/edges.csv')
    edge_index = torch.tensor(edges.values, dtype=torch.long).t().contiguous()

    # 读取特征数据
    features1 = pd.read_csv('C:/Users/jh/Desktop/data/raw/features1.csv')
    features2 = pd.read_csv('C:/Users/jh/Desktop/data/raw/features2.csv')
    features = torch.cat([torch.tensor(features1.values), torch.tensor(features2.values)], dim=1)

    # 读取标签数据
    labels = pd.read_csv('C:/Users/jh/Desktop/data/raw/label.csv')
    labels = torch.tensor(labels.values, dtype=torch.long).squeeze()

    return edge_index, features, labels

接下来，我们可以定义自定义数据集类MyDataset：

class MyDataset(torch.utils.data.Dataset):
    def __init__(self, edge_index, features, labels, train_mask):
        self.edge_index = edge_index
        self.features = features
        self.labels = labels
        self.train_mask = train_mask

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

    def __getitem__(self, index):
        x = self.features[index]
        y = self.labels[index]
        edge_mask = self.train_mask[index]
        edge_index = self.edge_index[:, edge_mask]
        data = Data(x=x, edge_index=edge_index, y=y)
        return data

在上面的代码中，MyDataset类接受边数据edge_index，特征数据features，标签数据labels和训练集的掩码train_mask作为输入。__getitem__方法根据索引返回一个Data对象，该对象包含特征、边索引和标签。

接下来，我们可以定义一个GCN模型：

class GCN(torch.nn.Module):
    def __init__(self, num_features, num_classes):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(num_features, 16)
        self.conv2 = GCNConv(16, num_classes)

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, training=self.training)
        x = self.conv2(x, edge_index)
        return F.log_softmax(x, dim=1)

在上面的代码中，我们定义了一个简单的GCN模型，包含两个GCN层。输入的特征维度为num_features，输出的类别数为num_classes。

接下来，我们可以定义训练和验证函数：

def train(model, loader, optimizer):
    model.train()

    for data in loader:
        optimizer.zero_grad()
        out = model(data)
        loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask])
        loss.backward()
        optimizer.step()

def test(model, loader):
    model.eval()

    correct = 0
    total = 0

    for data in loader:
        out = model(data)
        _, predicted = torch.max(out[data.test_mask], 1)
        total += len(data.y[data.test_mask])
        correct += (predicted == data.y[data.test_mask]).sum().item()

    accuracy = correct / total
    return accuracy

在上面的代码中，train函数用于训练模型，接受模型、数据加载器和优化器作为输入。test函数用于验证模型，接受模型和数据加载器作为输入，并返回准确率。

最后，我们可以将上述代码组合起来，并使用for循环遍历每张图片的图数据进行训练和验证：

if __name__ == '__main__':
    edge_index, features, labels = read_data()
    train_mask = torch.cat([torch.tensor([True] * 16), torch.tensor([False] * 4)])
    dataset = MyDataset(edge_index, features, labels, train_mask)
    loader = DataLoader(dataset, batch_size=1, shuffle=True)

    num_features = features.size(1)
    num_classes = torch.max(labels) + 1
    model = GCN(num_features, num_classes)

    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

    for epoch in range(10):
        train(model, loader, optimizer)
        accuracy = test(model, loader)
        print(f'Epoch: {epoch+1}, Accuracy: {accuracy}')

在上述代码中，我们首先读取数据，然后创建MyDataset对象和数据加载器。接着，我们定义了GCN模型和优化器，并使用for循环进行训练和验证。

请注意，上述代码只是一个示例，具体的实现可能会根据数据的具体形式和任务的要求进行调整。