pytorch指定层冻结。初始化权重

• PyTorch的Module.modules()和Module.children()

 在PyTorch中，所有的neural network module都是class torch.nn.Module的子类，在Modules中可以包含其它的Modules，以一种树状结构进行嵌套。

当需要返回神经网络中的各个模块时，Module.modules()方法返回网络中所有模块的一个iterator，而Module.children()方法返回所有直接子模块的一个iterator。具体而言：

list ( nn.Sequential(nn.Linear(10, 20), nn.ReLU()).modules() )
Out[9]:
[Sequential (
(0): Linear (10 -> 20)
(1): ReLU ()
), Linear (10 -> 20), ReLU ()]

In [10]: list( nn.Sequential(nn.Linear(10, 20), nn.ReLU()) .children() )
Out[10]: [Linear (10 -> 20), ReLU ()]

参考：https://www.jianshu.com/p/7a7d45b8e0ee这个写的很好

• 选择特定的层进行finetune
  • 先使用Module.children()方法查看网络的直接子模块，将不需要调整的模块中的参数设置为param.requires_grad = False，同时用一个list收集需要调整的模块中的参数。具体代码为：

count = 0
    para_optim = []
    for k in model.children():
        count += 1
        # 6 should be changed properly
        if count > 6:
            for param in k.parameters():
                para_optim.append(param)
        else:
            for param in k.parameters():
                param.requires_grad = False
optimizer = optim.RMSprop(para_optim, lr)

 固定部分参数训练

# 只有True的才训练
optimizer.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3)

也就是我build.py里的

def make_optimizer(cfg, model):
    params = []
    for key, value in model.named_parameters():
        if not value.requires_grad:                 #value.requires_grad 那么not value.requires_grad false 跳过
            continue
        lr = cfg.SOLVER.BASE_LR                                     #   Adam比较小 0.00001/0.0003 或者 SGD 0.0025
        weight_decay = cfg.SOLVER.WEIGHT_DECAY                      #  0.0001
        if "bias" in key:                                           #  false here  'backbone.fpn.fpn_inner1.bias' 'backbone.fpn.fpn_layer1.bias'才会'rpn.head.conv.bias'
            lr = cfg.SOLVER.BASE_LR * cfg.SOLVER.BIAS_LR_FACTOR     #  BIAS_LR_FACTOR:2  2e-05 # lr = 0.0025* cfg.SOLVER.BIAS_LR_FACTOR   不可以 不好
            weight_decay = cfg.SOLVER.WEIGHT_DECAY_BIAS             # 0
        params += [{"params": [value], "lr": lr, "weight_decay": weight_decay}]

    #optimizer = torch.optim.SGD(params, lr, momentum=cfg.SOLVER.MOMENTUM) 
    return optimizer

• 另外一个小技巧就是在nn.Module里，可以在中间插入这个，这样前面的参数就是False，而后面的不变

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)

        for p in self.parameters():
            p.requires_grad=False

        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

训练特定层，冻结其它层
另一种使用预训练模型的方法是对它进行部分训练。具体做法是，将模型起始的一些层的权重保持不变，重新训练后面的层，得到新的权重。在这个过程中，可多次进行尝试，从而能够依据结果找到frozen layers和retrain layers之间的最佳搭配。
如何使用预训练模型，是由数据集大小和新旧数据集(预训练的数据集和自己要解决的数据集)之间数据的相似度来决定的。
下图表展示了在各种情况下应该如何使用预训练模型：

场景一：数据集小，数据相似度高(与pre-trained model的训练数据相比而言)

在这种情况下，因为数据与预训练模型的训练数据相似度很高，因此我们不需要重新训练模型。我们只需要将输出层改制成符合问题情境下的结构就好。我们使用预处理模型作为模式提取器。

比如说我们使用在ImageNet上训练的模型来辨认一组新照片中的小猫小狗。在这里，需要被辨认的图片与ImageNet库中的图片类似，但是我们的输出结果中只需要两项——猫或者狗。在这个例子中，我们需要做的就是把dense layer和最终softmax layer的输出从1000个类别改为2个类别。

场景二：数据集小，数据相似度不高

在这种情况下，我们可以冻结预训练模型中的前k个层中的权重，然后重新训练后面的n-k个层，当然最后一层也需要根据相应的输出格式来进行修改。

因为数据的相似度不高，重新训练的过程就变得非常关键。而新数据集大小的不足，则是通过冻结预训练模型的前k层进行弥补。

场景三：数据集大，数据相似度不高

在这种情况下，因为我们有一个很大的数据集，所以神经网络的训练过程将会比较有效率。然而，因为实际数据与预训练模型的训练数据之间存在很大差异，采用预训练模型将不会是一种高效的方式。

因此最好的方法还是将预处理模型中的权重全都初始化后在新数据集的基础上重头开始训练。

场景四：数据集大，数据相似度高

这就是最理想的情况，采用预训练模型会变得非常高效。最好的运用方式是保持模型原有的结构和初始权重不变，随后在新数据集的基础上重新训练。