0.0.pytorch构建模型方法

1模型的构建方法

参考：
https://blog.csdn.net/e01528/article/details/84397174
https://blog.csdn.net/u014090429/article/details/112618607
在构建网络的时候，pytorch有一些基础概念很重要，比如nn.Module，nn.ModuleList，nn.Sequential，这些类我们称为为容（containers）

1.1 nn.ModuleList()：可以看作是一种封装好的模型list来使用

参考：
https://blog.csdn.net/e01528/article/details/84397174
https://blog.csdn.net/qq_41475067/article/details/115828900

特点：
1、写一个module然后就写forward函数很麻烦，所以就有了这两个。它被设计用来存储任意数量的nn. module。
和普通list不一样，它和torch的其他机制结合紧密，继承了nn.Module的网络模型class可以使用nn.ModuleList并识别其中的parameters
2、nn.ModuleList则没有顺序性要求，并且也没有实现forward()方法，没有级联需求。
3、如果在构造函数__init__中用到list、tuple、dict等对象时，一定要思考是否应该用ModuleList或ParameterList代替。
如果你想设计一个神经网络的层数作为输入传递。
4、 既然ModuleList可以根据序号来调用，那么一个模型可以在forward函数中被调用多次。但需要注意的是，被调用多次的模块，是使用同一组parameters的，也就是它们是参数共享的。

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(10)])
 
    def forward(self, x):
        # ModuleList can act as an iterable, or be indexed using ints
        for i, l in enumerate(self.linears):
            x = self.linears[i // 2](x) + l(x)  # 可以看到nn.ModuleList则没有顺序性要求
        return x

1.2 nn.Sequential()

不同于nn.ModuleList，nn.Sequential已经实现了内部的forward函数，而且里面的模块必须是按照顺序进行排列的，所以我们必须确保前一个模块的输出大小和下一个模块的输入大小是一致的。

nn.Sequential 就是一个 nn.Module 的子类，也就是 nn.Module 所有的方法 (method) 它都有。并且直接使用 nn.Sequential 不用写 forward 函数，因为它内部已经帮你写好了。.

1、直接构建：层名字是0、1、2…

class net5(nn.Module):
    def __init__(self):
        super(net5, self).__init__()
        self.block = nn.Sequential(nn.Conv2d(1,20,5),
                                    nn.ReLU(),
                                    nn.Conv2d(20,64,5),
                                    nn.ReLU())
    def forward(self, x):
        x = self.block(x)
        return x

1、通过列表构建：层名字是0、1、2…

layers = [ ]
layers.append(层结构)
layers += [层结构1， 层结构2...]
nn.Sequential(*layers)

由于没有子模型所以里面的层名字用序号代替

2、添加子模型：通过add_module构建：nn.Sequential()对象.add_module(层名，层class的实例）
（经常使用）

net1 = nn.Sequential()
net1.add_module('conv', nn.Conv2d(3, 3, 3))
net1.add_module('batchnorm', nn.BatchNorm2d(3))
net1.add_module('activation_layer', nn.ReLU())

3、OrderedDict()列表：总和上述两种方法的有点，既可以使用列表构建，又能够给层重新命名，并且不需要*拆包解析。
（复杂模型经常使用）

from collections import OrderedDict
net3= nn.Sequential(OrderedDict([
          ('conv', nn.Conv2d(3, 3, 3)),
          ('batchnorm', nn.BatchNorm2d(3)),
          ('activation_layer', nn.ReLU())
        ]))

Sequential和ModeleList的区别

参考：
https://blog.csdn.net/u014090429/article/details/112618607

module_list = nn.ModuleList()
for index, x in enumerate(blocks[1:]):#根据不同的block 遍历module
        module = nn.Sequential()
        然后根据cfg读进来的数据，
        module.add_module("batch_norm_{0}".format(index), bn)
        module.add_module("conv_{0}".format(index), conv)
        module_list.append(module)

如果你确定 nn.Sequential 里面的顺序是你想要的，而且不需要再添加一些其他处理的函数 (比如 nn.functional 里面的函数，nn 与 nn.functional有什么区别?)，那么完全可以直接用 nn.Sequential。这么做的代价就是失去了部分灵活性，毕竟不能自己去定制 forward 函数里面的内容了。一般情况下 nn.Sequential 的用法是来组成卷积块 (block)，然后像拼积木一样把不同的 block 拼成整个网络，让代码更简洁，更加结构化。

不同点1：nn.Sequential内部实现了forward函数，因此可以不用写forward函数，而nn.ModuleList则没有实现内部forward函数。

不同点2：nn.Sequential可以使用OrderedDict对每层进行命名。但可以使用ModuleDict（{}）给各层命名。

不同点3：nn.Sequential里面的模块按照顺序进行排列的，所以必须确保前一个模块的输出大小和下一个模块的输入大小是一致的。而nn.ModuleList 并没有定义一个网络，它只是将不同的模块储存在一起，这些模块之间并没有什么先后顺序可言。

不同点4：有的时候网络中有很多相似或者重复的层，我们一般会考虑用 for 循环来创建它们，而不是一行一行地写，比如：

layers = [nn.Linear(10, 10) for i in range(5)]

其他

# 合并成一整层
class ConvBNActivation(nn.Sequential):
    def __init__(self,
                 in_planes: int,
                 out_planes: int,
                 kernel_size: int = 3,
                 stride: int = 1,
                 groups: int = 1,  # 控制使用普通的卷积还是dw卷积
                 norm_layer: Optional[Callable[..., nn.Module]] = None,  # BN结构
                 activation_layer: Optional[Callable[..., nn.Module]] = None):
        padding = (kernel_size - 1) // 2
        if norm_layer is None:
            norm_layer = nn.BatchNorm2d
        if activation_layer is None:
            activation_layer = nn.SiLU  # alias Swish  (torch>=1.7)
 
        super(ConvBNActivation, self).__init__(nn.Conv2d(in_channels=in_planes,
                                                         out_channels=out_planes,
                                                         kernel_size=kernel_size,
                                                         stride=stride,
                                                         padding=padding,
                                                         groups=groups,
                                                         bias=False),
                                               			 norm_layer(out_planes),
                                              			 activation_layer())