大模型权重文件格式全解：为什么有这么多？各自怎么用？

本文把大模型常见的权重格式逐一讲清楚——它是什么、为什么存在、优劣势是什么、Python 里怎么加载使用。一文看完不再困惑。

---

一、为什么大模型有这么多权重格式？

核心原因：不同场景的需求是矛盾的，没有一种格式能通吃

大模型的生命周期涉及多个环节，每个环节的诉求不同：

环节	核心诉求
训练	精度最高、梯度反传方便
微调	灵活加载、支持部分参数冻结
GPU 推理（服务器）	速度最快、批处理高效
CPU 推理（本地/边缘）	内存占用最小、不依赖 GPU
跨框架部署	格式通用、框架无关
量化压缩	体积最小、支持低精度

这些诉求互相打架：

• 要精度高 → 文件大、速度慢
• 要体积小 → 必须量化、精度有损
• 要 CPU 能跑 → 不能依赖 CUDA 算子
• 要跨框架 → 不能绑定 PyTorch

于是，不同社区针对不同场景造了不同的轮子，格式自然就多了。

打个比方

就像图片格式：JPG 适合照片（压缩率高）、PNG 适合截图（无损透明）、WebP 想通吃但兼容性有问题、GIF 适合动图、SVG 适合矢量图……没有一种图片格式能干所有事，权重文件也是一样。

目前主流的格式一览

格式	诞生背景	核心场景
PyTorch (.bin)	PyTorch 生态原生	训练、微调、通用推理
Safetensors	HuggingFace 推出	安全加载、防恶意代码
GGUF	llama.cpp 社区推出	CPU 推理、边缘部署
ONNX	微软+Meta 推出	跨框架部署
BitsAndBytes (NF4/INT8)	bitsandbytes 库	运行时量化、QLoRA 微调
GPTQ	ICML 2022 论文	训练后 INT4 量化推理
AWQ	MIT 2023 论文	训练后 INT4 量化推理
ExLlamaV2 (.exl2)	社区项目	高速 GPU 量化推理

下面逐个展开。

---

二、PyTorch 原生格式（.bin / .pt / .pth）

是什么

PyTorch 自带的序列化格式，用 Python 的 pickle 机制把张量（tensor）保存到磁盘。文件后缀通常是 .bin、.pt 或 .pth。

在 HuggingFace 上，早期模型（2023 年之前上传的）大多用这个格式，文件名类似 pytorch_model.bin。

为什么存在

这是最自然的格式——PyTorch 训练完直接 torch.save() 就存了，不用转换。简单直接。

优劣势

优势	劣势
PyTorch 原生支持，零额外依赖	⚠️ 安全风险：pickle 反序列化时可以执行任意代码，下载来路不明的 .bin 文件可能中招
训练/微调的首选格式	加载速度一般（需要反序列化整个 pickle）
兼容性最广（几乎所有 PyTorch 工具都认）	不支持内存映射（mmap），大模型加载时必须全部读进内存
格式简单	文件体积没有压缩优化

安全问题是 .bin 格式最大的隐患。HuggingFace 已经在推动全面迁移到 Safetensors。

怎么用

from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载 .bin 格式的模型（transformers 会自动识别）
model = AutoModelForCausalLM.from_pretrained(
    "gpt2",  # 这个模型用的就是 pytorch_model.bin
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained("gpt2")

# 推理
inputs = tokenizer("Hello, world!", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=50)
print(tokenizer.decode(outputs[0]))

# 手动保存为 .bin 格式
import torch

model.save_pretrained("./my_model")  # 默认保存为 pytorch_model.bin
# 或者直接用 torch.save
torch.save(model.state_dict(), "./my_model.pt")

---

三、Safetensors（.safetensors）

是什么

HuggingFace 推出的安全权重格式。文件后缀 .safetensors。

与 .bin 的核心区别：不用 pickle，而是用自定义的二进制格式存储张量，反序列化时不会执行任何代码。

为什么存在

专门为了解决 .bin 格式的安全问题而生。

2023 年，安全研究人员发现 HuggingFace 上存在利用 pickle 漏洞的恶意模型——下载加载后会在你电脑上执行恶意代码。Safetensors 从根上杜绝了这个问题：它只存数据，不存代码，反序列化时纯粹读取数字，不可能执行任何东西。

此外，Safetensors 还优化了加载性能：支持内存映射（mmap），大模型加载时不需要把整个文件读进内存，而是按需映射，加载速度快很多。

优劣势

优势	劣势
✅ 安全：不可能执行恶意代码	仅限 HuggingFace 生态，PyTorch 原生不直接支持
✅ 加载快：支持 mmap，大模型加载提速明显	格式较新，极少数老工具不支持
✅ 支持懒加载：可以只加载部分张量，不用全读
✅ HuggingFace 当前推荐格式
✅ 支持 BF16、FP16 等多种精度

怎么用

from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载 .safetensors 格式的模型（和加载 .bin 完全一样，transformers 自动识别）
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2-7B",  # 这个模型用的是 safetensors
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-7B")

# 保存时强制使用 safetensors 格式
model.save_pretrained("./my_model", safe_serialization=True)  # safe_serialization=True 就是存为 safetensors

# 单独使用 safetensors 库（不依赖 transformers）
from safetensors.torch import save_file, load_file

# 保存
tensors = {
    "weight1": torch.randn(3, 3),
    "weight2": torch.randn(2, 2),
}
save_file(tensors, "./weights.safetensors")

# 加载
loaded = load_file("./weights.safetensors")
print(loaded.keys())  # dict_keys(['weight1', 'weight2'])

# 命令行快速转换：把 .bin 转成 .safetensors
# 需要安装：pip install safetensors
python -c "
from safetensors.torch import load_file, save_file
import torch
state_dict = torch.load('pytorch_model.bin', map_location='cpu')
save_file(state_dict, 'model.safetensors')
print('转换完成')
"

---

四、GGUF（.gguf）

是什么

GGUF（GPT-Generated Unified Format）是 llama.cpp 项目推出的格式，专为 CPU 推理和边缘部署设计。文件后缀 .gguf。

它是旧格式 GGML 的升级版（GGML 已废弃，GGUF 从 2023 年 8 月起取代它）。

为什么存在

大部分量化格式（GPTQ、AWQ）都需要 GPU + CUDA 才能跑。但很多人想在没有 GPU 的电脑上跑大模型——比如 MacBook、普通笔记本、树莓派。

GGUF 就是为这个场景生的：它把模型量化成 CPU 友好的格式，配合 llama.cpp 的 C++ 推理引擎，可以纯 CPU 跑大模型，甚至 Mac 的统一内存架构上跑得飞快。

GGUF 的量化档位

GGUF 支持多种量化精度，文件名里直接标注：

量化标签	位宽	说明
Q8_0	8 位	几乎无损，体积较大
Q6_K	6 位	接近无损
Q5_K_M	5 位	推荐平衡点
Q4_K_M	4 位	最主流，性价比最高
Q3_K_M	3 位	明显有损
Q2_K	2 位	极限压缩
F16	16 位	不量化，纯半精度

文件名示例：qwen2-7b-instruct-q4_k_m.gguf —— 一看就知道是 Q4_K_M 量化的。

优劣势

优势	劣势
✅ 纯 CPU 可跑，不依赖 GPU	❌ GPU 推理速度不如 GPTQ/AWQ（GGUF 主要优化 CPU）
✅ 支持 Apple Silicon（M1/M2/M3）统一内存	❌ 需要用 llama.cpp 或相关工具，不能直接用 transformers
✅ 量化选项丰富（2~8 位可选）	❌ 不适合训练/微调（只用于推理）
✅ 单文件包含所有信息（权重+配置+tokenizer）	❌ 格式转换需要额外工具
✅ 社区生态强大（HuggingFace 上大量现成 GGUF 模型）

怎么用

方式一：用 llama.cpp 直接跑（最常见）

# 1. 下载/编译 llama.cpp
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make  # 编译（Mac 用 make，Linux 同理）

# 2. 下载 GGUF 模型（从 HuggingFace 下载）
# 例如：https://huggingface.co/Qwen/Qwen2-7B-Instruct-GGUF

# 3. 直接运行
./main -m qwen2-7b-instruct-q4_k_m.gguf -p "你好，请介绍一下自己" -n 200

方式二：用 Python 调用（llama-cpp-python）

pip install llama-cpp-python

from llama_cpp import Llama

# 加载 GGUF 模型
llm = Llama(
    model_path="./qwen2-7b-instruct-q4_k_m.gguf",
    n_ctx=4096,       # 上下文长度
    n_gpu_layers=0,   # GPU 层数（0=纯CPU，设大一点可以卸载到GPU）
)

# 推理
response = llm(
    "请用三句话解释量子计算。",
    max_tokens=200,
    temperature=0.7,
)
print(response["choices"][0]["text"])

方式三：自己把模型转成 GGUF

# llama.cpp 自带转换脚本
cd llama.cpp

# 把 HuggingFace 模型转成 GGUF（先转成 F16，再量化）
python convert_hf_to_gguf.py /path/to/huggingface/model --outfile model-f16.gguf

# 量化成 Q4_K_M
./llama-quantize model-f16.gguf model-q4_k_m.gguf Q4_K_M

方式四：用 Ollama 一键运行（最省心）

# 安装 Ollama 后，一行命令就能跑 GGUF 模型
ollama run qwen2:7b

# 或者加载本地 GGUF 文件
# 先创建 Modelfile
echo 'FROM ./qwen2-7b-instruct-q4_k_m.gguf' > Modelfile
ollama create my-qwen -f Modelfile
ollama run my-qwen

---

五、ONNX（.onnx）

是什么

ONNX（Open Neural Network Exchange）是微软和 Meta 联合推出的开放格式。不绑定任何框架，是一种"中间表示"。

为什么存在

深度学习框架太多了——PyTorch、TensorFlow、JAX、MXNet……模型在 PyTorch 里训练，想放到 TensorFlow Serving 上部署？或者放到手机上用 NCNN 推理？ONNX 就是这座桥梁：所有框架都能导出成 ONNX，所有推理引擎都能加载 ONNX。

优劣势

优势	劣势
✅ 跨框架：一次导出，到处运行	❌ 导出过程复杂，大模型导出 ONNX 经常踩坑
✅ 推理引擎丰富：ONNX Runtime、TensorRT、OpenVINO	❌ 不支持训练/微调
✅ 支持 CPU/GPU/移动端等多种后端	❌ 对最新模型架构支持滞后（新模型可能导出失败）
✅ 部分推理引擎有图优化，速度可能比原生 PyTorch 更快	❌ 文件体积无压缩优势
✅ 微软生态深度支持（Azure ML 原生部署 ONNX）	❌ 大模型场景下不如 GPTQ/AWQ/GGUF 主流

怎么用

pip install optimum[onnxruntime] onnxruntime-gpu

from optimum.onnxruntime import ORTModelForCausalLM
from transformers import AutoTokenizer

model_path = "Qwen/Qwen2-7B"
onnx_path = "./qwen2-7b-onnx"

# 第一步：把 PyTorch 模型转换为 ONNX
print("正在导出 ONNX...")
model = ORTModelForCausalLM.from_pretrained(
    model_path,
    export=True,  # 自动导出为 ONNX
    provider="CUDAExecutionProvider",  # 或 "CPUExecutionProvider"
)
tokenizer = AutoTokenizer.from_pretrained(model_path)

# 保存
model.save_pretrained(onnx_path)
tokenizer.save_pretrained(onnx_path)
print("ONNX 导出完成！")

# 第二步：加载 ONNX 模型推理
print("加载 ONNX 模型推理...")
ort_model = ORTModelForCausalLM.from_pretrained(onnx_path)

inputs = tokenizer("什么是深度学习？", return_tensors="pt")
outputs = ort_model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

# 进阶：ONNX Runtime 量化（INT8）
from optimum.onnxruntime import ORTQuantizer
from optimum.onnxruntime.configuration import AutoQuantizationConfig

quantizer = ORTQuantizer.from_pretrained(onnx_path)
qconfig = AutoQuantizationConfig.avx512_vnni(
    is_static=False,
    per_channel=True,  # 按通道量化，精度更高
)
quantizer.quantize(
    save_dir="./qwen2-7b-onnx-int8",
    quantization_config=qconfig,
)
print("ONNX INT8 量化完成！")

---

六、BitsAndBytes 格式（NF4 / INT8）

是什么

不是文件格式，而是一种运行时量化方案。模型存储时还是 safetensors/bin（FP16），加载到 GPU 时由 bitsandbytes 库实时量化成 INT8 或 NF4（Normal Float 4 位）。

为什么存在

GPTQ 和 AWQ 需要提前花时间量化好再保存。但有时候你只是想快速试一下某个模型，不想花几十分钟量化——bitsandbytes 可以在加载模型时瞬间量化，加载即用。

更重要的是：QLoRA 微调依赖 bitsandbytes 的 NF4 量化。这是目前大模型微调最主流的方案——把基础模型用 NF4 量化节省显存，然后在上面加 LoRA 适配器做微调。

优劣势

优势	劣势
✅ 即载即用：加载时自动量化，不需要预处理	❌ 推理速度比 GPTQ/AWQ 慢（运行时反量化开销）
✅ QLoRA 微调的基础：微调大模型的标配方案	❌ 不生成独立的量化文件，每次加载都要重新量化
✅ 实现简单，transformers 原生支持	❌ 必须 GPU + CUDA，CPU 不行
✅ NF4 量化效果优秀（NormalFloat 分布对齐权重分布）	❌ 不适合生产推理部署（速度劣势）

怎么用

pip install bitsandbytes accelerate

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

model_path = "Qwen/Qwen2-7B"

# ============ INT8 量化加载 ============
int8_config = BitsAndBytesConfig(load_in_8bit=True)

model_int8 = AutoModelForCausalLM.from_pretrained(
    model_path,
    quantization_config=int8_config,
    device_map="auto",
)

# ============ NF4 (INT4) 量化加载 ============
nf4_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",            # NF4 量化类型
    bnb_4bit_compute_dtype=torch.float16,  # 计算时反量化到 FP16
    bnb_4bit_use_double_quant=True,        # 双重量化，进一步压缩
)

model_nf4 = AutoModelForCausalLM.from_pretrained(
    model_path,
    quantization_config=nf4_config,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_path)

# 推理（和普通模型完全一样）
inputs = tokenizer("解释一下量子纠缠。", return_tensors="pt").to(model_nf4.device)
outputs = model_nf4.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

# QLoRA 微调（bitsandbytes 的核心用途）
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from transformers import TrainingArguments, Trainer

# 1. 用 NF4 加载基础模型
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    quantization_config=nf4_config,
    device_map="auto",
)

# 2. 准备模型用于量化训练
model = prepare_model_for_kbit_training(model)

# 3. 添加 LoRA 适配器
lora_config = LoraConfig(
    r=16,                          # LoRA 秩
    lora_alpha=32,                 # 缩放系数
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],  # 应用到哪些层
    lora_dropout=0.05,
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora_config)

# 4. 正常训练（只训练 LoRA 参数，基础模型冻结）
# ... 使用 Trainer 或其他训练框架
print(f"可训练参数: {model.print_trainable_parameters()}")

---

七、GPTQ 格式

是什么

GPTQ 量化后保存的模型格式。底层还是 safetensors 文件，但权重是 INT4 量化的，附带量化配置（group_size、bits 等）。

关于 GPTQ 的量化原理，详见同系列《大模型压缩量化技术文档》，此处只讲格式使用。

优劣势

优势	劣势
✅ INT4 推理速度快（配合专用推理内核）	❌ 量化过程较慢（需要计算 Hessian）
✅ 效果优秀，大模型上精度损失极小	❌ 需要 GPU + CUDA
✅ vLLM、TGI 等推理框架原生支持	❌ 不支持训练/微调
✅ HuggingFace 上大量现成 GPTQ 模型

怎么用

from transformers import AutoModelForCausalLM, AutoTokenizer

# 直接加载 HuggingFace 上的 GPTQ 量化模型
# （社区已经量化好的，比如 TheBloke 仓库）
model = AutoModelForCausalLM.from_pretrained(
    "TheBloke/Llama-2-7B-GPTQ",  # 已量化的 GPTQ 模型
    device_map="auto",
    trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained("TheBloke/Llama-2-7B-GPTQ")

# 推理
inputs = tokenizer("写一首关于春天的诗。", return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

# 自己量化生成 GPTQ 模型（详见量化技术文档）
from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig

model_path = "Qwen/Qwen2-7B"
tokenizer = AutoTokenizer.from_pretrained(model_path)

gptq_config = GPTQConfig(bits=4, group_size=128, desc_act=False, dataset="c4")
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    quantization_config=gptq_config,
    device_map="auto",
    trust_remote_code=True,
)
model.save_pretrained("./qwen2-7b-gptq")  # 保存为 GPTQ 格式

---

八、AWQ 格式

是什么

AWQ 量化后保存的模型格式。和 GPTQ 类似，底层是 safetensors 文件，权重为 INT4，附带 AWQ 特有的量化配置。

关于 AWQ 的量化原理，详见同系列《大模型压缩量化技术文档》，此处只讲格式使用。

优劣势

优势	劣势
✅ 量化速度快（比 GPTQ 快很多）	❌ 需要 GPU + CUDA
✅ INT4 推理速度快	❌ 不支持训练/微调
✅ 小模型上效果略优于 GPTQ	❌ 生态稍小于 GPTQ（但差距在缩小）
✅ vLLM、Transformers 原生支持

怎么用

from transformers import AutoModelForCausalLM, AutoTokenizer

# 直接加载 HuggingFace 上的 AWQ 量化模型
model = AutoModelForCausalLM.from_pretrained(
    "TheBloke/Llama-2-7B-Chat-AWQ",  # 已量化的 AWQ 模型
    device_map="auto",
    trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained("TheBloke/Llama-2-7B-Chat-AWQ")

# 推理
inputs = tokenizer("什么是人工智能？", return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=200)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

# 自己量化生成 AWQ 模型
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = "Qwen/Qwen2-7B"
model = AutoAWQForCausalLM.from_pretrained(model_path, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_path)

quant_config = {"zero_point": True, "q_group_size": 128, "w_bit": 4, "version": "GEMM"}
model.quantize(tokenizer, quant_config=quant_config)
model.save_quantized("./qwen2-7b-awq")

---

九、ExLlamaV2 格式（.exl2）

是什么

ExLlamaV2 是一个社区项目，专门为 NVIDIA GPU 高速推理优化。它有自己的量化格式 .exl2，支持混合精度量化（不同层用不同位宽），在追求极致推理速度的场景下很受欢迎。

为什么存在

GPTQ 和 AWQ 虽然好，但推理速度还有优化空间。ExLlamaV2 从底层重写了推理内核，针对 NVIDIA GPU 做了极致优化，推理速度通常比 GPTQ/AWQ 更快。同时它的混合精度量化允许在"效果"和"速度"之间更灵活地平衡。

优劣势

优势	劣势
✅ 推理速度极快（NVIDIA GPU 上通常最快）	❌ 只支持 NVIDIA GPU
✅ 支持混合精度（如 4.5bit、5.0bit 等非整数位宽）	❌ 社区较小，文档不如主流格式完善
✅ 显存占用优化好	❌ 不支持训练/微调
✅ 支持 exllamav2 库原生推理	❌ 不如 GPTQ/AWQ 主流

怎么用

pip install exllamav2

from exllamav2 import (
    ExLlamaV2,
    ExLlamaV2Config,
    ExLlamaV2Cache,
    ExLlamaV2Tokenizer,
)
from exllamav2.generator import ExLlamaV2DynamicGenerator
import glob

# 加载 .exl2 格式模型
model_dir = "./qwen2-7b-exl2"  # 从 HuggingFace 下载的 exl2 模型目录

config = ExLlamaV2Config(model_dir)
config.max_seq_len = 4096

model = ExLlamaV2(config)
model.load()

tokenizer = ExLlamaV2Tokenizer(config)
cache = ExLlamaV2Cache(model, max_seq_len=config.max_seq_len)

# 创建生成器
generator = ExLlamaV2DynamicGenerator(
    model=model,
    cache=cache,
    tokenizer=tokenizer,
)

# 推理
output = generator.generate(
    prompt="请解释什么是深度学习。",
    max_new_tokens=200,
    temperature=0.7,
)
print(output)

# 自己量化生成 exl2 模型
# 需要准备校准数据，使用 exllamav2 自带的转换工具
python convert.py \
    -i /path/to/base/model \
    -o /path/to/output \
    -cf /path/to/calibration/data.json \
    -b 4.0  \  # 目标平均位宽（支持小数，如 4.5、5.0）

---

十、全部格式对比总表

格式	文件后缀	核心场景	需要 GPU	支持训练	推理速度	量化支持
PyTorch	.bin/.pt	训练/微调/通用	可选	✅	中	❌
Safetensors	.safetensors	安全加载/通用推理	可选	✅	中	❌
GGUF	.gguf	CPU 推理/边缘部署	❌	❌	CPU 上最快	✅ 2-8 位
ONNX	.onnx	跨框架部署	可选	❌	中	✅ INT8
BitsAndBytes	运行时量化	QLoRA 微调/快速试模型	✅	✅ (QLoRA)	较慢	✅ NF4/INT8
GPTQ	safetensors+config	GPU 量化推理	✅	❌	快	✅ INT4
AWQ	safetensors+config	GPU 量化推理	✅	❌	快	✅ INT4
ExLlamaV2	.exl2	极速 GPU 推理	✅ (NVIDIA)	❌	最快	✅ 混合精度

---

十一、实战选型指南：我该用哪个格式？

场景一：我要训练或微调模型

→ Safetensors（保存模型）+ BitsAndBytes NF4（QLoRA 微调时加载基础模型）

场景二：我有 GPU，想部署量化模型做推理

→ AWQ 或 GPTQ（效果差不多，AWQ 量化更快）+ vLLM 部署

追求极致速度 → ExLlamaV2 (.exl2)

场景三：我没有 GPU，想在 CPU/Mac 上跑

→ GGUF + llama.cpp 或 Ollama

场景四：我要跨框架/跨平台部署

→ ONNX + ONNX Runtime

场景五：我只想快速试用一个模型，不想折腾

→ BitsAndBytes INT4 一行参数加载即用（需要 GPU）

场景六：我要开发 HuggingFace 上的模型，存什么格式

→ Safetensors（HuggingFace 当前推荐，安全且加载快）

选型流程图

你的需求是什么？
│
├── 训练 / 微调
│   ├── 全参数微调 → Safetensors (FP16/BF16)
│   └── QLoRA 微调 → Safetensors + BitsAndBytes NF4
│
├── GPU 推理
│   ├── 追求效果平衡 → AWQ 或 GPTQ (INT4) + vLLM
│   ├── 追求极致速度 → ExLlamaV2 (.exl2)
│   └── 快速试用 → BitsAndBytes (NF4, 运行时量化)
│
├── CPU / Mac 推理
│   └── GGUF + llama.cpp / Ollama
│
├── 跨框架部署
│   └── ONNX + ONNX Runtime
│
└── 保存/分享模型
    └── Safetensors (HuggingFace 标准格式)

---

十二、格式互转速查

转换方向	工具/方法
PyTorch → Safetensors	model.save_pretrained(path, safe_serialization=True)
Safetensors → PyTorch	加载后 torch.save(model.state_dict(), path)
PyTorch → GGUF	llama.cpp 的 convert_hf_to_gguf.py 脚本
PyTorch → ONNX	optimum 的 ORTModelForCausalLM.from_pretrained(export=True)
PyTorch → GPTQ	transformers.GPTQConfig 或 auto-gptq 库
PyTorch → AWQ	autoawq 库
PyTorch → ExLlamaV2	exllamav2 的 convert.py 脚本
GGUF → PyTorch	无直接方法，需要先反量化（不推荐，建议从原始模型重新转换）

注意：量化格式（GPTQ/AWQ/GGUF/exl2）之间通常不能直接互转。它们都是从原始 FP16 模型量化而来。如果需要换格式，请从原始未量化模型重新量化。

---

总结：三句话记住核心

1. 格式多是因为场景多——训练要精度、推理要速度、CPU 要省内存、跨框架要通用，没有一种格式能通吃。

2. 日常最常用的三件套：Safetensors（存模型）、AWQ/GPTQ（GPU 量化推理）、GGUF（CPU 推理）。其余格式按需使用。

3. 选型原则一句话：训练微调用 Safetensors + BitsAndBytes，GPU 推理用 AWQ/GPTQ + vLLM，CPU 推理用 GGUF + Ollama，跨框架用 ONNX。