使用 PyTorch 实现逻辑回归并评估模型性能

1. 逻辑回归简介

逻辑回归是一种用于解决二分类问题的算法。它通过一个逻辑函数（Sigmoid 函数）将线性回归的输出映射到 [0, 1] 区间内，从而将问题转化为概率预测问题。如果预测概率大于 0.5，则将样本分类为正类；否则分类为负类。

2. 数据准备

为了演示逻辑回归的效果，我们构造了一个简单的二维数据集，包含两类样本。每类样本有 7 个数据点，特征维度为 2。

class1_points = np.array([[1.9, 1.2],
                          [1.5, 2.1],
                          [1.9, 0.5],
                          [1.5, 0.9],
                          [0.9, 1.2],
                          [1.1, 1.7],
                          [1.4, 1.1]])

class2_points = np.array([[3.2, 3.2],
                          [3.7, 2.9],
                          [3.2, 2.6],
                          [1.7, 3.3],
                          [3.4, 2.6],
                          [4.1, 2.3],
                          [3.0, 2.9]])

我们将这两类数据点的特征合并，并为每个数据点分配标签（0 表示第一类，1 表示第二类）。

3. 模型构建

我们使用 PyTorch 框架来实现逻辑回归模型。模型结构非常简单，仅包含一个线性层和一个 Sigmoid 激活函数。

class LogisticRegression(nn.Module):
    def __init__(self):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(2, 1)  # 输入特征维度为 2，输出为 1

    def forward(self, x):
        return torch.sigmoid(self.linear(x))

4. 模型训练

我们使用二分类交叉熵损失函数（BCELoss）和随机梯度下降优化器（SGD）来训练模型。训练过程如下：

epochs = 5000
for epoch in range(epochs):
    model.train()
    optimizer.zero_grad()
    outputs = model(X)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

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

训练过程中，我们每 100 个 epoch 打印一次损失值，以便观察模型的收敛情况。

5. 模型保存与加载

训练完成后，我们将模型的权重保存到文件中，方便后续加载和使用。

torch.save(model.state_dict(), 'model3.pth')
print("模型已保存")

加载模型时，我们创建一个新的模型实例，并使用 load_state_dict 方法加载保存的权重。

loaded_model = LogisticRegression()
loaded_model.load_state_dict(torch.load('model3.pth', map_location=torch.device('cpu')))
loaded_model.eval()

6. 模型预测与性能评估

加载模型后，我们使用模型对训练数据进行预测，并计算精确度、召回率和 F1 分数。

with torch.no_grad():
    predictions = loaded_model(X)
    predicted_labels = (predictions > 0.5).float()

print("实际结果：", y.numpy().flatten())
print("预测结果：", predicted_labels.numpy().flatten())

precision = precision_score(y.numpy().flatten(), predicted_labels.numpy().flatten())
recall = recall_score(y.numpy().flatten(), predicted_labels.numpy().flatten())
f1 = f1_score(y.numpy().flatten(), predicted_labels.numpy().flatten())

print(f"精确度（Precision）: {precision:.4f}")
print(f"召回率（Recall）: {recall:.4f}")
print(f"F1 分数: {f1:.4f}")

7. 运行结果

运行上述代码后，我们得到了以下结果：

实际结果：[0. 0. 0. 0. 0. 0. 0. 1. 1. 1. 1. 1. 1. 1.]
预测结果：[0. 0. 0. 0. 0. 0. 0. 1. 1. 1. 1. 1. 1. 1.]
精确度（Precision）：1.0000
召回率（Recall）：1.0000
F1 分数：1.0000

从结果可以看出，模型在训练集上表现良好，精确度、召回率和 F1 分数均为 1.0000。

8. 完整代码

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.metrics import precision_score, recall_score, f1_score

"""使用pytorch框架实现逻辑回归并保存模型，然后保存模型后再加载模型进行预测，对预测结果计算精确度和召回率及F1分数"""
# 提取特征和标签
class1_points = np.array([[1.9, 1.2],
                          [1.5, 2.1],
                          [1.9, 0.5],
                          [1.5, 0.9],
                          [0.9, 1.2],
                          [1.1, 1.7],
                          [1.4, 1.1]])

class2_points = np.array([[3.2, 3.2],
                          [3.7, 2.9],
                          [3.2, 2.6],
                          [1.7, 3.3],
                          [3.4, 2.6],
                          [4.1, 2.3],
                          [3.0, 2.9]])

# 提取两类特征，输入特征维度为2
x1_data = np.concatenate((class1_points[:, 0], class2_points[:, 0]), axis=0)
x2_data = np.concatenate((class1_points[:, 1], class2_points[:, 1]), axis=0)
label = np.concatenate((np.zeros(len(class1_points)), np.ones(len(class2_points))), axis=0)

# 将数据转换为 PyTorch 张量
X = torch.tensor(np.column_stack((x1_data, x2_data)), dtype=torch.float32)
y = torch.tensor(label, dtype=torch.float32).view(-1, 1)

# 定义逻辑回归模型
class LogisticRegression(nn.Module):
    def __init__(self):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(2, 1)  # 输入特征维度为 2，输出为 1

    def forward(self, x):
        return torch.sigmoid(self.linear(x))

# 初始化模型、损失函数和优化器
model = LogisticRegression()
criterion = nn.BCELoss()  # 二分类交叉熵损失
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
epochs = 5000
for epoch in range(epochs):
    model.train()
    optimizer.zero_grad()
    outputs = model(X)
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

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

# 保存模型
torch.save(model.state_dict(), 'model3.pth')
print("模型已保存")

# 加载模型
loaded_model = LogisticRegression()
loaded_model.load_state_dict(torch.load('model3.pth',
                                        map_location=torch.device('cpu'),
                                        weights_only=True))
loaded_model.eval()

# 进行预测
with torch.no_grad():
    predictions = loaded_model(X)
    predicted_labels = (predictions > 0.5).float()

 # 展示预测结果和实际结果
print("实际结果：", y.numpy().flatten())
print("预测结果：", predicted_labels.numpy().flatten())

# 计算精确度、召回率和 F1 分数
precision = precision_score(y.numpy().flatten(), predicted_labels.numpy().flatten())
recall = recall_score(y.numpy().flatten(), predicted_labels.numpy().flatten())
f1 = f1_score(y.numpy().flatten(), predicted_labels.numpy().flatten())

print(f"精确度（Precision）: {precision:.4f}")
print(f"召回率（Recall）: {recall:.4f}")
print(f"F1 分数: {f1:.4f}")