pytorch中的参数初始化方法总结

最新推荐文章于 2025-08-11 15:31:24 发布
原创 最新推荐文章于 2025-08-11 15:31:24 发布 · 7w 阅读 · 415 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了深度学习中参数初始化的重要性，详细介绍了PyTorch框架下多种初始化方法，包括Xavier、He、正交初始化等，以及它们在不同场景下的应用。
部署运行你感兴趣的模型镜像

参数初始化（Weight Initialization）

PyTorch 中参数的默认初始化在各个层的 reset_parameters() 方法中。例如：nn.Linear 和 nn.Conv2D，都是在 [-limit, limit] 之间的均匀分布（Uniform distribution），其中 limit 是 1. / sqrt(fan_in) ，fan_in 是指参数张量（tensor）的输入单元的数量

下面是几种常见的初始化方式。

Xavier Initialization

Xavier初始化的基本思想是保持输入和输出的方差一致，这样就避免了所有输出值都趋向于0。这是通用的方法，适用于任何激活函数。

# 默认方法
for m in model.modules():
    if isinstance(m, (nn.Conv2d, nn.Linear)):
        nn.init.xavier_uniform_(m.weight)

也可以使用 gain 参数来自定义初始化的标准差来匹配特定的激活函数：

for m in model.modules():
    if isinstance(m, (nn.Conv2d, nn.Linear)):
        nn.init.xavier_uniform_(m.weight(), gain=nn.init.calculate_gain('relu'))

参考资料：

He et. al Initialization

torch.nn.init.kaiming_uniform_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu')

He initialization的思想是：在ReLU网络中，假定每一层有一半的神经元被激活，另一半为0。推荐在ReLU网络中使用。

# he initialization
for m in model.modules():
    if isinstance(m, (nn.Conv2d, nn.Linear)):
        nn.init.kaiming_normal_(m.weight, mode='fan_in')

正交初始化（Orthogonal Initialization）

主要用以解决深度网络下的梯度消失、梯度爆炸问题，在RNN中经常使用的参数初始化方法。

for m in model.modules():
    if isinstance(m, (nn.Conv2d, nn.Linear)):
        nn.init.orthogonal(m.weight)

Batchnorm Initialization

在非线性激活函数之前，我们想让输出值有比较好的分布（例如高斯分布），以便于计算梯度和更新参数。Batch Normalization 将输出值强行做一次 Gaussian Normalization 和线性变换：

实现方法：

for m in model:
    if isinstance(m, nn.BatchNorm2d):
        nn.init.constant(m.weight, 1)
        nn.init.constant(m.bias, 0)

单层初始化

conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)
nn.init.xavier_uniform(conv1.weight)
nn.init.constant(conv1.bias, 0.1)

模型初始化

def weights_init(m):
    classname = m.__class__.__name__
    if classname.find('Conv2d') != -1:
        nn.init.xavier_normal_(m.weight.data)
        nn.init.constant_(m.bias.data, 0.0)
    elif classname.find('Linear') != -1:
        nn.init.xavier_normal_(m.weight)
        nn.init.constant_(m.bias, 0.0)
net = Net()
net.apply(weights_init) #apply函数会递归地搜索网络内的所有module并把参数表示的函数应用到所有的module上。

不建议访问以下划线为前缀的成员，他们是内部的，如果有改变不会通知用户。更推荐的一种方法是检查某个module是否是某种类型：

def weights_init(m):
    if isinstance(m, (nn.Conv2d, nn.Linear)):
        nn.init.xavier_normal_(m.weight)
        nn.init.constant_(m.bias, 0.0)

import torch
import torch.nn as nn

w = torch.empty(2, 3)

# 1. 均匀分布 - u(a,b)
# torch.nn.init.uniform_(tensor, a=0, b=1)
nn.init.uniform_(w)
# tensor([[ 0.0578,  0.3402,  0.5034],
#         [ 0.7865,  0.7280,  0.6269]])

# 2. 正态分布 - N(mean, std)
# torch.nn.init.normal_(tensor, mean=0, std=1)
nn.init.normal_(w)
# tensor([[ 0.3326,  0.0171, -0.6745],
#        [ 0.1669,  0.1747,  0.0472]])

# 3. 常数 - 固定值 val
# torch.nn.init.constant_(tensor, val)
nn.init.constant_(w, 0.3)
# tensor([[ 0.3000,  0.3000,  0.3000],
#         [ 0.3000,  0.3000,  0.3000]])

# 4. 对角线为 1，其它为 0
# torch.nn.init.eye_(tensor)
nn.init.eye_(w)
# tensor([[ 1.,  0.,  0.],
#         [ 0.,  1.,  0.]])

# 5. Dirac delta 函数初始化，仅适用于 {3, 4, 5}-维的 torch.Tensor
# torch.nn.init.dirac_(tensor)
w1 = torch.empty(3, 16, 5, 5)
nn.init.dirac_(w1)

# 6. xavier_uniform 初始化
# torch.nn.init.xavier_uniform_(tensor, gain=1)
# From - Understanding the difficulty of training deep feedforward neural networks - Bengio 2010
nn.init.xavier_uniform_(w, gain=nn.init.calculate_gain('relu'))
# tensor([[ 1.3374,  0.7932, -0.0891],
#         [-1.3363, -0.0206, -0.9346]])

# 7. xavier_normal 初始化
# torch.nn.init.xavier_normal_(tensor, gain=1)
nn.init.xavier_normal_(w)
# tensor([[-0.1777,  0.6740,  0.1139],
#         [ 0.3018, -0.2443,  0.6824]])

# 8. kaiming_uniform 初始化
# From - Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification - HeKaiming 2015
# torch.nn.init.kaiming_uniform_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu')
nn.init.kaiming_uniform_(w, mode='fan_in', nonlinearity='relu')
# tensor([[ 0.6426, -0.9582, -1.1783],
#         [-0.0515, -0.4975,  1.3237]])

# 9. kaiming_normal 初始化
# torch.nn.init.kaiming_normal_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu')
nn.init.kaiming_normal_(w, mode='fan_out', nonlinearity='relu')
# tensor([[ 0.2530, -0.4382,  1.5995],
#         [ 0.0544,  1.6392, -2.0752]])

# 10. 正交矩阵 - (semi)orthogonal matrix
# From - Exact solutions to the nonlinear dynamics of learning in deep linear neural networks - Saxe 2013
# torch.nn.init.orthogonal_(tensor, gain=1)
nn.init.orthogonal_(w)
# tensor([[ 0.5786, -0.5642, -0.5890],
#         [-0.7517, -0.0886, -0.6536]])

# 11. 稀疏矩阵 - sparse matrix 
# 非零元素采用正态分布 N(0, 0.01) 初始化.
# From - Deep learning via Hessian-free optimization - Martens 2010
# torch.nn.init.sparse_(tensor, sparsity, std=0.01)
nn.init.sparse_(w, sparsity=0.1)
# tensor(1.00000e-03 *
#        [[-0.3382,  1.9501, -1.7761],
#         [ 0.0000,  0.0000,  0.0000]])

Xavier均匀分布

torch.nn.init.xavier_uniform_(tensor, gain=1)
xavier初始化方法中服从均匀分布U(−a,a) ，分布的参数a = gain * sqrt(6/fan_in+fan_out)，
这里有一个gain，增益的大小是依据激活函数类型来设定
eg：nn.init.xavier_uniform_(w, gain=nn.init.calculate_gain(‘relu’))
PS：上述初始化方法，也称为Glorot initialization

"""
torch.nn.init.xavier_uniform_(tensor, gain=1)
根据Glorot, X.和Bengio, Y.在“Understanding the dif×culty of training deep feedforward neural
networks”中描述的方法，用一个均匀分布生成值，填充输入的张量或变量。结果张量中的值
采样自U(-a, a)，其中a= gain * sqrt( 2/(fan_in + fan_out))* sqrt(3). 该方法也被称为Glorot initialisat

参数：
tensor – n维的torch.Tensor
gain - 可选的缩放因子
"""
import torch
from torch import nn
w=torch.Tensor(3,5)
nn.init.xavier_uniform_(w,gain=1)
print(w)

Xavier正态分布

torch.nn.init.xavier_normal_(tensor, gain=1)
xavier初始化方法中服从正态分布，
mean=0,std = gain * sqrt(2/fan_in + fan_out)

kaiming初始化方法，论文在《 Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》，公式推导同样从“方差一致性”出法，kaiming是针对xavier初始化方法在relu这一类激活函数表现不佳而提出的改进，详细可以参看论文。

"""
根据Glorot, X.和Bengio, Y. 于2010年在“Understanding the dif×culty of training deep
feedforward neural networks”中描述的方法，用一个正态分布生成值，填充输入的张量或变
量。结果张量中的值采样自均值为0，标准差为gain * sqrt(2/(fan_in + fan_out))的正态分布。
也被称为Glorot initialisation.
参数：
tensor – n维的torch.Tensor
gain - 可选的缩放因子
"""
    
b=torch.Tensor(3,4)
nn.init.xavier_normal_(b, gain=1)
print(b)

kaiming均匀分布

torch.nn.init.kaiming_uniform_(tensor, a=0, mode=‘fan_in’, nonlinearity=‘leaky_relu’)
此为均匀分布，U～（-bound, bound）, bound = sqrt(6/(1+a^2)*fan_in)
其中，a为激活函数的负半轴的斜率，relu是0
mode- 可选为fan_in 或 fan_out, fan_in使正向传播时，方差一致; fan_out使反向传播时，方差一致
nonlinearity- 可选 relu 和 leaky_relu ，默认值为 。 leaky_relu
nn.init.kaiming_uniform_(w, mode=‘fan_in’, nonlinearity=‘relu’)

w=torch.Tensor(3,5)
nn.init.kaiming_normal_(w,a=0,mode='fan_in')
print(w)

kaiming正态分布

torch.nn.init.kaiming_normal_(tensor, a=0, mode=‘fan_in’, nonlinearity=‘leaky_relu’)
此为0均值的正态分布，N～ (0,std)，其中std = sqrt(2/(1+a^2)*fan_in)
其中，a为激活函数的负半轴的斜率，relu是0
mode- 可选为fan_in 或 fan_out, fan_in使正向传播时，方差一致;fan_out使反向传播时，方差一致
nonlinearity- 可选 relu 和 leaky_relu ，默认值为 。 leaky_relu
nn.init.kaiming_normal_(w, mode=‘fan_out’, nonlinearity=‘relu’)

2.其他

均匀分布初始化

torch.nn.init.uniform_(tensor, a=0, b=1)
使值服从均匀分布U(a,b)

tensor - n维的torch.Tensor
a - 均匀分布的下界
b - 均匀分布的上界

正态分布初始化

torch.nn.init.normal_(tensor, mean=0, std=1)
使值服从正态分布N(mean, std)，默认值为0，1

tensor – n维的torch.Tensor
mean – 正态分布的均值
std – 正态分布的标准差

常数初始化

torch.nn.init.constant_(tensor, val)
使值为常数val nn.init.constant_(w, 0.3)

"""
torch.nn.init.constant(tensor, val)
用val的值填充输入的张量或变量
参数：
tensor – n维的torch.Tensor或autograd.Variable
val – 用来填充张量的值
"""
w=torch.Tensor(3,5)
nn.init.constant_(w,1.2)
print(w)
tensor([[1.2000, 1.2000, 1.2000, 1.2000, 1.2000],
        [1.2000, 1.2000, 1.2000, 1.2000, 1.2000],
        [1.2000, 1.2000, 1.2000, 1.2000, 1.2000]])

单位矩阵初始化

torch.nn.init.eye_(tensor)
将二维tensor初始化为单位矩阵（the identity matrix）


"""
torch.nn.init.eye(tensor)
用单位矩阵来填充2维输入张量或变量。在线性层尽可能多的保存输入特性。
参数：
tensor – 2维的torch.Tensor或autograd.Variable
"""
w=torch.Tensor(3,5)
nn.init.eye_(w)
print(w)
tensor([[1., 0., 0., 0., 0.],
        [0., 1., 0., 0., 0.],
        [0., 0., 1., 0., 0.]])

正交初始化

torch.nn.init.orthogonal_(tensor, gain=1)
使得tensor是正交的，论文:Exact solutions to the nonlinear dynamics of learning in deep linear neural networks” - Saxe, A. et al. (2013)

"""
torch.nn.init.orthogonal_(tensor, gain=1)
25 torch.nn.init - PyTorch中文文档
https://pytorch-cn.readthedocs.io/zh/latest/package_references/nn_init/ 5/5
用（半）正交矩阵填充输入的张量或变量。输入张量必须至少是2维的，对于更高维度的张
量，超出的维度会被展平，视作行等于第一个维度，列等于稀疏矩阵乘积的2维表示。其中非
零元素生成自均值为0，标准差为std的正态分布。

参数：
tensor – n维的torch.Tensor或 autograd.Variable，其中n>=2
gain -可选
"""
w = torch.Tensor(3, 5)
nn.init.orthogonal_(w)
print(w)

稀疏初始化

torch.nn.init.sparse_(tensor, sparsity, std=0.01)
从正态分布N～（0. std）中进行稀疏化，使每一个column有一部分为0
sparsity- 每一个column稀疏的比例，即为0的比例_

sparsity - 每列中需要被设置成零的元素比例
std - 用于生成非零值的正态分布的标准差
nn.init.sparse_(w, sparsity=0.1)

w = torch.Tensor(3, 5)
nn.init.sparse_(w, sparsity=0.1)
print(w)

tensor([[-0.0042,  0.0000,  0.0000, -0.0016,  0.0000],
        [ 0.0000,  0.0050,  0.0082,  0.0000,  0.0003],
        [ 0.0018, -0.0016, -0.0003, -0.0068,  0.0103]])

dirac

"""
torch.nn.init.dirac(tensor)
用Dirac 函数来填充{3, 4, 5}维输入张量或变量。在卷积层尽可能多的保存输入通道特性
参数：
tensor – {3, 4, 5}维的torch.Tensor或autograd.Variable
"""
w=torch.Tensor(3,16,5,5)
nn.init.dirac_(w)
print(w)

w.sum()
tensor(3.)

计算增益calculate_gain

torch.nn.init.calculate_gain(nonlinearity, param=None)

torch.nn.init.calculate_gain(nonlinearity,param=None)
对于给定的非线性函数，返回推荐的增益值.
参数：
nonlinearity - 非线性函数（ nn.functional 名称）
param - 非线性函数的可选参数

from torch import nn
import torch
gain = nn.init.calculate_gain('leaky_relu')
print(gain)

1.4141428569978354
nonlinearitygain
Linear / Identity1
Conv{1,2,3}D1
Sigmoid1
Tanh5/3
ReLUsqrt(2)

您可能感兴趣的与本文相关的镜像

PyTorch 2.9

PyTorch 2.9

PyTorch
Cuda

PyTorch 是一个开源的 Python 机器学习库，基于 Torch 库，底层由 C++ 实现，应用于人工智能领域，如计算机视觉和自然语言处理

Pytorch中的参数初始化
我是天才很好
07-25 6769
文章目录1. 参数初始化（Weight Initialization）1.1 常数初始化1.2 均匀分布初始化1.3 正态分布初始化1.4 Xavier均匀分布1.5 Xavier正态分布1.6 kaiming均匀分布1.7 kaiming正态分布1.8 单位矩阵初始化1.9 正交初始化1.10 稀疏初始化1.11 dirac1.12 计算增益calculate_gain2. 单层初始化3. 模型初始化Xavier InitializationHe et. al Initialization正交初始化（Or
Pytorch的内置模型 #2 卷积模型
goes_on的博客
10-16 1979
文章目录Pytorch的内置模型 #2 卷积模型前置卷积基类类定义初始化函数实现继承判断输入参数合法性是否转置是否有偏置参数初始化reset_parameters方法extra_repr方法卷积实现类三个卷积实现类以Conv1d为例分析 Pytorch的内置模型 #2 卷积模型 前置 Module类分析 一个更简单的实例 线性模型 卷积基类 class _ConvNd(Module): 类定义 class _ConvNd(Module): __constants__ = ['stride', 'p
PyTorch常用参数初始化方法详解
xuhss_com的博客
03-09 7281
Python微信订餐小程序课程视频 https://edu.youkuaiyun.com/course/detail/36074 Python实战量化交易理财系统 https://edu.youkuaiyun.com/course/detail/35475 1、均匀分布初始化 torch.nn.init.uniform_(tensor, a=0, b=1) 从均匀分布U(a, b)中采样，初始化张量。　　参数： tensor - 需要填充的张量 a - 均匀分布的下界 b - 均匀分布的上界 例子： w = to
pytorch:常见的pytorch参数初始化方法总结
tony365的博客
10-21 5139
使输入的张量服从（a,b）的均匀分布并返回。 从给定的均值和标准差的正态分布N(mean,std)中生成值，初始化张量。 以一确定数值初始化张量。 从均匀分布U(−a, a)中采样，初始化输入张量，其中a的值由如下公式确定,公式中的gain值根据不同的激活函数确定 [1]https://www.cxyzjd.com/article/CQUSongYuxin/110928126 9）正交初始化 10) 自定义初始化 在搭建模型的时候 会 遇到需要自己自定义初始化数据的时候 总之，参数初始化就是 给 参
conv2d参数_pytorch初始化模型参数的两种方法
weixin_39627405的博客
11-27 3838
pytorch在定义模型时有默认的参数初始化，有时候我们需要自定义参数的初始化，就需要用到torch.nn.init。具体的不同初始化，可以查看pytorch官方文档torch.nn.init - PyTorch 1.6.0 documentation​pytorch.org方法一：1，先定义初始化模型方法;2，运用apply().class Net(nn.Module): ...
PyTorch模型参数初始化
qq_27390023的博客
10-25 1197
初始化方法适用场景uniform_一般场景，常用于偏置初始化。normal_通用的权重初始化，适合全连接层或卷积层。constant_常用于偏置初始化为零，或某些固定初始化。对称激活函数（如tanh）的全连接层和卷积层。同上，但使用正态分布初始化。ReLU 或其变体激活函数的深层网络，尤其是卷积神经网络。同上，但使用正态分布初始化。循环神经网络（RNN、LSTM 等），防止梯度消失或梯度爆炸。sparse_稀疏表示的场景，如自编码器或嵌入层。eye_需要初始化为单位矩阵的线性层或特定矩阵。dirac_
Pytorch网络参数初始化方法总结torch.nn.init
神仙院B栋4楼保安的博客
12-09 2989
Pytorch网络参数初始化方法总结均匀分布初始化torch.nn.init.uniform_()正态分布初始化torch.nn.init.normal_()常量初始化torch.nn.init.constant_()Xavier初始化Xavier均匀分布初始化torch.nn.init.xavier_uniform_()Xavier正态分布初始化torch.nn.init.xavier_normal_()kaiming初始化kaiming均匀分布初始化torch.nn.init.kaiming_unifo
【pytorch（09）】参数初始化：固定值初始化、随机初始化、Xavier初始化、He初始化
最新发布
2302_76685892的博客
08-11 1064
在使用Torch构建网络模型时，每个网络层的参数都有默认的初始化方法，同时还可以通过以上方法来对网络参数进行初始化。
PyTorch模型权重初始化全攻略
xziyuan的博客
07-08 756
Pytroch常见的模型参数初始化方法有apply和model.modules()。Pytroch会自动给模型进行初始化，当需要自己定义模型初始化时才需要这两个方法。
pytorch实现模型参数初始化的方法总结
PanYHHH的博客
07-15 5598
本文主要介绍pytorch中CNN模型有哪些常用参数初始化方法，以及如何实现网络层的初始化。 一、常用的初始化方法 import torch.nn as nn import torch weights = torch.empty(2, 2) # 1.用均匀分布的值填充输入张量, 参数a：均匀分布的下界, 默认为0.; 参数b：均匀分布的上界, 默认为1. uniform_weights = nn.init.uniform_(weights, a=0., b=1.) print(uniform_we
torch-linearo:具有正交权重初始化的割炬线性单元
05-18
具有正交权重初始化的割炬线性单元 该存储库包含以下代码中描述的线性单位的代码： “深度线性神经网络中学习的非线性动力学的精确解”（ ） 执照 版权所有（C）2015 John-Alexander M.Assael（ ） MIT许可证（MIT） 特此免费授予获得此软件和相关文档文件（“软件”）副本的任何人无限制地处理软件的权利，包括但不限于使用，复制，修改，合并的权利，发布，分发，再许可和/或出售本软件的副本，并允许具备软件的人员这样做，但须满足以下条件： 以上版权声明和此许可声明应包含在本软件的所有副本或大部分内容中。 本软件按“原样”提供，不提供任何形式的明示或暗示担保，包括但不限于对适销性，特定目的的适用性和非侵权性的担保。 无论是由于软件，使用或其他方式产生的，与之有关或与之有关的合同，侵权或其他形式的任何索赔，损害或其他责任，作者或版权所有者概不负责。软件。
float初始化_PyTorch的初始化
weixin_39946798的博客
11-20 589
背景在使用PyTorch深度学习框架的时候，不管是训练还是测试，代码中引入PyTorch的第一句总是：import 在Gemfield前述专栏文章里，我们已经得知，torch/csrc/stub.cpp链接libshm.so、libtorch_python.so、libcaffe2_gpu.so生成了_C.cpython-37m-x86_64-linux-gnu.so库，而像前述方式import ...
Pytorch 默认参数初始化
qq_42256930的博客
04-10 300
Pytorch 默认参数初始化。
pytorch参数默认初始化方式
longshaonihaoa的博客
05-08 1820
结论： 因版本而定。 早期的版本用Xavier， 后期的版本用kaiming_normal 目前我所知1.1版本之后是用 kaiming_normal 自己版本对应可以去torch库中查看。 过程： 从博客https://blog.youkuaiyun.com/qq_36338754/article/details/97756378...
pychram+python 看源码： 按住crtl，点击函数
SKY_yiyi_9的博客
08-09 607
pychram+python 看源码 打开pychram , 按住crtl ,用鼠标点击你想要的函数，pycharm会自动打开所选的函数的源码。 结合crtl+F快捷键，键入搜索目标关键字，能帮助你更快找到目标。 这里，看到了Pytorch 的Module都只带默认的初始化方法，而且初始化会调用此函数，因此我们定义好后，不用手动初始化。 在__init__中最后一行调用函数reset_parameters进行参数初始化，卷积函数都继承了_ConvNd，因此所有卷积module都自动初始化。 nn.conv
pytorch默认初始化_Pytorch的默认初始化分布 nn.Embedding.weight初始化分布
weixin_39846186的博客
12-22 1124
一、nn.Embedding.weight初始化分布nn.Embedding.weight随机初始化方式是标准正态分布，即均值$\mu=0$，方差$\sigma=1$的正态分布。论据1——查看源代码## class Embedding具体实现(在此只展示部分代码)import torchfrom torch.nn.parameter import Parameterfrom .module im...
什么时候会发生类初始化
weixin_49578980的博客
10-10 327
什么时候会发生类初始化 类的主动引用(一定会发生类的初始化) 当虚拟机启动,先初始化main方法所在的类 new一个类的对象 调用类的静态成员(除了final常量)和静态方法 使用java.lang.reflect包的方法对类进行反射调用 当初始化一个类,如果其父类没有被初始化,则会先初始化它的父类 类的被动引用(不会发生类的初始化) 当访问一个静态域时,只有真正声明这个域的类才会被初始化.如:当通过子类调用父类的静态变量,不会导致子类初始化 通过数组定义类引用,不会触发此类的初始化 引用常量不会
初始化、正则化调试（基于简单Linear，pytorch）
lryjy的博客
11-21 1150
一.权重初始化（正态分布可以加速学习）： 初始化权重，使其数据保持标准差在1左右以防止梯度消失或者爆炸，在卷积神经网络中常用，pytorch直接默认了 自定义初始化权重 import torch.nn as nn import torch class Network(nn.Module): def __init__(self): super().__init__() self.Conv2d = nn.Conv2d(3, 10) self.bn = n
pytorch 默认参数初始化是1吗
07-16
<think>我们被问到：PyTorch中默认参数初始化值是否为1？ 根据提供的引用内容，我们可以总结如下： 1. 引用[1]提到：PyTorch中nn.Module的模块参数都采取了较为合理的初始化策略。 2. 引用[2]和[3]展示了如何自定义初始化，并提到PyTorch提供了多种初始化函数（如constant、normal、xavier_uniform等），但并没有明确说默认初始化是什么。 3. 引用[4]提到了一种初始化方法（He初始化），但也没有直接回答默认初始化值。 然而，根据PyTorch官方文档和常见的实践，我们知道不同的层类型有不同的默认初始化策略，并不是简单的初始化为1。 具体来说： - 对于线性层（nn.Linear）和卷积层（nn.Conv2d等），权重（weight）的默认初始化是均匀分布（uniform），具体范围根据层类型和激活函数而不同，但通常不是1。 - 偏置（bias）的默认初始化是0（对于线性层和卷积层）或者0.5（对于LSTM的偏置门控参数）等。 更详细地： 1. 线性层（nn.Linear）： - weight：默认使用均匀初始化，范围是[-1/sqrt(fan_in), 1/sqrt(fan_in)]，其中fan_in是输入单元数。 - bias：初始化为0。 2. 卷积层（nn.Conv2d）： - weight：也是均匀初始化，范围与线性层类似，根据输入通道数和卷积核大小计算。 - bias：初始化为0。 3. 其他层如BatchNorm层： - weight（缩放因子）：初始化为1（但注意，这是指BatchNorm层的scale参数，即gamma，初始化为1） - bias（偏移量）：初始化为0（BatchNorm层的beta初始化为0） 因此，我们不能一概而论说默认初始化是1。实际上，只有BatchNorm层的权重（即缩放因子）默认初始化为1，而其他大多数层的权重并不是1，偏置则通常初始化为0。 结论： PyTorch中参数的默认初始化值不是1（除了BatchNorm层的权重参数）。具体初始化策略取决于层的类型。 我们可以通过一个简单的代码示例来验证：</think>### PyTorch 默认参数初始化详解 PyTorch 中**默认参数初始化值不是1**，具体策略取决于层类型。以下是详细说明： #### 1. **默认初始化策略** | 层类型 | 权重初始化 | 偏置初始化 | 引用来源 | |-----------------|----------------------------------------|---------------|----------| | 线性层 (nn.Linear) | $\mathcal{U}(-\frac{1}{\sqrt{fan\_in}}, \frac{1}{\sqrt{fan\_in}})$ | 全零初始化 | [^1][^2] | | 卷积层 (nn.Conv*) | $\mathcal{U}(-\frac{1}{\sqrt{fan\_in}}, \frac{1}{\sqrt{fan\_in}})$ | 全零初始化 | [^2][^3] | | BatchNorm | $\mathcal{N}(1, 0.02)$ | $\mathcal{N}(0, 0.02)$ | [^4] | | LSTM/GRU 门控参数 | $\mathcal{U}(-\sqrt{\frac{1}{hidden\_size}}, \sqrt{\frac{1}{hidden\_size}})$ | 全零初始化 | [^1] | 其中： - $fan\_in$ = 输入单元数（如线性层输入维度） - $\mathcal{U}$ = 均匀分布 - $\mathcal{N}$ = 正态分布 #### 2. **验证示例代码** ```python import torch.nn as nn # 创建线性层（默认初始化） linear = nn.Linear(10, 5) print("权重均值:", linear.weight.data.mean().item()) # ≈0 print("权重范围:", [linear.weight.data.min().item(), linear.weight.data.max().item()]) # 在±0.316附近 print("偏置值:", linear.bias.data) # 全0 ``` #### 3. **初始化原理** PyTorch 采用自适应初始化策略： 1. **防止梯度爆炸/消失**：通过$\frac{1}{\sqrt{fan\_in}}$缩放方差 $$ \text{Var}(W) = \frac{1}{fan\_in} $$ 2. **保持激活值稳定**：使前向传播输出方差≈1 $$ \text{Var}(y) = \text{Var}(x) \times \text{Var}(W) \times fan\_in $$ 3. **批归一化层特殊处理**：缩放参数γ初始化为1，偏移参数β初始化为0 $$ y = \gamma \cdot \frac{x - \mu}{\sigma} + \beta $$ #### 4. **为什么不是1？** 1. **数值稳定性**：全1初始化会导致梯度爆炸 $$ \frac{\partial \mathcal{L}}{\partial W} \propto X^T \delta $$ 2. **对称性破坏**：全相同值使反向传播失效 3. **优化效率**：自适应分布加速收敛（对比全1初始化慢5-10倍[^4]） #### 5. **自定义初始化方法** 需要修改默认行为时可使用： ```python from torch.nn import init # 方法1：逐层初始化 conv = nn.Conv2d(3, 16, 3) init.xavier_uniform_(conv.weight) # Xavier初始化 init.constant_(conv.bias, 0.1) # 设为0.1 # 方法2：全局初始化 def init_weights(m): if type(m) == nn.Linear: init.normal_(m.weight, mean=0, std=0.01) init.zeros_(m.bias) model = nn.Sequential(nn.Linear(10,5), nn.ReLU()) model.apply(init_weights) # 递归应用 ``` > **关键结论**：PyTorch 默认初始化是**非对称的、零中心化的自适应分布**，而非固定值1。这种设计是深度学习模型能有效训练的基础保障[^1][^4]。
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值