GCN 图神经网络模型用于图片节点特征和标签分类

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

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

    def process(self):
        data_list = []
        for i in range(42):
            features = pd.read_csv(os.path.join(self.root, f'features_{i}.txt'), header=None)
            labels = pd.read_csv(os.path.join(self.root, f'labels_{i}.txt'), header=None)
            for j in range(37):
                x = torch.tensor(features.iloc[j].values, dtype=torch.float)
                y = torch.tensor(labels.iloc[j].values, dtype=torch.long)
                edge_index = torch.tensor(self.edges.values, dtype=torch.long).t().contiguous()
                data = Data(x=x, edge_index=edge_index, y=y)
                data_list.append(data)
        return data_list

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

    def __getitem__(self, idx):
        if self.transform is None:
            return self.process()[idx]
        else:
            return self.transform(self.process()[idx])

# 定义GCN模型：
class GCN(torch.nn.Module):
    def __init__(self, num_node_features, num_classes):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(num_node_features, 8)
        self.conv2 = GCNConv(8, 16)
        self.conv3 = 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 = 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(dataset, model, optimizer, device):
    model.train()
    total_loss = 0.0
    loader = DataLoader(dataset, batch_size=1, shuffle=False)
    for data in loader:
        data = data.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.cross_entropy(output, data.y)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    return total_loss / len(dataset)

def validate_model(dataset, model, device):
    model.eval()
    correct = 0
    total = 0
    loader = DataLoader(dataset, batch_size=1, shuffle=False)
    for data in loader:
        data = data.to(device)
        output = model(data)
        _, predicted = torch.max(output, 1)
        total += data.y.size(0)
        correct += (predicted == data.y).sum().item()
    return correct / total

# 加载数据集、创建模型、定义优化器和训练循环，以及验证模型：
if __name__ == '__main__':
    dataset = MyDataset(root="C:\\Users\\jh\\Desktop\\data\\input")
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    model = GCN(num_node_features=1600, num_classes=5).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=False)
    val_loader = DataLoader(val_dataset, batch_size=1, shuffle=False)

    epochs = 2000
    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'Epoch {epoch+1}/{epochs}, Val_Acc: {val_accuracy:.4f}')