PyTorch模型训练效果不佳？深入剖析常见错误与调试技巧

with torch.no_grad():
    n_correct = 0
    n_samples = 0
    for inputs, labels in test_loader:
        labels = labels.to(device)
        outputs = model(inputs)
        # ... 其他处理 ...

        _, predictions = torch.max(outputs, 1)
        n_samples += labels.shape[0]
        # 错误：n_correct在每次迭代中被重置
        n_correct = (predictions == labels).sum().item() 

    acc = 100 * n_correct / n_samples
    print(f'accuracy = {acc}')

n_correct += (predictions == labels).sum().item()

# ... (其他代码) ...
#test
with torch.no_grad():
    n_correct = 0 # 初始化总的正确预测数
    n_samples = 0 # 初始化总样本数
    for inputs, labels in test_loader:
        inputs = inputs.to(device) # 将输入数据移动到设备
        labels = labels.to(device) # 将标签移动到设备

        outputs = model(inputs)

        _, predictions = torch.max(outputs.data, 1) # 获取预测结果的类别索引
        n_samples += labels.shape[0] # 累加当前批次的样本数
        n_correct += (predictions == labels).sum().item() # 正确：累加当前批次的正确预测数

    acc = 100 * n_correct / n_samples
    print(f'Accuracy of the model on the test samples: {acc:.2f}%')

# 训练循环中
outputs = model(inputs)
inputs = torch.flatten(inputs) # 潜在问题
labels = torch.flatten(labels)
loss = criterion(outputs, labels.long())

# 测试循环中
outputs = model(inputs)
inputs = torch.flatten(inputs) # 潜在问题
labels = torch.flatten(labels)

class NeuralNet(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(NeuralNet,self).__init__()
        self.l1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.LeakyReLU()
        self.l2 = nn.Linear(hidden_size, num_classes)

    def forward(self, x):
        out = self.l1(x)
        out = self.relu(out)
        out = self.l2(out)
        return out

# 训练循环中
outputs = model(inputs) # 直接将inputs传入模型
labels = labels.flatten() # 标签仍需要展平为 [batch_size]
loss = criterion(outputs, labels.long())

# 测试循环中
outputs = model(inputs) # 直接将inputs传入模型
labels = labels.flatten() # 标签仍需要展平为 [batch_size]

class SDSS(Dataset):
    # ... 加载SDSS.csv ...

class testSDSS(Dataset):
    # ... 加载SDSS.csv ...

dataset = SDSS()
test_dataset = testSDSS()

from torch.utils.data import random_split

# 假设SDSS数据集已经加载
full_dataset = SDSS() # 假设SDSS类可以加载整个数据集

# 定义训练集和测试集的比例
train_size = int(0.8 * len(full_dataset))
test_size = len(full_dataset) - train_size

# 使用random_split进行划分
train_dataset, test_dataset = random_split(full_dataset, [train_size, test_size])

# 然后创建各自的DataLoader
data_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True, num_workers=0)
test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False, num_workers=0)

# ... (device config, model definition, optimizer, criterion等不变) ...

# 假设已经正确划分了train_dataset和test_dataset
# 并创建了data_loader (for train) 和 test_loader (for evaluation)

# 训练循环
n_total_steps = len(data_loader) # 修正：应为数据加载器的批次总数
for epoch in range(num_epochs):
    model.train() # 设置模型为训练模式
    for i, (inputs, labels) in enumerate(data_loader):
        inputs = inputs.to(device)
        labels = labels.to(device)

        # Forward pass
        outputs = model(inputs)
        labels = labels.flatten() # 确保标签形状为 [batch_size]
        loss = criterion(outputs, labels.long())

        # Backward and optimize
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if (i+1) % 100 == 0:
            print(f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{n_total_steps}], Loss: {loss.item():.4f}')

# 测试/评估循环
with torch.no_grad():
    model.eval() # 设置模型为评估模式
    n_correct = 0
    n_samples = 0
    for inputs, labels in test_loader:
        inputs = inputs.to(device)
        labels = labels.to(device)

        outputs = model(inputs)
        labels = labels.flatten() # 确保标签形状为 [batch_size]

        # max returns (value, index)
        _, predictions = torch.max(outputs.data, 1)
        n_samples += labels.size(0)
        n_correct += (predictions == labels).sum().item()

    acc = 100.0 * n_correct / n_samples
    print(f'Accuracy of the model on the test dataset: {acc:.2f}%')