PyTorch二分类模型精度计算陷阱解析与跨框架对比实践

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

# 假设数据加载和预处理已完成
# data = pd.read_csv('your_data.csv')
# train, test = train_test_split(data, test_size=0.056, random_state=42)
# train_X_np = train[["A","B","C", "D"]].to_numpy()
# test_X_np = test[["A","B", "C", "D"]].to_numpy()
# train_Y_np = train[["label"]].to_numpy()
# test_Y_np = test[["label"]].to_numpy()

# train_X = torch.tensor(train_X_np, dtype=torch.float32)
# test_X = torch.tensor(test_X_np, dtype=torch.float32)
# train_Y = torch.tensor(train_Y_np, dtype=torch.float32)
# test_Y = torch.tensor(test_Y_np, dtype=torch.float32)

# train_dataset = TensorDataset(train_X, train_Y)
# batch_size = 64
# train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

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))
        return x

# input_size = train_X.shape[1]
# hidden_size1 = 64
# hidden_size2 = 32
# output_size = 1
# model = SimpleClassifier(input_size, hidden_size1, hidden_size2, output_size)

# criterion = nn.BCELoss()
# optimizer = optim.Adam(model.parameters(), lr=0.001)

# # 原始PyTorch训练循环中的评估部分（存在错误）
# num_epochs = 50
# for epoch in range(num_epochs):
#     # ... (训练代码略)
#     with torch.no_grad():
#         model.eval()
#         predictions = model(test_X).squeeze()
#         predictions_binary = (predictions.round()).float()
#         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))

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
# import numpy as np # 假设 train_X, train_Y, test_X, test_Y 已经准备好为 numpy 数组

# # 假设数据加载和预处理已完成
# # model_tf = Sequential()
# # model_tf.add(Dense(64, input_dim=len(train_X[0]), activation='relu'))
# # model_tf.add(Dense(32, activation='relu'))
# # model_tf.add(Dense(1, activation='sigmoid'))

# # Compile the model
# # model_tf.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# # model_tf.fit(train_X, train_Y, epochs=50, batch_size=64, verbose=0)

# # Evaluate the model
# # loss_tf, accuracy_tf = model_tf.evaluate(test_X, test_Y, verbose=0)
# # print(f"Loss: {loss_tf}, Accuracy: {accuracy_tf}")

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

# 假设 predictions_binary 是模型输出经过 Sigmoid 后，再四舍五入得到的二值预测 (0或1)
# 假设 test_Y 是真实的二值标签 (0或1)

# 计算正确预测的数量
correct_predictions = (predictions_binary == test_Y).sum().item()

# 获取总样本数
total_samples = test_Y.size(0) # 或者 len(test_Y)

# 计算精度（0-100