Task04 模型训练与验证

一、模型训练与验证的流程

1 、在训练集上进行训练，在验证集上进行验证
2 、模型可以保存最优的权重，并读取权重
3 、记录下训练集和验证集的精度，便于调参

二、训练集、验证集和测试集

训练集（trainning set）：用于模型训练和调整模型参数
验证集（validation set）：用于验证模型精度和调整模型超参数
测试集（test set）：验证模型的泛化能力

三、验证集的划分方式

1.留出法（Hold out）

直接将训练集化为两个部分，新的训练集和验证集。这种划分方式的优点是最为简单；缺点是只得到一份验证集，有可能导致模型在验证集上过拟合。留出法的应用场景是数据量比较大的情况。

2.交叉验证法（Cross Validation）

将训练集划分成K份，将其中的K-1份作为训练集，剩下的一份作为验证集，循环K次。这种方法的优点是验证集的精度比较高，训练K次可以得到的K个有多样性的差异的模型；交叉验证的缺点是需要训练K次，不适合数据量很大的情况。

3.自助采样法（BootStrap）

在原始样本集中有放回的随机采样n次，构成与原始样本集一样大小的训练集（包含n个样本）。根据概率，约36.8%的样本没有被采到，另外60%多的样本有很多被重复采到。这样可以使用采出来的大小为n且包含重复样本的集合为训练集，剩下约36.8%的样本当测试集。
这种方式一般适用于数据量较小的情况。

四、解析代码

先看一下这个task的代码

def train(train_loader, model, criterion, optimizer):
       # 切换模型为训练模式
        model.train()
        train_loss = []
 
        for i, (input, target) in enumerate(train_loader):
            if use_cuda:
                input = input.cuda()
                target = target.cuda()
 
            c0, c1, c2, c3, c4 = model(input)
            target = target.long() 
            loss = criterion(c0, target[:, 0]) + \
                   criterion(c1, target[:, 1]) + \
                   criterion(c2, target[:, 2]) + \
                   criterion(c3, target[:, 3]) + \
                   criterion(c4, target[:, 4])
 
            # loss /= 6
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
 
            if i % 100 == 0:
               print(loss.item())
 
            train_loss.append(loss.item())
        return np.mean(train_loss)
def validate(val_loader, model, criterion):
       # 切换模型为预测模型
        model.eval()
        val_loss = []
        # 不记录模型梯度信息
        with torch.no_grad():
             for i, (input, target) in enumerate(val_loader):
                    if use_cuda:
                        input = input.cuda()
                        target = target.cuda()
 
                    c0, c1, c2, c3, c4 = model(input)
                    target = target.long()
                    loss = criterion(c0, target[:, 0]) + \
                           criterion(c1, target[:, 1]) + \
                           criterion(c2, target[:, 2]) + \
                           criterion(c3, target[:, 3]) + \
                           criterion(c4, target[:, 4])
                           # loss /= 6
                    val_loss.append(loss.item())
        return np.mean(val_loss)
def predict(test_loader, model, tta=10):
        model.eval()
        test_pred_tta = None
 
        # TTA 次数
        for _ in range(tta):
            test_pred = []
 
            with torch.no_grad():
                for i, (input, target) in enumerate(test_loader):
                    if use_cuda:
                        input = input.cuda()
                    c0, c1, c2, c3, c4 = model(input)
                   
                    output = np.concatenate([
                             c0.data.numpy(),
                             c1.data.numpy(),
                             c2.data.numpy(),
                             c3.data.numpy(),
                             c4.data.numpy()], axis=1)
                    test_pred.append(output)
 
                test_pred = np.vstack(test_pred)
                if test_pred_tta is None:
                    test_pred_tta = test_pred
                else:
                    test_pred_tta += test_pred
 
        return test_pred_tta

model = SVHN_Model1()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), 0.001)
best_loss = 1000.0
use_cuda = False
if use_cuda:
    model = model.cuda()
for epoch in range(2):
    train_loss = train(train_loader, model, criterion, optimizer)
    val_loss = validate(val_loader, model, criterion)
 
    val_label = [''.join(map(str, x)) for x in val_loader.dataset.img_label]
    val_predict_label = predict(val_loader, model, 1)
    val_predict_label = np.vstack([
                        val_predict_label[:, :11].argmax(1),
                        val_predict_label[:, 11:22].argmax(1),
                        val_predict_label[:, 22:33].argmax(1),
                        val_predict_label[:, 33:44].argmax(1),
                        val_predict_label[:, 44:55].argmax(1),
                        ]).T
    val_label_pred = []
    for x in val_predict_label:
        val_label_pred.append(''.join(map(str, x[x!=10])))
 
    val_char_acc = np.mean(np.array(val_label_pred) == np.array(val_label))
    print('Epoch: {0}, Train loss: {1} \t Val loss: {2}'.format(epoch, train_loss, val_loss))
    print(val_char_acc)
    # 记录下验证集精度
    if val_loss < best_loss:
        best_loss = val_loss
        torch.save(model.state_dict(), './model.pt')

1.第一部分的代码

model = SVHN_Model1()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), 0.001)
best_loss = 1000.0
use_cuda = False
if use_cuda:
    model = model.cuda()
for epoch in range(2):
    train_loss = train(train_loader, model, criterion, optimizer)
    val_loss = validate(val_loader, model, criterion)
 
    val_label = [''.join(map(str, x)) for x in val_loader.dataset.img_label]
    val_predict_label = predict(val_loader, model, 1)
    val_predict_label = np.vstack([
                        val_predict_label[:, :11].argmax(1),
                        val_predict_label[:, 11:22].argmax(1),
                        val_predict_label[:, 22:33].argmax(1),
                        val_predict_label[:, 33:44].argmax(1),
                        val_predict_label[:, 44:55].argmax(1),
                        ]).T
    val_label_pred = []
    for x in val_predict_label:
        val_label_pred.append(''.join(map(str, x[x!=10])))
 
    val_char_acc = np.mean(np.array(val_label_pred) == np.array(val_label))
    print('Epoch: {0}, Train loss: {1} \t Val loss: {2}'.format(epoch, train_loss, val_loss))
    print(val_char_acc)
    # 记录下验证集精度
    if val_loss < best_loss:
        best_loss = val_loss
        torch.save(model.state_dict(), './model.pt')

（1）理解一下CrossEntropyLoss
baseline中将CrossEntropyLoss作为损失函数。损失函数结合了NLLLoss和LogSoftmax两个函数。这个损失函数的具体详细解释后续再说吧。
（2）optimizer
这里是选择adam作为优化器
（3）初始设定best_loss为1000

二、第二部分代码

这里看一下每个epoch具体做了什么

def train(train_loader, model, criterion, optimizer):
       # 切换模型为训练模式
        model.train()
        train_loss = []
 
        for i, (input, target) in enumerate(train_loader):
            if use_cuda:
                input = input.cuda()
                target = target.cuda()
 
            c0, c1, c2, c3, c4 = model(input)
            target = target.long() 
            loss = criterion(c0, target[:, 0]) + \
                   criterion(c1, target[:, 1]) + \
                   criterion(c2, target[:, 2]) + \
                   criterion(c3, target[:, 3]) + \
                   criterion(c4, target[:, 4])
 
            # loss /= 6
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
 
            if i % 100 == 0:
               print(loss.item())
 
            train_loss.append(loss.item())
        return np.mean(train_loss)

简单理解一下：
（1）

for i, (input, target) in enumerate(train_loader):

得到每张图片的input和对应的target的tensor
（2）

            c0, c1, c2, c3, c4 = model(input)
            target = target.long() 
            loss = criterion(c0, target[:, 0]) + \
                   criterion(c1, target[:, 1]) + \
                   criterion(c2, target[:, 2]) + \
                   criterion(c3, target[:, 3]) + \
                   criterion(c4, target[:, 4])

将input输入到model，然后通过target根据损失函数计算loss
（3）

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

optimizer.zero_grad()先手动将梯度清零
loss.backward()：反向传播求解梯度
optimizer.step()：更新权重参数
(4)
最后计算所有的图片得到的loss的均值

三、第三部分代码

def validate(val_loader, model, criterion):
       # 切换模型为预测模型
        model.eval()
        val_loss = []
        # 不记录模型梯度信息
        with torch.no_grad():
             for i, (input, target) in enumerate(val_loader):
                    if use_cuda:
                        input = input.cuda()
                        target = target.cuda()
 
                    c0, c1, c2, c3, c4 = model(input)
                    target = target.long()
                    loss = criterion(c0, target[:, 0]) + \
                           criterion(c1, target[:, 1]) + \
                           criterion(c2, target[:, 2]) + \
                           criterion(c3, target[:, 3]) + \
                           criterion(c4, target[:, 4])
                           # loss /= 6
                    val_loss.append(loss.item())
        return np.mean(val_loss)

注意一下这里使用了一个with torch.no_grad(),表示这里的数据不需要计算梯度，也不会进行反向传播
很显然，这里是验证集，当然不需要