PyTorch二分类模型准确率计算陷阱与修正：对比TensorFlow实践

# 原始PyTorch准确率计算片段
# ...
with torch.no_grad():
    model.eval()
    predictions = model(test_X).squeeze() # 模型输出经过Sigmoid，范围在0-1之间
    predictions_binary = (predictions.round()).float() # 四舍五入到0或1
    accuracy = torch.sum(predictions_binary == test_Y) / (len(test_Y) * 100) # 错误的计算方式
    if(epoch%25 == 0):
      print("Epoch " + str(epoch) + " passed. Test accuracy is {:.2f}%".format(accuracy))
# ...

# TensorFlow模型训练与评估片段
# ...
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model.fit(train_X, train_Y, epochs=50, batch_size=64)
loss, accuracy = model.evaluate(test_X, test_Y)
print(f"Loss: {loss}, Accuracy: {accuracy}")
# ...

accuracy = torch.sum(predictions_binary == test_Y) / (len(test_Y) * 100)

# 修正后的PyTorch准确率计算片段
# ...
with torch.no_grad():
    model.eval()
    # 确保模型输出和标签形状一致，这里假设test_Y是(N, 1)或(N,)
    # 如果model(test_X)输出是(N, 1)，则不需要.squeeze()
    # 如果model(test_X)输出是(N, 1)且test_Y是(N,)，则需要.squeeze()其中一个
    # 这里我们假设test_Y是(N, 1)，模型输出也是(N, 1)，因此不使用.squeeze()
    predictions = model(test_X) # 保持(N, 1)形状
    predictions_binary = (predictions.round()).float() # 四舍五入到0或1，保持(N, 1)形状

    # 计算正确预测的数量
    correct_predictions = torch.sum(predictions_binary == test_Y).item()
    # 获取总样本数
    total_samples = test_Y.size(0) # 等同于 len(test_Y)

    # 计算准确率百分比
    accuracy = (correct_predictions / total_samples) * 100

    if(epoch%25 == 0):
      print("Epoch " + str(epoch) + " passed. Test accuracy is {:.2f}%".format(accuracy))
# ...

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.model_selection import train_test_split
import pandas as pd
import numpy as np

# 1. 数据准备 (模拟数据)
# 假设你的数据加载和预处理如下：
# data = pd.read_csv('your_data.csv')
# data['label'] = (data['some_feature'] > threshold).astype(int) # 示例标签生成
# ...
# 这里使用模拟数据以确保代码可运行
np.random.seed(42)
num_samples = 1000
data = pd.DataFrame({
    'A': np.random.rand(num_samples),
    'B': np.random.rand(num_samples),
    'C': np.random.rand(num_samples),
    'D': np.random.rand(num_samples),
    'label': np.random.randint(0, 2, num_samples)
})

train, test = train_test_split(data, test_size=0.2, random_state=42) # 调整test_size

train_X = train[["A","B","C", "D"]].to_numpy()
test_X = test[["A","B", "C", "D"]].to_numpy()
train_Y = train[["label"]].to_numpy()
test_Y = test[["label"]].to_numpy()

train_X = torch.tensor(train_X, dtype=torch.float32)
test_X = torch.tensor(test_X, dtype=torch.float32)
train_Y = torch.tensor(train_Y, dtype=torch.float32) # 保持(N, 1)形状
test_Y = torch.tensor(test_Y, dtype=torch.float32)   # 保持(N, 1)形状

batch_size = 64
train_dataset = TensorDataset(train_X, train_Y)
# test_dataset = TensorDataset(test_X, test_Y) # 评估时通常直接使用test_X, test_Y
train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
# test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False) # 如果需要批量评估，也可以使用

# 2. 模型定义
class SimpleClassifier(nn.Module):
    def __init__(self, input_size, hidden_size1, hidden_size2, output_size):
        super(SimpleClassifier, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size1)
        self.relu1 = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size1, hidden_size2)
        self.relu2 = nn.ReLU()
        self.fc3 = nn.Linear(hidden_size2, output_size)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.relu1(self.fc1(x))
        x = self.relu2(self.fc2(x))
        x = self.sigmoid(self.fc3(x)) # 输出范围0-1
        return x

input_size = train_X.shape[1]
hidden_size1 = 64
hidden_size2 = 32
output_size = 1 # 二分类输出
model = SimpleClassifier(input_size,