import torch.nn as nn        

# a simple network
rand_net = nn.Sequential(nn.Linear(in_features, h_size),
                         nn.BatchNorm1d(h_size),
                         nn.ReLU(),
                         nn.Linear(h_size, h_size),
                         nn.BatchNorm1d(h_size),
                         nn.ReLU(),
                         nn.Linear(h_size, 1),
                         nn.ReLU())

# initialization function, first checks the module type,
# then applies the desired changes to the weights
def init_normal(m):
    if type(m) == nn.Linear:
        nn.init.uniform_(m.weight)

# use the modules apply function to recursively apply the initialization
rand_net.apply(init_normal)

因为到目前为止我还没有足够的声誉，我不能在下面添加评论

prosti在19年6月26日13:16发布的答案。

    def reset_parameters(self):
        init.kaiming_uniform_(self.weight, a=math.sqrt(3))
        if self.bias is not None:
            fan_in, _ = init._calculate_fan_in_and_fan_out(self.weight)
            bound = 1 / math.sqrt(fan_in)
            init.uniform_(self.bias, -bound, bound)

但我想指出的是，实际上我们知道何开明的论文《深入研究整流器:在ImageNet分类上超越人类的性能》中的一些假设是不合适的，尽管看起来刻意设计的初始化方法在实践中取得了成功。

例如，在反向传播案例的分段中，它们假设$w_l$和$\delta y_l$是相互独立的。但我们都知道，以分数映射$\delta y^L_i$为例，如果我们使用典型的交叉熵损失函数目标，它通常是$y_i-softmax(y^L_i)=y_i-softmax(w^L_ix^L_i)$。

所以我认为，为什么他的初始化工作得很好，真正的潜在原因还有待解开。因为每个人都见证了它在促进深度学习训练方面的力量。

如果您看到deprecation警告(@Fábio Perez)…

def init_weights(m):
    if type(m) == nn.Linear:
        torch.nn.init.xavier_uniform_(m.weight)
        m.bias.data.fill_(0.01)

net = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2))
net.apply(init_weights)

要初始化层，通常不需要做任何事情。

PyTorch会为你做这件事。仔细想想，这就说得通了。为什么我们要初始化层，当PyTorch可以遵循最新的趋势时?

例如，线性层的__init__方法将进行开明河初始化:

init.kaiming_uniform_(self.weight, a=math.sqrt(5))
if self.bias is not None:
    fan_in, _ = init._calculate_fan_in_and_fan_out(self.weight)
    bound = 1 / math.sqrt(fan_in) if fan_in > 0 else 0
    init.uniform_(self.bias, -bound, bound)

类似地，这也适用于其他层类型。例如，Conv2d，检查这里。

注意:适当的初始化的好处是更快的训练速度。如果您的问题需要特殊的初始化，您仍然可以在之后进行初始化。

import torch.nn as nn        

# a simple network
rand_net = nn.Sequential(nn.Linear(in_features, h_size),
                         nn.BatchNorm1d(h_size),
                         nn.ReLU(),
                         nn.Linear(h_size, h_size),
                         nn.BatchNorm1d(h_size),
                         nn.ReLU(),
                         nn.Linear(h_size, 1),
                         nn.ReLU())

# initialization function, first checks the module type,
# then applies the desired changes to the weights
def init_normal(m):
    if type(m) == nn.Linear:
        nn.init.uniform_(m.weight)

# use the modules apply function to recursively apply the initialization
rand_net.apply(init_normal)

我们比较了使用同一神经网络架构的不同权重初始化模式。

都是0或1

如果您遵循奥卡姆剃刀原理，您可能认为将所有权重设置为0或1是最佳解决方案。事实并非如此。

在每个权重相同的情况下，每一层的所有神经元都产生相同的输出。这使得很难决定调整哪个权重。

    # initialize two NN's with 0 and 1 constant weights
    model_0 = Net(constant_weight=0)
    model_1 = Net(constant_weight=1)

2个时代之后:

Validation Accuracy
9.625% -- All Zeros
10.050% -- All Ones
Training Loss
2.304  -- All Zeros
1552.281  -- All Ones

统一的初始化

均匀分布从一组数字中选取任意一个数的概率相等。

让我们看看使用统一权重初始化(其中low=0.0, high=1.0)的神经网络训练效果如何。

下面，我们将看到另一种方法(除了在Net类代码中)来初始化网络的权重。要在模型定义之外定义权重，我们可以:

然后定义一个根据网络层类型分配权重的函数 使用model. Apply (fn)将这些权重应用到初始化的模型，它将一个函数应用到每个模型层。

    # takes in a module and applies the specified weight initialization
    def weights_init_uniform(m):
        classname = m.__class__.__name__
        # for every Linear layer in a model..
        if classname.find('Linear') != -1:
            # apply a uniform distribution to the weights and a bias=0
            m.weight.data.uniform_(0.0, 1.0)
            m.bias.data.fill_(0)

    model_uniform = Net()
    model_uniform.apply(weights_init_uniform)

2个时代之后:

Validation Accuracy
36.667% -- Uniform Weights
Training Loss
3.208  -- Uniform Weights

设置权重的一般规则

在神经网络中设置权重的一般规则是将它们设置为接近零而又不会太小。

好的做法是在[-y, y]范围内开始权重，其中y=1/根号(n) (n为给定神经元的输入数量)。

    # takes in a module and applies the specified weight initialization
    def weights_init_uniform_rule(m):
        classname = m.__class__.__name__
        # for every Linear layer in a model..
        if classname.find('Linear') != -1:
            # get the number of the inputs
            n = m.in_features
            y = 1.0/np.sqrt(n)
            m.weight.data.uniform_(-y, y)
            m.bias.data.fill_(0)

    # create a new model with these weights
    model_rule = Net()
    model_rule.apply(weights_init_uniform_rule)

下面我们比较了NN的性能，权重初始化为均匀分布[-0.5,0.5)与权重初始化为一般规则的NN

2个时代之后:

Validation Accuracy
75.817% -- Centered Weights [-0.5, 0.5)
85.208% -- General Rule [-y, y)
Training Loss
0.705  -- Centered Weights [-0.5, 0.5)
0.469  -- General Rule [-y, y)

正态分布来初始化权重

正态分布的均值应为0，标准差为y=1/√(n)，其中n为NN的输入数

    ## takes in a module and applies the specified weight initialization
    def weights_init_normal(m):
        '''Takes in a module and initializes all linear layers with weight
           values taken from a normal distribution.'''

        classname = m.__class__.__name__
        # for every Linear layer in a model
        if classname.find('Linear') != -1:
            y = m.in_features
        # m.weight.data shoud be taken from a normal distribution
            m.weight.data.normal_(0.0,1/np.sqrt(y))
        # m.bias.data should be 0
            m.bias.data.fill_(0)

下面我们展示了两个神经网络的性能，一个使用均匀分布初始化，另一个使用正态分布初始化

2个时代之后:

Validation Accuracy
85.775% -- Uniform Rule [-y, y)
84.717% -- Normal Distribution
Training Loss
0.329  -- Uniform Rule [-y, y)
0.443  -- Normal Distribution