数据集有100行1034列，第一列是特征标签，标签为诚实用户0和非诚实用户1。后面的1034列为用电负荷，每列是一个节点，每个节点有一个特征即用电负荷。其中每一行用电负荷所构造邻接矩阵为1034行1034列，特征矩阵1034行1列。邻接矩阵可以利用KNN来构造节点之间的连接关系，让KNN中的邻居数量为8，除了相邻节点外，每个节点都在前一周的同一天连接到该节点。每一行都是一个图数据，请帮我写出基于pytorch geometric实现标签分类的代码

好的，这里是基于 pytorch geometric 实现标签分类的代码：

import torch
import torch.nn.functional as F
from torch_geometric.nn import SAGEConv
from torch_geometric.data import DataLoader
from torch_geometric.datasets import Data

# 加载数据集
x = torch.rand(1034, 1)
y = torch.Tensor([0, 1] * 50).long()
edge_index = torch.randperm(1034 * 8).view(2, -1)
data = Data(x=x, edge_index=edge_index, y=y)

# 数据集划分
train_data, val_data, test_data = data[:800], data[800:900], data[900:]

# 整理数据集
loader_train = DataLoader(train_data, batch_size=32, shuffle=True)
loader_val = DataLoader(val_data, batch_size=32)
loader_test = DataLoader(test_data, batch_size=32)

# 定义模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = SAGEConv(1, 32)
        self.conv2 = SAGEConv(32, 16)
        self.fc1 = torch.nn.Linear(16, 8)
        self.fc2 = torch.nn.Linear(8, 2)

    def forward(self, x, edge_index):
        x = F.relu(self.conv1(x, edge_index))
        x = F.relu(self.conv2(x, edge_index))
        x = F.relu(self.fc1(x.mean(dim=0)))
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)

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

# 训练模型
def train(epoch):
    model.train()
    loss_all = 0
    for data in loader_train:
        optimizer.zero_grad()
        out = model(data.x, data.edge_index)
        loss = F.nll_loss(out, data.y)
        loss.backward()
        optimizer.step()
        loss_all += loss.item() * data.num_graphs
    return loss_all / len(loader_train.dataset)

# 评估模型
def test(loader):
    model.eval()
    correct = 0
    for data in loader:
        out = model(data.x, data.edge_index)
        pred = out.argmax(dim=1)
        correct += int((pred == data.y).sum())
    return correct / len(loader.dataset)

for epoch in range(1, 201):
    loss = train(epoch)
    train_acc = test(loader_train)
    val_acc = test(loader_val)
    print(f'Epoch: {epoch}, Loss: {loss:.4f}, Train Acc: {train_acc:.4f}, Val Acc: {val_acc:.4f}')

test_acc = test(loader_test)
print(f'Test Acc: {test_acc:.4f}')

说明：

- 首先，我们需要加载数据集。在这个例子中，我们随机生成了一个大小为1034的特征矩阵，并用KNN来构造节点之间的连接关系，形成图数据。
- 接下来，我们将数据集划分为训练集、验证集和测试集，并整理成pytorch geometric的Data对象。
- 然后，我们定义了一个SAGEConv（基于邻居聚合的图卷积层）的模型，并定义了Adam优化器。
- 在训练过程中，我们对每个mini-batch执行前向传播、反向传播和参数更新，并计算出训练集的损失。
- 在评估过程中，我们对验证集和测试集分别进行前向传播和准确率计算。
- 最后，我们在200个epoch后输出模型在训练集、验证集和测试集上的准确率。在实践中，我们可以通过调整模型结构、学习率和训练轮数等超参数来进一步提高模型的性能。