当前位置： 首页 > article >正文

【机器学习】自定义数据集 使用pytorch框架实现逻辑回归并保存模型，然后保存模型后再加载模型进行预测，对预测结果计算精确度和召回率及F1分数

article 2025/2/2 5:31:12

一、使用pytorch框架实现逻辑回归

1. 数据部分：

  • 首先自定义了一个简单的数据集，特征 X 是 100 个随机样本，每个样本一个特征，目标值 y 基于线性关系并添加了噪声。
  • 将 numpy 数组转换为 PyTorch 张量，方便后续在模型中使用。

2. 模型定义部分：

方案 1：使用 nn.Sequential 直接按顺序定义了一个线性层，简洁直观。

import torch
import torch.nn as nn
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score

# 自定义数据集
X = np.random.rand(100, 1).astype(np.float32)
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)

# 转换为 PyTorch 张量
X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)

# 定义线性回归模型
model = nn.Sequential(
    nn.Linear(1, 1)
)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):
    # 前向传播
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)

    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

# 模型评估
with torch.no_grad():
    y_pred = model(X_tensor).numpy()

mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")

# 输出模型的系数和截距
print("模型系数:", model[0].weight.item())
print("模型截距:", model[0].bias.item())

方案 2：使用 nn.ModuleList 存储线性层，在 forward 方法中依次调用层进行前向传播，适合动态构建层序列。

import torch
import torch.nn as nn
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score

# 自定义数据集
X = np.random.rand(100, 1).astype(np.float32)
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)

# 转换为 PyTorch 张量
X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)

# 定义线性回归模型
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.layers = nn.ModuleList([
            nn.Linear(1, 1)
        ])

    def forward(self, x):
        for layer in self.layers:
            x = layer(x)
        return x

model = LinearRegression()

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):
    # 前向传播
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)

    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

# 模型评估
with torch.no_grad():
    y_pred = model(X_tensor).numpy()

mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")

# 输出模型的系数和截距
print("模型系数:", model.layers[0].weight.item())
print("模型截距:", model.layers[0].bias.item())

方案 3：使用 nn.ModuleDict 以字典形式存储层，通过键名调用层，适合需要对层进行命名和灵活访问的场景。

import torch
import torch.nn as nn
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score

# 自定义数据集
X = np.random.rand(100, 1).astype(np.float32)
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)

# 转换为 PyTorch 张量
X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)

# 定义线性回归模型
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.layers = nn.ModuleDict({
            'linear': nn.Linear(1, 1)
        })

    def forward(self, x):
        x = self.layers['linear'](x)
        return x

model = LinearRegression()

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):
    # 前向传播
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)

    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

# 模型评估
with torch.no_grad():
    y_pred = model(X_tensor).numpy()

mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")

# 输出模型的系数和截距
print("模型系数:", model.layers['linear'].weight.item())
print("模型截距:", model.layers['linear'].bias.item())

方案 4：直接继承 nn.Module，在 __init__ 方法中定义线性层，在 forward 方法中实现前向传播逻辑，是最常见和基础的定义模型方式。

import torch
import torch.nn as nn
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score

# 自定义数据集
X = np.random.rand(100, 1).astype(np.float32)
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)

# 转换为 PyTorch 张量
X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)

# 定义线性回归模型
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(1, 1)

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

model = LinearRegression()

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):
    # 前向传播
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)

    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

# 模型评估
with torch.no_grad():
    y_pred = model(X_tensor).numpy()

mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")

# 输出模型的系数和截距
print("模型系数:", model.linear.weight.item())
print("模型截距:", model.linear.bias.item())

3. 训练和评估部分：

  • 定义了均方误差损失函数 nn.MSELoss 和随机梯度下降优化器 torch.optim.SGD。
  • 通过多个 epoch 进行训练，每个 epoch 包含前向传播、损失计算、反向传播和参数更新。
  • 训练结束后，在无梯度计算模式下进行预测，并使用 scikit-learn 的指标计算均方误差和决定系数评估模型性能，最后输出模型的系数和截距。

二、保存pytorch框架逻辑回归模型

在 PyTorch 中，有两种常见的保存模型的方式：保存模型的权重和其他参数，以及保存整个模型。下面将结合一个简单的逻辑回归模型示例，详细介绍这两种保存方式及对应的加载方法。

方式 1：保存模型的权重和其他参数

这种方式只保存模型的状态字典（state_dict），它包含了模型的所有可学习参数（如权重和偏置）。这种方法的优点是文件体积小，便于共享和迁移，缺点是加载时需要先定义模型结构。

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 自定义数据集
X = np.random.randn(100, 2).astype(np.float32)
y = (2 * X[:, 0] + 3 * X[:, 1] > 0).astype(np.float32).reshape(-1, 1)

X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)

# 定义逻辑回归模型
class LogisticRegression(nn.Module):
    def __init__(self, input_size):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_size, 1)
        self.sigmoid = nn.Sigmoid()

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

# 初始化模型
input_size = 2
model = LogisticRegression(input_size)

# 定义损失函数和优化器
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

# 保存模型的权重和其他参数
torch.save(model.state_dict(), 'model_weights.pth')

# 加载模型的权重和其他参数
loaded_model = LogisticRegression(input_size)
loaded_model.load_state_dict(torch.load('model_weights.pth'))
loaded_model.eval()

# 生成新数据进行预测
new_X = np.random.randn(10, 2).astype(np.float32)
new_X_tensor = torch.from_numpy(new_X)

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

print("预测概率:")
print(predictions.numpy())
print("预测标签:")
print(predicted_labels.numpy())

代码解释

  1. 模型训练：首先定义并训练一个逻辑回归模型。
  2. 保存模型：使用 torch.save(model.state_dict(), 'model_weights.pth') 保存模型的状态字典到文件 model_weights.pth。
  3. 加载模型：先创建一个新的模型实例 loaded_model，然后使用 loaded_model.load_state_dict(torch.load('model_weights.pth')) 加载保存的状态字典。
  4. 预测：将模型设置为评估模式，生成新数据进行预测。

方式 2：保存整个模型

这种方式会保存整个模型对象，包括模型的结构和状态字典。优点是加载时不需要重新定义模型结构，缺点是文件体积较大，并且可能会受到 Python 版本和库版本的限制。

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 自定义数据集
X = np.random.randn(100, 2).astype(np.float32)
y = (2 * X[:, 0] + 3 * X[:, 1] > 0).astype(np.float32).reshape(-1, 1)

X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)

# 定义逻辑回归模型
class LogisticRegression(nn.Module):
    def __init__(self, input_size):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_size, 1)
        self.sigmoid = nn.Sigmoid()

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

# 初始化模型
input_size = 2
model = LogisticRegression(input_size)

# 定义损失函数和优化器
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

# 保存整个模型
torch.save(model, 'whole_model.pth')

# 加载整个模型
loaded_model = torch.load('whole_model.pth')
loaded_model.eval()

# 生成新数据进行预测
new_X = np.random.randn(10, 2).astype(np.float32)
new_X_tensor = torch.from_numpy(new_X)

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

print("预测概率:")
print(predictions.numpy())
print("预测标签:")
print(predicted_labels.numpy())

代码解释

  1. 模型训练：同样先定义并训练逻辑回归模型。
  2. 保存模型：使用 torch.save(model, 'whole_model.pth') 保存整个模型对象到文件 whole_model.pth。
  3. 加载模型：使用 torch.load('whole_model.pth') 直接加载整个模型。
  4. 预测：将模型设置为评估模式，生成新数据进行预测。

通过以上两种方式，可以根据实际需求选择合适的模型保存和加载方法。

三、加载pytorch框架逻辑回归模型

以下将分别详细介绍在 PyTorch 中针对只保存模型参数和保存结构与参数这两种不同保存方式对应的模型加载方法，同时给出完整的代码示例。

方式 1：只保存模型参数的加载方式

当用户只保存了模型的参数（即 state_dict）时，在加载模型时需要先定义好与原模型相同结构的模型，再将保存的参数加载到该模型中。

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 自定义数据集
X = np.random.randn(100, 2).astype(np.float32)
y = (2 * X[:, 0] + 3 * X[:, 1] > 0).astype(np.float32).reshape(-1, 1)

X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)

# 定义逻辑回归模型
class LogisticRegression(nn.Module):
    def __init__(self, input_size):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_size, 1)
        self.sigmoid = nn.Sigmoid()

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

# 初始化模型
input_size = 2
model = LogisticRegression(input_size)

# 定义损失函数和优化器
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

# 保存模型的参数
torch.save(model.state_dict(), 'model_params.pth')

# 加载模型的参数
# 重新定义模型结构
loaded_model = LogisticRegression(input_size)
# 加载保存的参数
loaded_model.load_state_dict(torch.load('model_params.pth'))
# 将模型设置为评估模式
loaded_model.eval()

# 生成新数据进行预测
new_X = np.random.randn(10, 2).astype(np.float32)
new_X_tensor = torch.from_numpy(new_X)

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

print("预测概率:")
print(predictions.numpy())
print("预测标签:")
print(predicted_labels.numpy())

代码解释

  1. 模型定义与训练：定义了一个简单的逻辑回归模型，并使用自定义数据集进行训练。
  2. 保存参数：使用 torch.save(model.state_dict(), 'model_params.pth') 保存模型的参数。
  3. 加载参数：
    • 重新定义与原模型相同结构的 loaded_model。
    • 使用 loaded_model.load_state_dict(torch.load('model_params.pth')) 加载保存的参数。
  4. 预测：将模型设置为评估模式，生成新数据进行预测。

方式 2：保存结构和参数的模型加载方式

当保存了模型的结构和参数时，加载模型就相对简单，直接使用 torch.load 函数即可加载整个模型。

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 自定义数据集
X = np.random.randn(100, 2).astype(np.float32)
y = (2 * X[:, 0] + 3 * X[:, 1] > 0).astype(np.float32).reshape(-1, 1)

X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)

# 定义逻辑回归模型
class LogisticRegression(nn.Module):
    def __init__(self, input_size):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_size, 1)
        self.sigmoid = nn.Sigmoid()

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

# 初始化模型
input_size = 2
model = LogisticRegression(input_size)

# 定义损失函数和优化器
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

# 保存整个模型（结构和参数）
torch.save(model, 'whole_model.pth')

# 加载整个模型
loaded_model = torch.load('whole_model.pth')
# 将模型设置为评估模式
loaded_model.eval()

# 生成新数据进行预测
new_X = np.random.randn(10, 2).astype(np.float32)
new_X_tensor = torch.from_numpy(new_X)

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

print("预测概率:")
print(predictions.numpy())
print("预测标签:")
print(predicted_labels.numpy())

代码解释

  1. 模型定义与训练：同样定义并训练逻辑回归模型。
  2. 保存整个模型：使用 torch.save(model, 'whole_model.pth') 保存模型的结构和参数。
  3. 加载整个模型：使用 torch.load('whole_model.pth') 直接加载整个模型。
  4. 预测：将模型设置为评估模式，生成新数据进行预测。

通过以上两种方式，可以根据不同的保存情况正确加载 PyTorch 模型。

五、计算pytorch模型预测结果的精确度

在机器学习任务中，计算预测结果的精确度（Accuracy）是评估模型性能的重要指标。对于回归任务，通常使用均方误差（MSE）、平均绝对误差（MAE）或R² 分数 来评估模型的性能；而对于分类任务，则使用准确率（Accuracy）、精确率（Precision）、召回率（Recall） 等指标。

以下是如何在 PyTorch 中计算预测结果的精确度（以回归任务为例）：

1. 分类任务的精确度计算

对于分类任务，常用的评估指标是准确率（Accuracy），即预测正确的样本数占总样本数的比例。

代码实现

import torch

# 假设有真实标签和预测标签
y_true = torch.tensor([0, 1, 1, 0, 1, 0, 0, 1])  # 真实标签
y_pred = torch.tensor([0, 1, 0, 0, 1, 0, 1, 1])  # 预测标签

# 计算准确率
accuracy = (y_true == y_pred).float().mean()
print(f"准确率: {accuracy.item():.4f}")

 2. 回归任务的精确度计算

对于回归任务，常用的评估指标包括：

  • 均方误差（MSE）：预测值与真实值之间差异的平方的平均值。

  • 平均绝对误差（MAE）：预测值与真实值之间差异的绝对值的平均值。

  • R² 分数：表示模型对数据的拟合程度，取值范围为 [0, 1]，越接近 1 表示模型越好。

代码实现

import torch
import torch.nn as nn

# 假设有真实值和预测值
y_true = torch.tensor([3.0, 5.0, 7.0, 9.0], dtype=torch.float32)
y_pred = torch.tensor([2.8, 5.1, 7.2, 8.9], dtype=torch.float32)

# 计算均方误差 (MSE)
mse = nn.MSELoss()(y_pred, y_true)
print(f"Mean Squared Error (MSE): {mse.item():.4f}")

# 计算平均绝对误差 (MAE)
mae = nn.L1Loss()(y_pred, y_true)
print(f"Mean Absolute Error (MAE): {mae.item():.4f}")

# 计算 R² 分数
def r2_score(y_true, y_pred):
    ss_total = torch.sum((y_true - torch.mean(y_true)) ** 2)
    ss_residual = torch.sum((y_true - y_pred) ** 2)
    r2 = 1 - (ss_residual / ss_total)
    return r2

r2 = r2_score(y_true, y_pred)
print(f"R²分数: {r2.item():.4f}")

六、计算pytorch模型预测结果的召回率

1. 召回率的定义

在分类任务中，召回率（Recall） 是一个重要的评估指标，用于衡量模型对正类样本的识别能力。召回率的定义是：

Recall= \frac{True Positives (TP)}{True Positives (TP)+False Negatives (FN)}

其中：

  • True Positives (TP)：模型正确预测为正类的样本数。

  • False Negatives (FN)：模型错误预测为负类的正类样本数。

2. 计算召回率的步骤

  1. 获取真实标签和预测标签：

  • 真实标签（y_true）：数据集中样本的真实类别。
  • 预测标签（y_pred）：模型对样本的预测类别。

  1. 计算混淆矩阵：

  • 通过比较 y_true 和 y_pred，计算混淆矩阵中的 TP 和 FN。

  1. 计算召回率：

        使用公式 Recall= \frac{TP}{TP+FN} 计算召回率。

3. 二分类任务召回率代码

  • 对于二分类任务，召回率衡量模型对正类样本的识别能力。

import torch

# 假设有真实标签和预测标签
y_true = torch.tensor([0, 1, 1, 0, 1, 0, 0, 1])  # 真实标签
y_pred = torch.tensor([0, 1, 0, 0, 1, 0, 1, 1])  # 预测标签

# 计算混淆矩阵
def confusion_matrix(y_true, y_pred):
    TP = ((y_true == 1) & (y_pred == 1)).sum().item()  # 模型正确预测为正类的样本数
    FN = ((y_true == 1) & (y_pred == 0)).sum().item()  # 模型错误预测为负类的正类样本数
    FP = ((y_true == 0) & (y_pred == 1)).sum().item()  # 模型错误预测为正类的正类样本数
    TN = ((y_true == 0) & (y_pred == 0)).sum().item()  # 模型正确预测为负类的样本数
    return TP, FN, FP, TN

# 计算召回率
def recall_score(y_true, y_pred):
    TP, FN, _, _ = confusion_matrix(y_true, y_pred)
    if TP + FN == 0:
        return 0.0  # 避免除以零
    return TP / (TP + FN)

# 计算召回率
recall = recall_score(y_true, y_pred)
print(f"召回率: {recall:.4f}")

 4. 多分类任务召回率代码

  • 对于多分类任务，可以分别计算每个类别的召回率，然后取平均值。

import torch

# 假设有真实标签和预测标签（多分类任务）
y_true = torch.tensor([0, 1, 2, 0, 1, 2])  # 真实标签
y_pred = torch.tensor([0, 1, 0, 0, 1, 2])  # 预测标签

# 计算每个类别的召回率
def recall_score_multiclass(y_true, y_pred, num_classes):
    recall_scores = []
    for cls in range(num_classes):
        TP = ((y_true == cls) & (y_pred == cls)).sum().item()  # 模型正确预测为正类的样本数
        FN = ((y_true == cls) & (y_pred != cls)).sum().item()  # 模型错误预测为负类的正类样本数
        if TP + FN == 0:
            recall_scores.append(0.0)  # 避免除以零
        else:
            recall_scores.append(TP / (TP + FN))
    return recall_scores

# 计算召回率
num_classes = 3
recall_scores = recall_score_multiclass(y_true, y_pred, num_classes)
for cls, recall in enumerate(recall_scores):
    print(f"每个类别的召回率 {cls}: {recall:.4f}")

# 计算宏平均召回率
macro_recall = sum(recall_scores) / num_classes
print(f"宏平均召回率: {macro_recall:.4f}")

七、计算pytorch模型预测结果的F1分数

1. F1分数的定义

F1 分数（F1 Score） 是分类任务中常用的评估指标，结合了 精确率（Precision） 和 召回率（Recall） 的信息。F1 分数的定义是：

F1 Score= 2\times \frac{Precision\times ×Recall}{Precision+Recall}

其中：

  • 精确率（Precision）：预测为正类的样本中，实际为正类的比例。

  • 召回率（Recall）：实际为正类的样本中，预测为正类的比例。

F1 分数的取值范围为 [0, 1]，越接近 1 表示模型性能越好。

2. 计算 F1 分数的步骤

  1. 获取真实标签和预测标签：

  • 真实标签（y_true）：数据集中样本的真实类别。
  • 预测标签（y_pred）：模型对样本的预测类别。

  1. 计算混淆矩阵：

  • 通过比较 y_true 和 y_pred，计算混淆矩阵中的 TP、FP 和 FN。

  1. 计算精确率和召回率：

  • 精确率：

Precision=\frac{TP}{TP+FP}

  • 召回率：

Recall=\frac{TP}{TP+FN}

  1. 计算 F1 分数：

  • 使用公式：

F1 Score= 2\times \frac{Precision\times ×Recall}{Precision+Recall}

3. 二分类任务F1分数代码

  • 对于二分类任务，F1 分数结合了精确率和召回率，是评估模型性能的重要指标。

import torch

# 假设有真实标签和预测标签
y_true = torch.tensor([0, 1, 1, 0, 1, 0, 0, 1])  # 真实标签
y_pred = torch.tensor([0, 1, 0, 0, 1, 0, 1, 1])  # 预测标签

# 计算混淆矩阵
def confusion_matrix(y_true, y_pred):
    TP = ((y_true == 1) & (y_pred == 1)).sum().item()  # 模型正确预测为正类的样本数
    FN = ((y_true == 1) & (y_pred == 0)).sum().item()  # 模型错误预测为负类的正类样本数
    FP = ((y_true == 0) & (y_pred == 1)).sum().item()  # 模型错误预测为正类的正类样本数
    TN = ((y_true == 0) & (y_pred == 0)).sum().item()  # 模型正确预测为负类的样本数
    return TP, FN, FP, TN

# 计算 F1 分数
def f1_score(y_true, y_pred):
    TP, FN, FP, _ = confusion_matrix(y_true, y_pred)
    
    # 计算精确率和召回率
    precision = TP / (TP + FP) if (TP + FP) > 0 else 0.0
    recall = TP / (TP + FN) if (TP + FN) > 0 else 0.0
    
    # 计算 F1 分数
    if precision + recall == 0:
        return 0.0  # 避免除以零
    f1 = 2 * (precision * recall) / (precision + recall)
    return f1

# 计算 F1 分数
f1 = f1_score(y_true, y_pred)
print(f"F1分数: {f1:.4f}")

4. 多分类任务F1分数代码

  • 对于多分类任务，可以分别计算每个类别的 F1 分数，然后取平均值。

import torch

# 假设有真实标签和预测标签（多分类任务）
y_true = torch.tensor([0, 1, 2, 0, 1, 2])  # 真实标签
y_pred = torch.tensor([0, 1, 0, 0, 1, 2])  # 预测标签

# 计算每个类别的 F1 分数
def f1_score_multiclass(y_true, y_pred, num_classes):
    f1_scores = []
    for cls in range(num_classes):
        TP = ((y_true == cls) & (y_pred == cls)).sum().item()  # 模型正确预测为正类的样本数
        FN = ((y_true == cls) & (y_pred != cls)).sum().item()  # 模型错误预测为负类的正类样本数
        FP = ((y_true != cls) & (y_pred == cls)).sum().item()  # 模型错误预测为正类的正类样本数
        
        # 计算精确率和召回率
        precision = TP / (TP + FP) if (TP + FP) > 0 else 0.0
        recall = TP / (TP + FN) if (TP + FN) > 0 else 0.0
        
        # 计算 F1 分数
        if precision + recall == 0:
            f1_scores.append(0.0)  # 避免除以零
        else:
            f1_scores.append(2 * (precision * recall) / (precision + recall))
    return f1_scores

# 计算 F1 分数
num_classes = 3
f1_scores = f1_score_multiclass(y_true, y_pred, num_classes)
for cls, f1 in enumerate(f1_scores):
    print(f"每个类别的F1分数 {cls}: {f1:.4f}")

# 计算宏平均 F1 分数
macro_f1 = sum(f1_scores) / num_classes
print(f"宏平均 F1 分数: {macro_f1:.4f}")

八、完整流程（使用直接继承 nn.Module逻辑回归，且仅保存模型的权重和其他参数，计算了二分类任务的精确度、召回率及F1分数）

1. 实现思路

① 自定义数据集：

生成 100 个样本，每个样本有 2 个特征。

根据特征生成标签，使用简单的线性组合和阈值判断。

② 定义逻辑回归模型：

使用 nn.Linear 定义一个线性层，并通过  实现逻辑回归。

③ 训练模型：

使用二元交叉熵损失 (nn.BCELoss) 和随机梯度下降优化器 (optim.SGD) 训练模型。

④ 保存模型：

使用 torch.save 保存模型参数。

⑤ 加载模型：

使用 torch.load 加载模型参数。

⑥ 预测：

加载模型后，使用新数据进行预测，并将概率转换为类别（0 或 1）。

⑦ 评估模型：

计算模型的精确度、召回率和 F1 分数。

2. 代码示例

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 自定义数据集
# 生成 100 个样本，每个样本有 2 个特征
X = np.random.randn(100, 2).astype(np.float32)
# 根据特征生成标签，使用简单的线性组合和阈值判断
y = (2 * X[:, 0] + 3 * X[:, 1] > 0).astype(np.float32).reshape(-1, 1)

# 将 numpy 数组转换为 PyTorch 张量
X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)

# 定义逻辑回归模型
class LogisticRegression(nn.Module):
    def __init__(self, input_size):
        super(LogisticRegression, self).__init__()
        self.linear = nn.Linear(input_size, 1)
        self.sigmoid = nn.Sigmoid()

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

# 初始化模型
input_size = 2
model = LogisticRegression(input_size)

# 定义损失函数和优化器
criterion = nn.BCELoss()  # 二元交叉熵损失函数
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):
    # 前向传播
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)

    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

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

# 保存模型
torch.save(model.state_dict(), 'logistic_regression_model.pth')

# 加载模型
loaded_model = LogisticRegression(input_size)
loaded_model.load_state_dict(torch.load('logistic_regression_model.pth'))
loaded_model.eval()

# 生成新数据进行预测
new_X = np.random.randn(10, 2).astype(np.float32)
new_X_tensor = torch.from_numpy(new_X)

# 使用加载的模型进行预测
with torch.no_grad():
    predictions = loaded_model(new_X_tensor)
    predicted_labels = (predictions >= 0.5).float()

print("预测概率:")
print(predictions.numpy())
print("预测标签:")
print(predicted_labels.numpy())

# 计算精确度、召回率和 F1 分数
def evaluate_model(y_true, y_pred):
    # 计算混淆矩阵
    TP = ((y_true == 1) & (y_pred == 1)).sum().item()  # 模型正确预测为正类的样本数
    FN = ((y_true == 1) & (y_pred == 0)).sum().item()  # 模型错误预测为负类的正类样本数
    FP = ((y_true == 0) & (y_pred == 1)).sum().item()  # 模型错误预测为正类的正类样本数
    TN = ((y_true == 0) & (y_pred == 0)).sum().item()  # 模型正确预测为负类的样本数

    # 计算精确度、召回率和 F1 分数
    accuracy = (TP + TN) / (TP + TN + FP + FN) if (TP + TN + FP + FN) > 0 else 0.0
    precision = TP / (TP + FP) if (TP + FP) > 0 else 0.0
    recall = TP / (TP + FN) if (TP + FN) > 0 else 0.0
    f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0.0

    return accuracy, precision, recall, f1

# 对训练集进行预测，计算评估指标
with torch.no_grad():
    train_predictions = loaded_model(X_tensor)
    train_predicted_labels = (train_predictions >= 0.5).float()

# 计算评估指标
accuracy, precision, recall, f1 = evaluate_model(y_tensor, train_predicted_labels)

# 输出结果
print("\n模型评估结果:")
print(f"精确度: {accuracy:.4f}")
print(f"精确率: {precision:.4f}")
print(f"召回率: {recall:.4f}")
print(f"F1分数: {f1:.4f}")

3. 代码解释 

① 数据集生成：

  • X = np.random.randn(100, 2).astype(np.float32)：生成 100 个样本，每个样本有 2 个特征。
  • y = (2 * X[:, 0] + 3 * X[:, 1] > 0).astype(np.float32).reshape(-1, 1)：根据特征的线性组合生成标签，大于 0 标记为 1，否则标记为 0。
  • X_tensor = torch.from_numpy(X) 和 y_tensor = torch.from_numpy(y)：将 numpy 数组转换为 PyTorch 张量。

② 模型定义：

  • LogisticRegression 类继承自 nn.Module，包含一个线性层 nn.Linear 和一个 Sigmoid 激活函数 nn.Sigmoid。
  • forward 方法定义了前向传播的逻辑。

③ 损失函数和优化器：

  • criterion = nn.BCELoss()：使用二元交叉熵损失函数，适用于二分类问题。
  • optimizer = optim.SGD(model.parameters(), lr=0.01)：使用随机梯度下降优化器，学习率为 0.01。

④ 模型训练：

  • 通过多次迭代进行前向传播、损失计算、反向传播和参数更新。
  • 每 100 个 epoch 打印一次损失值。

⑤ 模型保存：

  • torch.save(model.state_dict(), 'logistic_regression_model.pth')：保存模型的参数到本地文件 logistic_regression_model.pth。

⑥ 模型加载和预测：

  1. loaded_model = LogisticRegression(input_size)：创建一个新的模型实例。
  2. loaded_model.load_state_dict(torch.load('logistic_regression_model.pth'))：加载保存的模型参数。
  3. loaded_model.eval()：将模型设置为评估模式。
  4. 生成新数据 new_X 并转换为张量 new_X_tensor。
  5. 使用 loaded_model 进行预测，通过 (predictions >= 0.5).float() 将预测概率转换为标签。

⑦ 模型评估：

  • 定义 evaluate_model 函数：

        计算混淆矩阵（TP、FN、FP、TN）。

        计算精确度、精确率、召回率和 F1 分数。

  • 对训练集进行预测并计算评估指标：

        train_predictions = loaded_model(X_tensor)：计算训练集的预测概率。

        train_predicted_labels = (train_predictions >= 0.5).float()：将预测概率转换为标签。

  • 输出评估结果：

        精确度（Accuracy）：模型预测正确的样本比例。

        精确率（Precision）：预测为正类的样本中，实际为正类的比例。

        召回率（Recall）：实际为正类的样本中，预测为正类的比例。

        F1 分数（F1 Score）：精确率和召回率的调和平均值。


http://www.kler.cn/a/528053.html

相关文章：

  • Spring JDBC：简化数据库操作的利器
  • 5. 【Vue实战--孢子记账--Web 版开发】-- 主页UI
  • [论文阅读] (37)CCS21 DeepAID：基于深度学习的异常检测（解释）
  • AutoDL 云服务器：xfce4 远程桌面 终端乱码 + 谷歌浏览器
  • 【Java异步编程】CompletableFuture基础（1）：创建不同线程的子任务、子任务链式调用与异常处理
  • 【leetcode详解】T3175(一点反思)
  • 【愚公系列】《循序渐进Vue.js 3.x前端开发实践》040-Vue过渡动画
  • git基础使用--1--版本控制的基本概念
  • Flutter常用Widget小部件
  • 数据结构 树2
  • Spring Boot 实例解析：从概念到代码
  • STM32 01 LED
  • [原创](Modern C++)现代C++的关键性概念: 流格式化
  • 网络基础
  • 8.[前端开发-CSS]Day08-图形-字体-字体图标-元素定位
  • 【Git】初识Git Git基本操作详解
  • XML Schema 数值数据类型
  • 物联网 STM32【源代码形式-ESP8266透传】连接OneNet IOT从云产品开发到底层MQTT实现，APP控制 【保姆级零基础搭建】
  • 50. 正点原子官方系统镜像烧写实验
  • 100.1 AI量化面试题：解释夏普比率(Sharpe Ratio)的计算方法及其在投资组合管理中的应用，并说明其局限性
  • 什么是“知识蒸馏”
  • 云计算部署模式全面解析
  • HTML5 技术深度解读：本地存储与地理定位的最佳实践
  • ArkTS语言介绍
  • 全程Kali linux---CTFshow misc入门（25-37）
  • 深度学习练手小例子——cifar10数据集分类问题