语言模型

语言模型定义🎓

LM 定义

LM 定义

语言模型LM：一种对Token序列的概率分布。

• LM可以为token序列赋予一个概率：$p(x_1,...,x_k)=?$

• LM具有卓越世界知识，才能通过概率准确评估序列好坏。

  $$p(\text{a kid eat an apple })>p(\text{an apple eat a kid })$$

• LM可以做生成任务，以概率$p(x_{1:k})$进行采样。

  • 但我们通常不直接从LM进行采样，因为：
    • 真实语言模型限制
    • 期望得到最佳序列，而非平均序列

N-gram

N-Gram模型

• 定义：在n-gram模型中，$x_i$只依赖于相邻前n-1个字符，而非整个历史 🔑。

$$p(x_i|x_{1:i-1})=p(x_i|x_{i-(n-1):i-1})$$

• 例如：trigram(n=3)，只依赖于前2个字符

$$p(\text{cheese | the mouse ate the})=p(\text{cheese | ate the})$$

• 概率计算：基于n-gram在文中的出现次数来计算的，并做数据平滑避免0概率。
• n-gram的限制
  • n太小：无法捕获长距离信息
  • n太大：统计上不好得到概率估计，很多都会为0.

神经语言模型🐸

神经语言模型

• 概率由神经网络计算，而非由统计信息得出。
• 😈上下文长度仍然受n的限制

$$\begin{array}{l}p(x_i|x_{i-(n-1):i-1})=neural\mathrm{\_}network(x_{i-(n-1):i})\\ p(\text{cheese | ate the})=neural\mathrm{\_}network(\text{ate the mouth})\end{array}$$

• 关键发展
  • RNN/LSTM：使得$x_i$的条件分布可以依赖整个上下文$x_{1:i-1}$，有效使得$n\sim \mathrm{\infty }$，但难以训练。
  • Transformer：2017年提出的新架构，再次使用上下文长度n，但利用GPU并行更易于训练。GPT-3 n=2048。

自回归 LM (Next-Token Prediction)

自回归语言模型

核心思想

• 自回归生成序列，每次生成1个token： $x_1,\dots ,x_k$，$x_i\sim p(x_i|x_{1:i-1})$

• 可以用前馈神经网络计算每个条件概率：$p(x_i|x_{1:i-1})$

• 链式法则计算条件概率：

$$p(x_{1:k})=p(x_1)p(x_2|x_1)p(x_3|x_1,x_2)\cdots p(x_k|x_{1:k-1})=\prod _{i=1}^{k}p(x_i|x_{1:i-1})$$

缺点

• 必须1个接1个，没法并行
• 容易一步错、步步错。

扩散 LM (Denosing)

扩散LM

核心思想

• 不用从左到右依次解码，而是通过多个去噪步骤逐渐把噪声序列转化成流畅的文本。

• I l.. e A. 逐步变成 I love AI

关键点

• Iterative Denosing
  • 一开始全是噪声，经过几十步迭代，整个句子结构逐渐显现
• Non-Autogressive
  • 可以同时生成句子里的所有词，或者一大块词，速度潜力很大
• Global Control：属性/结构强控制
  • 因为是一次性规划整个句子，更容易控制这句话包含哪个词或是某种句式。

优点

• 可控性更好：更听话，让写诗就写诗、让填空就填空
• 并行度更高：可并行生成，理论上吞吐量更高

缺点

• 迭代多步较慢：像画图一样需要多步，写文本也需要迭代多步
• 现状：生成质量目前不ok，还不足以PK GPT4这种模型。

温度参数T🎇

温度参数T

🔥随机性温度参数T

• 定义：${x_i\sim p(x_i|x_{1:i-1})}^{\frac{1}{T}}$

• $\frac{1}{T}$：⭐意味着压缩或放大原始概率，调整概率分布的陡峭程度，💥控制生成的随机性和多样性。

• 压缩后需要重新进行标准化，即退火调节🔥

3️⃣三种可能性

• T = 1：概率保持不变，从原LM中正常采样
• T > 1 (∞)：大的概率会变小��⬆️，🌟概率会被压平，趋近于均匀分布
• T < 1 (0)：大的概率会变大��⬇️，🌟在每一步都选择最有可能的token

💡举个例子

• T=1：$p(\text{cheese})=0.6,p(\text{mouse})=0.4$
• T=0.5：
  • 计算：$p(\text{cheese})={0.6}^2=0.36,p(\text{mouse})={0.4}^2=0.16$
  • 标准化：$p(\text{cheese})=\frac{0.36}{0.36+0.16}=0.69,p(\text{mouse})=\frac{0.36}{0.36+0.16}=0.31$
• T从$1\to 0.5$的变化：🔑
  • $p(\text{cheese}):0.6\to 0.69$，略微增加 ⬆️
  • $p(\text{mouse}):0.4\to 0.31$，略微下降 ⬇️

常用数学公式

极大似然估计(MLE)✏️

似然函数

概率和似然

概率(probability)

• 参数已知，预测结果。

• 某个事件发生概率：$P(x|\theta )$，$\theta$ 已知。

• 概率是关于结果的函数，概率和为1。

似然(likelihood)：

• 结果已知，反推参数。根据结果估计参数。
• 似然函数：$L(x|\theta )$，$x$已知。给定观察数据/样本集合$X$，参数$\theta$为${\theta }_1,{\theta }_2,..$ 的可能性。
• 似然是关于参数的函数，所有可能参数的似然值不一定唯一。
• 似然不是概率，只是一个衡量像不像的指标。

极大似然估计

极大似然估

• 设$D$为训练集，$D_c$是第$c$类样本集合，样本独立同分布。

• 找到让样本似然/可能性最大的参数，即寻找最大化似然$P(D_c|{\theta }_c)$的参数${\theta }_c$

• 参数${\theta }_c$对$D_c$的似然

$$P(D_c|{\theta }_c)=\prod _{x\in D_c}P(x|{\theta }_c)$$

负对数似然

负对数似然

• 对数似然：乘法不好计算，所以取对数变成加法。求参数使其最大。

$$L(\theta )=\text{log}(P(D_c|{\theta }_c))=\sum _{x\in D_c}\text{log}(P(x|{\theta }_c))$$

• 负对数似然： 概率[0,1] 导致对数似然为负数。所以增加负号，求参数$\theta$，使其最小👍 。

$$L(\theta )=-\sum _{x\in D_c}\text{log}(P(x|{\theta }_c))$$

信息熵

信息/信息量/信息熵📌

参考文章

• 损失函数-负对数似然和交叉熵(Pytorch中的应用)
• log函数的公式与应用解析
• 语言模型平滑参数-旧笔记
• softmax-交叉熵-旧笔记
• 深入理解语言模型的困惑度(perplexity)

信息、信息量、信息熵

常识

• 概率越低的事件，带来的信息量越大；概率越高，带来的信息量越小。

信息和信息量

• 信息：用来消除不确定性的东西。

• 信息量：衡量信息消除不确定性的程度。越不确定，信息量越大。

• 某事件x的发生概率为$\text{p}(x)$，其信息量为：

$$I(x)=-\text{log}(\text{p}(x))$$

• 信息和信息量关系

  • 信息量大小和信息发生概率成反比。

  • 信息概率越高，信息量越小；信息概率越低，信息量越大。

信息熵/熵

• 信息熵(熵)为所有信息量的期望。

$$H(X)=-\sum _{i=1}^{n}p(x_i)\cdot \text{log}(p(x_i))$$

• 随机变量$X$的熵越大，说明不确定性也越大。
• 香浓理论：熵也是把变量$x$编码/压缩成bit串 所需要的最少bit数🐮。

熵计算公式推导

熵计算代码实现

符号定义

• $z_i$：$x_i$ 的logits
• $p(x_i)$：$x_i$的概率

$$p(x_i)=\frac{e^{z_{x_i}}}{\sum _j{e}^{z_{x_j}}}$$

• $H(X)$：随机变量$X$的熵$$H(X)=-\sum _{i=1}^{n}p(x_i)\cdot \text{log}(p(x_i))$$

熵公式计算推导

• 推导过程

$$\begin{array}{ll}H(X)& =-\sum _{i=1}p(x_i)\cdot \log (\frac{e^{z_{x_i}}}{\sum _j{e}^{z_{x_j}}})\\ & =-\sum _{i=1}p(x_i)(\log e^{z_{x_i}}-\log (\sum e^{z_{x_j}}))\\ & =-\sum _{i=1}p(x_i)z_{x_i}+\sum _{i=1}p(x_i)\log (\sum _j{e}^{z_{x_j}})\\ & =-\sum _{i=1}p(x_i)z_{x_i}+(\sum _{i=1}p(x_i))\cdot (\log (\sum _j{e}^{z_{x_j}}))\\ & =-\sum _{i=1}p(x_i)z_{x_i}+\log (\sum _j{e}^{z_{x_j}})\end{array}$$

• 推导结果

$$H(X)=-\sum _{i=1}p(x_i)z_{x_i}+\log (\sum _j{e}^{z_{x_j}})$$

推导注意事项

• 对数加法不等

$$\log (A+B)\ne \log A+\log B$$$$\log (\sum _j{e}^{z_{x_j}})\ne \sum _j\log (e^{z_{x_j}})$$

• 左侧括号为常数，其实就为1。因为右侧和左侧求和是无关的。$$\underset{1}{\underbrace{(\sum _{i=1}p(x_i))}}\cdot \underset{\mathrm{和}\mathrm{前}\mathrm{面}\mathrm{无}\mathrm{关}}{\underbrace{(\log (\sum _j{e}^{z_{x_j}}))}}$$

熵代码实现(FSDP+Megatron)

Verl-FSDP 熵计算

直接使用推导结果

• 先计算logits概率 pd

• 再一步计算熵：logsum logits - sum logits*logis概率

  $$H(X)=-\sum _{i=1}p(x_i)z_{x_i}+\log (\sum _j{e}^{z_{x_j}})$$

# 计算流程
logits = output.logits
logits.div_(temperature)
logits = logits[:, -response_length - 1 : -1, :]  # (bsz, response_length, vocab_size)  #
log_probs = logprobs_from_logits(logits, micro_batch["responses"]) 
if calculate_entropy:
    if not self.config.entropy_checkpointing:
        entropy = verl_F.entropy_from_logits(logits)  # (bsz, response_length) #
    else:
        entropy = torch.utils.checkpoint.checkpoint(verl_F.entropy_from_logits, logits)

# 核心方法
def entropy_from_logits(logits: torch.Tensor):
    """Calculate entropy from logits."""
    # 和推导结果公式一样
    pd = torch.nn.functional.softmax(logits, dim=-1) 
    entropy = torch.logsumexp(logits, dim=-1) - torch.sum(pd * logits, dim=-1) 
    return entropy

Verl-Megatron 熵计算

说明

• 和推导计算过程一样，和fsdp相比要复杂一些一步一步计算。
• verl训练代码笔记

代码实现-VocabParallelEntropy 根据logits计算熵

• 计算exp_logits：logits求指数
• 计算sum_exp_logits：exp_logits 求和，用于计算概率
• 计算softmax_logits：每个logit的概率，exp_logits/sum_exp_logits
• 计算sum_softmax_times_logits：logits概率 * logits
• 计算最终entropy：log logits求和 - logits概率 * logits

class _VocabParallelEntropy(torch.autograd.Function):
  def forward(ctx, vocab_parallel_logits: torch.Tensor) -> torch.Tensor:
      def mul_reduce(a, b):
          return (a * b).sum(dim=-1, keepdim=True)
      # 稳定性操作，避免溢出，减去最大值
      logits_max = vocab_parallel_logits.max(dim=-1, keepdim=True).values
      normalized_vocab_parallel_logits = vocab_parallel_logits - logits_max  
      # exp_logits
      normalized_exp_logits = normalized_vocab_parallel_logits.exp_() 
      # sum_exp_logits
      normalized_sum_exp_logits = normalized_exp_logits.sum(dim=-1, keepdim=True) 
      # 计算每个logit概率
      softmax_logits = normalized_exp_logits.div_(normalized_sum_exp_logits) 
      # p_i * logits_i
      sum_softmax_times_logits = mul_reduce(softmax_logits, vocab_parallel_logits)  
      # 最终的熵，log_sum_exp_logits - sum_softmax_times_logits + logits_max
      entropy = logits_max + normalized_sum_exp_logits.log() - sum_softmax_times_logits
      ctx.save_for_backward(vocab_parallel_logits, softmax_logits, sum_softmax_times_logits)
      return entropy.squeeze(dim=-1)

  def backward(ctx, grad_output: torch.Tensor) -> torch.Tensor:
      vocab_parallel_logits, softmax_logits, sum_softmax_times_logits = ctx.saved_tensors
      # reuse softmax_logits as grad
      vocab_parallel_logits.sub_(sum_softmax_times_logits)
      softmax_logits.mul_(vocab_parallel_logits)
      softmax_logits.mul_(grad_output.unsqueeze(dim=-1))
      # recover vocab_parallel_logits
      vocab_parallel_logits.add_(sum_softmax_times_logits)
      softmax_logits.mul_(-1)
      return softmax_logits

KL散度/相对熵

KL 散度相关文章

• 深入理解 KL 散度：从直觉、数学到前沿应用的全方位解析
• Approximating KL Divergence
• TRPO KL 信任球、PPO KL Loss、 PPO 奖励加入KL散度、GRPO K3约束

相对熵KL散度定义

相对熵/KL(q, p)散度定义

分布差异/距离

• 两个分布之间的差异
• 分布q到分布p的距离。但不是真的距离。
• q和p越接近，KL散度越小；q和p相同时，KL散度为0。

信息损失

• KL(q, p)：错误认知的代价。
• 用模型分布p来近似真实分布q时，造成的信息损失。
• 本以为数据是按p分布的，但实际上数据是按q分布的。

分布q和p

• 第1个参数q：采样分布、真实分布、分子。期望是从q中采样的。

• 第2个参数p：参考分布、模型分布、分母。

  $$D_{KL}(q,p)=\sum _{x\sim q(x)}q(x)\cdot \log \frac{q(x)}{p(x)}=E_{x\sim q(x)}[\log \frac{q(x)}{p(x)}]$$

示例

• 学习策略和参考策略

  $$D_{KL}({\pi }_{\theta }||{\pi }_{ref})=E_{x\sim {\pi }_{\theta }}[\log \frac{{\pi }_{\theta }(o_{i,t}\mid q,o_{i,<t})}{{\pi }_{ref}(o_{i,t}\mid q,o_{i,<t})}]$$

• 采样策略和学习策略

  $$D_{KL}({\pi }_{old}||{\pi }_{\theta })=E_{x\sim {\pi }_{old}}[\log \frac{{\pi }_{old}(o_{i,t}\mid q,o_{i,<t})}{{\pi }_{\theta }(o_{i,t}\mid q,o_{i,<t})}]$$

• 真实和近似

  $$D_{KL}(\mathrm{真}\mathrm{实}||\mathrm{近}\mathrm{似})=\sum _{x\sim \mathrm{真}\mathrm{实}(x)}\mathrm{真}\mathrm{实}(x)\cdot \log \frac{\mathrm{真}\mathrm{实}(x)}{\mathrm{近}\mathrm{似}(x)}=E_{x\sim \mathrm{真}\mathrm{实}(x)}[\log \frac{\mathrm{真}\mathrm{实}(x)}{\mathrm{近}\mathrm{似}(x)}]$$

KL 散度 (K1)：无偏但高方差

相对熵/KL散度

K1 优点-无偏差

• 从q(x)取数据，每个数据计算$k_1(x_i)$，用平均值近似KL值。

$$k_1=\log \frac{q(x)}{p(x)}\to D_{KL}(q,p)=E_{x\sim q(x)}[\log \frac{q(x)}{p(x)}]$$

• 无偏差。只要采样样本足够多，平均值就会收敛，没有系统偏差。$$E_{x\sim q}[k_1]=E_{x\sim q}[\log \frac{q(x)}{p(x)}]$$

K1 缺点-高方差

• 方差高：$k_1\in \mathrm{任}\mathrm{何}\mathrm{值}$， 当$q(x)>p(x)$ 或 $q(x)<p(x)$时，方差很大。
• 真实示例
  • KL(q,p)=0.01，但样本： 1.5, -0.8, 2.1, -3.0, 0.2, ....
  • 离均值0.01非常远，高方差，估计值不稳定

另一种r写法

$$D_{KL}(q,p)=E_{x\sim q(x)}[-\log \frac{p(x)}{q(x)}]=E_{x\sim q(x)}[-\log r]$$

KL散度 vs 交叉熵、信息熵

• KL(q,p)散度 = p近似q的交叉熵 - q本身的熵

$$D_{KL}(q||p)=\sum _{i=1}^n\text{q}(x_i)\text{log}\frac{q(x_i)}{p(x_i)}=\underset{\text{p去近似q的交叉熵}}{\underbrace{(-\sum _{x\in X}q(x)\text{log}p(x))}}-\underset{q\mathrm{本}\mathrm{身}/\mathrm{真}\mathrm{实}\mathrm{分}\mathrm{布}\mathrm{的}\mathrm{信}\mathrm{息}\mathrm{熵}}{\underbrace{(-\sum _{x\in X}q(x)\text{log}(q(x)))}}$$

K2：低方差但有偏

K2 低方差但有偏

K2 定义

$$k_2=\frac{1}{2}(\log \frac{q(x)}{p(x)}{)}^2\to D_{KL}(q,p)\approx E_{x\sim q(x)}[\frac{1}{2}(\log \frac{q(x)}{p(x)}{)}^2]$$

优点-非负低方差

• 平方：不管谁大谁小，只关心差异大小。
• 永远非负：不像k1正负跳跃，更贴合KL散度本身非负的性质。

缺点-K2有偏

$$E_{x\sim q}[k_2]\ne KL(q,p)$$$$E_{x\sim q(x)}[\frac{1}{2}(\log \frac{q(x)}{p(x)}{)}^2]\ne E_{x\sim q(x)}[\log \frac{q(x)}{p(x)}]$$

• K2有偏差其实很小，但方差大大降低

K3：无偏且低方差

K1及r定义

• k1无偏估计

  $$k_1=\log \frac{q(x)}{p(x)}$$

• $r$定义，正好和默认KL定义是反过来的。

  $$r=\frac{p(x)}{q(x)}\to k_1=\log \frac{q(x)}{p(x)}=-\log r$$

K3 定义

K3 核心思想

• 目标：无偏+低方差。
• 手段：k1无偏估计 + r-1(期望为0)，保证期望不变，同时降低方差。

前言说明

• Composer2：P和Q差异较大时，K3方差很大，还是用回了K1
• DeepSeekV3.2：${\pi }_{\theta }\ll {\pi }_{ref}$时，K3会给这些token 分配极大权重，导致梯度瞬间爆炸。

K3 公式

• 直接公式 (对应原理)

$$k_3=\log \frac{q(x)}{p(x)}+\frac{p(x)}{q(x)}-1$$

• 推导过程

$$k_3=-\log r+r-1\to k_3=(r-1)-\log r\to k_3=(r-1)+k_1$$

• 简洁公式 (对应代码)

  $$k_3=(r-1)+k_1$$$$k_3=\frac{p(x)}{q(x)}-\log \frac{p(x)}{q(x)}-1$$

K3 为何无偏且低方差

为何无偏

• 公式推导出来是无偏的

  $$\begin{array}{ll}{E}_{x\sim q(x)}[k_3]& =E_{x\sim q(x)}[\log \frac{q(x)}{p(x)}+\frac{p(x)}{q(x)}-1]\\ & =E_{x\sim q(x)}[\log \frac{q(x)}{p(x)}]+E_{x\sim q(x)}[\frac{p(x)}{q(x)}-1]\\ & =D_{KL}(q,p)+\sum _{x}q(x)\cdot (\frac{p(x)}{q(x)}-1)\\ & =D_{KL}(q,p)+\sum _{x}p(x)-\sum _{x}q(x)\\ & =D_{KL}(q,p)\end{array}$$$$E[k_3]=E[k_1]+E[r-1]=D_{KL}(q,p)+0=D_{KL}(q,p)$$

为何方差低

• 类似k2，值永远非负，避免正负大波动$$\mathrm{\forall }x>0,\log x\le x-1\Rightarrow (r-1)-\log r>0$$

K3 值非负证明过程

• 设函数

$$f(x)=x-1-\log x$$

• 求导数

  $$f^{\prime }(x)=1-\frac{1}{x}$$

• 单调性、极值点。

  $$f^{\prime }(x)=\{\begin{array}{lll}<0,& \text{单调递减},& x<0\\ =0,& \text{极小值},& x=0\\ >0,& \text{单调递增},& x>0\end{array}$$

• 因此，k3永远非负

  $$f(x)\ge 0\to x-1-\log x\ge 0$$

IS权重优化K3估计(DeepSeekV3.2)

IS权重优化K3估计

参考链接

• IS权重优化KL3估计

$${D_{KL}}_t({\pi }_{\theta },{\pi }_{{\theta }_{ref}})=\frac{{\pi }_{\theta }(o_{i,t}\mid q,o_{i,<t})}{{\pi }_{old}(o_{i,t}\mid q,o_{i,<t})}\cdot (\frac{{\pi }_{ref}(o_{i,t}\mid q,o_{i,<t})}{{\pi }_{\theta }(o_{i,t}\mid q,o_{i,<t})}-\log \frac{{\pi }_{ref}(o_{i,t}\mid q,o_{i,<t})}{{\pi }_{\theta }(o_{i,t}\mid q,o_{i,<t})}-1)$$

实现代码

def kl_penalty_forward(logprob: torch.FloatTensor, ref_logprob: torch.FloatTensor, kl_penalty) -> torch.FloatTensor:
    """Compute KL divergence given logprob and ref_logprob.
    Copied from https://github.com/huggingface/trl/blob/main/trl/trainer/ppo_trainer.py#L1104
    See more description in http://joschu.net/blog/kl-approx.html

    Args:
        logprob:
        ref_logprob:

    Returns:
        kl_estimate
    """
    if kl_penalty in ("kl", "k1"):
        return logprob - ref_logprob 

    if kl_penalty ` "abs":
        return (logprob - ref_logprob).abs()

    if kl_penalty in ("mse", "k2"):
        return 0.5 * (logprob - ref_logprob).square() 

    # J. Schulman. Approximating kl divergence, 2020.
    # # URL http://joschu.net/blog/kl-approx.html.
    if kl_penalty in ("low_var_kl", "k3"):
        kl = ref_logprob - logprob 
        # For numerical stability
        kl = torch.clamp(kl, min=-20, max=20)
        ratio = torch.exp(kl) 
        kld = (ratio - kl - 1).contiguous()  
        return torch.clamp(kld, min=-10, max=10)

    if kl_penalty ` "full":
        # so, here logprob and ref_logprob should contain the logits for every token in vocabulary
        raise NotImplementedError

    raise NotImplementedError

交叉熵

交叉熵

交叉熵

• 真实分布q和模型估计p之间的差异，以p去近似q的熵。

$$H(q,p)=\underset{\text{p去近似q的交叉熵}}{\underbrace{(-\sum _{x\in X}q(x)\text{log}p(x))}}=\underset{KL\mathrm{散}\mathrm{度}}{\underbrace{D_{KL}(q||p)}}+\underset{\mathrm{信}\mathrm{息}\mathrm{熵}}{\underbrace{H(q)}}$$

实际应用

• $y_{\mathrm{真}\mathrm{实}}\sim y^{\prime }$为真实分布，$y_{\mathrm{预}\mathrm{测}}\sim y$为预测分布，用交叉熵去判断准确度

$$H(y^{\prime },y)=-\sum _i{y}_i^{\prime }\text{log}{y}_i=-\sum _i{y}_{\mathrm{真}\mathrm{实}}\text{log}{y}_{\mathrm{预}\mathrm{测}}$$

交叉熵简化

• 在训练过程中，标签通常采用one-hot编码，真实概率分布$q(x_i)=1$，简化：

$$H(q,p)=-\sum _{x\in X}\text{log}p(x)$$

交叉熵loss

• 交叉熵求平均，越小越好。

$$\begin{array}{rl}CELoss& =-\frac{1}{N}(\log p(x_1)+\log p(x_2|x_1)+\cdots +\log p(x_n|x_1,x_2,\cdots x_{n-1}))\\ & =-\frac{1}{N}\log p(x_1{x}_2\cdots x_n)\end{array}$$

困惑度

困惑度

困惑度

• 模型生成某个语料(句子)的概率。
• 重构输入的能力，原封不动还原原始语料的概率。评估语言模型的基本准则。
• $-\frac{1}{n}$幂：做归一化，惩罚因子，避免太长 导致数值很低。

$$ppl=p(x_1{x}_2\cdots x_n{)}^{-\frac{1}{n}}=e^{CE}=2^{\mathrm{交}\mathrm{叉}\mathrm{熵}}$$

困惑度和交叉熵的推导

$$\begin{array}{ll}-n\cdot CE=\log p(x_1{x}_2\cdots x_n)& \Rightarrow p(x_1\cdots x_n)=2^{-n\cdot CE}\\ ppl=p(x_1\cdots x_n{)}^{-\frac{1}{n}}& \Rightarrow ppl={\left(2^{-n\cdot CE}\right)}^{-\frac{1}{n}}=2^{CE}\end{array}$$

下面是一个pytorch计算交叉熵loss的一个真实示例：

# 输入数据
import torch
input=torch.rand(4,3)
tensor([[0.0515, 0.6730, 0.2852],
        [0.0362, 0.3434, 0.7450],
        [0.7136, 0.6566, 0.2402],
        [0.6989, 0.0917, 0.7857]])
# log soft max 计算
output=torch.nn.LogSoftmax(dim=1)(input)
tensor([[-1.4170, -0.7956, -1.1834],
        [-1.4796, -1.1724, -0.7708],
        [-0.9429, -0.9999, -1.4163],
        [-0.9691, -1.5762, -0.8823]])

# 假设标签为 
[1, 0, 2, 1]

# 手动计算loss
loss=−(−0.7956−1.4796−1.4163−1.5762)/4=1.3169

# pytorch计算loss，pytorch entropyloss 自动有softmax，而nllloss则无
target = torch.tensor([1,0,2,1])
loss = torch.nn.CrossEntropyLoss()
output = loss(input, target)
tensor(1.3169)

方差相关

方差相关应用笔记

• 策略梯度降低方差公式推导

方差

方差

含义

• 衡量一组数据与其平均值的偏离程度，数据的离散程度，胖瘦。

公式

• $\mu$：均值，$\sigma$：标准差，${\sigma }^2$：方差

$$\text{Var}(X)=\frac{1}{N}\sum _{i=1}^N(X_i-\mu {)}^2={\sigma }^2$$

性质

• 方差越大：数据越分散，都距离平均值较远，队伍参差不齐。
• 方差越小：数据越密集，都比较接近，队伍整整齐齐。

协方差

协方差

含义

• 描述两个变量的同步变化方向。

公式

$$\text{Cov}(X,Y)=\frac{1}{N}\sum _{i=1}^N(X_i-{\mu }_x)(Y_i-{\mu }_y)$$

性质

• 协方差大小关系

  • $\text{Cov}(X,Y)>0$：X和Y正相关

  • $\text{Cov}(X,Y)<0$：X和Y负相关

  • $\text{Cov}(X,Y)=0$：不相关，无线性关系

• 计算关系

$$\text{Cov}(X,Y)=\text{Cov}(Y,X)$$$$\text{Cov}(X,X)=\text{Var}(X)$$$$\text{Cov}(aX,bY)=ab\cdot \text{Cov}(X,Y)$$$$\text{Cov}(a+X,b+Y)=\text{Cov}(X,Y)$$$$\text{Cov}(X,Y)=E[XY]-E[X]\cdot E[Y]$$

缺点

• 数字大小很难解释。100、还是500 算相关性强？

相关系数

相关系数

含义

• 解决协方差数字大小难以解释的问题，衡量两个变量的同步变化趋势。
• 在协方差基础上，除以X和Y的标准差。

公式

$$\rho (X,Y)=\frac{\text{Cov}(X,Y)}{{\sigma }_X\cdot {\sigma }_Y}\in [-1,1]$$

性质

• $\rho (X,Y)=0$：完全没关系
• $\rho (X,Y)=1$：完全正相关
  • $(0,1]$：越接近1，正相关越强
• $\rho (X,Y)=-1$：完全负相关
  • $[-1,0)$：越接近-1，负相关越强

分词和词向量

中文分词算法🐒

英文使用空格，但中文没办法，具有以下难点。

• 分词标准不统一：“花草” 或 “花” “草”？
• 切分歧义：如“商务处女干事”，"商务/处女/干事" or “商务处/女干事”？
• 未登录词：新词的影响远超歧义切分，难度更大。

基于词典的分词算法

最大匹配法

• 正向最大匹配法：从左到右匹配，匹配度越长越好
• 逆向最大匹配法：从右到左匹配，匹配度越长越好
• 双向匹配分词法：两者混合使用，选择二者词汇数量较少者。

全切分路径选择法

核心思想：所有切分结果全部选出来，从中选择最佳的

• n最短路径选择：切分结果组成有向无环图，找到总词频最大的切分路径
• n元语法模型：采用n最短路径时，考虑词的上下文关系。

基于统计的分词算法

核心：转换成序列标注问题B(开始) E(结束) M(中间) S(一个字表示的词)

• 😈隐马尔可夫模型：观测序列/隐藏序列，条件转移概率.... jieba使用这个。
• 😕条件随机场：详细看这里。
• 💥深度学习/大模型：直接输出分词结果。

大模型分词🐹

tokenize的有3种粒度：

• Word-词：词级别独立语义，中文依赖分词算法，但长尾问题会导致词表超级大难以训练，一般不能超过5w。
• Char-字符：字符，字符有限太少会导致字符承载的信息太多，难以训练。
• Subword-子词：介于词和字符之间，平衡了词汇量和语义独立性。常用词保持原状，生僻词拆分成子词。

主要的分词算法

BPE(Byte Pair Encoding)

1、BPE(Byte Pair Encoding)

• 将最常见的子词对合并，直到词汇表到达既定大小。
• 步骤：先拆分成字符，再选择出现频率最高的相邻子词进行合并。

2、WordPiece

• BPE变种，使用语言模型概率来合并子词，而非采用出现频率。
• 合并两个字符串A和B，应有最大的$\frac{P(AB)}{P(A)P(B)}$

3、Unigram

• 从一个大词汇表出发，逐渐删除一些词汇，直到词汇表达既定大小。
• 选择删除词汇：使预定义的loss最小，挑出使loss增长最小的10%-20%词汇来删除。
• 一般Unigram算法会与SentencePiece算法连用。

4、SentencePiece

• 把句子当做整体，再拆成片段，使用BPE或Unigram算法来构造词表。

词向量🐫

参见之前的旧笔记：

• Word2vec之公式推导笔记
• Word2vec之总体介绍
• 利用tensorflow实现简版word2vec
• Word2Vec详解

1、早期one-hot编码存在的问题

• 词汇表超级大，经常百万以上。
• 词向量彼此正交，没有体现词和词之间的相互关系

2、通过训练把词向量映射到较短向量，Word2Vec

word2vec

🧠核心思想

• 基于word和context做文章，学习word和context的co-occurrence。
• 通过训练一个隐藏层神经网络，输入one-hot，输出one-hot，隐藏层则为词向量

🌟优点

• 🚀极快的训练速度。
  • 纯学词嵌入，大大简化模型，抛弃之前LM的MLE/困惑度等内容。
  • 利用HSoftmax和负采样做加速，小时级别训练完成，之前LM要几周。
• 🤴👸一个很酷炫的man-woman=king-queen的示例，使词向量成为一个热门研究方向，不只是参数。
• 相比one-hot极大提升🆙，保留词间关系，词向量维度由大V降为d，d远小于V。
• word2vec里有大量的tricks。

CBOW & SKIP-Gram

Skip-Gram

• 核心思想：中心词c预测上下文o。中心词向量预测每个上下文词向量，根据各位置算loss。
• 适用场景：适合大数据集
• 缺点：基于窗口的模型，无法使用语料库中的共现统计，导致次有词向量

CBOW

• 核心思想：上下文预测中心词。上下文向量求平均与中心词向量，越相近越好。
• 适用场景：适合小数据集
• 缺点：基于窗口的模型，无法使用语料库中的共现统计，导致次有词向量

优化提效技巧

• 层次化softmax
  • 原词向量✖️矩阵后求平均 $\to$ 直接在输入测onehot词向量求平均
  • 原隐藏层到输出层矩阵W $\to$ 哈夫曼树
    • 叶节点个数代表词汇数量，根节点到叶节点的路径决定了词向量
• 💥负采样
  • 问题：期望设计一种方法每次只更新一部分权重，那么计算复杂度将大大降低。
  • 核心思想：不采样整个词表，仅采样少数负样本，来进行计算代替整个词表。
    • 采样：可从噪声分布$P_n(w)$中进行负采样，采样概率可与词频相关。
  • 优点：加速模型计算，保证模型训练效果。
    • 每次只更新采样词的权重，不更新所有权重。👍