77183233101031131002521908020102100884831523895264115077183233101031031002521908020100100727686214447021104077183233101031031002521908020100100795906782150269130077183233101031031002521908020102100914

下面是一个使用PyTorch实现GRU分类模型的示例代码：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from sklearn.model_selection import train_test_split

# 自定义数据集类
class MyDataset(Dataset):
    def __init__(self, data):
        self.data = data
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        sample = self.data[idx]
        x = torch.FloatTensor(sample[:-1])
        y = torch.LongTensor([sample[-1]])
        return x, y

# 定义GRU分类模型
class GRUClassifier(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(GRUClassifier, self).__init__()
        self.hidden_size = hidden_size
        self.gru = nn.GRU(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, num_classes)
    
    def forward(self, x):
        output, _ = self.gru(x)
        output = output[:, -1, :]
        output = self.fc(output)
        return output

# 准备数据
data = []
with open('data.txt', 'r') as f:
    for line in f:
        sample = list(map(float, line.strip().split(',')))
        data.append(sample)
        
train_data, test_data = train_test_split(data, test_size=0.2, random_state=42)
train_data, val_data = train_test_split(train_data, test_size=0.2, random_state=42)

train_dataset = MyDataset(train_data)
val_dataset = MyDataset(val_data)
test_dataset = MyDataset(test_data)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# 定义模型参数和优化器
input_size = len(data[0]) - 1
hidden_size = 128
num_classes = 8

model = GRUClassifier(input_size, hidden_size, num_classes)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
best_val_acc = 0.0

for epoch in range(10):
    model.train()
    train_correct = 0
    train_total = 0
    
    for inputs, labels in train_loader:
        inputs = inputs.to(device)
        labels = labels.squeeze().to(device)
        
        optimizer.zero_grad()
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        train_total += labels.size(0)
        train_correct += (predicted == labels).sum().item()
    
    train_acc = train_correct / train_total
    
    model.eval()
    val_correct = 0
    val_total = 0
    
    with torch.no_grad():
        for inputs, labels in val_loader:
            inputs = inputs.to(device)
            labels = labels.squeeze().to(device)
            
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            
            val_total += labels.size(0)
            val_correct += (predicted == labels).sum().item()
        
        val_acc = val_correct / val_total
        
        if val_acc > best_val_acc:
            best_val_acc = val_acc
            torch.save(model.state_dict(), 'best_model.pt')
        
    print('Epoch [{}/{}], Train Acc: {:.2f}, Val Acc: {:.2f}'.format(epoch+1, 10, train_acc, val_acc))

# 在测试集上评估模型
model.load_state_dict(torch.load('best_model.pt'))
model.eval()

test_correct = 0
test_total = 0

with torch.no_grad():
    for inputs, labels in test_loader:
        inputs = inputs.to(device)
        labels = labels.squeeze().to(device)
        
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        
        test_total += labels.size(0)
        test_correct += (predicted == labels).sum().item()
    
    test_acc = test_correct / test_total
    
print('Test Acc: {:.2f}'.format(test_acc))

上述代码中，首先定义了一个自定义的数据集类MyDataset，用于加载和处理数据。然后定义了一个GRU分类模型GRUClassifier，包含一个GRU层和一个全连接层。接下来，使用train_test_split函数将原始数据划分为训练集、验证集和测试集，并创建相应的数据加载器。然后定义模型参数和优化器。接着进入训练循环，每个epoch中，先将模型设为训练模式，然后遍历训练集进行训练，并计算训练准确率。然后将模型设为评估模式，遍历验证集计算验证准确率，并保存在验证集上表现最好的模型。最后，在测试集上评估模型的准确率