从Token到推理：一文读懂大语言模型的核心概念与运作全貌

在人工智能的浪潮中，大语言模型（Large Language Model, LLM）已成为最耀眼的明星之一。无论是ChatGPT的对话能力，还是GitHub Copilot的代码生成，其背后都离不开一套复杂而精妙的系统。对于许多开发者而言，理解这套系统的工作原理，尤其是其中几个核心概念——Token、参数、训练和推理——是解锁LLM潜力的关键。本文将带你深入这些概念，用通俗的语言和代码示例，串联起LLM从“识字”到“创作”的全过程。

一、Token：模型的“词汇表”与“基本单元”

在人类看来，文本是由一个个字或词组成的。但对于计算机模型，它需要一种更结构化的方式来处理文本。这就是Token的用武之地。

什么是Token？

Token是模型理解和处理文本的最小单位。它可以是：

• 子词（Subword）： 最常见的形式，如 “playing” 可能被拆分为 “play” 和 “ing”。
• 词（Word）： 对于常见词汇。
• 字符（Character）： 对于某些语言或特定模型。
• 标点符号： 如 “.”、“,”、“？”。

Token化过程

将原始文本转换为一系列Token的过程称为Token化。这通常由一个预训练的分词器（Tokenizer） 完成。

代码示例（使用Hugging Face Transformers库）：

from transformers import AutoTokenizer

# 加载一个预训练模型的分词器（例如GPT-2）
tokenizer = AutoTokenizer.from_pretrained("gpt2")

text = "Hello, world! How are you today?"
tokens = tokenizer.tokenize(text)
token_ids = tokenizer.encode(text)

print("原始文本:", text)
print("Token列表:", tokens)
# 输出可能类似： ['Hello', ',', ' world', '!', ' How', ' are', ' you', ' today', '?']
print("Token ID列表:", token_ids)
# 输出类似： [15496, 11, 995, 0, 4435, 389, 345, 1842, 30]

在这个例子中，分词器将句子拆解成了子词Token，并为每个Token分配了一个唯一的ID。这个ID就是模型内部真正“看到”的输入。

为什么是子词？ 子词化平衡了词汇表大小和语义粒度。纯字符级Token序列太长，效率低；纯词级Token会导致词汇表巨大（包含所有可能的词），且无法处理未登录词（OOV）。子词化让模型能通过已知的部件（如词根、后缀）来理解和生成新词。

二、参数：模型的“记忆”与“知识”

如果说Token是输入，那么参数（Parameters） 就是模型本身，是存储所有“知识”和“能力”的地方。

什么是参数？

模型参数是神经网络中所有可调整的权重（Weights）和偏置（Biases）的集合。在训练过程中，这些参数被不断调整，以最小化模型预测的误差。训练完成后，这些参数就被固定下来，构成了模型的“大脑”。

参数的作用与规模

• 作用： 参数决定了模型如何处理输入的Token序列，并预测下一个Token。它们编码了语言的语法规则、世界知识、逻辑推理模式等。
• 规模： 大语言模型的“大”直接体现在参数数量上。例如，GPT-3有1750亿个参数。更多的参数通常意味着更强的表示能力和更丰富的知识储备，但也需要更多的计算资源和数据来训练。

一个简化的视角： 你可以把模型想象成一个极其复杂的函数：下一个Token的概率 = 模型函数(所有输入Token的序列, 模型参数)。参数就是这个函数的“配方”。

三、训练：赋予模型“智慧”的过程

训练是使用海量文本数据，通过算法自动调整模型参数的过程。目标是让模型学会根据给定的上文，预测出最可能的下一个Token。

训练的核心：自监督学习

大语言模型主要采用自监督学习。我们不需要人工标注“这段下文是什么”，因为训练数据本身就是答案。

基本步骤：

1. 准备数据： 收集海量文本（如网页、书籍、代码）。
2. 构造样本： 从文本中截取一段序列作为输入（如上文），紧跟着的下一个Token（或一段）作为预测目标。
3. 前向传播： 将输入Token序列送入模型，模型根据当前参数计算，输出对下一个Token的预测概率分布。
4. 计算损失： 比较模型的预测分布和真实的下一个Token（一个one-hot向量），计算差异（损失，如交叉熵损失）。
5. 反向传播与优化： 通过反向传播算法，计算损失相对于每一个模型参数的梯度。然后使用优化器（如Adam）沿着梯度反方向微调参数，以降低损失。
6. 循环迭代： 对海量数据重复步骤2-5，直到模型损失收敛。

伪代码概念：

# 概念性伪代码，展示训练循环
model = LanguageModel() # 初始化模型，参数随机
optimizer = Adam(model.parameters())
criterion = CrossEntropyLoss()

for epoch in range(num_epochs):
    for batch in data_loader: # 批量加载文本数据
        input_ids, target_ids = batch # input_ids是上文，target_ids是下一个token
        # 前向传播
        logits = model(input_ids) # 模型输出预测logits
        loss = criterion(logits, target_ids)
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        # 参数更新
        optimizer.step()

通过数十亿次这样的调整，模型参数从随机状态逐渐变得“聪明”，学会了语言的统计规律和深层模式。

四、推理：模型能力的“释放”与应用

训练完成后，固定参数的模型就可以用于实际任务，这个过程称为推理（Inference） 或生成（Generation）。

推理的基本模式：自回归生成

给定一个提示（Prompt），模型以自回归的方式逐个生成Token。

1. 将提示文本Token化，得到初始序列。
2. 将序列输入模型，模型输出下一个Token的概率分布。
3. 根据某种采样策略从分布中选取一个Token，追加到序列末尾。
4. 重复步骤2-3，直到生成结束标记（如<eos>）或达到最大长度。

关键采样策略

如何从概率分布中选取下一个Token，直接影响生成文本的质量和多样性。

• 贪婪搜索（Greedy Search）： 总是选择概率最高的Token。生成结果确定但可能单调、重复。

  # 概念性代码
  next_token_id = torch.argmax(logits, dim=-1)
  

• 束搜索（Beam Search）： 保留多个（束宽）高概率候选序列，每一步都扩展这些序列，最终选择总体概率最高的序列。常用于机器翻译等任务，追求确定性最优。
• 温度采样（Temperature Sampling）： 引入温度参数T控制分布的平滑度。
  • T=1： 使用原始分布。
  • T<1： 分布更尖锐，高概率Token更易被选中，输出更确定。
  • T>1： 分布更平缓，低概率Token机会增加，输出更多样、更有创造性。

    # 概念性代码
    import torch.nn.functional as F
    logits = logits / temperature # 应用温度
    probs = F.softmax(logits, dim=-1) # 转换为概率
    next_token_id = torch.multinomial(probs, num_samples=1) # 依概率采样
    

• Top-k / Top-p 采样：
  • Top-k： 仅从概率最高的k个Token中采样。
  • Top-p（核采样）： 从累积概率超过p的最小Token集合中采样。能动态调整候选集大小。

代码示例（使用Transformers库进行文本生成）：

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

tokenizer = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2")

prompt = "人工智能的未来将是"
input_ids = tokenizer.encode(prompt, return_tensors="pt")

# 使用generate函数，内置多种采样策略
with torch.no_grad():
    # 使用温度采样和Top-p采样
    output_ids = model.generate(
        input_ids,
        max_length=50,
        do_sample=True,
        temperature=0.8,
        top_p=0.92,
        pad_token_id=tokenizer.eos_token_id
    )

generated_text = tokenizer.decode(output_ids[0], skip_special_tokens=True)
print("生成的文本:", generated_text)

总结：概念的串联

现在，让我们把四个核心概念串联起来，看看一个完整的LLM应用是如何工作的：

1. 输入： 用户输入“写一首关于春天的诗：”。
2. Token化： 分词器将这句话转换为一系列Token ID，如 [x1, x2, x3, ...]。
3. 推理（前向传播）： 模型加载其固定的、训练好的参数。Token ID序列被送入模型。模型基于其参数所编码的“知识”（包括对诗歌格式、春天意象的理解），计算下一个Token的概率分布。
4. 采样： 根据设定的策略（如温度采样），从分布中选取一个Token ID（比如“春”）。
5. 自回归循环： 将新生成的Token“春”追加到输入序列末尾，形成新的输入 [x1, x2, x3, ..., “春”]，重复步骤3-4，生成下一个Token（如“天”）。
6. 输出： 持续生成，直到遇到结束标记或达到长度限制。最后，将生成的Token ID序列通过分词器转换回人类可读的文本：“春天来了，万物复苏…”。

参数是模型在训练阶段从数据中学到的“知识结晶”。Token是模型与文本世界交互的“通用货币”。而推理则是利用凝固的知识和通用的货币，为用户创造价值的“生产过程”。

理解这四个环节及其相互关系，是深入探索大语言模型技术、进行模型微调（Fine-tuning）或优化推理部署的坚实基础。随着技术的演进，每个环节都在不断创新（如更高效的分词算法、MoE架构的参数组织、新的训练范式、更快的推理引擎），但它们构成的这个核心闭环，依然是驱动当今LLM发展的基本原理。