大模型量化技术详解：让 AI 模型更小更快

发表于 | 分类于 | 评论数： 0 | 阅读次数：

摘要：随着大模型规模不断增长，量化技术成为模型部署的关键。本文深入讲解量化的基本原理、主流方法、实际收益，并提供完整的实战代码示例。

引言

你有没有想过，为什么一个 70B 参数的模型需要 140GB 显存，但在某些设备上却能以几分之一的显存运行？答案就是量化（Quantization）。

量化是深度学习模型压缩和加速的核心技术之一。简单来说，它通过将模型权重和激活值从高精度（如 FP32）转换为低精度（如 INT8、INT4），在几乎不损失精度的情况下，大幅减少模型大小和计算资源需求。

本文将从原理到实践，带你全面理解大模型量化技术。

一、量化的基本概念和原理

1.1 什么是量化？

深度学习中，模型的权重和激活值通常使用32 位浮点数（FP32）表示。FP32 可以表示非常大或非常小的数值，精度高，但占用内存多（每个参数 4 字节）。

量化的核心思想是：用更少的比特数来表示这些数值。常见的量化精度包括：

精度 类型 每参数字节数 相对 FP32 压缩比
FP32 32 位浮点 4 字节 1x
FP16 16 位浮点 2 字节 2x
INT8 8 位整数 1 字节 4x
INT4 4 位整数 0.5 字节 8x
INT2 2 位整数 0.25 字节 16x

1.2 量化的数学原理

量化的本质是一个映射过程，将连续的高精度数值映射到离散的低精度数值。

对称量化公式：

1
2
量化：q = round(r / scale)
反量化：r' = q × scale

其中：

  • r 是原始浮点数值
  • q 是量化后的整数值
  • scale 是缩放因子，用于确定量化范围

非对称量化还会引入零点偏移（zero_point）：

1
2
q = round(r / scale) + zero_point
r' = (q - zero_point) × scale

1.3 为什么量化后模型还能工作？

这是一个很好的问题。直觉上，降低精度应该会严重损失模型能力，但实际并非如此。原因有几点：

  1. 神经网络具有冗余性：大模型中存在大量冗余参数，对精度不敏感
  2. 训练过程中的噪声容忍：模型在训练时已经适应了各种噪声（如 Dropout、数据增强）
  3. 量化感知训练：可以让模型在训练时就适应量化带来的误差
  4. 精心设计的量化策略：如 per-channel 量化、混合精度量化等

二、量化的主要方法

2.1 训练后量化（PTQ, Post-Training Quantization）

PTQ 是最常用的量化方法，它不需要重新训练模型，直接在训练好的模型上进行量化。

工作流程：

1
原始模型 → 校准（Calibration）→ 量化 → 部署

校准阶段需要使用少量代表性数据（通常 100-1000 条样本）来确定量化参数（scale 和 zero_point）。

优点：

  • 无需训练，成本低
  • 实施简单，速度快
  • 适合大多数场景

缺点：

  • 精度损失相对较大（尤其是低比特量化）
  • 对异常值敏感

代码示例（使用 Hugging Face + bitsandbytes）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "meta-llama/Llama-2-7b-hf"
tokenizer = AutoTokenizer.from_pretrained(model_name)

# INT8 量化加载
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    load_in_8bit=True,  # 启用 INT8 量化
    device_map="auto",
    torch_dtype=torch.float16
)

# 推理
input_text = "什么是量化？"
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

2.2 量化感知训练（QAT, Quantization-Aware Training）

QAT 在模型训练过程中就模拟量化效果，让模型学习适应量化带来的误差。

工作流程：

1
原始模型 → 插入假量化节点 → 微调训练 → 量化 → 部署

核心思想：在前向传播时模拟量化误差，但反向传播时仍使用高精度梯度（Straight-Through Estimator, STE）。

优点：

  • 精度损失最小
  • 适合低比特量化（INT4、INT2）
  • 可以量化到极端精度

缺点：

  • 需要训练，成本高
  • 实施复杂，需要调整超参数
  • 训练时间长

代码示例（使用 PyTorch QAT API）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import torch
import torch.quantization as quant
from torch.ao.quantization import QuantStub, DeQuantStub

class QuantizableModel(torch.nn.Module):
    def __init__(self, original_model):
        super().__init__()
        self.quant = QuantStub()
        self.model = original_model
        self.dequant = DeQuantStub()
    
    def forward(self, x):
        x = self.quant(x)
        x = self.model(x)
        x = self.dequant(x)
        return x

# 准备模型
model = QuantizableModel(original_model)
model.qconfig = torch.ao.quantization.get_default_qconfig('fbgemm')

# 准备量化（插入假量化节点）
model_prepared = quant.prepare(model)

# 微调训练（关键步骤）
for epoch in range(num_epochs):
    for batch in dataloader:
        output = model_prepared(batch)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

# 转换为量化模型
model_quantized = quant.convert(model_prepared)

2.3 其他量化方法

2.3.1 动态量化（Dynamic Quantization）

权重在加载时量化，激活值在推理时动态量化。

1
2
3
4
5
6
# PyTorch 动态量化
model_quantized = torch.quantization.quantize_dynamic(
    model,
    {torch.nn.Linear},  # 只量化 Linear 层
    dtype=torch.qint8
)

2.3.2 混合精度量化（Mixed Precision Quantization）

不同层使用不同精度，敏感层用高精度，不敏感层用低精度。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# bitsandbytes 4bit 量化配置
from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",      # 4bit 量化类型
    bnb_4bit_compute_dtype=torch.float16,  # 计算精度
    bnb_4bit_use_double_quant=True,  # 双重量化
)

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=quantization_config,
    device_map="auto"
)

2.3.3 GPTQ 量化

GPTQ（Generative Pre-trained Transformer Quantization）是一种针对大语言模型的逐层量化方法，通过最小化每层的量化误差来实现高精度量化。

1
2
3
4
5
6
7
8
# 使用 auto-gptq
from auto_gptq import AutoGPTQForCausalLM

model = AutoGPTQForCausalLM.from_quantized(
    "TheBloke/Llama-2-7B-GPTQ",
    use_safetensors=True,
    device_map="auto"
)

三、量化带来的收益

3.1 模型大小

量化最直接的好处是模型体积大幅缩小：

模型 FP16 大小 INT8 大小 INT4 大小
LLaMA-7B 14 GB 7 GB 3.5 GB
LLaMA-13B 26 GB 13 GB 6.5 GB
LLaMA-70B 140 GB 70 GB 35 GB

对于消费级显卡（如 RTX 4090 24GB），INT4 量化使得运行 70B 模型成为可能。

3.2 推理速度

量化可以带来显著的推理加速：

  1. 内存带宽减少：低精度数据传输更快
  2. 计算效率提升：INT8/INT4 矩阵乘法比 FP16/FP32 更快
  3. 缓存命中率提高：更小的模型更容易放入缓存

实际测试数据（RTX 4090，LLaMA-7B）：

精度 tokens/s 相对速度
FP16 45 1.0x
INT8 65 1.44x
INT4 85 1.89x

3.3 内存占用

内存占用与模型大小成正比减少：

1
2
3
FP16:  7B × 2 bytes = 14 GB
INT8:  7B × 1 byte  = 7 GB
INT4:  7B × 0.5 bytes = 3.5 GB

这使得大模型可以在资源受限的设备上运行，如：

  • 消费级显卡
  • 边缘设备（Jetson、树莓派）
  • 移动设备（手机、平板）
  • CPU 推理

3.4 精度损失

这是量化的主要代价，但现代量化技术已经将损失控制在可接受范围内：

量化方法 精度损失（perplexity）
FP16 0% (基准)
INT8 PTQ 1-3%
INT4 PTQ 3-8%
INT4 QAT 1-2%
INT4 GPTQ 2-4%

对于大多数应用场景，INT4 量化的精度损失是可以接受的。

四、常见的量化框架和工具

4.1 bitsandbytes

特点：最流行的大模型量化库，支持 INT8、INT4 量化

1
pip install bitsandbytes
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from transformers import AutoModelForCausalLM
from transformers import BitsAndBytesConfig

# 4bit 量化配置
config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    quantization_config=config,
    device_map="auto"
)

4.2 auto-gptq

特点：专为 LLM 设计的 GPTQ 量化实现，支持多种模型架构

1
pip install auto-gptq
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig

quantize_config = BaseQuantizeConfig(
    bits=4,
    group_size=128,
    damp_percent=0.01,
    desc_act=False
)

model = AutoGPTQForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    quantize_config=quantize_config
)

# 量化
model.quantize(calibration_data)

# 保存
model.save_quantized("./quantized_model")

4.3 llama.cpp

特点：C++ 实现，支持 GGUF 格式，CPU 推理性能优秀

1
2
3
4
5
6
7
8
9
10
# 克隆项目
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make

# 转换模型为 GGUF 格式
python convert.py --outfile model.gguf path/to/model

# 量化
./quantize model.gguf model_q4.gguf q4_0

4.4 PyTorch Quantization

特点：PyTorch 官方量化支持，适合自定义模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import torch.ao.quantization as quantization

# 配置量化
model.qconfig = quantization.get_default_qconfig('fbgemm')

# 准备
model_prepared = quantization.prepare(model)

# 校准
with torch.no_grad():
    for data in calibration_data:
        model_prepared(data)

# 转换
model_quantized = quantization.convert(model_prepared)

4.5 TensorRT

特点：NVIDIA 官方推理引擎，支持 INT8 量化，性能最优

1
2
3
4
5
6
7
8
9
10
11
12
import tensorrt as trt

# 创建构建器
builder = trt.Builder(logger)
config = builder.create_builder_config()
config.set_flag(trt.BuilderFlag.INT8)

# 设置校准器
config.int8_calibrator = calibrator

# 构建引擎
engine = builder.build_engine(network, config)

4.6 工具对比

工具 支持精度 易用性 性能 适用场景
bitsandbytes INT8/INT4 ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐ 快速部署
auto-gptq INT4/INT3 ⭐⭐⭐⭐ ⭐⭐⭐⭐ LLM 量化
llama.cpp INT4/INT5/INT8 ⭐⭐⭐⭐ ⭐⭐⭐⭐⭐ CPU 推理
PyTorch INT8/FP16 ⭐⭐⭐ ⭐⭐⭐ 自定义模型
TensorRT INT8/FP16 ⭐⭐ ⭐⭐⭐⭐⭐ 生产部署

五、实战案例

5.1 案例一：使用 bitsandbytes 量化 LLaMA 模型

场景：在单张 RTX 4090（24GB）上运行 LLaMA-2-70B

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

model_name = "meta-llama/Llama-2-70b-hf"

# 配置 4bit 量化
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_llm_int8_threshold=6.0,
)

# 加载 tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 加载量化模型
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=quantization_config,
    device_map="auto",
    trust_remote_code=True
)

# 推理
prompt = "请解释一下什么是机器学习？"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=512,
        temperature=0.7,
        top_p=0.9,
        do_sample=True
    )

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

显存占用对比：

  • FP16：约 140 GB（无法运行）
  • INT4：约 38 GB（可运行，需要 offload）
  • INT4 + offload：约 22 GB（完美运行）

5.2 案例二：使用 auto-gptq 量化自定义模型

场景：量化自己的微调模型用于生产部署

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
from transformers import AutoTokenizer
import torch

# 加载模型和 tokenizer
model_name = "./my_finetuned_model"
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 配置量化参数
quantize_config = BaseQuantizeConfig(
    bits=4,              # 4bit 量化
    group_size=128,      # 分组大小
    damp_percent=0.01,   # 阻尼系数
    desc_act=False,      # 是否使用 desc_act
    sym=True,            # 对称量化
    true_sequential=True,
)

# 加载模型
model = AutoGPTQForCausalLM.from_pretrained(
    model_name,
    quantize_config=quantize_config,
    torch_dtype=torch.float16
)

# 准备校准数据
calibration_data = [
    "今天天气真好，适合出去玩。",
    "机器学习是人工智能的一个重要分支。",
    "深度学习需要大量的训练数据。",
    # ... 更多样本（建议 100-1000 条）
]

# 量化
model.quantize(
    tokenizer(calibration_data, padding=True, truncation=True, return_tensors="pt"),
    batch_size=1
)

# 保存量化模型
model.save_quantized("./quantized_model")
tokenizer.save_pretrained("./quantized_model")

print("量化完成！模型大小：", os.path.getsize("./quantized_model/model.safetensors") / 1024 / 1024, "MB")

5.3 案例三：性能对比测试

场景：对比不同量化精度的性能差异

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
import torch
import time
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

def benchmark(model, tokenizer, prompt, num_runs=10):
    """性能测试函数"""
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    
    # 预热
    with torch.no_grad():
        model.generate(**inputs, max_new_tokens=50)
    
    # 正式测试
    torch.cuda.synchronize()
    start = time.time()
    
    for _ in range(num_runs):
        with torch.no_grad():
            model.generate(**inputs, max_new_tokens=50)
    
    torch.cuda.synchronize()
    end = time.time()
    
    avg_time = (end - start) / num_runs
    tokens_per_sec = 50 / avg_time
    
    return avg_time, tokens_per_sec

model_name = "meta-llama/Llama-2-7b-hf"
prompt = "人工智能的未来发展趋势是"

# FP16 基准
print("=" * 50)
print("FP16 基准测试")
print("=" * 50)
model_fp16 = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)
avg_time, tps = benchmark(model_fp16, tokenizer, prompt)
print(f"平均推理时间：{avg_time:.2f}s")
print(f"生成速度：{tps:.2f} tokens/s")
print(f"显存占用：{torch.cuda.memory_allocated() / 1024**3:.2f} GB")

# INT8 量化
print("\n" + "=" * 50)
print("INT8 量化测试")
print("=" * 50)
config_int8 = BitsAndBytesConfig(load_in_8bit=True)
model_int8 = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=config_int8,
    device_map="auto"
)
avg_time, tps = benchmark(model_int8, tokenizer, prompt)
print(f"平均推理时间：{avg_time:.2f}s")
print(f"生成速度：{tps:.2f} tokens/s")
print(f"显存占用：{torch.cuda.memory_allocated() / 1024**3:.2f} GB")

# INT4 量化
print("\n" + "=" * 50)
print("INT4 量化测试")
print("=" * 50)
config_int4 = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16
)
model_int4 = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=config_int4,
    device_map="auto"
)
avg_time, tps = benchmark(model_int4, tokenizer, prompt)
print(f"平均推理时间：{avg_time:.2f}s")
print(f"生成速度：{tps:.2f} tokens/s")
print(f"显存占用：{torch.cuda.memory_allocated() / 1024**3:.2f} GB")

典型测试结果（RTX 4090，LLaMA-2-7B）：

精度 显存占用 生成速度 加速比
FP16 14.2 GB 45 t/s 1.0x
INT8 7.8 GB 62 t/s 1.38x
INT4 4.5 GB 82 t/s 1.82x

5.4 案例四：量化精度评估

场景：评估量化对模型质量的影响

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset
import torch
import numpy as np

def calculate_perplexity(model, tokenizer, dataset, max_samples=100):
    """计算困惑度（Perplexity）"""
    model.eval()
    total_loss = 0
    total_tokens = 0
    
    for i, sample in enumerate(dataset):
        if i >= max_samples:
            break
        
        text = sample['text']
        inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
        inputs = {k: v.to(model.device) for k, v in inputs.items()}
        
        with torch.no_grad():
            outputs = model(**inputs, labels=inputs["input_ids"])
            loss = outputs.loss
        
        total_loss += loss.item() * inputs["input_ids"].numel()
        total_tokens += inputs["input_ids"].numel()
    
    avg_loss = total_loss / total_tokens
    perplexity = np.exp(avg_loss)
    
    return perplexity

# 加载测试数据集
dataset = load_dataset("wikitext", "wikitext-2-raw-v1", split="test")

# 加载不同精度的模型
models = {
    "FP16": AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", 
                                                   torch_dtype=torch.float16, 
                                                   device_map="auto"),
    "INT8": AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", 
                                                   load_in_8bit=True, 
                                                   device_map="auto"),
    "INT4": AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", 
                                                   load_in_4bit=True, 
                                                   bnb_4bit_quant_type="nf4",
                                                   device_map="auto"),
}

tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")

# 评估
print("精度评估结果：")
print("-" * 40)
for name, model in models.items():
    ppl = calculate_perplexity(model, tokenizer, dataset, max_samples=50)
    print(f"{name}: Perplexity = {ppl:.2f}")

六、最佳实践与建议

6.1 如何选择量化方法？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
                    ┌─────────────────┐
                    │   需要量化吗？   │
                    └────────┬────────┘
                             │
              ┌──────────────┴──────────────┐
              │                            │
             是                           否
              │                            │
    ┌─────────┴─────────┐                  │
    │                   │                  │
  有训练资源          无训练资源            使用 FP16
    │                   │
    ▼                   ▼
   QAT                 PTQ
    │                   │
    │         ┌─────────┴─────────┐
    │         │                   │
    │       要求高精度          追求极致压缩
    │         │                   │
    │         ▼                   ▼
    │       INT8 PTQ            INT4 GPTQ
    │                           │
    │                           ▼
    │                      INT4 + 双重量化
    │
    ▼
INT4 QAT（最佳精度）

6.2 量化调试技巧

  1. 检查量化参数：
1
2
3
4
for name, module in model.named_modules():
    if hasattr(module, 'weight_quantizer'):
        print(f"{name}: scale={module.weight_quantizer.scale}, "
              f"zero_point={module.weight_quantizer.zero_point}")
  1. 监控精度损失：
1
2
3
4
5
6
7
# 比较量化前后的输出差异
with torch.no_grad():
    output_fp16 = model_fp16(input_ids)
    output_int4 = model_int4(input_ids)
    
    diff = torch.abs(output_fp16.logits - output_int4.logits).mean()
    print(f"平均输出差异：{diff.item():.6f}")
  1. 处理量化失败：
1
2
3
4
5
6
7
8
9
# 如果某些层量化后效果差，可以排除这些层
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    llm_int8_has_fp16_weight=False,
    llm_int8_threshold=6.0,
)

# 或者使用混合精度
model.model.layers[-1:] = model.model.layers[-1:].to(torch.float16)

6.3 生产部署建议

  1. 选择合适的量化格式：

    • 云端 GPU 部署：INT8/INT4 + bitsandbytes
    • 边缘设备：INT4 + llama.cpp (GGUF)
    • 移动设备：INT4 + CoreML/TFLite

  2. 性能优化：

1
2
3
# 使用 vLLM 加速推理
pip install vllm
python -m vllm.entrypoints.api_server --model ./quantized_model --quantization awq
  1. 监控与回滚：
    • 部署后持续监控模型输出质量
    • 保留 FP16 版本作为回滚选项
    • 设置自动告警机制

七、总结与展望

核心要点回顾

  1. 量化原理：通过降低数值精度来压缩模型，核心是 scale 和 zero_point 的映射
  2. 主要方法：PTQ（快速、简单）vs QAT（精确、复杂）
  3. 实际收益：模型大小减少 4-8 倍，推理速度提升 1.5-2 倍，显存占用大幅降低
  4. 工具选择：bitsandbytes（易用）、auto-gptq（LLM 专用）、llama.cpp（CPU 推理）
  5. 精度权衡：INT8 损失 1-3%，INT4 损失 3-8%，QAT 可以显著降低损失

未来趋势

  1. 更低比特量化：INT2、INT1 甚至二值化网络
  2. 混合精度自动化：自动搜索最优混合精度配置
  3. 硬件原生支持：新一代 GPU/TPU 对低精度计算的原生优化
  4. 量化 - 剪枝联合优化：量化与剪枝、蒸馏等技术结合

最后的建议

量化不是银弹，但是大模型部署的必备技能。建议：

  • 从 INT8 PTQ 开始，快速验证可行性
  • 对于生产环境，考虑 INT4 GPTQ 或 QAT
  • 始终保留 FP16 版本用于对比和回滚
  • 关注量化对特定任务的影响，必要时微调

参考资源

作者：Noah Sun
日期：2026 年 3 月 29 日
标签：#大模型 #量化 #深度学习 #模型压缩 #AI 工程化

感谢你的阅读，如果文章对你有帮助，可以请作者喝杯茶!