Pytorch学习笔记(八):nn.ModuleList和nn.Sequential函数详解

最新推荐文章于 2024-08-13 04:15:00 发布

ZZY_dl

最新推荐文章于 2024-08-13 04:15:00 发布

阅读量2.1k

点赞数 3

分类专栏： # Pytorch 文章标签： python 深度学习机器学习 pytorch yuan

本文链接：https://blog.csdn.net/m0_51004308/article/details/118034232

版权

Pytorch 专栏收录该内容

10 篇文章 84 订阅

订阅专栏

Pytorch学习笔记(一):torch.cat()模块的详解
 Pytorch学习笔记(二):nn.Conv2d()函数详解
 Pytorch学习笔记(三):nn.BatchNorm2d()函数详解
 Pytorch学习笔记(四):nn.MaxPool2d()函数详解
 Pytorch学习笔记(五):nn.AdaptiveAvgPool2d()函数详解
 Pytorch学习笔记(六):view()和nn.Linear()函数详解
 Pytorch学习笔记(七):F.softmax()和F.log_softmax函数详解
 Pytorch学习笔记(八):nn.ModuleList和nn.Sequential函数详解

文章目录

1.函数语法格式和作用

nn.ModuleList作用:
nn.ModuleList则没有顺序性要求，并且也没有实现forward()方法。为了构建网络模型。
nn.ModuleList函数语言格式:
这个直接看后面具体的代码即可
nn.Sequential作用:
nn.Sequential定义的网络中各层会按照定义的顺序进行级联，因此需要保证各层的输入和输出之间要衔接。而且里面的模块必须是按照顺序进行排列的，所以我们必须确保前一个模块的输出大小和下一个模块的输入大小是一致的，并且nn.Sequential实现了farward()方法，因此可以直接通过类似于x=self.combine(x)的方式实现forward。
nn.Sequential函数语言格式:
这个直接看后面具体的代码即可

2.参数解释

x指的是输入矩阵。
dim指的是归一化的方式，如果为0是对列做归一化，1是对行做归一化。

3.具体代码

nn.ModuleList
nn.ModuleList 并没有定义一个网络，它只是将不同的模块储存在一起，这些模块之间并没有什么先后顺序可言
被调用多次的模块，是使用同一组 parameters 的，也就是它们的参数是共享的，无论之后怎么更新。例子如下，虽然在 forward 中我们用了 nn.Linear(10,10) 两次，但是它们只有一组参数。

class net3(nn.Module):
    def __init__(self):
        super(net3, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(10,20), nn.Linear(20,30), nn.Linear(5,10)])
    def forward(self, x):
        x = self.linears[2](x)
        x = self.linears[0](x)
        x = self.linears[1](x) 
        return x

net = net3()
print(net)
# net3(
#   (linears): ModuleList(
#     (0): Linear(in_features=10, out_features=20, bias=True)
#     (1): Linear(in_features=20, out_features=30, bias=True)
#     (2): Linear(in_features=5, out_features=10, bias=True)
#   )
# )
input = torch.randn(32, 5)
print(net(input).shape)
# torch.Size([32, 30])

class net4(nn.Module):
    def __init__(self):
        super(net4, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(5, 10), nn.Linear(10, 10)])
    def forward(self, x):
        x = self.linears[0](x)
        x = self.linears[1](x)
        x = self.linears[1](x)
        return x

net = net4()
print(net)
# net4(
#   (linears): ModuleList(
#     (0): Linear(in_features=5, out_features=10, bias=True)
#     (1): Linear(in_features=10, out_features=10, bias=True)
#   )
# )
for name, param in net.named_parameters():
    print(name, param.size())
# linears.0.weight torch.Size([10, 5])
# linears.0.bias torch.Size([10])
# linears.1.weight torch.Size([10, 10])
# linears.1.bias torch.Size([10])

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

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

net = net5()
print(net)
# net5(
#   (block): Sequential(
#     (0): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
#     (1): ReLU()
#     (2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
#     (3): ReLU()
#   )
# )