Class14参数管理

import torch
from torch import nn

# 定义2个线性层+1个ReLU激活函数
net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,1))
# 输入向量形状为(2,4)
X = torch.rand(size=(2,4))
# 传入网络
net(X)

# 打印第3个模块的参数字典
print(net[2].state_dict())

# 查看第3层的偏移的类型
print(type(net[2].bias))
# 查看第3层的便偏移参数内容
print(net[2].bias)
# 查看偏移中的张量数据
print(net[2].bias.data)

# 查看第3层权重张量的梯度
net[2].weight.grad == None

# 打印出net[0]层所有参数名称和形状
# net[0]:网络中的第1层模块
# named_parameters():返回该层所有可学习的参数及其名字
# param.shape:返回该参数张量的形状
# *:用于解包打印
print(*[(name,param.shape) for name,param in net[0].named_parameters()])
# 打印出整个网络中所有可训练参数的名字和形状
# net.named_parameters():返回整个模型net中所有模块的参数及其名字
# name:每个参数的完整路径名
# param.shape:返回该参数的张量形状
print(*[(name,param.shape) for name,param in net.named_parameters()])

# 访问某一层的偏置对应的张量数据
net.state_dict()['2.bias'].data

# 定义前馈神经网络模块
def block1():
    # 第1个线性层+ReLU
    # 第2个线性层+ReLU
    return nn.Sequential(nn.Linear(4,8),nn.ReLU(),
                         nn.Linear(8,4),nn.ReLU())

# 构建由4个block1组成的block2
def block2():
    net = nn.Sequential()
    # 循环遍历
    for i in range(4):
        # 循环打印block1
        net.add_module(f'block {i}',block1())
    return net

# 调用block2，最终输出为1维
rgnet = nn.Sequential(block2(),nn.Linear(4,1))
# 带入网络
rgnet(X)

# 打印网络
print(rgnet)

# 定义初始化函数
def init_normal(m):
    # 如果是nn.Linear类型层
    if type(m) == nn.Linear:
        # m.weight使用正态分布初始化，为均值0，标准差为0.01
        nn.init.normal_(m.weight,mean = 0,std = 0.01)
        # 偏置全部置为0
        nn.init.zeros_(m.bias)
# 对net中每个子模块递归执行fn(m)
net.apply(init_normal)
# net[0].weight.data[0]:第0个输出神经元的所有输入权重(向量)
# net[0].bias.data[0]:第0个输出神经元的偏置标量(0)
net[0].weight.data[0],net[0].bias.data[0]

# 定义初始化函数
def init_constant(m):
    # 如果子模块是nn.Linear类型层
    if type(m) == nn.Linear:
        # 将所有权重设置为常数1
        nn.init.constant_(m.weight,1)
        # 将其所有偏置设为0
        nn.init.zeros_(m.bias)
# 递归遍历net中素有的子模块，每个模块执行一次init_constant(m)
net.apply(init_constant)
# 查看初始化结果
net[0].weight.data[0],net[0].bias.data[0]

# 定义初始化函数
def init_xavier(m):
    # 如果子模块是nn.Linear类型层
    if type(m) == nn.Linear:
        # 用Xavier均匀分布初始化权重
        nn.init.xavier_uniform_(m.weight)
# 把所有线性层权重初始化为常数42
def init_42(m):
    # 如果子模块是nn.Linear类型层
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight,42)

# 应用初始化到不同层
net[0].apply(init_xavier)
net[2].apply(init_42)
# 打印结果
print(net[0].weight.data[0])
print(net[2].weight.data)

# 自定义初始化函数
def my_init(m):
    # 如果子模块是nn.Linear类型层
    if type(m) == nn.Linear:
        # 打印当前初始化层的第1个参数名称和形状
        print("Init",*[(name,param.shape)
                      for name,param in m.named_parameters()][0])
        # 将权重初始化为[-10,10]范围内的均匀分布随机值
        nn.init.uniform_(m.weight,-10,10)
        # 满足权重>5的元素保留原值，其余全部为0
        m.weight.data *= m.weight.data.abs() >= 5

# 遍历并对网络中所有子模块递归执行
net.apply(my_init)
# 查看初始化后的权重
net[0].weight[:2]

# 将第0层所有权重整体+1
net[0].weight.data[:] += 1
# 将第0层的权重矩阵中的第0行第0列元素设置为42
net[0].weight.data[0,0] = 42
# 打印第0层第0个输出神经元对应的全部输入权重
net[0].weight.data[0]

生成线性层:输入8，输出8

shared = nn.Linear(8,8)

4个线性层+3个ReLU函数

net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),
shared,nn.ReLU(),
shared,nn.ReLU(),
nn.Linear(8,1))

# 传入网络
net(X)
# 权重共享测试
# 查看第1次和第2次的shared层的第0行权重向量是否相同
print(net[2].weight.data[0] == net[4].weight.data[0])
# 将第0行第0列的权重直接赋值为100
net[2].weight.data[0,0] = 100
# 再次查看第1次和第2次的shared层的第0行权重向量是否相同
print(net[2].weight.data[0] == net[4].weight.data[0])