python - 为什么我重新加载模型并继续训练损失迅速增加？

Question

这是一个类似的问题，但我认为torch足以处理初始化问题。

---

让我们先看看损失

# first time save and the loss  
epoch:8  loss:2.6038

# second time reload, and save model when epoch is 10
epoch:8  loss:7.8922
epoch:10 loss:4.8546

# third time reload, and save model when epoch is 27
epoch:10 loss:6.0920
epoch:27 loss:2.1613

# fourth time reload and training
epoch:27 loss:6.0920

正如你所看到的，一旦我重新加载模型并运行一个 epoch 训练，损失就会上升而不是下降。这真的很奇怪。

我使用step由于我的机器无法支持大批量的方法。

1. 我第一次使用具有16 个批量大小的四个 GPU，每2 步反向损失一次。.
2. 第二次我使用两个具有8 个批量大小的 GPU，每4步向后损失一次
3. 第三次我使用 4个批量大小为 16的 GPU，每2 步反向损失一次。.
4. 第四次我使用 4个批量大小为 16的 GPU，每2 步反向损失一次。.

根据第一次到第三次，我认为这是batchnorm问题导致批量大小与参数不同alpha并且beta不适合另一组。

但令人惊讶的是，第四次仍然得到类似的情况。所以我真的很困惑。我错过了一些应该保存的参数吗？这是我的加载和重新加载代码。

# saving script 
    def save_model(self, path, epoch, model, optimizer):
        #if epoch % 4 != 0:
        #    return
        if isinstance(model, torch.nn.DataParallel):
            state_dict = model.module.state_dict()
        else:
            state_dict = model.state_dict()
        torch.save({
            'epoch': epoch,
            'model_state_dict': state_dict,
            'optimizer_state_dict': optimizer.state_dict(),
            'learning_rate':optimizer.state_dict()['param_groups'][0]['lr']
            # 'loss': loss
        }, path)

# reloading script 
    def load_model(self, model, optimizer, resume, strict=True):
        checkpoint = torch.load(resume, map_location=lambda storage, loc: storage)
        print('loaded weights from {}, epoch {}'.format(resume, checkpoint['epoch']))
        state_dict_ = checkpoint['model_state_dict']
        state_dict = {}
        for k in state_dict_:
            if k.startswith('module') and not k.startswith('module_list'):
                state_dict[k[7:]] = state_dict_[k]
            else:
                state_dict[k] = state_dict_[k]
        model_state_dict = model.state_dict()
        if not strict:
            for k in state_dict:
                if k in model_state_dict:
                    if state_dict[k].shape != model_state_dict[k].shape:
                        print('Skip loading parameter {}, required shape{}, ' \
                              'loaded shape{}.'.format(k, model_state_dict[k].shape, state_dict[k].shape))
                        state_dict[k] = model_state_dict[k]
                else:
                    print('Drop parameter {}.'.format(k))
            for k in model_state_dict:
                if not (k in state_dict):
                    print('No param {}.'.format(k))
                    state_dict[k] = model_state_dict[k]
        model.load_state_dict(state_dict, strict=False)
        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
        for state in optimizer.state.values():
            for k, v in state.items():
                if isinstance(v, torch.Tensor):
                    state[k] = v.cuda()
        epoch = checkpoint['epoch']
        # loss = checkpoint['loss']
        return model, optimizer, epoch

标签： pythondeep-learningneural-networkpytorch