外观
大模型知识
约 3222 字大约 11 分钟
AI
2025-02-06
大模型(Large Language Model)
根据你输入的一串文字(Token),预测下一个最可能出现的文字(Token).
LLM是自回归模型,什么叫自回归模型:就是根据前面的内容,预测下一个最可能的内容。
回归模型:用一组外部变量去预测另一组变量;(根据地段、面积预测房价;身高年龄预测体重)
自回归模型: 专门用自身历史数据预测未来的一种时间序列回归模型(昨、前天的气温预测今天;前几月销量预测下个月;过去几天的股票价格预测明天的)
他需要巨量的知识!其本质就是一个"文本压缩复读机"。 把人类互联网上的海量数据(模型参数动辄千亿万亿)去重压缩,你问他问题他关联一下再解压出来给你。他知道"我爱"之后大概率跟"你",知道"苹果"这个词后大概率会跟着"手机"或者"很好吃",但他压根不知道什么是苹果。
大模型参数的7B、8B、671B的含义
参数规模的含义
- B表示十亿(Billion)参数
- 7B:70亿参数
- 671B:6710亿参数
- 参数数量直接影响模型的复杂度和显存需求
参数 ≈ 模型学到的所有 “知识 + 规律” 的总重量。它不是文件大小本身,但文件大小基本由它决定。
"涌现"
当模型的大小大到一定量级,量变就引起了质变,他就变聪明了,有了智能的感觉,上下文学习、思维链的概念,写代码,做题,逻辑推理。
占用空间,精度
FP32、FP16、INT8、INT4,本质是模型参数的存储格式
一个参数要占一定空间:
- FP32:32位 1 个参数 ≈ 4 字节
- FP16:16位 1 个参数 ≈ 2 字节
- INT8:8位 1 个参数 ≈ 1 字节
- INT4:4位 1 个参数 ≈ 0.5 字节
所以:
- 0.6B FP16 ≈ 1.1GB
- 1.5B FP16 ≈ 2.8GB
- 7B FP16 ≈ 13GB
- 8B FP16 ≈ 15GB
- 67B FP16 ≈ 125GB
- 71B FP16 ≈ 132GB
量化后会更小:
- INT4 一般就是 FP16 的 1/4 左右

所谓的量化就是降低精度,减少模型存储的大小,让模型运行更快体积更小 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
模型量化
将模型的权重从高精度浮点类型,映射到低精度整数类型(如 INT8/INT4),通过缩放与偏移减少数值范围与表示位数,从而减小模型体积、提升推理速度,同时尽可能保持模型效果。
模型量化也是一个用于优化机器学习模型的方法,但它侧重于减少模型的大小和计算开销,而不是简化模型的功能。
量化的步骤
- 参数量化:将高精度的权重和偏置转换为低精度的形式(如8位整数)。
- 模型训练或推理优化:在量化过程中,确保量化后的参数仍然能够保持模型的性能
把原模型中的复杂参数(比如高精度的数字)转换为更简洁的形式(比如更低精度的整数),从而缩小模型的大小,并降低计算成本。同时,量化后的模型仍然能够完成差不多的任务。
- FP32 → FP16 几乎 = 没影响
- FP16 → INT8
- 极轻微的精度损失
- 正常聊天、写代码、问答 = 基本看不出区别
- 只有非常复杂的数学、超长逻辑推理可能弱一丢丢
- FP16 → INT4
- 能感觉到一点点变 “笨”
- 偶尔语句没那么顺
- 复杂逻辑、长文理解稍微下降
- 数学、代码可能偶尔出错
举例
1.23567841 在各个精度下的值
| 格式 | 二进制示例 | 占用 | 值 | 误差 | 有效数字 |
|---|---|---|---|---|---|
| FP32 | 0 01111111 00111100010101010110110 | 32 bits (4B) | 1.23567843 | ~0 | ~7 位 |
| FP16 | 0 01111 0011110001 | 16 bits (2B) | 1.23535156 | 0.00033 | ~3-4 位 |
| INT4-A | 0101 | 4 bits (0.5B) | 1.33333333 | 0.09765 | ~1-2 位 |
| INT4-B | 0110 | 4 bits (0.5B) | 1.20000000 | 0.03568 | ~1-2 位 |
可以理解为用普通的尺子和用游标卡尺、千分尺量东西的区别,都是一个长度,但是精度不同
参数究竟是啥?
说了这么多,参数究竟是什么? 一个模型里有数千亿乃至万亿个参数,它们到底是啥玩意?
💡 核心定义
本质是数学概念:一个不直接参与变量变化,但用来确定整体形式的量。
通俗理解:就是参与计算的一个固定量。
1. 从直线方程理解
比如最简单的直线方程:
y=ax+b
在这里,a 和 b 就是参数!
- 只要你找到了 a,b 的值,你就能掌握一条直线上所有点的分布。
- 随便给你一个 x 的点,你都能得到对应的 y 点。 换种专业的说法:只要找到了合适的拟合方法,这条线上所有点的分布规律,就被压缩到了 a,b 这两个参数上。
2. 大模型的参数有何不同?
大模型做的事,本质上和拟合直线一样,也是把文字、图片、声音的分布规律压缩到参数里。但区别在于复杂度,所以需要的参数极多,拟合他的方法也非常复杂,以此衍生除了自注意力机制、transformer架构,反向传播算法之类的。
| 特性 | 直线方程 | 大模型 (LLM) |
|---|---|---|
| 规律复杂度 | 简单 (二维) | 极高 (文字/图片/声音) |
| 拟合方法 | 简单计算 | 自注意力机制、Transformer、反向传播等 |
| 参数量级 | 2 个 (a,b) | 数百亿、数千亿甚至更多 |
虽然参数量巨大,但本质上跟拟合直线的原理一样!
3. 训练 vs 推理
模型训练 (Training)
- 输入:大量的文本、图片 (相当于 x 和 y)
- 目标:推导参数 (相当于求 a 和 b)
- 本质:从数据中学习规律,固化到参数中。
模型推理 (Inference)
- 输入:你的提问或聊天内容 (相当于 x)
- 工具:拿训练出来的参数 (相当于已知的 a,b)
- 输出:拟合结果 (计算 y 的值)
训练就是已知结果 去算参数,推理就是拿训练的参数 去算结果。
分词器
既让模型内存储的全是数字/小数,那他是如何理解我们问的问题和输出我们能理解的文字呢?
分词器(Tokenizer)
像一本字典,会把我们输入的文字转换成数字。比如: 你 -> 123; 好 -> 456; 这样模型去计算出另一串数字,然后再通过分词器把计算出来的数字转换成我们能懂的话
- 文字 → Tokenizer → 数字
- 数字 → Transformer 一顿算 → 下一个数字
- 数字 → Tokenizer 反查 → 文字
模型训练
模型训练的过程就是:猜数字 -> 猜错 -> 改数字 -> 再猜 重复无数次(几十亿几百亿)
- 1.开始:模型里全是「随机数」
- 所有参数(权重)都是随机小数
- 你问它啥,它都乱输出
- 相当于:婴儿无法表达 乱哭
- 2.给模型看巨量文本
- 比如给他看一句话:我今天去超市买了__果
- 模型看到的是101, 209, 333, 456, __ , 777
- 3.让模型「预测下一个数字」
- 模型用当前的随机数字瞎猜:
- 猜:888 → 对应文字:车
- 猜:123 → 对应文字:你
- 明显都是错的
- 模型用当前的随机数字瞎猜:
- 4.计算「错了多少」—— Loss(损失)
- 标准答案是:水果 → 对应数字 666
- 系统告诉模型:
- 你离正确答案差多少
- 这个差值叫 Loss(损失)
- 5.反向传播:把所有数字「微调一下」
- 这一步叫 Backpropagation
- 把内部所有参数,往 “能猜对” 的方向,轻轻改一点点。
- 就像调收音机旋钮:
- 这次偏左 → 下次往右调一点
- 这次偏右 → 下次往左调一点
- 目标:让下一次预测,更接近正确答案。
- 这一步叫 Backpropagation
- 6.重复:几百亿~几千亿次
用海量文本逼着模型不断猜下一个词, 猜错就微调内部数字, 直到数字组合能稳定输出正确文字。
模型不学习语言,不学习知识 它只学习:在什么数字后面,接什么数字概率最高。
损失与反向传播
损失: 量化“模型猜错的程度”—— Loss值越大,错得越离谱;Loss值越小,越接近正确答案。
反向传播:模型内有很多层,根据loss值 从模型的最后一次往第一层倒着算,分责任 每一层错了多少,再根据调整
- 损失值由喂给模型的数据和函数决定
怎么算呢,比如训练一个模型让他计算1+2=? 模型内部最开始只有2个参数 w1=0.5 w2=0.8(初始的随机数)
1.前向计算(得到loss):
输入:x1=1(第一个数)、x2=2(第二个数)
计算:y = x1*w1 + x2*w2 (模型猜的答案)
正确答案:y_true=3(1+2的真实结果)第一步计算的结果是:y = 1 * 0.5 + 2 * 0.8 = 0.5 + 1.6 = 2.1
模型猜的结果是2.1 正确答案是3,错了0.9 (LOSS=0.9)
2.反向传播
找责任,找梯度。错的0.9 让w1、w2分别承担多少
- 1.导数求导
导数:一个参数变一点,结果会变多少
使用导数来计算错误的责任比例。 核心依据:导数(梯度)= 错误的“责任比例”
dLoss/dy = 2*(y - y_true) = 2*(2.1-3) = -1.8dLoss/dw1 = dLoss/dy × dy/dw1 = -1.8 × 1 = -1.8(w1 的梯度)dLoss/dw2 = dLoss/dy × dy/dw2 = -1.8 × 2 = -3.6(w2 的梯度)
2.根据导数改参数(微调)
规则:新参数 = 旧参数 - 学习率*导数(学习率是 “每次改多少”,比如取 0.1)
- 新 w1 = 0.5 - 0.1*(-1.8) = 0.5 + 0.18 = 0.68
- 新 w2 = 0.8 - 0.1*(-3.6) = 0.8 + 0.36 = 1.16
- 重新计算:y = 1 * 0.68 + 2 * 1.16 = 0.68 + 2.32 = 3.0 → 刚好等于正确答案!
如果学习率取0.2呢:
| 学习率 | 新 w1 | 新 w2 | 调整后 y 值 | 离正确答案(3)的误差 | 效果分析 |
|---|---|---|---|---|---|
| 0.1 | 0.68 | 1.16 | 3.0 | 0(完全正确) | 刚好改到正确值,收敛完美 |
| 0.2 | 0.86 | 1.52 | 3.9 | +0.9(改过头了) | 调整幅度过大,从 “猜太小” 变成 “猜太大” |
大模型的启示:训练初期模型参数全是随机数(离最优值极远),如果一开始用大学习率,参数会 “乱晃”;所以实际训练中,会先小步慢调,再逐步微调
总结:
- 先算最后一步的错误(Loss):知道模型错了多少;
- 从后往前拆责任:顺着 “y→w2→w1” 的计算路径,倒着算每个参数对错误的 “贡献度”(导数);
- 按责任改参数:责任大的参数(比如 w2 的导数 - 3.6)改得多,责任小的改得少;
- 目标:让下一次前向计算的结果更接近正确答案。
实际大模型的反向传播
- 参数不是 2 个,而是几十亿个;
- 计算路径不是 “y=x1w1+x2w2”,而是几十层 Transformer;
- 导数计算不是手动算,而是框架(PyTorch/TensorFlow)自动算。 但核心不变:从 Loss 倒着算每个参数的梯度,按梯度微调参数,让模型下次猜词更准。
模型蒸馏
提取出模型的核心知识,然后用更简单、更方便的方式把它表现出来——比如用一个更小、更快的模型来模拟它。
蒸馏步骤:
- 知识提取:将复杂模型的核心“知识”(比如决策逻辑和特征提取)传递给一个更简单的模型。
- 性能保持:确保这个简单模型能够像原来的大模型一样完成任务,并且有相似的性能表现。
模型蒸馏可以想象为从一个“懂很多知识体系”的模型中提取出关键的知识或信息,形成一个新的更简单、更高效的模型(就像简化版的知识体系)。这就好比从一本厚重的手册中提炼出几个核心要点,让新的人能够快速掌握原来的内容。
具体来说,蒸馏后的模型就像是一个经过精简和提炼的“浓缩版”,它保留了原模型的核心能力和功能,但去掉了复杂性和冗余的部分。这样,新的模型就能更高效地完成任务,就像简化版的知识体系更容易理解和使用一样。
简单的说来就是在别人的桶里钓鱼!
需要多大的GPU
显存需求计算
- 存储参数
- 数据类型:通常使用FP32(4字节)、FP16(2字节)、INT8(1字节)
- 计算公式
显存 = 参数数量 * 每参数字节数
7B模型(FP32) = 7×10⁹ × 4B ≈ 28 GB 7B模型(FP16)= 7×10⁹ × 2B ≈ 14 GB
