训练集准确率很高，验证集准确率低问题

训练集在训练过程中&＃xff0c;loss稳步下降&＃xff0c;准确率上升&＃xff0c;最后能达到97%
验证集准确率没有升高&＃xff0c;一直维持在50%左右&＃xff08;二分类问题&＃xff0c;随机概率&＃xff09;
测试集准确率57%
在网上搜索可能打的原因&＃xff1a;
1.learning rate太小&＃xff0c;陷入局部最优

2.训练集和测试集数据没有规律

3.数据噪声太大

4.数据量太小&＃xff08;总共1440个样本&＃xff0c;80%为训练集&＃xff09;

5.训练集和测试集数据分布不同&＃xff1a;如训练集正样本太少&＃xff08;如果训练集和测试集每次运行随机选择&＃xff0c;则排除&＃xff09;

6.数据集存在问题&＃xff0c;如标注有问题&＃xff08;如采用公开数据集&＃xff0c;则排除&＃xff09;

7.学习率过大

8.模型参数量过多而数据量过少

9.过拟合&＃xff0c;数据量太小但是模型的结构较为复杂
解决办法&＃xff1a;降低模型的复杂度&＃xff0c;增大L2正则项&＃xff0c;在全连接层加入Dropout层&＃xff1b;有了dropout&＃xff0c;网络不会为任何一个特征加上很高的权重&＃xff08;因为那个特征的输入神经元有可能被随机删除&＃xff09;&＃xff0c;最终dropout产生了收缩权重平方范数的效果

10.输入到网络中的特征有问题&＃xff0c;特征与label之间没有很明确的关联&＃xff0c;或特征太少

11.数据没有归一化

12.修改学习率&＃xff0c;使得每次梯度下降低于某个值或者停止下降时&＃xff0c;降低学习率&＃xff0c;来使得梯度进一步下降。&＃xff08;我使用该方法&＃xff0c;使得问题得到解决&＃xff09;

【备注&＃xff1a;
batch size过小&＃xff0c;花费时间多&＃xff0c;同时梯度震荡严重&＃xff0c;不利于收敛&＃xff1b;batch size过大&＃xff0c;不同batch的梯度方向没有任何变化&＃xff0c;容易陷入局部极小值。】

针对第12点&＃xff0c;修改学习率的举例如下&＃xff1a;&＃xff08;基于pytorch&＃xff09;

optimizer &＃061; torch.optim.SGD(model.parameters(), lr&＃061;0.1) # 优化器
scheduler &＃061; torch.optim.lr_scheduler.StepLR(optimizer, step_size&＃061;30, gamma&＃061;0.1) # 设定优优化器更新的时刻表
def train(...):
for i, data in enumerate(train_loader):
......
y_ &＃061; model(x)
loss &＃061; criterion(y_,y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
......
# 开始训练
for epoch in range(epochs):
scheduler.step() #在每轮epoch之前更新学习率
train(...)
veritf(...)


等间隔调整学习率 StepLR
torch.optim.lr_scheduler.StepLR(optimizer, step_size, gamma&＃061;0.1, last_epoch&＃061;-1)
每训练step_size个epoch&＃xff0c;学习率调整为lr&＃061;lr*gamma.
参数&＃xff1a;
optimizer: 神经网络训练中使用的优化器&＃xff0c;如optimizer&＃061;torch.optim.SGD(…)
step_size(int): 学习率下降间隔数&＃xff0c;单位是epoch&＃xff0c;而不是iteration.
gamma(float): 学习率调整倍数&＃xff0c;默认为0.1
last_epoch(int): 上一个epoch数&＃xff0c;这个变量用来指示学习率是否需要调整。当last_epoch符合设定的间隔时&＃xff0c;就会对学习率进行调整&＃xff1b;当为-1时&＃xff0c;学习率设置为初始值。
学习率变化如下图所示&＃xff1a;

当然调整学习率的方式还有很多&＃xff1a;
多间隔调整学习率 MultiStepLR
指数衰减调整学习率 ExponentialLR
余弦退火函数调整学习率&＃xff1a;
根据指标调整学习率 ReduceLROnPlateau
自定义调整学习率 LambdaLR

网上都可以查到&＃xff0c;这里就不一一列举了。

欢迎留言讨论~ ^ _ ^

# 前面省略了一部分代码&＃xff0c;下面的代码仅供代码格式参考&＃xff1a;
args &＃061; parser.parse_args()
device &＃061; &＃039;cuda&＃039; if torch.cuda.is_available() else &＃039;cpu&＃039;
best_acc &＃061; 0
start_epoch &＃061; 0
# Data
print(&＃039;&＃061;&＃061;> Preparing data..&＃039;)
transform_train &＃061; transforms.Compose([
transforms.RandomCrop(32, padding&＃061;4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
transform_test &＃061; transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
dict_datasets&＃061;{&＃039;CIFAR10&＃039;:torchvision.datasets.CIFAR10, &＃039;CIFAR100&＃039;:torchvision.datasets.CIFAR100}
trainset &＃061; dict_datasets[args.datasets](
root&＃061;&＃039;./data&＃039;, train&＃061;True, download&＃061;True, transform&＃061;transform_train)
trainloader &＃061; torch.utils.data.DataLoader(
trainset, batch_size&＃061;args.batchsize, shuffle&＃061;True, num_workers&＃061;0)
testset &＃061; dict_datasets[args.datasets](
root&＃061;&＃039;./data&＃039;, train&＃061;False, download&＃061;True, transform&＃061;transform_test)
testloader &＃061; torch.utils.data.DataLoader(
testset, batch_size&＃061;args.batchsize_test, shuffle&＃061;False, num_workers&＃061;0)
global_x.plot_lr&＃061;[]
best_acc&＃061;0
# Model
print(&＃039;&＃061;&＃061;> Building model..&＃039;)
net &＃061; dict_model[args.model]
net &＃061; net.to(device)
if device &＃061;&＃061; &＃039;cuda&＃039;:
net &＃061; torch.nn.DataParallel(net)
cudnn.benchmark &＃061; True

criterion &＃061; nn.CrossEntropyLoss()
#####################################################
optimizer &＃061; optim.SGD(net.parameters(), lr&＃061;args.lr,
momentum&＃061;0.8, weight_decay&＃061;5e-4)
scheduler &＃061; lr_scheduler.Warmup_lineardecay(optimizer, T_max&＃061;args.epochs, improved&＃061;args.improved)
##################################################
# Training
train_Acc&＃061;np.array([])
train_Loss&＃061;np.array([])
def train(epoch):
global train_Acc
global train_Loss

print(&＃039;\nEpoch: %d&＃039; % epoch)
net.train()
train_loss &＃061; 0
correct &＃061; 0
total &＃061; 0

for batch_idx, (inputs, targets) in enumerate(trainloader):
inputs, targets &＃061; inputs.to(device), targets.to(device)
optimizer.zero_grad()
outputs &＃061; net(inputs)
loss &＃061; criterion(outputs, targets)
loss.backward()
##################梯度更新
optimizer.step()
##################
train_loss &＃043;&＃061; loss.item()
_, predicted &＃061; outputs.max(1)
total &＃043;&＃061; targets.size(0)
correct &＃043;&＃061; predicted.eq(targets).sum().item()
progress_bar(batch_idx, len(trainloader), &＃039;Loss: %.3f | Acc: %.3f%% (%d/%d)&＃039;
% (train_loss/(batch_idx&＃043;1), 100.*correct/total, correct, total))

train_Acc&＃061;np.append(train_Acc,100.*correct/total)
train_Loss&＃061;np.append(train_Loss,train_loss/(batch_idx&＃043;1))
if not os.path.exists(args.model):
os.mkdir(args.model)
np.savetxt(args.model&＃043;&＃039;/result_of_train_acc.txt&＃039;,train_Acc,fmt&＃061;&＃039;%f&＃039;)
np.savetxt(args.model&＃043;&＃039;/result_of_train_loss.txt&＃039;,train_Loss,fmt&＃061;&＃039;%f&＃039;)
test_Acc&＃061;np.array([])
test_Loss&＃061;np.array([])
def test(epoch):
global test_Acc
global test_Loss
global best_acc
net.eval()
test_loss &＃061; 0
correct &＃061; 0
total &＃061; 0
with torch.no_grad():
DATA_predict&＃061;np.empty([0,10])
DATA_predict_index&＃061;np.empty([0,1])
for batch_idx, (inputs, targets) in enumerate(testloader):
inputs, targets &＃061; inputs.to(device), targets.to(device)
outputs &＃061; net(inputs)
loss &＃061; criterion(outputs, targets)
test_loss &＃043;&＃061; loss.item()
_, predicted &＃061; outputs.max(1)
total &＃043;&＃061; targets.size(0)
correct &＃043;&＃061; predicted.eq(targets).sum().item()
DATA_predict&＃061;np.append(DATA_predict,outputs.cpu(),axis&＃061;0)
DATA_predict_index&＃061;np.append(DATA_predict_index,targets.view(-1,1).cpu(),axis&＃061;0)
progress_bar(batch_idx, len(testloader), &＃039;Loss: %.3f | Acc: %.3f%% (%d/%d)&＃039;
% (test_loss/(batch_idx&＃043;1), 100.*correct/total, correct, total))
test_Acc&＃061;np.append(test_Acc,100.*correct/total)
global_x.reference_acc &＃061; correct/total
test_Loss&＃061;np.append(test_Loss,test_loss/(batch_idx&＃043;1))
np.savetxt(args.model&＃043;&＃039;/result_of_test_acc.txt&＃039;,test_Acc,fmt&＃061;&＃039;%f&＃039;)
np.savetxt(args.model&＃043;&＃039;/result_of_test_loss.txt&＃039;,test_Loss,fmt&＃061;&＃039;%f&＃039;)
# Save checkpoint.
acc &＃061; 100.*correct/total
if acc > best_acc:
np.savetxt(args.model&＃043;&＃039;_DATA_predict.txt&＃039;,DATA_predict,fmt&＃061;&＃039;%f&＃039;)
np.savetxt(args.model&＃043;&＃039;_DATA_predict_index.txt&＃039;,DATA_predict_index,fmt&＃061;&＃039;%d&＃039;)
print(&＃039;Saving..&＃039;)
state &＃061; {
&＃039;net&＃039;: net.state_dict(),
&＃039;acc&＃039;: acc,
&＃039;epoch&＃039;: epoch,
}
if not os.path.isdir(&＃039;checkpoint&＃039;):
os.mkdir(&＃039;checkpoint&＃039;)
torch.save(state, &＃039;./checkpoint/ckpt.pth&＃039;)
best_acc &＃061; acc
for epoch in range(start_epoch, start_epoch&＃043;args.epochs):
train(epoch)
test(epoch)
################学习率更新&＃xff0c;每轮更新一次&＃xff0c;有些学习率的更新是每次迭代更新一次&＃xff0c;注意区分&＃xff0c;如果是每次迭代更新一次&＃xff0c;可以把这一行放在梯度更新的下一行
scheduler.step()
###################


对于此问题&＃xff0c;进行的更新&＃xff1a;
以下内容参考
版权声明&＃xff1a;本文为CSDN博主「TinaO-O」的原创文章&＃xff0c;遵循CC 4.0 BY-SA版权协议&＃xff0c;转载请附上原文出处链接及本声明。
原文链接&＃xff1a;https://blog.csdn.net/u013249853/article/details/89393982

0.学习率设置太高&＃xff0c;一个epoch直接收敛&＃xff0c;所以损失不会下降
比如学利率一开始设置为1&＃xff0c;因为下降太快&＃xff0c;那么很有可能在一个epoch旧完全收敛。所以看到的validation数值并不下降&＃xff0c;第一个epoch就已经处于谷底了。所以如果使用的是系统默认的学习率&＃xff0c;最好检查下默认值是什么。

1.最常见的原因&＃xff1a;过拟合
过拟合值得单独开个章节。主要包括

1.数据量小&＃xff0c;网络复杂
2.learning rate 比较高&＃xff0c;又没有设置任何防止过拟合的机制
解决方法主要包括
1.简化模型&＃xff0c;利用现有深度学习手段增加数据&＃xff08;翻转&＃xff0c;平移&＃xff0c;随机裁剪&＃xff0c;imgaug&＃xff09;
2.利用 dropout层
3.利用正则化


2.没有把数据规格化
图片的话&＃xff0c;img/255是肯定的

3.没有在分验证集之前打乱数据
因为validation_split操作不会为你shuffle数据&＃xff0c;所以如果你的数据前一半标签全是1 &＃xff0c;后一半全是0&＃xff0c;validation&＃061;0.5。恭喜你&＃xff0c;你压根也分不对&＃xff0c;你的validation准确率会一直为0.因为你拿所有的正样本训练&＃xff0c;却想判断负样本。

4.数据和标签没有对上
有可能再读取自定义的数据库的时候出现问题&＃xff0c;导致数据与标注不对应。比如第一张图片用第十张的标注

5.你的训练数据太少&＃xff0c;validation数据太多&＃xff0c;类别也太多
比如4000张训练&＃xff0c;1000张validation&＃xff0c;300类&＃xff0c;这显然就是不合理的。
遇到这种情况&＃xff0c;建议&＃xff1a;

1.使用别的大的数据集预训练
2.使用DATA augment
3.可以考虑迁移学习


6.最好使用预训练的权重
大多数流行的backone比如resnet都有再imagenet数据集上与训练过&＃xff0c;那么使用这种权重&＃xff0c;比起随即重新训练&＃xff0c;显然要可靠不少注意调整学习率。

7.网络结构有问题
可以通过使用现在流行的网络&＃xff08;resnet&＃xff0c;unet等&＃xff09;替入你的代码&＃xff0c;如果结果没有问题&＃xff0c;你的结果有问题那么肯定就是你网络结构出问题了。那么可以通过逐层注释掉排查究竟哪里出了问题

7.1 网络最后一层没有使用正确的激活函数
比如多类的应该使用softmax

8.relu后面是softmax
有一些说法是relu由于对于很大的数值直接复制&＃xff0c;所以会对softmax产生不好的影响&＃xff0c;从而输出不好的结果。所以可以使用tanh代替relu。

9.batch normalization需要batch size至少16张
https://mp.csdn.net/postedit/89456400
由于做dense prediction图片通常比较大。所以一个batch一般都只有1-2张图片&＃xff0c;不建议使用 BN。
因为BN一般是16张图片以上一起跑。所以吧&＃xff0c;如果是BN&＃xff0c;那么请用多GPU&＃xff0c;16以上的batch size。s
另外keras TF1.x可能会出问题&＃xff0c;https://github.com/keras-team/keras/pull/9965

10.可能设置了一些参数是不可训练的
在训练语句之前&＃xff0c;检查以下你的trainable参数&＃xff0c;是否设置了一些参数是不可训练的。这还可能导致你的输出只能是一个值&＃xff0c;比如永远预测为标注0&＃xff0c;因为你只有一点点的参数&＃xff0c;而这并不是一个模型&＃xff08;比如只有100个参数是可以训练的&＃xff0c;太简单了&＃xff0c;无法模拟&＃xff09;。

11.附送一个调参论文
Bag of Tricks for Image Classification with Convolutional Neural Networks
https://arxiv.org/abs/1812.01187

来源：LS_learner