参考链接：https://www.cnblogs.com/yqpy/p/12585331.html
 
model.named_parameters()
 
迭代打印model.named_parameters()将会打印每一次迭代元素的名字和param。
 
model = DarkNet([1, 2, 8, 8, 4])
for name, param in model.named_parameters():
    print(name,param.requires_grad)
    param.requires_grad = False
 
输出结果为
 
conv1.weight True
bn1.weight True
bn1.bias True
layer1.ds_conv.weight True
layer1.ds_bn.weight True
layer1.ds_bn.bias True
layer1.residual_0.conv1.weight True
layer1.residual_0.bn1.weight True
layer1.residual_0.bn1.bias True
layer1.residual_0.conv2.weight True
layer1.residual_0.bn2.weight True
layer1.residual_0.bn2.bias True
layer2.ds_conv.weight True
layer2.ds_bn.weight True
layer2.ds_bn.bias True
layer2.residual_0.conv1.weight True
layer2.residual_0.bn1.weight True
layer2.residual_0.bn1.bias True
....
 
并且可以更改参数的可训练属性，第一次打印是True，这是第二次，就是False了
 
model.parameters()
 
迭代打印model.parameters()将会打印每一次迭代元素的param而不会打印名字，这是它和named_parameters的区别，两者都可以用来改变requires_grad的属性。
 
for index, param in enumerate(model.parameters()):
    print(param.shape)
 
输出结果为
 
torch.Size([32, 3, 3, 3])
torch.Size([32])
torch.Size([32])
torch.Size([64, 32, 3, 3])
torch.Size([64])
torch.Size([64])
torch.Size([32, 64, 1, 1])
torch.Size([32])
torch.Size([32])
torch.Size([64, 32, 3, 3])
torch.Size([64])
torch.Size([64])
torch.Size([128, 64, 3, 3])
torch.Size([128])
torch.Size([128])
torch.Size([64, 128, 1, 1])
torch.Size([64])
torch.Size([64])
torch.Size([128, 64, 3, 3])
torch.Size([128])
torch.Size([128])
torch.Size([64, 128, 1, 1])
torch.Size([64])
torch.Size([64])
torch.Size([128, 64, 3, 3])
torch.Size([128])
torch.Size([128])
torch.Size([256, 128, 3, 3])
torch.Size([256])
torch.Size([256])
torch.Size([128, 256, 1, 1])
....
 
将两者结合进行迭代，同时具有索引，网络层名字及param
 
	for index, (name, param) in zip(enumerate(model.parameters()), model.named_parameters()):
		print(index[0])
		print(name, param.shape)
 
输出结果为
 
0
conv1.weight torch.Size([32, 3, 3, 3])
1
bn1.weight torch.Size([32])
2
bn1.bias torch.Size([32])
3
layer1.ds_conv.weight torch.Size([64, 32, 3, 3])
4
layer1.ds_bn.weight torch.Size([64])
5
layer1.ds_bn.bias torch.Size([64])
6
layer1.residual_0.conv1.weight torch.Size([32, 64, 1, 1])
7
layer1.residual_0.bn1.weight torch.Size([32])
8
layer1.residual_0.bn1.bias torch.Size([32])
9
layer1.residual_0.conv2.weight torch.Size([64, 32, 3, 3])
 
 

 
文章目录
 
1. 访问模型参数
2. 初始化模型参数
3. 自定义初始化方法
4. 共享模型参数
小结
 

 
本节将深入讲解如何访问和初始化模型参数，以及如何在多个层之间共享同一份模型参数。
 
我们先定义含单隐藏层的多层感知机。我们使用默认方式初始化它的参数，并做一次前向计算。在这里我们从nn中导入了init模块，它包含了多种模型初始化方法。
 
import torch
from torch import nn
from torch.nn import init

net = nn.Sequential(nn.Linear(4, 3), nn.ReLU(), nn.Linear(3, 1))  # pytorch已进行默认初始化

print(net)
X = torch.rand(2, 4)
Y = net(X).sum()
 
输出：
 
Sequential(
  (0): Linear(in_features=4, out_features=3, bias=True)
  (1): ReLU()
  (2): Linear(in_features=3, out_features=1, bias=True)
)
 
1. 访问模型参数
 
回忆一下上一节中提到的Sequential类与Module类的继承关系。对于Sequential实例中含模型参数的层，我们可以通过Module类的parameters()或者named_parameters方法来访问所有参数（以迭代器的形式返回），后者除了返回参数Tensor外还会返回其名字。下面，访问多层感知机net的所有参数：
 
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])
 
可见返回的名字自动加上了层数的索引作为前缀。
 我们再来访问net中单层的参数。对于使用Sequential类构造的神经网络，我们可以通过方括号[]来访问网络的任一层。索引0表示隐藏层为Sequential实例最先添加的层。
 
for name, param in net[0].named_parameters():
    print(name, param.size(), type(param))
 
输出：
 
weight torch.Size([3, 4]) <class 'torch.nn.parameter.Parameter'>
bias torch.Size([3]) <class 'torch.nn.parameter.Parameter'>
 
因为这里是单层的所以没有了层数索引的前缀。另外返回的param的类型为torch.nn.parameter.Parameter，其实这是Tensor的子类，和Tensor不同的是如果一个Tensor是Parameter，那么它会自动被添加到模型的参数列表里，来看下面这个例子。
 
class MyModel(nn.Module):
    def __init__(self, **kwargs):
        super(MyModel, self).__init__(**kwargs)
        self.weight1 = nn.Parameter(torch.rand(20, 20))
        self.weight2 = torch.rand(20, 20)
    def forward(self, x):
        pass
    
n = MyModel()
for name, param in n.named_parameters():
    print(name)
 
输出:
 
weight1
 
上面的代码中weight1在参数列表中但是weight2却没在参数列表中。
 
因为Parameter是Tensor，即Tensor拥有的属性它都有，比如可以根据data来访问参数数值，用grad来访问参数梯度。
 
weight_0 = list(net[0].parameters())[0]
print(weight_0.data)
print(weight_0.grad) # 反向传播前梯度为None
Y.backward()
print(weight_0.grad)

 
输出：
 
tensor([[ 0.2719, -0.0898, -0.2462,  0.0655],
        [-0.4669, -0.2703,  0.3230,  0.2067],
        [-0.2708,  0.1171, -0.0995,  0.3913]])
None
tensor([[-0.2281, -0.0653, -0.1646, -0.2569],
        [-0.1916, -0.0549, -0.1382, -0.2158],
        [ 0.0000,  0.0000,  0.0000,  0.0000]])

 
2. 初始化模型参数
 
PyTorch的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)

 
输出：
 
0.weight tensor([[ 0.0030,  0.0094,  0.0070, -0.0010],
        [ 0.0001,  0.0039,  0.0105, -0.0126],
        [ 0.0105, -0.0135, -0.0047, -0.0006]])
2.weight tensor([[-0.0074,  0.0051,  0.0066]])
 
下面使用常数来初始化权重参数。
 
for name, param in net.named_parameters():
    if 'bias' in name:
        init.constant_(param, val=0)
        print(name, param.data)
 
输出：
 
0.bias tensor([0., 0., 0.])
2.bias tensor([0.])
 
3. 自定义初始化方法
 
有时候我们需要的初始化方法并没有在init模块中提供。这时，可以实现一个初始化方法，从而能够像使用其他初始化方法那样使用它。在这之前我们先来看看PyTorch是怎么实现这些初始化方法的，例如torch.nn.init.normal_：
 
def normal_(tensor, mean=0, std=1):
    with torch.no_grad():
        return tensor.normal_(mean, std)
 
可以看到这就是一个inplace改变Tensor值的函数，而且这个过程是不记录梯度的。
 类似的我们来实现一个自定义的初始化方法。在下面的例子里，我们令权重有一半概率初始化为0，有另一半概率初始化为$[-10,-5]$和$[5,10]$两个区间里均匀分布的随机数。
 
def init_weight_(tensor):
    with torch.no_grad():
        tensor.uniform_(-10, 10)
        tensor *= (tensor.abs() >= 5).float()

for name, param in net.named_parameters():
    if 'weight' in name:
        init_weight_(param)
        print(name, param.data)
 
输出：
 
0.weight tensor([[ 7.0403,  0.0000, -9.4569,  7.0111],
        [-0.0000, -0.0000,  0.0000,  0.0000],
        [ 9.8063, -0.0000,  0.0000, -9.7993]])
2.weight tensor([[-5.8198,  7.7558, -5.0293]])
 
我们还可以通过改变这些参数的data来改写模型参数值同时不会影响梯度:
 
for name, param in net.named_parameters():
    if 'bias' in name:
        param.data += 1
        print(name, param.data)
 
输出：
 
0.bias tensor([1., 1., 1.])
2.bias tensor([1.])
 
4. 共享模型参数
 
在有些情况下，我们希望在多个层之间共享模型参数。 Module类的forward函数里多次调用同一个层。此外，如果我们传入Sequential的模块是同一个Module实例的话参数也是共享的，下面来看一个例子:
 
linear = nn.Linear(1, 1, bias=False)
net = nn.Sequential(linear, linear) 
print(net)
for name, param in net.named_parameters():
    init.constant_(param, val=3)
    print(name, param.data)
 
输出：
 
Sequential(
  (0): Linear(in_features=1, out_features=1, bias=False)
  (1): Linear(in_features=1, out_features=1, bias=False)
)
0.weight tensor([[3.]])
 
在内存中，这两个线性层其实一个对象:
 
print(id(net[0]) == id(net[1]))
print(id(net[0].weight) == id(net[1].weight))
 
输出:
 
True
True
 
因为模型参数里包含了梯度，所以在反向传播计算时，这些共享的参数的梯度是累加的:
 
x = torch.ones(1, 1)
y = net(x).sum()
print(y)
y.backward()
print(net[0].weight.grad) # 单次梯度是3，两次所以就是6
 
输出:
 
tensor(9., grad_fn=<SumBackward0>)
tensor([[6.]])
 
小结
 
有多种方法来访问、初始化和共享模型参数。
可以自定义初始化方法。

1.预构建网络
 
import torch
import matplotlib.pyplot as plt
import torch.nn.functional as F

#torch.unsqueeze,torch.squeeze,torch.linspace我的之前文章有讲解
#在torch中，只会处理2维的数据
x=torch.unsqueeze(torch.linspace(-1,1,100),dim=1)
#x.pow(2)的意思是x的平方
y=x.pow(2)+0.2*torch.rand(x.size())

class Net(torch.nn.Module):#继承torch的module
    def __init__(self,n_feature,n_hidden,n_output):
        super(Net,self).__init__() #继承__init__功能
        #定义每一层用什么样的样式
        self.hidden = torch.nn.Linear(n_feature,n_hidden) #隐藏层线性输出
        self.predict = torch.nn.Linear(n_hidden,n_output) #输出层线性输出
    def forward(self,x):
        # 激励函数（隐藏层的线性值）
        x=F.relu(self.hidden(x))
        x=self.predict(x) #输出值
        return x
   
net = Net(1,10,1)
print(net)
 
网络结构
 
Net(
  (hidden): Linear(in_features=1, out_features=10, bias=True)
  (predict): Linear(in_features=10, out_features=1, bias=True)
)
 
2.net.parameters()
 
print(net.parameters())
 
结果：
 
<generator object Module.parameters at 0x7ff10f745bd0>
 
para = list(net.parameters())
print(para)
 
结果：
 
[Parameter containing:
tensor([[-0.5081],
        [-0.2130],
        [-0.0958],
        [ 0.3794],
        [-0.4636],
        [-0.4734],
        [-0.8516],
        [ 0.3321],
        [ 0.3731],
        [ 0.5131]], requires_grad=True), Parameter containing:
tensor([ 0.7409, -0.2740, -0.0841,  0.2299,  0.4780, -0.5051,  0.4487, -0.2391,
         0.7307,  0.0095], requires_grad=True), Parameter containing:
tensor([[-0.1322, -0.0158,  0.2620,  0.0499,  0.3109,  0.1158, -0.1099, -0.0687,
         -0.1557,  0.1864]], requires_grad=True), Parameter containing:
tensor([0.1522], requires_grad=True)]
 
官方解释
 
class torch.nn.Parameter()
 
Variable的一种，常被用于模块参数(module parameter)。
 
Parameters 是 Variable 的子类。Paramenters和Modules一起使用的时候会有一些特殊的属性，即：当Paramenters赋值给Module的属性的时候，他会自动的被加到 Module的 参数列表中(即：会出现在 parameters() 迭代器中)。将Varibale赋值给Module属性则不会有这样的影响。 这样做的原因是：我们有时候会需要缓存一些临时的状态(state), 比如：模型中RNN的最后一个隐状态。如果没有Parameter这个类的话，那么这些临时变量也会注册成为模型变量。
 
Variable 与 Parameter的另一个不同之处在于，Parameter不能被 volatile(即：无法设置volatile=True)而且默认requires_grad=True。Variable默认requires_grad=False。
 
参数说明:
 
data (Tensor) – parameter tensor.
 
requires_grad (bool, optional) – 默认为True，在BP的过程中会对其求微分。

Layers/Parameters面板
 
该区域实际上由两个标签页构成，它们分别是 Layers 和 Parameters 。Layers标签页中的内容在小型项目中我们基本用不到，没有具体的人物模型也不好学习，暂时你可以忽略它。而另外一个Parameters标签页中的内容可以说是Animator必需的，包含了我们在Animator中使用的所有“参数”。在拥有多个动画短片的控制器中，正是通过Parameters中的参数实现了不同动画间的转变。
 
切换到Parameters标签页后，我们可以通过点击“+”创建4中类型的参数，它们分别是Float、Int、Bool和Trigger。前三个都比较好理解，均属于基本数据类型。最后一个Trigger则是一个与Bool类似的参数，同样拥有True和False两种状态。但是不像Bool在设置为True后会一直维持，Trigger在被触发后会迅速重置为未触发状态。这个特性在设置动画转变时非常实用。
 
animator.SetTrigger(Name);