【AI】大语言模型基础知识详解

大语言模型基础知识详解

前言

ChatGPT 火了之后，"大模型"这个词天天出现在各种新闻里。但很多人其实不太清楚：大模型到底是什么？它是怎么"理解"我们说的话的？为什么有时候它会胡说八道？这篇文章用最通俗的方式，带你搞懂大语言模型的核心原理。

🏠个人主页：你的主页

---

文章目录

• 大语言模型基础知识详解
  • 一、什么是大语言模型
  • 二、大模型的大体现在哪里
  • 三、Token是什么
  • 四、词表是什么
  • 五、大模型是怎么工作的
  • 六、大模型是怎么预测下一个词的
  • 七、大模型是怎么训练出来的
  • 八、为什么有些模型中文很差
  • 九、大模型的局限性
  • 十、总结

---

一、什么是大语言模型

1.1 一句话定义

大语言模型（Large Language Model，简称 LLM） 就是一个用海量文本数据训练出来的"超级文字接龙机器"。

你给它一段话的开头，它就能接着往下写。

1.2 它能干什么

打个比方：大模型就像一个读过几乎所有书、看过几乎所有网页的"学霸"。你问它任何问题，它都能根据自己"读过的内容"给你一个回答。

任务类型	举例
文本生成	你说"帮我写一封请假邮件"，它就能写出来
问答	你问"Python 怎么读取文件"，它告诉你代码
翻译	你说"把这段话翻译成英文"，它就翻译
总结	你给它一篇长文章，它帮你提炼要点
代码生成	你描述需求，它帮你写代码

1.3 它的本质是什么

核心原理只有一句话：

大模型本质上就是在不断预测"下一个词是什么"

你输入"今天天气"，它预测下一个词可能是"真好"、"不错"、"很热"...然后选一个概率最高的输出。

输出"真好"之后，它再预测"今天天气真好"后面应该接什么，可能是"适合"、"出去"...

就这样一个词一个词地往下接，直到它觉得该结束了。

所以：ChatGPT 并不是真的"理解"你说的话，它只是在做一个超级复杂的"文字接龙"游戏。

---

二、大模型的大体现在哪里

"大"语言模型，到底大在哪？主要体现在两个方面。

2.1 训练数据大

大模型需要"读"海量的文本才能变得"聪明"。

以 GPT-3 为例，它的训练数据来源：

数据来源	占比	说明
网络爬虫数据	60%	从高质量网站爬取的内容
论坛帖子	22%	Reddit 等论坛的讨论
电子书	16%	各种书籍的电子版
维基百科	3%	英文维基百科全部内容

总量 ：大约 3000 亿个 Token（后面会解释什么是 Token）。

打个比方 ：如果一本书有 10 万字，3000 亿 Token 相当于 300 万本书。一个人一辈子也读不完这么多书，但大模型在训练时全部"读"过了。

2.2 参数量大

参数是大模型的"大脑神经元"，参数越多，模型越"聪明"（理论上）。

OpenAI 各代模型的参数量：

模型	参数量	类比
GPT-1（2018）	1.17 亿	一个小镇的人口
GPT-2（2019）	15 亿	一个大城市的人口
GPT-3（2020）	1750 亿	全球人口的 20 倍
GPT-4（2023）	估计上万亿	难以想象

参数到底是什么？

参数就是一堆浮点数 （小数），比如 0.123456、-0.789012。

这些数字存储了模型从训练数据中"学到的知识"。

参数和模型大小的关系：

• 每个参数通常占 4 字节（32位浮点数）
• 7B 模型 = 70 亿参数 ≈ 70亿 × 4 字节 ≈ 28GB
• 这就是为什么大模型需要高端显卡才能运行

常见模型大小标记：

标记	含义	参数量
7B	7 Billion	70 亿
13B	13 Billion	130 亿
70B	70 Billion	700 亿
175B	175 Billion	1750 亿

2.3 大数据 + 大参数 = 通用能力

以前的 AI 模型都是"专才"：

• 翻译模型只能翻译
• 情感分析模型只能分析情感
• 问答模型只能问答

但大模型是"通才"，一个模型能干所有事情。这就是涌现能力（Emergent Abilities）------当模型足够大时，会突然"涌现"出一些小模型没有的能力。

打个比方：小模型像是只会一道菜的厨师，大模型像是什么菜都会做的大厨。

---

三、Token是什么

3.1 Token 的定义

Token 是大模型处理文本的基本单位，可以理解为"文本碎片"。

它不是"字"，也不是"词"，而是模型自己定义的一种切分方式。

3.2 Token 的例子

英文的 Token 切分：

"Hello, how are you?"
↓ 切分成 Token
["Hello", ",", " how", " are", " you", "?"]

注意：空格也可能是 Token 的一部分。

中文的 Token 切分：

"今天天气真好"
↓ 切分成 Token（不同模型切法不同）
["今天", "天气", "真", "好"]  # 可能这样
["今", "天", "天", "气", "真", "好"]  # 也可能这样

3.3 为什么要用 Token

问题：为什么不直接用"字"或"词"作为单位？

答案：因为语言太复杂了。

• 如果用"字"：英文 26 个字母太少，表达不了复杂语义
• 如果用"词"：词的数量太多（几十万个），而且新词不断出现

Token 是一种折中方案，通过算法（如 BPE）自动学习出一套切分规则，既不会太细，也不会太粗。

3.4 Token 和计费的关系

大模型 API 通常按 Token 数量计费：

模型	输入价格	输出价格
GPT-4	$0.03 / 1K tokens	$0.06 / 1K tokens
GPT-3.5	$0.0015 / 1K tokens	$0.002 / 1K tokens
Claude 3	$0.015 / 1K tokens	$0.075 / 1K tokens

估算规则：

• 英文：1 个 Token ≈ 4 个字符 ≈ 0.75 个单词
• 中文：1 个 Token ≈ 1-2 个汉字

3.5 上下文长度

上下文长度（Context Length） 是模型能处理的最大 Token 数量。

模型	上下文长度
GPT-3.5	4K / 16K
GPT-4	8K / 32K / 128K
Claude 3	200K
Gemini 1.5	1M（100万）

打个比方：上下文长度就像模型的"短期记忆"。16K 的模型只能"记住"最近 16000 个 Token 的内容，超过的部分就"忘了"。

这就是为什么和 ChatGPT 聊太久，它会"忘记"之前说过的话。

---

四、词表是什么

4.1 词表的定义

词表（Vocabulary） 是模型认识的所有 Token 的"字典"。

每个 Token 都有一个唯一的 ID（编号），模型内部只认 ID，不认文字。

4.2 词表长什么样

{
  "<|endoftext|>": 0,      // 特殊符号：文本结束
  "<|startoftext|>": 1,    // 特殊符号：文本开始
  "!": 2,
  "\"": 3,
  "#": 4,
  ...
  "hello": 15339,
  "world": 14957,
  ...
  "今天": 38014,
  "天气": 45892,
  "程序员": 52341,
  ...
}

4.3 词表大小

不同模型的词表大小差异很大：

模型	词表大小
GPT-2	50,257
GPT-3/4	100,000+
LLaMA	32,000
ChatGLM	130,000+
Qwen	150,000+

词表大小的影响：

• 词表太小：很多词需要拆成多个 Token，效率低
• 词表太大：模型参数增加，训练和推理变慢

4.4 特殊 Token

词表中有一些特殊的 Token，用于控制模型行为：

Token	作用
`<	endoftext
`<	startoftext
`<	pad
`<	unk
`<	im_start
`<	im_end

---

五、大模型是怎么工作的

5.1 完整工作流程

当你输入"北京的天气"时，大模型内部发生了什么？

步骤1：分词（Tokenization）
"北京的天气" → ["北京", "的", "天气"]

步骤2：转换为 Token ID
["北京", "的", "天气"] → [38014, 8024, 45892]

步骤3：输入模型，计算概率
模型输出词表中每个 Token 的概率：
{
  "怎么样": 0.35,
  "很好": 0.25,
  "预报": 0.15,
  "是": 0.08,
  ...
}
所有概率加起来 = 1

步骤4：选择概率最高的 Token
选中 "怎么样"（概率 0.35 最高）

步骤5：拼接到输入后面
"北京的天气" + "怎么样" = "北京的天气怎么样"

步骤6：重复步骤 3-5
输入 "北京的天气怎么样"，预测下一个词...
继续循环，直到输出结束符或达到最大长度

步骤7：得到最终结果
"北京的天气怎么样？今天北京晴，气温 15-25 度..."

5.2 图解工作流程

┌─────────────────────────────────────────────────────────────┐
│                    大模型工作流程                            │
└─────────────────────────────────────────────────────────────┘

用户输入: "写一首关于春天的诗"
              │
              ▼
┌─────────────────────────────────────────┐
│           分词器（Tokenizer）            │
│  "写一首关于春天的诗" → [ID1, ID2, ...]  │
└─────────────────────────────────────────┘
              │
              ▼
┌─────────────────────────────────────────┐
│           大语言模型（LLM）              │
│                                         │
│  输入: [ID1, ID2, ID3, ...]             │
│                 ↓                       │
│  计算词表中每个词的概率                  │
│                 ↓                       │
│  输出: "春" (概率最高)                   │
└─────────────────────────────────────────┘
              │
              ▼
┌─────────────────────────────────────────┐
│              循环预测                    │
│                                         │
│  "写一首关于春天的诗" + "春"             │
│           ↓ 继续预测                    │
│  "写一首关于春天的诗春" + "风"           │
│           ↓ 继续预测                    │
│  "写一首关于春天的诗春风" + "拂"         │
│           ↓ ...                         │
│  直到输出结束符                          │
└─────────────────────────────────────────┘
              │
              ▼
最终输出: "春风拂面暖阳照，万物复苏百花开..."

5.3 为什么每次回答不一样

你可能发现，同样的问题问 ChatGPT 两次，回答可能不一样。

原因：模型不是每次都选概率最高的词，而是有一定的"随机性"。

这个随机性由 Temperature（温度） 参数控制：

Temperature	效果
0	完全确定，每次选概率最高的词，回答固定
0.7	适度随机，回答有变化但不会太离谱
1.0	较高随机，回答更有创意但可能跑题
2.0	非常随机，回答可能很奇怪

打个比方：

• Temperature = 0：像一个严谨的学者，每次都给标准答案
• Temperature = 1：像一个有创意的作家，每次都有新想法

---

六、大模型是怎么预测下一个词的

6.1 方法一：基于统计（最朴素的想法）

原理：统计大量文本中，某个词后面最常出现什么词。

举个例子：

假设我们统计了 100 万条句子，发现：

"我今天" 后面出现的词：
- "很开心" → 出现 5000 次
- "去上班" → 出现 3000 次
- "吃火锅" → 出现 2000 次
- "学习了" → 出现 1500 次
...

当用户输入"我今天"时，模型查表发现"很开心"出现次数最多，就输出"很开心"。

问题：如果用户输入的内容从来没出现过怎么办？

比如用户输入"我今天和外星人"，统计表里根本没有这个组合，模型就懵了。

6.2 方法二：基于向量（现代大模型的做法）

核心思想：把文字变成数字（向量），用数学计算代替查表。

什么是向量？

向量就是一组数字，比如 [0.12, -0.34, 0.56, 0.78, ...]。

在大模型中，每个 Token 都会被转换成一个几百到几千维的向量。

举个例子：

"国王" → [0.82, 0.15, -0.43, 0.67, ...]  (假设 4 维)
"王后" → [0.79, 0.18, -0.41, 0.65, ...]
"男人" → [0.45, 0.32, -0.12, 0.28, ...]
"女人" → [0.42, 0.35, -0.10, 0.26, ...]

神奇的事情：

向量之间可以做数学运算，而且结果有语义意义！

国王 - 男人 + 女人 ≈ 王后

[0.82, 0.15, -0.43, 0.67]   # 国王
- [0.45, 0.32, -0.12, 0.28]  # 男人
+ [0.42, 0.35, -0.10, 0.26]  # 女人
= [0.79, 0.18, -0.41, 0.65]  # ≈ 王后

这说明向量确实捕捉到了词语的语义关系。

预测下一个词的过程：

1. 把输入 "我今天和外星人" 转换成向量
   → [0.23, -0.45, 0.67, ...]

2. 把词表中每个词也转换成向量
   "吃饭" → [0.12, -0.34, 0.56, ...]
   "聊天" → [0.21, -0.43, 0.65, ...]
   "打架" → [0.45, -0.12, 0.23, ...]
   ...

3. 计算输入向量和每个词向量的"距离"
   距离越近，说明这个词越可能是下一个词

4. 找到距离最近的词，输出
   假设 "聊天" 距离最近 → 输出 "聊天"

优势：即使"我今天和外星人"从来没出现过，模型也能通过向量计算找到合理的下一个词。

6.3 实际大模型更复杂

真正的大模型不只是简单的向量计算，还包括：

技术	作用
Transformer 架构	处理序列数据的神经网络结构
注意力机制（Attention）	让模型关注输入中最重要的部分
多层堆叠	GPT-3 有 96 层，每层都在提取更高级的特征
位置编码	让模型知道每个词的位置

但核心思想不变：把文字变成向量，用数学计算预测下一个词。

---

七、大模型是怎么训练出来的

7.1 训练的目标

训练的目标很简单：让模型能够准确预测下一个词。

7.2 训练数据

现代大模型的训练数据通常在 2 万亿 Token 以上。

数据来源包括：

• 网页内容（Common Crawl）
• 书籍（Books3、Gutenberg）
• 代码（GitHub）
• 论文（arXiv）
• 维基百科
• 社交媒体
• ...

7.3 训练流程（以训练"程序员写代码"为例）

┌─────────────────────────────────────────────────────────────┐
│                    大模型训练流程                            │
└─────────────────────────────────────────────────────────────┘

训练数据: "程序员写代码"

第1轮：
┌─────────────────────────────────────────┐
│ 输入: "程"                               │
│ 期望输出: "序"                           │
│ 模型输出: "hello"（随机初始化，瞎猜的）   │
│ 损失: 很大（差得远）                      │
│ 更新参数，让模型下次更可能输出 "序"       │
└─────────────────────────────────────────┘

第2轮：
┌─────────────────────────────────────────┐
│ 输入: "程序"                             │
│ 期望输出: "员"                           │
│ 模型输出: "设"（还是不对）               │
│ 损失: 较大                               │
│ 继续更新参数                             │
└─────────────────────────────────────────┘

第3轮：
┌─────────────────────────────────────────┐
│ 输入: "程序员"                           │
│ 期望输出: "写"                           │
│ 模型输出: "写"（对了！）                 │
│ 损失: 很小                               │
│ 参数微调                                 │
└─────────────────────────────────────────┘

... 重复几万亿次 ...

最终：模型学会了预测下一个词

7.4 关键概念

损失函数（Loss）：

衡量模型预测和正确答案之间的差距。损失越小，模型越准确。

梯度下降（Gradient Descent）：

一种优化算法，通过计算损失对参数的导数，找到让损失变小的参数更新方向。

打个比方：

• 损失函数就像考试分数（越高越差）
• 梯度下降就像根据错题分析，找到提分的方法
• 训练就是不断做题、分析、改进的过程

7.5 训练成本

训练大模型非常昂贵：

模型	估计训练成本
GPT-3	约 460 万美元
GPT-4	约 1 亿美元
LLaMA 65B	约 230 万美元

这还不包括研发人员工资、数据收集成本等。

---

八、为什么有些模型中文很差

8.1 根本原因：词表中中文 Token 太少

模型能处理什么语言，取决于词表里有什么 Token。

举个例子：

假设一个模型的词表只有：

["hello", "world", "the", "a", "is", ...]  // 全是英文

当你输入中文"你好"时，模型根本不认识，只能把它当作 <unk>（未知词）处理。

8.2 中文 Token 少的后果

后果一：中文被拆得很碎

英文模型处理 "hello"：
"hello" → 1 个 Token

英文模型处理 "你好"：
"你好" → 可能被拆成 6 个字节 Token

同样的内容，中文需要更多 Token，导致：

• 上下文长度被浪费
• API 调用费用更高
• 处理速度更慢

后果二：中文理解能力差

词表中中文 Token 少，意味着训练时中文数据也少，模型对中文的"理解"自然就差。

8.3 中文友好的模型

专门为中文优化的模型，词表中会包含大量中文 Token：

模型	词表大小	中文支持
GPT-3.5/4	100K+	一般
Claude	100K+	较好
ChatGLM	130K+	很好
Qwen（通义千问）	150K+	很好
Baichuan	64K+	很好

8.4 如何判断模型的中文能力

方法一：看 Token 数量

# 用 tiktoken 库测试
import tiktoken

enc = tiktoken.encoding_for_model("gpt-4")
text = "人工智能正在改变世界"

tokens = enc.encode(text)
print(f"Token 数量: {len(tokens)}")
print(f"Tokens: {tokens}")

如果一句简单的中文被拆成很多 Token，说明中文支持不好。

方法二：直接测试

问一些需要中文语言知识的问题：

• 成语接龙
• 古诗词补全
• 中文谐音梗

---

九、大模型的局限性

了解大模型的原理后，我们就能理解它的局限性了。

9.1 幻觉（Hallucination）

现象：大模型会一本正经地胡说八道，编造不存在的事实。

原因：大模型只是在预测"下一个词最可能是什么"，它并不知道自己说的是真是假。

举个例子：

用户：鲁迅和周树人是什么关系？

ChatGPT（可能的回答）：
鲁迅和周树人是同时代的两位著名作家，他们曾经有过一些学术交流...

实际上鲁迅就是周树人，但模型不"知道"这个事实，它只是根据概率在接龙。

9.2 知识截止日期

现象：大模型不知道训练数据之后发生的事情。

原因：模型的知识来自训练数据，训练完成后就"定格"了。

模型	知识截止日期
GPT-3.5	2021 年 9 月
GPT-4	2023 年 4 月
Claude 3	2024 年初

9.3 数学计算能力差

现象：大模型经常算错数学题。

原因：大模型是"文科生"，它是通过文本模式匹配来"算"数学的，而不是真的在计算。

用户：123456 × 789 = ?

大模型的思考过程：
"嗯，这个数字看起来像是...97406784？"
（实际答案是 97406784，但模型是"猜"的，不是算的）

对于复杂计算，大模型经常出错。

9.4 上下文长度限制

现象：聊天太久，模型会"忘记"之前说过的话。

原因：模型只能处理有限长度的 Token，超出部分会被截断。

解决方案：

• 使用更长上下文的模型（如 Claude 200K）
• 使用 RAG（检索增强生成）技术
• 定期总结对话内容

9.5 无法访问实时信息

现象：大模型不知道今天的天气、最新的新闻。

原因：大模型是离线训练的，不能上网。

解决方案：

• 使用联网插件（如 ChatGPT 的 Browse）
• 使用 Function Calling 调用外部 API
• 使用 RAG 检索最新文档

9.6 局限性总结

局限性	原因	解决方案
幻觉	只是概率预测，不知真假	人工核实、RAG
知识过时	训练数据有截止日期	联网搜索、RAG
数学差	文本模式匹配，不是真计算	调用计算器工具
忘记上文	上下文长度限制	长上下文模型、总结
无实时信息	离线模型，不能上网	联网插件、API

---

十、总结

10.1 核心概念速查表

术语	含义
LLM	Large Language Model，大语言模型
Token	文本片段，模型处理的基本单位
词表	模型认识的所有 Token 的字典
参数	模型的"大脑神经元"，存储学到的知识
上下文长度	模型能处理的最大 Token 数量
Temperature	控制输出随机性的参数
幻觉	模型编造不存在的事实
B	Billion，10 亿（7B = 70 亿参数）

10.2 核心原理一句话

大模型本质上就是一个超级复杂的"文字接龙"机器，通过预测"下一个词最可能是什么"来生成文本。

10.3 大模型的能力来源

┌─────────────────────────────────────────────────────────────┐
│                    大模型能力三要素                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. 海量训练数据（几万亿 Token）                             │
│     → 让模型"见多识广"                                      │
│                                                             │
│  2. 巨大参数量（几百亿到上万亿）                             │
│     → 让模型能"记住"更多模式                                │
│                                                             │
│  3. 先进的模型架构（Transformer + 注意力机制）               │
│     → 让模型能"理解"上下文关系                              │
│                                                             │
│  三者缺一不可，共同造就了大模型的强大能力                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

10.4 常见模型对比

模型	公司	参数量	特点
GPT-4	OpenAI	万亿级	综合能力最强
Claude 3	Anthropic	未公开	长上下文、安全性好
Gemini	Google	未公开	多模态能力强
LLaMA 3	Meta	8B/70B	开源、可本地部署
Qwen	阿里	7B-72B	中文能力强、开源
ChatGLM	智谱	6B-130B	中文能力强、开源

10.5 学习建议

1. 先会用，再理解原理：先用 ChatGPT 等产品，感受大模型能做什么
2. 理解 Token 概念：这是理解大模型的基础
3. 了解局限性：知道大模型不能做什么，避免踩坑
4. 关注 Agent 和 RAG：这是大模型落地应用的关键技术

---

热门专栏推荐

• Agent小册
• Java基础合集
• Python基础合集
• Go基础合集
• 大数据合集
• 前端小册
• 数据库合集
• Redis 合集
• Spring 全家桶
• 微服务全家桶
• 数据结构与算法合集
• 设计模式小册
• 消息队列合集

等等等还有许多优秀的合集在主页等着大家的光顾，感谢大家的支持

文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😊

希望能和诸佬们一起努力，今后我们一起观看感谢您的阅读🙏

如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🌟