LLM：归一化总结

一、Batch Normalization

原理

Batch Normalization 是一种用于加速神经网络训练并提高稳定性的技术。它通过在每一层网络的激活值上进行归一化处理，使得每一层的输入分布更加稳定，从而加速训练过程，并且减轻了对参数初始化的依赖。

公式

在这里插入图片描述

例子

下面是一个使用 Python 和 NumPy 实现的 Batch Normalization 例子：

import numpy as np

class BatchNormalization:
    def __init__(self, epsilon=1e-5, momentum=0.9):
        # 初始化BatchNormalization类，设定epsilon和momentum的默认值
        self.epsilon = epsilon  # 防止分母为零的小常数
        self.momentum = momentum  # 用于更新运行中均值和方差的动量
        self.running_mean = None  # 运行中的均值
        self.running_var = None  # 运行中的方差
        self.gamma = None  # 缩放参数
        self.beta = None  # 平移参数

    def initialize_params(self, D):
        # 初始化gamma, beta, running_mean和running_var的参数
        self.gamma = np.ones(D)  # 初始化缩放参数为1
        self.beta = np.zeros(D)  # 初始化平移参数为0
        self.running_mean = np.zeros(D)  # 初始化运行中的均值为0
        self.running_var = np.ones(D)  # 初始化运行中的方差为1

    def forward(self, X, training=True):
        # 前向传播，X是输入数据，training表示是否为训练模式
        if self.running_mean is None:
            # 如果是第一次运行，初始化参数
            self.initialize_params(X.shape[1])  # X.shape[1]是特征的维度
        
        if training:
            # 训练模式下
            batch_mean = np.mean(X, axis=0)  # 计算mini-batch的均值
            batch_var = np.var(X, axis=0)  # 计算mini-batch的方差
            # axis=0 代表沿着第一维，也就是行，可以想象成一个尺子，和每行对齐，依次往下移动，得到所有行在这些列上的均值，因此维度是【5】
            # axis=1 代表沿着第二维，也就是列。同理，最后维度是行的维度。
            # 更新运行中的均值
            self.running_mean = self.momentum * self.running_mean + (1 - self.momentum) * batch_mean
            # 更新运行中的方差
            self.running_var = self.momentum * self.running_var + (1 - self.momentum) * batch_var

            # 标准化输入数据
            X_normalized = (X - batch_mean) / np.sqrt(batch_var + self.epsilon)
        else:
            # 测试模式下，使用运行中的均值和方差进行标准化
            X_normalized = (X - self.running_mean) / np.sqrt(self.running_var + self.epsilon)

        # 应用可学习的缩放和平移参数
        out = self.gamma * X_normalized + self.beta
        return out

    def __call__(self, X, training=True):
        # 使类实例可以像函数一样被调用
        return self.forward(X, training)

# 示例数据
np.random.seed(0)  # 设置随机种子以确保结果可重复
X = np.random.randn(10, 5)  # 生成一个随机的10x5的矩阵

# 创建BatchNormalization实例
bn = BatchNormalization()

# 在训练模式下进行前向传播
output_train = bn(X, training=True)
print("Training Mode Output:\n", output_train)  # 打印训练模式下的输出

# 在测试模式下进行前向传播
output_test = bn(X, training=False)
print("Testing Mode Output:\n", output_test)  # 打印测试模式下的输出

维度变化

假设输入数据 X 的形状是 (batch_size, D)，其中 D 是特征的维度，batch_size 是 mini-batch 的大小。Batch Normalization 处理后的输出数据形状保持不变，仍然是 (batch_size, D)。

应用场景

Batch Normalization 可以应用于网络的任意层，常见的应用包括：

全连接层后的激活值
卷积层后的激活值（在这种情况下，均值和方差是沿着通道维度计算的）

结论

Batch Normalization 是一种强大的正则化和加速训练的方法，通过对 mini-batch 内的数据进行归一化处理，减少了内部协变量偏移，提高了网络的训练效率和稳定性。
BN的基本思想就是：把网络的每个隐含层的分布都归一化到标准正态。其实就是把越来越偏的分布强制拉回到比较标准的分布，这样使得激活函数的输入值落在该激活函数对输入比较敏感的区域，这样一来输入的微小变化就会导致损失函数较大的变化。通过这样的方式可以使梯度变大，就避免了梯度消失的问题，而且梯度变大意味着收敛速度快，能大大加快训练速度。

参考：https://blog.csdn.net/BXD1314/article/details/120148013
https://zhuanlan.zhihu.com/p/244983042

二、Layer Normalization

原理

Layer Normalization 是一种用于标准化神经网络层输出的技术，它与 Batch Normalization 类似，但不同的是它是沿着每个样本的特征维度进行标准化。Layer Normalization 不依赖于 mini-batch 的统计数据，因此在处理 RNN 等时间序列数据时表现更好。

公式

在这里插入图片描述

例子

下面是一个使用 Python 和 NumPy 实现的 Layer Normalization 例子：

import numpy as np

class LayerNormalization:
    def __init__(self, epsilon=1e-5):
        # 初始化LayerNormalization类，设定epsilon的默认值
        self.epsilon = epsilon  # 防止分母为零的小常数
        self.gamma = None  # 缩放参数
        self.beta = None  # 平移参数

    def initialize_params(self, D):
        # 初始化gamma和beta的参数
        self.gamma = np.ones(D)  # 初始化缩放参数为1
        self.beta = np.zeros(D)  # 初始化平移参数为0

    def forward(self, X):
        # 前向传播，X是输入数据
        if self.gamma is None or self.beta is None:
            # 如果是第一次运行，初始化参数
            self.initialize_params(X.shape[1])  # X.shape[1]是特征的维度

        # 计算每个样本的均值和方差
        mean = np.mean(X, axis=1, keepdims=True)  # keepdims=True保持结果的维度一致
        var = np.var(X, axis=1, keepdims=True)  # keepdims=True保持结果的维度一致

        # 标准化输入数据
        X_normalized = (X - mean) / np.sqrt(var + self.epsilon)

        # 应用可学习的缩放和平移参数
        out = self.gamma * X_normalized + self.beta
        return out

    def __call__(self, X):
        # 使类实例可以像函数一样被调用
        return self.forward(X)

# 示例数据
np.random.seed(0)  # 设置随机种子以确保结果可重复
X = np.random.randn(10, 5)  # 生成一个随机的10x5的矩阵

# 创建LayerNormalization实例
ln = LayerNormalization()

# 进行前向传播
output = ln(X)
print("Layer Normalization Output:\n", output)  # 打印输出

关键点解释

计算每个样本的均值和方差：
- 使用 np.mean(X, axis=1, keepdims=True) 计算每个样本的均值，axis=1 表示沿着特征维度计算，keepdims=True 确保输出的形状与输入一致。
- 使用 np.var(X, axis=1, keepdims=True) 计算每个样本的方差，axis=1 表示沿着特征维度计算，keepdims=True 确保输出的形状与输入一致。
标准化和应用缩放和平移参数：
- 对输入数据进行标准化，得到 X_normalized。
- 使用可学习的参数 gamma 和 beta 对标准化后的数据进行缩放和平移，得到最终输出 out。

总结

Layer Normalization 是一种有效的正则化技术，特别适用于 RNN 和其他不依赖于 mini-batch 统计的模型。它通过对每个样本的特征维度进行标准化，提供了更稳定的训练过程。

参考：https://pytorch.org/docs/stable/generated/torch.nn.LayerNorm.html
https://zhuanlan.zhihu.com/p/54530247

三、RMSNorm

公式

在这里插入图片描述

RMSNorm的思想就是移除层归一化中的均值的计算部分。

代码

import torch
import torch.nn as nn

# 假设有一个批次(batch)的嵌入向量
batch, sentence_length, embedding_dim = 20, 5, 10

# 生成随机的嵌入向量，形状为 [20, 5, 10]
embedding = torch.randn(batch, sentence_length, embedding_dim)

# 创建RMSNorm实例，传入的特征维度是 embedding_dim
rms_norm = nn.RMSNorm(embedding_dim)

# 对嵌入向量进行归一化
normalized_embedding = rms_norm(embedding)

print("Original Embedding:\n", embedding.shape)
print("Normalized Embedding:\n", normalized_embedding.shape)

参考：
https://mltalks.medium.com/rmsnorm%E8%AE%BA%E6%96%87%E9%98%85%E8%AF%BB-bfae83f6d464
https://blog.csdn.net/yjw123456/article/details/138139970
https://blog.csdn.net/qq_43814415/article/details/136985115
https://pytorch.org/docs/stable/generated/torch.nn.RMSNorm.html#torch.nn.RMSNorm