模型 · 第五层：模型如何加载并运行？

核心问题：下载模型后，计算机怎样真正运行它？

主要概念：Inference、Inference Engine、Runtime、CPU、RAM、GPU、VRAM、Precision、Quantization、Device、Offload、KV Cache、Batch、Prefill、Decode、Latency、Throughput。

磁盘里的模型只是权重、配置和输入处理文件；推理引擎需要根据配置创建计算结构，把权重加载到 RAM 或 VRAM，并调用 CPU、GPU 执行一次次 Tensor 计算，模型才真正“运行起来”。

两个过程：

加载模型，读取文件、创建结构、分配内存、放置权重；
执行推理，处理输入、运行模型计算、逐个生成 Token。

流程

Inference 推理

Inference 模型推理，是指使用已经训练好的模型参数处理新的输入，并计算输出结果。

大语言模型：

用户输入
→ 模型计算
→ 预测下一个 Token
→ 逐步生成回答

图像分类模型：

图片
→ 模型计算
→ 分类概率

图像或视频生成模型：

Prompt / 图片 / 视频
→ 多次模型计算
→ 逐步生成图像或视频

推理与训练都会运行模型的 Forward Pass，但目标不同：

阶段	主要工作
Training	前向计算、计算 Loss、反向传播、更新参数
Inference	前向计算、取得结果，不更新模型参数

同一个模型，推理通常比训练需要更少的显存和计算资源。

Inference Engine：推理引擎

权重文件只是保存 Tensor 数值的文件，负责加载和执行模型的是：Inference Engine，推理引擎。通常负责：

Inference Engine
│
├── 读取模型配置
├── 创建模型结构
├── 加载权重
├── 管理 CPU / GPU 设备
├── 管理 RAM / VRAM
├── 执行 Tensor 运算
├── 管理 KV Cache
├── 组织 Batch
├── 执行采样
└── 返回或流式输出结果

常见推理工具和引擎包括：

工具或框架	常见用途
Transformers	模型加载、开发和通用推理
PyTorch	底层 Tensor 计算与模型执行
vLLM	大语言模型高吞吐服务
TensorRT-LLM	NVIDIA GPU 上的 LLM 优化推理
llama.cpp	CPU、GPU 本地量化模型推理
ONNX Runtime	跨平台模型推理
MLX	Apple Silicon 上的模型计算
Diffusers	扩散类图像、视频模型
ComfyUI	以节点工作流组织生成模型推理

加载模型时，推理引擎做了什么？

1. 读取 Config

推理引擎先读取：config.json。从中获得：

模型类型；
层数；
Hidden Size；
Attention Head 数；
Vocabulary Size；
最大上下文；
数据类型；
多模态组件配置。

2. 创建模型结构

根据 Config 和对应的模型实现代码，创建计算结构：

Embedding
→ Transformer Block 1
→ Transformer Block 2
→ ...
→ LM Head

此时可以理解为：

推理框架先搭好了一个由计算层组成的“空模型”。

3. 找到权重文件

如果权重被分片，推理引擎会读取：

model.safetensors.index.json

确定每个参数位于哪个 Shard。

4. 反序列化权重

推理引擎将磁盘中的数据读取为 Tensor：

Safetensors 文件
→ Tensor 名称
→ Tensor 形状
→ Tensor 数据类型
→ Tensor 数值

5. 匹配结构与权重

模型结构中的参数要对应权重文件中的 Tensor。

6. 将权重放置到设备

权重可能被放到：

CPU 对应的 RAM；
GPU 对应的 VRAM；
多张 GPU；
RAM 和 VRAM 的组合；
少数情况下的磁盘映射区域。

CPU 和 GPU 分别负责什么？

CPU，Central Processing Unit，中央处理器，通用计算处理器，擅长：

操作系统和程序控制；
文件读取；
输入预处理；
Tokenizer；
任务调度；
分支和复杂控制逻辑；
内存管理；
部分模型计算。

模型完全可以在 CPU 上推理，但大模型计算通常很慢。

GPU，Graphics Processing Unit，图形处理器，大规模并行计算处理器，最初面向图形计算，但非常适合：

矩阵乘法；
向量计算；
大量相同操作的并行执行；
神经网络中的 Tensor 运算。

模型推理包含大量矩阵计算，GPU 可以同时执行大量类似计算，因此通常比 CPU 更适合大型神经网络推理。

GPU 并不是把整个应用程序都接管了。CPU 通常仍负责程序控制、数据准备和任务调度，GPU 主要承担适合并行化的模型计算。

RAM 和 VRAM 分别是什么？

RAM，Random Access Memory，系统内存，随机存取存储器，通常简称“内存”。由 CPU 和操作系统管理，主要用于保存：

正在运行的程序；
从磁盘读取的模型文件；
CPU 上的权重 Tensor；
输入和输出数据；
中间计算结果；
文件缓存；
Offload 出来的模型层。

VRAM，Video Random Access Memory，视频随机存取存储器，通常简称“显存”。位于显卡上，主要用于保存 GPU 计算所需的数据：

模型权重；
输入 Tensor；
Activation；
KV Cache；
临时计算缓冲区；
CUDA Kernel 工作空间；
图像或视频生成中的中间结果。

资源	主要服务对象	典型特点
RAM	CPU 和操作系统	容量通常较大，CPU 访问快
VRAM	GPU	容量通常较小，GPU 访问快
SSD / HDD	长期存储	容量大，但远慢于 RAM 和 VRAM

模型运行时，显存里装了什么？

很多朋友会把显存占用直接等同于权重大小，但实际显存通常包含多个部分：

VRAM Usage
│
├── Model Weights
├── KV Cache
├── Activations
├── Input / Output Tensors
├── Temporary Buffers
├── Framework Overhead
└── CUDA Context

因此：运行所需显存 > 模型权重文件大小

一个权重文件是 8GB，并不表示 8GB 显卡一定能够运行，因为还需要给其他数据留出空间。不同推理框架、模型架构、输入长度、Batch Size 和计算精度都会影响额外开销。

Precision：数值使用什么精度表示？

Precision，精度，模型参数和计算过程使用什么数值格式。

常见格式包括：

格式	全称	每个数典型位数	直观特点
FP32	32-bit Floating Point	32 bit	精度高，占用大
FP16	16-bit Floating Point	16 bit	占用约为 FP32 一半
BF16	Brain Floating Point 16	16 bit	动态范围接近 FP32
FP8	8-bit Floating Point	8 bit	更省空间，需要硬件和软件支持
INT8	8-bit Integer	8 bit	常用于量化
INT4	4-bit Integer	4 bit	占用更低，量化误差可能更明显

最粗略的权重体积关系是：

FP32
→ FP16 / BF16：约一半
→ FP8 / INT8：约四分之一
→ INT4：约八分之一

Quantization：为什么要量化模型？

Quantization，量化，指的是：使用位数更低的数值表示模型权重或计算数据，以减少存储、内存占用和计算成本。例如，原始 BF16 权重 -> 量化 -> INT8 或 INT4 权重。

量化的主要目的包括：

减少模型文件体积；
减少 RAM 和 VRAM 占用；
降低内存带宽压力；
在适配硬件上提高推理速度；
让大模型可以在资源较小的设备上运行。

代价可能包括：

数值精度损失；
模型质量下降；
某些任务对量化更敏感；
需要专用算子和推理引擎；
不同硬件上的加速效果不同。

Device：模型究竟在哪个设备上运行？

表示 Tensor 和计算所在的设备。

常见形式包括：

CPU
CUDA GPU
Apple Metal GPU
其他 AI 加速器

在 PyTorch 中可能看到：

cpu
cuda:0
cuda:1
mps

其中：

cuda:0 → 第一张 NVIDIA GPU
cuda:1 → 第二张 NVIDIA GPU
mps    → Apple Silicon GPU 后端

模型权重和参与计算的输入 Tensor 通常必须位于兼容设备上。

Offload：显存放不下怎么办？

Offload，卸载或转移，在模型推理中通常指：不把所有模型组件始终保留在 GPU 显存中，而是将一部分放在 RAM，甚至磁盘，需要时再转移到 GPU。

常见方式包括：

CPU Offload

部分权重保留在 RAM
→ 计算前传入 VRAM
→ GPU 完成计算
→ 需要时再换入其他权重

优点：

降低显存需求；
让显存较小的 GPU 运行更大的模型。

代价：

CPU 与 GPU 之间需要搬运数据；
受到 PCIe 带宽限制；
速度可能明显下降；
RAM 占用增加。

Disk Offload

部分权重保留在磁盘
→ 读取到 RAM
→ 再传入 VRAM

它可以进一步降低 RAM 需求，但磁盘远慢于内存，通常会带来更大的性能损失。

Sequential Offload

某些图像或视频生成工作流包含多个模型组件：

Text Encoder
→ Diffusion Model
→ VAE

推理引擎可以分阶段加载：

加载 Text Encoder
→ 完成文本编码
→ 卸载 Text Encoder
 
加载 Diffusion Model
→ 执行生成
→ 卸载 Diffusion Model
 
加载 VAE
→ 执行解码

这种方式特别适合显存有限的设备，但会增加模型换入换出的时间。

Offload 不等于把 RAM 当成显存

程序可以把部分数据保存在 RAM，但：RAM 不会真正变成 GPU 的本地 VRAM。GPU 计算需要的数据仍然需要通过 CPU—GPU 之间的通道传输。

类比的理解：

VRAM：GPU 手边的工作台
RAM：房间里的货架
SSD：仓库

工作台放不下时，可以把材料暂存在货架或仓库里，但每次使用前都需要搬运。

多 GPU：能否把多张显卡的显存加起来？

多张 GPU 可以共同运行模型，但不是简单地：12GB + 12GB = 一张 24GB GPU

推理框架必须明确支持模型切分和跨卡通信。常见方式包括：

方式	含义
Tensor Parallelism	将一次矩阵计算拆到多张 GPU
Pipeline Parallelism	将不同模型层放到不同 GPU
Expert Parallelism	将 MoE 的不同专家放到不同 GPU
Data Parallelism	每张 GPU 各放一套模型，处理不同请求

前面三种主要用于：

多张 GPU
→ 共同完成一个模型实例或一次推理

Data Parallelism 则是：

GPU 1 → 请求 A
GPU 2 → 请求 B
GPU 3 → 请求 C

所以在批量生成场景中，首先需要确认：目标是让多张卡共同运行一个大模型，还是让每张卡独立运行一个任务？

后者通常架构更简单，也更容易获得线性吞吐提升。

KV Cache：为什么生成时还会不断占用显存？

大语言模型通过自回归方式逐个生成 Token，如果每次生成新 Token 都重新计算之前所有 Token 的 Attention 中间结果，会产生大量重复计算，因此，推理引擎通常保存过去 Token 在 Attention 中生成的：Key、Value，这些缓存称为：KV Cache，Key-Value Cache。

没有 KV Cache，每次生成都重新处理完整历史。
使用 KV Cache，保存历史 Token 的部分中间计算结果，只计算新 Token 对应的新结果。

作用：

减少重复计算；
加快逐 Token 生成；
支持高效的自回归推理。

但也会占用 RAM 或 VRAM，并且通常随着以下因素增加：

上下文长度；
Batch Size；
并发请求数；
模型层数；
KV Head 数量；
KV Cache 精度。

因此：模型权重能装进显存，不代表一定能处理很长的上下文或很多并发请求。

因为剩余显存还要容纳 KV Cache。

Latency 和 Throughput：怎样评价推理速度？

Latency：延迟，表示完成某项操作需要多长时间。

指标	含义
TTFT	Time to First Token，收到请求到生成第一个 Token 的时间
ITL	Inter-Token Latency，相邻输出 Token 之间的延迟
E2E Latency	从发送请求到完整回答结束的总时间

Throughput：吞吐量，单位时间内系统能够完成多少工作。常见形式包括：

Tokens per Second， TPS, 每秒生成的 Token 数；
Requests per Second， RPS, 每秒处理的请求数；
Images per Minute， IPM, 每分钟生成的图片数；
Videos per Hour， VPH, 每小时生成的视频数。

生成式图像和视频模型的差异

图像和视频生成模型的运行过程可能不同。例如扩散类模型：

Prompt
→ Text Encoder
→ 初始噪声
→ Diffusion Model 多步去噪
→ VAE Decode
→ 图片或视频

运行时显存可能包含：

Generative Model VRAM
│
├── Text Encoder Weights
├── Diffusion Model Weights
├── VAE Weights
├── Latent
├── Attention 中间结果
├── 临时计算缓冲区
└── 图片 / 视频 Tensor

概念

Model Loading & Inference（模型加载与推理）
│
├── Inference Software（推理软件）
│   ├── Framework
│   ├── Inference Engine
│   ├── Runtime
│   └── Backend
│
├── Hardware（硬件）
│   ├── CPU
│   ├── RAM
│   ├── GPU
│   ├── VRAM
│   └── SSD
│
├── Model Loading（模型加载）
│   ├── Config
│   ├── Architecture Implementation
│   ├── Deserialization
│   ├── Weight Loading
│   └── Device Map
│
├── Numerical Representation（数值表示）
│   ├── Precision
│   ├── FP32 / FP16 / BF16
│   ├── FP8 / INT8 / INT4
│   └── Quantization
│
├── Memory Management（内存管理）
│   ├── Model Weights
│   ├── Activations
│   ├── KV Cache
│   ├── Temporary Buffers
│   └── Offload
│
├── Execution（执行过程）
│   ├── Prefill
│   ├── Decode
│   ├── Forward Pass
│   └── Sampling
│
├── Request Scheduling（请求调度）
│   ├── Batch
│   ├── Dynamic Batching
│   ├── Concurrency
│   └── Queue
│
└── Performance（性能）
    ├── Latency
    ├── TTFT
    ├── Tokens per Second
    ├── Throughput
    └── OOM

总结

模型下载到磁盘后，还不能直接运行。推理引擎首先读取 Config 创建模型结构，再将 Safetensors 等文件中的权重反序列化为 Tensor，并根据设备和内存策略放入 RAM 或 VRAM。输入经过编码后，由 CPU 负责程序组织与调度，GPU 执行主要的并行 Tensor 计算。大语言模型先通过 Prefill 处理输入并建立 KV Cache，再进入 Decode 阶段逐个生成 Token。Precision、Quantization、Offload、上下文长度和 Batch Size共同决定模型需要多少内存、运行多快以及能够同时处理多少请求。

下载模型只是把文件保存到磁盘，加载模型才会把权重放入 RAM 或 VRAM；
权重文件本身不能运行，必须由推理引擎、计算框架和硬件共同执行；
显存不只存模型权重，还要容纳 KV Cache、中间结果和临时缓冲区；
量化可以降低内存需求，但效果取决于量化方法、推理引擎和硬件支持；
Offload 让小显存设备有机会运行大模型，但通常会因数据搬运而降低速度。