每日基础课

一句话定义：因果语言模型（Causal Language Model, 简称 CLM）是一种“只能看过去、不能看未来”的模型，它的核心任务是根据已经出现的前文序列，预测下一个最可能出现的词（Token）。

生活类比： 就像你在手机输入法上打字，键盘上方会实时弹出下一个推荐词。你打出“今天天气”，输入法只能根据“今天天气”猜你想接“真好”还是“怎么样”。它绝对不可能提前读取你脑子里还没敲出来的后半句。这种“基于已知历史，只猜下一步”的模式，就是因果模型。

必要公式： 给定一个长度为 $T$ 的文本序列 $W = (w_1, w_2, \dots, w_T)$，因果语言模型将整句话的联合概率分解为一系列条件概率的乘积： $$P(w_1, w_2, \dots, w_T) = \prod_{t=1}^{T} P(w_t \mid w_1, w_2, \dots, w_{t-1})$$

符号逐个解释： - $w_t$：第 $t$ 个位置上的词（Token）。 - $w_1, w_2, \dots, w_{t-1}$：从第 1 个词到第 $t-1$ 个词的历史上文。 - $P(w_t \mid w_1, \dots, w_{t-1})$：在已知前文所有词的条件下，当前位置出现词 $w_t$ 的概率。 - $\prod_{t=1}^{T}$：连乘符号，表示把每一步预测下一个词的概率乘起来，得到整句话出现的总概率。

它解决什么问题？没有它会怎样？ - 解决的问题：解决了“开放式序列生成”和“实时流式处理”问题。模型在训练和推理时严格遵守时间先后顺序，学会自然流畅地往后编排内容。 - 没有它会怎样：如果在训练预测第 $t$ 个词时允许模型看到第 $t+1$ 个词（即偷看未来），模型会走捷径直接抄答案（Loss 很快降为零但学不到真本事）。一旦上线部署做实时语音转写、说话人切换判定或文本生成时，未来还没发生，没有“未来答案”可抄，模型就会彻底瘫痪。

实现思路： 1. 用 `torch.triu` 或 `torch.tril` 构造下三角掩码，右上角填充 $-\infty$，通过 Softmax 后未来权重严格为 0。 2. 搭建极简 Causal Self-Attention 与 Linear 投影头，输出词表概率分布（Logits）。 3. 训练计算损失时：将 `input_ids[:, :-1]` 预测 `input_ids[:, 1:]`。 4. 推理生成时：单步喂入当前全部已有序列，取最后一个位置的输出 argmax，拼接到序列末尾，循环迭代。

完整可运行代码：

import torch
import torch.nn as nn
import torch.nn.functional as F

class MiniCausalLM(nn.Module):
    def __init__(self, vocab_size, embed_dim):
        super().__init__()
        self.token_embed = nn.Embedding(vocab_size, embed_dim)
        self.q_proj = nn.Linear(embed_dim, embed_dim, bias=False)
        self.k_proj = nn.Linear(embed_dim, embed_dim, bias=False)
        self.v_proj = nn.Linear(embed_dim, embed_dim, bias=False)
        self.lm_head = nn.Linear(embed_dim, vocab_size, bias=False)

    def forward(self, input_ids):
        # input_ids: [batch_size, seq_len]
        B, T = input_ids.shape
        x = self.token_embed(input_ids)  # [B, T, embed_dim]

        # 1. 计算 Q, K, V
        q = self.q_proj(x)  # [B, T, embed_dim]
        k = self.k_proj(x)  # [B, T, embed_dim]
        v = self.v_proj(x)  # [B, T, embed_dim]

        # 2. 计算注意力原始分数
        scale = 1.0 / (q.shape[-1] ** 0.5)
        scores = torch.matmul(q, k.transpose(-2, -1)) * scale  # [B, T, T]

        # 3. 构造因果掩码 (Causal Mask)：遮蔽右上角（未来信息）
        mask = torch.triu(torch.ones(T, T, device=input_ids.device), diagonal=1).bool()
        scores = scores.masked_fill(mask, float('-inf'))

        # 4. 归一化为注意力权重并聚合 Value
        attn_weights = F.softmax(scores, dim=-1)  # [B, T, T]
        out = torch.matmul(attn_weights, v)       # [B, T, embed_dim]

        # 5. 投影到词表维度
        logits = self.lm_head(out)               # [B, T, vocab_size]
        return logits

# --- 验证 1：训练时的并行前向与 Loss 计算 ---
torch.manual_seed(42)
vocab_size, embed_dim = 20, 16
model = MiniCausalLM(vocab_size, embed_dim)

# 模拟一个批次的离散 Token 序列（比如音频离散 Codec 或文本 Token）
# 序列内容: [1, 5, 8, 12, 9]
seq = torch.tensor([[1, 5, 8, 12, 9]], dtype=torch.long)

# CLM 的标准切片方式：前 N-1 个词作为输入，后 N-1 个词作为目标
inputs = seq[:, :-1]   # [1, 5, 8, 12]
targets = seq[:, 1:]   # [5, 8, 12, 9]

logits = model(inputs) # 预测形状: [1, 4, vocab_size]
loss = F.cross_entropy(logits.view(-1, vocab_size), targets.view(-1))
print(f"训练前向 Loss: {loss.item():.4f}")

# --- 验证 2：自回归逐 Token 贪婪生成 ---
model.eval()
prompt = torch.tensor([[1]], dtype=torch.long) # 起始 Token
max_new_tokens = 5

generated = prompt
with torch.no_grad():
    for _ in range(max_new_tokens):
        # 传入当前积累的全部前文
        logits = model(generated) # [1, curr_len, vocab_size]
        # 只看最后一个时间步预测的下一个词
        next_token_logits = logits[:, -1, :] # [1, vocab_size]
        next_token = torch.argmax(next_token_logits, dim=-1, keepdim=True) # [1, 1]
        # 拼接进历史序列，继续下一步
        generated = torch.cat([generated, next_token], dim=1)

print(f"自回归生成完整序列: {generated.squeeze().tolist()}")