
下载软件：

https://www.latex-project.org/get/#tex-distributions

https://miktex.org/download


![](https://www.dong-blog.fun/static/img/ffcf7265a7dcb4966a368e5543390c66.image.webp)

MiKTeX 本身并不提供图形界面编辑器，但你可以选择与 MiKTeX 配合的文本编辑器。常用的 LaTeX 编辑器包括：

- TeXworks：是 MiKTeX 安装时自带的编辑器，界面简洁，适合初学者。
- TeXstudio：功能更全，适合有一定经验的用户。下载： https://www.texstudio.org/ 
- Visual Studio Code：通过安装 LaTeX 插件，也可以进行 LaTeX 编辑。


在TeXstudio里按F7就可以编译：

```

\documentclass[a4paper,12pt]{article}

% 导入必要的宏包
\usepackage{fontspec}      % 字体设置
\usepackage{xeCJK}         % 支持中文
\usepackage{amsmath}       % 数学公式
\usepackage{graphicx}      % 插入图片
\usepackage{cite}          % 引用管理

% 设置中文字体
\setCJKmainfont{SimSun}    % 设置中文主字体为宋体

% 设置英文字体
\setmainfont{Times New Roman}

% 设置页面边距
\usepackage[margin=1in]{geometry}

\title{XeLaTeX 示例文章}
\author{作者名}
\date{\today}

\begin{document}
	
	\maketitle
	
	\begin{abstract}
		本文介绍了如何使用XeLaTeX编写支持中文和英文混排的文档。文中展示了基本的排版功能，包括数学公式、图片插入和文献引用等。
	\end{abstract}
	
	\section{引言}
	XeLaTeX是一种基于LaTeX的排版系统，最大的特点是可以使用系统中的字体，尤其是支持Unicode字符，能够方便地处理中文。相比传统的LaTeX，XeLaTeX提供了更好的字体支持和更加灵活的排版功能。
	
	在本文中，我们将介绍如何在XeLaTeX中混排中文和英文，以及如何处理常见的数学公式和文献引用。
	
	\section{数学公式}
	XeLaTeX支持常见的数学公式排版，以下是几个例子：
	
	\subsection{简单的公式}
	\begin{equation}
		E = mc^2
	\end{equation}
	这是著名的质能方程，表示质量和能量之间的关系。
	
	\subsection{矩阵公式}
	\[
	A = \begin{pmatrix}
		1 & 2 & 3 \\
		4 & 5 & 6 \\
		7 & 8 & 9
	\end{pmatrix}
	\]
	这是一个$3 \times 3$的矩阵。
	
	\subsection{分段函数}
	\[
	f(x) =
	\begin{cases}
		x^2, & \text{if } x \geq 0 \\
		-x, & \text{if } x < 0
	\end{cases}
	\]
	这是一个分段函数的示例。
	
	\section{插入图片}
	你可以使用`graphicx`宏包插入图片。以下是一个例子：
	
	\begin{figure}[h]
		\centering
		\includegraphics[width=0.5\textwidth]{example.jpg}
		\caption{示例图片}
	\end{figure}
	
	\section{文献引用}
	在文中引用文献很简单，可以使用`\cite`命令。例如：
	
	在\cite{latexCompanion}中，作者介绍了LaTeX的各种技巧和最佳实践。
	
	\bibliographystyle{plain}  % 文献引用样式
	\bibliography{references}  % 文献数据库文件
	
\end{document}

```


![](https://www.dong-blog.fun/static/img/3b89d976a75f8b2055188a301a9ed314.image.webp)

LaTeX 文档写作

## 官网文档：

https://nvidia.github.io/TensorRT-LLM/quick-start-guide.html#launch-the-docker


https://github.com/triton-inference-server/tensorrtllm_backend






## tensorrtllm_backend

```bash
git clone https://github.com/triton-inference-server/tensorrtllm_backend.git
cd tensorrtllm_backend
git submodule update --init --recursive
git lfs install
git lfs pull
```

挺大：2.5G    tensorrtllm_backend/


## 启动容器

启动容器

```bash
docker run --rm -it --net host --shm-size=4g \
    --ulimit memlock=-1 --ulimit stack=67108864 --gpus device=1 \
    -v /data/xiedong/tensorrtllm_backend:/tensorrtllm_backend \
    -v /data/xiedong/engines:/engines \
    -v /data/xiedong/Qwen2.5-14B-Instruct/:/Qwen2.5-14B-Instruct/ \
    nvcr.io/nvidia/tritonserver:24.11-trtllm-python-py3
```


这里选镜像：

https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver/tags

## 准备 TensorRT-LLM 引擎文件

### 普通模型

```bash
cd /tensorrtllm_backend/tensorrt_llm/examples/qwen

# Convert weights from HF Tranformers to TensorRT-LLM checkpoint
python3 convert_checkpoint.py --model_dir /Qwen2.5-14B-Instruct \
        --dtype float16 \
        --tp_size 1 \
        --output_dir ./tllm_checkpoint_1gpu_bf16

# Build TensorRT engines
trtllm-build --checkpoint_dir ./tllm_checkpoint_1gpu_bf16 \
        --gemm_plugin float16 \
        --output_dir /engines/gpt/fp16/1-gpu
```

### 想做量化

如果想要量化怎么搞？首先要看看TensorRT-LLM 支持的量化精度，每个模型被支持的量化精度不尽相同：

https://nvidia.github.io/TensorRT-LLM/reference/precision.html

https://github.com/NVIDIA/TensorRT-LLM/tree/rel/examples/gpt


convert_checkpoint.py 本身提供了一些量化方式，基本是够用了。详细可看本身的--help。这个行为还自己下载量化矫正数据集去量化模型。下载的是这个数据集： https://huggingface.co/datasets/ccdv/cnn_dailymail 。


准备 TensorRT-LLM 引擎文件，并且是量化过的：


```bash
cd /tensorrtllm_backend/tensorrt_llm/examples/qwen

# Convert weights from HF Tranformers to TensorRT-LLM checkpoint 会自己下载量化校正数据集
python3 convert_checkpoint.py --model_dir /Qwen2.5-14B-Instruct \
        --dtype float16 --smoothquant 0.5 \
        --tp_size 1 --pp_size 1 \
        --output_dir ./tllm_checkpoint_1gpu_int8-sq

# Build TensorRT engines
trtllm-build --checkpoint_dir ./tllm_checkpoint_1gpu_int8-sq \
        --output_dir /engines/gpt/int8-sq/1-gpu
```

![](https://www.dong-blog.fun/static/img/4fecb74dcd8521b276db3846d053422f.image.webp)


### engines的不一样之处

https://github.com/triton-inference-server/tensorrtllm_backend/blob/main/docs/model_config.md



- max_batch_size 定义引擎可以处理的最大请求数。
- max_seq_len 定义单次请求的最大序列长度。
- max_num_tokens 定义每批删除填充后批量输入标记的最大数量。

 --max_num_tokens MAX_NUM_TOKENS
                        is removed in each batch It equals to ``max_batch_size
                        * max_beam_width`` by default, set this value as close


```bash
cd /tensorrtllm_backend/tensorrt_llm/examples/qwen

# 上一小节的量化
python3 convert_checkpoint.py --model_dir /Qwen2.5-14B-Instruct \
        --dtype float16 --smoothquant 0.5 \
        --tp_size 1 --pp_size 1 \
        --output_dir ./tllm_checkpoint_1gpu_int8-sq


# Build TensorRT engines
trtllm-build --checkpoint_dir ./tllm_checkpoint_1gpu_int8-sq \
        --output_dir /engines/gpt/int8-sq-haha/1-gpu --max_batch_size 1 --max_seq_len 512 
```



### 其他量化脚本-不推荐

也可以用另外一个脚本去量化：


```bash
cd /tensorrtllm_backend/tensorrt_llm

python3 examples/quantization/quantize.py --model_dir /Qwen2.5-14B-Instruct \
        --dtype float16 \
        --qformat int8_sq \
        --output_dir /tensorrtllm_backend/tensorrt_llm/examples/qwen/tllm_checkpoint_1gpu_int8-sq-quantize


cd /tensorrtllm_backend/tensorrt_llm/examples/qwen

# Build TensorRT engines
trtllm-build --checkpoint_dir ./tllm_checkpoint_1gpu_int8-sq \
        --output_dir /engines/gpt/int8-sq-quantize/1-gpu
```

quantize.py 参数之一：

* qformat：指定应用于检查点的量化算法。
  
  * fp8：权重在张量维度上量化为 FP8。激活范围在张量维度上校准。
    
  * int8_sq：权重被平滑处理并在通道维度上量化为 INT8。激活范围在张量维度上校准。
    
  * int4_awq：权重被重新缩放并按块量化为 INT4。块大小由 `awq_block_size` 指定。
    
  * w4a8_awq：权重被重新缩放并按块量化为 INT4。块大小由 `awq_block_size` 指定。激活范围在张量维度上校准。
    
  * int8_wo：实际上对权重没有进行任何操作。当 TRTLLM 构建引擎时，权重在通道维度上量化为 INT8。
    
  * int4_wo：与 int8_wo 相同，但在 INT4 中。
    
  * full_prec：不进行量化。


![](https://www.dong-blog.fun/static/img/64c58d5f9edf50daf700efe1f5fadaae.image.webp)


## 准备 Triton 模型库

Triton 推理服务器提供来自启动服务器时指定的一个或多个模型存储库的模型。在 Triton 运行时，可以按照模型管理中的说明修改所提供服务的模型。

这些存储库路径是在使用 --model-repository 选项启动 Triton 时指定的。可以多次指定 --model-repository 选项以包含来自多个存储库的模型。组成模型存储库的目录和文件必须遵循所需的布局。假设存储库路径指定如下。

https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_repository.md


![](https://www.dong-blog.fun/static/img/65e4ba633d901cfeaf1be4645247c0a3.image.webp)


```bash
mkdir /engines/triton_model_repo/
cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* /engines/triton_model_repo/
```

## 修改 Triton 模型配置



填写配置参数，执行这些指令：

```bash
ENGINE_DIR=/engines/gpt/int8-sq-haha/1-gpu
TOKENIZER_DIR=/Qwen2.5-14B-Instruct # HF模型所在
MODEL_FOLDER=/engines/triton_model_repo
TRITON_MAX_BATCH_SIZE=1 # 可以多给点，我这里为了测试下显存，给1
INSTANCE_COUNT=1
MAX_QUEUE_DELAY_MS=0
MAX_QUEUE_SIZE=1
FILL_TEMPLATE_SCRIPT=/tensorrtllm_backend/tools/fill_template.py
DECOUPLED_MODE=false
python3 ${FILL_TEMPLATE_SCRIPT} -i ${MODEL_FOLDER}/ensemble/config.pbtxt triton_max_batch_size:${TRITON_MAX_BATCH_SIZE}
python3 ${FILL_TEMPLATE_SCRIPT} -i ${MODEL_FOLDER}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},triton_max_batch_size:${TRITON_MAX_BATCH_SIZE},preprocessing_instance_count:${INSTANCE_COUNT}
python3 ${FILL_TEMPLATE_SCRIPT} -i ${MODEL_FOLDER}/tensorrt_llm/config.pbtxt triton_backend:tensorrtllm,triton_max_batch_size:${TRITON_MAX_BATCH_SIZE},decoupled_mode:${DECOUPLED_MODE},engine_dir:${ENGINE_DIR},max_queue_delay_microseconds:${MAX_QUEUE_DELAY_MS},batching_strategy:inflight_fused_batching,max_queue_size:${MAX_QUEUE_SIZE}
python3 ${FILL_TEMPLATE_SCRIPT} -i ${MODEL_FOLDER}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},triton_max_batch_size:${TRITON_MAX_BATCH_SIZE},postprocessing_instance_count:${INSTANCE_COUNT},max_queue_size:${MAX_QUEUE_SIZE}
python3 ${FILL_TEMPLATE_SCRIPT} -i ${MODEL_FOLDER}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:${TRITON_MAX_BATCH_SIZE},decoupled_mode:${DECOUPLED_MODE},bls_instance_count:${INSTANCE_COUNT}
```

填充完之后，各个文件夹下面是有一些配置文件的：


```bash
root@GZ-LG401-G1-DOCKER-node-gpu-8:triton_model_repo# tree -L 2
.
|-- ensemble
|   |-- 1
|   `-- config.pbtxt
|-- postprocessing
|   |-- 1
|   `-- config.pbtxt
|-- preprocessing
|   |-- 1
|   `-- config.pbtxt
|-- tensorrt_llm
|   |-- 1
|   `-- config.pbtxt
`-- tensorrt_llm_bls
    |-- 1
    `-- config.pbtxt

10 directories, 5 files
```


## 使用 TensorRT-LLM 模型启动 Triton 服务器


```bash
# 'world_size' is the number of GPUs you want to use for serving. This should
# be aligned with the number of GPUs used to build the TensorRT-LLM engine.

python3 /tensorrtllm_backend/scripts/launch_triton_server.py --world_size=1 --model_repo=${MODEL_FOLDER}
```

这个日志表示启动成功：

```bash
I1122 06:29:55.578920 145 grpc_server.cc:2558] "Started GRPCInferenceService at 0.0.0.0:8001"
I1122 06:29:55.579121 145 http_server.cc:4713] "Started HTTPService at 0.0.0.0:8000"
I1122 06:29:55.620023 145 http_server.cc:362] "Started Metrics Service at 0.0.0.0:8002"
```


要停止容器内的 Triton 服务器，请运行：


```bash
pkill tritonserver
```

- text_input：输入文本以生成响应
- max_tokens：请求的输出 token 数量
- bad_words：脏话列表（可以为空）
- stop_words：停用词列表（可以为空）



```bash
curl -X POST http://101.136.8.66:8000/v2/models/ensemble/generate -d '{"text_input": "<|im_start|>system<|im_end|>\n<|im_start|>user\n你是什么模型?\n<|im_end|>\n<|im_start|>assistant", "max_tokens": 200, "bad_words": "", "stop_words": ""}'
```

返回：

```bash
# curl -X POST http://101.136.8.66:8000/v2/models/ensemble/generate -d '{"text_input": "<|im_start|>system<|im_end|>\n<|im_start|>user\n你是什么模型?\n<|im_end|>\n<|im_start|>assistant", "max_tokens": 200, "bad_words": "", "stop_words": ""}'
{"model_name":"ensemble","model_version":"1","sequence_end":false,"sequence_id":0,"sequence_index":0,"sequence_start":false,"text_output":"system\nuser\n你是什么模型?\n\nassistant 我是一个语言模型，我的功能是生成文本，与用户进行自然语言交流。请问有什么可以帮您的？"}
```

## 客户端访问

https://github.com/triton-inference-server/tensorrtllm_backend/tree/main/inflight_batcher_llm/client



安装环境


```bash
pip3 install tritonclient[all]
pip install transformers

```

访问例子：
```bash
python3  /data/xiedong/tensorrtllm_backend/inflight_batcher_llm/client/inflight_batcher_llm_client.py --request-output-len 200 --tokenizer-dir  "/data/xiedong/Qwen2.5-14B-Instruct"
```


```bash
python3 /data/xiedong/tensorrtllm_backend/inflight_batcher_llm/client/end_to_end_grpc_client.py \
        --url "localhost:8001" --streaming --output-len 100 \
        --prompt "你是谁？"
```

TensorRT-LLM，Qwen2.5 加速量化部署

## Transformer模型中的位置编码

Transformer模型中的位置编码（Positional Encoding）用于为模型提供序列中单词的位置信息，因为Transformer本身是一个无序列的模型，它并不像RNN那样具有顺序处理的能力。

位置编码的公式通常分为两种形式：正弦和余弦函数，具体形式如下：



给定位置 $pos$ 和维度 $i$，位置编码的计算公式为：

$$
PE(pos, 2i) = \sin\left(\frac{pos}{10000^{2i/d}}\right)
$$

$$
PE(pos, 2i+1) = \cos\left(\frac{pos}{10000^{2i/d}}\right)
$$

其中：

- $pos$ 是词在序列中的位置（从0开始）。
- $i$ 是位置编码的维度索引（从0到 $d-1$，其中 $d$ 是位置编码的总维度）。
- $10000$ 是一个常数，用于控制位置编码的尺度。
- $d$ 是位置编码的维度。

解释：

- **正弦和余弦函数**：通过对不同频率的正弦和余弦函数进行编码，不同维度的编码能够在不同的尺度上表示位置差异。这有助于模型捕捉到位置间的相对关系。
- **频率**：随着维度的增加，频率逐渐增大，这意味着低维度的编码表示较大范围的位置信息，而高维度的编码则表示较小范围的位置信息。

这种设计使得位置编码可以为每个词提供一个唯一的、非线性变化的表示，从而帮助Transformer模型理解输入序列的顺序信息。

使用位置编码：

位置编码通常与输入的词向量相加，生成最终的输入表示：

$$
\text{Input}_{\text{final}} = \text{Input}_{\text{embedding}} + \text{Positional Encoding}
$$

这种加和方式使得模型可以同时利用词语的语义信息和其在序列中的位置。

## 向量的旋转

向量旋转的数学公式基于二维平面中的**旋转矩阵**，其表达式如下：

假设一个二维向量 $\mathbf{v} = \begin{bmatrix} x \\ y \end{bmatrix}$，我们希望将它绕原点逆时针旋转一个角度 $\theta$。旋转后的向量 $\mathbf{v'}$ 可通过以下公式计算：

$$
\mathbf{v'} = R(\theta) \cdot \mathbf{v}
$$

其中旋转矩阵 $R(\theta)$ 的定义是：

$$
R(\theta) = \begin{bmatrix} 
\cos\theta & -\sin\theta \\ 
\sin\theta & \cos\theta 
\end{bmatrix}
$$

将公式展开，结果为：
$$
\mathbf{v'} = \begin{bmatrix} 
\cos\theta & -\sin\theta \\ 
\sin\theta & \cos\theta 
\end{bmatrix} 
\cdot 
\begin{bmatrix} 
x \\ 
y 
\end{bmatrix} 
= \begin{bmatrix} 
x\cos\theta - y\sin\theta \\ 
x\sin\theta + y\cos\theta 
\end{bmatrix}
$$

## RoPE 旋转位置编码

在 **RoPE（Rotary Position Embedding）** 中，位置编码的核心思想是通过旋转变换将位置信息融入到输入向量中，而不是直接通过加法的方式。

RoPE 的公式如下：

给定位置 $p$ 和维度索引 $i$，我们通过旋转变换操作将输入的特征向量进行编码。具体公式如下：

### 输入向量表示
假设输入向量为 $x = [x_1, x_2, \ldots, x_d]$，其中 $d$ 是特征向量的维度。RoPE 将 $x$ 中每两个相邻维度视为一对，并施加旋转操作。

### RoPE 的旋转公式
对于每个位置 $p$，输入向量 $x$ 中的每对维度 $(x_{2i}, x_{2i+1})$ 进行如下旋转操作：

$$
\text{RoPE}(x, p) =
\begin{bmatrix}
x_{2i} \cos(\theta_p) - x_{2i+1} \sin(\theta_p) \\
x_{2i} \sin(\theta_p) + x_{2i+1} \cos(\theta_p)
\end{bmatrix}
$$

其中：

$$
\theta_p = \frac{p}{10000^{2i/d}}
$$

### 解释
1. **旋转角度** $\theta_p$：与 Transformer 中的位置编码类似，频率 $\frac{1}{10000^{2i/d}}$ 控制了旋转的幅度，位置 $p$ 影响了旋转角度。
2. **偶数维度** $x_{2i}$：施加 $\cos$ 和 $\sin$ 的旋转变换。
3. **奇数维度** $x_{2i+1}$：配合偶数维度的旋转变换，形成二维平面上的旋转效果。


## RoPE 整体公式

$$
\mathbf{R}_{\Theta, m}^d \mathbf{x} =
\begin{bmatrix}
x_0 \\
x_1 \\
x_2 \\
x_3 \\
\vdots \\
x_{d-2} \\
x_{d-1}
\end{bmatrix}
\otimes
\begin{bmatrix}
\cos(m\theta_0) \\
\cos(m\theta_0) \\
\cos(m\theta_1) \\
\cos(m\theta_1) \\
\vdots \\
\cos(m\theta_{d/2-1}) \\
\cos(m\theta_{d/2-1})
\end{bmatrix}
+
\begin{bmatrix}
-x_1 \\
x_0 \\
-x_3 \\
x_2 \\
\vdots \\
-x_{d-1} \\
x_{d-2}
\end{bmatrix}
\otimes
\begin{bmatrix}
\sin(m\theta_0) \\
\sin(m\theta_0) \\
\sin(m\theta_1) \\
\sin(m\theta_1) \\
\vdots \\
\sin(m\theta_{d/2-1}) \\
\sin(m\theta_{d/2-1})
\end{bmatrix}
$$


1. $ \mathbf{R}_{\Theta, m}^d \mathbf{x} $：旋转位置编码后的向量。
2. $ \mathbf{x} $：输入向量 $ \mathbf{x} = [x_0, x_1, \ldots, x_{d-1}] $。
3. $ \otimes $：逐元素乘法操作。
4. $ \cos(m\theta_i) $ 和 $ \sin(m\theta_i) $：分别为旋转角的正余弦分量，定义为：
   $$
   \theta_i = \frac{p}{10000^{2i/d}}
   $$

## RoPE 理解

### 1. **频率越低，对相对位置越不敏感**
在 RoPE 中，低频成分对应的是公式中 $ i $ 较小（即较低的维度），此时：

$$
\frac{1}{10000^{2i/d}}
$$

的值较大，导致 $ \theta_p $ 的变化很慢（角度变化较小）。这种慢速变化对应于较长周期的正弦和余弦波，位置编码的相邻值之间差异不大。

- **直观理解**：低频成分对序列中长距离位置之间的变化较为稳定，能够更好地捕获远距离依赖关系。例如：句首单词如何影响句尾单词的关系。

---

### 2. **高频：短距离依赖**
在 RoPE 中，高频成分对应的是公式中 $ i $ 较大（即较高的维度），此时：

$$
\frac{1}{10000^{2i/d}}
$$

的值较小，导致 $ \theta_p $ 的变化很快（角度变化较大）。这种快速变化对应于较短周期的正弦和余弦波，位置编码的相邻值之间差异显著。

- **直观理解**：高频成分对序列中短距离的位置变化更敏感，能够精确捕捉局部上下文之间的依赖关系。例如：单词与其前后邻近单词的关系。

---

### 3. **旋转操作的作用**
RoPE 的旋转操作将输入特征向量的各个维度进行正弦和余弦的加权处理，让模型能够利用高频和低频成分来捕获不同尺度的位置信息：

- **高频部分的旋转（维度较高）**：赋予模型捕捉局部依赖的能力。
- **低频部分的旋转（维度较低）**：赋予模型捕捉远距离依赖的能力。

通过将这些高频和低频成分在旋转后的结果中叠加起来，RoPE 能够让 Transformer 既关注短距离模式（局部结构），也能理解长距离关系（全局依赖）。

RoPE 旋转位置编码 解析

# WO、AWQ、GPTQ 与 SQ 的对比

随着深度学习模型规模的不断扩大，模型的部署和推理变得更加昂贵。量化技术通过降低模型的计算精度（如从浮点数到整数）显著减少模型的存储需求和计算复杂度，是优化大模型的重要手段。目前有多种量化方法被提出，它们各自有针对性的特点和适用场景。本文将介绍以下四种主流量化技术及其差异：

1. **WO**：仅权重量化（Weight Only Quantization）
2. **AWQ**：激活感知权重量化（Activation-aware Weight Quantization）
3. **GPTQ**：生成预训练 Transformer 量化（Generative Pretrained Transformer Quantization）
4. **SQ**：平滑量化（Smooth Quantization）






## **对比总结**

| **特性**              | **WO**              | **AWQ**             | **GPTQ**            | **SQ**              |
|-----------------------|---------------------|---------------------|---------------------|---------------------|
| **量化范围**           | 权重                | 权重 + 激活感知      | 权重                | 权重 + 激活          |
| **低位宽支持**         | INT8 / INT4         | INT4                | INT8/INT4                | INT8               |
| **激活值处理**         | 不处理              | 激活分布优化         | 无                  | 平滑处理            |
| **误差补偿机制**       | 无                  | 无                  | 有                  | 有                  |
| **精度保持**           | 一般                | 优秀                | 优秀                | 良好                |
| **实现复杂度**         | 低                  | 高                  | 较高                | 高                  |
| **适用场景**           | 存储优化，硬件友好  | 精度敏感的低位量化   | 生成式任务的部署    | 全面量化和加速需求 |

---

## **如何选择？**
1. **资源受限、实现简单**：选择 **WO**。
2. **对精度要求高的低位宽量化（如INT4）**：选择 **AWQ**。
3. **生成式任务（如大语言模型）的优化部署**：选择 **GPTQ**。
4. **全面优化权重和激活值量化，追求计算效率**：选择 **SQ**。

不同量化方法适合的场景和目标各有侧重，开发者应根据模型的应用场景、硬件限制和性能需求选择合适的量化技术，以达到存储、计算效率和精度的最佳平衡。



量化必然带来准确率不行，详细看这个对比表体会：

![](https://www.dong-blog.fun/static/img/e8b01683606ae581d1eb4f26b875aeea.image.webp)

大模型量化方法解析：WO、AWQ、GPTQ 与 SQ 的对比

https://www.superclueai.com/

https://rank.opencompass.org.cn/home

https://github.com/jeinlee1991/chinese-llm-benchmark


https://lmarena.ai/

开源LLM大模型排行榜

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。