TensorFlow batch_normalization

12 阅读6分钟
  • tf.layers.batch_normalization 是"层",会创建可训练/不可训练变量并管理统计量更新
  • tf.nn.batch_normalization 是"纯计算算子",只做归一化数学运算,不创建任何变量,mean/variance 必须由调用者提供

一、函数签名对比

# 高层封装:层
tf.layers.batch_normalization(
    inputs,
    axis=-1,
    momentum=0.99,
    epsilon=1e-3,
    center=True,
    scale=True,
    beta_initializer=..., gamma_initializer=...,
    moving_mean_initializer=..., moving_variance_initializer=...,
    beta_regularizer=None, gamma_regularizer=None,
    beta_constraint=None, gamma_constraint=None,
    training=False,          # 关键:训练/推理开关
    trainable=True,
    name=None,
    reuse=None,
    renorm=False,            # Batch Renorm
    renorm_clipping=None,
    renorm_momentum=0.99,
    fused=None,              # 是否用 fused BN(cudnn 加速)
    virtual_batch_size=None, # Ghost BatchNorm
    adjustment=None
)

# 底层算子:纯计算
tf.nn.batch_normalization(
    x,
    mean,              # 必须由调用者提供,形状可 broadcast
    variance,          # 必须由调用者提供
    offset,            # beta,可为 None
    scale,             # gamma,可为 None
    variance_epsilon,  # epsilon
    name=None
)

两者的归一化数学公式完全相同:

y = scale * (x - mean) / sqrt(variance + epsilon) + offset

差别全在"mean/variance 从哪来、变量谁来建、统计量谁来更新"。

二、tf.layers.batch_normalization 详解

1. 它创建的变量

默认 center=True, scale=True, trainable=True 时,创建四个变量:

变量属性作用
gammatrainable缩放,初始化为 1
betatrainable偏移,初始化为 0
moving_meannon-trainable滑动均值,初始化为 0
moving_variancenon-trainable滑动方差,初始化为 1

center=False 不建 beta;scale=False 不建 gamma;trainable=False 时 gamma/beta 也不进训练(冻结 BN 层)。

2. training=True 与 training=False 的行为

training=True:

  • 用当前 batch 计算 batch_mean、batch_variance(沿除 axis 外的所有维度,如 NHWC 时对 [N,H,W] 求统计);
  • 用 batch 统计量归一化;
  • 生成 update op 更新滑动统计量:
moving_mean     = momentum * moving_mean     + (1 - momentum) * batch_mean
moving_variance = momentum * moving_variance + (1 - momentum) * batch_variance

training=False:

  • 不计算 batch 统计量;
  • 用 moving_mean / moving_variance 归一化;
  • 不产生 update op。

momentum 语义注意:TF 中 momentum=0.99 表示旧值保留 99%、新值贡献 1%。这与 PyTorch 相反(PyTorch 的 momentum=0.1 表示新值贡献 0.1,对应 TF 的 momentum=0.9)。跨框架迁移时要换算。

3. 必须手动加 UPDATE_OPS 依赖

这是 TF1 用 BN 最经典的坑。滑动统计量的更新是独立的 op,不在 train_op 的依赖链里,必须显式加:

update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
    train_op = optimizer.minimize(loss)

否则推理时 moving_mean 永远是 0、moving_variance 永远是 1,归一化结果完全错误。

4. training 参数的类型

和 dropout 一样:

  • 训练/推理分图构建 → 传 Python True/False,建图期固定,安全;
  • 共用一张图 → 必须传 tf.placeholder(tf.bool),内部用 tf.cond 构建两个分支;
  • tf.estimator 的 model_fn → training = (mode == ModeKeys.TRAIN) 是 Python bool,分图构建,安全。

5. 其他参数

  • axis:归一化沿哪个轴做"逐通道"。NHWC 用 -1(默认),NCHW 用 1。NCHW 格式必须显式设 axis=1,否则统计量算错。
  • fused:True 时用 cudnn fused BN(GPU 上更快);None 时自动判断。用了 renorm 或 virtual_batch_size 时 fused 会被禁用。
  • renorm:Batch Renorm,缓解小 batch 下 BN 不稳的问题,引入 r/d 校正。一般不用,用了要配合 renorm_clipping、renorm_momentum。
  • virtual_batch_size:Ghost BatchNorm,把大 batch 拆成若干小 batch 分别算统计量再合并,小 batch 训练时可用。
  • adjustment:分布式训练里校正统计量的极少用参数。

6. 完整示例

def model(inputs, is_training):
    h = tf.layers.conv2d(inputs, 64, 3, padding='same')
    h = tf.layers.batch_normalization(h, training=is_training, name='bn1')
    h = tf.nn.relu(h)

    h = tf.layers.conv2d(h, 128, 3, padding='same')
    h = tf.layers.batch_normalization(h, training=is_training, name='bn2')
    h = tf.nn.relu(h)
    return h

is_training = tf.placeholder(tf.bool, name='is_training')
feat = model(inputs, is_training)

update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
    train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    sess.run(train_op, feed_dict={inputs: xb, labels: yb, is_training: True})
    pred = sess.run(logits, feed_dict={inputs: xb, is_training: False})

三、tf.nn.batch_normalization 详解

1. 纯计算,不建变量、不碰统计量

它只做一步:

y = scale * (x - mean) / sqrt(variance + epsilon) + offset
  • mean / variance / offset / scale 都必须是已存在的 Tensor(常量、变量、或别的 op 的输出);
  • mean/variance 的形状只需能 broadcast 到 x(如 NHWC 的 x 是 [N,H,W,C],mean 传 [C] 即可);
  • offset/scale 可传 None,等价于 0 / 1;
  • 没有任何 update op,也不区分 training/eval。

2. 典型用法一:手动实现标准 BN

需要自己建变量、算 moments、更新滑动统计量:

def manual_bn(x, is_training, axis=-1, momentum=0.99, epsilon=1e-3, name='bn'):
    channels = x.get_shape().as_list()[axis]
    with tf.variable_scope(name):
        gamma = tf.get_variable('gamma', [channels], initializer=tf.ones_initializer())
        beta  = tf.get_variable('beta',  [channels], initializer=tf.zeros_initializer())
        moving_mean = tf.get_variable('moving_mean', [channels],
                                      initializer=tf.zeros_initializer(), trainable=False)
        moving_var  = tf.get_variable('moving_variance', [channels],
                                      initializer=tf.ones_initializer(), trainable=False)

        # 沿除 axis 外的所有维度求统计
        reduce_axes = [i for i in range(len(x.shape)) if i != (axis % len(x.shape))]
        batch_mean, batch_var = tf.nn.moments(x, axes=reduce_axes, keep_dims=True)

        def train_branch():
            # 更新滑动统计量
            update_mean = tf.assign(moving_mean,
                                    momentum * moving_mean + (1 - momentum) * tf.squeeze(batch_mean))
            update_var  = tf.assign(moving_var,
                                    momentum * moving_var  + (1 - momentum) * tf.squeeze(batch_var))
            with tf.control_dependencies([update_mean, update_var]):
                return tf.nn.batch_normalization(x, batch_mean, batch_var, beta, gamma, epsilon)

        def infer_branch():
            return tf.nn.batch_normalization(x, moving_mean, moving_var, beta, gamma, epsilon)

        return tf.cond(is_training, train_branch, infer_branch)

这正是 tf.layers.batch_normalization 内部做的事——手写一遍就理解它替你省了什么。

注意:tf.nn.moments 在 TF 1.15 用的是 keep_dims(下划线),不是 keepdims。

3. 典型用法二:实现 LayerNorm / GroupNorm / InstanceNorm

这是 tf.nn.batch_normalization 真正不可替代的场景——统计量的计算方式变了,但归一化公式不变。

LayerNorm(沿最后一维归一化,不跨 batch):

def layer_norm(x, epsilon=1e-6, name='ln'):
    channels = x.get_shape().as_list()[-1]
    with tf.variable_scope(name):
        gamma = tf.get_variable('gamma', [channels], initializer=tf.ones_initializer())
        beta  = tf.get_variable('beta',  [channels], initializer=tf.zeros_initializer())
        mean, var = tf.nn.moments(x, axes=[-1], keep_dims=True)  # 只用当前样本
        return tf.nn.batch_normalization(x, mean, var, beta, gamma, epsilon)

LayerNorm 没有滑动统计量、没有 training 分支,所以直接用 tf.nn.batch_normalization 最干净。

GroupNorm:把通道分成 G 组,每组内算 mean/var(沿 [H, W, C/G]),再调用 tf.nn.batch_normalization。

InstanceNorm:沿 [H, W] 算 mean/var。

这些场景 tf.layers.batch_normalization 帮不上忙,因为它固定用"跨 batch + 跨空间"的统计量。

4. 典型用法三:推理时手动传入预先算好的统计量

比如统计量来自外部文件(离线校准、量化前的统计)、或来自 EMA 模型:

y = tf.nn.batch_normalization(x, mean=loaded_mean, variance=loaded_var,
                              offset=beta, scale=gamma, variance_epsilon=1e-5)

四、核心对比表

维度tf.layers.batch_normalizationtf.nn.batch_normalization
抽象层级层(Layer)算子(Op,纯计算)
创建变量✅ gamma/beta/moving_mean/moving_var❌ 一个都不建
计算 batch 统计量✅ 训练时自动❌ 需调用者提供
更新滑动统计量✅ 生成 UPDATE_OPS❌ 无
training 参数✅ 有❌ 无
归一化公式相同相同
需要手动加 control_dependencies✅ 是(UPDATE_OPS)❌ 否(没 update op)
典型用途标准 BN 层LayerNorm/GroupNorm/InstanceNorm、手动 BN、外部统计量
变量复用靠 name + reuse / variable_scope不涉及(变量自己管)

五、常见坑

坑说明
忘记 UPDATE_OPS用 tf.layers.batch_normalization 时最常见错误,推理统计量永远是初始值
training 用 Python bool 于共享图建图期固定,无法切换。共享图必须 placeholder
NCHW 没设 axis=1默认 axis=-1 会沿通道维归一化,统计量算错
momentum 语义与 PyTorch 相反TF momentum=0.99 = 旧值保留 0.99;PyTorch momentum=0.1 ≈ TF momentum=0.9
tf.nn.batch_normalization 的 offset/scale 形状要能 broadcast 到 x,NHWC 传 [C];传错形状可能静默广播出错误结果
fused=True 与 renorm/virtual_batch_size 冲突这两个特性会禁用 fused,不必强设
推理时 BN 用了 batch 统计量如果误把 training=True 用于推理,结果依赖 batch,不稳定

六、选择建议

  • 标准 CNN/MLP 的 BN 层 → 用 tf.layers.batch_normalization,省去建变量、算 moments、更新统计量、tf.cond 分支。
  • LayerNorm / GroupNorm / InstanceNorm → 用 tf.nn.batch_normalization + 自己算 moments,因为它不假设统计量怎么来。
  • 需要从外部加载 mean/var(量化、离线统计、迁移) → 用 tf.nn.batch_normalization。
  • 想彻底控制 BN 行为、做特殊变体 → 用 tf.nn.batch_normalization 手动搭,参考上面的 manual_bn。
  • TF2 迁移:tf.layers.batch_normalization → tf.keras.layers.BatchNormalization(training 由 model.fit / model(x, training=...) 管理,UPDATE_OPS 由 Keras 自动处理);tf.nn.batch_normalization 在 TF2 里仍有 tf.nn.batch_normalization(但更推荐 tf.nn.batch_normalization 的 Keras 封装或直接用底层数学运算)。

一句话:tf.layers.batch_normalization 是"会自己算统计量、建变量、更新滑动统计量"的完整 BN 层;tf.nn.batch_normalization 是"只做 (x-mean)/sqrt(var+eps)*scale+offset"的纯算子,mean/var 从哪来、变量谁建、统计量谁更新,全由你决定。