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

基于颜色特征的图神经网络时间序列分析

本项目利用 42 个时刻的 37 节点图数据，每个节点对应一张 40x40 像素的图片，提取图像颜色特征作为节点特征，训练图神经网络模型进行时间序列分析。

数据集

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

特征提取

将每张图片的颜色特征提取为向量，例如使用 RGB 颜色空间，每个像素对应一个 3 维向量，最终得到一个 1600 维的特征向量 (40x40x3)。
将所有图片的特征向量组成一个特征矩阵。

模型训练

使用 PyTorch Geometric 框架搭建图神经网络模型，具体步骤如下：

创建数据集类：

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}')

总结

该项目使用图神经网络模型对包含颜色特征的 42 个时刻的 37 节点图数据进行时间序列分析。通过提取图片颜色特征作为节点特征，可以更好地捕捉节点之间的关系，并利用图神经网络的优势进行时间序列预测。

进一步研究

可以尝试使用其他图像特征提取方法，例如纹理特征、形状特征等，以提高模型性能。
可以尝试使用其他图神经网络模型，例如 GAT、GraphSAGE 等，以探索不同模型在该任务上的效果。
可以尝试使用更复杂的模型架构，例如多层 GCN、递归神经网络等，以提高模型的预测能力。