微信公众号外链接网站开发,网络seo优化服务,有什么专门搜试卷做的网站,网络设计网站建设类网站模板一、使用pytorch框架实现逻辑回归
1. 数据部分#xff1a;
首先自定义了一个简单的数据集#xff0c;特征 X 是 100 个随机样本#xff0c;每个样本一个特征#xff0c;目标值 y 基于线性关系并添加了噪声。将 numpy 数组转换为 PyTorch 张量#xff0c;方便后续在模型中…一、使用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(), lr0.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(fEpoch [{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 xmodel LinearRegression()# 定义损失函数和优化器
criterion nn.MSELoss()
optimizer torch.optim.SGD(model.parameters(), lr0.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(fEpoch [{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 xmodel LinearRegression()# 定义损失函数和优化器
criterion nn.MSELoss()
optimizer torch.optim.SGD(model.parameters(), lr0.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(fEpoch [{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(), lr0.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(fEpoch [{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(), lr0.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(fEpoch [{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())代码解释
模型训练首先定义并训练一个逻辑回归模型。保存模型使用 torch.save(model.state_dict(), model_weights.pth) 保存模型的状态字典到文件 model_weights.pth。加载模型先创建一个新的模型实例 loaded_model然后使用 loaded_model.load_state_dict(torch.load(model_weights.pth)) 加载保存的状态字典。预测将模型设置为评估模式生成新数据进行预测。
方式 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(), lr0.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(fEpoch [{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())代码解释
模型训练同样先定义并训练逻辑回归模型。保存模型使用 torch.save(model, whole_model.pth) 保存整个模型对象到文件 whole_model.pth。加载模型使用 torch.load(whole_model.pth) 直接加载整个模型。预测将模型设置为评估模式生成新数据进行预测。
通过以上两种方式可以根据实际需求选择合适的模型保存和加载方法。
三、加载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(), lr0.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(fEpoch [{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())代码解释
模型定义与训练定义了一个简单的逻辑回归模型并使用自定义数据集进行训练。保存参数使用 torch.save(model.state_dict(), model_params.pth) 保存模型的参数。加载参数 重新定义与原模型相同结构的 loaded_model。使用 loaded_model.load_state_dict(torch.load(model_params.pth)) 加载保存的参数。 预测将模型设置为评估模式生成新数据进行预测。
方式 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(), lr0.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(fEpoch [{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())代码解释
模型定义与训练同样定义并训练逻辑回归模型。保存整个模型使用 torch.save(model, whole_model.pth) 保存模型的结构和参数。加载整个模型使用 torch.load(whole_model.pth) 直接加载整个模型。预测将模型设置为评估模式生成新数据进行预测。
通过以上两种方式可以根据不同的保存情况正确加载 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], dtypetorch.float32)
y_pred torch.tensor([2.8, 5.1, 7.2, 8.9], dtypetorch.float32)# 计算均方误差 (MSE)
mse nn.MSELoss()(y_pred, y_true)
print(fMean Squared Error (MSE): {mse.item():.4f})# 计算平均绝对误差 (MAE)
mae nn.L1Loss()(y_pred, y_true)
print(fMean 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 r2r2 r2_score(y_true, y_pred)
print(fR²分数: {r2.item():.4f})
六、计算pytorch模型预测结果的召回率
1. 召回率的定义
在分类任务中召回率Recall 是一个重要的评估指标用于衡量模型对正类样本的识别能力。召回率的定义是 其中 True Positives (TP)模型正确预测为正类的样本数。 False Negatives (FN)模型错误预测为负类的正类样本数。
2. 计算召回率的步骤 获取真实标签和预测标签
真实标签y_true数据集中样本的真实类别。预测标签y_pred模型对样本的预测类别。 计算混淆矩阵
通过比较 y_true 和 y_pred计算混淆矩阵中的 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 分数的定义是 其中 精确率Precision预测为正类的样本中实际为正类的比例。 召回率Recall实际为正类的样本中预测为正类的比例。
F1 分数的取值范围为 [0, 1]越接近 1 表示模型性能越好。
2. 计算 F1 分数的步骤 获取真实标签和预测标签
真实标签y_true数据集中样本的真实类别。预测标签y_pred模型对样本的预测类别。 计算混淆矩阵
通过比较 y_true 和 y_pred计算混淆矩阵中的 TP、FP 和 FN。 计算精确率和召回率
精确率 召回率 计算 F1 分数
使用公式 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.0recall 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(fF1分数: {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.0recall 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(), lr0.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(fEpoch [{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.0precision TP / (TP FP) if (TP FP) 0 else 0.0recall TP / (TP FN) if (TP FN) 0 else 0.0f1 2 * (precision * recall) / (precision recall) if (precision recall) 0 else 0.0return 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(fF1分数: {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(), lr0.01)使用随机梯度下降优化器学习率为 0.01。
④ 模型训练
通过多次迭代进行前向传播、损失计算、反向传播和参数更新。每 100 个 epoch 打印一次损失值。
⑤ 模型保存
torch.save(model.state_dict(), logistic_regression_model.pth)保存模型的参数到本地文件 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 并转换为张量 new_X_tensor。使用 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精确率和召回率的调和平均值。
