代码收藏家 训练集准确率很高，验证集准确率低问题
训练集在训练过程中，loss稳步下降，准确率上升，最后能达到97%
验证集准确率没有升高，一直维持在50%左右（二分类问题，随机概率）
测试集准确率57%
在网上搜索可能打的原因：
1.learning rate太小，陷入局部最优
2.训练集和测试集数据没有规律
3.数据噪声太大
4.数据量太小（总共1440个样本，80%为训练集）
5.训练集和测试集数据分布不同：如训练集正样本太少（如果训练集和测试集每次运行随机选择，则排除）
6.数据集存在问题，如标注有问题（如采用公开数据集，则排除）
7.学习率过大
8.模型参数量过多而数据量过少
9.过拟合，数据量太小但是模型的结构较为复杂
解决办法：降低模型的复杂度，增大L2正则项，在全连接层加入Dropout层；有了dropout，网络不会为任何一个特征加上很高的权重（因为那个特征的输入神经元有可能被随机删除），最终dropout产生了收缩权重平方范数的效果
10.输入到网络中的特征有问题，特征与label之间没有很明确的关联，或特征太少
11.数据没有归一化
12.修改学习率，使得每次梯度下降低于某个值或者停止下降时，降低学习率，来使得梯度进一步下降。（我使用该方法，使得问题得到解决）
【备注：
batch size过小，花费时间多，同时梯度震荡严重，不利于收敛；batch size过大，不同batch的梯度方向没有任何变化，容易陷入局部极小值。】
针对第12点，修改学习率的举例如下：（基于pytorch）
optimizer = torch.optim.SGD(model.parameters(), lr=0.1) # 优化器
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1) # 设定优优化器更新的时刻表
def train(...):
for i, data in enumerate(train_loader):
......
y_ = model(x)
loss = 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=0.1, last_epoch=-1)
每训练step_size个epoch，学习率调整为lr=lr*gamma.
参数：
optimizer: 神经网络训练中使用的优化器，如optimizer=torch.optim.SGD(…)
step_size(int): 学习率下降间隔数，单位是epoch，而不是iteration.
gamma(float): 学习率调整倍数，默认为0.1
last_epoch(int): 上一个epoch数，这个变量用来指示学习率是否需要调整。当last_epoch符合设定的间隔时，就会对学习率进行调整；当为-1时，学习率设置为初始值。
学习率变化如下图所示：
当然调整学习率的方式还有很多：
多间隔调整学习率 MultiStepLR
指数衰减调整学习率 ExponentialLR
余弦退火函数调整学习率：
根据指标调整学习率 ReduceLROnPlateau
自定义调整学习率 LambdaLR
网上都可以查到，这里就不一一列举了。
欢迎留言讨论~ ^ _ ^
# 前面省略了一部分代码，下面的代码仅供代码格式参考：
args = parser.parse_args()
device = 'cuda' if torch.cuda.is_available() else 'cpu'
best_acc = 0
start_epoch = 0
# Data
print('==> Preparing data..')
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
dict_datasets={'CIFAR10':torchvision.datasets.CIFAR10, 'CIFAR100':torchvision.datasets.CIFAR100}
trainset = dict_datasets[args.datasets](
root='./data', train=True, download=True, transform=transform_train)
trainloader = torch.utils.data.DataLoader(
trainset, batch_size=args.batchsize, shuffle=True, num_workers=0)
testset = dict_datasets[args.datasets](
root='./data', train=False, download=True, transform=transform_test)
testloader = torch.utils.data.DataLoader(
testset, batch_size=args.batchsize_test, shuffle=False, num_workers=0)
global_x.plot_lr=[]
best_acc=0
# Model
print('==> Building model..')
net = dict_model[args.model]
net = net.to(device)
if device == 'cuda':
net = torch.nn.DataParallel(net)
cudnn.benchmark = True
criterion = nn.CrossEntropyLoss()
#####################################################
optimizer = optim.SGD(net.parameters(), lr=args.lr,
momentum=0.8, weight_decay=5e-4)
scheduler = lr_scheduler.Warmup_lineardecay(optimizer, T_max=args.epochs, improved=args.improved)
##################################################
# Training
train_Acc=np.array([])
train_Loss=np.array([])
def train(epoch):
global train_Acc
global train_Loss
print('\nEpoch: %d' % epoch)
net.train()
train_loss = 0
correct = 0
total = 0
for batch_idx, (inputs, targets) in enumerate(trainloader):
inputs, targets = inputs.to(device), targets.to(device)
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, targets)
loss.backward()
##################梯度更新
optimizer.step()
##################
train_loss += loss.item()
_, predicted = outputs.max(1)
total += targets.size(0)
correct += predicted.eq(targets).sum().item()
progress_bar(batch_idx, len(trainloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'
% (train_loss/(batch_idx+1), 100.*correct/total, correct, total))
train_Acc=np.append(train_Acc,100.*correct/total)
train_Loss=np.append(train_Loss,train_loss/(batch_idx+1))
if not os.path.exists(args.model):
os.mkdir(args.model)
np.savetxt(args.model+'/result_of_train_acc.txt',train_Acc,fmt='%f')
np.savetxt(args.model+'/result_of_train_loss.txt',train_Loss,fmt='%f')
test_Acc=np.array([])
test_Loss=np.array([])
def test(epoch):
global test_Acc
global test_Loss
global best_acc
net.eval()
test_loss = 0
correct = 0
total = 0
with torch.no_grad():
DATA_predict=np.empty([0,10])
DATA_predict_index=np.empty([0,1])
for batch_idx, (inputs, targets) in enumerate(testloader):
inputs, targets = inputs.to(device), targets.to(device)
outputs = net(inputs)
loss = criterion(outputs, targets)
test_loss += loss.item()
_, predicted = outputs.max(1)
total += targets.size(0)
correct += predicted.eq(targets).sum().item()
DATA_predict=np.append(DATA_predict,outputs.cpu(),axis=0)
DATA_predict_index=np.append(DATA_predict_index,targets.view(-1,1).cpu(),axis=0)
progress_bar(batch_idx, len(testloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'
% (test_loss/(batch_idx+1), 100.*correct/total, correct, total))
test_Acc=np.append(test_Acc,100.*correct/total)
global_x.reference_acc = correct/total
test_Loss=np.append(test_Loss,test_loss/(batch_idx+1))
np.savetxt(args.model+'/result_of_test_acc.txt',test_Acc,fmt='%f')
np.savetxt(args.model+'/result_of_test_loss.txt',test_Loss,fmt='%f')
# Save checkpoint.
acc = 100.*correct/total
if acc > best_acc:
np.savetxt(args.model+'_DATA_predict.txt',DATA_predict,fmt='%f')
np.savetxt(args.model+'_DATA_predict_index.txt',DATA_predict_index,fmt='%d')
print('Saving..')
state = {
'net': net.state_dict(),
'acc': acc,
'epoch': epoch,
}
if not os.path.isdir('checkpoint'):
os.mkdir('checkpoint')
torch.save(state, './checkpoint/ckpt.pth')
best_acc = acc
for epoch in range(start_epoch, start_epoch+args.epochs):
train(epoch)
test(epoch)
################学习率更新，每轮更新一次，有些学习率的更新是每次迭代更新一次，注意区分，如果是每次迭代更新一次，可以把这一行放在梯度更新的下一行
scheduler.step()
###################
对于此问题，进行的更新：
以下内容参考
版权声明：本文为CSDN博主「TinaO-O」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u013249853/article/details/89393982
0.学习率设置太高，一个epoch直接收敛，所以损失不会下降
比如学利率一开始设置为1，因为下降太快，那么很有可能在一个epoch旧完全收敛。所以看到的validation数值并不下降，第一个epoch就已经处于谷底了。所以如果使用的是系统默认的学习率，最好检查下默认值是什么。
1.最常见的原因：过拟合
过拟合值得单独开个章节。主要包括
1.数据量小，网络复杂
2.learning rate 比较高，又没有设置任何防止过拟合的机制
解决方法主要包括
1.简化模型，利用现有深度学习手段增加数据（翻转，平移，随机裁剪，imgaug）
2.利用 dropout层
3.利用正则化
2.没有把数据规格化
图片的话，img/255是肯定的
3.没有在分验证集之前打乱数据
因为validation_split操作不会为你shuffle数据，所以如果你的数据前一半标签全是1 ，后一半全是0，validation=0.5。恭喜你，你压根也分不对，你的validation准确率会一直为0.因为你拿所有的正样本训练，却想判断负样本。
4.数据和标签没有对上
有可能再读取自定义的数据库的时候出现问题，导致数据与标注不对应。比如第一张图片用第十张的标注
5.你的训练数据太少，validation数据太多，类别也太多
比如4000张训练，1000张validation，300类，这显然就是不合理的。
遇到这种情况，建议：
1.使用别的大的数据集预训练
2.使用DATA augment
3.可以考虑迁移学习
6.最好使用预训练的权重
大多数流行的backone比如resnet都有再imagenet数据集上与训练过，那么使用这种权重，比起随即重新训练，显然要可靠不少注意调整学习率。
7.网络结构有问题
可以通过使用现在流行的网络（resnet，unet等）替入你的代码，如果结果没有问题，你的结果有问题那么肯定就是你网络结构出问题了。那么可以通过逐层注释掉排查究竟哪里出了问题
7.1 网络最后一层没有使用正确的激活函数
比如多类的应该使用softmax
8.relu后面是softmax
有一些说法是relu由于对于很大的数值直接复制，所以会对softmax产生不好的影响，从而输出不好的结果。所以可以使用tanh代替relu。
9.batch normalization需要batch size至少16张
https://mp.csdn.net/postedit/89456400
由于做dense prediction图片通常比较大。所以一个batch一般都只有1-2张图片，不建议使用 BN。
因为BN一般是16张图片以上一起跑。所以吧，如果是BN，那么请用多GPU，16以上的batch size。s
另外keras TF1.x可能会出问题，https://github.com/keras-team/keras/pull/9965
10.可能设置了一些参数是不可训练的
在训练语句之前，检查以下你的trainable参数，是否设置了一些参数是不可训练的。这还可能导致你的输出只能是一个值，比如永远预测为标注0，因为你只有一点点的参数，而这并不是一个模型（比如只有100个参数是可以训练的，太简单了，无法模拟）。
11.附送一个调参论文
Bag of Tricks for Image Classification with Convolutional Neural Networks
https://arxiv.org/abs/1812.01187
来源：LS_learner
