Pytorch学习之神经网络参数管理

已于 2022-05-25 10:28:22 修改
阅读量2.8k 收藏 35
点赞数 5
分类专栏： 神经网络 深度学习 Python 文章标签： pytorch 神经网络 深度学习
于 2022-05-25 10:23:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ting_qifengl/article/details/124959266
版权

这里记录一下pytorch神经网络参数管理方法(参数访问、参数初始化、参数绑定)，方便自己和需要的朋友学习、查阅。

目录

一、参数访问

1.1 访问指定层的指定参数

1.2 访问某一层或整个网络的所有参数

1.3 访问嵌套块的指定参数

二、参数初始化

2.1 内置初始化

2.2 自定义初始化

三、参数绑定

四、全部测试代码

一、参数访问

1.1 访问指定层的指定参数

首先构建一个多层感知机。

import torch
from torch import nn

net = nn.Sequential(nn.Linear(2, 4), nn.ReLU(), nn.Linear(4, 1))
X = torch.rand(size=(2, 2))

当通过nn.Sequential定义模型时， 我们可以通过索引来访问模型的任意层。 这就像模型是一个列表一样，每层的参数都在其属性中。 如下所示，我们可以检查任意一个全连接层的参数。

# 1 查看网络第一层(即第一个全连接层)的参数
print(net[0].state_dict())
# 2 查看网络第三层(即第二个全连接层)偏置参数的类型
print(type(net[2].bias))
# 3 查看网络第三层(即第二个全连接层)偏置参数
print(net[2].bias)
# 4 查看网络第三层(即第二个全连接层)偏置参数的值
print(net[2].bias.data)
# 5 查看网络第一层(即第一个全连接层)权重参数
print(net[0].weight)
# 6 查看网络第二层
print(net[1])

结果分别如下所示：

# 1
OrderedDict([('weight', tensor([[ 0.0854,  0.1861],
        [ 0.5421,  0.2435],
        [ 0.5745,  0.2469],
        [ 0.4120, -0.4345]])), ('bias', tensor([ 0.3356,  0.4215,  0.2181, -0.2548]))])
# 2
<class 'torch.nn.parameter.Parameter'>
# 3
Parameter containing:
tensor([-0.1606], requires_grad=True)
# 4
tensor([-0.1606])
# 5
Parameter containing:
tensor([[-0.4710,  0.0820],
        [-0.5563,  0.0728],
        [ 0.1691,  0.2211],
        [ 0.4279, -0.5597]], requires_grad=True)
# 6
ReLU()

可以看出，每个参数都表示为参数类的一个实例，要对参数执行任何操作，首先需要访问底层的数值。网络层数从0开始，即net[0]表示网络第一层，激活函数也是网络中的一层。

访问偏置使用basis属性，访问权重使用weight属性。参数是复合的对象，包含值、梯度和额外信息。若只想获取参数的值，要在basis或weight后加data属性。除了值之外，我们还可以访问每个参数的梯度。

print(net[2].weight.grad == None)
# 结果为 True
# 原因：由于还没有调用反向传播，所以参数的梯度处于初始状态

1.2 访问某一层或整个网络的所有参数

当需要对所有参数执行操作时，逐个访问它们可能会很麻烦，此时我们可以通过递归整个树来提取每个子块的参数。

# 1 访问第一层的所有参数
print(*[(name, param.shape) for name, param in net[0].named_parameters()])
# 2 访问网络所有层的全部参数
print(*[(name, param.shape) for name, param in net.named_parameters()])

结果如下：

# 1
('weight', torch.Size([4, 2])) ('bias', torch.Size([4]))
# 2
('0.weight', torch.Size([4, 2])) ('0.bias', torch.Size([4])) ('2.weight', torch.Size([1, 4])) ('2.bias', torch.Size([1]))

注意：激活函数没有参数，所以打印出来的网络的所有参数只有两个全连接层的参数。

此外，我们还可以通过下述方式访问网络参数。

# 访问第网络第三层的偏置参数的值
print(net.state_dict()['2.bias'].data)

结果如下：

tensor([-0.1089])

 如果不使用nn.Sequential定义模型，而是自己定义一个类实现网络，则不能使用索引访问指定层的参数。如下所示：

class mlp(nn.Module):
    def __init__(self, input_size, output_size):
        super().__init__()
        self.linear1 = nn.Linear(input_size, 4)  # 全连接层
        self.relu = nn.ReLU()
        self.linear2 = nn.Linear(4, output_size)  # 全连接层

    def forward(self, x):
        x = self.linear1(x)
        return self.relu(self.linear2(x))

mlp_net= mlp(2, 1)
X = torch.rand(size=(2, 2))
# 如果使用索引访问会报错
print(mlp_net[0].state_dict())

此时会输出如下结果：

Traceback (most recent call last):
  File "E:/SoftwareLearning/Python/Code/d2l-Train/ParameterManagement.py", line 46, in <module>
    print(mlp_net[0].state_dict())
TypeError: 'mlp' object is not subscriptable

但可以通过下述方式进行访问：

# linear2为定义网络模型时自己起的某一全连接层的名称
print(mlp_net.state_dict()['linear2.bias'].data)

输出结果如下：

tensor([0.3709])

1.3 访问嵌套块的指定参数

首先构建一个嵌套块的网络。

def block1():
    return nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
                         nn.Linear(8, 4), nn.ReLU())


def block2():
    net = nn.Sequential()
    for i in range(4):
        # 在这里嵌套
        net.add_module(f'block {i}', block1())
    return net

# 实例化
rgnet = nn.Sequential(block2(), nn.Linear(4, 1))
# 查看网络结构
print(rgnet)

输出结果如下：

Sequential(
  (0): Sequential(
    (block 0): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 1): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 2): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 3): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
  )
  (1): Linear(in_features=4, out_features=1, bias=True)
)

因为是分层嵌套的，所以我们也可以像通过嵌套列表索引一样访问它们。下面，我们访问第一个主要的块中第二个子块的第一层的权重项。

print(rgnet[0][1][0].weight.data)

输出结果如下：

tensor([[ 0.3175,  0.0233,  0.3233, -0.0627],
        [-0.0835, -0.3371, -0.4527,  0.0141],
        [ 0.1070,  0.3952,  0.4051,  0.3921],
        [ 0.1958, -0.3643,  0.4481, -0.3448],
        [ 0.0446, -0.0256,  0.1490,  0.4568],
        [-0.1352, -0.2099, -0.1225, -0.0413],
        [ 0.3027,  0.2114, -0.4063, -0.0288],
        [-0.4594,  0.0076, -0.2671,  0.2669]])

二、参数初始化

初始化对神经网络来说十分重要，良好的初始化能帮助模型快速收敛，对保持网络的数值稳定性至关重要。默认情况下，PyTorch会根据一个范围均匀地初始化权重和偏置矩阵，这个范围是根据输入和输出维度计算出的。PyTorch的nn.init模块提供了多种预置初始化方法。

2.1 内置初始化

首先调用内置的初始化器对网络参数进行初始化。下面的代码将所有权重参数初始化为标准差为0.01的高斯随机变量， 且将偏置参数设置为0。

# 将所有权重参数初始化为标准差为0.01的高斯随机变量， 且将偏置参数设置为0
def init_normal(m):
    if type(m) == nn.Linear:
        # 将权重参数初始化为标准差为0.01的高斯随机变量
        nn.init.normal_(m.weight, mean=0, std=0.01)
        # 将偏置参数初始化为0
        nn.init.zeros_(m.bias)

net.apply(init_normal)
print(net[0].weight.data[0], '\n', net[0].bias.data[0])

输出结果如下：

tensor([-0.0142, -0.0054]) 
tensor(0.)

我们还可以将所有参数初始化为给定的常数，比如初始化为1。

# 将所有参数初始化为给定的常数
def init_constant(m):
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight, 1)
        nn.init.zeros_(m.bias)

net.apply(init_constant)
print(net[0].weight.data[0], net[0].bias.data[0])

输出结果如下：

tensor([1., 1.]) 
tensor(0.)

我们还可以对不同层应用不同的初始化方法。 例如，下面我们使用Xavier初始化方法初始化第一个神经网络层， 然后将第三个神经网络层初始化为常量值42。

def xavier(m):
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)


def init_42(m):
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight, 42)


# 使用Xavier初始化方法初始化第一个神经网络层， 然后将第三个神经网络层初始化为常量值42
net[0].apply(xavier)
net[2].apply(init_42)
print(net[0].weight.data[0])
print(net[2].weight.data)

输出结果如下：

tensor([ 0.9265, -0.1521])
tensor([[42., 42., 42., 42.]])

2.2 自定义初始化

有时，深度学习框架没有提供我们需要的初始化方法，此时就需要我们自定义初始化方法实现参数初始化。

# 自定义初始化
def my_init(m):
    if type(m) == nn.Linear:
        print("Init", *[(name, param.shape)
                        for name, param in m.named_parameters()][0])
        nn.init.uniform_(m.weight, -10, 10)  # 均匀分布
        # 如果绝对值大于5则参数不变，如果绝对值小于5则将参数置0
        m.weight.data *= m.weight.data.abs() >= 5


net.apply(my_init)
print(net[0].weight[:2])

输出结果如下：

Init weight torch.Size([4, 2])
Init weight torch.Size([1, 4])
tensor([[ 6.6987, -5.3545],
        [ 6.6684, -6.3039]], grad_fn=<SliceBackward0>)

也可以根据需要直接对指定层的参数进行设置。

net[0].weight.data[:] += 1
net[0].weight.data[0, 0] = 42
print(net[0].weight.data[0])

输出结果如下：

Init weight torch.Size([4, 2])
Init weight torch.Size([1, 4])
tensor([42.0000,  8.5777])

三、参数绑定

有时我们希望在多个层间共享参数，此时，我们可以定义一个全连接层，然后使用它的参数来设置另一个层的参数，实现参数共享。

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

print(net(X))
# 检查参数是否相同
print(net[2].weight.data[0] == net[4].weight.data[0])
net[2].weight.data[0, 0] = 100
# 确保它们实际上是同一个对象，而不只是有相同的值
print(net[2].weight.data[0] == net[4].weight.data[0])

输出结果如下：

tensor([[0.4362],
        [0.4562]], grad_fn=<AddmmBackward0>)
tensor([True, True, True, True])
tensor([True, True, True, True])

这个例子表明第三个和第五个神经网络层的参数是绑定的。它们不仅值相等，而且由相同的张量表示。因此，如果我们改变其中一个参数，另一个参数也会改变。你可能会思考：当参数绑定时，梯度会发生什么情况？ 答案是由于模型参数包含梯度，因此在反向传播期间第二个隐藏层 （即第三个神经网络层）和第三个隐藏层（即第五个神经网络层）的梯度会加在一起。

四、全部测试代码

全部测试代码如下。

import torch
from torch import nn


class mlp(nn.Module):
    def __init__(self, input_size, output_size):
        super().__init__()
        self.linear1 = nn.Linear(input_size, 4)  # 全连接层
        self.relu = nn.ReLU()
        self.linear2 = nn.Linear(4, output_size)  # 全连接层

    def forward(self, x):
        x = self.linear1(x)
        return self.relu(self.linear2(x))


def block1():
    return nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
                         nn.Linear(8, 4), nn.ReLU())


def block2():
    net = nn.Sequential()
    for i in range(4):
        # 在这里嵌套
        net.add_module(f'block {i}', block1())
    return net


net = nn.Sequential(nn.Linear(2, 4), nn.ReLU(), nn.Linear(4, 1))
X = torch.rand(size=(2, 2))
print(net(X))
# 当通过Sequential类定义模型时，可以通过索引来访问模型的任意层。这就像模型是一个列表一样，每层的参数都在其属性中。
print(net[0].state_dict())
print(type(net[2].bias))
print(net[2].bias)
print(net[2].bias.data)
print(net[0].weight)
print(net[1])
print(net[2].weight.grad == None)

# 一次性访问所有参数
print(*[(name, param.shape) for name, param in net[0].named_parameters()])
print(*[(name, param.shape) for name, param in net.named_parameters()])
# 访问网络参数的另一种方式
print(net.state_dict()['2.bias'].data)

# 不使用nn.Sequential定义模型
mlp_net = mlp(2, 1)
X = torch.rand(size=(2, 2))
print(mlp_net(X))
# 不能使用索引访问某一层的参数，会报错
# print(mlp_net[0].state_dict())
print(mlp_net.state_dict()['linear2.bias'].data)

# 从嵌套块收集参数
rgnet = nn.Sequential(block2(), nn.Linear(4, 1))
print(rgnet)
# 访问第一个主要的块中、第二个子块的第一层的权重
print(rgnet[0][1][0].weight.data)


# 参数初始化
# 将所有权重参数初始化为标准差为0.01的高斯随机变量， 且将偏置参数设置为0
def init_normal(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, mean=0, std=0.01)
        nn.init.zeros_(m.bias)


# 将所有参数初始化为给定的常数
def init_constant(m):
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight, 1)
        nn.init.zeros_(m.bias)


net.apply(init_normal)
print(net[0].weight.data[0], '\n', net[0].bias.data[0])

net.apply(init_constant)
print(net[0].weight.data[0], '\n', net[0].bias.data[0])


def xavier(m):
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)


def init_42(m):
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight, 42)


# 使用Xavier初始化方法初始化第一个神经网络层， 然后将第三个神经网络层初始化为常量值42
net[0].apply(xavier)
net[2].apply(init_42)
print(net[0].weight.data[0])
print(net[2].weight.data)


# 自定义初始化
def my_init(m):
    if type(m) == nn.Linear:
        print("Init", *[(name, param.shape)
                        for name, param in m.named_parameters()][0])
        nn.init.uniform_(m.weight, -10, 10)
        m.weight.data *= m.weight.data.abs() >= 5


net.apply(my_init)
print(net[0].weight[:2])

# 也可以直接设置参数
net[0].weight.data[:] += 1
net[0].weight.data[0, 0] = 42
print(net[0].weight.data[0])

# 参数绑定
# 有时我们希望在多个层间共享参数：我们可以定义一个稠密层，然后使用它的参数来设置另一个层的参数
# 我们需要给共享层一个名称，以便可以引用它的参数
shared = nn.Linear(4, 4)
net = nn.Sequential(nn.Linear(2, 4), nn.ReLU(),
                    shared, nn.ReLU(),
                    shared, nn.ReLU(),
                    nn.Linear(4, 1))
print(net(X))
# 检查参数是否相同
print(net[2].weight.data[0] == net[4].weight.data[0])
net[2].weight.data[0, 0] = 100
# 确保它们实际上是同一个对象，而不只是有相同的值
print(net[2].weight.data[0] == net[4].weight.data[0])

pytorch 实现查看网络中的参数
09-18
今天小编就为大家分享一篇pytorch 实现查看网络中的参数，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
一个 Pytorch 深度学习神经网络训练和测试的模板代码.zip
01-13
这份压缩包“Pytorch深度学习神经网络训练和测试的模板代码.zip”提供了实现这一过程的基础框架，适用于初学者和有一定经验的开发者。以下是根据标题、描述和标签生成的相关知识点： 1. **PyTorch框架介绍**： ...
Pytorch获取神经网络各层的参数名称及参数值
信小海
12-30 6900
model.children()函数、model.state_dict()函数、model.parameters()函数和models.named_parameters()函数的实例演示。
个人学习笔记4：动手学深度学习pytorch版-李沐
最新发布
浪子L的博客
09-05 1031
主要记录学习笔记，学习书目为李沐老师的《动手学习深度学习》 重预备知识开始记录。 开源书籍地址：https://zh-v2.d2l.ai/chapter_preface/index.htmll 李沐老师B站视频：https://space.bilibili.com/1567748478/channel/seriesdetail?sid=358497
PyTorch网络及参数查看
lzfshub
08-03 2056
1. 查看网络 # 1. 直接打印网络 print(model) # 2. 打印网络及按名称查看子网络 for name, module in net.named_modules(): print(name, module) # 3. 按名称查看子网络 for name, module in net.named_children(): print(name, module) # 4. 使用第三方工具库 # 使用 pip install torchsummary import torch im
pytorch中关于网络参数的相关操作
MasterCayman的博客
08-06 868
在深度学习中，获取网络的参数信息，对网络的finetune非常重要，下面将举一个简单的例子说明如何获取网络参数。 # coding: utf-8 import torch.nn as nn import torch.nn.functional as F # ----------------------------------- state_dict class Net(nn.Module): def __init__(self): super(Net, self).__in
网络参数量、输出特征图大小、FLOPs计算及pytorch代码统计网络参数量
Daisy_D99的博客
06-10 4608
网络参数量、输出特征图大小、FLOPs计算及pytorch代码统计网络参数量
PyTorch快速搭建神经网络及其保存提取方法详解.pdf
04-17
在PyTorch中，快速搭建神经网络是深度学习实践中的一项基本技能。本教程将详细介绍如何使用PyTorch创建神经网络模型以及如何保存和提取模型的权重和参数。 首先，我们来看如何快速搭建神经网络。PyTorch提供了两种...
python进阶教程：PyTorch快速搭建神经网络及其保存提取方法详解
12-21
在PyTorch中，搭建神经网络可以通过自定义类或使用`torch.nn.Sequential`来实现。在本教程中，我们将深入探讨这两种方法，并介绍如何保存和提取训练好的模型。 首先，让我们详细了解一下这两种创建神经网络的方法：...
动手学深度学习PyTorch版 | （4）循环神经网络
12-23
循环神经网络（Recurrent Neural Network, RNN）是一种在序列数据处理方面表现出色的深度学习模型，特别适合处理如自然语言、音频等时间序列数据。RNN 的核心思想是通过循环结构来处理输入序列，使得当前时刻的隐藏...
查看神经网络的参数
weixin_43143419的博客
08-13 5639
1.查看模型的参数、参数量、参数的梯度 params=list(model.parameters()) print(params[0]) print(params[1]) print(params[2]) print(params[3]) loss=model.loss(o1,o2) print(params[0].grad) 调试的时候可以通过params查看网络每...
pytorch网络和参数的操作
weixin_45091814的博客
05-20 226
pytorch网络的参数的操作
Pytorch查看网络参数和网络内变量名称
呆呆象呆呆的博客
08-17 3293
主要目标 打印如下信息 网络结构 网络每一层变量的名字 网络每一层变量的具体每一个参数 因为有的时候直接整个网络打印的话（1）是会很难找（2）当参数很多的时候，有的时候会缩略起来看不到那个参数 实验代码 import torch import torch.nn as nn import numpy as np import os class NET(nn.Module): def __init__(self): super(NET, self).__init__()
Pytorch统计参数网络参数数量
qq_34535410的博客
04-30 1万+
def get_parameter_number(net): total_num = sum(p.numel() for p in net.parameters()) trainable_num = sum(p.numel() for p in net.parameters() if p.requires_grad) return {'Total': total_num, ...
Pytorch-如何查看网络的模块和参数
每天都要进步哦~
02-06 4466
Pytorch-如何查看网络的模块和参数 在实验的过程中，我们经常需要知道当前网络由哪些模块组成，以及这些模块当前的参数是什么。 查看模块 以如下网络为例： m = nn.Sequential(nn.Linear(2, 2), nn.ReLU(), nn.Sequential(nn.BatchNorm2d(2), nn.ReL...
[Pytorch系列-48]：如何查看和修改预定义神经网络的网络架构、网络参数属性
热门推荐
文火冰糖（王文兵）的博客
11-15 1万+
作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客 本文网址： 目录 第1章FineTuning、Transfer Trainning的理论基础与深度解析 第2章查看预定义神经网络的网络架构 2.1 前置条件 2.2 生成预定义网络实例 2.3 显示网络结构 2.4查看网络的内部特定结构以及对应的名称 第3章查看预定义神经网络的参数 3.1查看模型参数的名称以及结构 3.2 查看模型全部参数的结构以及当前的数值 3.3无名查看模型参...
pytorch_神经网络模型搭建系列（2）：自定义神经网络层
xgxg1314的博客
12-15 2679
目录1、nn.Module——搭建属于自己的神经网络1.1 回顾系统预定义的层1.1.1 最常用的Linear层1.1.2 Conv2d类的源代码1.1.3 小结1.1.4 自定义层的基本步骤1.2 简单实现-自定义层1.2.1 第一步：定义一个的层（即一个类）1.2.2 第二步：定义一个神经网络模型1.2.3 第三步：训练模型1.2.4 小结1.3 补充：model.parameters()和model.state_dict()1.3.1 model.parameters()1.3.2 model.sta
pytorch卷积神经网络的全连接层第一层参数（input_features）设置
CZ505632696的博客
01-09 1万+
  在用pytorch写网络结构的时候，会发现在卷积层与第一个全连接层的全连接层的input_features不知道该写多少？   这个时候我们可以换一个思路，由于pytorch支持动态图，所以我们可以把全链接层写在forward这个函数里面，这样就很好的解决了这个尴尬的问题。 代码如下 import torch as tc from torch import nn class CNN(nn.M...
pytroch中 module.apply() / net.apply () 的用法
qq_54628272的博客
10-09 603
这个init_normal()函数其实就是一个初始化参数w,b的函数，，让net网络模型每一层的w，b参数都进行用样的初始化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值