大学网站 作风建设专题,北京seo关键词排名优化软件,郑州汉狮专业做网站公司,教育网站建设市场分析计划书一、数据集的划分
#xff08;1#xff09;按一定比例划分为训练集和测试集
我们通常取8-2、7-3、6-4、5-5比例切分#xff0c;直接将数据随机划分为训练集和测试集#xff0c;然后使用训练集来生成模型#xff0c;再用测试集来测试模型的正确率和误差#xff0c;以验证…一、数据集的划分
1按一定比例划分为训练集和测试集
我们通常取8-2、7-3、6-4、5-5比例切分直接将数据随机划分为训练集和测试集然后使用训练集来生成模型再用测试集来测试模型的正确率和误差以验证模型的有效性。
这种方法常见于决策树、朴素贝叶斯分类器、线性回归和逻辑回归等任务中。
2交叉验证法
交叉验证一般采用k折交叉验证即k-fold cross validation往往k取为10。在这种数据集划分法中我们将数据集划分为k个子集每个子集均做一次测试集每次将其余的作为训练集。在交叉验证时我们重复训练k次每次选择一个子集作为测试集并将k次的平均交叉验证的正确率作为最终的结果。
from sklearn.model_selection import KFold
import numpy as np# 将PyTorch Tensor转为Numpy
X_np X.numpy()
y_np y.numpy()# 5折交叉验证
kf KFold(n_splits5, shuffleTrue, random_state42)
for fold, (train_idx, val_idx) in enumerate(kf.split(X_np)):# 转换为PyTorch DataLoadertrain_fold TensorDataset(torch.from_numpy(X_np[train_idx]), torch.from_numpy(y_np[train_idx]))val_fold TensorDataset(torch.from_numpy(X_np[val_idx]), torch.from_numpy(y_np[val_idx]))train_loader DataLoader(train_fold, batch_size32, shuffleTrue)val_loader DataLoader(val_fold, batch_size32)print(fFold {fold1}: Train {len(train_fold)}, Val {len(val_fold)})
3训练集、验证集、测试集法
我们首先将数据集划分为训练集和测试集由于模型的构建过程中也需要检验模型检验模型的配置以及训练程度过拟合还是欠拟合所以会将训练数据再划分为两个部分一部分是用于训练的训练集另一部分是进行检验的验证集。验证集可以重复使用主要是用来辅助我们构建模型的。
训练集用于训练得到神经网络模型然后用验证集验证模型的有效性挑选获得最佳效果的模型直到我们得到一个满意的模型为止。最后当模型“通过”验证集之后我们再使用测试集测试模型的最终效果评估模型的准确率以及误差等。测试集只在模型检验时使用绝对不能根据测试集上的结果来调整网络参数配置以及选择训练好的模型否则会导致模型在测试集上过拟合。
一般来说最终的正确率训练集大于验证集验证集大于测试集。
对于部分机器学习任务我们划分的测试集必须是模型从未见过的数据比如语音识别中一个完全不同的人的说话声图像识别中一个完全不同的识别个体。这时一般来说训练集和验证集的数据分布是同分布的而测试集的数据分布与前两者会略有不同。在这种情况下通常测试集的正确率会比验证集的正确率低得多这样就可以看出模型的泛化能力可以预测出实际应用中的真实效果。
下面是按照 8-1-1 划分数据集的代码示例
import torch
from torch.utils.data import DataLoader, TensorDataset, random_split# 生成示例数据
X torch.randn(1000, 10) # 1000个样本10维特征
y torch.randint(0, 2, (1000,)) # 二分类标签
dataset TensorDataset(X, y)# 划分比例80%训练10%验证10%测试
train_size int(0.8 * len(dataset))
val_size int(0.1 * len(dataset))
test_size len(dataset) - train_size - val_sizetrain_dataset, val_dataset, test_dataset random_split(dataset, [train_size, val_size, test_size],generatortorch.Generator().manual_seed(42) # 固定随机种子
)# 创建DataLoader
train_loader DataLoader(train_dataset, batch_size32, shuffleTrue)
val_loader DataLoader(val_dataset, batch_size32)
test_loader DataLoader(test_dataset, batch_size32)print(f训练集样本数: {len(train_dataset)}) # 直接查看原始数据集
print(fDataLoader 批次数量: {len(train_loader)}) # 总批次 样本数 // batch_size# 获取第一个批次的数据
batch next(iter(train_loader)) # 返回的是 (features, labels)
features, labels batch# 查看特征和标签的形状
print(特征张量形状:, features.shape) # [batch_size, 10]
print(标签张量形状:, labels.shape) # [batch_size]
print(标签示例:, labels[:5]) # 查看前5个标签
二、偏差与方差 假设这就是数据集如果给这个数据集拟合一条直线可能得到一个逻辑回归拟合但它并不能很好地拟合该数据这是高偏差high bias的情况我们称为**“欠拟合”underfitting**。 相反的如果我们拟合一个非常复杂的分类器比如深度神经网络或含有隐藏单元的神经网络可能就非常适用于这个数据集但是这看起来也不是一种很好的拟合方式分类器方差较高high variance数据过度拟合overfitting。 衡量方式
一般可通过查看训练集与验证集误差来诊断。 评估偏差bias一般看训练集 训练集误差大——偏差较高欠拟合 评估方差variance一般看验证集 训练集误差小验证集误差大——方差较高过拟合 学习曲线 学习曲线作用 查看模型的学习效果 通过学习曲线可以清晰的看出模型对数据的过拟合和欠拟合 学习曲线随着训练样本的逐渐增多算法训练出的模型的表现能力 表现能力也就是模型的预测准确情况。 总结就是如果训练样本准确率一直上不去就是欠拟合如果训练集准确率很高但是验证集很低就是过拟合。下面是两个案例
案例 1——欠拟合
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt# 生成非线性数据100个样本
torch.manual_seed(42)
x torch.unsqueeze(torch.linspace(-5, 5, 100), 1)
y torch.sin(x) * 2 torch.normal(0, 0.3, x.shape)# 划分训练集70%和验证集30%
split int(0.7 * len(x))
x_train, y_train x[:split], y[:split]
x_val, y_val x[split:], y[split:]# 构建欠拟合模型单层线性回归
class UnderfitModel(nn.Module):def __init__(self):super().__init__()self.linear nn.Linear(1, 1) # 仅一个线性层def forward(self, x):return self.linear(x)model UnderfitModel()
optimizer optim.SGD(model.parameters(), lr0.01) # 使用低学习率
criterion nn.MSELoss()# 训练过程仅50次迭代
train_loss []
val_loss []
for epoch in range(50):# 训练模式model.train()output model(x_train)loss criterion(output, y_train)optimizer.zero_grad()loss.backward()optimizer.step()# 验证模式model.eval()with torch.no_grad():val_pred model(x_val)v_loss criterion(val_pred, y_val)# 记录损失train_loss.append(loss.item())val_loss.append(v_loss.item())# 可视化损失曲线
plt.figure(figsize(10,5))
plt.plot(train_loss, labeltrain_loss)
plt.plot(val_loss, labelvalid_loss)
plt.ylim(0, 5)
plt.legend()
plt.title(欠拟合训练过程)
plt.show()# 最终预测可视化
model.eval()
with torch.no_grad():pred model(x)plt.figure(figsize(12,5))
plt.scatter(x_train, y_train, cr, labeltrain_data)
plt.scatter(x_val, y_val, cg, labelvalid_data)
plt.plot(x, pred.numpy(), b-, lw3, labelmodel_predict)
plt.plot(x, torch.sin(x)*2, k--, labeltrue_function)
plt.legend()
plt.show()# 输出误差指标
print(f[最终误差] 训练集{train_loss[-1]:.4f} | 验证集{val_loss[-1]:.4f})
print(f模型参数w{model.linear.weight.item():.2f}, b{model.linear.bias.item():.2f})它最终的学习曲线如下 可以很明显看到模型预测与真实曲线相差很远 案例 2——过拟合
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt# 生成少量训练数据20个样本
torch.manual_seed(1)
x_train torch.unsqueeze(torch.linspace(-5, 5, 20), dim1)
y_train 1.2 * x_train 0.8 torch.normal(0, 0.5, sizex_train.size())# 构建过参数化模型4层全连接网络
class OverfitModel(nn.Module):def __init__(self):super().__init__()self.net nn.Sequential(nn.Linear(1, 100),nn.ReLU(),nn.Linear(100, 100),nn.ReLU(),nn.Linear(100, 100),nn.ReLU(),nn.Linear(100, 1))def forward(self, x):return self.net(x)model OverfitModel()
optimizer optim.Adam(model.parameters(), lr0.01)
criterion nn.MSELoss()# 训练循环3000次迭代
loss_history []
for epoch in range(3000):output model(x_train)loss criterion(output, y_train)optimizer.zero_grad()loss.backward()optimizer.step()loss_history.append(loss.item())# 生成测试数据同分布但未参与训练
x_test torch.unsqueeze(torch.linspace(-6, 6, 100), dim1)
y_test 1.2 * x_test 0.8 torch.normal(0, 0.5, sizex_test.size())# 绘制结果对比
plt.figure(figsize(12,5))
plt.scatter(x_train.numpy(), y_train.numpy(), cr, labeltrain_data)
plt.plot(x_test.numpy(), model(x_test).detach().numpy(), b-, lw3, labelpredict)
plt.plot(x_test.numpy(), 1.2*x_test0.8, g--, labeltrue_function)
plt.legend()
plt.show()# 输出训练误差和测试误差
train_loss criterion(model(x_train), y_train)
test_loss criterion(model(x_test), y_test)
print(f训练误差{train_loss.item():.4f})
print(f测试误差{test_loss.item():.4f})可以看到最后生成的拟合曲线如蓝色所示很明显过拟合切测试误差比训练误差大很多 三、过拟合欠拟合的处理方式
1、首先根据训练集效果来判断是否是高偏差也就是是否欠拟合。
如果不是跳转到下一步判断是否高方差。
如果是有四种可尝试的方法
A、新网络比如更多的隐藏层或隐藏单元。
B、增加新特征可以考虑加入进特征组合、高次特征或者添加多项式特征将线性模型通过添加二次项或者三次项使模型泛化能力更强
C、用更多时间训练算法。
D、尝试更先进的优化算法。
反复调试直到偏差降到和接受范围内然后进行下一步。
2、根据验证集效果来判断是否是高方差也就是是否过拟合。
如果不是说明得到了很好的结果训练结束开始将该模型放入测试集。
如果是有三种可尝试的方法
A、更多数据来训练。
B、正则化来减少过拟合。
C、控制模型的复杂度用dropout、early stopping等方法
D、尝试新网络框架有时有用有时没用。
名词解释
- 正则化
L2正则化目标函数中增加所有权重w参数的平方之和, 逼迫所有w尽可能趋向零但不为零. 因为过拟合的时候, 拟合函数需要顾忌每一个点, 最终形成的拟合函数波动很大, 在某些很小的区间里, 函数值的变化很剧烈, 也就是某些w非常大. 为此, L2正则化的加入就惩罚了权重变大的趋势. model nn.Sequential(nn.Linear(784, 256),nn.ReLU(),nn.Linear(256, 10)
)# 设置优化器时添加weight_decay参数L2系数
optimizer optim.Adam(model.parameters(), lr0.001, weight_decay1e-4)
L1正则化目标函数中增加所有权重w参数的绝对值之和, 逼迫更多w为零(也就是变稀疏. L2因为其导数也趋0, 奔向零的速度不如L1给力了).大家对稀疏规则化趋之若鹜的一个关键原因在于它能实现特征的自动选择。一般来说xi的大部分元素也就是特征都是和最终的输出yi没有关系或者不提供任何信息的在最小化目标函数的时候考虑xi这些额外的特征虽然可以获得更小的训练误差但在预测新的样本时这些没用的特征权重反而会被考虑从而干扰了对正确yi的预测。稀疏规则化算子的引入就是为了完成特征自动选择的光荣使命它会学习地去掉这些无用的特征也就是把这些特征对应的权重置为0。 L1 正则化 torch 没有直接实现可以手动实现
def l1_regularization(model, lambda_l1):l1_loss 0for param in model.parameters():l1_loss torch.sum(torch.abs(param))return lambda_l1 * l1_loss# 训练循环
for data, target in dataloader:optimizer.zero_grad()output model(data)loss F.cross_entropy(output, target)# 添加L1正则项l1_lambda 0.001loss l1_regularization(model, l1_lambda)loss.backward()optimizer.step()下面是一个同时引用 L1 正则化和 L2 正则化的案例
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as Fclass RegularizedModel(nn.Module):def __init__(self):super().__init__()self.fc nn.Sequential(nn.Flatten(), nn.Linear(784, 256),nn.BatchNorm1d(256),nn.ReLU(),nn.Linear(256, 10))def forward(self, x):return self.fc(x)def train(model, train_loader, lambda_l10, lambda_l20):optimizer optim.AdamW(model.parameters(), lr0.001)for epoch in range(100):total_loss 0for x, y in train_loader:optimizer.zero_grad()pred model(x)loss F.cross_entropy(pred, y)# L1正则项if lambda_l1 0:l1 sum(p.abs().sum() for p in model.parameters())loss lambda_l1 * l1# L2正则项if lambda_l2 0:l2 sum(p.pow(2).sum() for p in model.parameters())loss 0.5 * lambda_l2 * l2loss.backward()optimizer.step()total_loss loss.item()print(fEpoch {epoch}: Loss{total_loss/len(train_loader):.4f})# 使用示例import torch
from torch.utils.data import DataLoader, TensorDataset# 参数配置
batch_size 16
input_dim 784 # 对应模型输入维度
num_classes 10
num_samples 1000 # 总样本量# 生成正态分布虚拟数据
X torch.randn(num_samples, input_dim) # 形状 (1000, 784)
y torch.randint(0, num_classes, (num_samples,)) # 随机标签# 创建数据集和数据加载器
dataset TensorDataset(X, y)
train_loader DataLoader(dataset, batch_sizebatch_size, shuffleTrue)# 验证数据形状
sample_X, sample_y next(iter(train_loader))
print(f输入数据形状: {sample_X.shape}) # 应输出 torch.Size([16, 784])
print(f标签形状: {sample_y.shape}) # 应输出 torch.Size([16])model RegularizedModel()
train(model, train_loader, lambda_l11e-5, lambda_l21e-4)- dropout
在训练的运行的时候让神经元以超参数p的概率被激活(也就是1-p的概率被设置为0), 每个w因此随机参与, 使得任意w都不是不可或缺的, 效果类似于数量巨大的模型集成。
class RegularizedModel(nn.Module):def __init__(self, input_dim):super().__init__()self.net nn.Sequential(nn.Linear(input_dim, 128),nn.ReLU(),nn.Dropout(0.5), # 添加Dropout层nn.Linear(128, 64),nn.ReLU(),nn.Dropout(0.3),nn.Linear(64, 1))def forward(self, x):return torch.sigmoid(self.net(x)).squeeze()
- early stop
提前终止训练即在模型对训练数据集迭代收敛之前停止迭代来防止过拟合常用的停止条件就是当 N 轮迭代都loss 都没有降低后可以停止迭代
下面案例的停止条件就是当 loss 连续 10 次都没有低于最佳 loss-0.001时就触发这里设置了一个delta为 0.001就能保证即使损失有波动只要未突破阈值就计数
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
from torch.utils.data import DataLoader, TensorDataset# 早停监控器带模型保存功能
class EarlyStopper:def __init__(self, patience5, delta0, pathbest_model.pth):self.patience patience # 容忍epoch数self.delta delta # 视为改进的最小变化量self.path path # 最佳模型保存路径self.counter 0 # 未改进计数器self.best_score None # 最佳监控指标值self.early_stop False # 停止标志def __call__(self, val_loss, model):score -val_loss # 默认监控验证损失越大越好if self.best_score is None:self.best_score scoreself.save_checkpoint(model)elif score self.best_score self.delta:self.counter 1print(fEarlyStopping counter: {self.counter}/{self.patience})if self.counter self.patience:self.early_stop Trueelse:self.best_score scoreself.save_checkpoint(model)self.counter 0def save_checkpoint(self, model):torch.save(model.state_dict(), self.path)# 生成模拟数据回归任务
def generate_data(samples1000):X torch.linspace(-10, 10, samples).unsqueeze(1)y 0.5 * X**3 - 2 * X**2 3 * X torch.randn(X.size()) * 10return X, y# 过参数化的全连接网络
class OverfitModel(nn.Module):def __init__(self):super().__init__()self.net nn.Sequential(nn.Linear(1, 128),nn.ReLU(),nn.Linear(128, 256),nn.ReLU(),nn.Linear(256, 128),nn.ReLU(),nn.Linear(128, 1))def forward(self, x):return self.net(x)# 训练函数集成早停
def train_with_earlystop(model, train_loader, val_loader, epochs1000):optimizer optim.Adam(model.parameters(), lr0.001)criterion nn.MSELoss()early_stopper EarlyStopper(patience10, delta0.001)train_losses []val_losses []for epoch in range(epochs):# 训练阶段model.train()train_loss 0for X_batch, y_batch in train_loader:optimizer.zero_grad()pred model(X_batch)loss criterion(pred, y_batch)loss.backward()optimizer.step()train_loss loss.item()train_loss / len(train_loader)train_losses.append(train_loss)# 验证阶段model.eval()val_loss 0with torch.no_grad():for X_val, y_val in val_loader:pred_val model(X_val)val_loss criterion(pred_val, y_val).item()val_loss / len(val_loader)val_losses.append(val_loss)print(fEpoch {epoch1:03d} | fTrain Loss: {train_loss:.4f} | fVal Loss: {val_loss:.4f})# 早停检查early_stopper(val_loss, model)if early_stopper.early_stop:print( Early stopping triggered)break# 恢复最佳模型model.load_state_dict(torch.load(best_model.pth))return train_losses, val_losses# 可视化训练过程
def plot_learning_curve(train_loss, val_loss):plt.figure(figsize(10, 6))plt.plot(train_loss, labelTraining Loss)plt.plot(val_loss, labelValidation Loss)plt.xlabel(Epochs)plt.ylabel(Loss)plt.title(Learning Curve with Early Stopping)plt.legend()plt.grid(True)plt.show()# 主程序
if __name__ __main__:# 数据准备X, y generate_data()dataset TensorDataset(X, y)# 划分训练集和验证集8:2train_size int(0.8 * len(dataset))val_size len(dataset) - train_sizetrain_dataset, val_dataset torch.utils.data.random_split(dataset, [train_size, val_size])train_loader DataLoader(train_dataset, batch_size32, shuffleTrue)val_loader DataLoader(val_dataset, batch_size32)# 初始化模型model OverfitModel()# 开始训练train_loss, val_loss train_with_earlystop(model, train_loader, val_loader, epochs1000)# 绘制学习曲线plot_learning_curve(train_loss, val_loss)# 最终模型测试model.eval()with torch.no_grad():test_input torch.tensor([[5.0], [-3.0], [8.0]])predictions model(test_input)print(\nModel Predictions at x5, -3, 8:)print(predictions.numpy())四、模型的效果评估
具体模型的评估方法也可以看我之前的文章本文主要补充一些代码案例【Python数据分析】数据挖掘建模——分类与预测算法评价含ROC曲线、F1等指标的解释_分类f1指标 python-CSDN博客
1分类任务评估混淆矩阵、AUC
from sklearn.metrics import confusion_matrix, roc_auc_scoredef evaluate_model(model, loader):model.eval()all_preds []all_labels []with torch.no_grad():for X_batch, y_batch in loader:outputs model(X_batch)preds (outputs 0.5).float()all_preds.extend(preds.cpu().numpy())all_labels.extend(y_batch.cpu().numpy())# 计算指标cm confusion_matrix(all_labels, all_preds)auc roc_auc_score(all_labels, all_preds)print(Confusion Matrix:)print(cm)print(fAUC Score: {auc:.4f})# 在测试集上评估
evaluate_model(model, test_loader)
2回归任务评估MAE、MSE
def evaluate_regression(model, loader):model.eval()total_mae 0total_mse 0with torch.no_grad():for X_batch, y_batch in loader:outputs model(X_batch)mae torch.abs(outputs - y_batch).mean()mse ((outputs - y_batch)**2).mean()total_mae mae.item() * X_batch.size(0)total_mse mse.item() * X_batch.size(0)mae total_mae / len(loader.dataset)mse total_mse / len(loader.dataset)print(fMAE: {mae:.4f}, MSE: {mse:.4f})
当然也可以把二者结合一下
import torch
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import (roc_curve, auc, confusion_matrix, precision_recall_curve,r2_score,mean_squared_error
)
import seaborn as snsdef evaluate_model(model, data_loader, task_typeclassification):综合模型评估函数参数model : 训练好的PyTorch模型data_loader : 数据加载器task_type : 任务类型 [classification, regression]返回包含各项指标的字典model.eval()device next(model.parameters()).deviceall_targets []all_outputs []with torch.no_grad():for inputs, targets in data_loader:inputs inputs.to(device)outputs model(inputs)all_targets.append(targets.cpu().numpy())all_outputs.append(outputs.cpu().numpy())y_true np.concatenate(all_targets)y_pred np.concatenate(all_outputs)metrics {}if task_type classification:# 分类任务指标y_prob torch.softmax(torch.tensor(y_pred), dim1).numpy()y_pred_labels np.argmax(y_pred, axis1)# 多分类AUC计算OvR策略fpr dict()tpr dict()roc_auc dict()n_classes y_prob.shape[1]for i in range(n_classes):fpr[i], tpr[i], _ roc_curve((y_true i).astype(int), y_prob[:, i])roc_auc[i] auc(fpr[i], tpr[i])# 计算宏观平均AUCfpr[macro], tpr[macro], _ roc_curve(y_true.ravel(), y_prob.ravel())roc_auc[macro] auc(fpr[macro], tpr[macro])metrics.update({accuracy: np.mean(y_pred_labels y_true),auc_macro: roc_auc[macro],confusion_matrix: confusion_matrix(y_true, y_pred_labels),classification_report: classification_report(y_true, y_pred_labels)})# 绘制ROC曲线plt.figure(figsize(10, 6))for i in range(n_classes):plt.plot(fpr[i], tpr[i], lw1,labelfClass {i} (AUC {roc_auc[i]:.2f}))plt.plot([0, 1], [0, 1], k--, lw1)plt.xlim([0.0, 1.0])plt.ylim([0.0, 1.05])plt.xlabel(False Positive Rate)plt.ylabel(True Positive Rate)plt.title(ROC Curves)plt.legend(loclower right)plt.show()elif task_type regression:# 回归任务指标metrics.update({mse: mean_squared_error(y_true, y_pred),mae: np.mean(np.abs(y_true - y_pred)),r2: r2_score(y_true, y_pred)})# 绘制预测值与真实值散点图plt.figure(figsize(8, 6))plt.scatter(y_true, y_pred, alpha0.5)plt.plot([y_true.min(), y_true.max()], [y_true.min(), y_true.max()], r--)plt.xlabel(True Values)plt.ylabel(Predictions)plt.title(Regression Evaluation)plt.show()return metrics# 使用示例分类任务
if __name__ __main__:# 假设已有训练好的分类模型和数据加载器from sklearn.metrics import classification_report# 加载测试数据test_loader DataLoader(test_dataset, batch_size32, shuffleFalse)# 进行评估classification_metrics evaluate_model(model, test_loader, classification)# 打印关键指标print(f准确率: {classification_metrics[accuracy]:.4f})print(f宏观平均AUC: {classification_metrics[auc_macro]:.4f})print(\n分类报告:)print(classification_metrics[classification_report])# 绘制混淆矩阵plt.figure(figsize(10, 8))sns.heatmap(classification_metrics[confusion_matrix], annotTrue, fmtd, cmapBlues)plt.title(Confusion Matrix)plt.xlabel(Predicted Label)plt.ylabel(True Label)plt.show()# 回归任务使用示例
# regression_metrics evaluate_model(model, test_loader, regression)
# print(fMSE: {regression_metrics[mse]:.4f})
# print(fR²: {regression_metrics[r2]:.4f})好啦 神经网络的基础就在这结束啦之后就开始进一步讲深度学习内容包括 RNN、LSTM、transformer 等最后就引出大模型的原理继续期待叭
