LLM成长笔记（四）：大语言模型（LLM）基础认知

大语言模型（LLM）基础认知学习博客（深度原理 + 图解 + 注释 · AI应用强化版）

大语言模型（LLM）是当前 AI 浪潮的核心。这篇博客从实际问题出发 ，用生活化类比 建立直觉，通过术语详解 深入概念本质，再用原理剖析 、图解演示 和可运行代码带你一步步理解。每一个概念都力求让初学者也能完全看懂，并指明它们在 AI 应用开发中的实际用途。

一、初级篇：理解 LLM 的工作方式

1. Transformer 原理入门

问题

传统循环神经网络（RNN）处理长文本时容易"忘记"开头，速度也慢。如何让模型高效地理解整段文字中任意两个词之间的关系？

生活化类比
Transformer 就像一场高效的圆桌会议：每个词都是一个与会者，他们同时听取所有人的发言（自注意力），然后根据重要性做笔记，再传递给下一轮讨论。不再像传话游戏那样一句一句排队，信息不会丢失。

术语详解：Q、K、V 到底是什么？

自注意力机制中，每个词都会被转换成三个不同的向量：查询（Query）、键（Key）、值（Value）。这三个向量是通过三个不同的权重矩阵（W^Q, W^K, W^V）分别乘以该词的原始输入向量得到的。这些矩阵在训练中会被自动学会。

查询 Q（Query） ：代表"我想找什么"。可以理解为这个词正在"提问"：句子中哪些地方对我最重要？
键 K（Key） ：代表"我有什么标签"。每个词都把自己的特征写成标签，方便别人来"检索"。
值 V（Value） ：代表"我实际要传递的信息"。当别的词通过 Q 和 K 的匹配决定要关注我之后，就从我这里取走真实的语义信息。

注意力计算过程就像用问题去匹配标签，按匹配度加权取出信息：

用 Q 去和所有词的 K 做点积，得到"注意力分数"，表示"这个问题和各个标签有多匹配"。
分数经过缩放和 softmax 变成注意力权重（一种百分比，和为1）。
用这些权重去加权求和所有词的 V，得到融合了上下文信息的输出向量。

这样，每个词都能从整句话中提取自己最需要的语义信息，而不会受距离限制。实际模型中会同时运行多个注意力头（Multi-Head Attention），就像邀请多个专家同时从不同角度解读文本，最后把他们的意见综合起来，理解更全面。

图解演示：注意力计算流程

复制代码

原始句子："我 爱 你"

第一步：为每个词生成 Q, K, V（通过矩阵乘法）

Token:    我            爱            你
Q:     [q1]         [q2]         [q3]     ← "我要找什么"
K:     [k1]         [k2]         [k3]     ← "我的标签是什么"
V:     [v1]         [v2]         [v3]     ← "我传递的信息"

第二步：计算注意力分数矩阵 = Q × K^T（每个词与其他词的点积）

          我        爱        你
我     q1·k1    q1·k2    q1·k3
爱     q2·k1    q2·k2    q2·k3
你     q3·k1    q3·k2    q3·k3

第三步：softmax（按行），得到注意力权重矩阵（每行的和为1）

          我        爱        你
我      0.1      0.3      0.6   ← "我"这个词，60% 关注"你"
爱      0.2      0.2      0.6
你      0.4      0.3      0.3

第四步：用权重矩阵乘以 V 矩阵，得到每个词的最终上下文表示

输出向量的每一行都是"自己关注的各个词的值"加权求和。

演示用例：手动计算一个极简注意力（帮助理解）

python 复制代码

import numpy as np

# 假设三个词的 Query, Key, Value 向量（维度2）
Q = np.array([[1, 0], [0, 1], [1, 1]])  # 每个词一个 query
K = np.array([[1, 2], [2, 1], [0, 1]])  # key
V = np.array([[10, 0], [0, 10], [5, 5]]) # value

# 计算注意力分数（点积）
scores = Q @ K.T
# 缩放（d_k=2）
d_k = 2
scores = scores / np.sqrt(d_k)

# softmax
def softmax(x):
    exp_x = np.exp(x - np.max(x, axis=1, keepdims=True))
    return exp_x / exp_x.sum(axis=1, keepdims=True)

attention_weights = softmax(scores)
print("注意力权重矩阵（每行是一个词对其它词的关注度）：\n", attention_weights)

# 加权求和 Value
output = attention_weights @ V
print("自注意力输出（每个词的上下文表示）：\n", output)
# 现在每一行都是一个融合了整句上下文后的向量，代表对应词在句子中的最终含义

输出结果

复制代码

注意力权重矩阵（每行是一个词对其它词的关注度）：
 [[0.422 0.327 0.251]
 [0.271 0.482 0.247]
 [0.338 0.328 0.334]]
自注意力输出：
 [[5.48  5.08 ]
 [2.99  7.06 ]
 [4.22  5.23 ]]

AI 应用场景：理解注意力机制后，你会明白为什么长上下文需要更多显存、为什么提示词顺序会影响输出质量，这对于设计 RAG 检索增强应用的提示词模板至关重要。

2. Tokenizer、Embedding、Attention 机制直观理解

问题

模型内部只能处理数字，如何把一段文字变成模型能理解的一串数字向量，并且保留语义？

生活化类比

分词器（Tokenizer）就像把中文句子拆成一个个"字/词积木"，并给每个积木编上唯一编号。
嵌入（Embedding）就像给每个积木赋予一个多维坐标，含义相近的积木在空间中位置接近，例如"高兴"和"开心"的坐标很近。
注意力机制就像句子中各个积木互相"发电报"，告诉对方自己有多重要，最终每个积木都融合了上下文信息。

术语详解：Token、Embedding 向量

Token ：文本被切割成的最小语义单元。不是简单地按字或词切割，而是通过字节对编码（BPE） 等算法统计高频连续片段，形成子词。
例子：英文 "playing" 可能被切分为 "play" + "ing"，这样模型看到 "play" 就能关联到 "play"、"plays"、"played" 等。
GPT-2 的 tokenizer 会把 "I love NLP" 切成：['I', 'Ġlove', 'ĠN', 'LP']，其中 Ġ 表示前导空格。
Embedding：一个固定维度的稠密向量（比如 768 维），每个 token 有一个唯一的嵌入向量。向量中每个位置的值没有直观含义，但训练过程中，"语义相近的词"向量在空间中彼此靠近。
位置编码：Transformer 是并行处理所有词的，如果不加位置信息，模型无法区分"我爱你"和"你爱我"。位置编码就是给每个向量加上一个与位置有关的数字标签，让模型知道词的前后顺序。
整个流程：文本 → 分词器 → token IDs → 嵌入矩阵查表 → 加上位置编码 → 送入 Transformer 层 → 得到富含上下文的向量。

特别注意：Chat 模型的特殊 Token 和模板

开源 Chat 模型（如 Llama、Qwen）在对话时需要严格按照Chat Template 拼接消息。例如 Llama 的模板可能是：

复制代码

<|begin_of_text|><|start_header_id|>user<|end_header_id|>

Hello<|eot_id|><|start_header_id|>assistant<|end_header_id|>

Hi!<|eot_id|>

如果直接用普通文本拼接而不套用模板，模型可能输出混乱、重复或答非所问。使用 tokenizer.apply_chat_template(messages) 可以自动生成正确格式，这是调用开源 Chat 模型的基本功。

图解演示：文本到向量的转换流程

复制代码

文本："我 爱 NLP"
            ↓
      Tokenizer (BPE)
            ↓
 tokens: ["我", "爱", "N", "LP"]
            ↓
 token IDs: [ 234, 456, 789, 1011 ]
            ↓
      Embedding 查表 (假设 embedding_dim=4)
            ↓
嵌入向量（初始）:
我: [0.2, -0.5, 0.1, 0.9]
爱: [0.6, -0.3, 0.7, 0.2]
N : [0.1, 0.4, -0.8, 0.3]
LP: [0.5, 0.2, -0.1, 0.6]
            ↓
      + 位置编码 (位置信息)
            ↓
送入 Transformer 自注意力层
            ↓
输出上下文感知的向量（每个词都融合了句子信息）

演示用例：使用 Hugging Face transformers 库体验 tokenizer

python 复制代码

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("gpt2")

text = "I love large language models!"
tokens = tokenizer.tokenize(text)
ids = tokenizer.encode(text)

print("原始文本：", text)
print("Token 拆分结果：", tokens)
print("Token IDs：", ids)

print("\n逐个 token 及其 ID：")
for t, i in zip(tokens, ids):
    print(f"  {t:12s} -> {i}")

输出结果

复制代码

原始文本： I love large language models!
Token 拆分结果： ['I', 'Ġlove', 'Ġlarge', 'Ġlanguage', 'Ġmodels', '!']
Token IDs： [40, 1842, 1790, 3067, 5682, 0]
逐个 token 及其 ID：
  I            -> 40
  Ġlove        -> 1842
  Ġlarge       -> 1790
  Ġlanguage    -> 3067
  Ġmodels      -> 5682
  !            -> 0

注意：GPT-2 词表大小为 50257，ID 0 是特殊 token <|endoftext|>，这里表示结尾。Embedding 矩阵大小是 [50257, 768]（以 GPT-2 small 为例），每个 ID 对应一行 768 维向量。
AI 应用场景：掌握 tokenizer 后，你能精确计算 API 调用成本（按 token 计费），并正确处理多轮对话的输入拼接；理解 Embedding 后，你就能搭建语义搜索和 RAG 系统------将用户查询和知识库内容都转成向量，用余弦相似度找到最相关的片段。

3. 解码策略：temperature、top-k、top-p

问题

同样的问题，有时候希望回答比较固定（比如翻译），有时候希望有创造性（比如写诗）。如何控制模型输出的随机程度？

生活化类比
解码策略就像炒菜的火候控制：

Temperature（温度）：温度低（如 0.2），模型只会选最稳妥的下一步，像小火慢炖，输出保守；温度高（如 1.0），各种可能性都会冒出来，像大火爆炒，创意十足但可能糊锅。
Top-k：只从概率最高的 k 个候选词里挑，把特别不靠谱的排除在外。
Top-p（核采样）：只保留累积概率刚超过 p 的最小候选集合，动态调整候选数量。

术语详解：logits、softmax 与采样

模型最后一层输出的是长度为词汇表大小（如 50000）的 logits 向量。logits 是未归一化的概率，可能包含负数。经过 softmax 后变成总和为 1 的概率分布。

Temperature（τ）：用 logits 除以 τ 后再 softmax。τ > 1 让分布更平坦（增加低概率词的机会），τ < 1 让分布更尖锐（高概率词更突出）。τ=1 是标准 softmax。
Top-k 采样：对概率排序，只保留前 k 个，将其余概率置零，然后重新归一化，最后从截断的分布中采样。
Top-p（核采样）：从最高概率的词开始累加概率，直到累积概率 ≥ p，保留这一组词，其余概率置零，重新归一化后采样。这样候选数量随分布动态变化。
重复惩罚（Repetition Penalty）：对已经生成的 token 进行降权，抑制模型反复输出相同内容，常配合上述策略使用。

图解演示：不同温度对概率分布的影响

复制代码

假设原始 logits 经过 softmax 后得到的概率：
A:0.6  B:0.3  C:0.08  D:0.02

temperature=1.0（标准）：
A:0.6  B:0.3  C:0.08  D:0.02

temperature=0.5（低温，更尖锐）：
A:0.85 B:0.12 C:0.02  D:0.01
(高概率词更突出)

temperature=2.0（高温，更平滑）：
A:0.35 B:0.28 C:0.22  D:0.15
(分布更均匀，低概率词机会变大)

演示用例：不同解码参数生成效果对比

python 复制代码

from transformers import pipeline, set_seed

generator = pipeline("text-generation", model="gpt2")
set_seed(42)

prompt = "The weather today is"

print("===== 贪婪解码（temperature=0, 确定性输出） =====")
output = generator(prompt, max_length=30, temperature=0.0001, do_sample=False)
print(output[0]["generated_text"])

print("\n===== temperature=0.5, top_k=50（适度创意） =====")
output = generator(prompt, max_length=30, temperature=0.5, top_k=50, do_sample=True)
print(output[0]["generated_text"])

print("\n===== temperature=1.0, top_p=0.9（高度发散，创意丰富） =====")
output = generator(prompt, max_length=30, temperature=1.0, top_p=0.9, do_sample=True)
print(output[0]["generated_text"])

输出结果

复制代码

===== 贪婪解码（确定性输出） =====
The weather today is expected to be a bit of a mixed bag for the next few days, with a mix of rain and snow expected to

===== temperature=0.5, top_k=50（适度创意） =====
The weather today is a bit cooler than the previous days, but it's still nice to have a little bit of sunshine

===== temperature=1.0, top_p=0.9（高度发散，创意丰富） =====
The weather today is fantastic: drizzle throughout most of July in DC, but they kept dancing; eventually they made sweet love

AI 应用场景：调整解码参数是控制 AI 应用输出风格的核心手段：客服机器人用低温度保证准确，创意写作助手用高温度激发多样性。掌握这些参数后，你就能根据业务需求精确调控模型行为。

二、中级篇：模型选型与生态

1. 模型类型与适用场景：Chat、Completion、Embedding、多模态模型差异

问题

市面上有各种模型：有的擅长聊天，有的补全代码，有的能把文本转成向量，还有的能看图说话。它们到底有什么区别？我应该用哪个？

生活化类比
不同模型就像不同工种的专家：

Chat 模型像能说会道的客服，适合多轮对话。
Completion 模型像文思泉涌的作家，适合续写、代码生成。
Embedding 模型像图书馆分类员，把文本变成数字标签，用于搜索、聚类。
多模态模型像感官齐全的艺术家，能同时处理文字、图片甚至声音。

术语详解：Chat vs Completion、Embedding、多模态

Chat 模型 （如 GPT-3.5-turbo, GPT-4）使用特定的消息格式 {"role":"user","content":...}，经过指令微调 和RLHF，懂得遵循指令，拒绝不当请求。
Completion 模型（如 text-davinci-003）只是做文本续写，输入一段文本，模型补充下文，没有"对话角色"概念。
Embedding 模型 （如 text-embedding-3-small）不生成文字，而是输出一个高维向量 （如 1536 维），可以比较两个向量的余弦相似度来衡量语义相似度。这些向量通常存储在向量数据库 （如 Pinecone、Weaviate、Milvus）中，用于实现 RAG（检索增强生成）------从知识库中检索最相关的文档片段，再交给 Chat 模型生成最终回答。
多模态模型（如 GPT-4o, Gemini）同时接受文本和图像输入：用户上传图片后，视觉编码器将图像转换为模型能理解的数字表示，然后由语言模型处理并生成回答。输入可以是"描述这张图片"或"图片中的公式是多少"。

图解演示：Chat 模型的消息格式与 Completion 模型的区别

复制代码

Chat 模型输入 (JSON)：
[
  {"role": "system", "content": "你是一个助手"},
  {"role": "user", "content": "你好"},
  {"role": "assistant", "content": "你好! 有什么我可以帮助你的？"},
  {"role": "user", "content": "今天天气如何？"}
]

Completion 模型输入 (纯文本)：
"你是一个助手\n用户: 你好\n助手: 你好! 有什么我可以帮助你的？\n用户: 今天天气如何？\n助手:"

演示用例：使用 OpenAI API 对比 Chat 和 Embedding

python 复制代码

from openai import OpenAI
client = OpenAI()

# Chat 模型
chat_response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "用一句话解释什么是 Transformer"}]
)
print("Chat 回复：", chat_response.choices[0].message.content)

# Embedding 模型
embedding_response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Transformer"
)
vec = embedding_response.data[0].embedding
print("Embedding 维度：", len(vec))
print("前5个值：", vec[:5])

输出结果

复制代码

Chat 回复： Transformer是一种基于自注意力机制的深度学习模型架构，它摒弃了循环网络结构，通过并行处理序列数据显著提升了训练效率，被广泛应用于自然语言处理等领域。
Embedding 维度： 1536
前5个值： [-0.001, 0.023, -0.012, 0.034, -0.008]

AI 应用场景：Embedding 是搭建 RAG 系统的基础------将用户查询和知识库都向量化，在向量数据库中检索最相似的内容，再交给 Chat 模型生成精确回答。多模态模型可直接在产品中分析用户上传的图片，实现视觉问答。

2. 商业化模型与开源生态

问题

GPT-4o、Claude、Gemini 都是顶尖模型，它们各有什么特点？还有 Llama、Qwen、DeepSeek 等开源模型，到底怎么选？

生活化类比

商业化模型就像高端定制餐厅：花大价钱享受顶级服务，但菜谱保密，你只能通过餐厅点菜（API）。
开源模型就像菜谱公开的厨房：你可以自己买食材（下载模型），随意改进，成本低但需要自己动手。

术语详解：闭源与开源的区别

模型	类型	特点
GPT-4o	闭源	OpenAI 多模态旗舰，语音、视觉、文本全能
Claude 3	闭源	Anthropic 开发，强调安全性和长上下文
Gemini	闭源	Google 多模态模型，与谷歌生态深度整合
Llama 3	开源	Meta 发布，可商用，社区活跃
Qwen 2	开源	阿里通义千问，多尺寸，中英文出色
DeepSeek V2	开源	国产高效 MoE 架构，推理成本极低

场景化选型建议

快速验证原型、追求最强性能：直接用 GPT-4o 或 Claude 3 的 API，几分钟就能接入，无需管部署。
处理中文文档且需本地部署、数据不出境：Qwen 2 是中文能力最强的开源模型之一，支持长上下文。
追求极致推理成本、大规模调用：DeepSeek V2 采用 MoE 架构，API 价格极低，且开源可本地部署。
需要社区生态和丰富微调教程：Llama 3 拥有最庞大的开发者社区，各种量化版、微调版应有尽有。

选闭源像点外卖------省事但花钱；选开源像买菜自炊------自由但需要自己操刀。根据你的预算、隐私要求和时间成本来做决定。

3. 理解模型卡（Model Card）、许可证、成本估算

问题

在 Hugging Face 上看到一个模型，旁边有"Model Card"标签；下载代码时看到 MIT、Apache、Llama 等许可证；用 API 又担心账单爆掉。这些分别意味着什么？

生活化类比

模型卡就像药品说明书：告诉你模型的用途、副作用（偏见）、训练数据来源、评测结果。
许可证就像租房合同：规定你能用这个模型做什么，能不能商用，要不要署名。
成本估算就像手机话费预算：用 API 按量付费，需要事先算好用量；本地部署则要购置硬件。

术语详解：模型卡、许可证、成本构成

模型卡 （Model Card）是模型发布时的文档，包含：
- 模型描述、架构、参数量
- 训练数据概况、评估基准成绩（如 MMLU、HumanEval）
- 已知偏见和伦理考量、使用限制
常见许可证 ：
- MIT、Apache 2.0：宽松，允许商用，需署名
- Llama 社区许可证：Meta 定制，允许商用（月活小于7亿），但禁止使用模型输出训练其他模型
- GPL v3：具有"传染性"，衍生作品也需开源
成本估算 ：
- API：按输入+输出 token 数计费，例如 GPT-4o $5/1M input tokens，$ 15/1M output tokens
- 本地：GPU 租赁（如 A100 约 $1-2/小时），或购买硬件（单卡 4090 约 ¥1.5万）
- 推理速度：不同模型大小、量化方式对吞吐量影响很大

图解演示：一个典型的 Model Card 结构

复制代码

┌─────────────────────────────────────────┐
│             Model Card: Llama-3-8B       │
├─────────────────────────────────────────┤
│ 开发者: Meta                             │
│ 架构: Transformer Decoder               │
│ 参数: 8B                                │
│ 上下文长度: 8K tokens                    │
│ 训练数据: 超过 15T tokens 的公开数据      │
│ 评测成绩:                                │
│   MMLU: 65.3                            │
│   HumanEval: 62.2                       │
│ 已知偏见: 可能包含西方文化偏见            │
│ 许可证: Llama 3 社区许可证               │
│ 用途: 研究、商业（限制有害用途）          │
└─────────────────────────────────────────┘

演示用例：估算 API 成本

python 复制代码

# 假设一段对话的 token 用量
input_tokens = 150
output_tokens = 80

# GPT-4o 价格（示例，请以官网为准）
input_price_per_1k = 0.005   # 每千 token 美元
output_price_per_1k = 0.015

cost = (input_tokens * input_price_per_1k + output_tokens * output_price_per_1k) / 1000
print(f"一次对话成本：${cost:.6f}")

# 假设每天 500 次类似对话
daily_cost = cost * 500
monthly_cost = daily_cost * 30
print(f"每月 API 估算成本：${monthly_cost:.2f}")

# ---- 本地部署成本估算 ----
# 假设租用 A100 GPU，$1.5/小时，每天推理 10 小时
gpu_hourly = 1.5
daily_gpu_cost = gpu_hourly * 10
monthly_gpu_cost = daily_gpu_cost * 30
print(f"每月 GPU 租赁估算成本：${monthly_gpu_cost:.2f}")

输出结果

复制代码

一次对话成本：$0.001950
每月 API 估算成本：$29.25
每月 GPU 租赁估算成本：$450.00

AI 应用场景：在将任何模型集成到产品前，先读模型卡了解其能力和偏见，检查许可证确保商用合规，并用成本估算模型规划预算------这是专业 AI 应用开发者的标准流程。对于 Llama 等开源模型，务必留意社区许可中"禁止用输出训练其他模型"的特殊限制。

总结

从 Transformer 的自注意力机制、文本到向量的转换流程，到解码策略的温度/采样控制，你已建立对 LLM 内部工作的深层理解。中级篇用对比和图表帮你选型，并教会你阅读模型卡、理解许可证和估算成本。每个概念都配有可操作代码和直观图解，新术语也在第一时间被详细拆解。现在你可以自信地进入大语言模型的世界，开始自己的探索与实践了。