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

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(...)

# 前面省略了一部分代码，下面的代码仅供代码格式参考：
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()
###################

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

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