Lesson 13.5 Xavier方法與kaiming方法（HE初始化）

??在進行了一系列的理論推導和代碼準備工作之后，接下來，我們介紹參數初始化優化方法，也就是針對tanh和Sigmoid激活函數的Xavier方法，以及針對ReLU激活函數的Kaiming方法（HE初始化）。當然，在經過漫長的準備工作之后，實際落地應用過程并不會太過于復雜。

一、Xavier方法

1.Xavier初始化參數方法基礎理論

??回顧Glorot條件，我們要求正向傳播時候數據流經每一層前后的方差一致，并且反向傳播時候數據流經每一層，該層梯度前后方差一致。我們將前者稱為向前傳播條件，后者稱為反向傳播條件。我們先看當向前傳播條件成立時候，有如下計算過程。

首先，數據流至某一層時，該層神經元接收到的數據可以通過如下方法算得：
$$z_j=\sum _{i=1}^n{w}_i{x}_i$$
其中$z_j$表示當前某層神經元接收到的數據，$x_i$表示上一層某神經元傳出的數據，$w_i$代表連接對應兩個神經元之間的權重，當然，如果我們將$z_j$、$x_i$、$w_i$看成是隨機變量，則上式就能夠表示計算過程的一般情況。并且$w_i$和$x_i$的方差計算過程如下：
$$Var(w_i{x}_i)=E[w_i{]}^{2}Var(x_i)+E[x_i{]}^{2}Var(w_i)+Var(w_i)Var(x_i)$$

上述過程涉及基礎數學知識，設X為隨機變量，$D(X)$表示X方差，$E(X)$表示其期望，則有：$$D(X)=E(X^2)?E(X{)}^2$$
進一步，如果X、Y表示隨機變量并且相互獨立，則有：$$D(XY)=E((XY{)}^2)?(E(XY){)}^2=E(X^2)E(Y^2)?(E(X)E(Y){)}^2$$
并且對其進行簡單變形，可以得出：$$\begin{array}{rl}D(XY)& =E(X{)}^{2}D(Y)+E(Y{)}^{2}D(X)+D(X)D(Y)\\ & =E(X{)}^2[E(Y^2)?E(Y{)}^2]+E(Y{)}^2[E(X^2)?E(X{)}^2]+[E(X^2)?E(X{)}^2][E(Y^2)?E(Y{)}^2]\\ & =E(X{)}^{2}E(Y^2)?E(X{)}^{2}E(Y{)}^2+E(Y{)}^{2}E(X^2)?E(Y{)}^{2}E(X{)}^2+E(X^2)E(Y^2)?E(X{)}^{2}E(Y^2)?E(X^2)E(Y{)}^2+E(X{)}^{2}E(Y{)}^2\\ & =E(X^2)E(Y^2)?E(X{)}^{2}E(Y{)}^2\end{array}$$

其中Var()表示方差計算，E()表示均值計算。由于我們假設參數是以0為均值的均勻分布或者0為均值的正態分布，因此$E(w_i)=0$，而此前我們介紹，假設輸入數據是Zero-Centered的，因此$E(x_i)=0$，所以上式可進一步簡化為：
$$Var(w_i{x}_i)=Var(w_i)Var(x_i)$$
而對于z來說，$z={\sum }_{i=1}^n{w}_i{x}_i$，其方差計算過程如下：
$$Var(z)=\sum _{i=1}^{n}Var(w_i{x}_i)=\sum _{i=1}^{n}Var(w_i)Var(x_i)$$

此處補充數學過程，$$D(X+Y)=D(X)+D(Y)+COV(X,Y)$$
其中$COV(X,Y)$是二者的協方差，當相互獨立時，$COV(X,Y)=0$。

此時，我們可以認為x和w是獨立同分布的（一個是采集處理后的數據，一個是隨機生成的參數），因此每個$Var(w_i)Var(x_i)$也是獨立同分布的，因此所有的$w_i$都可以用一個隨機變量$w$表示，所有的$x_i$也可以用一個隨機變量$x$表示，上式可進一步簡寫為：
$$Var(z)=\sum _{i=1}^{n}Var(w_i)Var(x_i)=nVar(w)Var(x)$$
而我們希望線性變換不影響數據方差，因此有：
$$Var(z)=Var(x)$$
進一步可以算得：
$$Var(w)=\frac{1}{n}$$
其中，n是上一層神經元的個數。需要注意的是，上式只考慮了正向傳播的情況，而實際在進行反向傳播時候，上述過程正好相反。反向傳播時z代表上一層神經元接收到的數據，而x則代表當前層傳出的數據，雖然計算公式不變，但n的含義卻發生了變化。為了進行區分，我們將正向傳播時的n、也就是代表上一層神經元個數的變量，命名為$n_{in}$，而在進行反向傳播時的n、也就是代表當前層神經元個數的變量，命名為$n_{out}$。為了同時兼顧向前傳播和反向傳播這兩種情況，我們將w的最終方差取值為:
$$Var(w)=\frac{1}{\frac{n_{in}+n_{out}}{2}}=\frac{2}{n_{in}+n_{out}}$$

取為均值，也就是折中的方案

而此時，如果我們設置w服從均勻在[-a, a]區間內均勻分布，則w的方差為：
$$Var(w)=\frac{(a+a{)}^2}{12}=\frac{4a^2}{12}=\frac{a^2}{3}=\frac{2}{n_{in}+n_{out}}$$

注：服從在[a, b]區間上均勻分布的隨機變量方差為$\frac{(b?a{)}^2}{12}$

進而計算可得
$$a=\sqrt{\frac{6}{n_{in}+n_{out}}}$$

即w的是均勻分布在$(?\sqrt{\frac{6}{n_{in}+n_{out}}},\sqrt{\frac{6}{n_{in}+n_{out}}})$上的隨機變量。

當然，如果我們假設w是服從正態分布的，則w服從$(0,\sqrt{\frac{2}{n_{in}+n_{out}}})$的隨機變量。據此，我們就能設置每一層的初始參數了。當然，在PyTorch中，可以使用init方法進行初始化。

另外，一種更加嚴謹的、指代某一次傳播過程上一層神經元數量和下一層神經元數量的叫法是扇入(fan in)和扇出(fan out)，由此Xavier方法中初始參數的方差也可寫為$Var(w)=\frac{2}{fa{n}_{in}+fa{n}_{out}}$。另外，Xavier在論文中所指出的，應該保持各層的激活值和梯度的方差在傳播過程中保持一致，也被稱為Glorot條件。

對于參數初始化計算過程，最重要的是確定參數的方差，如果是正態分布，由于均值是0，因此可以快速確定其分布，而如果是均勻分布，則可通過$bound=\sqrt{3var}$來確定分布區間$[?bound,bound]$。而在Xavier初始化方法中，$var=\frac{1}{fa{n}_{avg}}$ ，其中$fa{n}_{avg}=\frac{fa{n}_{in}+fa{n}_{out}}{2}$。

最關鍵的，我們需要知道，對于創建隨機分布的初始參數來說，只要確定其方差，就能確定其均勻分布或者正態分布的分布形式。

2.Xavier初始化參數執行方法

2.1 PyTorch實現Xavier均勻分布的參數創建

我們可以使用torch.nn.init.xavier_uniform_進行初始化參數設置。

nn.init.xavier_uniform_? # Signature: nn.init.xavier_uniform_(tensor, gain=1.0) # Docstring: # Fills the input `Tensor` with values according to the method # described in `Understanding the difficulty of training deep feedforward # neural networks` - Glorot, X. & Bengio, Y. (2010), using a uniform # distribution. The resulting tensor will have values sampled from # :math:`\mathcal{U}(-a, a)` where# .. math:: # a = \text{gain} \times \sqrt{\frac{6}{\text{fan\_in} + \text{fan\_out}}}# Also known as Glorot initialization.# Args: # tensor: an n-dimensional `torch.Tensor` # gain: an optional scaling factor# Examples: # >>> w = torch.empty(3, 5) # >>> nn.init.xavier_uniform_(w, gain=nn.init.calculate_gain('relu')) # File: d:\users\asus\anaconda3\lib\site-packages\torch\nn\init.py # Type: function

當然，這里需要注意的是，函數處理的對象是張量，也就是說只要輸入張量，就可以自動進行處理。其中$fa{n}_{in}$由張量的列決定，$fa{n}_{out}$由張量的行數決定。（想想是為什么？）

從說明中我們能看到，此時均勻分布的邊界為$$a=\text{gain}\times \sqrt{\frac{6}{\text{fan\_in}+\text{fan\_out}}}$$其中gain為增益系數，用于手動調整均勻分布的邊界，暫時不建議調整。

t = torch.arange(8).reshape(2, 4).float() t #tensor([[0., 1., 2., 3.], # [4., 5., 6., 7.]]) nn.init.xavier_uniform_(t) #tensor([[-0.2483, -0.8510, 0.0233, -0.9001], # [ 0.7834, -0.9809, 0.3314, 0.7942]]) t # 該函數會在原對象基礎上直接進行修改 #tensor([[-0.2483, -0.8510, 0.0233, -0.9001], # [ 0.7834, -0.9809, 0.3314, 0.7942]])

• Sigmoid激活函數

??接下來，在建模過程中使用Xavier初始化方法測試效果。首先是數據準備與核心參數定義。

# 設置隨機數種子 torch.manual_seed(420) # 創建最高項為2的多項式回歸數據集 features, labels = tensorGenReg(w=[2, -1], bias=False, deg=2)# 進行數據集切分與加載 train_loader, test_loader = split_loader(features, labels)# 初始核心參數 lr = 0.03 num_epochs = 20

然后實例化模型、調整模型初始參數，以及創建用于對比模型效果的模型容器，首先我們先創建一組相對簡單的模型，也就是包含兩個sigmoid隱藏層的神經網絡模型，對比初始化效果

# 設置隨機數種子 torch.manual_seed(420) # 實例化模型 sigmoid_model3 = Sigmoid_class3() # 保留原參數 sigmoid_model3_init = Sigmoid_class3() # 使用Xavier初始化參數# 修改init模型初始參數 for m in sigmoid_model3_init.modules():if isinstance(m, nn.Linear):nn.init.xavier_uniform_(m.weight) #不用弄截距 #<torch._C.Generator at 0x284ef4d16b0> #Parameter containing: #tensor([[ 0.7995, -0.2561], # [-0.1097, -0.0529], # [-0.8137, 0.8860], # [-0.0984, 0.9770]], requires_grad=True) #Parameter containing: #tensor([[ 0.7130, 0.3764, -0.0196, -0.0096], # [ 0.0199, -0.8417, -0.2067, -0.4007], # [-0.0515, 0.1059, -0.6787, 0.6582], # [ 0.7072, 0.5386, 0.3889, 0.1370]], requires_grad=True) #Parameter containing: #tensor([[-0.6241, 0.3488, 0.3069, 0.8371], # [-0.8167, 0.7516, 0.6801, 0.1606], # [ 0.2885, 0.1036, -0.0692, 0.1744], # [ 0.5015, 0.0987, -0.0787, -0.0286]], requires_grad=True) #Parameter containing: #tensor([[-0.8437, -0.5244, 0.8917, 0.0646]], requires_grad=True)# 創建模型容器 model_l = [sigmoid_model3, sigmoid_model3_init] name_l = ['sigmoid_model3', 'sigmoid_model3_init']train_l, test_l = model_comparison(model_l = model_l, name_l = name_l, train_data = train_loader,test_data = test_loader,num_epochs = 2, criterion = nn.MSELoss(), optimizer = optim.SGD, lr = lr, cla = False, eva = mse_cal) weights_vp(sigmoid_model3, att="grad")

weights_vp(sigmoid_model3_init, att="grad")

我們發現，在num_epochs取值為2的時候（只迭代了一輪），經過Xavier初始化的模型梯度整體更加穩定，并且沒有出現梯度消失的情況，反觀原始模型sigmoid_model2，第一層的梯度已經非常小了，已經出現了梯度消失的傾向。而我們知道，各層梯度的情況就代表著模型學習的狀態，很明顯經過初始化的模型各層都處于平穩學習狀態，此時模型收斂速度較快。我們也可以通過MSE曲線進行驗證。

train_l, test_l = model_comparison(model_l = model_l, name_l = name_l, train_data = train_loader,test_data = test_loader,num_epochs = num_epochs, criterion = nn.MSELoss(), optimizer = optim.SGD, lr = lr, cla = False, eva = mse_cal) # 訓練誤差 for i, name in enumerate(name_l):plt.plot(list(range(num_epochs)), train_l[i], label=name) plt.legend(loc = 1) plt.title('mse_train')

# 測試誤差 for i, name in enumerate(name_l):plt.plot(list(range(num_epochs)), test_l[i], label=name) plt.legend(loc = 1) plt.title('mse_test')

??由此我們可知，Xavier初始化的作用核心在于保證各層梯度取值的平穩分布，從而確保各層模型學習的有效性，最終在模型結果的表現上，經過Xavier初始化參數的模型學習效率更高、收斂速度更快。上述結果也驗證了Xavier初始化有效性。
??當然，在一些極端情況下，Xavier初始化效果會更加明顯。我們以四層sigmoid隱藏層的神經網絡為例，觀察Xavier初始化在規避梯度消失問題時的效果。

# 設置隨機數種子 torch.manual_seed(24) # 實例化模型 sigmoid_model4 = Sigmoid_class4() # 保留原參數 sigmoid_model4_init = Sigmoid_class4() # 使用Xavier初始化參數# 修改init模型初始參數 for m in sigmoid_model4_init.modules():if isinstance(m, nn.Linear):nn.init.xavier_uniform_(m.weight) #<torch._C.Generator at 0x1a0c00f16b0> #Parameter containing: #tensor([[ 0.8858, 0.6076], # [ 0.7526, 0.3184], # [-0.2945, 0.9237], # [ 0.7596, -0.6387]], requires_grad=True) #Parameter containing: #tensor([[-0.0020, -0.2599, -0.8290, 0.0234], # [-0.5126, -0.1948, -0.2230, 0.7317], # [ 0.3355, -0.7767, 0.4933, 0.5650], # [ 0.3391, 0.3513, 0.3385, 0.0232]], requires_grad=True) #Parameter containing: #tensor([[-0.7911, -0.4265, 0.5541, 0.2841], # [ 0.6846, 0.2079, 0.8334, -0.3973], # [-0.4116, 0.3072, -0.4335, 0.3472], # [ 0.0940, -0.3414, 0.2058, 0.8155]], requires_grad=True) #Parameter containing: #tensor([[ 0.4660, -0.8182, 0.3571, 0.5147], # [ 0.6018, -0.2091, 0.7026, 0.6874], # [-0.0111, -0.1543, 0.6806, 0.1008], # [ 0.3697, 0.0858, 0.4200, -0.2422]], requires_grad=True) #Parameter containing: #tensor([[-0.6746, 0.9178, 0.5031, 0.2799]], requires_grad=True)# 訓練誤差# 創建模型容器 model_l = [sigmoid_model4, sigmoid_model4_init] name_l = ['sigmoid_model4', 'sigmoid_model4_init']# 核心參數 lr = 0.03 num_epochs = 40# 模型訓練 train_l, test_l = model_comparison(model_l = model_l, name_l = name_l, train_data = train_loader,test_data = test_loader,num_epochs = num_epochs, criterion = nn.MSELoss(), optimizer = optim.SGD, lr = lr, cla = False, eva = mse_cal) # 訓練誤差 for i, name in enumerate(name_l):plt.plot(list(range(num_epochs)), train_l[i], label=name) plt.legend(loc = 1) plt.title('mse_train')

# 測試誤差 for i, name in enumerate(name_l):plt.plot(list(range(num_epochs)), test_l[i], label=name) plt.legend(loc = 1) plt.title('mse_test')

sigmoid_model4是Lesson 13.2中出現嚴重梯度消失的模型，由于前幾層基本喪失學習能力，sigmoid_model4本身效果并不好。但加入Xavier初始化之后，我們發現，init模型能夠極大程度規避梯度消失問題，從而獲得更好的效果。

不過正如此前所說，相比于sigmoid激活函數，Xavier初始化方法更適用于tanh激活函數，核心原因在于tanh激活函數本身能夠生成Zero-centered Data，配合Xavier初始化生成的參數，能夠更好的確保各層梯度平穩、確保各層平穩學習。

• tanh激活函數

我們以三層tanh激活函數隱藏層的神經網絡為例，測試Xavier初始化效果。

# 設置隨機數種子 torch.manual_seed(420) # 創建最高項為2的多項式回歸數據集 features, labels = tensorGenReg(w=[2, -1], bias=False, deg=2)# 進行數據集切分與加載 train_loader, test_loader = split_loader(features, labels) # 設置隨機數種子 torch.manual_seed(420) # 實例化模型 tanh_model3 = tanh_class3() # 保留原參數 tanh_model3_init = tanh_class3() # 使用Xavier初始化參數 # 設置隨機數種子 torch.manual_seed(420) # 修改init模型初始參數 for m in tanh_model3_init.modules():if isinstance(m, nn.Linear):nn.init.xavier_uniform_(m.weight) #<torch._C.Generator at 0x284ef4d16b0> #Parameter containing: #tensor([[ 0.6107, -0.6019], # [ 0.9517, -0.7944], # [-0.3051, -0.6891], # [ 0.7712, 0.3751]], requires_grad=True) #Parameter containing: #tensor([[-0.4319, -0.6698, -0.5014, -0.1671], # [-0.4420, 0.6311, -0.3644, -0.5666], # [-0.2672, -0.8457, -0.4206, -0.4725], # [ 0.1864, 0.7043, 0.0935, -0.5047]], requires_grad=True) #Parameter containing: #tensor([[ 0.3565, -0.3687, -0.4099, -0.1660], # [-0.4519, 0.0952, 0.7030, 0.1181], # [ 0.5231, -0.7523, -0.6813, -0.1152], # [ 0.0008, 0.5406, -0.7617, 0.3613]], requires_grad=True) #Parameter containing: #tensor([[-0.9402, 0.1767, 0.7240, 0.1511]], requires_grad=True)# 創建模型容器 model_l = [tanh_model3, tanh_model3_init] name_l = ['tanh_model3', 'tanh_model3_init']# 核心參數 lr = 0.03 num_epochs = 20# 模型訓練 train_l, test_l = model_comparison(model_l = model_l, name_l = name_l, train_data = train_loader,test_data = test_loader,num_epochs = 2, criterion = nn.MSELoss(), optimizer = optim.SGD, lr = lr, cla = False, eva = mse_cal) weights_vp(tanh_model3, att="grad")

weights_vp(tanh_model3_init, att="grad")

同樣，能夠看出經過Xavier參數初始化后的模型梯度更加平穩，進而我們判斷，經過初始化之后的模型初始迭代時收斂速度更快

# 設置隨機數種子 torch.manual_seed(420) # 實例化模型 tanh_model3 = tanh_class3() # 保留原參數 tanh_model3_init = tanh_class3() # 使用Xavier初始化參數# 修改init模型初始參數 for m in tanh_model3_init.modules():if isinstance(m, nn.Linear):nn.init.xavier_uniform_(m.weight) #<torch._C.Generator at 0x284ef4d16b0> #Parameter containing: #tensor([[ 0.7995, -0.2561], # [-0.1097, -0.0529], # [-0.8137, 0.8860], # [-0.0984, 0.9770]], requires_grad=True) #Parameter containing: #tensor([[ 0.7130, 0.3764, -0.0196, -0.0096], # [ 0.0199, -0.8417, -0.2067, -0.4007], # [-0.0515, 0.1059, -0.6787, 0.6582], # [ 0.7072, 0.5386, 0.3889, 0.1370]], requires_grad=True) #Parameter containing: #tensor([[-0.6241, 0.3488, 0.3069, 0.8371], # [-0.8167, 0.7516, 0.6801, 0.1606], # [ 0.2885, 0.1036, -0.0692, 0.1744], # [ 0.5015, 0.0987, -0.0787, -0.0286]], requires_grad=True) #Parameter containing: #tensor([[-0.8437, -0.5244, 0.8917, 0.0646]], requires_grad=True)# 創建模型容器 model_l = [tanh_model3, tanh_model3_init] name_l = ['tanh_model3', 'tanh_model3_init']# 核心參數 lr = 0.03 num_epochs = 40# 模型訓練 train_l, test_l = model_comparison(model_l = model_l, name_l = name_l, train_data = train_loader,test_data = test_loader,num_epochs = num_epochs, criterion = nn.MSELoss(), optimizer = optim.SGD, lr = lr, cla = False, eva = mse_cal)# 訓練誤差 for i, name in enumerate(name_l):plt.plot(list(range(num_epochs)), train_l[i], label=name) plt.legend(loc = 1) plt.title('mse_train')

# 測試誤差 for i, name in enumerate(name_l):plt.plot(list(range(num_epochs)), test_l[i], label=name) plt.legend(loc = 1) plt.title('mse_test')

同樣我們能夠發現，模型收斂速度更快，迭代多輪之后也變得更加穩定。

2.2 PyTorch實現Xavier高斯分布的參數創建

類似的，我們可以使用torch.nn.init.xavier_normal_進行初始化參數設置。

torch.nn.init.xavier_normal_? #Signature: torch.nn.init.xavier_normal_(tensor, gain=1.0) #Docstring: #Fills the input `Tensor` with values according to the method #described in `Understanding the difficulty of training deep feedforward #neural networks` - Glorot, X. & Bengio, Y. (2010), using a normal #distribution. The resulting tensor will have values sampled from #:math:`\mathcal{N}(0, \text{std}^2)` where # #.. math:: # \text{std} = \text{gain} \times \sqrt{\frac{2}{\text{fan\_in} + \text{fan\_out}}} # #Also known as Glorot initialization. # #Args: # tensor: an n-dimensional `torch.Tensor` # gain: an optional scaling factor # #Examples: # >>> w = torch.empty(3, 5) # >>> nn.init.xavier_normal_(w) #File: d:\users\asus\anaconda3\lib\site-packages\torch\nn\init.py #Type: function

$$\text{std}=\text{gain}\times \sqrt{\frac{2}{\text{fan\_in}+\text{fan\_out}}}$$
當然，修改參數的方法也是相同的，例如:

# 實例化模型 sigmoid_model2 = Sigmoid_class2() # 修改init模型初始參數 for m in sigmoid_model2.modules():if isinstance(m, nn.Linear):nn.init.xavier_normal_(m.weight) # Parameter containing: # tensor([[-0.3229, -0.5913], # [ 0.2859, -0.0382], # [ 0.7426, -0.0482], # [-0.9737, -0.1796]], requires_grad=True) # Parameter containing: # tensor([[ 0.8277, 0.0731, -0.2164, -0.8359], # [-0.0992, 0.1425, -0.6378, -0.0512], # [-0.1305, 0.4111, 0.4144, 0.5496], # [ 0.8238, -0.3335, -0.4961, 0.5645]], requires_grad=True) # Parameter containing: # tensor([[-0.1274, 0.6312, 0.6152, -0.9861]], requires_grad=True)

其他測試初始化效果的相關實驗和此前操作流程一致，同學們可以自行進行嘗試。從理論上來說，均勻分布和高斯分布并沒有根本性區別，二者任選其一使用即可。不過也有一些不是很嚴謹的實驗證明了均勻分布比高斯分布能夠產生相對較大的梯度，因而模型學習效果會更好。

二、Kaiming方法（HE初始化）

1.HE初始化基礎理論

??盡管Xavier初始化能夠在Sigmoid和tanh激活函數疊加的神經網絡中起到一定的效果，但由于ReLU激活函數屬于非飽和類激活函數，并不會出現類似Sigmoid和tanh激活函數使用過程中可能存在的梯度消失或梯度爆炸問題，反而因為ReLU激活函數的不飽和特性，ReLU激活函數的疊加極有可能出現神經元活性消失的問題，很明顯，該類問題無法通過Xavier初始化解決。
??盡管如此，對參數的初始值進行合理設置，仍然是保證模型有效性的有效方法，同樣也能一定程度上解決ReLU激活函數的神經元活性消失問題。目前通用的針對ReLU激活函數的初始化參數方法，是由何凱明在2015年的《Delving Deep into Rectifiers:
Surpassing Human-Level Performance on ImageNet Classification》一文中所提出的HE初始化方法，也被稱為Kaiming方法。原文地址。

近一輪深度學習的興起也就在十年間，我們接觸到的很多算法和優化方法基本都是發表于10年內。

??當然，He初始化也遵循Glorot條件，即參數初始化結果要求正向傳播時各層接收到的數據方差保持一致、反向傳播時各層參數梯度的方差保持一致，不過由于每一層的激活值（激活函數輸出結果）均值不為0，因此Xavier的數學推導過程不再成立。關于HE初始化的數學推導此處不進行深入講解，感興趣的同學可自行參考論文中給出的推導過程。需要知道的是，經過一系列的推導和論證之后，HE初始化仍然是規定參數是滿足均值為0的隨機變量，并且仍然借助均勻分布和高斯分布進行隨機變量創建，不同的是Xavier中參數方差為：$$Var(w{)}_{Xavier}=\frac{2}{fa{n}_{in}+fa{n}_{out}}$$而HE初始化過程中，參數方差為$$Var(w{)}_{HE}=\frac{2}{fa{n}_{in}}或Var(w{)}_{HE}=\frac{2}{fa{n}_{out}}$$也就是分子不變，分母取某層扇入或扇出的神經元的數量，同時論文中給出論證二者沒有明顯區別，建模過程中任取其一即可。

當然，根據參數方差，我們就能確定參數滿足均勻分布時的邊界，以及滿足高斯分布時的基本形態。均勻分布時$bound=\sqrt{3var}$，因此參數分布區間為:$$(?\sqrt{\frac{6}{fa{n}_{in}}},\sqrt{\frac{6}{fa{n}_{in}}})$$

值得注意的是，HE初始化不僅針對ReLU激活函數，還可以對其變種激活函數使用，相關內容會在后續進行介紹。

后續還將介紹其他初始化方法，我們仍然可以從以下幾個角度進行理解：
(1).為了滿足或者更好的滿足Glorot條件；
(2).數學理論推導出參數方差；
(3).方差由扇入和扇出神經元個數組成。

2.HE初始化在PyTorch中實現

2.1 PyTorch實現HE初始化的均勻分布參數創建

我們可以使用torch.nn.init.kaiming_uniform_進行初始化參數設置。

nn.init.kaiming_uniform_? #Signature: #nn.init.kaiming_uniform_( # tensor, # a=0, # mode='fan_in', # nonlinearity='leaky_relu', #) #Docstring: #Fills the input `Tensor` with values according to the method #described in `Delving deep into rectifiers: Surpassing human-level #performance on ImageNet classification` - He, K. et al. (2015), using a #uniform distribution. The resulting tensor will have values sampled from #:math:`\mathcal{U}(-\text{bound}, \text{bound})` where # #.. math:: # \text{bound} = \text{gain} \times \sqrt{\frac{3}{\text{fan\_mode}}} # #Also known as He initialization. # #Args: # tensor: an n-dimensional `torch.Tensor` # a: the negative slope of the rectifier used after this layer (only # used with ``'leaky_relu'``) # mode: either ``'fan_in'`` (default) or ``'fan_out'``. Choosing ``'fan_in'`` # preserves the magnitude of the variance of the weights in the # forward pass. Choosing ``'fan_out'`` preserves the magnitudes in the # backwards pass. # nonlinearity: the non-linear function (`nn.functional` name), # recommended to use only with ``'relu'`` or ``'leaky_relu'`` (default). # #Examples: # >>> w = torch.empty(3, 5) # >>> nn.init.kaiming_uniform_(w, mode='fan_in', nonlinearity='relu') #File: d:\users\asus\anaconda3\lib\site-packages\torch\nn\init.py #Type: function

相關參數解釋：

• mode：參數表示選擇帶入扇入還是扇出的神經元個數進行計算，正如前文所說，理論上二者對建模沒有明顯影響，可任選其一，但實際由于模型個體差異，在實際使用過程中還是略有差異，我們可以根據實際效果進行選擇；
• a：為使用ReLU變種激活函數時的修正系數；
• nonlinearity：表示所選用的變種ReLU激活函數類型，需要配合a參數使用，相關使用方法我們將在后續介紹ReLU變種激活函數的使用時一并介紹。

另外，值得注意的是，kaiming方法的幫助文檔中的數學公式有誤，切勿參考該公式進行建模。

幫助文檔中公式$$\text{bound}=\text{gain}\times \sqrt{\frac{3}{\text{fan\_mode}}}$$
而實際上kaiming方法并沒有gain增益系數，只有a的一個修正系數，實際公式如下：$$bound=\sqrt{\frac{6}{(1+a^2)fa{n}_{in}}}$$和Xavier方法一樣，kaiming方法直接對張量的值進行修改，并且張量列數表示$fa{n}_{in}$的個數，行數表示$fa{n}_{out}$的個數，據此，我們簡單測試下公式正確性。

t = torch.arange(12).reshape(2, 6).float() t #tensor([[ 0., 1., 2., 3., 4., 5.], # [ 6., 7., 8., 9., 10., 11.]]) # 設置隨機數種子 # torch.manual_seed(420) torch.nn.init.kaiming_uniform_(t) # 此時扇入個數是6 #tensor([[ 0.7759, -0.0605, 0.9326, -0.1187, -0.6536, 0.7461], # [ 0.6820, 0.5430, 0.1063, -0.6791, -0.6492, 0.3862]]) # 設置隨機數種子 # torch.manual_seed(420) torch.nn.init.kaiming_uniform_(t,a=1) # 此時分母是12 #tensor([[ 0.2317, 0.5822, 0.4021, -0.6404, -0.4904, -0.6925], # [ 0.3130, 0.6996, -0.6849, 0.5654, -0.6616, -0.0863]]) math.sqrt(0.5) #0.7071067811865476 t = torch.arange(18).reshape(6, 3).float() t #tensor([[ 0., 1., 2.], # [ 3., 4., 5.], # [ 6., 7., 8.], # [ 9., 10., 11.], # [12., 13., 14.], # [15., 16., 17.]]) # 設置隨機數種子 torch.manual_seed(420) torch.nn.init.kaiming_uniform_(t) # 此時扇入個數是3 #<torch._C.Generator at 0x225457416b0> #tensor([[ 0.8637, -0.8512, 1.3459], # [-1.1234, -0.4314, -0.9746], # [ 1.0907, 0.5305, -0.7054], # [-1.0938, -0.8188, -0.2728], # [-0.7218, 1.0306, -0.5950], # [-0.9252, -0.4363, -1.3810]]) math.sqrt(2) # 應該小于根號2 #1.4142135623730951

據此，驗證了公式的正確性。接下來，嘗試在建模過程中使用kaiming方法，驗證是否能夠加快迭代效率，并且規避神經元活性失效問題。

HE初始化如何幫助模型規避Dead ReLU Problem？核心在于模型初始化時如果參數完全隨機選擇，就有可能出現初始參數全部輸出0的結果，而通過HE初始化的參數不會出現上述情況。

# 設置隨機數種子 torch.manual_seed(420) # 創建最高項為2的多項式回歸數據集 features, labels = tensorGenReg(w=[2, 1], bias=False, deg=2)# 進行數據集切分與加載 train_loader, test_loader = split_loader(features, labels)# 初始核心參數 lr = 0.001 num_epochs = 20# 設置隨機數種子 torch.manual_seed(420) # 實例化模型 relu_model3 = ReLU_class3() # 保留原參數 relu_model3_init = ReLU_class3() # 使用HE初始化參數# 修改init模型初始參數 for m in relu_model3_init.modules():if isinstance(m, nn.Linear):nn.init.kaiming_uniform_(m.weight) #<torch._C.Generator at 0x225457416b0> #Parameter containing: #tensor([[ 1.3847, -0.4435], # [-0.1899, -0.0916], # [-1.4094, 1.5347], # [-0.1705, 1.6922]], requires_grad=True) #Parameter containing: #tensor([[ 1.0084, 0.5323, -0.0277, -0.0135], # [ 0.0282, -1.1904, -0.2923, -0.5667], # [-0.0729, 0.1498, -0.9598, 0.9308], # [ 1.0001, 0.7617, 0.5500, 0.1938]], requires_grad=True) #Parameter containing: #tensor([[-0.8826, 0.4933, 0.4340, 1.1838], # [-1.1550, 1.0630, 0.9618, 0.2271], # [ 0.4080, 0.1464, -0.0979, 0.2467], # [ 0.7092, 0.1396, -0.1113, -0.0405]], requires_grad=True) #Parameter containing: #tensor([[-0.9433, -0.5863, 0.9970, 0.0722]], requires_grad=True)# 創建模型容器 model_l = [relu_model3, relu_model3_init] name_l = ['relu_model3', 'relu_model3_init']train_l, test_l = model_comparison(model_l = model_l, name_l = name_l, train_data = train_loader,test_data = test_loader,num_epochs = num_epochs, criterion = nn.MSELoss(), optimizer = optim.SGD, lr = lr, cla = False, eva = mse_cal)# 訓練誤差 for i, name in enumerate(name_l):plt.plot(list(range(num_epochs)), train_l[i], label=name) plt.legend(loc = 1) plt.title('mse_train')

# 測試誤差 for i, name in enumerate(name_l):plt.plot(list(range(num_epochs)), test_l[i], label=name) plt.legend(loc = 1) plt.title('mse_test')

我們發現，使用HE初始化之后模型收斂速度明顯提升。

2.2 PyTorch實現HE初始化的正態分布參數創建

??類似的，我們可以使用torch.nn.init.kaiming_normal_來進行滿足正態分布的初始化參數設置。

nn.init.kaiming_normal_? #Signature: # nn.init.kaiming_normal_( # tensor, # a=0, # mode='fan_in', # nonlinearity='leaky_relu', # ) # Docstring: # Fills the input `Tensor` with values according to the method # described in `Delving deep into rectifiers: Surpassing human-level # performance on ImageNet classification` - He, K. et al. (2015), using a # normal distribution. The resulting tensor will have values sampled from # :math:`\mathcal{N}(0, \text{std}^2)` where# .. math:: # \text{std} = \frac{\text{gain}}{\sqrt{\text{fan\_mode}}}# Also known as He initialization.# Args: # tensor: an n-dimensional `torch.Tensor` # a: the negative slope of the rectifier used after this layer (only # used with ``'leaky_relu'``) # mode: either ``'fan_in'`` (default) or ``'fan_out'``. Choosing ``'fan_in'`` # preserves the magnitude of the variance of the weights in the # forward pass. Choosing ``'fan_out'`` preserves the magnitudes in the # backwards pass. # nonlinearity: the non-linear function (`nn.functional` name), # recommended to use only with ``'relu'`` or ``'leaky_relu'`` (default).# Examples: # >>> w = torch.empty(3, 5) # >>> nn.init.kaiming_normal_(w, mode='fan_out', nonlinearity='relu') # File: d:\users\asus\anaconda3\lib\site-packages\torch\nn\init.py # Type: function

同樣，說明文檔中的公式存在錯誤。以下是說明文檔中的公式:
$$\text{std}=\frac{\text{gain}}{\sqrt{\text{fan\_mode}}}$$實際上，PyTorch中所使用的HE初始化時，初始參數的方差為：$$Var(w)=\frac{2}{(1+a^2)fa{n}_{in}}$$
其中a為ReLU變種激活函數的修正系數，需要配合ReLU變種激活函數共同使用，扇入神經元個數和扇出神經元個數等效，并且$$std(w)=\sqrt{\frac{2}{(1+a^2)fa{n}_{in}}}$$接下來，簡單實踐測試效果：

# 設置隨機數種子 torch.manual_seed(420) # 實例化模型 relu_model3 = ReLU_class3() # 保留原參數 relu_model3_init = ReLU_class3() # 使用HE初始化參數# 修改init模型初始參數 for m in relu_model3_init.modules():if isinstance(m, nn.Linear):nn.init.kaiming_normal_(m.weight) # <torch._C.Generator at 0x225457416b0> # Parameter containing: # tensor([[ 0.4132, 1.2154], # [-0.0425, -1.3647], # [-0.5896, 2.1108], # [ 0.2548, 0.1661]], requires_grad=True) # Parameter containing: # tensor([[ 0.5093, -0.2730, -0.1495, 1.4481], # [ 1.5209, 1.1812, 0.8868, -0.7768], # [ 0.6132, -0.8655, -0.3035, -0.1526], # [ 0.2752, -0.5203, -0.7091, -0.5119]], requires_grad=True) # Parameter containing: # tensor([[ 0.7865, -0.0605, 0.6548, -0.9418], # [-1.1811, 0.8337, 0.5161, -0.8076], # [ 0.6926, 0.9038, -0.4330, -0.1764], # [-0.4042, 0.3451, -0.5829, -0.0914]], requires_grad=True) # Parameter containing: # tensor([[-0.7091, 0.1566, -0.7193, -0.9234]], requires_grad=True) # 創建模型容器 model_l = [relu_model3, relu_model3_init] name_l = ['relu_model3', 'relu_model3_init']train_l, test_l = model_comparison(model_l = model_l, name_l = name_l, train_data = train_loader,test_data = test_loader,num_epochs = num_epochs, criterion = nn.MSELoss(), optimizer = optim.SGD, lr = lr, cla = False, eva = mse_cal) # 訓練誤差 for i, name in enumerate(name_l):plt.plot(list(range(num_epochs)), train_l[i], label=name) plt.legend(loc = 1) plt.title('mse_train')

# 測試誤差 for i, name in enumerate(name_l):plt.plot(list(range(num_epochs)), test_l[i], label=name) plt.legend(loc = 1) plt.title('mse_test')

同樣，經過HE初始化后的參數，模型收斂速度更快，也證明了HE初始化的有效性。

三、參數初始化的作用局限

??截止目前，我們討論了圍繞Glorot條件進行的參數初始化方法，當然，合理的設置初始參數值能夠一定程度上使得模型各層都得到有效的學習，模型訓練過程更加平穩、收斂速度也更快。但由于我們設置的是初始條件，伴隨著模型不斷訓練，由于受到激活函數導函數本身特性影響，仍然有可能在迭代過程中出現梯度不均衡的現象。
??然而模型一旦開始訓練，我們是不能手動參與修改模型參數的。那此時應該如何處理梯度不均衡的問題呢？我們知道，影響梯度計算的三個核心因素，分別是參數狀態值、激活值和輸入的數據，參數狀態值由模型迭代的數學過程決定，激活值很大程度上由我們所選取的激活函數決定，如果從Glorot條件入手，我們就只剩下一個可以人工修改的選項：每一個線性層接收到的數據。

總結

以上是生活随笔為你收集整理的Lesson 13.5 Xavier方法与kaiming方法（HE初始化）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。