Xavier初始化与He初始化

一句话概述

权重初始化是深度学习训练中最容易被忽视却至关重要的环节。错误的初始化会导致梯度消失（Vanishing Gradient）或梯度爆炸（Exploding Gradient），使网络无法训练。Xavier初始化（Glorot Initialization, 2010）针对tanh和sigmoid激活函数，根据输入和输出神经元数量缩放权重方差：WU(-√(6/(n_in+n_out)), √(6/(n_in+n_out)))；He初始化（Kaiming Initialization, 2015）针对ReLU激活函数，考虑到ReLU会让一半神经元输出为0，仅根据输入神经元数量缩放：WN(0, √(2/n_in))。核心目标是保持各层输出的方差一致，确保信号在前向传播时不衰减也不放大。

💡 核心要点：①权重初始化决定了梯度能否有效传播，是深层网络训练的前提 ②Xavier初始化适合sigmoid/tanh，用n_in+n_out平衡前向和反向传播 ③He初始化适合ReLU及其变体，用n_in因为ReLU损失了一半方差 ④正确初始化后各层输出的方差应保持不变（方差守恒）⑤偏置通常初始化为0

教学与演示

一、为什么权重初始化如此关键

是什么（定义）：权重初始化指在训练开始前，为神经网络的所有权重（和偏置）赋予初始值的过程。看似简单的初始值分配，实际上决定了训练能否成功——如果初始权重全为0，所有神经元做相同的计算，无法打破对称性；如果初始权重过大，激活值在经过激活函数后饱和，梯度趋近于0（梯度消失）；如果初始权重过小，信号在多层传播后衰减为0（梯度消失）。

大白话 权重初始化就像"起跑线"。跑100米，起跑线偏了1米可能影响不大——但跑1000层深度网络，每层偏了0.1就可能导致最终偏到天上或地底。好的初始化保证每层的输出"方差"基本一致——就像接力赛每一棒交接时速度稳定，不会越跑越快（爆炸）或越跑越慢（消失）。

为什么（原理）：考虑一个全连接层h_l = W_l · x_l + b_l。如果W_l的元素方差为σ²_w，x_l的元素方差为σ²_x，且两者独立且均值为0，那么h_l每个元素的方差为：Var(h_l) = n_in · σ²_w · σ²_x。要保证Var(h_l) = σ²_x（方差不变），必须令σ²_w = 1/n_in。但反向传播时信号从n_out维度过来，为同时照顾前向和反向，取调和平均：σ²_w = 2/(n_in + n_out)。这就是Xavier初始化的本质。

import numpy as np

# Xavier初始化和He初始化的完整对比
# 展示不同初始化对层输出方差的影响

def xavier_uniform(n_in, n_out):
    """Xavier均匀分布初始化"""
    limit = np.sqrt(6.0 / (n_in + n_out))
    return np.random.uniform(-limit, limit, size=(n_out, n_in))

def xavier_normal(n_in, n_out):
    """Xavier正态分布初始化"""
    std = np.sqrt(2.0 / (n_in + n_out))
    return np.random.normal(0, std, size=(n_out, n_in))

def he_uniform(n_in, n_out):
    """He均匀分布初始化（Kaiming Uniform）"""
    limit = np.sqrt(6.0 / n_in)
    return np.random.uniform(-limit, limit, size=(n_out, n_in))

def he_normal(n_in, n_out):
    """He正态分布初始化（Kaiming Normal）"""
    std = np.sqrt(2.0 / n_in)
    return np.random.normal(0, std, size=(n_out, n_in))

def bad_init_small(n_in, n_out):
    """错误的初始化：权重过小"""
    return np.random.normal(0, 0.01, size=(n_out, n_in))

def bad_init_large(n_in, n_out):
    """错误的初始化：权重过大"""
    return np.random.normal(0, 1.0, size=(n_out, n_in))


# 模拟多层网络的前向传播，观察各层输出的方差变化
def simulate_forward(n_layers, n_in, n_out, init_func, activation, batch_size=512):
    """模拟多层前向传播，返回每层输出的方差"""
    np.random.seed(42)
    x = np.random.randn(batch_size, n_in)  # 标准正态输入
    variances = [np.var(x)]
    
    for i in range(n_layers):
        W = init_func(n_in, n_out) if i == 0 else init_func(n_out, n_out)
        h = x @ W.T  # 线性变换
        
        # 应用激活函数
        if activation == 'relu':
            h = np.maximum(0, h)
        elif activation == 'tanh':
            h = np.tanh(h)
        elif activation == 'sigmoid':
            h = 1 / (1 + np.exp(-h))
        
        variances.append(np.var(h))
        x = h
    
    return variances


print("=== 权重初始化：方差传播分析 ===\n")

n_layers = 10
n_in, n_out = 512, 512

# 对比不同初始化方法在ReLU激活下的方差传播
print("【ReLU激活函数下的方差传播（10层网络）】\n")
print(f"各层输出方差（初始方差≈1.0）：\n")

inits = {
    'He Normal': lambda ni, no: he_normal(ni, no),
    'He Uniform': lambda ni, no: he_uniform(ni, no),
    'Xavier Normal': lambda ni, no: xavier_normal(ni, no),
    'Xavier Uniform': lambda ni, no: xavier_uniform(ni, no),
    'Bad(1.0标准差)': lambda ni, no: bad_init_large(ni, no),
    'Bad(0.01标准差)': lambda ni, no: bad_init_small(ni, no),
}

for name, init_f in inits.items():
    vars_arr = simulate_forward(n_layers, n_in, n_out, init_f, 'relu')
    print(f"  {name:16s}: 第1层={vars_arr[1]:.4f}, 第5层={vars_arr[5]:.4f}, 第10层={vars_arr[10]:.4f}")

print("\n→ He初始化保持了方差稳定（≈1.0）")
print("→ Xavier初始化和错误初始化导致方差衰减（梯度消失）")

二、Xavier初始化（Glorot Initialization）

是什么（定义）：Xavier初始化由Glorot和Bengio于2010年提出，核心思想是"方差守恒"——前向传播时各层输出的方差保持不变，反向传播时各层梯度的方差保持不变。由于这两个目标难以同时完美满足（一个关注n_in，一个关注n_out），Xavier采用折中方案：σ²_w = 2/(n_in + n_out)。这个值在均匀分布下对应[-√(6/(n_in+n_out)), √(6/(n_in+n_out))]，在正态分布下对应N(0, √(2/(n_in+n_out)))。

大白话 Xavier初始化是"和事佬"策略。前向传播希望方差按1/n_in缩放，反向传播希望按1/n_out缩放——Xavier取两者的调和平均2/(n_in+n_out)，两边都照顾，但两边都不完美。对于tanh/sigmoid这种对称激活函数效果很好，但对ReLU效果不佳（因为ReLU会"砍掉"一半信号）。

怎么做（推导）：

import numpy as np

# Xavier初始化的数学推导验证
# 验证前向和反向传播的方差守恒

np.random.seed(42)

def xavier_forward_variance_check(n_in, n_out, n_samples=10000):
    """验证Xavier初始化是否保持前向传播方差"""
    # Xavier初始化
    limit = np.sqrt(6.0 / (n_in + n_out))
    W = np.random.uniform(-limit, limit, size=(n_out, n_in))
    
    # 输入：标准正态分布（均值为0，方差为1）
    x = np.random.randn(n_samples, n_in)
    
    # 线性变换
    h = x @ W.T  # shape: (n_samples, n_out)
    
    # 理论方差：若W和x独立且均值为0
    # Var(h_j) = n_in * Var(W_ji) * Var(x_i)
    var_w = limit**2 / 3  # 均匀分布U(-a,a)的方差 = a²/3
    var_x = 1.0
    expected_var = n_in * var_w * var_x
    
    actual_var = np.var(h)
    
    print(f"  n_in={n_in}, n_out={n_out}")
    print(f"  W方差={var_w:.6f}, 理论h方差={expected_var:.4f}")
    print(f"  实际h方差={actual_var:.4f}, 是否接近1.0: {'是' if abs(actual_var - 1.0) < 0.1 else '否'}")

def he_forward_variance_check(n_in, n_out, n_samples=10000):
    """验证He初始化在ReLU激活下的方差"""
    std = np.sqrt(2.0 / n_in)
    W = np.random.normal(0, std, size=(n_out, n_in))
    
    x = np.random.randn(n_samples, n_in)
    h = x @ W.T
    
    # ReLU激活
    h_relu = np.maximum(0, h)
    
    var_w = 2.0 / n_in  # 正态分布的方差
    var_x = 1.0
    # ReLU后理论方差：(n_in * σ²_w * σ²_x) / 2
    expected_var = n_in * var_w * var_x / 2.0
    
    actual_var = np.var(h_relu)
    
    print(f"  n_in={n_in}, n_out={n_out}")
    print(f"  W方差={var_w:.6f}, 理论ReLU后方差={expected_var:.4f}")
    print(f"  实际ReLU后方差={actual_var:.4f}, 是否接近1.0: {'是' if abs(actual_var - 1.0) < 0.15 else '否'}")


print("=== Xavier/He初始化方差验证 ===\n")

print("【Xavier初始化——不同层宽下的前向方差传播】")
for n_in in [64, 256, 1024]:
    xavier_forward_variance_check(n_in, n_in)
print()

print("【He初始化——ReLU激活后方差验证】")
for n_in in [64, 256, 1024]:
    he_forward_variance_check(n_in, n_in)

三、He初始化（Kaiming Initialization）与各初始化对比

是什么（定义）：He初始化由Kaiming He等人于2015年提出，专门为ReLU激活函数设计。核心洞察：ReLU函数f(x)=max(0,x)将所有负值截断为0，导致输出方差减半。因此初始化需要补偿这"丢失的一半"——将方差设为2/n_in而非1/n_in。这一简单调整使得ResNet等深度ReLU网络可以被成功训练。2016年，He等人又提出了"Delving Deep into Rectifiers"的详细分析。

大白话 He初始化的思路就是"先算清楚ReLU砍掉了多少"。ReLU把一半的输入变成0，相当于信号损失了50%的能量。既然损失了一半，初始化时就把权重"放大"一倍（方差×2），这样ReLU后的输出能量就和输入一样了。简单而优雅——解决了Xavier初始化在ReLU网络上训练不起来的难题。

怎么做（选择指南）：

import numpy as np

# 对比不同初始化方法下ReLU网络的梯度传播
# 这是判断初始化质量的关键指标

def simulate_gradient_flow(n_layers, n_neurons, init_func, batch_size=256):
    """模拟梯度的反向传播，观察各层梯度范数"""
    np.random.seed(42)
    
    # 初始化权重
    weights = []
    for i in range(n_layers):
        if i == 0:
            W = init_func(n_neurons, n_neurons)
        else:
            W = init_func(n_neurons, n_neurons)
        weights.append(W)
    
    # 前向传播（记录ReLU mask用于反向）
    x = np.random.randn(batch_size, n_neurons)
    h_list = [x]
    masks = []
    
    for W in weights:
        h = h_list[-1] @ W.T
        mask = (h > 0).astype(float)  # ReLU的导数指示
        h = h * mask  # ReLU激活
        masks.append(mask)
        h_list.append(h)
    
    # 反向传播梯度（从最后一层开始）
    dL_dh = np.random.randn(batch_size, n_neurons)  # 模拟顶层梯度
    grad_norms = [np.linalg.norm(dL_dh)]
    
    for i in range(n_layers - 1, -1, -1):
        # 通过ReLU梯度
        dL_dh = dL_dh * masks[i]
        # 通过线性层梯度
        dL_dh = dL_dh @ weights[i]  # 反向：乘以W（不是W^T，因为是dL/dx = dL/dh * W）
        grad_norms.append(np.linalg.norm(dL_dh))
    
    return list(reversed(grad_norms))  # 从第0层到第n层


print("=== 梯度反向传播：各层梯度范数 ===\n")

n_layers = 20
n_neurons = 256

inits_comparison = {
    'He Normal': lambda ni, no: np.random.normal(0, np.sqrt(2.0/ni), size=(no, ni)),
    'He Uniform': lambda ni, no: np.random.uniform(-np.sqrt(6.0/ni), np.sqrt(6.0/ni), size=(no, ni)),
    'Xavier Normal': lambda ni, no: np.random.normal(0, np.sqrt(2.0/(ni+no)), size=(no, ni)),
    'Random(0.01)': lambda ni, no: np.random.normal(0, 0.01, size=(no, ni)),
}

for name, init_f in inits_comparison.items():
    grad_norms = simulate_gradient_flow(n_layers, n_neurons, init_f)
    g0, g5, g10, g19 = grad_norms[0], grad_norms[5], grad_norms[10], grad_norms[-1]
    decay_factor = g19 / g0 if g0 > 0 else 0
    print(f"  {name:15s}: 第0层={g0:.2f}, 第5层={g5:.4f}, 第10层={g10:.6f}, 第20层={g19:.8f}")
    print(f"             衰减倍数={decay_factor:.2e}")

print("\n→ He初始化保持梯度最稳定")
print("→ Xavier初始化在ReLU下梯度衰减严重")
print("→ 0.01标准差初始化导致梯度几乎完全消失")

概念关系图谱

重点答疑

Q1: 为什么权重不能全部初始化为0？

全0初始化导致所有神经元计算完全相同的输出，反向传播时所有权重获得完全相同的梯度，所有神经元永远保持相同——这就是"对称性破坏"问题。网络退化为一层只含一个有效神经元。偏置可以初始化为0，因为偏置不破坏对称性——不同输入乘以不同权重后加上相同偏置，输出仍然不同。

Q2: Xavier初始化为什么在ReLU上效果差？

Xavier假设激活函数是线性的（或近似线性的）来推导方差守恒。但ReLU会将所有负值截断为0，实际输出方差只有线性假设下的一半。这个偏差在浅层网络中不明显，但在深层网络（10层以上）中会累积，导致深层输出的方差指数衰减→梯度消失。He初始化通过将方差翻倍（×2）完美补偿了ReLU的半截性。

Q3: 批归一化（Batch Normalization）之后还需要好的初始化吗？

需要，但重要性降低。BN通过标准化每层输出来"修正"不良的初始化——即使初始权重不好，BN也能把输出拉回合理范围。但好的初始化仍然有价值：①减少BN的训练负担，加速收敛；②某些场景不使用BN（如某些GAN、强化学习）；③好的初始化配合BN效果更好；④极端不良的初始化可能导致BN前几步梯度爆炸。

章节单词汇总