大模型原理与训练 / 系统课时

让模型按提示连续生成文本

让模型按提示连续生成文本

本节把训练好的微型 GPT 变成可连续生成文本的自回归程序:从提示词开始,每次只预测一个新词元,再把它拼回上下文继续预测。你还会加入温度、top-k、重复惩罚和停止条件,避免输出过早终止或陷入机械循环。

学习目标

  • 实现提示词编码、上下文裁剪、单步采样与回填组成的自回归生成循环。
  • 理解温度、top-k 与重复惩罚分别怎样改变下一个词元的概率分布。
  • 用最大生成长度、停止字符串或 EOS 设计可靠的停止边界,并定位重复问题。

自回归生成在循环什么

GPT 不会一次性写出整段文本。它先根据当前上下文得到最后一个位置的 logits,经过采样得到一个新词元,再把这个词元追加到序列尾部,重新执行同样过程。只要没有命中停止条件,这个循环就会持续。

模型的上下文窗口是有限的。序列长度超过 block_size 后,只能保留最后一段词元送回模型;这不是删除已经生成的文本,而是限制下一次前向计算能看到的历史范围。

GPT 自回归生成循环

采样参数分别控制什么

温度会缩放 logits。temperature < 1 会让高概率候选更占优势,结果更稳定;大于 1 会放大随机性。top_k 只保留概率最高的一小组候选,避免从长尾中抽到明显不合理的字符或词元。

重复惩罚解决的是另一类问题:模型可能已经非常确信某个局部模式,于是不断重复同一字符、单词或短句。本例对最近窗口中出现过的词元降低 logits。惩罚过大也会破坏正常语法,所以应在确认存在重复后再逐步增加。

停止条件至少要有一个硬边界。字符级模型通常没有 EOS,因此本例把 max_new_tokens 作为兜底,同时支持 stop_text;如果你的词表含 EOS,只需在采到对应 ID 时提前退出。

运行连续生成脚本

下面脚本与训练时使用同一个 TinyGPT 结构,并从 tiny_gpt.pt 恢复配置、字符表和参数。这个检查点应由你自己生成或来自可信来源,且字段至少包含 model_state、config、stoi 与 itos。

python
import torch
import torch.nn.functional as F
from torch import nn

device = "cuda" if torch.cuda.is_available() else "cpu"
checkpoint = torch.load(
    "tiny_gpt.pt",
    map_location=device,
    weights_only=True,
)
config = checkpoint["config"]
stoi = checkpoint["stoi"]
itos = checkpoint["itos"]

class TinyGPT(nn.Module):
    def __init__(self, cfg):
        super().__init__()
        self.token_embedding = nn.Embedding(
            cfg["vocab_size"],
            cfg["d_model"],
        )
        self.position_embedding = nn.Embedding(
            cfg["block_size"],
            cfg["d_model"],
        )
        layer = nn.TransformerEncoderLayer(
            d_model=cfg["d_model"],
            nhead=cfg["n_head"],
            dim_feedforward=4 * cfg["d_model"],
            dropout=cfg["dropout"],
            batch_first=True,
            norm_first=True,
            activation="gelu",
        )
        self.blocks = nn.TransformerEncoder(
            layer,
            num_layers=cfg["n_layer"],
        )
        self.norm = nn.LayerNorm(cfg["d_model"])
        self.lm_head = nn.Linear(
            cfg["d_model"],
            cfg["vocab_size"],
        )

    def forward(self, idx):
        _, t = idx.shape
        pos = torch.arange(t, device=idx.device)
        x = self.token_embedding(idx) + self.position_embedding(pos)

        # 因果掩码保证当前词元不能利用未来位置。
        mask = torch.triu(
            torch.full((t, t), float("-inf"), device=idx.device),
            diagonal=1,
        )
        x = self.blocks(x, mask=mask)
        return self.lm_head(self.norm(x))

model = TinyGPT(config).to(device)
model.load_state_dict(checkpoint["model_state"])
model.eval()

def encode(text):
    unknown = sorted(set(text) - set(stoi))
    if unknown:
        raise ValueError(f"prompt contains unknown chars: {unknown}")
    return [stoi[ch] for ch in text]

def decode(ids):
    return "".join(itos[int(i)] for i in ids)

@torch.no_grad()
def generate(
    idx,
    max_new_tokens=120,
    temperature=0.8,
    top_k=8,
    repetition_penalty=0.4,
    repeat_window=24,
    stop_text=None,
):
    for _ in range(max_new_tokens):
        idx_cond = idx[:, -config["block_size"]:]
        logits = model(idx_cond)[:, -1, :]
        logits = logits / max(temperature, 1e-5)

        # 对最近出现过的词元做轻量惩罚,减少局部循环。
        recent = idx[:, -min(idx.size(1), repeat_window):]
        recent_ids = torch.unique(recent)
        logits[:, recent_ids] = (
            logits[:, recent_ids] - repetition_penalty
        )

        k = min(top_k, logits.size(-1))
        top_values, _ = torch.topk(logits, k)
        cutoff = top_values[:, -1].unsqueeze(-1)
        logits = torch.where(
            logits < cutoff,
            torch.full_like(logits, float("-inf")),
            logits,
        )

        probs = F.softmax(logits, dim=-1)
        next_id = torch.multinomial(probs, num_samples=1)
        idx = torch.cat([idx, next_id], dim=1)

        # stop_text 是软停止条件,max_new_tokens 始终提供硬上限。
        if stop_text and decode(idx[0].tolist()).endswith(stop_text):
            break

    return idx

prompt = "to be"
input_ids = torch.tensor(
    [encode(prompt)],
    dtype=torch.long,
    device=device,
)
output_ids = generate(
    input_ids,
    max_new_tokens=120,
    temperature=0.8,
    top_k=8,
    repetition_penalty=0.4,
    stop_text=" question ",
)
print("prompt:", prompt)
print("completion:", decode(output_ids[0].tolist()))

预期输出

text
prompt: to be
completion: to be<GENERATED_TEXT>

<GENERATED_TEXT> 每次运行都可能不同,因为 torch.multinomial 会按概率采样。若模型一直没有生成 question,循环会在新增 120 个字符后停止;若提前生成该字符串,则立即结束。

排查停止与重复

如果输出几乎立刻终止,先检查 stop_text 是否本来就容易出现在提示词附近,以及停止判断是否误用了“包含”而不是“以该序列结尾”。若使用带 EOS 的词表,还要确认 EOS 的 ID 与训练时一致。

如果文本反复出现同一小段,可以先把 repetition_penalty 从 0.4 小幅提高,再观察语法是否被破坏;也可以适度提高 top_k,让模型拥有更多合理候选。相反,如果输出过于随机,应降低温度或缩小 top_k,而不是单纯增加重复惩罚。

同一个提示连续生成多次时,结果不同是采样的正常表现。验收时应重点确认三件事:提示词没有未知字符、每轮只追加一个词元且上下文正确裁剪、停止条件总能在有限步数内结束生成。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

让模型按提示连续生成文本

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通