基于颜色特征的图神经网络模型：42个时刻37个节点的图片数据分析

本文介绍了一种使用图神经网络模型对42个时刻37个节点的图片数据进行分析的方法。该方法利用图片的颜色特征作为模型的输入，并通过图神经网络模型对数据进行学习和预测。

数据描述:

数据存储在'C:\Users\jh\Desktop\data\images_block'路径下，包含42个时刻的图片数据，每个时刻包含37张图片，每张图片代表一个节点，图片大小为40×40像素，图片命名格式为'i.png_j.png'，其中'i'表示时刻（从1到42），'j'表示节点序号（从0到36）。所有图片的边连接关系相同。

模型设计:

我们将使用PyTorch Geometric库构建图神经网络模型。模型的输入是每个节点的颜色特征，输出是每个节点的标签。

代码示例:

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.edges = pd.read_csv(os.path.join(root, 'edges_L.csv'))
        self.transform = transform
        self.pre_transform = pre_transform
        self.num_classes = 8  # 修改成8类标签
        self.features = []
        self.labels = []
        for i in range(1, 43):
            for j in range(37):
                feature_path = os.path.join(root, 'images_flatten', f'{i}.txt_{j}.txt')
                label_path = os.path.join(root, 'labels', f'{i}_{j}.txt')  # 修改标签文件名
                features = pd.read_csv(feature_path, header=None, sep=' ')
                labels = pd.read_csv(label_path, header=None, sep=' ', encoding='ansi')
                self.features.append(torch.tensor(features.values, dtype=torch.float))
                self.labels.append(torch.tensor(labels.values.squeeze(), dtype=torch.long))  # 修改标签数据类型为long型

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

    def __getitem__(self, idx):
        edge_index = torch.tensor(self.edges.values, dtype=torch.long).t().contiguous()
        x = self.features[idx]
        y = self.labels[idx]

        # 定义图数据的train_mask和val_mask
        train_mask = torch.zeros(y.size(0), dtype=torch.bool)
        val_mask = torch.zeros(y.size(0), dtype=torch.bool)
        train_mask[:30] = 1
        val_mask[30:] = 1

        data = Data(x=x, edge_index=edge_index, y=y, train_mask=train_mask, val_mask=val_mask)

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

# 定义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

    for data in dataset:
        data = data.to(device)
        optimizer.zero_grad()
        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(dataset)

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

    for data in dataset:
        data = data.to(device)
        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\input")
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    model = GCN(num_node_features=1600, num_classes=8).to(device)  # 修改num_classes为8
    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 = 2
    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}')

新的特征输入内容:

新的特征输入可以通过以下步骤实现：

在MyDataset类中，添加一个新的方法来提取颜色特征。可以使用PIL库来加载图片，并使用numpy库将图片转换为数组。然后，使用数组的reshape方法将图片大小调整为40×40。接下来，将图片数组展平为一维数组，并将其作为特征添加到self.features列表中。

    def extract_color_features(self, image_path):
        image = Image.open(image_path)
        image = image.resize((40, 40))
        image_array = np.array(image)
        flattened_image = image_array.flatten()
        return flattened_image

    def __init__(self, root, transform=None, pre_transform=None):
        ...
        self.features = []
        self.labels = []
        for i in range(1, 43):
            for j in range(37):
                image_path = os.path.join(root, 'images_block', f'{i}.png_{j}.png')
                features = self.extract_color_features(image_path)
                self.features.append(torch.tensor(features, dtype=torch.float))
                ...

在GCN模型中，修改num_node_features的值为1600，因为每个图片有1600个颜色特征（40×40）。

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)

在训练模型之前，将train_test_split函数的test_size参数设置为0，以便将所有数据用于训练。

train_dataset, val_dataset = train_test_split(dataset, test_size=0)

创建一个新的数据加载器train_loader，用于训练模型。设置batch_size为1，以便逐个图像地提取特征。

train_loader = DataLoader(train_dataset, batch_size=1, shuffle=False)

在训练循环中，将数据提取为data.x，其中x是特征。由于现在的特征是一维数组，需要使用reshape方法将其转换为二维数组。

def train_model(dataset, model, optimizer, device):
    ...
    for data in dataset:
        data = data.to(device)
        x = data.x.reshape(-1, 1600)
        data.x = x
        ...

这样，模型就可以使用新的颜色特征进行训练和验证了。

总结:

本文介绍了一种使用图神经网络模型对图片数据进行分析的方法。该方法利用图片的颜色特征作为模型的输入，并通过图神经网络模型对数据进行学习和预测。该方法可以应用于多种领域，例如图像分类、目标检测、场景识别等。

未来方向:

未来可以研究更复杂的图神经网络模型，例如使用注意力机制、多层卷积等，来提高模型的性能。还可以研究如何将其他特征，例如形状特征、纹理特征等，与颜色特征结合起来，进一步提高模型的预测能力。