在大语言模型（LLM）风靡全球的今天，运行这些动辄数十亿参数的模型对硬件提出了极高的要求。如何让个人电脑甚至移动端设备顺畅运行 LLM？答案就是模型量化（Quantization）。

本文将带你从零开始，使用 PyTorch 构建一个简易的大语言模型，并亲自动手编写量化算法，将模型从 32 位浮点数（FP32）压缩至 8 位整数（INT8），实现显存减半与推理加速。

什么是大语言模型量化？

**模型量化（Model Quantization）**是指将深度学习模型中高精度的权重（通常是 32 位浮点数 FP32）映射到低精度数值（如 8 位整数 INT8、4 位整数 INT4）的过程。

为什么要进行量化？

1. 减少显存占用：一个 7B（70亿参数）的模型如果使用 FP32 存储，需要约 28GB 显存；若量化到 INT8，仅需约 7GB 显存。
2. 提升计算速度：大多数现代 CPU 和 GPU 对整数运算（Integer Arithmetic）的支持远比浮点运算高效。
3. 降低功耗：在边缘设备和移动端，整数运算的能效比高出数倍。

第一步：从零构建一个微型 Transformer 架构

在实现量化之前，我们先用 PyTorch 构建一个最基础的自注意力（Self-Attention）机制模型。以下是一个标准的 Transformer 块的核心代码实现：

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleSelfAttention(nn.Module):
    def __init__(self, embed_dim):
        super().__init__()
        self.embed_dim = embed_dim
        self.q_proj = nn.Linear(embed_dim, embed_dim)
        self.k_proj = nn.Linear(embed_dim, embed_dim)
        self.v_proj = nn.Linear(embed_dim, embed_dim)
        self.out_proj = nn.Linear(embed_dim, embed_dim)
        
    def forward(self, x):
        B, T, C = x.size()
        q = self.q_proj(x)
        k = self.k_proj(x)
        v = self.v_proj(x)
        
        # 计算注意力权重
        att = (q @ k.transpose(-2, -1)) * (1.0 / (C ** 0.5))
        att = F.softmax(att, dim=-1)
        y = att @ v
        return self.out_proj(y)

第二步：实现自定义 INT8 对称量化算法

对称量化（Symmetric Quantization）是量化技术中最经典、最直观的一种方式。它通过一个缩放因子（Scale Factor）将 FP32 的动态范围映射到 [-127, 127] 的 INT8 区间。

量化公式：

$$
Scale = \frac{127}{\max(|X|)}
$$
$$
X_{quant} = \text{clip}(\text{round}(X \times Scale), -127, 127)
$$

反量化（Dequantization）公式：

$$
X_{dequant} = \frac{X_{quant}}{Scale}
$$

以下是手写对称量化的 Python 代码实现：

import numpy as np

def quantize_tensor(tensor):
    # 寻找权重的最大绝对值
    max_val = torch.max(torch.abs(tensor))
    
    # 防止除以 0
    if max_val == 0:
        scale = 1.0
    else:
        scale = 127.0 / max_val.item()
        
    # 量化并舍入，最后限制在 INT8 范围内
    quantized = torch.clamp(torch.round(tensor * scale), -127, 127).to(torch.int8)
    return quantized, scale

def dequantize_tensor(quantized_tensor, scale):
    # 还原为浮点数形式
    return quantized_tensor.to(torch.float32) / scale

第三步：将量化应用到我们自建的模型中

通过对模型中的线性层（Linear Layers）应用上述量化方法，我们可以在推理阶段动态地对权重进行压缩：

# 实例化一个线性层
original_layer = nn.Linear(1024, 1024)

# 获取其权重并进行量化
weight_fp32 = original_layer.weight.data
weight_int8, scale = quantize_tensor(weight_fp32)

# 在推理时，我们将使用 weight_int8 进行计算，并用 scale 还原
print(f"原始权重大小: {weight_fp32.nelement() * 4} 字节")
print(f"量化后权重大小: {weight_int8.nelement() * 1} 字节")

精度与体积对比表

下面展示了同一模型在不同量化配置下的对比表现：

常见问题解答 (FAQ)

Q1: 量化会导致模型变得“愚蠢”吗？

答：会有一点点精度损失，但通常极其微弱。对于 8 位量化（INT8），在常规任务上的准确率损失一般低于 1%。但如果进一步压缩到 INT2 或 INT3，模型的语言逻辑能力会发生明显的退化。

Q2: 什么是量化感知训练 (QAT) 与后量化 (PTQ)？

• 后量化 (Post-Training Quantization, PTQ)：在模型完全训练完成后，直接对权重进行量化，无需重新训练。这是最常用、最快捷的方法。
• 量化感知训练 (Quantization-Aware Training, QAT)：在训练过程中模拟量化带来的舍入误差，让模型在训练中主动适应低精度。这种方法的精度保持最好，但需要消耗大量的计算资源进行再训练。

Q3: 我们手写的量化代码可以直接用于生产环境吗？

答：本文手写的代码旨在帮助理解底层原理。在实际生产部署中，建议使用工业级成熟框架，例如 bitsandbytes、llama.cpp（GGML/GGUF 格式）以及 vLLM。这些框架针对底层 GPU/CPU 的 SIMD 指令集进行了极致的汇编级优化。

总结

恭喜你！你已经掌握了如何从零手写一个大语言模型的核心注意力机制，并亲自实现了 INT8 对称量化算法。通过这种模型压缩技术，我们可以将庞大的 AI 模型装入日常使用的电子设备中，让生成式 AI 真正做到触手可及。

在本站快速上手 Claude / GPT / Gemini / Grok

本文涉及的能力可以直接在本站的中转 API 上调用，兼容 OpenAI / Anthropic 官方 SDK：

• 查看支持的全部模型与端点 → 模型列表
• 开通额度即可获取 API Key → 前往开通
• 持有兑换码可直接核销 → 兑换码入口

无需科学上网，国内可直连，5 分钟完成接入。