# 本地 LLM 硬件要求：一个模型需要多少显存

> 本地模型需要的内存，等于权重占用的空间，再加上对话占用的空间。权重大约是参数量乘以每个权重的位数，再除以八。在 llama.cpp 公布的表格里，4 位 Q4_K_M 级别的 Llama 3.1 8B 占 4.9 GB，所以放进一张 8 GB 显卡后还有一些余量。

Mindket 编辑部 · 发布于 2026-11-05 · 更新于 2026-11-05 · https://mindket.com/cn/learn/local-ai/local-llm-hardware

## 要点

- 在开始漫长的下载之前，先在纸上算好模型大小。
- 牺牲几位精度，换一个装得进显卡的模型。
- 内存预算要算上对话，而不只是文件。
- 在意回复速度时，让整个模型都留在显卡上。

## 开始之前：决定一切的几个数字

本地 LLM 的硬件要求，归根到底是内存。模型回答问题时必须待在内存里，而最快的位置是显存，也就是显卡上的内存。一个 LLM 需要多少显存，取决于模型名字里的两个数字，以及你自己选的一个设置。

挑下载之前，先弄清你的电脑有什么。在 Windows 上，任务管理器的“性能”标签页会列出每块 GPU 和它的专用显存。在 Mac 上，“关于本机”会显示内存大小，CPU 和 GPU 共用这块内存。在装了 NVIDIA 显卡的 Linux 上，`nvidia-smi` 会打印显卡的显存。把这些数字记下来。

如果你学过第 1 课或第 3 课，你已经以标签和下载选项的形式见过这些数字。这一课把它们换算成 GB。

- 参数量：模型内部学到的数字，以十亿计。名字里的 8B 表示大约 80 亿个。
- 每权重位数：存一个参数用多少位。F16 文件每个参数用 16 位，常见的 4 位文件略低于 5 位。
- 上下文长度：按 Ollama 文档的说法，是模型在内存里能容纳的最大 token 数。
- 统一内存：Apple 芯片的 Mac 上，CPU 和 GPU 共用的同一块内存。
- 卸载到 CPU：模型装不进显存时，把一部分放到 CPU 上、用系统内存来运行。

## 算出一个模型需要多少内存

权重决定了下限。把参数量乘以每权重位数，再除以八，因为八位是一个字节。一个 Q4_K_M 级别的 8B 模型，就是 80 亿乘以 4.89 位再除以八，略低于 50 亿字节。

llama.cpp 的 [quantize README](https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/README.md) 对 Meta 的 Llama 3.1 三种大小给出了同样的结果，见下表。它还说，内存需求和硬盘需求相同，因为整个模型都会载入内存。所以每个下载选项旁边的文件大小，就是它占用内存的一个合理初步估计。

对话也要占空间。上下文里的每个 token 都会在 KV 缓存里留下数据。KV 缓存是“键值缓存”的缩写，存的是模型对前面 token 已经算好的结果。Ollama 的[上下文长度页面](https://docs.ollama.com/context-length)说，上下文越长，运行模型需要的内存越多。Ollama 默认按显存来定上下文：低于 24 GiB 用 4k，24 到 48 GiB 用 32k，再往上用 256k。

这个缓存可以压缩。Ollama 的 [FAQ](https://docs.ollama.com/faq) 允许你用 `OLLAMA_KV_CACHE_TYPE=q8_0` 把它存成 8 位，内存大约是默认 `f16` 的一半，或者用 `q4_0` 存成 4 位，大约四分之一。两者都需要 Flash Attention，这是一种计算注意力的方法，上下文越长省的内存越多。硬件支持时，Ollama 会自动打开它。

并行请求会让缓存翻倍。FAQ 说，需要的内存随并行请求数乘以上下文长度增长。它举的例子是：2K 上下文加上 4 个并行请求，就变成 8K 上下文。

最后留出余量。Hugging Face 的[内存估算页面](https://huggingface.co/docs/accelerate/usage_guides/model_size_estimator)说，它的数字只算载入，推理时还可能再多出最多 20%，这个数字来自 EleutherAI。它的工具 `accelerate estimate-memory` 读取的是 Transformers 库格式的模型，而不是 GGUF 文件。不过这个余量对两者都适用。

LM Studio 也能替你算。它的 lms load 命令可以加 `--estimate-only`，打印一份内存估算后就退出，不会真的载入模型。

````python
# memory for the weights alone: parameters x bits per weight / 8
def weights_gb(params_billion, bits_per_weight):
    return params_billion * bits_per_weight / 8

# bits per weight from llama.cpp's quantize README (Llama 3.1 8B)
for name, bpw in [("F16", 16.0005), ("Q8_0", 8.5008), ("Q4_K_M", 4.8944)]:
    print(name, round(weights_gb(8, bpw), 1), "GB before context")
````

1. 从模型名字里读出参数量，比如 8B 或 70B。
2. 选一种量化，记下它的每权重位数，比如 Q4_K_M 是 4.89。
3. 两者相乘再除以八，得到权重占多少 GB。
4. 加上你打算用的上下文所需的空间，再加一份推理余量。
5. 把总数和你的显存比较，Mac 就和统一内存比较。装不下的话，量化降一级，或者模型降一档。

| 模型大小 | 原始大小 | Q4_K_M 大小 |
| --- | --- | --- |
| 8B | 32.1 GB | 4.9 GB |
| 70B | 280.9 GB | 43.1 GB |
| 405B | 1,625.1 GB | 249.1 GB |

## 量化：GGUF 的 Q4、Q8 和中间的级别

量化就是用更少的位数存每个权重。llama.cpp 的 README 把它描述为降低权重的精度，比如从 32 位浮点数降到 4 位整数。GGUF 文件装着量化后的结果，文件名里的标签，比如 `Q4_K_M` 或 `Q8_0`，说明用的是哪种方法。

Q 后面的数字是大致的位宽。K 表示 k-quant 系列，它把权重分进共用缩放系数的超级块。Hugging Face 的 [GGUF 页面](https://huggingface.co/docs/hub/gguf)列出 Q4_K 是每权重 4.5 位，Q6_K 是 6.5625 位。它把 Q8_0 和 Q4_0 归为旧类型，做法是把每个权重四舍五入到最近的一档。以 IQ 开头的名字用了重要性矩阵，也就是记录哪些权重最重要的数据。

实际文件会比名义位宽略高一点，因为缩放系数也占空间。要看文件大小，而不是标签。

同一级别的 S、M、L 版本，大小略有不同。下面的图表是 llama.cpp 为那个 8B 模型公布的数字，单位是 GiB。1 GiB 是 1,073,741,824 字节，比 1 GB 稍多一点。

位数越少，质量可能越低。README 说量化可能带来一些精度损失，通常用困惑度或 KL 散度来衡量。困惑度衡量模型预测真实文本的能力。KL 散度衡量量化后的模型和原模型的预测差了多远。README 还说，合适的重要性矩阵文件可以减少这种损失，但它没有给出这些类型的具体分数。

两个应用都让你从中间起步。LM Studio 的[下载页面](https://lmstudio.ai/docs/app/basics/download-model)建议，只要电脑跑得动，就选 4 位或更高的版本。Ollama 不带标签地从 Hugging Face 拉取 GGUF 仓库时，按 Hugging Face 的 [Ollama 页面](https://huggingface.co/docs/hub/ollama)的说法，只要仓库里有 Q4_K_M，就用它。

README 也列了每种类型的速度，但没有说明用的是什么硬件，所以规划时以大小为准。

**各量化类型下的 Llama 3.1 8B，单位 GiB** 文件大小出自 llama.cpp 的 quantize README，模型是 meta-llama/Llama-3.1-8B，每个标签里写着每权重位数。金色那根是 Q4_K_M，你不带标签从 Hugging Face 仓库拉取时，Ollama 选的就是它。

- F16，16.0005 位: 14.96 GiB
- Q8_0，8.5008 位: 7.95 GiB
- Q6_K，6.5633 位: 6.14 GiB
- Q5_K_M，5.7036 位: 5.33 GiB
- Q4_K_M，4.8944 位: **4.58 GiB**
- Q3_K_M，3.9960 位: 3.74 GiB
- Q2_K，3.1593 位: 2.95 GiB

来源：[llama.cpp: quantize README](https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/README.md) (2026-11-05 查阅)

## CPU、GPU 还是 Apple 芯片

模型在哪里运行，决定了它回答得多快。GPU 能并行处理模型的计算，所以完全装进显存的模型回复最快。Ollama 的上下文长度页面说，想要最佳性能，就别把模型卸载到 CPU 上。

模型装不下时，两个工具都会把它拆开。[llama.cpp 的 README](https://github.com/ggml-org/llama.cpp) 把这叫作 CPU+GPU 混合推理，可以部分加速比总显存还大的模型。Ollama 的[快速入门](https://docs.ollama.com/quickstart)说，显存不够时它可以用系统内存，但回复可能会变慢。运行 `ollama ps`，看 PROCESSOR 这一列：`100% GPU`、`100% CPU`，或者 `48%/52% CPU/GPU` 这样的混合。

没有受支持 GPU 的电脑照样能运行模型，用的是 CPU 和系统内存。llama.cpp 在 x86 处理器上支持 AVX、AVX2、AVX512 和 AMX 指令集。LM Studio 在 x64 的 Windows 机器上要求 AVX2。同样的算法照样适用，只是上限换成了系统内存。

Apple 芯片的 Mac 不太一样。CPU 和 GPU 共用统一内存，所以 Mac 的内存大小，起的就是 PC 上显存的作用。这也是 Ollama 快速入门要求 8 GB 可用显存，或者 Mac 上同样大小统一内存的原因。

llama.cpp 说 Apple 芯片是一等公民，通过 Apple 的图形接口 Metal 做了优化。Ollama 在 M 系列 Mac 上同时用 CPU 和 GPU，在 Intel Mac 上只用 CPU。

在 PC 上，先确认你的显卡受支持。Ollama 的 [GPU 页面](https://docs.ollama.com/gpu)列出的 NVIDIA 显卡要求计算能力 5.0 或更高、驱动 550 或更新，其中最老的、到 6.2 为止的那些需要驱动 570。AMD 显卡需要 ROCm v7 驱动。Vulkan 是一种跨厂商的图形接口，在 Windows 和 Linux 上覆盖其他 GPU。

LM Studio 的[系统要求](https://lmstudio.ai/docs/app/system-requirements)给出了它这个应用的门槛：Windows 上建议 16GB 内存和 4GB 独立显存，Mac 上建议 16GB 或更多。

| 硬件 | Ollama | llama.cpp 后端 |
| --- | --- | --- |
| NVIDIA GPU | 计算能力 5.0 以上，加上较新的驱动 | CUDA |
| AMD GPU | ROCm v7 驱动 | HIP |
| Apple 芯片的 Mac | CPU 和 GPU，通过 Metal | Metal |
| Intel Mac | 只用 CPU | CPU |
| Windows 或 Linux 上的其他 GPU | Vulkan | Vulkan |
| 没有受支持的 GPU | CPU 和系统内存，较慢 | CPU，x86 上支持 AVX 到 AMX |

## Dan Woods 为什么从 Q2 退回 Q4

Dan Woods 是 CVS Health 的 AI 平台副总裁。三月，他在 [X 上](https://x.com/danveloper/status/2034686509748462022)的一条回复里说，工具调用这个指标，让他们从 2 位量化退回了 4 位。他写道，Q2 下的模型聊天很出色，但凡是需要可预期结果的工作，它都太不稳定。

Paul Gauthier 早在 2024 年就在 [X 上](https://x.com/paulgauthier/status/1859684310204473349)说过同样的意思，他链接的测试作为方法至今仍然适用。

按 [Aider 博客](https://aider.chat/2024/11/21/quantization.html)的结果，Qwen 2.5 Coder 32B 通过 Ollama 以 fp16 运行时，完成了代码编辑基准测试的 71.4%，q4_K_M 是 66.9%，q2_K 是 61.7%。用 fp16 加上 Ollama 当时 2k token 的默认上下文，成绩跌到 51.9%，因为较长的提示词被悄悄截断了，没有任何报错。

所以，先用上面的算法估出模型大小，再拿你自己的任务测试这个文件。如果智能体要调用工具或修改代码，就在 Q4_K_M 和 Q8_0 下各跑几个这样的任务，再决定要不要用更小的那个。上下文要设得够大，别让任何提示词被截断。

> “工具调用”成了让我们回到 Q4 的那个指标。
>
> Dan Woods, CVS Health 的 AI 平台副总裁，引文为译文, [X](https://x.com/danveloper/status/2034686509748462022) (2026-11-05 查阅)

[![Dan Woods（@danveloper）2026 年 3 月 19 日在 X 上回复 @simonw：是“工具调用”这个指标让我们回到了 Q4，Q2 在对话上很棒，但对需要可预期结果的事，就像把温度调到 10,000。](https://mindket.com/blog/shots/x-danveloper-back-to-q4.webp?v=4b486fde69d9)](https://x.com/danveloper/status/2034686509748462022)

Dan Woods 在 X 上，2026 年 3 月 19 日

[![Paul Gauthier（@paulgauthier）2024 年在 X 上说：留意你（或你的服务商）是怎样量化开源模型的，这会大大影响代码编辑能力。](https://mindket.com/blog/shots/x-paulgauthier-quantization-matters.webp?v=878d288e101b)](https://x.com/paulgauthier/status/1859684310204473349)

Paul Gauthier 在 X 上，2024 年 11 月 21 日

> X 官方嵌入卡片的截图，拍摄于 2026 年 11 月 5 日，时间为 UTC。点击任一截图可到 X 上打开原帖。

## 常见错误

- 把下载大小当成全部的内存开销。上下文和运行时在权重之外还要占空间。
- 在小显卡上把上下文长度开到最大。上下文越长，KV 缓存越大，可能把模型挤到 CPU 上。
- 把 GB 和 GiB 当成同一个单位来比较。1 GiB 大约比 1 GB 大 7%。
- 不看内存就调高并行请求数。每多一个并行槽位，缓存里就多一整份上下文。
- 给大模型选了最小的量化，却不检查它的回答。README 提醒量化可能损失精度，所以先用你自己的问题试一试。
- 以为 Intel Mac 会用上它的 GPU。在那上面，Ollama 只用 CPU。

## 自己试一试

- 写下你的显存和内存，算出表里三档 Llama 模型在 Q4_K_M 下哪几档装得下。
- 用 Python 小工具算一个你想用的模型，分别按 Q8_0 和 Q4_K_M 来算。
- 在 Ollama 里载入一个模型，看 `ollama ps` 里的 PROCESSOR 这一列。
- 用 `OLLAMA_CONTEXT_LENGTH=64000 ollama serve` 启动 Ollama，这是文档为智能体和编程建议的大小，再和默认设置下的 `ollama ps` 比一比。
- 在 LM Studio 里，用 `lms load` 加 `--gpu 0.5` 载入一个模型，再换成 `--gpu max`，比较它回复的速度。
- 对一个下载好的模型运行 `lms load` 加 `--estimate-only`，把它的估算和你自己算的结果比一比。

## 下一门课：Hugging Face

这门课里你算过的每个文件，都来自同一个地方。[Hugging Face 课程](https://mindket.com/cn/learn/hugging-face/hugging-face-hub)从 Hub 讲起，模型、GGUF 文件和模型卡片都放在那里。

## 自测一下

1. 一个 Q4_K_M 级别的 8B 模型，权重大约占多少内存？

   A. 大约 32 GB
   B. 大约 16 GB
   C. 大约 8 GB
   D. 大约 5 GB

   答案：D。 80 亿个权重，每个约 4.9 位，再除以八，略低于 5 GB，和 llama.cpp 的表格一致。

2. ollama ps 的 PROCESSOR 列显示 100% CPU，是什么意思？

   A. 模型完全载入了系统内存
   B. GPU 正忙着跑另一个模型
   C. 模型在 CPU 和 GPU 之间平分
   D. CPU 的内存用完了

   答案：A。 100% CPU 表示模型完全在系统内存里，回答起来比在 GPU 上慢。

3. 哪个设置能把 Ollama 的 KV 缓存内存减到大约一半？

   A. OLLAMA_NUM_PARALLEL=4
   B. 更长的上下文长度
   C. OLLAMA_KV_CACHE_TYPE=q8_0
   D. 一个 F16 模型文件

   答案：C。 8 位的 KV 缓存大约用默认 f16 一半的内存，而且需要 Flash Attention。

4. 为什么下载大小不等于模型需要的全部内存？

   A. 下载的文件是压缩过的
   B. 上下文和运行时在权重之外还要占空间
   C. GGUF 文件载入后会变成两倍大
   D. GPU 会存两份模型

   答案：B。 权重只是下限，上下文、并行请求和推理开销都会再加内存。

## 常见问题

### 运行一个 LLM 需要多少显存？

要装得下权重和上下文。Ollama 为它的快速入门模型建议 8 GB 显存，那个模型下载下来大约 7.2 GB。4 位的 70B 模型大约 43 GB，需要一张有这么多显存的显卡或一台 Mac，或者拆一部分到 CPU 上。

### 4 位模型比 16 位模型差很多吗？

这些资料没有给出一个统一的分数。llama.cpp 说量化可能损失一些精度，LM Studio 建议选 4 位或更高。在 llama.cpp 的表格里，4 位的 8B 文件不到 F16 文件的三分之一，所以内存够的话，就用你自己的提示词把两者都试一试。

### 没有 GPU 能运行 LLM 吗？

能。Ollama 和 llama.cpp 都能用处理器和系统内存运行模型，这时 `ollama ps` 会显示 `100% CPU`。回复会慢一些，所以先从小模型和 4 位文件开始。

### Mac 的统一内存算显存吗？

估算大小时算。M 系列的 GPU 和处理器读的是同一块内存，所以 Ollama 把 Mac 的统一内存当作显存。macOS 和你打开的应用会占用一部分，所以要留出余量。在 Intel Mac 上，Ollama 只用处理器。

## 资料来源

- [llama.cpp README](https://github.com/ggml-org/llama.cpp) (2026-11-05 查阅)
- [llama.cpp: quantize README](https://github.com/ggml-org/llama.cpp/blob/master/tools/quantize/README.md) (2026-11-05 查阅)
- [Hugging Face Docs: GGUF](https://huggingface.co/docs/hub/gguf) (2026-11-05 查阅)
- [Hugging Face Docs: Use Ollama with any GGUF model on Hugging Face Hub](https://huggingface.co/docs/hub/ollama) (2026-11-05 查阅)
- [Hugging Face Accelerate: Model memory estimator](https://huggingface.co/docs/accelerate/usage_guides/model_size_estimator) (2026-11-05 查阅)
- [Ollama Docs: Quickstart](https://docs.ollama.com/quickstart) (2026-11-05 查阅)
- [Ollama Docs: Context length](https://docs.ollama.com/context-length) (2026-11-05 查阅)
- [Ollama Docs: FAQ](https://docs.ollama.com/faq) (2026-11-05 查阅)
- [Ollama Docs: Hardware support](https://docs.ollama.com/gpu) (2026-11-05 查阅)
- [Ollama Docs: macOS](https://docs.ollama.com/macos) (2026-11-05 查阅)
- [Ollama library: llama3.1](https://ollama.com/library/llama3.1) (2026-11-05 查阅)
- [LM Studio Docs: System requirements](https://lmstudio.ai/docs/app/system-requirements) (2026-11-05 查阅)
- [LM Studio Docs: Download an LLM](https://lmstudio.ai/docs/app/basics/download-model) (2026-11-05 查阅)
- [LM Studio Docs: lms load](https://lmstudio.ai/docs/cli/local-models/load) (2026-11-05 查阅)
- [Dan Woods on X: tool calling got us back to Q4](https://x.com/danveloper/status/2034686509748462022) (2026-11-05 查阅)
- [Paul Gauthier on X: pay attention to how your open models are quantized](https://x.com/paulgauthier/status/1859684310204473349) (2026-11-05 查阅)
- [Aider blog: Details matter with open source models](https://aider.chat/2024/11/21/quantization.html) (2026-11-05 查阅)

[浏览套件](https://mindket.com/cn/kits)