通过Pytorch搭建网络以及初始化参数
前言：关于torch.nn
torch.nn包含了大量的函数及类，如nn.Linear(); nn.ReLU()等等，如想了解nn构造块包含了哪些函数，文档可参考：torch.nn.
一、通过nn.Module搭建模型
方式1：直接继承torch.nn.Module
nn.Module的nn模块提供了模型构造类，你可以通过继承它来搭建你自己的网络层。torch.nn.Module 这个类的内部有多达 48 个函数，这个类是 PyTorch 中所有 neural network module的基类，可以通过继承nn.Module来完成自己的网络搭建,文档可参考：torch.nn.Module; 知乎
nn.Module中的函数forward()和__init__()需要通过子类来实现，不然就会报错，__init__()主要作用是定义基础的网络层，forward()则是实现各层网络的连接，由于nn.Module模块中自带了__call__()函数，所以当项搭建好后的网络传递数据的时候，forward()函数会自动运行;
一个简单的例子：
import torch
from torch import nn
class MLP(nn.Module):
def __init__(self):
super(MLP, self).__init__()
self.hidden = nn.Linear(784, 256)
self.act = nn.ReLU()
self.output = nn.Linear(256, 10)
def forward(self, x):
a = self.act(self.hidden(x))
return self.output(a)
X = torch.rand(2, 784)
net = MLP()
print(net)
net(X)
方式2：通过nn.Module.add_module添加网络层
上一个例子是将各网络层添加到__init__()中来搭建网络，nn.Module父类中自带了函数add_module()，可以通过调用该函数，来添加网络层；添加完的网络层都存放在self._modules中，这里请注意forward()函数的写法：
"""
函数功能：构建一个容器，用于存放模块
语法笔记：
1.与python自带的字典相比较，OrderedDict表示有序的字典；
2.enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标；
"""
from collections import OrderedDict
class MySequential(nn.Module):
def __init__(self, *args):
super(MySequential, self).__init__()
# 如果传入的是一个有序的字典
# isinstance(args[0], OrderdDict)判断args[0]的类型是不是有序字典
if len(args) == 1 and isinstance(args[0], OrderdDict):
for key, module in args[0].items():
self.add_module(key, module)
# 否则遍历的方式读取
else:
for idx, module in enumerate(args):
self.add_module(str(idx), module)
def forward(self, input):
for module in self._modules.values():
# 每层网络输入后，都会返回一个输出
# 当前层的输出作为下一层的输入
input = module(input)
return input
下面两种方式的输出结果一致
X = torch.rand(2, 784)
# 通过传有序的字典
Dict = OrderedDict([
('0', nn.Linear(784, 256)),
('1', nn.ReLU()),
('2', nn.Linear(256, 10))
])
net1 = MySequential(Dict)
print(net1)
net1(X)
print('----------------------------------------')
# 通过传可迭代的对象
net2 = MySequential(
nn.Linear(784, 256),
nn.ReLU(),
nn.Linear(256, 10),
)
print(net2)
net2(X)
方式3：通过nn.Sequential有顺序添加网络层
nn.Sequential作为容易也是用于存放网络层，但要求是按照顺序进行排列的，所以必须确保上一层的输出与下一层的输入的size保持一致，实例如下：
import torch
import torch.nn as nn
import torch.nn.functional as F
class net_seq(nn.Module):
def __init__(self):
super(net2, self).__init__()
self.seq = nn.Sequential(
nn.Conv2d(1,20,5),
nn.ReLU(),
nn.Conv2d(20,64,5),
nn.ReLU()
)
def forward(self, x):
return self.seq(x)
net = net_seq()
print(net)
也可以通过OrderedDict来指定每个module的名字：
from collections import OrderedDict
class net_seq(nn.Module):
def __init__(self):
super(net_seq, self).__init__()
self.seq = nn.Sequential(OrderedDict([
('conv1', nn.Conv2d(1,20,5)),
('relu1', nn.ReLU()),
('conv2', nn.Conv2d(20,64,5)),
('relu2', nn.ReLU())
]))
def forward(self, x):
return self.seq(x)
net = net_se:q()
print(net)
方式4：通过nn.ModuleList搭建网络
ModuleList接收一个子模块的列表作为输入，也可以进行append和extend操作；
net = nn.ModuleList([nn.Linear(784, 256), nn.ReLU()])
net.append(nn.Linear(256, 10)) # # 类似List的append操作
print(net[-1]) # 类似List的索引访问
print(net)
# net(torch.zeros(1, 784)) # 会报NotImplementedError
-
ModuleList仅仅是一个储存各种模块的列表，这些模块之间没有联系也没有顺序; -
ModuleList没有实现forward功能，如果对net进行输入操作会报错；意思就是你需要自己将各层网络连接起来，相比较于sequential更有定制性； -
ModuleList相比较于python的list会自动添加网络的参数parameters；
nn.Sequential与nn.ModuleList的区别
-
nn.Sequential实现了forward函数，可以见上面的例子。ModuleList需要在类的内部自己实现forward函数；def forward(self, x): for m in self.modlist: x = m(x) return x如果完全使用
nn.Sequential是可以的，只是会失去部分灵活性，不可进行定制了； -
nn.Sequential可以使用OrderedDict进行命名； -
有时候网络中会有许多相似或者重复的层，这时会考虑通过
for循环来创建它们，而不是一行一行地写；linears = [nn.Linear(10, 10) for i in range(5)]但是问题是，这样创建出来的层它们之间的参数是一样的。
参见：知乎
方式5：通过ModuleDict搭建网络
目前感觉ModuleDict和ModuleList的区别是它可以自己命名网络层的名字而已；
net = nn.ModuleDict({
'linear': nn.Linear(784, 256),
'act': nn.ReLU(),
})
net['output'] = nn.Linear(256, 10) # 添加
print(net['linear']) # 访问
print(net.output)
print(net)
# net(torch.zeros(1, 784)) # 会报NotImplementedError
其他补充
- 如果某层的某个参数的
requires_grad为False，则该层的这个参数不会被更新； torch.nn.ReLU()和torch.nn.functional.relu()本质上没什么区别；源代码显示，nn.ReLU()是通过调用nn.functional.relu()来实现的；
二、模型参数的初始化
2.1 添加参数
方式1：model.state_dict()
model.state_dict()返回的是一个有序的字典，分别对应参数的名称及具体参数；
# 如果一个网络各层已经定义好了参数，可以通过遍历的方式来访问它；
for params, value in net.state_dict().items():
print(f'params:{params} \n value.size:{value.size()}')
输出如下：
params:conv1.weight
value.size:torch.Size([32, 3, 3, 3])
params:conv1.bias
value.size:torch.Size([32])
params:conv2.weight
value.size:torch.Size([32, 3, 3, 3])
params:conv2.bias
value.size:torch.Size([32])
params:dense1.weight
value.size:torch.Size([128, 288])
params:dense1.bias
value.size:torch.Size([128])
params:dense2.weight
value.size:torch.Size([10, 128])
params:dense2.bias
value.size:torch.Size([10])
方式2：model.named_parameters
model.named_parameters除了返回参数Tensor外，还会返回对应的名字；它与前面提到的model.state_dict()不同的是，它是一个迭代器。
print(type(net.named_parameters()))
for name, param in net.named_parameters():
print(name, param.size())
输出如下：
<class 'generator'>
0.weight torch.Size([3, 4])
0.bias torch.Size([3])
2.weight torch.Size([1, 3])
2.bias torch.Size([1])
方式3：model.parameters()
先说功能，model.parameters()是一个迭代器，但是只能返回参数的值，不可返回名字；准确来说，model.parameters()是通过model.named_parameters来实现的，定义如下：
def parameters(self, recurse: bool = True) -> Iterator[Parameter]:
r"""Returns an iterator over module parameters.
This is typically passed to an optimizer.
Args:
recurse (bool): if True, then yields parameters of this module
and all submodules. Otherwise, yields only parameters that
are direct members of this module.
Yields:
Parameter: module parameter
Example::
>>> for param in model.parameters():
>>> print(type(param), param.size())
(20L,)
(20L, 1L, 5L, 5L)
"""
for name, param in self.named_parameters(recurse=recurse):
yield param
2.2 初始化模型的参数
pytorch的nn.init提供了多种预设的初始化方式，可以访问：nn.init；下面以将权重参数以均值为0，标准差为0.01的正态分布来设置：
for name, param in net.named_parameters():
if 'weight' in name:
init.normal_(param, mean=0, std=0.01)
print(name, param.data)
使用常数填充nn.init.constant_(tensor, val)：
w = torch.empty(3, 5)
nn.init.constant_(w, 0.3)